././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4743795 jedi-0.19.1/0000775000175000017500000000000000000000000012400 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/.coveragerc0000664000175000017500000000047100000000000014523 0ustar00davedave00000000000000[run] omit = jedi/_compatibility.py jedi/inference/compiled/subprocess/__main__.py jedi/__main__.py # For now this is not being used. [report] # Regexes for lines to exclude from consideration exclude_lines = # Don't complain about missing debug-only code: def __repr__ debug.warning ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/AUTHORS.txt0000664000175000017500000000471200000000000014272 0ustar00davedave00000000000000Main Authors ------------ - David Halter (@davidhalter) - Takafumi Arakaki (@tkf) Code Contributors ----------------- - Danilo Bargen (@dbrgn) - Laurens Van Houtven (@lvh) <_@lvh.cc> - Aldo Stracquadanio (@Astrac) - Jean-Louis Fuchs (@ganwell) - tek (@tek) - Yasha Borevich (@jjay) - Aaron Griffin - andviro (@andviro) - Mike Gilbert (@floppym) - Aaron Meurer (@asmeurer) - Lubos Trilety - Akinori Hattori (@hattya) - srusskih (@srusskih) - Steven Silvester (@blink1073) - Colin Duquesnoy (@ColinDuquesnoy) - Jorgen Schaefer (@jorgenschaefer) - Fredrik Bergroth (@fbergroth) - Mathias Fußenegger (@mfussenegger) - Syohei Yoshida (@syohex) - ppalucky (@ppalucky) - immerrr (@immerrr) immerrr@gmail.com - Albertas Agejevas (@alga) - Savor d'Isavano (@KenetJervet) - Phillip Berndt (@phillipberndt) - Ian Lee (@IanLee1521) - Farkhad Khatamov (@hatamov) - Kevin Kelley (@kelleyk) - Sid Shanker (@squidarth) - Reinoud Elhorst (@reinhrst) - Guido van Rossum (@gvanrossum) - Dmytro Sadovnychyi (@sadovnychyi) - Cristi Burcă (@scribu) - bstaint (@bstaint) - Mathias Rav (@Mortal) - Daniel Fiterman (@dfit99) - Simon Ruggier (@sruggier) - Élie Gouzien (@ElieGouzien) - Robin Roth (@robinro) - Malte Plath (@langsamer) - Anton Zub (@zabulazza) - Maksim Novikov (@m-novikov) - Tobias Rzepka (@TobiasRzepka) - micbou (@micbou) - Dima Gerasimov (@karlicoss) - Max Woerner Chase (@mwchase) - Johannes Maria Frank (@jmfrank63) - Shane Steinert-Threlkeld (@shanest) - Tim Gates (@timgates42) - Lior Goldberg (@goldberglior) - Ryan Clary (@mrclary) - Max Mäusezahl (@mmaeusezahl) - Vladislav Serebrennikov (@endilll) - Andrii Kolomoiets (@muffinmad) - Leo Ryu (@Leo-Ryu) - Joseph Birkner (@josephbirkner) - Márcio Mazza (@marciomazza) And a few more "anonymous" contributors. Note: (@user) means a github user name. ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/CHANGELOG.rst0000664000175000017500000002623200000000000014426 0ustar00davedave00000000000000.. :changelog: Changelog --------- Unreleased ++++++++++ 0.19.1 (2023-10-02) +++++++++++++++++++ - Python 3.12 support (Thanks Peter!) 0.19.0 (2023-07-29) +++++++++++++++++++ - Python 3.11 support - Massive improvements in performance for ``Interpreter`` (e.g. IPython) users. This especially affects ``pandas`` users with large datasets. - Add ``jedi.settings.allow_unsafe_interpreter_executions`` to make it easier for IPython users to avoid unsafe executions. 0.18.2 (2022-11-21) +++++++++++++++++++ - Added dataclass-equivalent for attrs.define - Find fixtures from Pytest entrypoints; Examples of pytest plugins installed like this are pytest-django, pytest-sugar and Faker. - Fixed Project.search, when a venv was involved, which is why for example `:Pyimport django.db` did not work in some cases in jedi-vim. - And many smaller bugfixes 0.18.1 (2021-11-17) +++++++++++++++++++ - Implict namespaces are now a separate types in ``Name().type`` - Python 3.10 support - Mostly bugfixes 0.18.0 (2020-12-25) +++++++++++++++++++ - Dropped Python 2 and Python 3.5 - Using ``pathlib.Path()`` as an output instead of ``str`` in most places: - ``Project.path`` - ``Script.path`` - ``Definition.module_path`` - ``Refactoring.get_renames`` - ``Refactoring.get_changed_files`` - Functions with ``@property`` now return ``property`` instead of ``function`` in ``Name().type`` - Started using annotations - Better support for the walrus operator - Project attributes are now read accessible - Removed all deprecations This is likely going to be the last minor release before 1.0. 0.17.2 (2020-07-17) +++++++++++++++++++ - Added an option to pass environment variables to ``Environment`` - ``Project(...).path`` exists now - Support for Python 3.9 - A few bugfixes This will be the last release that supports Python 2 and Python 3.5. ``0.18.0`` will be Python 3.6+. 0.17.1 (2020-06-20) +++++++++++++++++++ - Django ``Model`` meta class support - Django Manager support (completion on Managers/QuerySets) - Added Django Stubs to Jedi, thanks to all contributors of the `Django Stubs `_ project - Added ``SyntaxError.get_message`` - Python 3.9 support - Bugfixes (mostly towards Generics) 0.17.0 (2020-04-14) +++++++++++++++++++ - Added ``Project`` support. This allows a user to specify which folders Jedi should work with. - Added support for Refactoring. The following refactorings have been implemented: ``Script.rename``, ``Script.inline``, ``Script.extract_variable`` and ``Script.extract_function``. - Added ``Script.get_syntax_errors`` to display syntax errors in the current script. - Added code search capabilities both for individual files and projects. The new functions are ``Project.search``, ``Project.complete_search``, ``Script.search`` and ``Script.complete_search``. - Added ``Script.help`` to make it easier to display a help window to people. Now returns pydoc information as well for Python keywords/operators. This means that on the class keyword it will now return the docstring of Python's builtin function ``help('class')``. - The API documentation is now way more readable and complete. Check it out under https://jedi.readthedocs.io. A lot of it has been rewritten. - Removed Python 3.4 support - Many bugfixes This is likely going to be the last minor version that supports Python 2 and Python3.5. Bugfixes will be provided in 0.17.1+. The next minor/major version will probably be Jedi 1.0.0. 0.16.0 (2020-01-26) +++++++++++++++++++ - **Added** ``Script.get_context`` to get information where you currently are. - Completions/type inference of **Pytest fixtures**. - Tensorflow, Numpy and Pandas completions should now be about **4-10x faster** after the first time they are used. - Dict key completions are working now. e.g. ``d = {1000: 3}; d[10`` will expand to ``1000``. - Completion for "proxies" works now. These are classes that have a ``__getattr__(self, name)`` method that does a ``return getattr(x, name)``. after loading them initially. - Goto on a function/attribute in a class now goes to the definition in its super class. - Big **Script API Changes**: - The line and column parameters of ``jedi.Script`` are now deprecated - ``completions`` deprecated, use ``complete`` instead - ``goto_assignments`` deprecated, use ``goto`` instead - ``goto_definitions`` deprecated, use ``infer`` instead - ``call_signatures`` deprecated, use ``get_signatures`` instead - ``usages`` deprecated, use ``get_references`` instead - ``jedi.names`` deprecated, use ``jedi.Script(...).get_names()`` - ``BaseName.goto_assignments`` renamed to ``BaseName.goto`` - Add follow_imports to ``Name.goto``. Now its signature matches ``Script.goto``. - **Python 2 support deprecated**. For this release it is best effort. Python 2 has reached the end of its life and now it's just about a smooth transition. Bugs for Python 2 will not be fixed anymore and a third of the tests are already skipped. - Removed ``settings.no_completion_duplicates``. It wasn't tested and nobody was probably using it anyway. - Removed ``settings.use_filesystem_cache`` and ``settings.additional_dynamic_modules``, they have no usage anymore. Pretty much nobody was probably using them. 0.15.2 (2019-12-20) +++++++++++++++++++ - Signatures are now detected a lot better - Add fuzzy completions with ``Script(...).completions(fuzzy=True)`` - Files bigger than one MB (about 20kLOC) get cropped to avoid getting stuck completely. - Many small Bugfixes - A big refactoring around contexts/values 0.15.1 (2019-08-13) +++++++++++++++++++ - Small bugfix and removal of a print statement 0.15.0 (2019-08-11) +++++++++++++++++++ - Added file path completions, there's a **new** ``Completion.type`` now: ``path``. Example: ``'/ho`` -> ``'/home/`` - ``*args``/``**kwargs`` resolving. If possible Jedi replaces the parameters with the actual alternatives. - Better support for enums/dataclasses - When using Interpreter, properties are now executed, since a lot of people have complained about this. Discussion in #1299, #1347. New APIs: - ``Name.get_signatures() -> List[Signature]``. Signatures are similar to ``CallSignature``. ``Name.params`` is therefore deprecated. - ``Signature.to_string()`` to format signatures. - ``Signature.params -> List[ParamName]``, ParamName has the following additional attributes ``infer_default()``, ``infer_annotation()``, ``to_string()``, and ``kind``. - ``Name.execute() -> List[Name]``, makes it possible to infer return values of functions. 0.14.1 (2019-07-13) +++++++++++++++++++ - CallSignature.index should now be working a lot better - A couple of smaller bugfixes 0.14.0 (2019-06-20) +++++++++++++++++++ - Added ``goto_*(prefer_stubs=True)`` as well as ``goto_*(prefer_stubs=True)`` - Stubs are used now for type inference - Typeshed is used for better type inference - Reworked Name.full_name, should have more correct return values 0.13.3 (2019-02-24) +++++++++++++++++++ - Fixed an issue with embedded Python, see https://github.com/davidhalter/jedi-vim/issues/870 0.13.2 (2018-12-15) +++++++++++++++++++ - Fixed a bug that led to Jedi spawning a lot of subprocesses. 0.13.1 (2018-10-02) +++++++++++++++++++ - Bugfixes, because tensorflow completions were still slow. 0.13.0 (2018-10-02) +++++++++++++++++++ - A small release. Some bug fixes. - Remove Python 3.3 support. Python 3.3 support has been dropped by the Python foundation. - Default environments are now using the same Python version as the Python process. In 0.12.x, we used to load the latest Python version on the system. - Added ``include_builtins`` as a parameter to usages. - ``goto_assignments`` has a new ``follow_builtin_imports`` parameter that changes the previous behavior slightly. 0.12.1 (2018-06-30) +++++++++++++++++++ - This release forces you to upgrade parso. If you don't, nothing will work anymore. Otherwise changes should be limited to bug fixes. Unfortunately Jedi still uses a few internals of parso that make it hard to keep compatibility over multiple releases. Parso >=0.3.0 is going to be needed. 0.12.0 (2018-04-15) +++++++++++++++++++ - Virtualenv/Environment support - F-String Completion/Goto Support - Cannot crash with segfaults anymore - Cleaned up import logic - Understand async/await and autocomplete it (including async generators) - Better namespace completions - Passing tests for Windows (including CI for Windows) - Remove Python 2.6 support 0.11.1 (2017-12-14) +++++++++++++++++++ - Parso update - the caching layer was broken - Better usages - a lot of internal code was ripped out and improved. 0.11.0 (2017-09-20) +++++++++++++++++++ - Split Jedi's parser into a separate project called ``parso``. - Avoiding side effects in REPL completion. - Numpy docstring support should be much better. - Moved the `settings.*recursion*` away, they are no longer usable. 0.10.2 (2017-04-05) +++++++++++++++++++ - Python Packaging sucks. Some files were not included in 0.10.1. 0.10.1 (2017-04-05) +++++++++++++++++++ - Fixed a few very annoying bugs. - Prepared the parser to be factored out of Jedi. 0.10.0 (2017-02-03) +++++++++++++++++++ - Actual semantic completions for the complete Python syntax. - Basic type inference for ``yield from`` PEP 380. - PEP 484 support (most of the important features of it). Thanks Claude! (@reinhrst) - Added ``get_line_code`` to ``Name`` and ``Completion`` objects. - Completely rewritten the type inference engine. - A new and better parser for (fast) parsing diffs of Python code. 0.9.0 (2015-04-10) ++++++++++++++++++ - The import logic has been rewritten to look more like Python's. There is now an ``InferState.modules`` import cache, which resembles ``sys.modules``. - Integrated the parser of 2to3. This will make refactoring possible. It will also be possible to check for error messages (like compiling an AST would give) in the future. - With the new parser, the type inference also completely changed. It's now simpler and more readable. - Completely rewritten REPL completion. - Added ``jedi.names``, a command to do static analysis. Thanks to that sourcegraph guys for sponsoring this! - Alpha version of the linter. 0.8.1 (2014-07-23) +++++++++++++++++++ - Bugfix release, the last release forgot to include files that improve autocompletion for builtin libraries. Fixed. 0.8.0 (2014-05-05) +++++++++++++++++++ - Memory Consumption for compiled modules (e.g. builtins, sys) has been reduced drastically. Loading times are down as well (it takes basically as long as an import). - REPL completion is starting to become usable. - Various small API changes. Generally this release focuses on stability and refactoring of internal APIs. - Introducing operator precedence, which makes calculating correct Array indices and ``__getattr__`` strings possible. 0.7.0 (2013-08-09) ++++++++++++++++++ - Switched from LGPL to MIT license. - Added an Interpreter class to the API to make autocompletion in REPL possible. - Added autocompletion support for namespace packages. - Add sith.py, a new random testing method. 0.6.0 (2013-05-14) ++++++++++++++++++ - Much faster parser with builtin part caching. - A test suite, thanks @tkf. 0.5 versions (2012) +++++++++++++++++++ - Initial development. ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/LICENSE.txt0000664000175000017500000000233100000000000014222 0ustar00davedave00000000000000All contributions towards Jedi are MIT licensed. ------------------------------------------------------------------------------- The MIT License (MIT) Copyright (c) <2013> Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/MANIFEST.in0000664000175000017500000000062600000000000014142 0ustar00davedave00000000000000include README.rst include CHANGELOG.rst include LICENSE.txt include AUTHORS.txt include .coveragerc include sith.py include conftest.py include pytest.ini recursive-include jedi/third_party *.pyi include jedi/third_party/typeshed/LICENSE include jedi/third_party/django-stubs/LICENSE.txt include jedi/third_party/typeshed/README recursive-include test * recursive-include docs * recursive-exclude * *.pyc ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4743795 jedi-0.19.1/PKG-INFO0000664000175000017500000006153300000000000013505 0ustar00davedave00000000000000Metadata-Version: 2.1 Name: jedi Version: 0.19.1 Summary: An autocompletion tool for Python that can be used for text editors. Home-page: https://github.com/davidhalter/jedi Author: David Halter Author-email: davidhalter88@gmail.com Maintainer: David Halter Maintainer-email: davidhalter88@gmail.com License: MIT Project-URL: Documentation, https://jedi.readthedocs.io/en/latest/ Description: #################################################################################### Jedi - an awesome autocompletion, static analysis and refactoring library for Python #################################################################################### .. image:: http://isitmaintained.com/badge/open/davidhalter/jedi.svg :target: https://github.com/davidhalter/jedi/issues :alt: The percentage of open issues and pull requests .. image:: http://isitmaintained.com/badge/resolution/davidhalter/jedi.svg :target: https://github.com/davidhalter/jedi/issues :alt: The resolution time is the median time an issue or pull request stays open. .. image:: https://github.com/davidhalter/jedi/workflows/ci/badge.svg?branch=master :target: https://github.com/davidhalter/jedi/actions :alt: Tests .. image:: https://pepy.tech/badge/jedi :target: https://pepy.tech/project/jedi :alt: PyPI Downloads Jedi is a static analysis tool for Python that is typically used in IDEs/editors plugins. Jedi has a focus on autocompletion and goto functionality. Other features include refactoring, code search and finding references. Jedi has a simple API to work with. There is a reference implementation as a `VIM-Plugin `_. Autocompletion in your REPL is also possible, IPython uses it natively and for the CPython REPL you can install it. Jedi is well tested and bugs should be rare. Jedi can currently be used with the following editors/projects: - Vim (jedi-vim_, YouCompleteMe_, deoplete-jedi_, completor.vim_) - `Visual Studio Code`_ (via `Python Extension `_) - Emacs (Jedi.el_, company-mode_, elpy_, anaconda-mode_, ycmd_) - Sublime Text (SublimeJEDI_ [ST2 + ST3], anaconda_ [only ST3]) - TextMate_ (Not sure if it's actually working) - Kate_ version 4.13+ supports it natively, you have to enable it, though. [`see `_] - Atom_ (autocomplete-python-jedi_) - `GNOME Builder`_ (with support for GObject Introspection) - Gedit (gedi_) - wdb_ - Web Debugger - `Eric IDE`_ - `IPython 6.0.0+ `_ - `xonsh shell `_ has `jedi extension `_ and many more! There are a few language servers that use Jedi: - `jedi-language-server `_ - `python-language-server `_ (currently unmaintained) - `python-lsp-server `_ (fork from python-language-server) - `anakin-language-server `_ Here are some pictures taken from jedi-vim_: .. image:: https://github.com/davidhalter/jedi/raw/master/docs/_screenshots/screenshot_complete.png Completion for almost anything: .. image:: https://github.com/davidhalter/jedi/raw/master/docs/_screenshots/screenshot_function.png Documentation: .. image:: https://github.com/davidhalter/jedi/raw/master/docs/_screenshots/screenshot_pydoc.png Get the latest version from `github `_ (master branch should always be kind of stable/working). Docs are available at `https://jedi.readthedocs.org/en/latest/ `_. Pull requests with enhancements and/or fixes are awesome and most welcome. Jedi uses `semantic versioning `_. If you want to stay **up-to-date** with releases, please **subscribe** to this mailing list: https://groups.google.com/g/jedi-announce. To subscribe you can simply send an empty email to ``jedi-announce+subscribe@googlegroups.com``. Issues & Questions ================== You can file issues and questions in the `issue tracker `. Alternatively you can also ask on `Stack Overflow `_ with the label ``python-jedi``. Installation ============ `Check out the docs `_. Features and Limitations ======================== Jedi's features are listed here: `Features `_. You can run Jedi on Python 3.6+ but it should also understand code that is older than those versions. Additionally you should be able to use `Virtualenvs `_ very well. Tips on how to use Jedi efficiently can be found `here `_. API --- You can find a comprehensive documentation for the `API here `_. Autocompletion / Goto / Documentation ------------------------------------- There are the following commands: - ``jedi.Script.goto`` - ``jedi.Script.infer`` - ``jedi.Script.help`` - ``jedi.Script.complete`` - ``jedi.Script.get_references`` - ``jedi.Script.get_signatures`` - ``jedi.Script.get_context`` The returned objects are very powerful and are really all you might need. Autocompletion in your REPL (IPython, etc.) ------------------------------------------- Jedi is a dependency of IPython. Autocompletion in IPython with Jedi is therefore possible without additional configuration. Here is an `example video `_ how REPL completion can look like. For the ``python`` shell you can enable tab completion in a `REPL `_. Static Analysis --------------- For a lot of forms of static analysis, you can try to use ``jedi.Script(...).get_names``. It will return a list of names that you can then filter and work with. There is also a way to list the syntax errors in a file: ``jedi.Script.get_syntax_errors``. Refactoring ----------- Jedi supports the following refactorings: - ``jedi.Script.inline`` - ``jedi.Script.rename`` - ``jedi.Script.extract_function`` - ``jedi.Script.extract_variable`` Code Search ----------- There is support for module search with ``jedi.Script.search``, and project search for ``jedi.Project.search``. The way to search is either by providing a name like ``foo`` or by using dotted syntax like ``foo.bar``. Additionally you can provide the API type like ``class foo.bar.Bar``. There are also the functions ``jedi.Script.complete_search`` and ``jedi.Project.complete_search``. Development =========== There's a pretty good and extensive `development documentation `_. Testing ======= The test suite uses ``pytest``:: pip install pytest If you want to test only a specific Python version (e.g. Python 3.8), it is as easy as:: python3.8 -m pytest For more detailed information visit the `testing documentation `_. Acknowledgements ================ Thanks a lot to all the `contributors `_! .. _jedi-vim: https://github.com/davidhalter/jedi-vim .. _youcompleteme: https://github.com/ycm-core/YouCompleteMe .. _deoplete-jedi: https://github.com/zchee/deoplete-jedi .. _completor.vim: https://github.com/maralla/completor.vim .. _Jedi.el: https://github.com/tkf/emacs-jedi .. _company-mode: https://github.com/syohex/emacs-company-jedi .. _elpy: https://github.com/jorgenschaefer/elpy .. _anaconda-mode: https://github.com/proofit404/anaconda-mode .. _ycmd: https://github.com/abingham/emacs-ycmd .. _sublimejedi: https://github.com/srusskih/SublimeJEDI .. _anaconda: https://github.com/DamnWidget/anaconda .. _wdb: https://github.com/Kozea/wdb .. _TextMate: https://github.com/lawrenceakka/python-jedi.tmbundle .. _Kate: https://kate-editor.org .. _Atom: https://atom.io/ .. _autocomplete-python-jedi: https://atom.io/packages/autocomplete-python-jedi .. _GNOME Builder: https://wiki.gnome.org/Apps/Builder .. _Visual Studio Code: https://code.visualstudio.com/ .. _gedi: https://github.com/isamert/gedi .. _Eric IDE: https://eric-ide.python-projects.org .. :changelog: Changelog --------- Unreleased ++++++++++ 0.19.1 (2023-10-02) +++++++++++++++++++ - Python 3.12 support (Thanks Peter!) 0.19.0 (2023-07-29) +++++++++++++++++++ - Python 3.11 support - Massive improvements in performance for ``Interpreter`` (e.g. IPython) users. This especially affects ``pandas`` users with large datasets. - Add ``jedi.settings.allow_unsafe_interpreter_executions`` to make it easier for IPython users to avoid unsafe executions. 0.18.2 (2022-11-21) +++++++++++++++++++ - Added dataclass-equivalent for attrs.define - Find fixtures from Pytest entrypoints; Examples of pytest plugins installed like this are pytest-django, pytest-sugar and Faker. - Fixed Project.search, when a venv was involved, which is why for example `:Pyimport django.db` did not work in some cases in jedi-vim. - And many smaller bugfixes 0.18.1 (2021-11-17) +++++++++++++++++++ - Implict namespaces are now a separate types in ``Name().type`` - Python 3.10 support - Mostly bugfixes 0.18.0 (2020-12-25) +++++++++++++++++++ - Dropped Python 2 and Python 3.5 - Using ``pathlib.Path()`` as an output instead of ``str`` in most places: - ``Project.path`` - ``Script.path`` - ``Definition.module_path`` - ``Refactoring.get_renames`` - ``Refactoring.get_changed_files`` - Functions with ``@property`` now return ``property`` instead of ``function`` in ``Name().type`` - Started using annotations - Better support for the walrus operator - Project attributes are now read accessible - Removed all deprecations This is likely going to be the last minor release before 1.0. 0.17.2 (2020-07-17) +++++++++++++++++++ - Added an option to pass environment variables to ``Environment`` - ``Project(...).path`` exists now - Support for Python 3.9 - A few bugfixes This will be the last release that supports Python 2 and Python 3.5. ``0.18.0`` will be Python 3.6+. 0.17.1 (2020-06-20) +++++++++++++++++++ - Django ``Model`` meta class support - Django Manager support (completion on Managers/QuerySets) - Added Django Stubs to Jedi, thanks to all contributors of the `Django Stubs `_ project - Added ``SyntaxError.get_message`` - Python 3.9 support - Bugfixes (mostly towards Generics) 0.17.0 (2020-04-14) +++++++++++++++++++ - Added ``Project`` support. This allows a user to specify which folders Jedi should work with. - Added support for Refactoring. The following refactorings have been implemented: ``Script.rename``, ``Script.inline``, ``Script.extract_variable`` and ``Script.extract_function``. - Added ``Script.get_syntax_errors`` to display syntax errors in the current script. - Added code search capabilities both for individual files and projects. The new functions are ``Project.search``, ``Project.complete_search``, ``Script.search`` and ``Script.complete_search``. - Added ``Script.help`` to make it easier to display a help window to people. Now returns pydoc information as well for Python keywords/operators. This means that on the class keyword it will now return the docstring of Python's builtin function ``help('class')``. - The API documentation is now way more readable and complete. Check it out under https://jedi.readthedocs.io. A lot of it has been rewritten. - Removed Python 3.4 support - Many bugfixes This is likely going to be the last minor version that supports Python 2 and Python3.5. Bugfixes will be provided in 0.17.1+. The next minor/major version will probably be Jedi 1.0.0. 0.16.0 (2020-01-26) +++++++++++++++++++ - **Added** ``Script.get_context`` to get information where you currently are. - Completions/type inference of **Pytest fixtures**. - Tensorflow, Numpy and Pandas completions should now be about **4-10x faster** after the first time they are used. - Dict key completions are working now. e.g. ``d = {1000: 3}; d[10`` will expand to ``1000``. - Completion for "proxies" works now. These are classes that have a ``__getattr__(self, name)`` method that does a ``return getattr(x, name)``. after loading them initially. - Goto on a function/attribute in a class now goes to the definition in its super class. - Big **Script API Changes**: - The line and column parameters of ``jedi.Script`` are now deprecated - ``completions`` deprecated, use ``complete`` instead - ``goto_assignments`` deprecated, use ``goto`` instead - ``goto_definitions`` deprecated, use ``infer`` instead - ``call_signatures`` deprecated, use ``get_signatures`` instead - ``usages`` deprecated, use ``get_references`` instead - ``jedi.names`` deprecated, use ``jedi.Script(...).get_names()`` - ``BaseName.goto_assignments`` renamed to ``BaseName.goto`` - Add follow_imports to ``Name.goto``. Now its signature matches ``Script.goto``. - **Python 2 support deprecated**. For this release it is best effort. Python 2 has reached the end of its life and now it's just about a smooth transition. Bugs for Python 2 will not be fixed anymore and a third of the tests are already skipped. - Removed ``settings.no_completion_duplicates``. It wasn't tested and nobody was probably using it anyway. - Removed ``settings.use_filesystem_cache`` and ``settings.additional_dynamic_modules``, they have no usage anymore. Pretty much nobody was probably using them. 0.15.2 (2019-12-20) +++++++++++++++++++ - Signatures are now detected a lot better - Add fuzzy completions with ``Script(...).completions(fuzzy=True)`` - Files bigger than one MB (about 20kLOC) get cropped to avoid getting stuck completely. - Many small Bugfixes - A big refactoring around contexts/values 0.15.1 (2019-08-13) +++++++++++++++++++ - Small bugfix and removal of a print statement 0.15.0 (2019-08-11) +++++++++++++++++++ - Added file path completions, there's a **new** ``Completion.type`` now: ``path``. Example: ``'/ho`` -> ``'/home/`` - ``*args``/``**kwargs`` resolving. If possible Jedi replaces the parameters with the actual alternatives. - Better support for enums/dataclasses - When using Interpreter, properties are now executed, since a lot of people have complained about this. Discussion in #1299, #1347. New APIs: - ``Name.get_signatures() -> List[Signature]``. Signatures are similar to ``CallSignature``. ``Name.params`` is therefore deprecated. - ``Signature.to_string()`` to format signatures. - ``Signature.params -> List[ParamName]``, ParamName has the following additional attributes ``infer_default()``, ``infer_annotation()``, ``to_string()``, and ``kind``. - ``Name.execute() -> List[Name]``, makes it possible to infer return values of functions. 0.14.1 (2019-07-13) +++++++++++++++++++ - CallSignature.index should now be working a lot better - A couple of smaller bugfixes 0.14.0 (2019-06-20) +++++++++++++++++++ - Added ``goto_*(prefer_stubs=True)`` as well as ``goto_*(prefer_stubs=True)`` - Stubs are used now for type inference - Typeshed is used for better type inference - Reworked Name.full_name, should have more correct return values 0.13.3 (2019-02-24) +++++++++++++++++++ - Fixed an issue with embedded Python, see https://github.com/davidhalter/jedi-vim/issues/870 0.13.2 (2018-12-15) +++++++++++++++++++ - Fixed a bug that led to Jedi spawning a lot of subprocesses. 0.13.1 (2018-10-02) +++++++++++++++++++ - Bugfixes, because tensorflow completions were still slow. 0.13.0 (2018-10-02) +++++++++++++++++++ - A small release. Some bug fixes. - Remove Python 3.3 support. Python 3.3 support has been dropped by the Python foundation. - Default environments are now using the same Python version as the Python process. In 0.12.x, we used to load the latest Python version on the system. - Added ``include_builtins`` as a parameter to usages. - ``goto_assignments`` has a new ``follow_builtin_imports`` parameter that changes the previous behavior slightly. 0.12.1 (2018-06-30) +++++++++++++++++++ - This release forces you to upgrade parso. If you don't, nothing will work anymore. Otherwise changes should be limited to bug fixes. Unfortunately Jedi still uses a few internals of parso that make it hard to keep compatibility over multiple releases. Parso >=0.3.0 is going to be needed. 0.12.0 (2018-04-15) +++++++++++++++++++ - Virtualenv/Environment support - F-String Completion/Goto Support - Cannot crash with segfaults anymore - Cleaned up import logic - Understand async/await and autocomplete it (including async generators) - Better namespace completions - Passing tests for Windows (including CI for Windows) - Remove Python 2.6 support 0.11.1 (2017-12-14) +++++++++++++++++++ - Parso update - the caching layer was broken - Better usages - a lot of internal code was ripped out and improved. 0.11.0 (2017-09-20) +++++++++++++++++++ - Split Jedi's parser into a separate project called ``parso``. - Avoiding side effects in REPL completion. - Numpy docstring support should be much better. - Moved the `settings.*recursion*` away, they are no longer usable. 0.10.2 (2017-04-05) +++++++++++++++++++ - Python Packaging sucks. Some files were not included in 0.10.1. 0.10.1 (2017-04-05) +++++++++++++++++++ - Fixed a few very annoying bugs. - Prepared the parser to be factored out of Jedi. 0.10.0 (2017-02-03) +++++++++++++++++++ - Actual semantic completions for the complete Python syntax. - Basic type inference for ``yield from`` PEP 380. - PEP 484 support (most of the important features of it). Thanks Claude! (@reinhrst) - Added ``get_line_code`` to ``Name`` and ``Completion`` objects. - Completely rewritten the type inference engine. - A new and better parser for (fast) parsing diffs of Python code. 0.9.0 (2015-04-10) ++++++++++++++++++ - The import logic has been rewritten to look more like Python's. There is now an ``InferState.modules`` import cache, which resembles ``sys.modules``. - Integrated the parser of 2to3. This will make refactoring possible. It will also be possible to check for error messages (like compiling an AST would give) in the future. - With the new parser, the type inference also completely changed. It's now simpler and more readable. - Completely rewritten REPL completion. - Added ``jedi.names``, a command to do static analysis. Thanks to that sourcegraph guys for sponsoring this! - Alpha version of the linter. 0.8.1 (2014-07-23) +++++++++++++++++++ - Bugfix release, the last release forgot to include files that improve autocompletion for builtin libraries. Fixed. 0.8.0 (2014-05-05) +++++++++++++++++++ - Memory Consumption for compiled modules (e.g. builtins, sys) has been reduced drastically. Loading times are down as well (it takes basically as long as an import). - REPL completion is starting to become usable. - Various small API changes. Generally this release focuses on stability and refactoring of internal APIs. - Introducing operator precedence, which makes calculating correct Array indices and ``__getattr__`` strings possible. 0.7.0 (2013-08-09) ++++++++++++++++++ - Switched from LGPL to MIT license. - Added an Interpreter class to the API to make autocompletion in REPL possible. - Added autocompletion support for namespace packages. - Add sith.py, a new random testing method. 0.6.0 (2013-05-14) ++++++++++++++++++ - Much faster parser with builtin part caching. - A test suite, thanks @tkf. 0.5 versions (2012) +++++++++++++++++++ - Initial development. Keywords: python completion refactoring vim Platform: any Classifier: Development Status :: 4 - Beta Classifier: Environment :: Plugins Classifier: Intended Audience :: Developers Classifier: License :: OSI Approved :: MIT License Classifier: Operating System :: OS Independent Classifier: Programming Language :: Python :: 3 Classifier: Programming Language :: Python :: 3.6 Classifier: Programming Language :: Python :: 3.7 Classifier: Programming Language :: Python :: 3.8 Classifier: Programming Language :: Python :: 3.9 Classifier: Programming Language :: Python :: 3.10 Classifier: Programming Language :: Python :: 3.11 Classifier: Programming Language :: Python :: 3.12 Classifier: Topic :: Software Development :: Libraries :: Python Modules Classifier: Topic :: Text Editors :: Integrated Development Environments (IDE) Classifier: Topic :: Utilities Requires-Python: >=3.6 Provides-Extra: docs Provides-Extra: qa Provides-Extra: testing ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/README.rst0000664000175000017500000002015000000000000014065 0ustar00davedave00000000000000#################################################################################### Jedi - an awesome autocompletion, static analysis and refactoring library for Python #################################################################################### .. image:: http://isitmaintained.com/badge/open/davidhalter/jedi.svg :target: https://github.com/davidhalter/jedi/issues :alt: The percentage of open issues and pull requests .. image:: http://isitmaintained.com/badge/resolution/davidhalter/jedi.svg :target: https://github.com/davidhalter/jedi/issues :alt: The resolution time is the median time an issue or pull request stays open. .. image:: https://github.com/davidhalter/jedi/workflows/ci/badge.svg?branch=master :target: https://github.com/davidhalter/jedi/actions :alt: Tests .. image:: https://pepy.tech/badge/jedi :target: https://pepy.tech/project/jedi :alt: PyPI Downloads Jedi is a static analysis tool for Python that is typically used in IDEs/editors plugins. Jedi has a focus on autocompletion and goto functionality. Other features include refactoring, code search and finding references. Jedi has a simple API to work with. There is a reference implementation as a `VIM-Plugin `_. Autocompletion in your REPL is also possible, IPython uses it natively and for the CPython REPL you can install it. Jedi is well tested and bugs should be rare. Jedi can currently be used with the following editors/projects: - Vim (jedi-vim_, YouCompleteMe_, deoplete-jedi_, completor.vim_) - `Visual Studio Code`_ (via `Python Extension `_) - Emacs (Jedi.el_, company-mode_, elpy_, anaconda-mode_, ycmd_) - Sublime Text (SublimeJEDI_ [ST2 + ST3], anaconda_ [only ST3]) - TextMate_ (Not sure if it's actually working) - Kate_ version 4.13+ supports it natively, you have to enable it, though. [`see `_] - Atom_ (autocomplete-python-jedi_) - `GNOME Builder`_ (with support for GObject Introspection) - Gedit (gedi_) - wdb_ - Web Debugger - `Eric IDE`_ - `IPython 6.0.0+ `_ - `xonsh shell `_ has `jedi extension `_ and many more! There are a few language servers that use Jedi: - `jedi-language-server `_ - `python-language-server `_ (currently unmaintained) - `python-lsp-server `_ (fork from python-language-server) - `anakin-language-server `_ Here are some pictures taken from jedi-vim_: .. image:: https://github.com/davidhalter/jedi/raw/master/docs/_screenshots/screenshot_complete.png Completion for almost anything: .. image:: https://github.com/davidhalter/jedi/raw/master/docs/_screenshots/screenshot_function.png Documentation: .. image:: https://github.com/davidhalter/jedi/raw/master/docs/_screenshots/screenshot_pydoc.png Get the latest version from `github `_ (master branch should always be kind of stable/working). Docs are available at `https://jedi.readthedocs.org/en/latest/ `_. Pull requests with enhancements and/or fixes are awesome and most welcome. Jedi uses `semantic versioning `_. If you want to stay **up-to-date** with releases, please **subscribe** to this mailing list: https://groups.google.com/g/jedi-announce. To subscribe you can simply send an empty email to ``jedi-announce+subscribe@googlegroups.com``. Issues & Questions ================== You can file issues and questions in the `issue tracker `. Alternatively you can also ask on `Stack Overflow `_ with the label ``python-jedi``. Installation ============ `Check out the docs `_. Features and Limitations ======================== Jedi's features are listed here: `Features `_. You can run Jedi on Python 3.6+ but it should also understand code that is older than those versions. Additionally you should be able to use `Virtualenvs `_ very well. Tips on how to use Jedi efficiently can be found `here `_. API --- You can find a comprehensive documentation for the `API here `_. Autocompletion / Goto / Documentation ------------------------------------- There are the following commands: - ``jedi.Script.goto`` - ``jedi.Script.infer`` - ``jedi.Script.help`` - ``jedi.Script.complete`` - ``jedi.Script.get_references`` - ``jedi.Script.get_signatures`` - ``jedi.Script.get_context`` The returned objects are very powerful and are really all you might need. Autocompletion in your REPL (IPython, etc.) ------------------------------------------- Jedi is a dependency of IPython. Autocompletion in IPython with Jedi is therefore possible without additional configuration. Here is an `example video `_ how REPL completion can look like. For the ``python`` shell you can enable tab completion in a `REPL `_. Static Analysis --------------- For a lot of forms of static analysis, you can try to use ``jedi.Script(...).get_names``. It will return a list of names that you can then filter and work with. There is also a way to list the syntax errors in a file: ``jedi.Script.get_syntax_errors``. Refactoring ----------- Jedi supports the following refactorings: - ``jedi.Script.inline`` - ``jedi.Script.rename`` - ``jedi.Script.extract_function`` - ``jedi.Script.extract_variable`` Code Search ----------- There is support for module search with ``jedi.Script.search``, and project search for ``jedi.Project.search``. The way to search is either by providing a name like ``foo`` or by using dotted syntax like ``foo.bar``. Additionally you can provide the API type like ``class foo.bar.Bar``. There are also the functions ``jedi.Script.complete_search`` and ``jedi.Project.complete_search``. Development =========== There's a pretty good and extensive `development documentation `_. Testing ======= The test suite uses ``pytest``:: pip install pytest If you want to test only a specific Python version (e.g. Python 3.8), it is as easy as:: python3.8 -m pytest For more detailed information visit the `testing documentation `_. Acknowledgements ================ Thanks a lot to all the `contributors `_! .. _jedi-vim: https://github.com/davidhalter/jedi-vim .. _youcompleteme: https://github.com/ycm-core/YouCompleteMe .. _deoplete-jedi: https://github.com/zchee/deoplete-jedi .. _completor.vim: https://github.com/maralla/completor.vim .. _Jedi.el: https://github.com/tkf/emacs-jedi .. _company-mode: https://github.com/syohex/emacs-company-jedi .. _elpy: https://github.com/jorgenschaefer/elpy .. _anaconda-mode: https://github.com/proofit404/anaconda-mode .. _ycmd: https://github.com/abingham/emacs-ycmd .. _sublimejedi: https://github.com/srusskih/SublimeJEDI .. _anaconda: https://github.com/DamnWidget/anaconda .. _wdb: https://github.com/Kozea/wdb .. _TextMate: https://github.com/lawrenceakka/python-jedi.tmbundle .. _Kate: https://kate-editor.org .. _Atom: https://atom.io/ .. _autocomplete-python-jedi: https://atom.io/packages/autocomplete-python-jedi .. _GNOME Builder: https://wiki.gnome.org/Apps/Builder .. _Visual Studio Code: https://code.visualstudio.com/ .. _gedi: https://github.com/isamert/gedi .. _Eric IDE: https://eric-ide.python-projects.org ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/conftest.py0000664000175000017500000001225100000000000014600 0ustar00davedave00000000000000import tempfile import shutil import os import sys from functools import partial import pytest import jedi from jedi.api.environment import get_system_environment, InterpreterEnvironment from test.helpers import test_dir collect_ignore = [ 'setup.py', 'jedi/__main__.py', 'jedi/inference/compiled/subprocess/__main__.py', 'build/', 'test/examples', 'sith.py', ] # The following hooks (pytest_configure, pytest_unconfigure) are used # to modify `jedi.settings.cache_directory` because `clean_jedi_cache` # has no effect during doctests. Without these hooks, doctests uses # user's cache (e.g., ~/.cache/jedi/). We should remove this # workaround once the problem is fixed in pytest. # # See: # - https://github.com/davidhalter/jedi/pull/168 # - https://bitbucket.org/hpk42/pytest/issue/275/ jedi_cache_directory_orig = None jedi_cache_directory_temp = None def pytest_addoption(parser): parser.addoption("--jedi-debug", "-D", action='store_true', help="Enables Jedi's debug output.") parser.addoption("--warning-is-error", action='store_true', help="Warnings are treated as errors.") parser.addoption("--env", action='store', help="Execute the tests in that environment (e.g. 39 for python3.9).") parser.addoption("--interpreter-env", "-I", action='store_true', help="Don't use subprocesses to guarantee having safe " "code execution. Useful for debugging.") def pytest_configure(config): global jedi_cache_directory_orig, jedi_cache_directory_temp jedi_cache_directory_orig = jedi.settings.cache_directory jedi_cache_directory_temp = tempfile.mkdtemp(prefix='jedi-test-') jedi.settings.cache_directory = jedi_cache_directory_temp if config.option.jedi_debug: jedi.set_debug_function() if config.option.warning_is_error: import warnings warnings.simplefilter("error") def pytest_unconfigure(config): global jedi_cache_directory_orig, jedi_cache_directory_temp jedi.settings.cache_directory = jedi_cache_directory_orig shutil.rmtree(jedi_cache_directory_temp) @pytest.fixture(scope='session') def clean_jedi_cache(request): """ Set `jedi.settings.cache_directory` to a temporary directory during test. Note that you can't use built-in `tmpdir` and `monkeypatch` fixture here because their scope is 'function', which is not used in 'session' scope fixture. This fixture is activated in ../pytest.ini. """ from jedi import settings old = settings.cache_directory tmp = tempfile.mkdtemp(prefix='jedi-test-') settings.cache_directory = tmp @request.addfinalizer def restore(): settings.cache_directory = old shutil.rmtree(tmp) @pytest.fixture(scope='session') def environment(request): version = request.config.option.env if version is None: v = str(sys.version_info[0]) + str(sys.version_info[1]) version = os.environ.get('JEDI_TEST_ENVIRONMENT', v) if request.config.option.interpreter_env or version == 'interpreter': return InterpreterEnvironment() if '.' not in version: version = version[0] + '.' + version[1:] return get_system_environment(version) @pytest.fixture(scope='session') def Script(environment): return partial(jedi.Script, environment=environment) @pytest.fixture(scope='session') def ScriptWithProject(Script): project = jedi.Project(test_dir) return partial(jedi.Script, project=project) @pytest.fixture(scope='session') def get_names(Script): return lambda code, **kwargs: Script(code).get_names(**kwargs) @pytest.fixture(scope='session', params=['goto', 'infer']) def goto_or_infer(request, Script): return lambda code, *args, **kwargs: getattr(Script(code), request.param)(*args, **kwargs) @pytest.fixture(scope='session', params=['goto', 'help']) def goto_or_help(request, Script): return lambda code, *args, **kwargs: getattr(Script(code), request.param)(*args, **kwargs) @pytest.fixture(scope='session', params=['goto', 'help', 'infer']) def goto_or_help_or_infer(request, Script): def do(code, *args, **kwargs): return getattr(Script(code), request.param)(*args, **kwargs) do.type = request.param return do @pytest.fixture(scope='session', params=['goto', 'complete', 'help']) def goto_or_complete(request, Script): return lambda code, *args, **kwargs: getattr(Script(code), request.param)(*args, **kwargs) @pytest.fixture(scope='session') def has_django(environment): script = jedi.Script('import django', environment=environment) return bool(script.infer()) @pytest.fixture(scope='session') def jedi_path(): return os.path.dirname(__file__) @pytest.fixture() def skip_pre_python38(environment): if environment.version_info < (3, 8): # This if is just needed to avoid that tests ever skip way more than # they should for all Python versions. pytest.skip() @pytest.fixture() def skip_pre_python37(environment): if environment.version_info < (3, 7): # This if is just needed to avoid that tests ever skip way more than # they should for all Python versions. pytest.skip() ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.3863792 jedi-0.19.1/docs/0000775000175000017500000000000000000000000013330 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/docs/Makefile0000664000175000017500000001266400000000000015001 0ustar00davedave00000000000000# Makefile for Sphinx documentation # # You can set these variables from the command line. SPHINXOPTS = SPHINXBUILD = sphinx-build PAPER = BUILDDIR = _build # Internal variables. PAPEROPT_a4 = -D latex_paper_size=a4 PAPEROPT_letter = -D latex_paper_size=letter ALLSPHINXOPTS = -d $(BUILDDIR)/doctrees $(PAPEROPT_$(PAPER)) $(SPHINXOPTS) . # the i18n builder cannot share the environment and doctrees with the others I18NSPHINXOPTS = $(PAPEROPT_$(PAPER)) $(SPHINXOPTS) . .PHONY: help clean html dirhtml singlehtml pickle json htmlhelp qthelp devhelp epub latex latexpdf text man changes linkcheck doctest gettext help: @echo "Please use \`make ' where is one of" @echo " html to make standalone HTML files" @echo " dirhtml to make HTML files named index.html in directories" @echo " singlehtml to make a single large HTML file" @echo " pickle to make pickle files" @echo " json to make JSON files" @echo " htmlhelp to make HTML files and a HTML help project" @echo " qthelp to make HTML files and a qthelp project" @echo " devhelp to make HTML files and a Devhelp project" @echo " epub to make an epub" @echo " latex to make LaTeX files, you can set PAPER=a4 or PAPER=letter" @echo " latexpdf to make LaTeX files and run them through pdflatex" @echo " text to make text files" @echo " man to make manual pages" @echo " texinfo to make Texinfo files" @echo " info to make Texinfo files and run them through makeinfo" @echo " gettext to make PO message catalogs" @echo " changes to make an overview of all changed/added/deprecated items" @echo " linkcheck to check all external links for integrity" @echo " doctest to run all doctests embedded in the documentation (if enabled)" clean: -rm -rf $(BUILDDIR)/* html: $(SPHINXBUILD) -b html $(ALLSPHINXOPTS) $(BUILDDIR)/html @echo @echo "Build finished. The HTML pages are in $(BUILDDIR)/html." dirhtml: $(SPHINXBUILD) -b dirhtml $(ALLSPHINXOPTS) $(BUILDDIR)/dirhtml @echo @echo "Build finished. The HTML pages are in $(BUILDDIR)/dirhtml." singlehtml: $(SPHINXBUILD) -b singlehtml $(ALLSPHINXOPTS) $(BUILDDIR)/singlehtml @echo @echo "Build finished. The HTML page is in $(BUILDDIR)/singlehtml." pickle: $(SPHINXBUILD) -b pickle $(ALLSPHINXOPTS) $(BUILDDIR)/pickle @echo @echo "Build finished; now you can process the pickle files." json: $(SPHINXBUILD) -b json $(ALLSPHINXOPTS) $(BUILDDIR)/json @echo @echo "Build finished; now you can process the JSON files." htmlhelp: $(SPHINXBUILD) -b htmlhelp $(ALLSPHINXOPTS) $(BUILDDIR)/htmlhelp @echo @echo "Build finished; now you can run HTML Help Workshop with the" \ ".hhp project file in $(BUILDDIR)/htmlhelp." qthelp: $(SPHINXBUILD) -b qthelp $(ALLSPHINXOPTS) $(BUILDDIR)/qthelp @echo @echo "Build finished; now you can run "qcollectiongenerator" with the" \ ".qhcp project file in $(BUILDDIR)/qthelp, like this:" @echo "# qcollectiongenerator $(BUILDDIR)/qthelp/Jedi.qhcp" @echo "To view the help file:" @echo "# assistant -collectionFile $(BUILDDIR)/qthelp/Jedi.qhc" devhelp: $(SPHINXBUILD) -b devhelp $(ALLSPHINXOPTS) $(BUILDDIR)/devhelp @echo @echo "Build finished." @echo "To view the help file:" @echo "# mkdir -p $$HOME/.local/share/devhelp/Jedi" @echo "# ln -s $(BUILDDIR)/devhelp $$HOME/.local/share/devhelp/Jedi" @echo "# devhelp" epub: $(SPHINXBUILD) -b epub $(ALLSPHINXOPTS) $(BUILDDIR)/epub @echo @echo "Build finished. The epub file is in $(BUILDDIR)/epub." latex: $(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex @echo @echo "Build finished; the LaTeX files are in $(BUILDDIR)/latex." @echo "Run \`make' in that directory to run these through (pdf)latex" \ "(use \`make latexpdf' here to do that automatically)." latexpdf: $(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex @echo "Running LaTeX files through pdflatex..." $(MAKE) -C $(BUILDDIR)/latex all-pdf @echo "pdflatex finished; the PDF files are in $(BUILDDIR)/latex." text: $(SPHINXBUILD) -b text $(ALLSPHINXOPTS) $(BUILDDIR)/text @echo @echo "Build finished. The text files are in $(BUILDDIR)/text." man: $(SPHINXBUILD) -b man $(ALLSPHINXOPTS) $(BUILDDIR)/man @echo @echo "Build finished. The manual pages are in $(BUILDDIR)/man." texinfo: $(SPHINXBUILD) -b texinfo $(ALLSPHINXOPTS) $(BUILDDIR)/texinfo @echo @echo "Build finished. The Texinfo files are in $(BUILDDIR)/texinfo." @echo "Run \`make' in that directory to run these through makeinfo" \ "(use \`make info' here to do that automatically)." info: $(SPHINXBUILD) -b texinfo $(ALLSPHINXOPTS) $(BUILDDIR)/texinfo @echo "Running Texinfo files through makeinfo..." make -C $(BUILDDIR)/texinfo info @echo "makeinfo finished; the Info files are in $(BUILDDIR)/texinfo." gettext: $(SPHINXBUILD) -b gettext $(I18NSPHINXOPTS) $(BUILDDIR)/locale @echo @echo "Build finished. The message catalogs are in $(BUILDDIR)/locale." changes: $(SPHINXBUILD) -b changes $(ALLSPHINXOPTS) $(BUILDDIR)/changes @echo @echo "The overview file is in $(BUILDDIR)/changes." linkcheck: $(SPHINXBUILD) -b linkcheck $(ALLSPHINXOPTS) $(BUILDDIR)/linkcheck @echo @echo "Link check complete; look for any errors in the above output " \ "or in $(BUILDDIR)/linkcheck/output.txt." doctest: $(SPHINXBUILD) -b doctest $(ALLSPHINXOPTS) $(BUILDDIR)/doctest @echo "Testing of doctests in the sources finished, look at the " \ "results in $(BUILDDIR)/doctest/output.txt." ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/docs/README.md0000664000175000017500000000035700000000000014614 0ustar00davedave00000000000000Installation ------------ Install the graphviz library:: sudo apt-get install graphviz Install sphinx:: sudo pip install sphinx You might also need to install the Python graphviz interface:: sudo pip install graphviz ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.3863792 jedi-0.19.1/docs/_screenshots/0000775000175000017500000000000000000000000016027 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/docs/_screenshots/screenshot_complete.png0000664000175000017500000004132500000000000022607 0ustar00davedave00000000000000PNG  IHDR-{sRGBbKGD pHYs  tIME 8/  IDATxy|MGǿ%77{BBl%RZTK-Em UUUԮ Z[k%B%քrAm/ |ɜy3<;3sH(@ sd@ B@ ;Qxɀ=&J-_Y2Qon]FosXE! -&P=D[0مW@::~W(A޵/ h9`7 Gql; Ⰹk}pIX`q JQ/=B)O&OMmhMØ9jmd?̈D7cS1ÚUBCvQ%+(822r~lW4oT0\;_Kn=t2 ]?yxA.~MoS?.R;1x]E&?;uxy>anXv@[CHfSF|wBuy/ܼ4ό8NNGȞTy(z 8d~J w{V}WgHSJs8Z-% 'wj3+{xԭԖj}S{?Nc䝘rnPl{U:,YaNB ~L; sޓ"e Ss[`$;r D0""f6x4WkW`cv "Cq!6Z2X:uGd4g `௹EvvWua.Y72PQ>P'w1{g,R>!8kjOB$/\눉GzЅi6;6HSbB^G{k m ,S&e0x]wJig" ҙfQ`\o>FMӌ n@S'kܨ$eNC4*ыuW>;4%ygϴNNT/Ҟy|-ER*:Ocƨ2-Vr1e6Z?ħU#yZu]5+ {`<\^-ffufo pR/-ؿJr]uо%]@SW;s392USssD[ۍ9 "d6kc5"_l\=QyL`=a'SZccfң\m^)YBBG$g׆e2aM7b1R4(2&#WW"͌k$l Q^JƜ)&t^Ul6[i[bK&{*̧,)&;lX/r6,':C%s["0TP{S+["I={ct5a7an~w_O~otd@ @тr{z,j W7H40m c7&f [ 7u,W| nCgV\4nsﺽ៳uLVG1 }%>sVA(;evE %ѐڝ}췥\&)2;7ejzCvA\4 II#;1}'L|[s?_9&HQ[ImxQp1FHuй tj1$eN(YOZPR/!*r`=tzO ɱɘѥm}'{;4JF7h_3_AڍIk:M IHygfYtUQJ%mƲmfE1h5JPVq\ֺ*Zóx%j/chd >͚D@YnHrewfa%= Nݣ^U 羋Isܶ_޴%*BSbF  bcp>MRg4r~ Gfn&;8UX"yD; ʤQT_pNľ1H;L% Yx(aI9h<_ZX.,qǂ^ nhQ,dm،ܹaGL>ΞY׿ѯ32<0)Gؼg*^)+y}Ff=ӟzNtfОn؞P+MD߅ɒSlֳ9L yylBڗGe8?mdʤվ||8WX:" 8011Pw.A~΃+j bᚪ,i1ҰI*e0eg__kC9Zpl$Nɳd"iyVo5/ 0hPHI 6.볊 -"3Z _k1:~*0stp~9>㟱{,WgpD_,eyo +ϋ"32I @ I@ B@ "@ǍK|u_D@ xE«/6T \é3Y4΋f ψP ҩxꁢ =ΟT""?4s-D1C7-C"eFu5&ytH̀,8c4׽n=3.ؖ%q@ xRE52z_=ƪ9*jpty_2q"2NW`^*LWcFqO,{T\v^Ku] kSMDևar"/2xhfgLzx<7"}Vmb=lO3eP6?/gsR4ìZ֟Z*'ϩce ZKZW}fǖ}"n  _qsvYtSL8t?C0Z~_; ;3M~evO`/v i)RKfa8V^]/UVL~uig" ҙfQ`nKӦi{J7Rŵ8QލN]$:KXw5^᳿3@y *+P[̔Zv~sߞ)ZѱA13Q6M}L V*j}DKCL<B8u)KJa7d&+Do9 .'!fq%A0Bֳau,gor3P29%c@e ߘʱڛҕ\I l?ԀS-lj!Q6}(YQOrh*S @۝d|K+sf'ڌ$$`MH\?w|Jܫ1ODҶ1|^̶(PPVF3v6d PS]zjApYAW(-r(|sy($NESiM [Mou^*mx;_W?jluۍA *r,/ё@ $"T[4H|>݉V9*l)ħ;1OscyMWʨap=KJq|Q|&ֽ3Yyqd&aNu=rhܔw/Ʃh@/X0l]$@ xWbKmd|8gH 2ZɹJd5oLPPƸ[AdJ?IrBrl2fEƭktipkiKCiyu;sJn~[[cSj╨UN(ܖq,W1zE40@ o͍1xx2 l;RmG+HxDI9¢=5fF֜%W3CfmLE O gJsȖ* d壄%iM `OfGΌÄat{s)oo*V_ cЋ>&$Ԧ.Ӄ㣉_F]he@ <b D1߮n6 vYb8kƌfֺ+ @@ |X@ D@ -@ h)h);|;jG]-u/Wk_{"D'"Z @ %G4jj~XŇ+s܍3Y0֋ygӄQ~aʲ|;fW-˽H;Wl6J=AxR:n3o7 zZt7ǝ <'_ʮhV|TƹZBDa}I|~Q|T4ybɯ%swq5קHf+Gva![ӓqP@ DK-^V"%3Ӽve*ʘ<;H_ Ur>ņsd=J}]W#a1#J"[q!G3߬?{Gf#)9djNa{>n_9,}[z[a6PցlMYNtJ&D` LaޔʖHm`O>e$tnigW Ja<ǖCɪݎ7br>='?pi\IP,Ccy)V3HT!*4#U+=&I³;=Ѫo)=OaRAlg#n N0!5U:ɢ1j?Qm (lHBڬI+.s]7̈́.Hj~W + bœ'3s.RQE*LnNS]zjApYAW(bN|m޴QdPIHHӚxTCXw~*kpQˠll((v+f; vH*2k%$ o ~ ~xӉJq|55 uI|TjY\ %7E!t:gd j36圖튄2ַ0nr OVܻ~{N.^$x[Mc%'\q9U1ROwBqXlTUk;W3HK4.HjW0Ykcc^2>jAU{ʸI{Q6t{lŕJ61'BӅgrxl;gL&jB&켾4aKLRev4nȻUE@CCrnL$SxFmOEPRTtx9^Tqg ;}\KGirg\)Xn.~˞JbC@ <1ѢQ'$m&.!C=ytHWӽE35mFa{˲guJj =Gʕ29).Gr>#jv:G .dRvl)ذ*g7oZP8(F vv3a37ތbM_//y֤KCfÞ} &35 1{&a+p ٻlY-΃g3EΧSiߜ 1JehP*+D{) H {L0>ڕ>a[``0gZ$YTЖ]\XբZ$͙pȵ۬Q(켛\I4:nCWyGC73$ .J4^:pbWDZ6sɐːC即,XdKKe$*ݱkd*C$@ N' 9YO Fvݟ8),E̒՞IYɓg9xODe80Q <+O\+_ɇ9̴c `QrD1&UW>(i8 OW0"75߬<,@ Dp-&57F~Bh|y#'/m.G)YXAuS ? f7aCAG, gJ7OWN{w["@ D@ !ZAޠ)׌ covdy &~7(x1^hʇ|_3fv7jOw&])scڔ<28ϢE~E xڰ i]9ndOlޟJ^$W>O1ӳM3zkcg#i&\|Jq&~v?L䇛U <=("\ڥd%Ra62g0w" @РS0]8Aą4t G D@ ޖ~}Jႄǀm,pteVl/t,김SY {qXWَ)g,d#GY^oVCg/5*`\wSNkiDx70c4+Xc0c~ ]~)tum-e냱x| %4`ꎕ>tSz^CkGsr)_x(/{-_YʟwcTߑ}'5F M2q!Rln!-7y{AZ^VLDS?9FG.!?.l.Lv`>_!??S>LP nقѧ"Zk)bC@_.a{.0 yMnwoU קӢYiؓac&b-yh xgVGYp)Oj|*L:omUŅݓdND6/<8qs;xg[K'w:JG=Y6SF ١}69$czX!͟:OW02gsͭ#|ϋ-݈'1$Y!& -}'9{%}{_n2-bX^/&A`BKe&9.v V".[̵.PyRɦdZlq|fP?l JV<"b]R9ؒم Y[(VN юuKT|A?Kl^If i3Ӓ}7+C<.ߑH%jEUh=|)VeIo^j__K>ye[QSgu*qdH4(Ӵ"7*/gŏ#csw([CA~GEϺѤU>i–/6p&yk{o;3uElB7] U^ːxl#x n`:5:瑼IŽ|s G}w(+Hڴ_tӲ@^Vm+u:g{?IZ^5-8U,YɄ-ds-|sDž Q qx]K~B<ݐbє#;ٹ}h?6'0gٱc¦X80Q x큉.1 = 燻L3-AGRZ̴*T˨H^h6 r7)A.A &yt5C~@])Ӗh hyw&A9F.l] 4cvY=G<3A, O]<$36^$ @vo@ !b@ hsXnÈ>4; h[4?`k)ي)se 7_!Zcz /z)IOg{ԪK6U/y6dʜ)w߯Z'Kx5L>w|"?8؈+hG&ч/(i|5B!v֝}:ݯr㟧O bE x P⃉Fd&2톅(m-ET*ځGQS,o9-Èܿ5{s+=,ڰ B 5OwL\֍NoC15a;/tg۶ ys.[Ahfv{Uo%8ٝ*3ov"È ʑ//]+ޅ9kCٺ1BpQܥ\OaDnq>0~[2wOm."wy^W߲?';Y>ʁ'S;,Y;!}Gڿ z~LT_ `O>N-}*q1)&10u1:NOcp30.v/ևuI*K3hjQm_/v1&/|=F8a.k#f2u5Z]MOg*9-^iyY({ifNLFҡ?H "xؓ~+IR/xQΊCpPiFK+T-Nd;1 `󨃏և?oINǞO)|@fZmOWEڋ /GI1g!с}[ i쳦\!U^7-Dk#vǼځfv"̸6p:ӖF\cIH\*0n$ TvXL w0jgbgRkf%);=1d+yY+jtszMκg54|ѐفtn *nT3N? _I3&])Y6aMЋ8Q?'}؈+p7X߈b.k{u$26Z%׺4 ®sdROsdJ~owwGXZՃpOԖkEH*x@U_@l]e벣)=ahyQJzVƵ$cy@BVy糱;5L>/3Jͷdojn.r-ӔIalT;ؿr 85ZC`#WX'>ۿ]I KVvyk9?DJ•\0J ;F>2bqt`M@1|z]OOB\`73z"ګɼɊsg)g6WCG|ӀΙuy?gD`q|.ep!t0&SQ?YUZhxuol(g:Sbz8}~=+Q]\;#o.&deذ)>51yb0u-aKHng,?S'p@ xiUk.bU3蟂i0bE 3-b#@ X0M^N{;-fZ@ h@ D@ 4aY ߎBM;9^$s^hʇ|_3fv7jVVxЗǢ!)ydɛ}J/-ӆT(Ox؃S%JtWO I7S?ӳM3zkcy_๿ߧx~)3KJ3 '𨲑?IX?a msEww!Y-C_$~bk~cQ ]~)tum-e냱x| %4`ꎕ>tcxU{~ tdw;+MQȞ17YđHy ߐ)iQ{Yo?˱r|ȥot~h}o3 KljݲOE4R6.&$ [ou;߽sxEpOȼ~h|Z4>Ͷ{2s ?D-݈'1$Y!FNA;|\]~;?YC**;2qd_%6|\Kά'\Oj|*L:omUŅݓdND6/<8_K'w:JG=Y6SF ١} 3I'OsJI?1PB?%?u>{2ad<{;Rn p{5"v$"g$Zo w9CE AŎb &^qTfRΜf%6/$4Ov:E 98/P𘎁[8q (f@w<5ʓJĸO6'bÔ|o$\ B$c$d+(Y^uZHؾwg.dsd=nѢX92F;JU,8Qp}%81oWI@PDKʖߙf˭3¹Y0q0ٳ0?d[2oV:rqu=X~c]Ig*=s-$o$2=28/?`>[z2rgqO FR4>k~B0gW I0BAy:R᡼t(.{H``Y%vDXLq -[5;[;Ih$]\033 fS J <N2rk_YN">x7L_jԳT7{jFs5kn2<̽ľ^<ƼlMv#ĕqZNlGBv{i'j!7frbAp,>L14ceŻd>^o}d0cqN gi:irُ2jhlB+oIn&qqH=wOr)x=B*Rlsu}_aヱWAdv'}u[9rO.S׾0`D+-" EPvCsZBX%FdSq|P""SRP>Sh{Hdc~{HDd=EDDD|A<-"""RQ~@IENDB`././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/docs/_screenshots/screenshot_function.png0000664000175000017500000011614300000000000022625 0ustar00davedave00000000000000PNG  IHDR6sRGBbKGD pHYs  tIME  0&S IDATxy|L߳fUAPb5 RJ([]-4$b-X"L֙?(Z y^^W{sysG@ DL^@ xPExC  B~. W@ Ep@ (ߘu?ETQJ|5ߎbW~b]3Vmɱ0"缋pIK D1hTt?NyrOgl,k1R^'PWSNlss.御`:Df[^7b/1?_8߷n%KyyWߚky%|ar*0sSNʝ;lQVJ&_%,2s V$4mR"DE$![%W-sFQxfLMc؜p ecJ[' ߡN৬+\(@t7=u6$ۗLĜIS̒utp| :QV]}b?=Kԑt0ChV !QzPO{v({5A,_v΍q8ـև_bP*ҹqh%'.",.wm_W97:Pwt4ri&M^'?[>0f w6-犕,:v6{M1־?3#L8>9j Ge4KNR}J9 &x Vk$͜‘u ߕEYHzpgݸvq>E_xSW|wלb˷/])3io״/gՍ"rdv EQ  wQMf. Άb+r7`Xl;Dһ\.e?cR_Lj&p;GT=סն6&<&?nrViW3cWvM bZpuA?ӽTY|ẜ~-q>8gh?`ƒ=Iԋ4b$]k.nɼi57~п?ߟFڍ 7Hɰ?~cl4&OAaD6Tm1{LJ3+|8twUdr'k굤Dt=w3lVǽn W2YqH/;>`S'iMY6{>Yµ[|~}=$:gq~77s]IvO >jZOeOϑ0, v,2yQe>um:%uiN".6(}(2gQz 7صj5σhP&Ȱ;䷎QlJ 7YQ55LXҿGOV>D]9grkX=H|] AVp\9[FhCܱz@ A%toIlm rLt KCzI%ټvGhF  kb^]˞.6R3&zMZy !9>Qп{h޸Z!ʹcU{|*YS_n(&[{ӳIQlOVl+z RxP2 QĥީjXBKt))kݾ%L,Mf&O9CFqY5旂yygdbǏ@N̸y?)+ gO$$I^ %pp(Yg 8?LC1dJVTb=K*IR!{7jGwO,+tRC)p4nӛпֆtvP i?(吖xR qdB|pkW.>\ rD¹q-@ 0a)f(W(ȼPبX$rvJ*@\aI R1+fRiS ) үq,իoy{'zѫ#JZɐYI;]ύTEpR|?lI[M?KĖǪmݽ%>JBMSuIdjzj92Ҽ+S[9*YsVZJ>fЧp.qw M?ӹMoF/9BPg7Y@m0c֜!U|F ^bPo/aܷ^ҟu'nОǴ|!a7ձcU_{e={@]km&dXL1́Irŏqkr>vH ;U~;+}ʪGܻ6>r#,Ni\? ߖ#כ?#ʨ/k'c_Hm+iNΔfԺ86v'~^GȖ?CQ|DZqf^:&.(G%ްJU;Os r]"ef>D}l}JEYm9PEx0tme.g^]iD=Tz5ݬK/313uFoCI3b|,nFsJDPR? dʬz日}4g ' %b_UM\1wT^nAޙU8up1ܡ"\.|׮Vʪa:n: =5%ZezkL|([ҸȝZbp>7+$@` 13X+u[OJ{H^Kxy3v <ݽAl|y99rN`ĉL ̠(@ bP@ P@ @@ Q @ $, :.|9(**a0>o%s=S8Z 0bAo[#Ig1tj{}Zm:۫ @ ^  DͻwL6Gz[^g%jm@ u*u}dYI8 J M) )AC})@ N,6LAa2S_ײ@ ^bP&ofR!KOc|X'H@ }1(Sip)S#S8ie˱V @  )̟w` oT-+un@ (LrP1(@ x%A+@#A@ Q @ D1(@ Š@ GPbP @75>c9ʬ}eť´~^'qǐk,>KaWQp _cSA߁%Y{ R(mmz"pƘ]H&RMؕMLVW%\1}| k9Y?)? Az'3| g]r^}\g-:NԳD@щg>~( KY288/ M^nW(CZNwG<iϰfWZx\qmfTsSۗОL͵G_Š+.Z S@&EϨ V}z`NwXy(;RvNBJp)茮4N??c78DZm.ʁYuO!H&25uRLȑXtr_`/Mg y|u~w1уu}E:]DjNy0>u/IR/o[G< w{s];|R(cBٲ8;Ӻ_03h";d^ͅҾ0'TM䞶wA+c&$*C'rc}L=Gԟž9Գ2}6ya; ApHz~/Sg?=wp05H]\ȖnM?/}cо ޼?gg6p K.~plϘ 91m4Ǯm`L<颗B_ ĦҥMewL([RBenw|ߌ/#S&?㍶o@T/ J`Hu=9Yl3,cRmޫ?BI6<TxOMbՙZՑGb[M.3ƴ*ۀA0h'x%Ҏ`WVC4t~4遟fk@LKQoHэ?J62g'_WSM=dFvtz)_ƥҦ!LےYOS|ۍxۻ={1fT LYe7ӳ;tr짫qjњqg}&}1;}s0?gt gl@SZm[혴-7m),+*'vQZutF$aȇsӷqvԙ3K4*Տmwޮ1Z? <ʼ 8ŇV&|}dw/W(ʚCW {{"1 qQ?>e74ڴ: NJa{@K6c1ߌo~;>7˘ϘX7ͪD!hٙA+q"sJ;=o0n;R2 zՈa`nh 4W=iRao2 hR:vG񬂇М5)=nyw@mWb:\ӭWǐ~ݳBȨ _'\uSws;CC&)30X}ٗw*Y '  CVqi}>MO} Gw k9h?r]Xc?3erg)`H:|JQz8ȏ9c}R2sEs6*F~7r̩6gk&.k "Y7I­_ ٗ~oϿ&gh2Ƅ_>/%$;gLcY.A!eXsiHyhex8)+]KRDOALIW48`@VY\] ,Mft~?\!P:ڍy_P +Nrx(i&L r\ΠQB.[¦TqTQ$ Cv&z$$lM6$ ze(LEɞ,S3OFQ79ƞ&.h󲮀_OܲtME4@3_\֘WWWs_ܗZe5;oFrD\^28)Rf6;1޽2߼[_3P_)F_@abQI\NcټL:Qabj-Yy-c"+w]qUrV@q%s8!ɦs%V֜Lx>69Ф93OeU3RŐ_ݚ2apفK)YSyNx* K&0H2vN1j Q;O3tMgNLe[1x,ch3%NDԴL;L|$,AHzz&[}TC<*]QsDz?g~5y7HRAc$ ڿFMY:7 -˝llHfָɰ+@6 #ӹkLX3~'6xڡuijjm*Uc%99%ldlKxt`uus޽Yz)0˷ZCѻ2~deJ%۽&UT DZ9hCRlْJ3Sfo8.uƿ}-pCQ?i\ߗSI̶,jэJ^fWQQCCDfUDaz">L)@?QoKHRM5],G>l'9dG_Фrn9 eeE@?ە1s ឝ0+w'>^4$q`h7~'fבj잯 A|ywszmlM,6'GQg1sfeB|^ھ܅FKB?F?1?S\ɾƺp<\Y'Np[<IDVخcT-[ ;Xa?[ L}J\'Fs"v== ;yi~#ϹOFᬺ}sלf)ae 踽x&HF~[[ _ql%G>"Sf}+56cGhsǏ)W~3\=> X҇CF^61R@VӶvقW̺<!񊡮6U[p6ME/S`[3!Usw"S8IO7/ ILDU}b$ve(=n$ D~D @ xL##?}lt8}.2@ JM2@ ew @ bP @JQ }c0ƿDi-+.Ex Nx>CCf-X^Il$ @ؕ|TF#U0M߅_w}_^EO` ƗǾGe *[E"+U_;Sa]#pHM6;8rUҌFcŐ>n37%s~:S~<`l;7[tg_~)B޿\_&űe}|]i9GWC?/ςE9eBiOxbd}\"ԫR)~CcGT&b[՜"=^ % 2% 4ib0X2/ + 4(a8ʭ4jrYsA *?ʊLMՉڅRnZNKqihbzh;v}̾"~h"5'ټ~~E=/n2bskO] ewL([`Dk\< m4ĢG4}\T} χ&rO[\R6߳9"2^k}~cסʪ+' KmT(pk3Î&R{CF0x}k6 eOE5fƝ0&vۛ}Fk[a[t7Zڽ %xKWJLڷ`FĢ{jO[6p K.&RMdq6тNQwA+c&$*C'rkg,ԟž9Գ7M?eapO!H&25uRec7/S[}ˋ0xNv^>;ci}l$>WCFsƴ/8/{7`j4 - u\he7Tȱ+[*>Q/cbJ)y4%~ >cѡ!nmagg|6:+YW(% IDATeA.Lso MA> c4fxيqݘdnw#dFvtz)_ƥҦ!m.{dqz+3d'xoOJm Qfwax<ZC泓ߩ&zn@OS|ۍxۻ={1fT \xЅ.=x<&=K buk>cM?ͬ6m`R)ƥҲͪ{S?>mY:4wӪlm(àn2oB9N|! (߅q3B,w5^~rVh͸y혝>9ֿyo _Ui>^;SgӭXxuf7Vu˔})h~Svԙ3K4*Տmwޮ1њvCW|ƒ ~ᣬ9t@'VT1Oͣ<QlHlJĩjUIگ5)V@ʹdYb|1#~_g>ϋvT_8cҲlKjǤϹW__XA9>JŀջLnuT~?ݡk{{êޥ>>~QIz =+u"96qGd##bQҊUC͋iߨ}Yd=En'^{j8= YX0u73$0dr?Q˾WI2O8IpP,>.h6̺L)Eܢ5\V\|92 hR:vG|#q~vqќJdz㉏8TܗptAnJe)C)) To1,  !W'MJ+Mn+)[Ŗ;OCYSʹ琌ć1ʜjӮ~&nƀ>!uӎm05u$]z;:*0-`Zơ,卣W]wF+nsY?X2w|13~_/QYآtIf_f ZY1d2cd qŞ#]"OS(R)=~`w:MZvp8=UXIp;Hz\^A&G(_@FŦ~4u 7IWA?O4q$fJϼ3wy;FF 5l RQE['n<Kڋv*_duϘ|= ?w@F|Wk0  %\%>`#aDdБƀA2̴gf(YSP(]KRDǃ>I3%]UpYgD/} _WsIBxֲM/q5}Bl`qYc^2o'ٱ,eBee@ ̓6g|E_fJruLQ9fJh'vV1TE}zjԨ(OM2$@<Ӷy^|R.yAl7mq.;E<'8RnD4e†0=\%Sԝ,J_f \G99v4{g١i6iM|DH|AsTCsSEa*?ʀoRI!M6*Ҹ;vFʽ jgl8R H YՊ'ƯJ ޕ{2nj%lTR2Jcm߄bj@Mȩd2#V9$&-ɱԊ=AԜĿ%rI }ǣeH܇wo*lJQGfnfq3kk:ZnIVSF̶GX v_׽7SHi+}ҹ~7-TSH|t-a45me+f;M_5j ;Hd]Lv6BOr>$MѢuvEjH? ǿgg,?}1UlꫦX5m|~P(-3 Μz%zܼ#H1+S),>#%w2L.d$ OQ~:2^$Dc6t&?s 鵱56}eqڭAUOFQhIvިdz~#]aiVelѥ09g QYupYq?\ ,?]VMD}ǣ! 1B8t#1oElowo5 +-'ȪDkMԏ1}=5w ]a(+.rٮdD5^(ɂm3r݄bluHsYu a89͆?Sa̿8͎#XC)}#}/%.߉Dh9s=,吡ѣפOrˊ=kotig 9m}j4_D)_A볠3Doe:F3>ˏ/  ,5\BB#:O&[xD xQW-Yz8Φ)-ׁݪ97 ̺<Q(M6c؎N`)m1#X(7UrKӢy(#$Bl&7>cӺfjΰNJ7L##?}lt8\ vbX ebX M{ @ ^bP)A@ 7BV ́TD|XO``;4d#)8{|eť´/iU'oU ~ת*Δۮ si}#z3_A;>>_]2çЭ|}%_Cf_[lB},.O-}d-xyX22x)ȸCK{gHdgee }p:˶Z39yc_A;>> IˍAɸ#$=>q:g-M.,,43(á m\!)̀&@F > F-.0xFkʹ `FĢ{jOϧG+mRL`ݲt~]FlupϢK eLiߡ!nmagZu/IR/o[G<ܑVؕM$ïdy}&)ёji"Dg-(xh_쿗lOaOٛ?[1Cgu)r?MO(pk3Î&R{CF襰L|?Fg~L dx!i9vmcGh|ϲkԞgǣ!>poͦY̸@,Ư )!ǵ8s |T&phXoZ5~XH߂ע" ))-_B ,His>=O+C)7{FLEt(O-:|e:[#0y\۲thr4U PAs?[ Ji:n*Pǫ3K#^J0?Ȍv:81S.KץMChMm߮"Дe[2V;&-hƦP몵wI[4fxيqݘ҈,rF n2oB9N|! (߅q3B\oǔ5^~rVh͸y혝>9v}y')BF ݏힽ3֖O3RS?ycUxb/|5DbOPw0V5x|.L^&t!%K6&=K bu4ǯ1,F/H]ɹpCY(o#m1gIn"ގkJ'.2|T LBgl Z+εݑh<[F K&sCkBȄIZIk9h?r]c݄Jr}Ibq}QOo>SmdM\'Dn#nCf#*YAsɪ0dFae* oO)5$pP-B5M߼ ć]ET6ce s[ұvtRq1Y3\h )c:ڬVOܲtME4@3_\֘O#>8 $9t-I}wO Ir .,P/g8:(j /&̧G\Wk7* 8?(5yQPU"l>^=^c<0dgGB2dc@ \f~em.vgЈ(F-aS8(,?Ǩ_qR8d'ơѻ#j}]MRU司86n,]j/fVt|=c,2xXON4`8Ҹ) e+w?,oS >5娒!,9xYJ'&hc2vs1IŎUrV@aY6Z=߳ <\@ƣ;O3< o~M3TVexcϋdbe4PIϸ0H26]=ό $nMa8@%Wɔ~OvTC<\Rػ`χ(lq.8]+x`? d=@ȹx[92įI)!e.lgXeZpj̬2AfѷLi,tb†e&6T*|8Ҷ=o9p,ȰVdX));fߞ(֨!UKء@"3*WdSY$1bX znN 2R4݇b+}](r^*^*@\}1UlꫦXȩdA!%fV+>Rv(U68zWRXˌƯ_G>.}#q6MWq+E?ole@v:߾JP֡W-4-SY9hCRlْJ%O/Y?Rq֔!H`6oB15p&X>?2^ EGckT??>$eo8Q ~5pU 3˨?LַM58}ӣ\pbpo\/b݉^ErZza /U]h$ soY}~?S`.߉Dh9s Ks ]a(+.rٮdD5zxmL~r˳Ɵkckj {'"u귅{ܼ80?EglI“OLz5vPa0;ZD! 1B8t#1oEl@5 +-'ȪDk-$M?WlK6;`}Ej_J>#L<-3t'\ӥ)aT?E,Nu;Y}= (ٚ_1~a^T˫ȇ}^>UQ9~o) &11Xմ-'qhȬ˓kۘIauߴ9Oyš(!!'E`i_!cθ |E10p:Q1 ^ .AMBk~}r*sb"1 /%E[ c@,*4qqK )e2?̤BP fBWp@qh5Us5=VeVPnne\ JP<"\.r6Tzeb@ 7x03ȃN 'TXS8A >t @ ɈbP @9C|Q>_Ϻ@Mē -ilq@ bP_;j;V׳#+<}#f|;j݌_wE ,nݕ%𬄯cyjUbHH{c%پdUMV%_r?}\qi>t_5;%0`z}ߎn%[ Đ|S3iÜk,W>@Z&lB v|q-k`tC s|PO˨d1.& ˻|˾?hq U?,^bI*s+bY\/H?jݹ] qȐ4B<[ Y}۟ 'ėgW_#?A dA׬/O]{jUU`hז6s?z>}ץq麴}#]W:|_?R-3?x{2nmH;ѐԓ<1F֥Eʱ@4L?^I EJXa_244Ɠ:iKМ |03- 2OGs#Τ+ [E|+\{kIs ;ŇZ5i,XrGSߤ=|w{8,>K];jDܖ5*>uccj[-r#׈t.;&Xɜ6yS?%>hAÉόUW+ G.}2&Db9viΎ}aK<ٰ1`ejOľsFrWFlfE7eH’Oyikܕ A)+IHč4[ɧn2bfVͮt] ewL([`gjˊ{#8| ۠i 5S¦js!I7Ⱥ8,E>cŨY6EU'sm YͰJԊ_2f^2܁CO濫ϧ iiHiɈUc3Uw@m q0_CdFL+~r6f#o$N'á^7Xgm q2ٿOՇaV| _]D^NG\hJJ'!Z#y(m+ҹ@ ٺ%$ 2QD.KƠӁ*`H@w!2٣* /7QJro"K;7 ?yu1~Egۺ KQP<3ҹWtDedI+مbVk>`RtWYgEGWQAi4])Q'c;CcJJԆ@ ÝB}X>k W۞*8 ۹asMHqtbʸ9QIxrp}e5 ,ֲL΍lJS.b*U&/YAXr~tIÂ0&RixŐ˽PUل I$=.u@1~ТʖLƝVؗ\^*(yM9;s>c̘F JehْB("RfWh!ReK1 c;ssB2#CGs~^ػoNF '2(/a𵧯 VmOZo0˽簿N/nRۯZSʧod$>Yʾ_C4N6b!8<~-v7O]P#ˮ#L(-P*QYt8\L@A<b&)~|7րKl?qYف?7XOˣٲgn) xS(10_u$+Ga5I99W%6W?5U1={♙+ g6-߇3зgsm)uHt/۽ 4K Ğ؂w5iBGffr7uj NqlK;wKȕA'欟ˬ_yK (Iӆҧf#'ҤzON&`!4nED-V -jܭ y6mDèt&Z}9 fH ^ 7)B<+'aƹ>9I=wTΒקcvZ 4'g]Sr''@F?ÿaXTV?j r6 iѽд_vAަN8tDަ27Xl6+W÷y`d5S?ګ:סm ШDԛisH332ܖؖ'ǻvԼ<]8Uq۷WAAvښpUq5YvQz*j!8t͝tpmTm^hԡA;HSo$B={4u ^W*U77v<vıqئbڭ'~ܽU8^<މ7+]E{lj>yOU埍3x~*gpwXo(Չ}[!Ŀ6/_Ygg9AE|5[ |fAr5[N)XNSegb'8%g}z؎ϛ-抲}x|*iT, ޺u큾,w߇S>t}[!ĿTOԦ5N' ſX͠B!OB! @]G ) !Bː !BHB!uVO1o6\vQFX]XB!(àfi$E֊4t~fkѧZQJјkS)73~cOH;qc)BRT*wk%P,,-aP|hkn3kw|].L!B\aR)QV ^OMJV4ɬb `hf2LK3Q Tl!vTSǷ :J5T?kEV|o`I|&wǡZ|U TQY7+>}P< 'v>_&n/"On&5֙]xM Y y7?ڕ X;6mihۭa[GRhmT|S7buC`]T1 ! 9Զdm| *G>uR`Lr` zn̬S2k@[Ş?@Q p.$9G֌JUC5޷ز!5Fjׂ@k;ڡmwpm ,*-&KdEY3'˟g“ݓw`e`f|w\L0`BN;`䷹&҄EAe lFqpH[3¨nGC}Ǫ|à+ә z0;E.BUj •w"E1E5t'=_`/ʓ}y.nO'=i#sI=jcGlJKF},#/K,]4B!{Rot]9Tn&O=\.v k.D͔j%֛ O X (d;+\-X^q\L̼L #JBíjM|\G V@ANK}hTفj'R-L"B!ΔJ7OJWOvqUJ(z@bV P"٤+KI]x+j4xO/aU[`Q {>e/C~mGBq$NIkD^?'~0g?OρI䫑 O5 Z.[(fo\V_g|@^5뇐^ֿ;W-׹B!.]Tݼ".׾41vR!B⌘9Z&B!IB!]C7c}B!8KR3(B!aP!BHB!B!:DuƒIv͔B!tàBh}~̃a'N@x=B!.0o<D! ]]+>?1 B!.0h~u3 !'? '0QHB!({J7qa7VIA !BEm::ժ`'}HB!.0h u~EF0@A"TB!ĥ6!GQó4ǃdA!BK9 |,@B!.&2B!A!B!aP!BHB!B!A!B!a_x]y>Z_{k6>!Xq4FP(X(e'BH,)kxnA"&iOmv_& h^xel k XvptZrZ#iJvNEO7cLczn;ڼhsS"i<.K`EL!)H"I9*Gd.fk.1EW|[h?]NJ2Id/\֮jY <NB3Y;A^~ InsHB!.0Rw`4G<Pp֛и8Jb ?Kz1y*u QZTi)S<4=ZmޗYOP.CxKeT=qO6)Ld>|fQrT:Z3,A(3bW C8l ^ib6w@Vߎ+PG GmW>هO~} ꣭PB?_)@}mj Tw"(fq0 PݯP0R'O 5 21PHd- V ڤ,NОdA/a@Cz.F&a^ {=M\cGOXhs`J֘)r !tX\N%:X%0(ZoL"dܤp}dbAxr{)ܤp~۩(yp^/q7hNG5 VLw \ru$;Ž Ŧ* *~0/< c2rB[PBi<VPk_a%c#yPŠ9k=\gy1yHv#85)G2fܼB!Dĸٌd&_ Ao V;+v9LG;|sHd(>EP,*V_<ȍfQ>*_Ice%CtiST͙ 03/ 54դqg^?\ !-(P! կa(d愿 Lg@HDv=ɟRH9,BOS3( @)XMM7פIUU݊lO"23ӼƎЦNQ4H^|nOL%Y^[cs>̣yT+&̂M;TlP!ECQLEtS͖s so,z{ ]AYRؑE p?! (AM ã[P氫$~?}P@PIwcb{zl6@#fh& skS!Y(7t 8nKRs# A-!<eP7ȱb%f3/?c:w~8uES P` @ Qܸ3PBQR$Tr[Sx+'Q[U(-ԭPԅD8 +DׂVh`9PѵeRh0j:G5&TKB!Jr]Pyf3 /0tF >ƬBӨ۷Ѥ ??<4VA,*3ܙœұRˋ=xno w诽#EyiEȃf-n9*>[AYp4@LA(-@bO@?{UB});kqssX[ I{ald#Yf:QG(A-ڷIL^Oixn-ޓԤ&:3~ ?>A>+q:QR8kЦ|2Mؾy/lҞq;hB oxQ0P]uؿ=^K*F!LgѰ'A1{6nRh`?|kWAnV:Ά0rIth&N `U(wѻ$Z$c_,Ƹ>>>L D9qt:u&W6M&t( -Sxf3zۏ/[Q'go +Q ;1ݎׇA˩XotE"c:vA&|x2BqAvy,u,W$8Udd~8UjԴ[}jJZ~!fMQ7_I'5]?6 7Y7-R̟K~0:ݛyY|C,9u,X@y7/'mp~.GMbhM`ɨOؚce4GI!(17tm=^ޝw1_-*Amjk:۶W OjN{zLS!DHtjp4A`*OEѢF021ntLLÏAQih="U+ƒKk:/QeJhԢ2dB!DYVzYCѨHmX|1 'B֕;RJaԛ\A,* :K7ܙœwC y5'Eg0H]v/3KjXy[3$#*On}*n3MFgoşkD^?'~0g?OρI䫑 O5 Z.[(fo\V(b2j$#!w8O܇[3!즠낪_j0BLIaNjL_x ޳[7!B\ZF XAA3|B g4_\Mԁ$렕ݗ2x>ހk3v%*cU^N3v4-S :%ѣi&Q}">n='<x9TD i|Zߨ0c1/ƾCb?{.?#/7BQ9jݻsIEN C4=ʷ.ܼ=d{ ,QVڑR]G5Mk ףSS7߿z&漺%4'y\ܞNzFz$,Ǝٔ Y:F^NYLAh-}Bt:nxO6Pp8C4%wV⃨$L#=c6kbu뱶Rެ4S 6;WGnC?i89L&Nm]"|ucb~N/&E$MEiU4V,B\aH W1X59] RFf`oh'k\e3o<݅fmRyy(o7yڍt oڒ0hQrPb#,PB ^Zeπ1O>HfAxB!."ӆ{FÓDYi9pFСҼe u( ˟};ĵh'Ս氢f 'S%HA NàfT /0ޘ] (9@3c~@ШNXZ4jQ@En2!^7?Ě&[^Ʉy 8%ơżVlb-֌]㭛"[=k7Cse|Ȉg7P {;XiUϮ2VZ3G1m?#@,=WxĢi\b)#of}_=mb=&Bi֛X!B\\J7B!HB!0(B!$ !B B!B B!0(B!.UڐD R8аT%'-BQN͠j˕][ų*L`BB!nkbi7X<1s4ƅ#[8UB!.0h&jnWpć'D_.B!`,'Jz&ĐrB!(JcT]+2vdx]zL@"Bq A( 5k0%B!%Q@j]=?9B!ĥUÉ$kkoO=B!ĥDB!."2B!A!B!aP!BHB!B!A!B!a ǷjJ4 .Z Qb6I{ _k*ӥrOX6Ʊ(coj(-F[?`ٱWQ*jr% !A5NY$Iүi81,/ aIˆ]\ AVXRFVD`Ct(z7_M?D!H0 R3X+[!#]ehBVfX֔L#S'W{۰CS^gfRۢk<˩-+"P"`qc?N'8]PTw;e4F&@dy9>ߙ8\B!(A(=#;qnJn6>6:vCT;yZL0'po] 0 |V(:<&Aph&GVetȻ to%<0@~Tu~u'gܿ7܏\gc 6}>-:D5@{IeT26 cYk:y(jݰN|DiPơV)3ca;߭e@i4f MѾEcMTǑ|9,q}93cCW%k<bOf>֮d͚eh!B:5E(Vb_&kz nѰSѱ3XI:N|~JX0oRp,oi3DARxF.y51#[1+JDaX#"?UQ~_FLBkQ1u 0%?dMd̙(F@`9ԞL7HU.6-ݏ#ۍ$ԤÆaȘur !,}BMLn:biDU e[ Ј:ϭIWwh!wVMk@aKQ s=h}BQ0N6;*%|P\ CPQ[re61`QEnckvm4\*D:4ȑ`!B0ǯi***/&Uq.7\1aRsXk FL]1Xergd3|!9GP~v ]v&RSԷGI4 Y PP,C2c~EmfC?c9v"CGhsKB!άtzXՠr\_+),CJ1aM*N jT vh`Svw&!yw>M*QjB&6ϵ 64/fh1"C7Ei%1SAr~dAsoU_CEh71# !*Eytfp4F+&ߗkt-!)k<%a45*Í !Ҫd)InLZ ήRy]cf%?Oۏ:+&xua1{>?QE}kე4Υ;{P﯍rL/ڹԋ0)CVw>ydcnre'dJƳoaOsJzko%FӐR֒+׿BqS .J -YqSOȲ4N_6H'g3XV*P#.pYuJ6߯DiSmWBA3؜ehBG4Z֭[,E؟bn1Q1bq/6_ih'w ሡb\eoiEtfb𚑌#\';=hNu~n%.@#"]^ovz%JsL+,%X._:^ӨQ#,YB5, ;#J7 5ode܅fPP.>hҷ>ry?Z?ym2^X~c#I/V\!Ŀ͛7端"$[wJ Œ_n>2OyO  t['݅>IG_ׄu 08_DK~>`3/^EU$T 5LdTbμ~x_bgm۶|gյ+9XH,Vl9>2:v`I]LjS6lii"8TOZ|ܙ<8DLv5"4- |JD(٬Sμ\!ĿcXuxh׮޽z ZH ! $De9;<;IvZ YE/Ç7rvj*^?;,4iDt9u`X7O^u v v%2mOX_r!c5^'ڵ+oN-<SY14yp_YGpmHg/ =VIx]$x._wy>Ĝ| 1?J\!ĿO|յkc۱ʫRB!eR3h\h^頂;2BB!àRJLmEc݇X! !B\aPQٿ2o'u.`@"Ӝ!BQ3Ca6e\OaK [!St1ʭRB!iB!0(B!$ !B B!B B!0(B!.U)q1 l<2z?V{W#'xeZOUMWc^X)VD%/¿-]'^wQ}l\!ʪTH$Zc >\O7&io돚|R8UKMx y#nPׂ`LS" \>jt}3r}pM_;9~-/cႾ VD 庞/0b YM6@ƪ7xu⋼X<]BqnaQ; UF*aO"4/˲s7ۥܩ)ڤ\%Jr~?[*~ֻܝ2A#W_0EHVmyxR:~=#~gasezqu ^pvxJ &ëz9| ύ$w!G!JAO_8`qqXz ? Q DV+40d }ڍnÍasq hsM<09zv!4Y~ +Rb:}F5/cүJ@V[#oo,s1~-AF6@jXeyġڮJQDaƓ`Ru @e=ˇ&~:aX'4\xQB` LsxJTǑ37gh<6/ㄿmҠ+;'[ptjۄarO]_-f@ NiR9dӢYq%7v&A(w~:`M]]+~ׁ%̚<.T!80Os`>s W)jUn)#ut|?)~!7)d Xvo(/Nl5Z{L] 6|>%(iOC9 ,R!POw䦧 ?gz7~xcQ)g@\s( Q*Y0AE[,XwXcE}uV0|Z.h F;~8:e03̌](BQ!K_[)RRQHD?Bl%.m0a̘19?F0|-s?s}>|G b6& }atTd,m,o)/n/8'\)ks3wأ?߽k^\I1%GsӊزOoKl'8zʇz=ǿZбH%ٓg1%/e},fX$?tɿ$\.*O@/tJfI3T㩁!BH3~9,enT r/st[hj F?Ts{ǁx+'f'I scEz6J໏WrPE-8NGߐ~__T-g13z${xa' M7Aw@"HG9IDATu-QA*Bc&HmsN -=&KB[mS"E[HUo=\Ej3yUC˻ ٳ籵D'ǡʥi B6$dNBjؙ.O7!To%}vb3z &tnag͸_9VÂ,ƳDZx1}*@ KQnluZS˻_BÙuc'8oOdfvgPP#ȎBT 3LJh3t&xR*W$+8Sy'1TOaƴ pM=%λY% 9K`o^8 *JH~ ,ReϬI` 4dߊ(Dg&rfSXʊ{He;M&;¼ JU 7g:X;ft2HE-0o\f̓-Aq/g xn$N(mصT7}AD, c̙a(=^-}3Wҵbɛoc2V҅/jH Gi@@0?GT?Bup6)>LeC `7BMf}T(oWmI2եsG5Le\[FN22?n:<ܥ'>ųR&S7`Ϥ$7zI.aF \~:x;/*zKxGg `c唳jg[ _k NߑnUxdsEDwV3;L|) =pvYBj' NUW܏ D>T g:iH[ 5|6jHg[ D:t2DK/;wKz Lj>@f\]dedvOP !{aO'>Վ/ ٻXL7YBCL^ϗ$K-e/8ЬIۉ/}=oڕ~vVy>^EgƤhHk 9l6PR'׀ZAF ujl)N:ϡ|hh}C=jjP?w_[ӐfǞ tn0t${FKj"\]j0` Iu;/ > B=17 I*Hee@!,Ir ٷ3}|{${ïvDG^f`҃\=2c|Kk]^c۸;0> u)gFBzK-$!m/؉x֝VWDqin1N*/d g    Ŵj=h% p- AADAA@2PA-Ň=hh>?)n<@؜Gjc6B\q:aTݴ1͆9BHn] E)ebG5À׽/.26bT l*К) v?+$QiQAЫ>L|7æF/?t1~xQ/hv6bG?7OŻ8~$ۧ>:$M#Xv%F&@38Ss |<W{]7Y[Snʰ1#rOe,U@ںw6z;4pN?Ԕ z=i}e{>.jzIЖ?j$xARxMV+ r>k)sdԨGvaHO{040V!{[ / u&* L n=}YfLƄl>١2G{ G0\/TW:  :(~|m[0wmũ*INf B-&޼vq@ =՞( z0P=ds9 gzOϳeW3r錺>˧%Ȫqp$ldD\x=܅ W1p4"|} mmh*C|iVgbQ }gL=xu_7f0$ zuÖLŨ,;ri:vbuOSq/ՖN3QSʢʸ{`/6^<؞ >ZGnI~+s$1geL7ۣMۿiۆTr@#.<@@NT][~${1%ԯ9Ruب uwcKSk`},*S|JIBdۈB~ sJA>-U'Y֐u_!ρQV:{NǴ7bKv pp&f߱Lr8s`G25'[LdXYJAޑEa|8 J%ӃH!K^ɪ;arh@R]J$)? I~d6 9oͯAy߮B:ati1$B1Z?Sȁ8 bAe4qqv&KzImFәHNe*L_ ?MCf_3A, `Z0z:3=?|2@Fz]IdKQW:p,!|77D]E$#Z֗.Y$ޣPl/ V@WAXe y%_&8*$6$azhKH\dq$ @oWWW B\( 0fO%8z,Ox#"1Om"٘ X+)}^&?zg|`!kҮ3/z$+#}v<׾@bg; \zTԯ`@VdE>/y*&a-e~l"*b3+EO:[Z͋jqKyU$qy{Q]lF t5zheՒS$*6oG&c C-j0݋!nlgOʏ'0×{R$n\-P˹~2bp^AA\.;s$I:o#n{<$t }w(zqډWYzmܩ,:f`OXnͻBq}Lx^:NZIGENJrY3OdMxoɟ. a@hp?CR%6gVvQ! sep| U6#{r sV8V_F.L?f{S>}dtTZwhpCN8cсٌ*D'oy9mAZ 9r1Jye^8Gpa65>Ђ~hN'zJ|V)ra݅%Tߑy@#H 9}'Ԣh'kt'&W~Yb'AJg A-oCzJŽ#1ojԴy_ zeb9? g)j>DrBV.uABH-94 $Xَ9/tf7UAPAA&*#3@s_*AY,=cp %]&mzA:s-AAChAAdsxoWILVvLe@?΄-+ ByAWOCؽ4 iVlٽEU,8a>o'fj}~|<˃]eDoʦiSk\֮b(֯Z_C,BlNLV}&o=hAxm\OhOpdf^9i֮X?\~[0+WEe"t+X{|&2eܕl^ook; %s--kl'fzM@s|W% &oAPAntg:X$]"e#%Π=#ѳl$07Vo~Ycx9_1:ztvh%q Z!YȩLWH!KH=;^yaO~D@Dξydbo{qrn Kѣ&jr* {_ηfzwQť\~X&ds. 'm;`)wENs9p_\wˌ֋5.e|h:wһ4)4ڿ!ge:5_9ӃiNؕ' , K;Ɵ摞xk:'Su0DG J&3sH}D[ݕk9iSQ GumbyyICAN ;$Ax;)])HkۆlMllV]/ $#6S|RbBoJVQAdO6Lӿo 4פe5+{  aЭcM27zJP3#Ҕ&eLVzQ?{ο~j6)—'7l-saPfBLw' _k!m`>14mwh.n4TՅjHί._fMؼM_=E'TMA({^# 6MLx*V8WjN"[Ce_ 2CDOc?g2= ^O#˞Ʀ0ȥ4G6DI !AIu 2ѹ~ULC N\-^c|l1 A~pfށJ{5F +6/""֤KcRLöD2c]^u;~J}c5kA3 3'?@13 WvNKWR`F#OI03:hvo8^gWP`G FADPf>1¢y@;r򋛒.<ʇ>q ɉ3qoOG#yTxƭY?M/$& #SD5͹ώ(>7Z\*rc+)>//*Xc O[Ȩ)1Aa Ư%ٵ1#b.Ǎu@d>Qup wg߈?fæO^xozvm> +S['jŎ#  &&zJe1cܷ| 9=1ۯ\E MF>Ӭ>t':*aM" - " w՚N  pۄA`h ]늯{A%ӂ  wjIENDB`././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/docs/_screenshots/screenshot_pydoc.png0000664000175000017500000005303100000000000022112 0ustar00davedave00000000000000PNG  IHDR&%sRGBbKGD pHYs  tIME  30ﵞ IDATxwxlnz )"METPTlȵ]*^+6PQvQQJG@:(5@M?] |?(Μ2UZ;*h,ABaTm| ByOB BILB!@nDQq\t9Q̣+89D3?kKٞ-?61Њj,&-'N+S6 o_](/N٬ cBV8=A1gdWΚOx'i%_+]g@߇{}<'{R4yNPv ?4*bt5~"JӼFcI'g_aiT9Wv:RAU vZ 66ڍpPRq 0)(9FFbi{?9Pm2?NXO|PL<lWJncw>Enf3NBBJ ޿>#ٱo6$ /[ե8^Jw\4PA)mtg.-8SMՓuSUl; eN76Ui꽝t`3^ q`&XD–4v`K厇\Xr8VLڱak.Ԇ͗™/hEASӤdOz8T 7q#'OV:i~Zy5TCs4گK6`Ms|8yZC'N#6ķ4qp{U;rJ(|xLe<'vͣ`7!? g Q`eǏ1bpj(6zX1A>Z7O*g/O8~^`q⯩4 s61v#sRo99C3}:KE/S-[G<(WC_iAڏW>/\4@Ś`q5UbbM~__FzUIXra9$X6Ejrb~ڠ?>'u6PY $ 墁 ߿CLw@%0s}Kŭ+x>뿀d)O1x;^~/eB~h1]C 濟1\|)MRMA5MLMu8RA_Zt!.jO&`,uWђ,5̂,X1 亙:m] ƌZfKlԶ*ng!pu,/$C{;=Ƙ̸͋PM-lE!6]A/ Iw8iP\[ƴ~,$L<[ |KtY,W:<`>AֆL5*k3IzF<V&lf!R\7bQBSfݤxZ g)QVN)ֆV00t~7<&ڨ[O%& zBGemާs`ELLL<; H3zk()@މ"obu֏SZf;l7ëaGmWp:_ONnPK!qu-4(O7MrS1,?6Ńg|l_d95@qX+h!F ˘;ok4n~> #``WO{/ 5su'f[;5N}?/g# zshwAMTq񙤓mR&+J [E$t4Sp;6weB/TB Hp 8tq⫄(KۦOtW")K9nڱ%Ioɶ ⣄il>~QѶ!'Nb~Gter&њb U~ ڿ¹2 VJ&EA8:T7:\ERӰTpHGi`1 Mx/Q{czYg=>dbb;F-fd xWP jC5f1X!JEgcW?xԵ= {;9_12"~^/gO7 :7Wh~9kVE~@#_ǧZb"LddxlV}A/hIcq\t~|~2`Gř&K)`Qd)7Tוo|hOm-Xۥ[ǣj؂/cb83Yg/ 'B}Nh` `.? Ey4+EbQ(G+s_.qWoU3߿ʜܬ-xn|VS(6XklyA bL=/[TCAՏRQHU(2/R/XSU:5Ɔf(}T~SP UZRw"zٻ ~k=zTWB6*\ZIJjMN~&腍g`LRKşQW 2G1]X²m$#;DF,Pn;54cVP8U*V&Z#+-J؝/ 5tXЂM`GD޽VR4iATLfQ?J}ĤlOn~u+-nKw3w\;n@VxXj'^αp:IߤRf=zBUH-(@+7Pa LiN4.^bmKɴ2?4%2~HgEAmŠ7z/?=}Ha8+]Px;YW\g[IlxU t4IN.[ FcU,{Տ8is58QW_P Zr|EwƒngK<i|B|>/B׬áel]b?zרF }'l{Kn`x=&c;!gV 6J*Gym2)KШ^dPI.:h{ uX4Djm;ƹU 2ʋUs~lflM67*D.+=9ILZª S/'$μBD1C:;pvj)sWLdT}~S8 ȩ08Wj9j$#y~V(cgΩ\V*,1#N)+&3J\s OR9?X3#+&GVLVb+&|tK%1B!DUJB!B!$&B!D!"(|]X!]2=_^͵%2 2g !"<( qf1,BZZp Mb,B0Ebbl|wOH}S3QVzwQ'J,T.el? (e_zGcrȜtwɐ)yAB!NҊɱTNf`dY!HL3>*y WqVl]n!~M'r+GQiq_=nGq1Wt/Bo娜qo=iCʭt+ƪ8l(E!1zm]Xd!Y@ !d$&B!Q"wZB!B!$&B!D!B!BHb"B!l4yj&~@vbt϶f;5/ RʧQ -!W7HE"ZBպuώ3D;›?)S,fAi&%e.5V$~j?4?y_\D~bzMp;Wy!׼z+^ùg E!W.9_Po/jѶ_m^,c>>|l&y?,yV/J?49\UR&s< %2z~_BY19z!g9|MLdb$ӈlW#ILI^^v~ĽC㣍Y?tNQ!;cNe9ܽ{9V3ŢL2W3;ht f;rH&XNJ-,~ iPSSzR?R m˙vu?X^I{3f=NZGjۅ7G_u?2cjnx:ƣ#OVCU,wgc_c2oX%)\_Ȩ+xG7}:u ߭yKZ̩7n}郡V½L2[X+4>B?w+]4٣87VO7*?9WL2J7CPM {P|{COE5jozNJn QF5?˷_{F~L*/g~iϝ7g3}?z.cqGf\aOuK]ȽxaB_jh>OO ٌvcVLcrb ah9}ݽ,(b\X^Zi5&W_V`=dC?T/87)3zs]$c۷t:_(5nc?3֨9_{i00W{N >*c%,_M'!1Q,\ޜoNdj{ְ;͇8z-ʊ$zLEt7+?XA?8ԟ {sY|L zv0rM0<.'cz u̜Cl~]CQt`k^i-hB'dBL&Shi |ɶo-(qUYXC>|{g$J/8nT,U]mKܙ} fl̢ڧ+ =C0(bVRlȉG`363GQHhmcw_&6͵O) y11R&v,.?:⃔jmIS!^cщBCD+l2Jsj$w{m|&1jcxz^¡c 5 LURV*>a/Ek$]V>׵Wf@|qsVTW'&Sd?WK͐C>юNgUInN+t{ zվ_A!*!1Qc;{9RpՉc1FYF|'6:SuFo]vA!%*T9} [Gi9;:DYy~wLwa4I>HauԸVnT~;fR>fʗnC=k u[Сk=J_>jG Q+&6 IcK .Í tvK)y{Lf1_W}/+ V]I<~T/oIqC)=Tdh3eb8/6/dtMi3;j` lYȴEs1o̧Z?E(qW{Bwuvg6n6>k(g{| ? |Ī\Y})?z(`ѐ3OZǪ ]6[.VrCWNjw8q*r"ukgSFh\wlܾŠriѪJfq󂫹L|!WQ)+&U%Ò,Td(wẌ́vʤ. !8!*Qoݤ^̗bv\HBߩ+G! y>\!!BHb"BILB!NnbYluh !"|QpZZ>l;c6kR487wlI5Vwf99?y HBHbrki`aݥ 㤪*UIda^#O&p8޹_~bKY=.Z\Uyyu>KCB!$19$.]V?%'zLu*U6Sd͈4R/\Mհ+,Wn{ĞEH/ IDATp;Y\F!Meo}D'*!+U:݌q=bl3/UfLP-V!N2-t{0rA],_EIl{>kpbnAQĚgR!N .0''R(fW(eTi\nL5=4;M3O:E̡4>UumG2B2)GLBHb.q] <0.m>*79U@fθ"ztFrכ9;FgSu7GK~Dz+eInJho槌a'B!),Sժ`*Qj Hg|AʚzM^Šv19sRI"SV hɁtT!j%Nj:t~&ZC)JBi&K&(oŞ@OVN>SuFo]uiQuSqٵ;oL#:wA`wŒ!TWr/ yfmuY%8q%b^\@'xu6iΣo34i2O!TW Ϙ!B5Jz!BHb"B!B!$1B!D!!BHbr32w BBY)<=9vdΖޔg:IsBbo:7'4>sHBWkdޜX:v aMURF*eBow3.z/'W2z <绥 !8-ES}yr|&ab$`ZKoQI M(nSRd&2ܛa֣tfΖؓ9d'g]O +Kvv??b+qNYB!+&s^{@A*nphU/=xB%&&3)P陠r[7 Lg|AF aتѵnksf◼4!+~=gJIB!+&AS ƪ83[&g$5M7a0 uĥz-6jtexY9j uҭL99;Q9i`ъ^7N?{ ѢCZB!+&ǻt&eS$5NK&=mN:#49}*M`?S|vSG80?a!{% 0ԍQMjhI E_ tdQIRPh5 9TFVϤwXjw³)͹BHb^/'6+՟JgVCq)3,@i&K&(oC=9;rdWY_xgmZ:̰X({ @?(,XK@d{x9=~Šo9/%7-yq9McϬݗfom.='jLU(#IL?kpK_ *dUƞpT -MZL4|\0-vYlSk*Yگxn8  Щq vCΚoX;%_!}dqM[鷿(gCsAˁ !8KlK*#Ao_*&Xo种i2bՠ~c^-6٬d(jJk Zeq5π ΁) 3Gu{(qfoԝ x" h";cZNJy#`&;!UHt~XF;~Ɓn6ZL}e|Y' ;88=̲p]L s&/= s{U+>:F`>޳/]ً2B^ 3 n*NZt3ǐvHdo"!u΄9:'r)X|lQ*&gP en@gmV6=GK(OڜjN CݎHn{ 5&Z5OGz+26óh6k޴mr w}Ǹ8Bq%&F8Ja~CQ-i_=u^7wSe5V {~=Wʏ=Z ɱGCŦ28TFԝG7ncYxL;-E)QS^e;ѱEjHRɕLBn-=;2 ,t TRxOSYb8J5W GO}nĬua$Wxm~3U\ /bPXwWV5hgWaֺר:}IR"KL׺H+R0v0-Dލa38i )mx㛩='ax xylP3?a."-ҸMt},'g2n̢\ƀB.11 zΧbr/|(!&WL_:ׅBa^2q /ꄟY+XM5 VB?:z\. o⤥BY1B!Dv6 B!dD!!BHb"B*+*1Q]ZmЊx<2 !BSDc-N玳UpdH8:/=Cb,B0Eeę(7ٹσu`OR$B!8yE i>j*-1B!Dg{_,4h$1N7atB!NfbZZC9Gtq?Ժ.K|G!'-1qЧ;~%|L!ޘ8#F,Bl;k iq$49$B!OT~+!Nt|WG{`ŝW\[oT5m6]-Y%7烧INrG857xEݿ܋7<@{,.K+W-㧪S;U|EhyVbzr|N׫Aڑ '_0/$ϻ7ajݿ^ʖty+xSϩߪ?"osi'Y ٸ7scI.gPtu ,[~X#3vfc|XWSSzR?R m˙vuLΖ&lZw&~+ u|uL20KUo2z2fYӣ\5~2s3(] C0FתwfWXTIFj&}rFʯwhdc6ؿΏ ~ f;rH&XNJ-,~ i*}|G~<~d?;sc3> LVP{a/9g'Zਈ>͟ʲO6^9)sD[?(*vDQ <ۗSTsPtؽsx]z_L\ coi5&W_V`DeWK]HFݸgryFB8QqÐ5㶦~'ܺo=\ϡ]y<ʭFxƬ}JzKxf#K:;3뱁\Ҍs[G&W6c?aӮW>Q,\?i<2f3պ[3jYŒDoRgvIG&;䞃P:/W]6Cdنw4yUQVK&qPj2n2vˠ4%5lڿϿO}'JjoI=7wP䗍 y̚BSrm5+ɝ`l,1v1o,; }q {sY|L zvsIOTL|eۍЪ%[N~L9}&Gw#Wү#c{WRO 6~C/e~l/}wϧ=Q??G:~#n0yL^ꍪɀu z|РCԇ6NML [9 N'wqC-1M5x>?F(T}e(b/V1paɤq5HzQOP^v~%9oG4z1nkǑg9OEZ$jE;ڏ}գs|qo[}EϑP| )JxbpֳMUEPB7'm/܅> c]b;yQ2Ț2SᅆpWcxǖEaD+o62'+~o،p_HNBfհR ԋxn0x*}9|xvx#lz^ި(BLj%iPl뒤4^M?9x{pE21?dN~U"'k04hm)5peQi%0F~,Lf-FM4YYy~wLwa4iY (j?Â2>tKJLj=ZvS $3U\gf5i,?Oٹ[PυCBtZG(5/Vs8qQsgT{ ;{cn4%Ń$H緈7nb ?|㴈 gGC-ff`f|\<sˠ 1mQߝe(ŹwQɥ&sGe.U[|y!3WClŢRrym:V3Y 75Ge^>ק/Xu`_gU?}xKwg`˲;Tș/mĕ[ף[6.=Q!yecgZUl4\Xk4bR>ʚ9%{?tC/zF#>TԂ9*mWV_W$ƦQU|v17qXE ~2Qj=w< ͡-,A0O͟">Zz_F"A×O<>|^'͹ܿ"B?d|aS^Ƃ JkgƮtbk+g\1|s%e!ĩ"!B޵-wi^ *N5%VgdJR"iNVLBQeȯ !PLӔ $ BBdD!!BTij).LNwDó3[֥B!*511nMhS m}A7 `T6MIeӔjl~1yn?(@Vl$chz!xϮ5.MS}aSٙjs1E;Ës<8Tv&_:6ڻՄ6~5ޛ'xPwE7UovMh:fIF.{LT')IV4\wouU;+:(jo|_|:PP.#1/|u7 z rs ˜] ޻jZtBO%(45T{WRO 5)ӻkwhWu`K{Zũ. y)p7m0lX fۇk7N>Ek#h+{v{ISz޹q>^{5LoA#v:@&צjF7a\2!_IL4<ϋAsQJ02S~>ל7ȸu%opg5<$7rds~~&^X]ӮFx?@@i {ʱ6$%jToѨM=Zǡ֏+3PӨ噔oQY@?}W{؇ ]յiy M^»\v)Z?DqBRë|R;b!7\b AQO6su ۊm%+Θm__ŏt^.BDKf=Y)?i{?MƐyLL'^dnћ5<;ONpGq.q+'$zaW6ԬPDPņ4Q#Υ݀ 8լFj+-ZO).{6Eh11_%0 >D{_2=P%ܸŸ?E\8xǩ3 XfdOjpzG'y]߈?"|ӄ;F#ҟ0JRixeUIg_:l.l.("^`X(ʀ,WEE" . :l2aG.{  ת!pT$8K~ӧoA¨U^#,T Ns^UQ0D%zQ)$9Nٯ,zV(!#wIDAT=;E]d2V 0*nPO;_ˣh[=/_^_NɿΩwׯQsh % uC/5Q}6 =ȟ%n ,|֟vNK}x$ F|1ܚ$51c=PBM'8 pk>!>fJ) @) 43a$Ec _Fޑ\|D`T~HbГ pn=Ɉ_!vv* 'ѽ'+pRv%Ս#$ ^-Yw=?R̨T㞠T߂m8SDYz>>eKv;B!%%]q8Y;qg䭔 j`H|ޭKEk?A[s P<0o|S_c֚tgߺcSQN0wd%^_:%G3y"b"Dyk7%˸ (#9{t1@_:,N4gn|݆S=hS!Д6c1lnA5v a%֖-sb 5YGlZӥoV3" 8L%>s):E|!Dm`&soz6P0f5lL \0p/T+u:Y+% 'z.ؚ3jbxSws> 0>TG!crCD!o.,BZCiѪUwLI!B\5!B !B)L×G` D=4ߑJc/xA휿v)ErSQMs~d>dnSEwF ؎}$?BZtLL #6? 5Ksôi`. P$Sf3 qe3&T[UH=Gv| ac 䰖Ht~ seGQ _9,Ϳ4M:?a"?&9Sʰ$=F ]eW|j G7=lNͳmC/09JA,a~؄ʶ;Qy/ɞCPuϏ'jT=U!`{>(LuoL4P#:%nJ&L6X4}ϙQy{|2>RKrX 7|>;n'}A7oFB45edl؋=t)rWT /MezǙno˻iȘͥgzϙƓ[HV.ϣmU{ʶ*=HNsX63Ι!p@w??> rTa+SP{{~סcb4mWchc(oU)*:Wݣ5(lFp+ff@A8$u'_9?i(-ѳěJIɡ@ȻUc9T@+`5ًo~JtMo8䧰xvr옲K)8gt| 3ɪ}r|wvH~~VOgO-SnJCFd.o*s@PJŹ5xu<_߱&J`zJX~f3&u&{y  DYz7;# ku~5gTAvF%v6=n'dZHJW=,^ԃfސlvթbyS)9Qs'I)>ط=._Ǹ{) 2/q(S@,&c]-^uL,I-dnSEwF ؎KB\k115d72.΍Ӧ4@fL#(=RI̘T#&&1gK6deJғ LyR^Eb Su.aBQ _9,Ϳ4M:?a"?&9Sʰ$=FB.w4L-6ޅ#pX$f C^R\il;]/$_7'KI.pϲ%hSUԂZ0lr1]"CypF֟IJhom{q!gw٫g _].22GL1Qyp*2p%+*3.޹/0ySwngA+yu.~m힛y>M"X]=XuBT?cpOk~*J@#ww>F2M4EHNI S:V7h}_X0ڭĚG,{4,S`榡44R(@G:=@ǦIrǒ'SuiJů.XFʧS91D$e<(D5ap=J?EX ο Vq0.$?1a%W|58^ D#/|[:d̡_q~*މ=z&^9hǑ6hP &]8d뫨t ,8l/K>,Ԥ`j{@j r a)'`~,L OSEAi[:ufꁚ bbƃǯptÅKQq2~%:Z(F5#`XCDR HL˺Z5A/{/u+M&/nI}lpW}*GUBT{ǔPd|>|IL[Hz:YԦMuf2>q'3bAZ}Kcؽhlڗ͸]J x Xnױ:ma>K6rk4G3@Yʏ& .PƖ# ?aՠY6%ilKyk^UQϿ;co .Ҳr.v櫩M&jO&!O(-Zꣻz@")Bj:-!i>J~&q`ϳܡ!B\+1B!D! !B !B)LBQk?P@IENDB`././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.3863792 jedi-0.19.1/docs/_static/0000775000175000017500000000000000000000000014756 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/docs/_static/custom_style.css0000664000175000017500000000025700000000000020226 0ustar00davedave00000000000000div.version { color: black !important; margin-top: -1.2em !important; margin-bottom: .6em !important; } div.wy-side-nav-search { padding-top: 0 !important; } ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/docs/_static/logo-src.txt0000664000175000017500000000017200000000000017244 0ustar00davedave00000000000000The source of the logo is a photoshop file hosted here: https://dl.dropboxusercontent.com/u/170011615/Jedi12_Logo.psd.xz ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/docs/_static/logo.png0000664000175000017500000007017300000000000016434 0ustar00davedave00000000000000PNG  IHDR o AiCCPICC ProfileH wTSϽ7" %z ;HQIP&vDF)VdTG"cE b PQDE݌k 5ޚYg}׺PtX4X\XffGD=HƳ.d,P&s"7C$ E6<~&S2)212 "įl+ɘ&Y4Pޚ%ᣌ\%g|eTI(L0_&l2E9r9hxgIbטifSb1+MxL 0oE%YmhYh~S=zU&ϞAYl/$ZUm@O ޜl^ ' lsk.+7oʿ9V;?#I3eE妧KD d9i,UQ h A1vjpԁzN6p\W p G@ K0ށiABZyCAP8C@&*CP=#t] 4}a ٰ;GDxJ>,_“@FXDBX$!k"EHqaYbVabJ0՘cVL6f3bձX'?v 6-V``[a;p~\2n5׌ &x*sb|! ߏƿ' Zk! $l$T4QOt"y\b)AI&NI$R$)TIj"]&=&!:dGrY@^O$ _%?P(&OJEBN9J@y@yCR nXZOD}J}/G3ɭk{%Oחw_.'_!JQ@SVF=IEbbbb5Q%O@%!BӥyҸM:e0G7ӓ e%e[(R0`3R46i^)*n*|"fLUo՝mO0j&jajj.ϧwϝ_4갺zj=U45nɚ4ǴhZ ZZ^0Tf%9->ݫ=cXgN].[7A\SwBOK/X/_Q>QG[ `Aaac#*Z;8cq>[&IIMST`ϴ kh&45ǢYYF֠9<|y+ =X_,,S-,Y)YXmĚk]c}džjcΦ浭-v};]N"&1=xtv(}'{'IߝY) Σ -rqr.d._xpUەZM׍vm=+KGǔ ^WWbj>:>>>v}/avO8 FV> 2 u/_$\BCv< 5 ]s.,4&yUx~xw-bEDCĻHGKwFGEGME{EEKX,YFZ ={$vrK .3\rϮ_Yq*©L_wד+]eD]cIIIOAu_䩔)3ѩiB%a+]3='/40CiU@ёL(sYfLH$%Y jgGeQn~5f5wugv5k֮\۹Nw]m mHFˍenQQ`hBBQ-[lllfjۗ"^bO%ܒY}WwvwXbY^Ю]WVa[q`id2JjGէ{׿m>PkAma꺿g_DHGGu;776ƱqoC{P38!9 ҝˁ^r۽Ug9];}}_~imp㭎}]/}.{^=}^?z8hc' O*?f`ϳgC/Oϩ+FFGGόzˌㅿ)ѫ~wgbk?Jި9mdwi獵ޫ?cǑOO?w| x&mf2:Y~ pHYs  iTXtXML:com.adobe.xmp 1 5 72 1 72 200 1 226 2013-07-05T14:07:80 Pixelmator 2.2 '1s@IDATx} ]E-zIwgYȾB q\WG qAEtfQe}Ig{׷ߩ{_w^u[U:u9Uu.r]7y 5дyh^y PyA^-h -('k WAh.+Q>pUV||CN9^O%nr͇, 9"I\H?{vi*96d-p҉s+29Dîx`B?dۘm۱}hhQ /_/ <zSkq֒w,veYs/vQEڱn8": Nt$-C3eIláx83ܽ#GV|MqR;H%n^*(L"Q?;pR)g ! !8 0(J{#^g\w>МeA:/^~aH$FNKÀ]%PĜ)bd搙!B[*av$qѝoZɇk סp;)禴^JCwJje)!$LB0I I+\~EǪUY! y;>Ux̜?H;})#1nJ Q5wv/pȨsI v?.<oNaL0q+X5}D3J4r#BI4v(Q_g̺Ko+dtB/NHm… #[[\;)pxN灴*q5 -NxΥeK'- cQ[z,.HDCN]}N9k5u}AN@i,Y(lꑞp?~91o9*&/N!I *QNCXiWyUA㤒paՇl-vi R"7/a_3fR{gjȇ]k;m[ 2҇q Q?JV8R:7>aّ\|. ;V.1ȓԯ8F#L/ڡ,Ns9 ; Kbʎhq(8JKJwس),U^o8zLTV%L0ݸp|بx}[Km7TR: ZoHhF^ȐP:Շuc|-;a%g؎|h6= //H}&z 7NUUnz5Q|k̴i[_RF.:i cZ]ulF2vCHĊU8 Kͯ {͊xJyi%}޵XN\`q_t*W^ݹb7~}(q3kRRd~29*W,uY~[;}RݿpJ|kM`xݱc;ު][6] a=?w ?&EUUw֧*Ĺ%UAZaƞwʤTU[oUlnXNq-bzcEMTWDxWq<;kjҌbzf=pxUS{N WoH/wWGp+lӷݿ~SoFtyT=z9"+q n*yU1gϻvvI]GRAtwv/7o~}s- Tsp7,ZS=a\g6).))8VDq:ӇOס؂ [|qX#Xj뙐h(Wva±X!n~zú:ig_~milmǤ>dҥY*wXhK(YJ5K1>&=X6vqio1p}~{|)3h@/DT2m)w>hq2=U=]ۆ^uC5WuV =d`IZ#Fc9ppU_[;=ܷC.m rHc 9YĚ0guۛW֥P|yۨ{ԩ)3YM˯ȎED3[n\9]_7p9 `[x-xnjNf !0r˲cؽ0"Dë! \b>ZR:'qGQhн12a% #XG{ׁ ڋЀd{ @\8Fphj:(w`~$ڷ7OؘIޣ҂A0GYP4^ҶY#0BFbʫ'[cB* p_ٜ0m1[d .jϷ 8k?%^ Ϙ3l b?DOL$ H$Muzl&V)L<wx`/ Gwۨɟk*W9ȸsϛ떕 7 Vj7WŇ7BS 4+7 Aa3 m5]c-(+ԳS9%XtYI|ƨ0riƌmgO;Vhi -47rXFgԘ3f^iA&ѷҖ.3遆@s``&Bt9{ >rZ6VhJ eTrG;BkadE?DžgJzc}> nXh̿gAԄ2͂`UTu/:cp2~]s߄"/e G6er)= V&t#YB|ӱօ^,honX9𓟌[CN]('mz">xpxy|ڞ>b7HUƭo 1.?/]ڳvN{ê%91'u z48J:[{rO1c&B.ԣ& }PˤJ2t!3 pE_{EKTIb,S&5@? ^Q/A@guw-;{|ǶpfGW5+2&}4PelWTfmE}5@ [t=q?~mA_EH6,AO2Hұm̙_&wS=h'ۀiK|+XpVJx6& XLxƥhs$2EooMvA {*`ñyGg5x+!z*(Y_\jB>@LNe(L fxVxu̼yq;Ȥy[ֈr|6T[ t:/p| \/=ӓL ̶ț-%2&2jǁJ?׳Z<1Qerrۍf͟bÏ]o^!XG۔F삖el}:g:*nN;d_[]~ _?ⵇ@j2[b "3$oW})Xa=XTޯخ%wo n߁^.pftn.Nw\kE~ esph|t)MUVnXSe{U?2CUoJ4pRrT8;n1N+}qMnYf֦QLEld | ciZJ/$j>|>J;t#ܸ闿w,yYf\E= 'q*yrM:ZSu{utedU}D)]W?+RXnXMMaE >>`v$d:U2$;ٻϯZ92zD*5Oiۅ>S*ey@%)9;IpI3& ԰LҵK[93f_f=6:13D`Σ@P7#hB'M^'?x뭷ұmu[.3SOխ)6*p41 U8ȘyLLR?3AWd`t4'nxիlwp~?}'Z҇ޓӑ3f P( 7ALB'#( #fDo@6=8E0fN#2&)Q]XĶ_w/p=|<9RՈą=ĮM>ϾMKp r{W'ί):I(G@TK6Yiy}ͪ^v* *M04EAgh~U E0ު[wk5QMƜ1*7r:Wffai ɼ@m&ͼ(b*+Y':p3g5M e8Q"Vmϯ<:AO=kW#Ex1^U7oq>SNh_'ILF4F8PA ="`ݛ~9aƝvΈʐg3ӞS͒ZFJ1K8qKYef ~u:%b^>>ڽm۶;SD.2|*17c\՚MH7xiXnBA[a>Qyj?ϻ*OVw8o,\NjARH2J];zSGگ~(yvڅ/F08\>!fbQEI%Nj\mY߿;Tz4mڴ}[sŨ=,`륩,?,%e*b+~)|;)lxa|TI;%[vmYuyk?D'Fˡ>Ɯr_'9ϾrM펫r:DˑiO9I@)iHxsv4sPf|tihY&Kn]u%OQ[w!Y Y=Y5)It[iF szp[k1s/9J|ͿF4 'JI Du8t3ff-*x|WoxlSӧ݁S4ʤŸXa<C\SDTBTm4ڮ ¡ʟRٌG=C5_C#,cA$G‹w|V׬ ӦWH6oJYƥ L&ʈsOW8;ts˾[hj02)yJFK1|tJ|$ 'LIw~#;=:d@ҩau{tL Y<.3:y!8KZƲG]]g91CڬdS^8RS9Ɣ @t6t9uѐsSfٺfogAdN#MC1y0fL833eɺ2j:4li#8 `LD@%^^$"{ 07LNoc#=ܓ.) (.?vs6V̊~Υرt!FŘy )қYxȒHW帯<#r6y!:9$N4Id؁diLV v4|Œ3jBWHtӦ*#;ɼz3sPmo>WQQɪk?gr>Q'Xiÿp;[N~%;'n5cVƵَ7^~ve<|ڙӝX|dJJD2.ip e8Wu6?aji\8֍4q[|:[²o=|"i4M;DxI!c@3CHc݂:&,}J56#8fU N )cE_ŅrN~`GAY7Ï:|9Ȍ3qtZRA3 441.|0}vvO-{cMQűbMЎ9J!P;x%Ro_/3yو3'jS'.mݟvCKuC fuJм}yig79贷5 {j`<UÑ4v[ Mx/~:(vp%7 #6"1&c{k.(TCɫ?~֑'JFI :fHΗ ܆֯!@nSvզזXOh ʀrhǀxt~rG. ;AS}ʹx76Ӽi<<ĆuwwF:DǢJs]]4pti6*A§ >;S_O4|^` /M%:qt3yu0UA4|++ˍ'Ոm6Pq_"-Ӕ6xC8*jđF\I:X#vnCKuk՜[E۞A)CBXde ,waPGB{e]DxPqU$2 4ԋXD^!t N hE׵2^9Xd 6~$lvf(h)R֏xNvmJ4;G ΎS +]XX3ZaWM\@|TF]P%#6\bQx}Qlf(-)~o֋#U;p̙u:SOoxŠ7SvCUV+TnLbڕ{"_?͕St)C08!)t*a`>D CFY853w!05 NwsEK#DT?p[qC;ڊq $ieV ]pNwZV #njͮfe7{etճx%bȆ }DL"ȧRrPhW5Aˬy{ZF}'$mtxXv[rPxbVpیG3%t1FipiL{V l [ќ +[.OFc12^KL 6 ,Ih^h5@@GZQ#`J 54,bqޕ?wsD*: %.NfhK: knAbC`K04p ʧ =};,)EC8̒Er]J AgK/At+'\TRB;qd`@6X@po=-PQ'# A}5~s *hc: }㸴¨chGAC]C;*pW2dxO79hȼȠ/}T`̢^F'LQA NX8'"#?4ZMFX|,#z0HQc~Jc7+-Th[onSjKBPO YLAXU6mRY8xxRtD:>@NZ~R(/0Oƈ[Y# 6^Ջa0SBe3pnZ »XQR1B3bkCc$>6xj`aL|\<":H=ԭ~DvD=au}MqY]o؟E`f: FJ jDH=) mWίί_َ<읆 ƋiD "4&Ol$Q*db LWbDp~&U52+cp@V?P{N_rmp!)29_hTǍA) 0=ey tB*H?Q9-DC ڮxk"Ԉ:~LjQC^0QI~oxiw5moh: {/@C; ủꨰU> b0>m$݊*qźMxEy82PT꜁ʔ!!ksLX*!V}c쁧X44jN"i3J,viwHyGnS8HOsQlk){lg6>)3zmti39% 0oQ屒2uh"҇DVp,y2zb'n5+m )NGum a;r :BC][ ۍ9KAi{ ښNCO")L'Z@TrK 큉DF85s] ~ sfly|kXoѽ]zPȸXQA|8zheƧ$!KUt%sq|zyK>LuA>}q tBJtoYx\;l6s?#|qɂx>-zrPPU,!{wGK;W3R%t:O du+C ~ x* H(l&TF I O& a&LWR4seWEd7VΐSbɒ:1BݛX=:h˪RW/@ڣEWJYgitQF)a[4OE=_Q 4 ?s2uASV=wiEAg dy%+xp@m(Ov]8uŧz_`w ?jWk\>93%|Cb(yTYF)e!!A2IB%}%%ƓDJcVĀ[HQ*Qa~;yI6NH1,qڇ?7}M4yUh+v &&` 7nPߑć~ cTG0?Ah8I{ΣnT Mg`^ʃ'=:Ej> B61Uj{[ߠNȁ+p$| :۽=;A nY'jS]:-oFg9gpcbbTʬiC&vAM6֬L6uA]r%BN#[-;I:<@=ӫ-l2{6~Ӯy;ABl3>Cru=@ߡaÆ;\?M *% K!N2aA7:4JYN>ll_kQN_;b D[uٴN;UԩBo-{h$mk@U(~4yg#3fpSZN92kT @+hʤωDNm|*J|ÛDB@` %YeҞ$xfL1#:p*)㇟<|YLNx]&;3'" mgPqettrűA|hT*vԬDڒ1})  `)`eARP33J"jFpZPeHʫ:pV'LL+,CӟKCȑ"!Ѧgg6@EG-T"hҫO?1 h/7]YN]fs2>f`N5?iMyepB`ʘM 2Gq~_PiK(`ʫGa+:5#(KI@Ty0ATM:ܻI9w/p7h[ߙ9ұU0jpgs{/Ig ^^-؁u~)J/Zu~ &Og*aKX@,UsM͐g$t KSH'b1R $ 3H%iJ& (l4#K24^̳2 9^-,Z/^pO?|u;uͯlaג)^_PXP8ɗ\n+j靏7AC}تt>N-. D @ݿa3HTLz1&LFp, *cP1s(jq S7A7:P)By_rA 嬗} iܨѬbd p#o#naqɓn۰fӀw|FAY%]:ء=KHO1NGԤM +5cca4_Pu 7Z\֙A 2d}&@yq0p _x˙HՍ:|2:|麝_y/-sߎ7^mv]Q`ǺK <8үߨ{vO,?`bnx8%k1:%KO[v*@石 Sοx|2來mBe!FPb?Gv<%v vM۾.4*-X{)eeR;N.c G{{bKhX*0#*R1А/|(dRRVg +c+2I#e`!He5| ЇD>K r+5o Uq,TeM[=k I|bp¬"L %[xhaРz;Qx(:/k #-Tm~D04f dLzڧj}VywXW*jRN_xmъҨY#bU94\l /iIO$wu&K^lY`.1KU 4w,eo gAcVZoW!찆헎DB |JIhLQLIG"_rE,N<S$Pg$M«JM(GF*2W>#dTĜPg՚@gdѕ1Ih WIMO^ڽT2л! %<JFXK-zŏ/1))TB+=F'Ώwu{EաK}<;!yq觅^Fpy_hv&/0Wܦ.ʁiIi NI2&c$z ,k0p)j:Hޗ]}^ӧk`o6AH.iSpEjWaLSd?zyg'bC񋭪4n)R4-q*D4KQ~{F¼8K,1Aע%k P7cQ0Lt` L0!@O%Dy4јb &PV y -c I&=#iAp&/ HnԮd=x+Z6[l9NbPJeJuVPR4?*>Arb"4чX0U2@MG "Gȟ' d)J(,DJLe`@hx+NʨRš$"hJ`R0,"Eh<锢I 9CO (}-Zk^?SSF ݏOF1k17ZɌTG !<ҊXK'Lc^ټ eM'tM N8Ĵ_*$N`ZЊ N)rU Wе2WX$,Xk"&-f0*. Y5#QޱĊ%!hfv%*a(])xv, *CYAyFxIeLM^8ib6Rf,]ơJTyYXQMPZYȫL8~gSi< .!RA#eL2 &iuL{O(톶 -@9!g89qQމqQX{tTI f.UGiΈi(r0R0jc1iO=yH Lx,HEkx *PFB.@X$-T_D J9opLtcԴ5p14DqbpfPhGGVT,Qw;®] |S0 F` 1U8b>oM'ey"\Jx'YvǠY9L{y]BI1\%@ ~ę@1O$m{M`ڬ4glr?`U>^X1Z%)uH,~@w`wXo95ډueTopHҔbR6@wBS& ԴP||hZ4M ɌZjeDRX-B$kH᚟ƼȭdR'Rij9*荾4qAT錳Bx:{ .szJxfek[gJǛuHC1f V̬VJ)ؙ iPEYvp7PEN4d~@#Dpbe'OMBd·vɍB#v ?p%yO:HcNJY(@ذ$T90/"B/PqQgL3z%8%BNL$_%/DiHC[f5٥2OMU0Ӽ7h;!#,cHZYAY ?$5x~1߷;nG vSɭ5Ƿڿkoe2oиoV?z9E%7 ϘcO(ݴX >/yuP^ Lc""Ҽkp݁E3KZ Ӵ%܋'̯YԵnO(T쎜اpАanzLءu5ՓX'b|Әz*V씞hjh!xiKR(͟#Z`gb0EBML~MlrྗbNy4U_܋2|i3()ԎSQn7}!bFz͌ #V?L+"20i8bk&e19VnOȉV~k{q]pvp/Dcx3 4B!M!Щa^ #fa LJ$>ي;rYNt\xkP:<{*&$8EBrE*G':k-^}-,8P[k]u:&\E :{V8H6q IKʣ`BҺl ["e\Ymy غ曋wxLF˞s- afmsK%]@F#8 2IXJ@uG>מY>-3 IDAT\<> TWv$"m&51P$OʥOoZЃ4,NRNHbH|sIrK6jMV[[{~aςK/'B)7O(ǐ7Ncb`lM(0>bo}K,r?s}>N֟ΐ`{AfU[+,yg3noَПe#؍hV+*qm5|7:oO;_}߮xlyW;Pdۏ1h.Ahs\YL5b`,i ŊԀn,ӤN/u9䱣oPfH|[W}ֶVW+-+HnqQ련Wh %bg`J$R/߳魷˻3w~3.T_6J3ѫY_YV-Cࢗ83b|.G/Zs?J7atو%}MWh(-iS +Vliv[d[,ҎZV4RXXuՖV~$I%&m*@⋫}֔&0|z|bص6peI{L#k wO "J핁#YC?m6acNv &8QMnV-\6A :~\ho2/@Vmq׺YYFtlx5nY&`;r+"gEHmtsq^Ƹ\=}e]!1m-u52:___T X˸3B @IJ>yͪ-L 2lYCWـp9$c:0SxcE]8~؁_gпcf3U 2YuAxwsA4n}ϣy);Rq{ʅhS!36(/".krO᮵}ӣ|áT{|V-8౒T\hTN8꧞2.Q4zunM i /ϥoex8aA2NBhWIM88V }`9kVlʅ&匃p 'Kd@>䤝zI2ܰGCO?c(q8L8*~:,~kƢ<7u'o?_o}ߌQVm~~ūiP.ҖhQ )50<%Sʔ Pű}EpvoRQq4WZSB1V7Z)FwsfeCaԪz\:v3(:P)+NT\)Zţp ~wV=sE9rA/+b @ԍu%!ʮWs!dh"e&t)gs ގo`׈:'esAȷW=2~ 3.I[ҨK/Ph'I.ӻl땝?aEgl^9 /_;ÓĒs/F=U#keK-B)2Yg-'#,=H+f|h`G#O?gL"߷H3jZ/'dӣ_x4J;k޼a~0bb 0{2򪌂=gh t漡 cY+KY~ōšx 럅mrAURQ$ nLƸ&ds?\Aԭs1AG :#QކXeA3\cN=H:״e͐rӗ* m6|J1W6zBe G>KOa`M0ru "V?1v`Ĵ|Gδk.]}vvΐP>lO+p  ʹOrKG?wNP:Phdį~?0/V'= _mkCW/`Bi4HA^9*1}lU^9s*7`ʲdI:ST.ut CrA^{jd0.9d' U*Xt_{sǴ힏-CF~DV<[!Y35y‘Aa&LqM:[8GӠa_>[9dڕi!hdF!T';dv8vݟ}~;|nemO]q/A&C-6nԤlzq n>DUi#< ˓#`":[> 1hb>|֭}fSwO ^9Өq> ON|̙]"4x8_rC\tبLr^曹T~p7+[]m_jZF"*&ǘS|"~agbˊ]qZp) 2ż0ҳ*% DYO?t)7ץNYRj!Pe}*L{P}^^}~V=GO=Ab+TTUyOȨ9hdB8}:ag1miSp(`f#|1APq H)2LiqH_0I7Qy?S"O;&Hה1Bu~3R#e;%*{o6-wkU#QJ|`(_4~v"`g8ᴟV1ki[VR7TI( 8+ڵksr[׈j 6l8^eBJb4)ƾ߹KN[Z=.^>|”+:;n*CϠ)#ʬcpp}'A+öC?Xpq;:kפMZWЮC_RSCȮAz8nXd=֮%le84(`Ą#ө4|5c+ij4ѡ:i77xĄ?q+(lcF^p|)#iN/j':gS7m\'XYb#Ξx w1۷NC xKxa8zr5\zP!c'.JD Mvt;#2?¦6iɛNa%[u葻/ٶ^ t4?Py4 "6زS)peL; +|A2}v:j" >j ALnJYUim*n"{PwL/9qG/ Ht5.>²HsO’ _0 t?~}3xәT~!M3yCtQСN2?fE/|mJY9w~"b(l_I1y Pzr@L %{5Ʊ w=] lpU;''Vc`=oAbT}eQ07pG %kSDⅿ1kol.&'{d't jfylD}4.uw qۯ,oB?炩 :\t]f qeHNbP0,(~Yౢʋ:ʺ6ai mE"cU)"l\bP+/ iZ+\ھ;7,PS'kR)#nĞ"ѳ0 ZH;b .ݺ-^=0+z:SՎ5IL\:-!u kIH=}`9~hyվ}L_Owո}  Vp|y|CLkF3IedYæQүŵU Be܇E) g 8g:L{2Np +@',SCqCMT]s3xg܂HsIhM,QG@*fj+Sc{#ȡIX}4jyGl/j2E6J%km>}&xR}s38L$`U$~`xq|eӔ4RzxG?:G>I7*vU+,RyUᒋ^tt"PQ~Y!7= lLmXi K&ק9mz #TMHa񫉣G r*S}  e[!8x9!=a0hcGܱeK`l8=?Z1]6ױ#WG cY1ފ>g<iTcg:qp$r±G1RzN=̡%O G f+gdb.1qTf]C MXu0k)oTxljH']\/;zdG-d2vةoWփR>gႁI$LR% ,|SN&b&Ad>eϦdYs?w퇃{[;HæYVIh ;:/Jӓap4f$Ƃ_^ GDɺ]^?{ײxzwѣGg/RTVvjر$֑Cbe K"bXaXDbEE>&sF DcҸK,SV9R:xڃwm1e{?eԜ;<}܁%Kmn.t}(ydkjpjj&T3OO8VRH9\UL+tʻm\_>vk}Yi]5up3ut 7`AoEѳNhEW^|'>q٠A;iyhtx3u~^sM՟N1g$M>3d諿Y G~ଏ}n*LYnŮ|pCyԬw' χڥf@^h (&k;HhAyiA9yT^y@^-h -('k yk Qy $oy <*m 4wG5i* y@ rx M[0|l~/ 1nSl|iOv| Dݕ$@T4AVhZ[UhB `W|ꙁ@SB4m0Hf%v'7p±ƹq`ZtOtE-hF ,GCv`'"uT>Βe8F8gq<682ĝזR8К~gGp< G48[mpztyMjp\$I;I43-ppkV:'yp" ]us7 HCll?6!ppn1weMtyi_o>cy}E ًW6Jƥֳf{IlgoWV;y-e8>F,Ʊ #yiF8ɽh_}_w9h.h]#;HҶ7N"?#J)n*|^;Hֶ7 N׆ȣ.m"H{}kb/nס뺴 ,8.lzs_N[m $yi_?2gy~i 4h[CKm#maIӞwAdRo4HiAO}=vVQs;+9Ӧ JKBI瀸]&B~eVξA| y9iM mLҿG[u '՝l[fym%Ьk]"2N ?h1$whˠ|MxC sX|-ݽ-뵨st\qs_<9KUМ(:G6}:P_[l-$@p=tOֆԝtt\??Gl֞Z,ѐcryr0זGSUfd8^m ߇JrA/ᘍ/F4.FD-@K4RR/N},|r+nkw8~:8nk*4d}G)z/ΰ-؇;V$X=@vn)_J >nA猃[z*`4Zs߃̏mF}pk '$|sL 09&^^Wy^kq S!IENDB`././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.3863792 jedi-0.19.1/docs/_templates/0000775000175000017500000000000000000000000015465 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/docs/_templates/ghbuttons.html0000664000175000017500000000034700000000000020374 0ustar00davedave00000000000000

Github



././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/docs/_templates/sidebarlogo.html0000664000175000017500000000021000000000000020636 0ustar00davedave00000000000000 ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/docs/conf.py0000664000175000017500000002214600000000000014634 0ustar00davedave00000000000000# Jedi documentation build configuration file, created by # sphinx-quickstart on Wed Dec 26 00:11:34 2012. # # This file is execfile()d with the current directory set to its containing dir. # # Note that not all possible configuration values are present in this # autogenerated file. # # All configuration values have a default; values that are commented out # serve to show the default. import sys import os # If extensions (or modules to document with autodoc) are in another directory, # add these directories to sys.path here. If the directory is relative to the # documentation root, use os.path.abspath to make it absolute, like shown here. sys.path.insert(0, os.path.abspath('..')) # -- General configuration ----------------------------------------------------- # If your documentation needs a minimal Sphinx version, state it here. #needs_sphinx = '1.0' # Add any Sphinx extension module names here, as strings. They can be extensions # coming with Sphinx (named 'sphinx.ext.*') or your custom ones. extensions = ['sphinx.ext.autodoc', 'sphinx.ext.viewcode', 'sphinx.ext.todo', 'sphinx.ext.intersphinx', 'sphinx.ext.inheritance_diagram', 'sphinx_rtd_theme', 'sphinx.ext.autosummary'] # Add any paths that contain templates here, relative to this directory. templates_path = ['_templates'] # The suffix of source filenames. source_suffix = '.rst' # The encoding of source files. source_encoding = 'utf-8' # The master toctree document. master_doc = 'index' # General information about the project. project = 'Jedi' copyright = 'jedi contributors' import jedi from jedi.utils import version_info # The version info for the project you're documenting, acts as replacement for # |version| and |release|, also used in various other places throughout the # built documents. # # The short X.Y.Z version. version = '.'.join(str(x) for x in version_info()[:3]) # The full version, including alpha/beta/rc tags. release = jedi.__version__ # The language for content autogenerated by Sphinx. Refer to documentation # for a list of supported languages. #language = None # There are two options for replacing |today|: either, you set today to some # non-false value, then it is used: #today = '' # Else, today_fmt is used as the format for a strftime call. #today_fmt = '%B %d, %Y' # List of patterns, relative to source directory, that match files and # directories to ignore when looking for source files. exclude_patterns = [] # The reST default role (used for this markup: `text`) to use for all documents. #default_role = None # If true, '()' will be appended to :func: etc. cross-reference text. #add_function_parentheses = True # If true, the current module name will be prepended to all description # unit titles (such as .. function::). #add_module_names = True # If true, sectionauthor and moduleauthor directives will be shown in the # output. They are ignored by default. #show_authors = False # The name of the Pygments (syntax highlighting) style to use. pygments_style = 'sphinx' # A list of ignored prefixes for module index sorting. #modindex_common_prefix = [] # -- Options for HTML output --------------------------------------------------- # The theme to use for HTML and HTML Help pages. See the documentation for # a list of builtin themes. html_theme = 'sphinx_rtd_theme' # Theme options are theme-specific and customize the look and feel of a theme # further. For a list of options available for each theme, see the # documentation. html_theme_options = { 'logo_only': True, 'style_nav_header_background': 'white', } # Add any paths that contain custom themes here, relative to this directory. html_theme_path = ['_themes'] # The name for this set of Sphinx documents. If None, it defaults to # " v documentation". #html_title = None # A shorter title for the navigation bar. Default is the same as html_title. #html_short_title = None # The name of an image file (relative to this directory) to place at the top # of the sidebar. html_logo = '_static/logo.png' # The name of an image file (within the static path) to use as favicon of the # docs. This file should be a Windows icon file (.ico) being 16x16 or 32x32 # pixels large. #html_favicon = None # Add any paths that contain custom static files (such as style sheets) here, # relative to this directory. They are copied after the builtin static files, # so a file named "default.css" will overwrite the builtin "default.css". html_static_path = ['_static'] html_css_files = ['custom_style.css'] # If not '', a 'Last updated on:' timestamp is inserted at every page bottom, # using the given strftime format. #html_last_updated_fmt = '%b %d, %Y' # If true, SmartyPants will be used to convert quotes and dashes to # typographically correct entities. #html_use_smartypants = True # Custom sidebar templates, maps document names to template names. html_sidebars = { '**': [ 'sidebarlogo.html', 'localtoc.html', #'relations.html', 'ghbuttons.html', #'sourcelink.html', 'searchbox.html' ] } # Additional templates that should be rendered to pages, maps page names to # template names. #html_additional_pages = {} # If false, no module index is generated. #html_domain_indices = True # If false, no index is generated. #html_use_index = True # If true, the index is split into individual pages for each letter. #html_split_index = False # If true, links to the reST sources are added to the pages. html_show_sourcelink = False # If true, "Created using Sphinx" is shown in the HTML footer. Default is True. html_show_sphinx = False # If true, "(C) Copyright ..." is shown in the HTML footer. Default is True. html_show_copyright = False # If true, an OpenSearch description file will be output, and all pages will # contain a tag referring to it. The value of this option must be the # base URL from which the finished HTML is served. #html_use_opensearch = '' # This is the file name suffix for HTML files (e.g. ".xhtml"). #html_file_suffix = None # Output file base name for HTML help builder. htmlhelp_basename = 'Jedidoc' #html_style = 'default.css' # Force usage of default template on RTD # -- Options for LaTeX output -------------------------------------------------- latex_elements = { # The paper size ('letterpaper' or 'a4paper'). #'papersize': 'letterpaper', # The font size ('10pt', '11pt' or '12pt'). #'pointsize': '10pt', # Additional stuff for the LaTeX preamble. #'preamble': '', } # Grouping the document tree into LaTeX files. List of tuples # (source start file, target name, title, author, documentclass [howto/manual]). latex_documents = [ ('index', 'Jedi.tex', 'Jedi Documentation', 'Jedi contributors', 'manual'), ] # The name of an image file (relative to this directory) to place at the top of # the title page. #latex_logo = None # For "manual" documents, if this is true, then toplevel headings are parts, # not chapters. #latex_use_parts = False # If true, show page references after internal links. #latex_show_pagerefs = False # If true, show URL addresses after external links. #latex_show_urls = False # Documents to append as an appendix to all manuals. #latex_appendices = [] # If false, no module index is generated. #latex_domain_indices = True # -- Options for manual page output -------------------------------------------- # One entry per manual page. List of tuples # (source start file, name, description, authors, manual section). man_pages = [ ('index', 'jedi', 'Jedi Documentation', ['Jedi contributors'], 1) ] # If true, show URL addresses after external links. #man_show_urls = False # -- Options for Texinfo output ------------------------------------------------ # Grouping the document tree into Texinfo files. List of tuples # (source start file, target name, title, author, # dir menu entry, description, category) texinfo_documents = [ ('index', 'Jedi', 'Jedi Documentation', 'Jedi contributors', 'Jedi', 'Awesome Python autocompletion library.', 'Miscellaneous'), ] # Documents to append as an appendix to all manuals. #texinfo_appendices = [] # If false, no module index is generated. #texinfo_domain_indices = True # How to display URL addresses: 'footnote', 'no', or 'inline'. #texinfo_show_urls = 'footnote' # -- Options for todo module --------------------------------------------------- todo_include_todos = False # -- Options for autodoc module ------------------------------------------------ autoclass_content = 'both' autodoc_member_order = 'bysource' autodoc_default_flags = [] #autodoc_default_flags = ['members', 'undoc-members'] # -- Options for intersphinx module -------------------------------------------- intersphinx_mapping = { 'python': ('https://docs.python.org/', None), 'parso': ('https://parso.readthedocs.io/en/latest/', None), } def skip_deprecated(app, what, name, obj, skip, options): """ All attributes containing a deprecated note shouldn't be documented anymore. This makes it even clearer that they are not supported anymore. """ doc = obj.__doc__ return skip or doc and '.. deprecated::' in doc def setup(app): app.connect('autodoc-skip-member', skip_deprecated) ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.3863792 jedi-0.19.1/docs/docs/0000775000175000017500000000000000000000000014260 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/docs/docs/acknowledgements.rst0000664000175000017500000000510300000000000020343 0ustar00davedave00000000000000.. include global.rst History & Acknowledgements ========================== Acknowledgements ---------------- - Dave Halter for creating and maintaining Jedi & Parso. - Takafumi Arakaki (@tkf) for creating a solid test environment and a lot of other things. - Danilo Bargen (@dbrgn) for general housekeeping and being a good friend :). - Guido van Rossum (@gvanrossum) for creating the parser generator pgen2 (originally used in lib2to3). - Thanks to all the :ref:`contributors `. A Little Bit of History ----------------------- Written by Dave. The Star Wars Jedi are awesome. My Jedi software tries to imitate a little bit of the precognition the Jedi have. There's even an awesome `scene `_ of Monty Python Jedis :-). But actually the name has not much to do with Star Wars. It's part of my second name Jedidjah. I actually started Jedi back in 2012, because there were no good solutions available for VIM. Most auto-completion solutions just did not work well. The only good solution was PyCharm. But I liked my good old VIM very much. There was also a solution called Rope that did not work at all for me. So I decided to write my own version of a completion engine. The first idea was to execute non-dangerous code. But I soon realized, that this would not work. So I started to build a static analysis tool. The biggest problem that I had at the time was that I did not know a thing about parsers. I did not even know the word static analysis. It turns out they are the foundation of a good static analysis tool. I of course did not know that and tried to write my own poor version of a parser that I ended up throwing away two years later. Because of my lack of knowledge, everything after 2012 and before 2020 was basically refactoring. I rewrote the core parts of Jedi probably like 5-10 times. The last big rewrite (that I did twice) was the inclusion of gradual typing and stubs. I learned during that time that it is crucial to have a good understanding of your problem. Otherwise you just end up doing it again. I only wrote features in the beginning and in the end. Everything else was bugfixing and refactoring. However now I am really happy with the result. It works well, bugfixes can be quick and is pretty much feature complete. -------- I will leave you with a small anecdote that happened in 2012, if I remember correctly. After I explained Guido van Rossum, how some parts of my auto-completion work, he said: *"Oh, that worries me..."* Now that it is finished, I hope he likes it :-). .. _contributors: .. include:: ../../AUTHORS.txt ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/docs/docs/api-classes.rst0000664000175000017500000000157700000000000017230 0ustar00davedave00000000000000.. include:: ../global.rst .. _api-classes: API Return Classes ------------------ Abstract Base Class ~~~~~~~~~~~~~~~~~~~ .. autoclass:: jedi.api.classes.BaseName :members: :show-inheritance: Name ~~~~ .. autoclass:: jedi.api.classes.Name :members: :show-inheritance: Completion ~~~~~~~~~~ .. autoclass:: jedi.api.classes.Completion :members: :show-inheritance: BaseSignature ~~~~~~~~~~~~~ .. autoclass:: jedi.api.classes.BaseSignature :members: :show-inheritance: Signature ~~~~~~~~~ .. autoclass:: jedi.api.classes.Signature :members: :show-inheritance: ParamName ~~~~~~~~~ .. autoclass:: jedi.api.classes.ParamName :members: :show-inheritance: Refactoring ~~~~~~~~~~~ .. autoclass:: jedi.api.refactoring.Refactoring :members: :show-inheritance: .. autoclass:: jedi.api.errors.SyntaxError :members: :show-inheritance: ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/docs/docs/api.rst0000664000175000017500000000742300000000000015571 0ustar00davedave00000000000000.. include:: ../global.rst API Overview ============ .. note:: This documentation is mostly for Plugin developers, who want to improve their editors/IDE with Jedi. .. _api: The API consists of a few different parts: - The main starting points for complete/goto: :class:`.Script` and :class:`.Interpreter`. If you work with Jedi you want to understand these classes first. - :ref:`API Result Classes ` - :ref:`Python Versions/Virtualenv Support ` with functions like :func:`.find_system_environments` and :func:`.find_virtualenvs` - A way to work with different :ref:`Folders / Projects ` - Helpful functions: :func:`.preload_module` and :func:`.set_debug_function` The methods that you are most likely going to use to work with Jedi are the following ones: .. currentmodule:: jedi .. autosummary:: :nosignatures: Script.complete Script.goto Script.infer Script.help Script.get_signatures Script.get_references Script.get_context Script.get_names Script.get_syntax_errors Script.rename Script.inline Script.extract_variable Script.extract_function Script.search Script.complete_search Project.search Project.complete_search Script ------ .. autoclass:: jedi.Script :members: Interpreter ----------- .. autoclass:: jedi.Interpreter :members: .. _projects: Projects -------- .. automodule:: jedi.api.project .. autofunction:: jedi.get_default_project .. autoclass:: jedi.Project :members: .. _environments: Environments ------------ .. automodule:: jedi.api.environment .. autofunction:: jedi.find_system_environments .. autofunction:: jedi.find_virtualenvs .. autofunction:: jedi.get_system_environment .. autofunction:: jedi.create_environment .. autofunction:: jedi.get_default_environment .. autoexception:: jedi.InvalidPythonEnvironment .. autoclass:: jedi.api.environment.Environment :members: Helper Functions ---------------- .. autofunction:: jedi.preload_module .. autofunction:: jedi.set_debug_function Errors ------ .. autoexception:: jedi.InternalError .. autoexception:: jedi.RefactoringError Examples -------- Completions ~~~~~~~~~~~ .. sourcecode:: python >>> import jedi >>> code = '''import json; json.l''' >>> script = jedi.Script(code, path='example.py') >>> script > >>> completions = script.complete(1, 19) >>> completions [, ] >>> completions[1] >>> completions[1].complete 'oads' >>> completions[1].name 'loads' Type Inference / Goto ~~~~~~~~~~~~~~~~~~~~~ .. sourcecode:: python >>> import jedi >>> code = '''\ ... def my_func(): ... print 'called' ... ... alias = my_func ... my_list = [1, None, alias] ... inception = my_list[2] ... ... inception()''' >>> script = jedi.Script(code) >>> >>> script.goto(8, 1) [] >>> >>> script.infer(8, 1) [] References ~~~~~~~~~~ .. sourcecode:: python >>> import jedi >>> code = '''\ ... x = 3 ... if 1 == 2: ... x = 4 ... else: ... del x''' >>> script = jedi.Script(code) >>> rns = script.get_references(5, 8) >>> rns [, , ] >>> rns[1].line 3 >>> rns[1].column 4 Deprecations ------------ The deprecation process is as follows: 1. A deprecation is announced in any release. 2. The next major release removes the deprecated functionality. ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/docs/docs/changelog.rst0000664000175000017500000000004100000000000016734 0ustar00davedave00000000000000.. include:: ../../CHANGELOG.rst ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/docs/docs/development.rst0000664000175000017500000001254300000000000017341 0ustar00davedave00000000000000.. include:: ../global.rst Jedi Development ================ .. currentmodule:: jedi .. note:: This documentation is for Jedi developers who want to improve Jedi itself, but have no idea how Jedi works. If you want to use Jedi for your IDE, look at the `plugin api `_. It is also important to note that it's a pretty old version and some things might not apply anymore. Introduction ------------ This page tries to address the fundamental demand for documentation of the |jedi| internals. Understanding a dynamic language is a complex task. Especially because type inference in Python can be a very recursive task. Therefore |jedi| couldn't get rid of complexity. I know that **simple is better than complex**, but unfortunately it sometimes requires complex solutions to understand complex systems. In six chapters I'm trying to describe the internals of |jedi|: - :ref:`The Jedi Core ` - :ref:`Core Extensions ` - :ref:`Imports & Modules ` - :ref:`Stubs & Annotations ` - :ref:`Caching & Recursions ` - :ref:`Helper modules ` .. note:: Testing is not documented here, you'll find that `right here `_. .. _core: The Jedi Core ------------- The core of Jedi consists of three parts: - :ref:`Parser ` - :ref:`Python type inference ` - :ref:`API ` Most people are probably interested in :ref:`type inference `, because that's where all the magic happens. I need to introduce the :ref:`parser ` first, because :mod:`jedi.inference` uses it extensively. .. _parser: Parser ~~~~~~~~~~~~~~~~~~~~~~~~~~~ Jedi used to have its internal parser, however this is now a separate project and is called `parso `_. The parser creates a syntax tree that |jedi| analyses and tries to understand. The grammar that this parser uses is very similar to the official Python `grammar files `_. .. _inference: Type inference of python code (inference/__init__.py) ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ .. automodule:: jedi.inference Inference Values (inference/base_value.py) ++++++++++++++++++++++++++++++++++++++++++++++++++++++ .. automodule:: jedi.inference.base_value .. inheritance-diagram:: jedi.inference.value.instance.TreeInstance jedi.inference.value.klass.ClassValue jedi.inference.value.function.FunctionValue jedi.inference.value.function.FunctionExecutionContext :parts: 1 .. _name_resolution: Name resolution (inference/finder.py) +++++++++++++++++++++++++++++++++++++ .. automodule:: jedi.inference.finder .. _dev-api: API (api/__init__.py and api/classes.py) ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ The API has been designed to be as easy to use as possible. The API documentation can be found `here `_. The API itself contains little code that needs to be mentioned here. Generally I'm trying to be conservative with the API. I'd rather not add new API features if they are not necessary, because it's much harder to deprecate stuff than to add it later. .. _core-extensions: Core Extensions --------------- Core Extensions is a summary of the following topics: - :ref:`Iterables & Dynamic Arrays ` - :ref:`Dynamic Parameters ` - :ref:`Docstrings ` - :ref:`Refactoring ` These topics are very important to understand what Jedi additionally does, but they could be removed from Jedi and Jedi would still work. But slower and without some features. .. _iterables: Iterables & Dynamic Arrays (inference/value/iterable.py) ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ To understand Python on a deeper level, |jedi| needs to understand some of the dynamic features of Python like lists that are filled after creation: .. automodule:: jedi.inference.value.iterable .. _dynamic_params: Parameter completion (inference/dynamic_params.py) ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ .. automodule:: jedi.inference.dynamic_params .. _docstrings: Docstrings (inference/docstrings.py) ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ .. automodule:: jedi.inference.docstrings .. _refactoring: Refactoring (api/refactoring.py) ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ .. automodule:: jedi.api.refactoring .. _imports-modules: Imports & Modules ----------------- - :ref:`Modules ` - :ref:`Builtin Modules ` - :ref:`Imports ` .. _builtin: Compiled Modules (inference/compiled.py) ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ .. automodule:: jedi.inference.compiled .. _imports: Imports (inference/imports.py) ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ .. automodule:: jedi.inference.imports .. _stubs: Stubs & Annotations (inference/gradual) ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ .. automodule:: jedi.inference.gradual .. _caching-recursions: Caching & Recursions -------------------- - :ref:`Caching ` - :ref:`Recursions ` .. _cache: Caching (cache.py) ~~~~~~~~~~~~~~~~~~ .. automodule:: jedi.cache .. _recursion: Recursions (recursion.py) ~~~~~~~~~~~~~~~~~~~~~~~~~ .. automodule:: jedi.inference.recursion .. _dev-helpers: Helper Modules -------------- Most other modules are not really central to how Jedi works. They all contain relevant code, but you if you understand the modules above, you pretty much understand Jedi. ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/docs/docs/features.rst0000664000175000017500000001057000000000000016633 0ustar00davedave00000000000000.. include:: ../global.rst Features and Limitations ======================== Jedi's main API calls and features are: - Autocompletion: :meth:`.Script.complete`; It's also possible to get it working in :ref:`your REPL (IPython, etc.) ` - Goto/Type Inference: :meth:`.Script.goto` and :meth:`.Script.infer` - Static Analysis: :meth:`.Script.get_names` and :meth:`.Script.get_syntax_errors` - Refactorings: :meth:`.Script.rename`, :meth:`.Script.inline`, :meth:`.Script.extract_variable` and :meth:`.Script.extract_function` - Code Search: :meth:`.Script.search` and :meth:`.Project.search` Basic Features -------------- - Python 3.6+ support - Ignores syntax errors and wrong indentation - Can deal with complex module / function / class structures - Great ``virtualenv``/``venv`` support - Works great with Python's :ref:`type hinting `, - Understands stub files - Can infer function arguments for sphinx, epydoc and basic numpydoc docstrings - Is overall a very solid piece of software that has been refined for a long time. Bug reports are very welcome and are usually fixed within a few weeks. Supported Python Features ------------------------- |jedi| supports many of the widely used Python features: - builtins - returns, yields, yield from - tuple assignments / array indexing / dictionary indexing / star unpacking - with-statement / exception handling - ``*args`` / ``**kwargs`` - decorators / lambdas / closures - generators / iterators - descriptors: property / staticmethod / classmethod / custom descriptors - some magic methods: ``__call__``, ``__iter__``, ``__next__``, ``__get__``, ``__getitem__``, ``__init__`` - ``list.append()``, ``set.add()``, ``list.extend()``, etc. - (nested) list comprehensions / ternary expressions - relative imports - ``getattr()`` / ``__getattr__`` / ``__getattribute__`` - function annotations - simple/typical ``sys.path`` modifications - ``isinstance`` checks for if/while/assert - namespace packages (includes ``pkgutil``, ``pkg_resources`` and PEP420 namespaces) - Django / Flask / Buildout support - Understands Pytest fixtures Limitations ----------- In general Jedi's limit is quite high, but for very big projects or very complex code, sometimes Jedi intentionally stops type inference, to avoid hanging for a long time. Additionally there are some Python patterns Jedi does not support. This is intentional and below should be a complete list: - Arbitrary metaclasses: Some metaclasses like enums and dataclasses are reimplemented in Jedi to make them work. Most of the time stubs are good enough to get type inference working, even when metaclasses are involved. - ``setattr()``, ``__import__()`` - Writing to some dicts: ``globals()``, ``locals()``, ``object.__dict__`` - Manipulations of instances outside the instance variables without using methods Performance Issues ~~~~~~~~~~~~~~~~~~ Importing ``numpy`` can be quite slow sometimes, as well as loading the builtins the first time. If you want to speed things up, you could preload libraries in |jedi|, with :func:`.preload_module`. However, once loaded, this should not be a problem anymore. The same is true for huge modules like ``PySide``, ``wx``, ``tensorflow``, ``pandas``, etc. Jedi does not have a very good cache layer. This is probably the biggest and only architectural `issue `_ in Jedi. Unfortunately it is not easy to change that. Dave Halter is thinking about rewriting Jedi in Rust, but it has taken Jedi more than 8 years to reach version 1.0, a rewrite will probably also take years. Security -------- For :class:`.Script` ~~~~~~~~~~~~~~~~~~~~ Security is an important topic for |jedi|. By default, no code is executed within Jedi. As long as you write pure Python, everything is inferred statically. If you enable ``load_unsafe_extensions=True`` for your :class:`.Project` and you use builtin modules (``c_builtin``) Jedi will execute those modules. If you don't trust a code base, please do not enable that option. It might lead to arbitrary code execution. For :class:`.Interpreter` ~~~~~~~~~~~~~~~~~~~~~~~~~ If you want security for :class:`.Interpreter`, ``do not`` use it. Jedi does execute properties and in general is not very careful to avoid code execution. This is intentional: Most people trust the code bases they have imported, because at that point a malicious code base would have had code execution already. ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/docs/docs/installation.rst0000664000175000017500000000546300000000000017523 0ustar00davedave00000000000000.. include:: ../global.rst Installation and Configuration ============================== .. warning:: Most people will want to install Jedi as a submodule/vendored and not through pip/system wide. The reason for this is that it makes sense that the plugin that uses Jedi has always access to it. Otherwise Jedi will not work properly when virtualenvs are activated. So please read the documentation of your editor/IDE plugin to install Jedi. For plugin developers, Jedi works best if it is always available. Vendoring is a pretty good option for that. You can either include |jedi| as a submodule in your text editor plugin (like jedi-vim_ does by default), or you can install it systemwide. .. note:: This just installs the |jedi| library, not the :ref:`editor plugins `. For information about how to make it work with your editor, refer to the corresponding documentation. The normal way -------------- Most people use Jedi with a :ref:`editor plugins`. Typically you install Jedi by installing an editor plugin. No necessary steps are needed. Just take a look at the instructions for the plugin. With pip -------- On any system you can install |jedi| directly from the Python package index using pip:: sudo pip install jedi If you want to install the current development version (master branch):: sudo pip install -e git://github.com/davidhalter/jedi.git#egg=jedi System-wide installation via a package manager ---------------------------------------------- Arch Linux ~~~~~~~~~~ You can install |jedi| directly from official Arch Linux packages: - `python-jedi `__ (There is also a packaged version of the vim plugin available: `vim-jedi at Arch Linux `__.) Debian ~~~~~~ Debian packages are available in the `unstable repository `__. Others ~~~~~~ We are in the discussion of adding |jedi| to the Fedora repositories. Manual installation from GitHub --------------------------------------------- If you prefer not to use an automated package installer, you can clone the source from GitHub and install it manually. To install it, run these commands:: git clone --recurse-submodules https://github.com/davidhalter/jedi cd jedi sudo python setup.py install Inclusion as a submodule ------------------------ If you use an editor plugin like jedi-vim_, you can simply include |jedi| as a git submodule of the plugin directory. Vim plugin managers like Vundle_ or Pathogen_ make it very easy to keep submodules up to date. .. _jedi-vim: https://github.com/davidhalter/jedi-vim .. _vundle: https://github.com/gmarik/vundle .. _pathogen: https://github.com/tpope/vim-pathogen ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/docs/docs/settings.rst0000664000175000017500000000011500000000000016647 0ustar00davedave00000000000000.. include:: ../global.rst Settings ======== .. automodule:: jedi.settings ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/docs/docs/testing.rst0000664000175000017500000000145200000000000016471 0ustar00davedave00000000000000.. include:: ../global.rst Jedi Testing ============ The test suite depends on ``pytest``:: pip install pytest If you want to test only a specific Python version (e.g. Python 3.8), it is as easy as:: python3.8 -m pytest Tests are also run automatically on `GitHub Actions `_. You want to add a test for |jedi|? Great! We love that. Normally you should write your tests as :ref:`Blackbox Tests `. Most tests would fit right in there. For specific API testing we're using simple unit tests, with a focus on a simple and readable testing structure. .. _blackbox: Integration Tests (run.py) ~~~~~~~~~~~~~~~~~~~~~~~~~~ .. automodule:: test.run Refactoring Tests (refactor.py) ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ .. automodule:: test.refactor ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/docs/docs/usage.rst0000664000175000017500000001502400000000000016120 0ustar00davedave00000000000000.. include:: ../global.rst Using Jedi ========== |jedi| is can be used with a variety of :ref:`plugins `, :ref:`language servers ` and other software. It is also possible to use |jedi| in the :ref:`Python shell or with IPython `. Below you can also find a list of :ref:`recipes for type hinting `. .. _language-servers: Language Servers -------------- - `jedi-language-server `_ - `python-language-server `_ (currently unmaintained) - `python-lsp-server `_ (fork from python-language-server) - `anakin-language-server `_ .. _editor-plugins: Editor Plugins -------------- Vim ~~~ - jedi-vim_ - YouCompleteMe_ - deoplete-jedi_ Visual Studio Code ~~~~~~~~~~~~~~~~~~ - `Python Extension`_ Emacs ~~~~~ - Jedi.el_ - elpy_ - anaconda-mode_ Sublime Text 2/3 ~~~~~~~~~~~~~~~~ - SublimeJEDI_ (ST2 & ST3) - anaconda_ (only ST3) SynWrite ~~~~~~~~ - SynJedi_ TextMate ~~~~~~~~ - Textmate_ (Not sure if it's actually working) Kate ~~~~ - Kate_ version 4.13+ `supports it natively `__, you have to enable it, though. Atom ~~~~ - autocomplete-python-jedi_ GNOME Builder ~~~~~~~~~~~~~ - `GNOME Builder`_ `supports it natively `__, and is enabled by default. Gedit ~~~~~ - gedi_ Eric IDE ~~~~~~~~ - `Eric IDE`_ Web Debugger ~~~~~~~~~~~~ - wdb_ xonsh shell ~~~~~~~~~~~ Jedi is a preinstalled extension in `xonsh shell `_. Run the following command to enable: :: xontrib load jedi and many more! .. _repl-completion: Tab Completion in the Python Shell ---------------------------------- Jedi is a dependency of IPython. Autocompletion in IPython is therefore possible without additional configuration. Here is an `example video `_ how REPL completion can look like in a different shell. There are two different options how you can use Jedi autocompletion in your ``python`` interpreter. One with your custom ``$HOME/.pythonrc.py`` file and one that uses ``PYTHONSTARTUP``. Using ``PYTHONSTARTUP`` ~~~~~~~~~~~~~~~~~~~~~~~ .. automodule:: jedi.api.replstartup Using a Custom ``$HOME/.pythonrc.py`` ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ .. autofunction:: jedi.utils.setup_readline .. _recipes: Recipes ------- Here are some tips on how to use |jedi| efficiently. .. _type-hinting: Type Hinting ~~~~~~~~~~~~ If |jedi| cannot detect the type of a function argument correctly (due to the dynamic nature of Python), you can help it by hinting the type using one of the docstring/annotation styles below. **Only gradual typing will always work**, all the docstring solutions are glorified hacks and more complicated cases will probably not work. Official Gradual Typing (Recommended) +++++++++++++++++++++++++++++++++++++ You can read a lot about Python's gradual typing system in the corresponding PEPs like: - `PEP 484 `_ as an introduction - `PEP 526 `_ for variable annotations - `PEP 589 `_ for ``TypeDict`` - There are probably more :) Below you can find a few examples how you can use this feature. Function annotations:: def myfunction(node: ProgramNode, foo: str) -> None: """Do something with a ``node``. """ node.| # complete here Assignment, for-loop and with-statement type hints:: import typing x: int = foo() y: typing.Optional[int] = 3 key: str value: Employee for key, value in foo.items(): pass f: Union[int, float] with foo() as f: print(f + 3) PEP-0484 should be supported in its entirety. Feel free to open issues if that is not the case. You can also use stub files. Sphinx style ++++++++++++ http://www.sphinx-doc.org/en/stable/domains.html#info-field-lists :: def myfunction(node, foo): """ Do something with a ``node``. :type node: ProgramNode :param str foo: foo parameter description """ node.| # complete here Epydoc ++++++ http://epydoc.sourceforge.net/manual-fields.html :: def myfunction(node): """ Do something with a ``node``. @type node: ProgramNode """ node.| # complete here Numpydoc ++++++++ https://github.com/numpy/numpy/blob/master/doc/HOWTO_DOCUMENT.rst.txt In order to support the numpydoc format, you need to install the `numpydoc `__ package. :: def foo(var1, var2, long_var_name='hi'): r""" A one-line summary that does not use variable names or the function name. ... Parameters ---------- var1 : array_like Array_like means all those objects -- lists, nested lists, etc. -- that can be converted to an array. We can also refer to variables like `var1`. var2 : int The type above can either refer to an actual Python type (e.g. ``int``), or describe the type of the variable in more detail, e.g. ``(N,) ndarray`` or ``array_like``. long_variable_name : {'hi', 'ho'}, optional Choices in brackets, default first when optional. ... """ var2.| # complete here .. _jedi-vim: https://github.com/davidhalter/jedi-vim .. _youcompleteme: https://valloric.github.io/YouCompleteMe/ .. _deoplete-jedi: https://github.com/zchee/deoplete-jedi .. _Jedi.el: https://github.com/tkf/emacs-jedi .. _elpy: https://github.com/jorgenschaefer/elpy .. _anaconda-mode: https://github.com/proofit404/anaconda-mode .. _sublimejedi: https://github.com/srusskih/SublimeJEDI .. _anaconda: https://github.com/DamnWidget/anaconda .. _SynJedi: http://uvviewsoft.com/synjedi/ .. _wdb: https://github.com/Kozea/wdb .. _TextMate: https://github.com/lawrenceakka/python-jedi.tmbundle .. _kate: https://kate-editor.org/ .. _autocomplete-python-jedi: https://atom.io/packages/autocomplete-python-jedi .. _GNOME Builder: https://wiki.gnome.org/Apps/Builder/ .. _gedi: https://github.com/isamert/gedi .. _Eric IDE: https://eric-ide.python-projects.org .. _Python Extension: https://marketplace.visualstudio.com/items?itemName=ms-python.python ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/docs/global.rst0000664000175000017500000000004300000000000015317 0ustar00davedave00000000000000:orphan: .. |jedi| replace:: Jedi ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/docs/index.rst0000664000175000017500000000405400000000000015174 0ustar00davedave00000000000000.. include global.rst .. meta:: :github_url: https://github.com/davidhalter/jedi Jedi - an awesome autocompletion, static analysis and refactoring library for Python ==================================================================================== .. image:: https://img.shields.io/github/stars/davidhalter/jedi.svg?style=social&label=Star&maxAge=2592000 :target: https://github.com/davidhalter/jedi :alt: GitHub stars .. image:: http://isitmaintained.com/badge/open/davidhalter/jedi.svg :target: https://github.com/davidhalter/jedi/issues :alt: The percentage of open issues and pull requests .. image:: http://isitmaintained.com/badge/resolution/davidhalter/jedi.svg :target: https://github.com/davidhalter/jedi/issues :alt: The resolution time is the median time an issue or pull request stays open. .. image:: https://github.com/davidhalter/jedi/workflows/ci/badge.svg?branch=master :target: https://github.com/davidhalter/jedi/actions :alt: Tests .. image:: https://coveralls.io/repos/davidhalter/jedi/badge.svg?branch=master :target: https://coveralls.io/r/davidhalter/jedi :alt: Coverage status .. image:: https://pepy.tech/badge/jedi :target: https://pepy.tech/project/jedi :alt: PyPI Downloads `Github Repository `_ .. automodule:: jedi Autocompletion can for example look like this in jedi-vim: .. figure:: _screenshots/screenshot_complete.png .. _toc: Docs ---- .. toctree:: :maxdepth: 1 docs/usage docs/features docs/api docs/api-classes docs/installation docs/settings docs/development docs/testing docs/acknowledgements docs/changelog .. _resources: Resources --------- If you want to stay **up-to-date** with releases, please **subscribe** to this mailing list: https://groups.google.com/g/jedi-announce. To subscribe you can simply send an empty email to ``jedi-announce+subscribe@googlegroups.com``. - `Source Code on Github `_ - `Python Package Index `_ ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.3903792 jedi-0.19.1/jedi/0000775000175000017500000000000000000000000013313 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/jedi/__init__.py0000664000175000017500000000271600000000000015432 0ustar00davedave00000000000000""" Jedi is a static analysis tool for Python that is typically used in IDEs/editors plugins. Jedi has a focus on autocompletion and goto functionality. Other features include refactoring, code search and finding references. Jedi has a simple API to work with. There is a reference implementation as a `VIM-Plugin `_. Autocompletion in your REPL is also possible, IPython uses it natively and for the CPython REPL you can install it. Jedi is well tested and bugs should be rare. Here's a simple example of the autocompletion feature: >>> import jedi >>> source = ''' ... import json ... json.lo''' >>> script = jedi.Script(source, path='example.py') >>> script >>> completions = script.complete(3, len('json.lo')) >>> completions [, ] >>> print(completions[0].complete) ad >>> print(completions[0].name) load """ __version__ = '0.19.1' from jedi.api import Script, Interpreter, set_debug_function, preload_module from jedi import settings from jedi.api.environment import find_virtualenvs, find_system_environments, \ get_default_environment, InvalidPythonEnvironment, create_environment, \ get_system_environment, InterpreterEnvironment from jedi.api.project import Project, get_default_project from jedi.api.exceptions import InternalError, RefactoringError # Finally load the internal plugins. This is only internal. from jedi.plugins import registry del registry ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/jedi/__main__.py0000664000175000017500000000363600000000000015415 0ustar00davedave00000000000000import sys from os.path import join, dirname, abspath, isdir def _start_linter(): """ This is a pre-alpha API. You're not supposed to use it at all, except for testing. It will very likely change. """ import jedi if '--debug' in sys.argv: jedi.set_debug_function() for path in sys.argv[2:]: if path.startswith('--'): continue if isdir(path): import fnmatch import os paths = [] for root, dirnames, filenames in os.walk(path): for filename in fnmatch.filter(filenames, '*.py'): paths.append(os.path.join(root, filename)) else: paths = [path] try: for p in paths: for error in jedi.Script(path=p)._analysis(): print(error) except Exception: if '--pdb' in sys.argv: import traceback traceback.print_exc() import pdb pdb.post_mortem() else: raise def _complete(): import jedi import pdb if '-d' in sys.argv: sys.argv.remove('-d') jedi.set_debug_function() try: completions = jedi.Script(sys.argv[2]).complete() for c in completions: c.docstring() c.type except Exception as e: print(repr(e)) pdb.post_mortem() else: print(completions) if len(sys.argv) == 2 and sys.argv[1] == 'repl': # don't want to use __main__ only for repl yet, maybe we want to use it for # something else. So just use the keyword ``repl`` for now. print(join(dirname(abspath(__file__)), 'api', 'replstartup.py')) elif len(sys.argv) > 1 and sys.argv[1] == '_linter': _start_linter() elif len(sys.argv) > 1 and sys.argv[1] == '_complete': _complete() else: print('Command not implemented: %s' % sys.argv[1]) ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/jedi/_compatibility.py0000664000175000017500000000162600000000000016702 0ustar00davedave00000000000000""" This module is here to ensure compatibility of Windows/Linux/MacOS and different Python versions. """ import errno import sys import pickle def pickle_load(file): try: return pickle.load(file) # Python on Windows don't throw EOF errors for pipes. So reraise them with # the correct type, which is caught upwards. except OSError: if sys.platform == 'win32': raise EOFError() raise def pickle_dump(data, file, protocol): try: pickle.dump(data, file, protocol) # On Python 3.3 flush throws sometimes an error even though the writing # operation should be completed. file.flush() # Python on Windows don't throw EPIPE errors for pipes. So reraise them with # the correct type and error number. except OSError: if sys.platform == 'win32': raise IOError(errno.EPIPE, "Broken pipe") raise ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.3903792 jedi-0.19.1/jedi/api/0000775000175000017500000000000000000000000014064 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/jedi/api/__init__.py0000664000175000017500000007725400000000000016214 0ustar00davedave00000000000000""" The API basically only provides one class. You can create a :class:`Script` and use its methods. Additionally you can add a debug function with :func:`set_debug_function`. Alternatively, if you don't need a custom function and are happy with printing debug messages to stdout, simply call :func:`set_debug_function` without arguments. """ import sys from pathlib import Path import parso from parso.python import tree from jedi.parser_utils import get_executable_nodes from jedi import debug from jedi import settings from jedi import cache from jedi.file_io import KnownContentFileIO from jedi.api import classes from jedi.api import interpreter from jedi.api import helpers from jedi.api.helpers import validate_line_column from jedi.api.completion import Completion, search_in_module from jedi.api.keywords import KeywordName from jedi.api.environment import InterpreterEnvironment from jedi.api.project import get_default_project, Project from jedi.api.errors import parso_to_jedi_errors from jedi.api import refactoring from jedi.api.refactoring.extract import extract_function, extract_variable from jedi.inference import InferenceState from jedi.inference import imports from jedi.inference.references import find_references from jedi.inference.arguments import try_iter_content from jedi.inference.helpers import infer_call_of_leaf from jedi.inference.sys_path import transform_path_to_dotted from jedi.inference.syntax_tree import tree_name_to_values from jedi.inference.value import ModuleValue from jedi.inference.base_value import ValueSet from jedi.inference.value.iterable import unpack_tuple_to_dict from jedi.inference.gradual.conversion import convert_names, convert_values from jedi.inference.gradual.utils import load_proper_stub_module from jedi.inference.utils import to_list # Jedi uses lots and lots of recursion. By setting this a little bit higher, we # can remove some "maximum recursion depth" errors. sys.setrecursionlimit(3000) class Script: """ A Script is the base for completions, goto or whatever you want to do with Jedi. The counter part of this class is :class:`Interpreter`, which works with actual dictionaries and can work with a REPL. This class should be used when a user edits code in an editor. You can either use the ``code`` parameter or ``path`` to read a file. Usually you're going to want to use both of them (in an editor). The Script's ``sys.path`` is very customizable: - If `project` is provided with a ``sys_path``, that is going to be used. - If `environment` is provided, its ``sys.path`` will be used (see :func:`Environment.get_sys_path `); - Otherwise ``sys.path`` will match that of the default environment of Jedi, which typically matches the sys path that was used at the time when Jedi was imported. Most methods have a ``line`` and a ``column`` parameter. Lines in Jedi are always 1-based and columns are always zero based. To avoid repetition they are not always documented. You can omit both line and column. Jedi will then just do whatever action you are calling at the end of the file. If you provide only the line, just will complete at the end of that line. .. warning:: By default :attr:`jedi.settings.fast_parser` is enabled, which means that parso reuses modules (i.e. they are not immutable). With this setting Jedi is **not thread safe** and it is also not safe to use multiple :class:`.Script` instances and its definitions at the same time. If you are a normal plugin developer this should not be an issue. It is an issue for people that do more complex stuff with Jedi. This is purely a performance optimization and works pretty well for all typical usages, however consider to turn the setting off if it causes you problems. See also `this discussion `_. :param code: The source code of the current file, separated by newlines. :type code: str :param path: The path of the file in the file system, or ``''`` if it hasn't been saved yet. :type path: str or pathlib.Path or None :param Environment environment: Provide a predefined :ref:`Environment ` to work with a specific Python version or virtualenv. :param Project project: Provide a :class:`.Project` to make sure finding references works well, because the right folder is searched. There are also ways to modify the sys path and other things. """ def __init__(self, code=None, *, path=None, environment=None, project=None): self._orig_path = path if isinstance(path, str): path = Path(path) self.path = path.absolute() if path else None if code is None: if path is None: raise ValueError("Must provide at least one of code or path") # TODO add a better warning than the traceback! with open(path, 'rb') as f: code = f.read() if project is None: # Load the Python grammar of the current interpreter. project = get_default_project(None if self.path is None else self.path.parent) self._inference_state = InferenceState( project, environment=environment, script_path=self.path ) debug.speed('init') self._module_node, code = self._inference_state.parse_and_get_code( code=code, path=self.path, use_latest_grammar=path and path.suffix == '.pyi', cache=False, # No disk cache, because the current script often changes. diff_cache=settings.fast_parser, cache_path=settings.cache_directory, ) debug.speed('parsed') self._code_lines = parso.split_lines(code, keepends=True) self._code = code cache.clear_time_caches() debug.reset_time() # Cache the module, this is mostly useful for testing, since this shouldn't # be called multiple times. @cache.memoize_method def _get_module(self): names = None is_package = False if self.path is not None: import_names, is_p = transform_path_to_dotted( self._inference_state.get_sys_path(add_parent_paths=False), self.path ) if import_names is not None: names = import_names is_package = is_p if self.path is None: file_io = None else: file_io = KnownContentFileIO(self.path, self._code) if self.path is not None and self.path.suffix == '.pyi': # We are in a stub file. Try to load the stub properly. stub_module = load_proper_stub_module( self._inference_state, self._inference_state.latest_grammar, file_io, names, self._module_node ) if stub_module is not None: return stub_module if names is None: names = ('__main__',) module = ModuleValue( self._inference_state, self._module_node, file_io=file_io, string_names=names, code_lines=self._code_lines, is_package=is_package, ) if names[0] not in ('builtins', 'typing'): # These modules are essential for Jedi, so don't overwrite them. self._inference_state.module_cache.add(names, ValueSet([module])) return module def _get_module_context(self): return self._get_module().as_context() def __repr__(self): return '<%s: %s %r>' % ( self.__class__.__name__, repr(self._orig_path), self._inference_state.environment, ) @validate_line_column def complete(self, line=None, column=None, *, fuzzy=False): """ Completes objects under the cursor. Those objects contain information about the completions, more than just names. :param fuzzy: Default False. Will return fuzzy completions, which means that e.g. ``ooa`` will match ``foobar``. :return: Completion objects, sorted by name. Normal names appear before "private" names that start with ``_`` and those appear before magic methods and name mangled names that start with ``__``. :rtype: list of :class:`.Completion` """ self._inference_state.reset_recursion_limitations() with debug.increase_indent_cm('complete'): completion = Completion( self._inference_state, self._get_module_context(), self._code_lines, (line, column), self.get_signatures, fuzzy=fuzzy, ) return completion.complete() @validate_line_column def infer(self, line=None, column=None, *, only_stubs=False, prefer_stubs=False): self._inference_state.reset_recursion_limitations() """ Return the definitions of under the cursor. It is basically a wrapper around Jedi's type inference. This method follows complicated paths and returns the end, not the first definition. The big difference between :meth:`goto` and :meth:`infer` is that :meth:`goto` doesn't follow imports and statements. Multiple objects may be returned, because depending on an option you can have two different versions of a function. :param only_stubs: Only return stubs for this method. :param prefer_stubs: Prefer stubs to Python objects for this method. :rtype: list of :class:`.Name` """ pos = line, column leaf = self._module_node.get_name_of_position(pos) if leaf is None: leaf = self._module_node.get_leaf_for_position(pos) if leaf is None or leaf.type == 'string': return [] if leaf.end_pos == (line, column) and leaf.type == 'operator': next_ = leaf.get_next_leaf() if next_.start_pos == leaf.end_pos \ and next_.type in ('number', 'string', 'keyword'): leaf = next_ context = self._get_module_context().create_context(leaf) values = helpers.infer(self._inference_state, context, leaf) values = convert_values( values, only_stubs=only_stubs, prefer_stubs=prefer_stubs, ) defs = [classes.Name(self._inference_state, c.name) for c in values] # The additional set here allows the definitions to become unique in an # API sense. In the internals we want to separate more things than in # the API. return helpers.sorted_definitions(set(defs)) @validate_line_column def goto(self, line=None, column=None, *, follow_imports=False, follow_builtin_imports=False, only_stubs=False, prefer_stubs=False): self._inference_state.reset_recursion_limitations() """ Goes to the name that defined the object under the cursor. Optionally you can follow imports. Multiple objects may be returned, depending on an if you can have two different versions of a function. :param follow_imports: The method will follow imports. :param follow_builtin_imports: If ``follow_imports`` is True will try to look up names in builtins (i.e. compiled or extension modules). :param only_stubs: Only return stubs for this method. :param prefer_stubs: Prefer stubs to Python objects for this method. :rtype: list of :class:`.Name` """ tree_name = self._module_node.get_name_of_position((line, column)) if tree_name is None: # Without a name we really just want to jump to the result e.g. # executed by `foo()`, if we the cursor is after `)`. return self.infer(line, column, only_stubs=only_stubs, prefer_stubs=prefer_stubs) name = self._get_module_context().create_name(tree_name) # Make it possible to goto the super class function/attribute # definitions, when they are overwritten. names = [] if name.tree_name.is_definition() and name.parent_context.is_class(): class_node = name.parent_context.tree_node class_value = self._get_module_context().create_value(class_node) mro = class_value.py__mro__() next(mro) # Ignore the first entry, because it's the class itself. for cls in mro: names = cls.goto(tree_name.value) if names: break if not names: names = list(name.goto()) if follow_imports: names = helpers.filter_follow_imports(names, follow_builtin_imports) names = convert_names( names, only_stubs=only_stubs, prefer_stubs=prefer_stubs, ) defs = [classes.Name(self._inference_state, d) for d in set(names)] # Avoid duplicates return list(set(helpers.sorted_definitions(defs))) def search(self, string, *, all_scopes=False): """ Searches a name in the current file. For a description of how the search string should look like, please have a look at :meth:`.Project.search`. :param bool all_scopes: Default False; searches not only for definitions on the top level of a module level, but also in functions and classes. :yields: :class:`.Name` """ return self._search_func(string, all_scopes=all_scopes) @to_list def _search_func(self, string, all_scopes=False, complete=False, fuzzy=False): names = self._names(all_scopes=all_scopes) wanted_type, wanted_names = helpers.split_search_string(string) return search_in_module( self._inference_state, self._get_module_context(), names=names, wanted_type=wanted_type, wanted_names=wanted_names, complete=complete, fuzzy=fuzzy, ) def complete_search(self, string, **kwargs): """ Like :meth:`.Script.search`, but completes that string. If you want to have all possible definitions in a file you can also provide an empty string. :param bool all_scopes: Default False; searches not only for definitions on the top level of a module level, but also in functions and classes. :param fuzzy: Default False. Will return fuzzy completions, which means that e.g. ``ooa`` will match ``foobar``. :yields: :class:`.Completion` """ return self._search_func(string, complete=True, **kwargs) @validate_line_column def help(self, line=None, column=None): """ Used to display a help window to users. Uses :meth:`.Script.goto` and returns additional definitions for keywords and operators. Typically you will want to display :meth:`.BaseName.docstring` to the user for all the returned definitions. The additional definitions are ``Name(...).type == 'keyword'``. These definitions do not have a lot of value apart from their docstring attribute, which contains the output of Python's :func:`help` function. :rtype: list of :class:`.Name` """ self._inference_state.reset_recursion_limitations() definitions = self.goto(line, column, follow_imports=True) if definitions: return definitions leaf = self._module_node.get_leaf_for_position((line, column)) if leaf is not None and leaf.end_pos == (line, column) and leaf.type == 'newline': next_ = leaf.get_next_leaf() if next_ is not None and next_.start_pos == leaf.end_pos: leaf = next_ if leaf is not None and leaf.type in ('keyword', 'operator', 'error_leaf'): def need_pydoc(): if leaf.value in ('(', ')', '[', ']'): if leaf.parent.type == 'trailer': return False if leaf.parent.type == 'atom': return False grammar = self._inference_state.grammar # This parso stuff is not public, but since I control it, this # is fine :-) ~dave reserved = grammar._pgen_grammar.reserved_syntax_strings.keys() return leaf.value in reserved if need_pydoc(): name = KeywordName(self._inference_state, leaf.value) return [classes.Name(self._inference_state, name)] return [] @validate_line_column def get_references(self, line=None, column=None, **kwargs): """ Lists all references of a variable in a project. Since this can be quite hard to do for Jedi, if it is too complicated, Jedi will stop searching. :param include_builtins: Default ``True``. If ``False``, checks if a definition is a builtin (e.g. ``sys``) and in that case does not return it. :param scope: Default ``'project'``. If ``'file'``, include references in the current module only. :rtype: list of :class:`.Name` """ self._inference_state.reset_recursion_limitations() def _references(include_builtins=True, scope='project'): if scope not in ('project', 'file'): raise ValueError('Only the scopes "file" and "project" are allowed') tree_name = self._module_node.get_name_of_position((line, column)) if tree_name is None: # Must be syntax return [] names = find_references(self._get_module_context(), tree_name, scope == 'file') definitions = [classes.Name(self._inference_state, n) for n in names] if not include_builtins or scope == 'file': definitions = [d for d in definitions if not d.in_builtin_module()] return helpers.sorted_definitions(definitions) return _references(**kwargs) @validate_line_column def get_signatures(self, line=None, column=None): """ Return the function object of the call under the cursor. E.g. if the cursor is here:: abs(# <-- cursor is here This would return the ``abs`` function. On the other hand:: abs()# <-- cursor is here This would return an empty list.. :rtype: list of :class:`.Signature` """ self._inference_state.reset_recursion_limitations() pos = line, column call_details = helpers.get_signature_details(self._module_node, pos) if call_details is None: return [] context = self._get_module_context().create_context(call_details.bracket_leaf) definitions = helpers.cache_signatures( self._inference_state, context, call_details.bracket_leaf, self._code_lines, pos ) debug.speed('func_call followed') # TODO here we use stubs instead of the actual values. We should use # the signatures from stubs, but the actual values, probably?! return [classes.Signature(self._inference_state, signature, call_details) for signature in definitions.get_signatures()] @validate_line_column def get_context(self, line=None, column=None): """ Returns the scope context under the cursor. This basically means the function, class or module where the cursor is at. :rtype: :class:`.Name` """ pos = (line, column) leaf = self._module_node.get_leaf_for_position(pos, include_prefixes=True) if leaf.start_pos > pos or leaf.type == 'endmarker': previous_leaf = leaf.get_previous_leaf() if previous_leaf is not None: leaf = previous_leaf module_context = self._get_module_context() n = tree.search_ancestor(leaf, 'funcdef', 'classdef') if n is not None and n.start_pos < pos <= n.children[-1].start_pos: # This is a bit of a special case. The context of a function/class # name/param/keyword is always it's parent context, not the # function itself. Catch all the cases here where we are before the # suite object, but still in the function. context = module_context.create_value(n).as_context() else: context = module_context.create_context(leaf) while context.name is None: context = context.parent_context # comprehensions definition = classes.Name(self._inference_state, context.name) while definition.type != 'module': name = definition._name # TODO private access tree_name = name.tree_name if tree_name is not None: # Happens with lambdas. scope = tree_name.get_definition() if scope.start_pos[1] < column: break definition = definition.parent() return definition def _analysis(self): self._inference_state.is_analysis = True self._inference_state.analysis_modules = [self._module_node] module = self._get_module_context() try: for node in get_executable_nodes(self._module_node): context = module.create_context(node) if node.type in ('funcdef', 'classdef'): # Resolve the decorators. tree_name_to_values(self._inference_state, context, node.children[1]) elif isinstance(node, tree.Import): import_names = set(node.get_defined_names()) if node.is_nested(): import_names |= set(path[-1] for path in node.get_paths()) for n in import_names: imports.infer_import(context, n) elif node.type == 'expr_stmt': types = context.infer_node(node) for testlist in node.children[:-1:2]: # Iterate tuples. unpack_tuple_to_dict(context, types, testlist) else: if node.type == 'name': defs = self._inference_state.infer(context, node) else: defs = infer_call_of_leaf(context, node) try_iter_content(defs) self._inference_state.reset_recursion_limitations() ana = [a for a in self._inference_state.analysis if self.path == a.path] return sorted(set(ana), key=lambda x: x.line) finally: self._inference_state.is_analysis = False def get_names(self, **kwargs): """ Returns names defined in the current file. :param all_scopes: If True lists the names of all scopes instead of only the module namespace. :param definitions: If True lists the names that have been defined by a class, function or a statement (``a = b`` returns ``a``). :param references: If True lists all the names that are not listed by ``definitions=True``. E.g. ``a = b`` returns ``b``. :rtype: list of :class:`.Name` """ names = self._names(**kwargs) return [classes.Name(self._inference_state, n) for n in names] def get_syntax_errors(self): """ Lists all syntax errors in the current file. :rtype: list of :class:`.SyntaxError` """ return parso_to_jedi_errors(self._inference_state.grammar, self._module_node) def _names(self, all_scopes=False, definitions=True, references=False): self._inference_state.reset_recursion_limitations() # Set line/column to a random position, because they don't matter. module_context = self._get_module_context() defs = [ module_context.create_name(name) for name in helpers.get_module_names( self._module_node, all_scopes=all_scopes, definitions=definitions, references=references, ) ] return sorted(defs, key=lambda x: x.start_pos) def rename(self, line=None, column=None, *, new_name): """ Renames all references of the variable under the cursor. :param new_name: The variable under the cursor will be renamed to this string. :raises: :exc:`.RefactoringError` :rtype: :class:`.Refactoring` """ definitions = self.get_references(line, column, include_builtins=False) return refactoring.rename(self._inference_state, definitions, new_name) @validate_line_column def extract_variable(self, line, column, *, new_name, until_line=None, until_column=None): """ Moves an expression to a new statement. For example if you have the cursor on ``foo`` and provide a ``new_name`` called ``bar``:: foo = 3.1 x = int(foo + 1) the code above will become:: foo = 3.1 bar = foo + 1 x = int(bar) :param new_name: The expression under the cursor will be renamed to this string. :param int until_line: The the selection range ends at this line, when omitted, Jedi will be clever and try to define the range itself. :param int until_column: The the selection range ends at this column, when omitted, Jedi will be clever and try to define the range itself. :raises: :exc:`.RefactoringError` :rtype: :class:`.Refactoring` """ if until_line is None and until_column is None: until_pos = None else: if until_line is None: until_line = line if until_column is None: until_column = len(self._code_lines[until_line - 1]) until_pos = until_line, until_column return extract_variable( self._inference_state, self.path, self._module_node, new_name, (line, column), until_pos ) @validate_line_column def extract_function(self, line, column, *, new_name, until_line=None, until_column=None): """ Moves an expression to a new function. For example if you have the cursor on ``foo`` and provide a ``new_name`` called ``bar``:: global_var = 3 def x(): foo = 3.1 x = int(foo + 1 + global_var) the code above will become:: global_var = 3 def bar(foo): return int(foo + 1 + global_var) def x(): foo = 3.1 x = bar(foo) :param new_name: The expression under the cursor will be replaced with a function with this name. :param int until_line: The the selection range ends at this line, when omitted, Jedi will be clever and try to define the range itself. :param int until_column: The the selection range ends at this column, when omitted, Jedi will be clever and try to define the range itself. :raises: :exc:`.RefactoringError` :rtype: :class:`.Refactoring` """ if until_line is None and until_column is None: until_pos = None else: if until_line is None: until_line = line if until_column is None: until_column = len(self._code_lines[until_line - 1]) until_pos = until_line, until_column return extract_function( self._inference_state, self.path, self._get_module_context(), new_name, (line, column), until_pos ) def inline(self, line=None, column=None): """ Inlines a variable under the cursor. This is basically the opposite of extracting a variable. For example with the cursor on bar:: foo = 3.1 bar = foo + 1 x = int(bar) the code above will become:: foo = 3.1 x = int(foo + 1) :raises: :exc:`.RefactoringError` :rtype: :class:`.Refactoring` """ names = [d._name for d in self.get_references(line, column, include_builtins=True)] return refactoring.inline(self._inference_state, names) class Interpreter(Script): """ Jedi's API for Python REPLs. Implements all of the methods that are present in :class:`.Script` as well. In addition to completions that normal REPL completion does like ``str.upper``, Jedi also supports code completion based on static code analysis. For example Jedi will complete ``str().upper``. >>> from os.path import join >>> namespace = locals() >>> script = Interpreter('join("").up', [namespace]) >>> print(script.complete()[0].name) upper All keyword arguments are same as the arguments for :class:`.Script`. :param str code: Code to parse. :type namespaces: typing.List[dict] :param namespaces: A list of namespace dictionaries such as the one returned by :func:`globals` and :func:`locals`. """ def __init__(self, code, namespaces, *, project=None, **kwds): try: namespaces = [dict(n) for n in namespaces] except Exception: raise TypeError("namespaces must be a non-empty list of dicts.") environment = kwds.get('environment', None) if environment is None: environment = InterpreterEnvironment() else: if not isinstance(environment, InterpreterEnvironment): raise TypeError("The environment needs to be an InterpreterEnvironment subclass.") if project is None: project = Project(Path.cwd()) super().__init__(code, environment=environment, project=project, **kwds) self.namespaces = namespaces self._inference_state.allow_unsafe_executions = \ settings.allow_unsafe_interpreter_executions # Dynamic params search is important when we work on functions that are # called by other pieces of code. However for interpreter completions # this is not important at all, because the current code is always new # and will never be called by something. # Also sometimes this logic goes a bit too far like in # https://github.com/ipython/ipython/issues/13866, where it takes # seconds to do a simple completion. self._inference_state.do_dynamic_params_search = False @cache.memoize_method def _get_module_context(self): if self.path is None: file_io = None else: file_io = KnownContentFileIO(self.path, self._code) tree_module_value = ModuleValue( self._inference_state, self._module_node, file_io=file_io, string_names=('__main__',), code_lines=self._code_lines, ) return interpreter.MixedModuleContext( tree_module_value, self.namespaces, ) def preload_module(*modules): """ Preloading modules tells Jedi to load a module now, instead of lazy parsing of modules. This can be useful for IDEs, to control which modules to load on startup. :param modules: different module names, list of string. """ for m in modules: s = "import %s as x; x." % m Script(s).complete(1, len(s)) def set_debug_function(func_cb=debug.print_to_stdout, warnings=True, notices=True, speed=True): """ Define a callback debug function to get all the debug messages. If you don't specify any arguments, debug messages will be printed to stdout. :param func_cb: The callback function for debug messages. """ debug.debug_function = func_cb debug.enable_warning = warnings debug.enable_notice = notices debug.enable_speed = speed ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/jedi/api/classes.py0000664000175000017500000007164000000000000016103 0ustar00davedave00000000000000""" There are a couple of classes documented in here: - :class:`.BaseName` as an abstact base class for almost everything. - :class:`.Name` used in a lot of places - :class:`.Completion` for completions - :class:`.BaseSignature` as a base class for signatures - :class:`.Signature` for :meth:`.Script.get_signatures` only - :class:`.ParamName` used for parameters of signatures - :class:`.Refactoring` for refactorings - :class:`.SyntaxError` for :meth:`.Script.get_syntax_errors` only These classes are the much biggest part of the API, because they contain the interesting information about all operations. """ import re from pathlib import Path from typing import Optional from parso.tree import search_ancestor from jedi import settings from jedi import debug from jedi.inference.utils import unite from jedi.cache import memoize_method from jedi.inference.compiled.mixed import MixedName from jedi.inference.names import ImportName, SubModuleName from jedi.inference.gradual.stub_value import StubModuleValue from jedi.inference.gradual.conversion import convert_names, convert_values from jedi.inference.base_value import ValueSet, HasNoContext from jedi.api.keywords import KeywordName from jedi.api import completion_cache from jedi.api.helpers import filter_follow_imports def _sort_names_by_start_pos(names): return sorted(names, key=lambda s: s.start_pos or (0, 0)) def defined_names(inference_state, value): """ List sub-definitions (e.g., methods in class). :type scope: Scope :rtype: list of Name """ try: context = value.as_context() except HasNoContext: return [] filter = next(context.get_filters()) names = [name for name in filter.values()] return [Name(inference_state, n) for n in _sort_names_by_start_pos(names)] def _values_to_definitions(values): return [Name(c.inference_state, c.name) for c in values] class BaseName: """ The base class for all definitions, completions and signatures. """ _mapping = { 'posixpath': 'os.path', 'riscospath': 'os.path', 'ntpath': 'os.path', 'os2emxpath': 'os.path', 'macpath': 'os.path', 'genericpath': 'os.path', 'posix': 'os', '_io': 'io', '_functools': 'functools', '_collections': 'collections', '_socket': 'socket', '_sqlite3': 'sqlite3', } _tuple_mapping = dict((tuple(k.split('.')), v) for (k, v) in { 'argparse._ActionsContainer': 'argparse.ArgumentParser', }.items()) def __init__(self, inference_state, name): self._inference_state = inference_state self._name = name """ An instance of :class:`parso.python.tree.Name` subclass. """ self.is_keyword = isinstance(self._name, KeywordName) @memoize_method def _get_module_context(self): # This can take a while to complete, because in the worst case of # imports (consider `import a` completions), we need to load all # modules starting with a first. return self._name.get_root_context() @property def module_path(self) -> Optional[Path]: """ Shows the file path of a module. e.g. ``/usr/lib/python3.9/os.py`` """ module = self._get_module_context() if module.is_stub() or not module.is_compiled(): # Compiled modules should not return a module path even if they # have one. path: Optional[Path] = self._get_module_context().py__file__() return path return None @property def name(self): """ Name of variable/function/class/module. For example, for ``x = None`` it returns ``'x'``. :rtype: str or None """ return self._name.get_public_name() @property def type(self): """ The type of the definition. Here is an example of the value of this attribute. Let's consider the following source. As what is in ``variable`` is unambiguous to Jedi, :meth:`jedi.Script.infer` should return a list of definition for ``sys``, ``f``, ``C`` and ``x``. >>> from jedi import Script >>> source = ''' ... import keyword ... ... class C: ... pass ... ... class D: ... pass ... ... x = D() ... ... def f(): ... pass ... ... for variable in [keyword, f, C, x]: ... variable''' >>> script = Script(source) >>> defs = script.infer() Before showing what is in ``defs``, let's sort it by :attr:`line` so that it is easy to relate the result to the source code. >>> defs = sorted(defs, key=lambda d: d.line) >>> print(defs) # doctest: +NORMALIZE_WHITESPACE [, , , ] Finally, here is what you can get from :attr:`type`: >>> defs = [d.type for d in defs] >>> defs[0] 'module' >>> defs[1] 'class' >>> defs[2] 'instance' >>> defs[3] 'function' Valid values for type are ``module``, ``class``, ``instance``, ``function``, ``param``, ``path``, ``keyword``, ``property`` and ``statement``. """ tree_name = self._name.tree_name resolve = False if tree_name is not None: # TODO move this to their respective names. definition = tree_name.get_definition() if definition is not None and definition.type == 'import_from' and \ tree_name.is_definition(): resolve = True if isinstance(self._name, SubModuleName) or resolve: for value in self._name.infer(): return value.api_type return self._name.api_type @property def module_name(self): """ The module name, a bit similar to what ``__name__`` is in a random Python module. >>> from jedi import Script >>> source = 'import json' >>> script = Script(source, path='example.py') >>> d = script.infer()[0] >>> print(d.module_name) # doctest: +ELLIPSIS json """ return self._get_module_context().py__name__() def in_builtin_module(self): """ Returns True, if this is a builtin module. """ value = self._get_module_context().get_value() if isinstance(value, StubModuleValue): return any(v.is_compiled() for v in value.non_stub_value_set) return value.is_compiled() @property def line(self): """The line where the definition occurs (starting with 1).""" start_pos = self._name.start_pos if start_pos is None: return None return start_pos[0] @property def column(self): """The column where the definition occurs (starting with 0).""" start_pos = self._name.start_pos if start_pos is None: return None return start_pos[1] def get_definition_start_position(self): """ The (row, column) of the start of the definition range. Rows start with 1, columns start with 0. :rtype: Optional[Tuple[int, int]] """ if self._name.tree_name is None: return None definition = self._name.tree_name.get_definition() if definition is None: return self._name.start_pos return definition.start_pos def get_definition_end_position(self): """ The (row, column) of the end of the definition range. Rows start with 1, columns start with 0. :rtype: Optional[Tuple[int, int]] """ if self._name.tree_name is None: return None definition = self._name.tree_name.get_definition() if definition is None: return self._name.tree_name.end_pos if self.type in ("function", "class"): last_leaf = definition.get_last_leaf() if last_leaf.type == "newline": return last_leaf.get_previous_leaf().end_pos return last_leaf.end_pos return definition.end_pos def docstring(self, raw=False, fast=True): r""" Return a document string for this completion object. Example: >>> from jedi import Script >>> source = '''\ ... def f(a, b=1): ... "Document for function f." ... ''' >>> script = Script(source, path='example.py') >>> doc = script.infer(1, len('def f'))[0].docstring() >>> print(doc) f(a, b=1) Document for function f. Notice that useful extra information is added to the actual docstring, e.g. function signatures are prepended to their docstrings. If you need the actual docstring, use ``raw=True`` instead. >>> print(script.infer(1, len('def f'))[0].docstring(raw=True)) Document for function f. :param fast: Don't follow imports that are only one level deep like ``import foo``, but follow ``from foo import bar``. This makes sense for speed reasons. Completing `import a` is slow if you use the ``foo.docstring(fast=False)`` on every object, because it parses all libraries starting with ``a``. """ if isinstance(self._name, ImportName) and fast: return '' doc = self._get_docstring() if raw: return doc signature_text = self._get_docstring_signature() if signature_text and doc: return signature_text + '\n\n' + doc else: return signature_text + doc def _get_docstring(self): return self._name.py__doc__() def _get_docstring_signature(self): return '\n'.join( signature.to_string() for signature in self._get_signatures(for_docstring=True) ) @property def description(self): """ A description of the :class:`.Name` object, which is heavily used in testing. e.g. for ``isinstance`` it returns ``def isinstance``. Example: >>> from jedi import Script >>> source = ''' ... def f(): ... pass ... ... class C: ... pass ... ... variable = f if random.choice([0,1]) else C''' >>> script = Script(source) # line is maximum by default >>> defs = script.infer(column=3) >>> defs = sorted(defs, key=lambda d: d.line) >>> print(defs) # doctest: +NORMALIZE_WHITESPACE [, ] >>> str(defs[0].description) 'def f' >>> str(defs[1].description) 'class C' """ typ = self.type tree_name = self._name.tree_name if typ == 'param': return typ + ' ' + self._name.to_string() if typ in ('function', 'class', 'module', 'instance') or tree_name is None: if typ == 'function': # For the description we want a short and a pythonic way. typ = 'def' return typ + ' ' + self._name.get_public_name() definition = tree_name.get_definition(include_setitem=True) or tree_name # Remove the prefix, because that's not what we want for get_code # here. txt = definition.get_code(include_prefix=False) # Delete comments: txt = re.sub(r'#[^\n]+\n', ' ', txt) # Delete multi spaces/newlines txt = re.sub(r'\s+', ' ', txt).strip() return txt @property def full_name(self): """ Dot-separated path of this object. It is in the form of ``[.[...]][.]``. It is useful when you want to look up Python manual of the object at hand. Example: >>> from jedi import Script >>> source = ''' ... import os ... os.path.join''' >>> script = Script(source, path='example.py') >>> print(script.infer(3, len('os.path.join'))[0].full_name) os.path.join Notice that it returns ``'os.path.join'`` instead of (for example) ``'posixpath.join'``. This is not correct, since the modules name would be `````. However most users find the latter more practical. """ if not self._name.is_value_name: return None names = self._name.get_qualified_names(include_module_names=True) if names is None: return None names = list(names) try: names[0] = self._mapping[names[0]] except KeyError: pass return '.'.join(names) def is_stub(self): """ Returns True if the current name is defined in a stub file. """ if not self._name.is_value_name: return False return self._name.get_root_context().is_stub() def is_side_effect(self): """ Checks if a name is defined as ``self.foo = 3``. In case of self, this function would return False, for foo it would return True. """ tree_name = self._name.tree_name if tree_name is None: return False return tree_name.is_definition() and tree_name.parent.type == 'trailer' @debug.increase_indent_cm('goto on name') def goto(self, *, follow_imports=False, follow_builtin_imports=False, only_stubs=False, prefer_stubs=False): """ Like :meth:`.Script.goto` (also supports the same params), but does it for the current name. This is typically useful if you are using something like :meth:`.Script.get_names()`. :param follow_imports: The goto call will follow imports. :param follow_builtin_imports: If follow_imports is True will try to look up names in builtins (i.e. compiled or extension modules). :param only_stubs: Only return stubs for this goto call. :param prefer_stubs: Prefer stubs to Python objects for this goto call. :rtype: list of :class:`Name` """ if not self._name.is_value_name: return [] names = self._name.goto() if follow_imports: names = filter_follow_imports(names, follow_builtin_imports) names = convert_names( names, only_stubs=only_stubs, prefer_stubs=prefer_stubs, ) return [self if n == self._name else Name(self._inference_state, n) for n in names] @debug.increase_indent_cm('infer on name') def infer(self, *, only_stubs=False, prefer_stubs=False): """ Like :meth:`.Script.infer`, it can be useful to understand which type the current name has. Return the actual definitions. I strongly recommend not using it for your completions, because it might slow down |jedi|. If you want to read only a few objects (<=20), it might be useful, especially to get the original docstrings. The basic problem of this function is that it follows all results. This means with 1000 completions (e.g. numpy), it's just very, very slow. :param only_stubs: Only return stubs for this goto call. :param prefer_stubs: Prefer stubs to Python objects for this type inference call. :rtype: list of :class:`Name` """ assert not (only_stubs and prefer_stubs) if not self._name.is_value_name: return [] # First we need to make sure that we have stub names (if possible) that # we can follow. If we don't do that, we can end up with the inferred # results of Python objects instead of stubs. names = convert_names([self._name], prefer_stubs=True) values = convert_values( ValueSet.from_sets(n.infer() for n in names), only_stubs=only_stubs, prefer_stubs=prefer_stubs, ) resulting_names = [c.name for c in values] return [self if n == self._name else Name(self._inference_state, n) for n in resulting_names] def parent(self): """ Returns the parent scope of this identifier. :rtype: Name """ if not self._name.is_value_name: return None if self.type in ('function', 'class', 'param') and self._name.tree_name is not None: # Since the parent_context doesn't really match what the user # thinks of that the parent is here, we do these cases separately. # The reason for this is the following: # - class: Nested classes parent_context is always the # parent_context of the most outer one. # - function: Functions in classes have the module as # parent_context. # - param: The parent_context of a param is not its function but # e.g. the outer class or module. cls_or_func_node = self._name.tree_name.get_definition() parent = search_ancestor(cls_or_func_node, 'funcdef', 'classdef', 'file_input') context = self._get_module_context().create_value(parent).as_context() else: context = self._name.parent_context if context is None: return None while context.name is None: # Happens for comprehension contexts context = context.parent_context return Name(self._inference_state, context.name) def __repr__(self): return "<%s %sname=%r, description=%r>" % ( self.__class__.__name__, 'full_' if self.full_name else '', self.full_name or self.name, self.description, ) def get_line_code(self, before=0, after=0): """ Returns the line of code where this object was defined. :param before: Add n lines before the current line to the output. :param after: Add n lines after the current line to the output. :return str: Returns the line(s) of code or an empty string if it's a builtin. """ if not self._name.is_value_name: return '' lines = self._name.get_root_context().code_lines if lines is None: # Probably a builtin module, just ignore in that case. return '' index = self._name.start_pos[0] - 1 start_index = max(index - before, 0) return ''.join(lines[start_index:index + after + 1]) def _get_signatures(self, for_docstring=False): if self._name.api_type == 'property': return [] if for_docstring and self._name.api_type == 'statement' and not self.is_stub(): # For docstrings we don't resolve signatures if they are simple # statements and not stubs. This is a speed optimization. return [] if isinstance(self._name, MixedName): # While this would eventually happen anyway, it's basically just a # shortcut to not infer anything tree related, because it's really # not necessary. return self._name.infer_compiled_value().get_signatures() names = convert_names([self._name], prefer_stubs=True) return [sig for name in names for sig in name.infer().get_signatures()] def get_signatures(self): """ Returns all potential signatures for a function or a class. Multiple signatures are typical if you use Python stubs with ``@overload``. :rtype: list of :class:`BaseSignature` """ return [ BaseSignature(self._inference_state, s) for s in self._get_signatures() ] def execute(self): """ Uses type inference to "execute" this identifier and returns the executed objects. :rtype: list of :class:`Name` """ return _values_to_definitions(self._name.infer().execute_with_values()) def get_type_hint(self): """ Returns type hints like ``Iterable[int]`` or ``Union[int, str]``. This method might be quite slow, especially for functions. The problem is finding executions for those functions to return something like ``Callable[[int, str], str]``. :rtype: str """ return self._name.infer().get_type_hint() class Completion(BaseName): """ ``Completion`` objects are returned from :meth:`.Script.complete`. They provide additional information about a completion. """ def __init__(self, inference_state, name, stack, like_name_length, is_fuzzy, cached_name=None): super().__init__(inference_state, name) self._like_name_length = like_name_length self._stack = stack self._is_fuzzy = is_fuzzy self._cached_name = cached_name # Completion objects with the same Completion name (which means # duplicate items in the completion) self._same_name_completions = [] def _complete(self, like_name): append = '' if settings.add_bracket_after_function \ and self.type == 'function': append = '(' name = self._name.get_public_name() if like_name: name = name[self._like_name_length:] return name + append @property def complete(self): """ Only works with non-fuzzy completions. Returns None if fuzzy completions are used. Return the rest of the word, e.g. completing ``isinstance``:: isinstan# <-- Cursor is here would return the string 'ce'. It also adds additional stuff, depending on your ``settings.py``. Assuming the following function definition:: def foo(param=0): pass completing ``foo(par`` would give a ``Completion`` which ``complete`` would be ``am=``. """ if self._is_fuzzy: return None return self._complete(True) @property def name_with_symbols(self): """ Similar to :attr:`.name`, but like :attr:`.name` returns also the symbols, for example assuming the following function definition:: def foo(param=0): pass completing ``foo(`` would give a ``Completion`` which ``name_with_symbols`` would be "param=". """ return self._complete(False) def docstring(self, raw=False, fast=True): """ Documented under :meth:`BaseName.docstring`. """ if self._like_name_length >= 3: # In this case we can just resolve the like name, because we # wouldn't load like > 100 Python modules anymore. fast = False return super().docstring(raw=raw, fast=fast) def _get_docstring(self): if self._cached_name is not None: return completion_cache.get_docstring( self._cached_name, self._name.get_public_name(), lambda: self._get_cache() ) return super()._get_docstring() def _get_docstring_signature(self): if self._cached_name is not None: return completion_cache.get_docstring_signature( self._cached_name, self._name.get_public_name(), lambda: self._get_cache() ) return super()._get_docstring_signature() def _get_cache(self): return ( super().type, super()._get_docstring_signature(), super()._get_docstring(), ) @property def type(self): """ Documented under :meth:`BaseName.type`. """ # Purely a speed optimization. if self._cached_name is not None: return completion_cache.get_type( self._cached_name, self._name.get_public_name(), lambda: self._get_cache() ) return super().type def get_completion_prefix_length(self): """ Returns the length of the prefix being completed. For example, completing ``isinstance``:: isinstan# <-- Cursor is here would return 8, because len('isinstan') == 8. Assuming the following function definition:: def foo(param=0): pass completing ``foo(par`` would return 3. """ return self._like_name_length def __repr__(self): return '<%s: %s>' % (type(self).__name__, self._name.get_public_name()) class Name(BaseName): """ *Name* objects are returned from many different APIs including :meth:`.Script.goto` or :meth:`.Script.infer`. """ def __init__(self, inference_state, definition): super().__init__(inference_state, definition) @memoize_method def defined_names(self): """ List sub-definitions (e.g., methods in class). :rtype: list of :class:`Name` """ defs = self._name.infer() return sorted( unite(defined_names(self._inference_state, d) for d in defs), key=lambda s: s._name.start_pos or (0, 0) ) def is_definition(self): """ Returns True, if defined as a name in a statement, function or class. Returns False, if it's a reference to such a definition. """ if self._name.tree_name is None: return True else: return self._name.tree_name.is_definition() def __eq__(self, other): return self._name.start_pos == other._name.start_pos \ and self.module_path == other.module_path \ and self.name == other.name \ and self._inference_state == other._inference_state def __ne__(self, other): return not self.__eq__(other) def __hash__(self): return hash((self._name.start_pos, self.module_path, self.name, self._inference_state)) class BaseSignature(Name): """ These signatures are returned by :meth:`BaseName.get_signatures` calls. """ def __init__(self, inference_state, signature): super().__init__(inference_state, signature.name) self._signature = signature @property def params(self): """ Returns definitions for all parameters that a signature defines. This includes stuff like ``*args`` and ``**kwargs``. :rtype: list of :class:`.ParamName` """ return [ParamName(self._inference_state, n) for n in self._signature.get_param_names(resolve_stars=True)] def to_string(self): """ Returns a text representation of the signature. This could for example look like ``foo(bar, baz: int, **kwargs)``. :rtype: str """ return self._signature.to_string() class Signature(BaseSignature): """ A full signature object is the return value of :meth:`.Script.get_signatures`. """ def __init__(self, inference_state, signature, call_details): super().__init__(inference_state, signature) self._call_details = call_details self._signature = signature @property def index(self): """ Returns the param index of the current cursor position. Returns None if the index cannot be found in the curent call. :rtype: int """ return self._call_details.calculate_index( self._signature.get_param_names(resolve_stars=True) ) @property def bracket_start(self): """ Returns a line/column tuple of the bracket that is responsible for the last function call. The first line is 1 and the first column 0. :rtype: int, int """ return self._call_details.bracket_leaf.start_pos def __repr__(self): return '<%s: index=%r %s>' % ( type(self).__name__, self.index, self._signature.to_string(), ) class ParamName(Name): def infer_default(self): """ Returns default values like the ``1`` of ``def foo(x=1):``. :rtype: list of :class:`.Name` """ return _values_to_definitions(self._name.infer_default()) def infer_annotation(self, **kwargs): """ :param execute_annotation: Default True; If False, values are not executed and classes are returned instead of instances. :rtype: list of :class:`.Name` """ return _values_to_definitions(self._name.infer_annotation(ignore_stars=True, **kwargs)) def to_string(self): """ Returns a simple representation of a param, like ``f: Callable[..., Any]``. :rtype: str """ return self._name.to_string() @property def kind(self): """ Returns an enum instance of :mod:`inspect`'s ``Parameter`` enum. :rtype: :py:attr:`inspect.Parameter.kind` """ return self._name.get_kind() ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/jedi/api/completion.py0000664000175000017500000006506700000000000016625 0ustar00davedave00000000000000import re from textwrap import dedent from inspect import Parameter from parso.python.token import PythonTokenTypes from parso.python import tree from parso.tree import search_ancestor, Leaf from parso import split_lines from jedi import debug from jedi import settings from jedi.api import classes from jedi.api import helpers from jedi.api import keywords from jedi.api.strings import complete_dict from jedi.api.file_name import complete_file_name from jedi.inference import imports from jedi.inference.base_value import ValueSet from jedi.inference.helpers import infer_call_of_leaf, parse_dotted_names from jedi.inference.context import get_global_filters from jedi.inference.value import TreeInstance from jedi.inference.docstring_utils import DocstringModule from jedi.inference.names import ParamNameWrapper, SubModuleName from jedi.inference.gradual.conversion import convert_values, convert_names from jedi.parser_utils import cut_value_at_position from jedi.plugins import plugin_manager class ParamNameWithEquals(ParamNameWrapper): def get_public_name(self): return self.string_name + '=' def _get_signature_param_names(signatures, positional_count, used_kwargs): # Add named params for call_sig in signatures: for i, p in enumerate(call_sig.params): kind = p.kind if i < positional_count and kind == Parameter.POSITIONAL_OR_KEYWORD: continue if kind in (Parameter.POSITIONAL_OR_KEYWORD, Parameter.KEYWORD_ONLY) \ and p.name not in used_kwargs: yield ParamNameWithEquals(p._name) def _must_be_kwarg(signatures, positional_count, used_kwargs): if used_kwargs: return True must_be_kwarg = True for signature in signatures: for i, p in enumerate(signature.params): kind = p.kind if kind is Parameter.VAR_POSITIONAL: # In case there were not already kwargs, the next param can # always be a normal argument. return False if i >= positional_count and kind in (Parameter.POSITIONAL_OR_KEYWORD, Parameter.POSITIONAL_ONLY): must_be_kwarg = False break if not must_be_kwarg: break return must_be_kwarg def filter_names(inference_state, completion_names, stack, like_name, fuzzy, cached_name): comp_dct = set() if settings.case_insensitive_completion: like_name = like_name.lower() for name in completion_names: string = name.string_name if settings.case_insensitive_completion: string = string.lower() if helpers.match(string, like_name, fuzzy=fuzzy): new = classes.Completion( inference_state, name, stack, len(like_name), is_fuzzy=fuzzy, cached_name=cached_name, ) k = (new.name, new.complete) # key if k not in comp_dct: comp_dct.add(k) tree_name = name.tree_name if tree_name is not None: definition = tree_name.get_definition() if definition is not None and definition.type == 'del_stmt': continue yield new def _remove_duplicates(completions, other_completions): names = {d.name for d in other_completions} return [c for c in completions if c.name not in names] def get_user_context(module_context, position): """ Returns the scope in which the user resides. This includes flows. """ leaf = module_context.tree_node.get_leaf_for_position(position, include_prefixes=True) return module_context.create_context(leaf) def get_flow_scope_node(module_node, position): node = module_node.get_leaf_for_position(position, include_prefixes=True) while not isinstance(node, (tree.Scope, tree.Flow)): node = node.parent return node @plugin_manager.decorate() def complete_param_names(context, function_name, decorator_nodes): # Basically there's no way to do param completion. The plugins are # responsible for this. return [] class Completion: def __init__(self, inference_state, module_context, code_lines, position, signatures_callback, fuzzy=False): self._inference_state = inference_state self._module_context = module_context self._module_node = module_context.tree_node self._code_lines = code_lines # The first step of completions is to get the name self._like_name = helpers.get_on_completion_name(self._module_node, code_lines, position) # The actual cursor position is not what we need to calculate # everything. We want the start of the name we're on. self._original_position = position self._signatures_callback = signatures_callback self._fuzzy = fuzzy def complete(self): leaf = self._module_node.get_leaf_for_position( self._original_position, include_prefixes=True ) string, start_leaf, quote = _extract_string_while_in_string(leaf, self._original_position) prefixed_completions = complete_dict( self._module_context, self._code_lines, start_leaf or leaf, self._original_position, None if string is None else quote + string, fuzzy=self._fuzzy, ) if string is not None and not prefixed_completions: prefixed_completions = list(complete_file_name( self._inference_state, self._module_context, start_leaf, quote, string, self._like_name, self._signatures_callback, self._code_lines, self._original_position, self._fuzzy )) if string is not None: if not prefixed_completions and '\n' in string: # Complete only multi line strings prefixed_completions = self._complete_in_string(start_leaf, string) return prefixed_completions cached_name, completion_names = self._complete_python(leaf) completions = list(filter_names(self._inference_state, completion_names, self.stack, self._like_name, self._fuzzy, cached_name=cached_name)) return ( # Removing duplicates mostly to remove False/True/None duplicates. _remove_duplicates(prefixed_completions, completions) + sorted(completions, key=lambda x: (x.name.startswith('__'), x.name.startswith('_'), x.name.lower())) ) def _complete_python(self, leaf): """ Analyzes the current context of a completion and decides what to return. Technically this works by generating a parser stack and analysing the current stack for possible grammar nodes. Possible enhancements: - global/nonlocal search global - yield from / raise from <- could be only exceptions/generators - In args: */**: no completion - In params (also lambda): no completion before = """ grammar = self._inference_state.grammar self.stack = stack = None self._position = ( self._original_position[0], self._original_position[1] - len(self._like_name) ) cached_name = None try: self.stack = stack = helpers.get_stack_at_position( grammar, self._code_lines, leaf, self._position ) except helpers.OnErrorLeaf as e: value = e.error_leaf.value if value == '.': # After ErrorLeaf's that are dots, we will not do any # completions since this probably just confuses the user. return cached_name, [] # If we don't have a value, just use global completion. return cached_name, self._complete_global_scope() allowed_transitions = \ list(stack._allowed_transition_names_and_token_types()) if 'if' in allowed_transitions: leaf = self._module_node.get_leaf_for_position(self._position, include_prefixes=True) previous_leaf = leaf.get_previous_leaf() indent = self._position[1] if not (leaf.start_pos <= self._position <= leaf.end_pos): indent = leaf.start_pos[1] if previous_leaf is not None: stmt = previous_leaf while True: stmt = search_ancestor( stmt, 'if_stmt', 'for_stmt', 'while_stmt', 'try_stmt', 'error_node', ) if stmt is None: break type_ = stmt.type if type_ == 'error_node': first = stmt.children[0] if isinstance(first, Leaf): type_ = first.value + '_stmt' # Compare indents if stmt.start_pos[1] == indent: if type_ == 'if_stmt': allowed_transitions += ['elif', 'else'] elif type_ == 'try_stmt': allowed_transitions += ['except', 'finally', 'else'] elif type_ == 'for_stmt': allowed_transitions.append('else') completion_names = [] kwargs_only = False if any(t in allowed_transitions for t in (PythonTokenTypes.NAME, PythonTokenTypes.INDENT)): # This means that we actually have to do type inference. nonterminals = [stack_node.nonterminal for stack_node in stack] nodes = _gather_nodes(stack) if nodes and nodes[-1] in ('as', 'def', 'class'): # No completions for ``with x as foo`` and ``import x as foo``. # Also true for defining names as a class or function. return cached_name, list(self._complete_inherited(is_function=True)) elif "import_stmt" in nonterminals: level, names = parse_dotted_names(nodes, "import_from" in nonterminals) only_modules = not ("import_from" in nonterminals and 'import' in nodes) completion_names += self._get_importer_names( names, level, only_modules=only_modules, ) elif nonterminals[-1] in ('trailer', 'dotted_name') and nodes[-1] == '.': dot = self._module_node.get_leaf_for_position(self._position) if dot.type == "endmarker": # This is a bit of a weird edge case, maybe we can somehow # generalize this. dot = leaf.get_previous_leaf() cached_name, n = self._complete_trailer(dot.get_previous_leaf()) completion_names += n elif self._is_parameter_completion(): completion_names += self._complete_params(leaf) else: # Apparently this looks like it's good enough to filter most cases # so that signature completions don't randomly appear. # To understand why this works, three things are important: # 1. trailer with a `,` in it is either a subscript or an arglist. # 2. If there's no `,`, it's at the start and only signatures start # with `(`. Other trailers could start with `.` or `[`. # 3. Decorators are very primitive and have an optional `(` with # optional arglist in them. if nodes[-1] in ['(', ','] \ and nonterminals[-1] in ('trailer', 'arglist', 'decorator'): signatures = self._signatures_callback(*self._position) if signatures: call_details = signatures[0]._call_details used_kwargs = list(call_details.iter_used_keyword_arguments()) positional_count = call_details.count_positional_arguments() completion_names += _get_signature_param_names( signatures, positional_count, used_kwargs, ) kwargs_only = _must_be_kwarg(signatures, positional_count, used_kwargs) if not kwargs_only: completion_names += self._complete_global_scope() completion_names += self._complete_inherited(is_function=False) if not kwargs_only: current_line = self._code_lines[self._position[0] - 1][:self._position[1]] completion_names += self._complete_keywords( allowed_transitions, only_values=not (not current_line or current_line[-1] in ' \t.;' and current_line[-3:] != '...') ) return cached_name, completion_names def _is_parameter_completion(self): tos = self.stack[-1] if tos.nonterminal == 'lambdef' and len(tos.nodes) == 1: # We are at the position `lambda `, where basically the next node # is a param. return True if tos.nonterminal in 'parameters': # Basically we are at the position `foo(`, there's nothing there # yet, so we have no `typedargslist`. return True # var args is for lambdas and typed args for normal functions return tos.nonterminal in ('typedargslist', 'varargslist') and tos.nodes[-1] == ',' def _complete_params(self, leaf): stack_node = self.stack[-2] if stack_node.nonterminal == 'parameters': stack_node = self.stack[-3] if stack_node.nonterminal == 'funcdef': context = get_user_context(self._module_context, self._position) node = search_ancestor(leaf, 'error_node', 'funcdef') if node is not None: if node.type == 'error_node': n = node.children[0] if n.type == 'decorators': decorators = n.children elif n.type == 'decorator': decorators = [n] else: decorators = [] else: decorators = node.get_decorators() function_name = stack_node.nodes[1] return complete_param_names(context, function_name.value, decorators) return [] def _complete_keywords(self, allowed_transitions, only_values): for k in allowed_transitions: if isinstance(k, str) and k.isalpha(): if not only_values or k in ('True', 'False', 'None'): yield keywords.KeywordName(self._inference_state, k) def _complete_global_scope(self): context = get_user_context(self._module_context, self._position) debug.dbg('global completion scope: %s', context) flow_scope_node = get_flow_scope_node(self._module_node, self._position) filters = get_global_filters( context, self._position, flow_scope_node ) completion_names = [] for filter in filters: completion_names += filter.values() return completion_names def _complete_trailer(self, previous_leaf): inferred_context = self._module_context.create_context(previous_leaf) values = infer_call_of_leaf(inferred_context, previous_leaf) debug.dbg('trailer completion values: %s', values, color='MAGENTA') # The cached name simply exists to make speed optimizations for certain # modules. cached_name = None if len(values) == 1: v, = values if v.is_module(): if len(v.string_names) == 1: module_name = v.string_names[0] if module_name in ('numpy', 'tensorflow', 'matplotlib', 'pandas'): cached_name = module_name return cached_name, self._complete_trailer_for_values(values) def _complete_trailer_for_values(self, values): user_context = get_user_context(self._module_context, self._position) return complete_trailer(user_context, values) def _get_importer_names(self, names, level=0, only_modules=True): names = [n.value for n in names] i = imports.Importer(self._inference_state, names, self._module_context, level) return i.completion_names(self._inference_state, only_modules=only_modules) def _complete_inherited(self, is_function=True): """ Autocomplete inherited methods when overriding in child class. """ leaf = self._module_node.get_leaf_for_position(self._position, include_prefixes=True) cls = tree.search_ancestor(leaf, 'classdef') if cls is None: return # Complete the methods that are defined in the super classes. class_value = self._module_context.create_value(cls) if cls.start_pos[1] >= leaf.start_pos[1]: return filters = class_value.get_filters(is_instance=True) # The first dict is the dictionary of class itself. next(filters) for filter in filters: for name in filter.values(): # TODO we should probably check here for properties if (name.api_type == 'function') == is_function: yield name def _complete_in_string(self, start_leaf, string): """ To make it possible for people to have completions in doctests or generally in "Python" code in docstrings, we use the following heuristic: - Having an indented block of code - Having some doctest code that starts with `>>>` - Having backticks that doesn't have whitespace inside it """ def iter_relevant_lines(lines): include_next_line = False for l in code_lines: if include_next_line or l.startswith('>>>') or l.startswith(' '): yield re.sub(r'^( *>>> ?| +)', '', l) else: yield None include_next_line = bool(re.match(' *>>>', l)) string = dedent(string) code_lines = split_lines(string, keepends=True) relevant_code_lines = list(iter_relevant_lines(code_lines)) if relevant_code_lines[-1] is not None: # Some code lines might be None, therefore get rid of that. relevant_code_lines = ['\n' if c is None else c for c in relevant_code_lines] return self._complete_code_lines(relevant_code_lines) match = re.search(r'`([^`\s]+)', code_lines[-1]) if match: return self._complete_code_lines([match.group(1)]) return [] def _complete_code_lines(self, code_lines): module_node = self._inference_state.grammar.parse(''.join(code_lines)) module_value = DocstringModule( in_module_context=self._module_context, inference_state=self._inference_state, module_node=module_node, code_lines=code_lines, ) return Completion( self._inference_state, module_value.as_context(), code_lines=code_lines, position=module_node.end_pos, signatures_callback=lambda *args, **kwargs: [], fuzzy=self._fuzzy ).complete() def _gather_nodes(stack): nodes = [] for stack_node in stack: if stack_node.dfa.from_rule == 'small_stmt': nodes = [] else: nodes += stack_node.nodes return nodes _string_start = re.compile(r'^\w*(\'{3}|"{3}|\'|")') def _extract_string_while_in_string(leaf, position): def return_part_of_leaf(leaf): kwargs = {} if leaf.line == position[0]: kwargs['endpos'] = position[1] - leaf.column match = _string_start.match(leaf.value, **kwargs) if not match: return None, None, None start = match.group(0) if leaf.line == position[0] and position[1] < leaf.column + match.end(): return None, None, None return cut_value_at_position(leaf, position)[match.end():], leaf, start if position < leaf.start_pos: return None, None, None if leaf.type == 'string': return return_part_of_leaf(leaf) leaves = [] while leaf is not None: if leaf.type == 'error_leaf' and ('"' in leaf.value or "'" in leaf.value): if len(leaf.value) > 1: return return_part_of_leaf(leaf) prefix_leaf = None if not leaf.prefix: prefix_leaf = leaf.get_previous_leaf() if prefix_leaf is None or prefix_leaf.type != 'name' \ or not all(c in 'rubf' for c in prefix_leaf.value.lower()): prefix_leaf = None return ( ''.join(cut_value_at_position(l, position) for l in leaves), prefix_leaf or leaf, ('' if prefix_leaf is None else prefix_leaf.value) + cut_value_at_position(leaf, position), ) if leaf.line != position[0]: # Multi line strings are always simple error leaves and contain the # whole string, single line error leaves are atherefore important # now and since the line is different, it's not really a single # line string anymore. break leaves.insert(0, leaf) leaf = leaf.get_previous_leaf() return None, None, None def complete_trailer(user_context, values): completion_names = [] for value in values: for filter in value.get_filters(origin_scope=user_context.tree_node): completion_names += filter.values() if not value.is_stub() and isinstance(value, TreeInstance): completion_names += _complete_getattr(user_context, value) python_values = convert_values(values) for c in python_values: if c not in values: for filter in c.get_filters(origin_scope=user_context.tree_node): completion_names += filter.values() return completion_names def _complete_getattr(user_context, instance): """ A heuristic to make completion for proxy objects work. This is not intended to work in all cases. It works exactly in this case: def __getattr__(self, name): ... return getattr(any_object, name) It is important that the return contains getattr directly, otherwise it won't work anymore. It's really just a stupid heuristic. It will not work if you write e.g. `return (getatr(o, name))`, because of the additional parentheses. It will also not work if you move the getattr to some other place that is not the return statement itself. It is intentional that it doesn't work in all cases. Generally it's really hard to do even this case (as you can see below). Most people will write it like this anyway and the other ones, well they are just out of luck I guess :) ~dave. """ names = (instance.get_function_slot_names('__getattr__') or instance.get_function_slot_names('__getattribute__')) functions = ValueSet.from_sets( name.infer() for name in names ) for func in functions: tree_node = func.tree_node if tree_node is None or tree_node.type != 'funcdef': continue for return_stmt in tree_node.iter_return_stmts(): # Basically until the next comment we just try to find out if a # return statement looks exactly like `return getattr(x, name)`. if return_stmt.type != 'return_stmt': continue atom_expr = return_stmt.children[1] if atom_expr.type != 'atom_expr': continue atom = atom_expr.children[0] trailer = atom_expr.children[1] if len(atom_expr.children) != 2 or atom.type != 'name' \ or atom.value != 'getattr': continue arglist = trailer.children[1] if arglist.type != 'arglist' or len(arglist.children) < 3: continue context = func.as_context() object_node = arglist.children[0] # Make sure it's a param: foo in __getattr__(self, foo) name_node = arglist.children[2] name_list = context.goto(name_node, name_node.start_pos) if not any(n.api_type == 'param' for n in name_list): continue # Now that we know that these are most probably completion # objects, we just infer the object and return them as # completions. objects = context.infer_node(object_node) return complete_trailer(user_context, objects) return [] def search_in_module(inference_state, module_context, names, wanted_names, wanted_type, complete=False, fuzzy=False, ignore_imports=False, convert=False): for s in wanted_names[:-1]: new_names = [] for n in names: if s == n.string_name: if n.tree_name is not None and n.api_type in ('module', 'namespace') \ and ignore_imports: continue new_names += complete_trailer( module_context, n.infer() ) debug.dbg('dot lookup on search %s from %s', new_names, names[:10]) names = new_names last_name = wanted_names[-1].lower() for n in names: string = n.string_name.lower() if complete and helpers.match(string, last_name, fuzzy=fuzzy) \ or not complete and string == last_name: if isinstance(n, SubModuleName): names = [v.name for v in n.infer()] else: names = [n] if convert: names = convert_names(names) for n2 in names: if complete: def_ = classes.Completion( inference_state, n2, stack=None, like_name_length=len(last_name), is_fuzzy=fuzzy, ) else: def_ = classes.Name(inference_state, n2) if not wanted_type or wanted_type == def_.type: yield def_ ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/jedi/api/completion_cache.py0000664000175000017500000000167200000000000017740 0ustar00davedave00000000000000from typing import Dict, Tuple, Callable CacheValues = Tuple[str, str, str] CacheValuesCallback = Callable[[], CacheValues] _cache: Dict[str, Dict[str, CacheValues]] = {} def save_entry(module_name: str, name: str, cache: CacheValues) -> None: try: module_cache = _cache[module_name] except KeyError: module_cache = _cache[module_name] = {} module_cache[name] = cache def _create_get_from_cache(number: int) -> Callable[[str, str, CacheValuesCallback], str]: def _get_from_cache(module_name: str, name: str, get_cache_values: CacheValuesCallback) -> str: try: return _cache[module_name][name][number] except KeyError: v = get_cache_values() save_entry(module_name, name, v) return v[number] return _get_from_cache get_type = _create_get_from_cache(0) get_docstring_signature = _create_get_from_cache(1) get_docstring = _create_get_from_cache(2) ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/jedi/api/environment.py0000664000175000017500000004102100000000000017000 0ustar00davedave00000000000000""" Environments are a way to activate different Python versions or Virtualenvs for static analysis. The Python binary in that environment is going to be executed. """ import os import sys import hashlib import filecmp from collections import namedtuple from shutil import which from jedi.cache import memoize_method, time_cache from jedi.inference.compiled.subprocess import CompiledSubprocess, \ InferenceStateSameProcess, InferenceStateSubprocess import parso _VersionInfo = namedtuple('VersionInfo', 'major minor micro') # type: ignore[name-match] _SUPPORTED_PYTHONS = ['3.12', '3.11', '3.10', '3.9', '3.8', '3.7', '3.6'] _SAFE_PATHS = ['/usr/bin', '/usr/local/bin'] _CONDA_VAR = 'CONDA_PREFIX' _CURRENT_VERSION = '%s.%s' % (sys.version_info.major, sys.version_info.minor) class InvalidPythonEnvironment(Exception): """ If you see this exception, the Python executable or Virtualenv you have been trying to use is probably not a correct Python version. """ class _BaseEnvironment: @memoize_method def get_grammar(self): version_string = '%s.%s' % (self.version_info.major, self.version_info.minor) return parso.load_grammar(version=version_string) @property def _sha256(self): try: return self._hash except AttributeError: self._hash = _calculate_sha256_for_file(self.executable) return self._hash def _get_info(): return ( sys.executable, sys.prefix, sys.version_info[:3], ) class Environment(_BaseEnvironment): """ This class is supposed to be created by internal Jedi architecture. You should not create it directly. Please use create_environment or the other functions instead. It is then returned by that function. """ _subprocess = None def __init__(self, executable, env_vars=None): self._start_executable = executable self._env_vars = env_vars # Initialize the environment self._get_subprocess() def _get_subprocess(self): if self._subprocess is not None and not self._subprocess.is_crashed: return self._subprocess try: self._subprocess = CompiledSubprocess(self._start_executable, env_vars=self._env_vars) info = self._subprocess._send(None, _get_info) except Exception as exc: raise InvalidPythonEnvironment( "Could not get version information for %r: %r" % ( self._start_executable, exc)) # Since it could change and might not be the same(?) as the one given, # set it here. self.executable = info[0] """ The Python executable, matches ``sys.executable``. """ self.path = info[1] """ The path to an environment, matches ``sys.prefix``. """ self.version_info = _VersionInfo(*info[2]) """ Like :data:`sys.version_info`: a tuple to show the current Environment's Python version. """ return self._subprocess def __repr__(self): version = '.'.join(str(i) for i in self.version_info) return '<%s: %s in %s>' % (self.__class__.__name__, version, self.path) def get_inference_state_subprocess(self, inference_state): return InferenceStateSubprocess(inference_state, self._get_subprocess()) @memoize_method def get_sys_path(self): """ The sys path for this environment. Does not include potential modifications from e.g. appending to :data:`sys.path`. :returns: list of str """ # It's pretty much impossible to generate the sys path without actually # executing Python. The sys path (when starting with -S) itself depends # on how the Python version was compiled (ENV variables). # If you omit -S when starting Python (normal case), additionally # site.py gets executed. return self._get_subprocess().get_sys_path() class _SameEnvironmentMixin: def __init__(self): self._start_executable = self.executable = sys.executable self.path = sys.prefix self.version_info = _VersionInfo(*sys.version_info[:3]) self._env_vars = None class SameEnvironment(_SameEnvironmentMixin, Environment): pass class InterpreterEnvironment(_SameEnvironmentMixin, _BaseEnvironment): def get_inference_state_subprocess(self, inference_state): return InferenceStateSameProcess(inference_state) def get_sys_path(self): return sys.path def _get_virtual_env_from_var(env_var='VIRTUAL_ENV'): """Get virtualenv environment from VIRTUAL_ENV environment variable. It uses `safe=False` with ``create_environment``, because the environment variable is considered to be safe / controlled by the user solely. """ var = os.environ.get(env_var) if var: # Under macOS in some cases - notably when using Pipenv - the # sys.prefix of the virtualenv is /path/to/env/bin/.. instead of # /path/to/env so we need to fully resolve the paths in order to # compare them. if os.path.realpath(var) == os.path.realpath(sys.prefix): return _try_get_same_env() try: return create_environment(var, safe=False) except InvalidPythonEnvironment: pass def _calculate_sha256_for_file(path): sha256 = hashlib.sha256() with open(path, 'rb') as f: for block in iter(lambda: f.read(filecmp.BUFSIZE), b''): sha256.update(block) return sha256.hexdigest() def get_default_environment(): """ Tries to return an active Virtualenv or conda environment. If there is no VIRTUAL_ENV variable or no CONDA_PREFIX variable set set it will return the latest Python version installed on the system. This makes it possible to use as many new Python features as possible when using autocompletion and other functionality. :returns: :class:`.Environment` """ virtual_env = _get_virtual_env_from_var() if virtual_env is not None: return virtual_env conda_env = _get_virtual_env_from_var(_CONDA_VAR) if conda_env is not None: return conda_env return _try_get_same_env() def _try_get_same_env(): env = SameEnvironment() if not os.path.basename(env.executable).lower().startswith('python'): # This tries to counter issues with embedding. In some cases (e.g. # VIM's Python Mac/Windows, sys.executable is /foo/bar/vim. This # happens, because for Mac a function called `_NSGetExecutablePath` is # used and for Windows `GetModuleFileNameW`. These are both platform # specific functions. For all other systems sys.executable should be # alright. However here we try to generalize: # # 1. Check if the executable looks like python (heuristic) # 2. In case it's not try to find the executable # 3. In case we don't find it use an interpreter environment. # # The last option will always work, but leads to potential crashes of # Jedi - which is ok, because it happens very rarely and even less, # because the code below should work for most cases. if os.name == 'nt': # The first case would be a virtualenv and the second a normal # Python installation. checks = (r'Scripts\python.exe', 'python.exe') else: # For unix it looks like Python is always in a bin folder. checks = ( 'bin/python%s.%s' % (sys.version_info[0], sys.version[1]), 'bin/python%s' % (sys.version_info[0]), 'bin/python', ) for check in checks: guess = os.path.join(sys.exec_prefix, check) if os.path.isfile(guess): # Bingo - We think we have our Python. return Environment(guess) # It looks like there is no reasonable Python to be found. return InterpreterEnvironment() # If no virtualenv is found, use the environment we're already # using. return env def get_cached_default_environment(): var = os.environ.get('VIRTUAL_ENV') or os.environ.get(_CONDA_VAR) environment = _get_cached_default_environment() # Under macOS in some cases - notably when using Pipenv - the # sys.prefix of the virtualenv is /path/to/env/bin/.. instead of # /path/to/env so we need to fully resolve the paths in order to # compare them. if var and os.path.realpath(var) != os.path.realpath(environment.path): _get_cached_default_environment.clear_cache() return _get_cached_default_environment() return environment @time_cache(seconds=10 * 60) # 10 Minutes def _get_cached_default_environment(): try: return get_default_environment() except InvalidPythonEnvironment: # It's possible that `sys.executable` is wrong. Typically happens # when Jedi is used in an executable that embeds Python. For further # information, have a look at: # https://github.com/davidhalter/jedi/issues/1531 return InterpreterEnvironment() def find_virtualenvs(paths=None, *, safe=True, use_environment_vars=True): """ :param paths: A list of paths in your file system to be scanned for Virtualenvs. It will search in these paths and potentially execute the Python binaries. :param safe: Default True. In case this is False, it will allow this function to execute potential `python` environments. An attacker might be able to drop an executable in a path this function is searching by default. If the executable has not been installed by root, it will not be executed. :param use_environment_vars: Default True. If True, the VIRTUAL_ENV variable will be checked if it contains a valid VirtualEnv. CONDA_PREFIX will be checked to see if it contains a valid conda environment. :yields: :class:`.Environment` """ if paths is None: paths = [] _used_paths = set() if use_environment_vars: # Using this variable should be safe, because attackers might be # able to drop files (via git) but not environment variables. virtual_env = _get_virtual_env_from_var() if virtual_env is not None: yield virtual_env _used_paths.add(virtual_env.path) conda_env = _get_virtual_env_from_var(_CONDA_VAR) if conda_env is not None: yield conda_env _used_paths.add(conda_env.path) for directory in paths: if not os.path.isdir(directory): continue directory = os.path.abspath(directory) for path in os.listdir(directory): path = os.path.join(directory, path) if path in _used_paths: # A path shouldn't be inferred twice. continue _used_paths.add(path) try: executable = _get_executable_path(path, safe=safe) yield Environment(executable) except InvalidPythonEnvironment: pass def find_system_environments(*, env_vars=None): """ Ignores virtualenvs and returns the Python versions that were installed on your system. This might return nothing, if you're running Python e.g. from a portable version. The environments are sorted from latest to oldest Python version. :yields: :class:`.Environment` """ for version_string in _SUPPORTED_PYTHONS: try: yield get_system_environment(version_string, env_vars=env_vars) except InvalidPythonEnvironment: pass # TODO: this function should probably return a list of environments since # multiple Python installations can be found on a system for the same version. def get_system_environment(version, *, env_vars=None): """ Return the first Python environment found for a string of the form 'X.Y' where X and Y are the major and minor versions of Python. :raises: :exc:`.InvalidPythonEnvironment` :returns: :class:`.Environment` """ exe = which('python' + version) if exe: if exe == sys.executable: return SameEnvironment() return Environment(exe) if os.name == 'nt': for exe in _get_executables_from_windows_registry(version): try: return Environment(exe, env_vars=env_vars) except InvalidPythonEnvironment: pass raise InvalidPythonEnvironment("Cannot find executable python%s." % version) def create_environment(path, *, safe=True, env_vars=None): """ Make it possible to manually create an Environment object by specifying a Virtualenv path or an executable path and optional environment variables. :raises: :exc:`.InvalidPythonEnvironment` :returns: :class:`.Environment` """ if os.path.isfile(path): _assert_safe(path, safe) return Environment(path, env_vars=env_vars) return Environment(_get_executable_path(path, safe=safe), env_vars=env_vars) def _get_executable_path(path, safe=True): """ Returns None if it's not actually a virtual env. """ if os.name == 'nt': python = os.path.join(path, 'Scripts', 'python.exe') else: python = os.path.join(path, 'bin', 'python') if not os.path.exists(python): raise InvalidPythonEnvironment("%s seems to be missing." % python) _assert_safe(python, safe) return python def _get_executables_from_windows_registry(version): import winreg # TODO: support Python Anaconda. sub_keys = [ r'SOFTWARE\Python\PythonCore\{version}\InstallPath', r'SOFTWARE\Wow6432Node\Python\PythonCore\{version}\InstallPath', r'SOFTWARE\Python\PythonCore\{version}-32\InstallPath', r'SOFTWARE\Wow6432Node\Python\PythonCore\{version}-32\InstallPath' ] for root_key in [winreg.HKEY_CURRENT_USER, winreg.HKEY_LOCAL_MACHINE]: for sub_key in sub_keys: sub_key = sub_key.format(version=version) try: with winreg.OpenKey(root_key, sub_key) as key: prefix = winreg.QueryValueEx(key, '')[0] exe = os.path.join(prefix, 'python.exe') if os.path.isfile(exe): yield exe except WindowsError: pass def _assert_safe(executable_path, safe): if safe and not _is_safe(executable_path): raise InvalidPythonEnvironment( "The python binary is potentially unsafe.") def _is_safe(executable_path): # Resolve sym links. A venv typically is a symlink to a known Python # binary. Only virtualenvs copy symlinks around. real_path = os.path.realpath(executable_path) if _is_unix_safe_simple(real_path): return True # Just check the list of known Python versions. If it's not in there, # it's likely an attacker or some Python that was not properly # installed in the system. for environment in find_system_environments(): if environment.executable == real_path: return True # If the versions don't match, just compare the binary files. If we # don't do that, only venvs will be working and not virtualenvs. # venvs are symlinks while virtualenvs are actual copies of the # Python files. # This still means that if the system Python is updated and the # virtualenv's Python is not (which is probably never going to get # upgraded), it will not work with Jedi. IMO that's fine, because # people should just be using venv. ~ dave if environment._sha256 == _calculate_sha256_for_file(real_path): return True return False def _is_unix_safe_simple(real_path): if _is_unix_admin(): # In case we are root, just be conservative and # only execute known paths. return any(real_path.startswith(p) for p in _SAFE_PATHS) uid = os.stat(real_path).st_uid # The interpreter needs to be owned by root. This means that it wasn't # written by a user and therefore attacking Jedi is not as simple. # The attack could look like the following: # 1. A user clones a repository. # 2. The repository has an innocent looking folder called foobar. jedi # searches for the folder and executes foobar/bin/python --version if # there's also a foobar/bin/activate. # 3. The attacker has gained code execution, since he controls # foobar/bin/python. return uid == 0 def _is_unix_admin(): try: return os.getuid() == 0 except AttributeError: return False # Windows ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/jedi/api/errors.py0000664000175000017500000000234500000000000015756 0ustar00davedave00000000000000""" This file is about errors in Python files and not about exception handling in Jedi. """ def parso_to_jedi_errors(grammar, module_node): return [SyntaxError(e) for e in grammar.iter_errors(module_node)] class SyntaxError: """ Syntax errors are generated by :meth:`.Script.get_syntax_errors`. """ def __init__(self, parso_error): self._parso_error = parso_error @property def line(self): """The line where the error starts (starting with 1).""" return self._parso_error.start_pos[0] @property def column(self): """The column where the error starts (starting with 0).""" return self._parso_error.start_pos[1] @property def until_line(self): """The line where the error ends (starting with 1).""" return self._parso_error.end_pos[0] @property def until_column(self): """The column where the error ends (starting with 0).""" return self._parso_error.end_pos[1] def get_message(self): return self._parso_error.message def __repr__(self): return '<%s from=%s to=%s>' % ( self.__class__.__name__, self._parso_error.start_pos, self._parso_error.end_pos, ) ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/jedi/api/exceptions.py0000664000175000017500000000173600000000000016626 0ustar00davedave00000000000000class _JediError(Exception): pass class InternalError(_JediError): """ This error might happen a subprocess is crashing. The reason for this is usually broken C code in third party libraries. This is not a very common thing and it is safe to use Jedi again. However using the same calls might result in the same error again. """ class WrongVersion(_JediError): """ This error is reserved for the future, shouldn't really be happening at the moment. """ class RefactoringError(_JediError): """ Refactorings can fail for various reasons. So if you work with refactorings like :meth:`.Script.rename`, :meth:`.Script.inline`, :meth:`.Script.extract_variable` and :meth:`.Script.extract_function`, make sure to catch these. The descriptions in the errors are usually valuable for end users. A typical ``RefactoringError`` would tell the user that inlining is not possible if no name is under the cursor. """ ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/jedi/api/file_name.py0000664000175000017500000001276400000000000016367 0ustar00davedave00000000000000import os from jedi.api import classes from jedi.api.strings import StringName, get_quote_ending from jedi.api.helpers import match from jedi.inference.helpers import get_str_or_none class PathName(StringName): api_type = 'path' def complete_file_name(inference_state, module_context, start_leaf, quote, string, like_name, signatures_callback, code_lines, position, fuzzy): # First we want to find out what can actually be changed as a name. like_name_length = len(os.path.basename(string)) addition = _get_string_additions(module_context, start_leaf) if string.startswith('~'): string = os.path.expanduser(string) if addition is None: return string = addition + string # Here we use basename again, because if strings are added like # `'foo' + 'bar`, it should complete to `foobar/`. must_start_with = os.path.basename(string) string = os.path.dirname(string) sigs = signatures_callback(*position) is_in_os_path_join = sigs and all(s.full_name == 'os.path.join' for s in sigs) if is_in_os_path_join: to_be_added = _add_os_path_join(module_context, start_leaf, sigs[0].bracket_start) if to_be_added is None: is_in_os_path_join = False else: string = to_be_added + string base_path = os.path.join(inference_state.project.path, string) try: listed = sorted(os.scandir(base_path), key=lambda e: e.name) # OSError: [Errno 36] File name too long: '...' except (FileNotFoundError, OSError): return quote_ending = get_quote_ending(quote, code_lines, position) for entry in listed: name = entry.name if match(name, must_start_with, fuzzy=fuzzy): if is_in_os_path_join or not entry.is_dir(): name += quote_ending else: name += os.path.sep yield classes.Completion( inference_state, PathName(inference_state, name[len(must_start_with) - like_name_length:]), stack=None, like_name_length=like_name_length, is_fuzzy=fuzzy, ) def _get_string_additions(module_context, start_leaf): def iterate_nodes(): node = addition.parent was_addition = True for child_node in reversed(node.children[:node.children.index(addition)]): if was_addition: was_addition = False yield child_node continue if child_node != '+': break was_addition = True addition = start_leaf.get_previous_leaf() if addition != '+': return '' context = module_context.create_context(start_leaf) return _add_strings(context, reversed(list(iterate_nodes()))) def _add_strings(context, nodes, add_slash=False): string = '' first = True for child_node in nodes: values = context.infer_node(child_node) if len(values) != 1: return None c, = values s = get_str_or_none(c) if s is None: return None if not first and add_slash: string += os.path.sep string += s first = False return string def _add_os_path_join(module_context, start_leaf, bracket_start): def check(maybe_bracket, nodes): if maybe_bracket.start_pos != bracket_start: return None if not nodes: return '' context = module_context.create_context(nodes[0]) return _add_strings(context, nodes, add_slash=True) or '' if start_leaf.type == 'error_leaf': # Unfinished string literal, like `join('` value_node = start_leaf.parent index = value_node.children.index(start_leaf) if index > 0: error_node = value_node.children[index - 1] if error_node.type == 'error_node' and len(error_node.children) >= 2: index = -2 if error_node.children[-1].type == 'arglist': arglist_nodes = error_node.children[-1].children index -= 1 else: arglist_nodes = [] return check(error_node.children[index + 1], arglist_nodes[::2]) return None # Maybe an arglist or some weird error case. Therefore checked below. searched_node_child = start_leaf while searched_node_child.parent is not None \ and searched_node_child.parent.type not in ('arglist', 'trailer', 'error_node'): searched_node_child = searched_node_child.parent if searched_node_child.get_first_leaf() is not start_leaf: return None searched_node = searched_node_child.parent if searched_node is None: return None index = searched_node.children.index(searched_node_child) arglist_nodes = searched_node.children[:index] if searched_node.type == 'arglist': trailer = searched_node.parent if trailer.type == 'error_node': trailer_index = trailer.children.index(searched_node) assert trailer_index >= 2 assert trailer.children[trailer_index - 1] == '(' return check(trailer.children[trailer_index - 1], arglist_nodes[::2]) elif trailer.type == 'trailer': return check(trailer.children[0], arglist_nodes[::2]) elif searched_node.type == 'trailer': return check(searched_node.children[0], []) elif searched_node.type == 'error_node': # Stuff like `join(""` return check(arglist_nodes[-1], []) ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/jedi/api/helpers.py0000664000175000017500000004504600000000000016111 0ustar00davedave00000000000000""" Helpers for the API """ import re from collections import namedtuple from textwrap import dedent from itertools import chain from functools import wraps from inspect import Parameter from parso.python.parser import Parser from parso.python import tree from jedi.inference.base_value import NO_VALUES from jedi.inference.syntax_tree import infer_atom from jedi.inference.helpers import infer_call_of_leaf from jedi.inference.compiled import get_string_value_set from jedi.cache import signature_time_cache, memoize_method from jedi.parser_utils import get_parent_scope CompletionParts = namedtuple('CompletionParts', ['path', 'has_dot', 'name']) def _start_match(string, like_name): return string.startswith(like_name) def _fuzzy_match(string, like_name): if len(like_name) <= 1: return like_name in string pos = string.find(like_name[0]) if pos >= 0: return _fuzzy_match(string[pos + 1:], like_name[1:]) return False def match(string, like_name, fuzzy=False): if fuzzy: return _fuzzy_match(string, like_name) else: return _start_match(string, like_name) def sorted_definitions(defs): # Note: `or ''` below is required because `module_path` could be return sorted(defs, key=lambda x: (str(x.module_path or ''), x.line or 0, x.column or 0, x.name)) def get_on_completion_name(module_node, lines, position): leaf = module_node.get_leaf_for_position(position) if leaf is None or leaf.type in ('string', 'error_leaf'): # Completions inside strings are a bit special, we need to parse the # string. The same is true for comments and error_leafs. line = lines[position[0] - 1] # The first step of completions is to get the name return re.search(r'(?!\d)\w+$|$', line[:position[1]]).group(0) elif leaf.type not in ('name', 'keyword'): return '' return leaf.value[:position[1] - leaf.start_pos[1]] def _get_code(code_lines, start_pos, end_pos): # Get relevant lines. lines = code_lines[start_pos[0] - 1:end_pos[0]] # Remove the parts at the end of the line. lines[-1] = lines[-1][:end_pos[1]] # Remove first line indentation. lines[0] = lines[0][start_pos[1]:] return ''.join(lines) class OnErrorLeaf(Exception): @property def error_leaf(self): return self.args[0] def _get_code_for_stack(code_lines, leaf, position): # It might happen that we're on whitespace or on a comment. This means # that we would not get the right leaf. if leaf.start_pos >= position: # If we're not on a comment simply get the previous leaf and proceed. leaf = leaf.get_previous_leaf() if leaf is None: return '' # At the beginning of the file. is_after_newline = leaf.type == 'newline' while leaf.type == 'newline': leaf = leaf.get_previous_leaf() if leaf is None: return '' if leaf.type == 'error_leaf' or leaf.type == 'string': if leaf.start_pos[0] < position[0]: # On a different line, we just begin anew. return '' # Error leafs cannot be parsed, completion in strings is also # impossible. raise OnErrorLeaf(leaf) else: user_stmt = leaf while True: if user_stmt.parent.type in ('file_input', 'suite', 'simple_stmt'): break user_stmt = user_stmt.parent if is_after_newline: if user_stmt.start_pos[1] > position[1]: # This means that it's actually a dedent and that means that we # start without value (part of a suite). return '' # This is basically getting the relevant lines. return _get_code(code_lines, user_stmt.get_start_pos_of_prefix(), position) def get_stack_at_position(grammar, code_lines, leaf, pos): """ Returns the possible node names (e.g. import_from, xor_test or yield_stmt). """ class EndMarkerReached(Exception): pass def tokenize_without_endmarker(code): # TODO This is for now not an official parso API that exists purely # for Jedi. tokens = grammar._tokenize(code) for token in tokens: if token.string == safeword: raise EndMarkerReached() elif token.prefix.endswith(safeword): # This happens with comments. raise EndMarkerReached() elif token.string.endswith(safeword): yield token # Probably an f-string literal that was not finished. raise EndMarkerReached() else: yield token # The code might be indedented, just remove it. code = dedent(_get_code_for_stack(code_lines, leaf, pos)) # We use a word to tell Jedi when we have reached the start of the # completion. # Use Z as a prefix because it's not part of a number suffix. safeword = 'ZZZ_USER_WANTS_TO_COMPLETE_HERE_WITH_JEDI' code = code + ' ' + safeword p = Parser(grammar._pgen_grammar, error_recovery=True) try: p.parse(tokens=tokenize_without_endmarker(code)) except EndMarkerReached: return p.stack raise SystemError( "This really shouldn't happen. There's a bug in Jedi:\n%s" % list(tokenize_without_endmarker(code)) ) def infer(inference_state, context, leaf): if leaf.type == 'name': return inference_state.infer(context, leaf) parent = leaf.parent definitions = NO_VALUES if parent.type == 'atom': # e.g. `(a + b)` definitions = context.infer_node(leaf.parent) elif parent.type == 'trailer': # e.g. `a()` definitions = infer_call_of_leaf(context, leaf) elif isinstance(leaf, tree.Literal): # e.g. `"foo"` or `1.0` return infer_atom(context, leaf) elif leaf.type in ('fstring_string', 'fstring_start', 'fstring_end'): return get_string_value_set(inference_state) return definitions def filter_follow_imports(names, follow_builtin_imports=False): for name in names: if name.is_import(): new_names = list(filter_follow_imports( name.goto(), follow_builtin_imports=follow_builtin_imports, )) found_builtin = False if follow_builtin_imports: for new_name in new_names: if new_name.start_pos is None: found_builtin = True if found_builtin: yield name else: yield from new_names else: yield name class CallDetails: def __init__(self, bracket_leaf, children, position): self.bracket_leaf = bracket_leaf self._children = children self._position = position @property def index(self): return _get_index_and_key(self._children, self._position)[0] @property def keyword_name_str(self): return _get_index_and_key(self._children, self._position)[1] @memoize_method def _list_arguments(self): return list(_iter_arguments(self._children, self._position)) def calculate_index(self, param_names): positional_count = 0 used_names = set() star_count = -1 args = self._list_arguments() if not args: if param_names: return 0 else: return None is_kwarg = False for i, (star_count, key_start, had_equal) in enumerate(args): is_kwarg |= had_equal | (star_count == 2) if star_count: pass # For now do nothing, we don't know what's in there here. else: if i + 1 != len(args): # Not last if had_equal: used_names.add(key_start) else: positional_count += 1 for i, param_name in enumerate(param_names): kind = param_name.get_kind() if not is_kwarg: if kind == Parameter.VAR_POSITIONAL: return i if kind in (Parameter.POSITIONAL_OR_KEYWORD, Parameter.POSITIONAL_ONLY): if i == positional_count: return i if key_start is not None and not star_count == 1 or star_count == 2: if param_name.string_name not in used_names \ and (kind == Parameter.KEYWORD_ONLY or kind == Parameter.POSITIONAL_OR_KEYWORD and positional_count <= i): if star_count: return i if had_equal: if param_name.string_name == key_start: return i else: if param_name.string_name.startswith(key_start): return i if kind == Parameter.VAR_KEYWORD: return i return None def iter_used_keyword_arguments(self): for star_count, key_start, had_equal in list(self._list_arguments()): if had_equal and key_start: yield key_start def count_positional_arguments(self): count = 0 for star_count, key_start, had_equal in self._list_arguments()[:-1]: if star_count or key_start: break count += 1 return count def _iter_arguments(nodes, position): def remove_after_pos(name): if name.type != 'name': return None return name.value[:position[1] - name.start_pos[1]] # Returns Generator[Tuple[star_count, Optional[key_start: str], had_equal]] nodes_before = [c for c in nodes if c.start_pos < position] if nodes_before[-1].type == 'arglist': yield from _iter_arguments(nodes_before[-1].children, position) return previous_node_yielded = False stars_seen = 0 for i, node in enumerate(nodes_before): if node.type == 'argument': previous_node_yielded = True first = node.children[0] second = node.children[1] if second == '=': if second.start_pos < position and first.type == 'name': yield 0, first.value, True else: yield 0, remove_after_pos(first), False elif first in ('*', '**'): yield len(first.value), remove_after_pos(second), False else: # Must be a Comprehension first_leaf = node.get_first_leaf() if first_leaf.type == 'name' and first_leaf.start_pos >= position: yield 0, remove_after_pos(first_leaf), False else: yield 0, None, False stars_seen = 0 elif node.type == 'testlist_star_expr': for n in node.children[::2]: if n.type == 'star_expr': stars_seen = 1 n = n.children[1] yield stars_seen, remove_after_pos(n), False stars_seen = 0 # The count of children is even if there's a comma at the end. previous_node_yielded = bool(len(node.children) % 2) elif isinstance(node, tree.PythonLeaf) and node.value == ',': if not previous_node_yielded: yield stars_seen, '', False stars_seen = 0 previous_node_yielded = False elif isinstance(node, tree.PythonLeaf) and node.value in ('*', '**'): stars_seen = len(node.value) elif node == '=' and nodes_before[-1]: previous_node_yielded = True before = nodes_before[i - 1] if before.type == 'name': yield 0, before.value, True else: yield 0, None, False # Just ignore the star that is probably a syntax error. stars_seen = 0 if not previous_node_yielded: if nodes_before[-1].type == 'name': yield stars_seen, remove_after_pos(nodes_before[-1]), False else: yield stars_seen, '', False def _get_index_and_key(nodes, position): """ Returns the amount of commas and the keyword argument string. """ nodes_before = [c for c in nodes if c.start_pos < position] if nodes_before[-1].type == 'arglist': return _get_index_and_key(nodes_before[-1].children, position) key_str = None last = nodes_before[-1] if last.type == 'argument' and last.children[1] == '=' \ and last.children[1].end_pos <= position: # Checked if the argument key_str = last.children[0].value elif last == '=': key_str = nodes_before[-2].value return nodes_before.count(','), key_str def _get_signature_details_from_error_node(node, additional_children, position): for index, element in reversed(list(enumerate(node.children))): # `index > 0` means that it's a trailer and not an atom. if element == '(' and element.end_pos <= position and index > 0: # It's an error node, we don't want to match too much, just # until the parentheses is enough. children = node.children[index:] name = element.get_previous_leaf() if name is None: continue if name.type == 'name' or name.parent.type in ('trailer', 'atom'): return CallDetails(element, children + additional_children, position) def get_signature_details(module, position): leaf = module.get_leaf_for_position(position, include_prefixes=True) # It's easier to deal with the previous token than the next one in this # case. if leaf.start_pos >= position: # Whitespace / comments after the leaf count towards the previous leaf. leaf = leaf.get_previous_leaf() if leaf is None: return None # Now that we know where we are in the syntax tree, we start to look at # parents for possible function definitions. node = leaf.parent while node is not None: if node.type in ('funcdef', 'classdef', 'decorated', 'async_stmt'): # Don't show signatures if there's stuff before it that just # makes it feel strange to have a signature. return None additional_children = [] for n in reversed(node.children): if n.start_pos < position: if n.type == 'error_node': result = _get_signature_details_from_error_node( n, additional_children, position ) if result is not None: return result additional_children[0:0] = n.children continue additional_children.insert(0, n) # Find a valid trailer if node.type == 'trailer' and node.children[0] == '(' \ or node.type == 'decorator' and node.children[2] == '(': # Additionally we have to check that an ending parenthesis isn't # interpreted wrong. There are two cases: # 1. Cursor before paren -> The current signature is good # 2. Cursor after paren -> We need to skip the current signature if not (leaf is node.children[-1] and position >= leaf.end_pos): leaf = node.get_previous_leaf() if leaf is None: return None return CallDetails( node.children[0] if node.type == 'trailer' else node.children[2], node.children, position ) node = node.parent return None @signature_time_cache("call_signatures_validity") def cache_signatures(inference_state, context, bracket_leaf, code_lines, user_pos): """This function calculates the cache key.""" line_index = user_pos[0] - 1 before_cursor = code_lines[line_index][:user_pos[1]] other_lines = code_lines[bracket_leaf.start_pos[0]:line_index] whole = ''.join(other_lines + [before_cursor]) before_bracket = re.match(r'.*\(', whole, re.DOTALL) module_path = context.get_root_context().py__file__() if module_path is None: yield None # Don't cache! else: yield (module_path, before_bracket, bracket_leaf.start_pos) yield infer( inference_state, context, bracket_leaf.get_previous_leaf(), ) def validate_line_column(func): @wraps(func) def wrapper(self, line=None, column=None, *args, **kwargs): line = max(len(self._code_lines), 1) if line is None else line if not (0 < line <= len(self._code_lines)): raise ValueError('`line` parameter is not in a valid range.') line_string = self._code_lines[line - 1] line_len = len(line_string) if line_string.endswith('\r\n'): line_len -= 2 elif line_string.endswith('\n'): line_len -= 1 column = line_len if column is None else column if not (0 <= column <= line_len): raise ValueError('`column` parameter (%d) is not in a valid range ' '(0-%d) for line %d (%r).' % ( column, line_len, line, line_string)) return func(self, line, column, *args, **kwargs) return wrapper def get_module_names(module, all_scopes, definitions=True, references=False): """ Returns a dictionary with name parts as keys and their call paths as values. """ def def_ref_filter(name): is_def = name.is_definition() return definitions and is_def or references and not is_def names = list(chain.from_iterable(module.get_used_names().values())) if not all_scopes: # We have to filter all the names that don't have the module as a # parent_scope. There's None as a parent, because nodes in the module # node have the parent module and not suite as all the others. # Therefore it's important to catch that case. def is_module_scope_name(name): parent_scope = get_parent_scope(name) # async functions have an extra wrapper. Strip it. if parent_scope and parent_scope.type == 'async_stmt': parent_scope = parent_scope.parent return parent_scope in (module, None) names = [n for n in names if is_module_scope_name(n)] return filter(def_ref_filter, names) def split_search_string(name): type, _, dotted_names = name.rpartition(' ') if type == 'def': type = 'function' return type, dotted_names.split('.') ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/jedi/api/interpreter.py0000664000175000017500000000455700000000000017014 0ustar00davedave00000000000000""" TODO Some parts of this module are still not well documented. """ from jedi.inference import compiled from jedi.inference.base_value import ValueSet from jedi.inference.filters import ParserTreeFilter, MergedFilter from jedi.inference.names import TreeNameDefinition from jedi.inference.compiled import mixed from jedi.inference.compiled.access import create_access_path from jedi.inference.context import ModuleContext def _create(inference_state, obj): return compiled.create_from_access_path( inference_state, create_access_path(inference_state, obj) ) class NamespaceObject: def __init__(self, dct): self.__dict__ = dct class MixedTreeName(TreeNameDefinition): def infer(self): """ In IPython notebook it is typical that some parts of the code that is provided was already executed. In that case if something is not properly inferred, it should still infer from the variables it already knows. """ inferred = super().infer() if not inferred: for compiled_value in self.parent_context.mixed_values: for f in compiled_value.get_filters(): values = ValueSet.from_sets( n.infer() for n in f.get(self.string_name) ) if values: return values return inferred class MixedParserTreeFilter(ParserTreeFilter): name_class = MixedTreeName class MixedModuleContext(ModuleContext): def __init__(self, tree_module_value, namespaces): super().__init__(tree_module_value) self.mixed_values = [ self._get_mixed_object( _create(self.inference_state, NamespaceObject(n)) ) for n in namespaces ] def _get_mixed_object(self, compiled_value): return mixed.MixedObject( compiled_value=compiled_value, tree_value=self._value ) def get_filters(self, until_position=None, origin_scope=None): yield MergedFilter( MixedParserTreeFilter( parent_context=self, until_position=until_position, origin_scope=origin_scope ), self.get_global_filter(), ) for mixed_object in self.mixed_values: yield from mixed_object.get_filters(until_position, origin_scope) ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/jedi/api/keywords.py0000664000175000017500000000225000000000000016304 0ustar00davedave00000000000000import pydoc from contextlib import suppress from typing import Dict, Optional from jedi.inference.names import AbstractArbitraryName try: from pydoc_data import topics pydoc_topics: Optional[Dict[str, str]] = topics.topics except ImportError: # Python 3.6.8 embeddable does not have pydoc_data. pydoc_topics = None class KeywordName(AbstractArbitraryName): api_type = 'keyword' def py__doc__(self): return imitate_pydoc(self.string_name) def imitate_pydoc(string): """ It's not possible to get the pydoc's without starting the annoying pager stuff. """ if pydoc_topics is None: return '' h = pydoc.help with suppress(KeyError): # try to access symbols string = h.symbols[string] string, _, related = string.partition(' ') def get_target(s): return h.topics.get(s, h.keywords.get(s)) while isinstance(string, str): string = get_target(string) try: # is a tuple now label, related = string except TypeError: return '' try: return pydoc_topics[label].strip() if pydoc_topics else '' except KeyError: return '' ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/jedi/api/project.py0000664000175000017500000004023700000000000016112 0ustar00davedave00000000000000""" Projects are a way to handle Python projects within Jedi. For simpler plugins you might not want to deal with projects, but if you want to give the user more flexibility to define sys paths and Python interpreters for a project, :class:`.Project` is the perfect way to allow for that. Projects can be saved to disk and loaded again, to allow project definitions to be used across repositories. """ import json from pathlib import Path from itertools import chain from jedi import debug from jedi.api.environment import get_cached_default_environment, create_environment from jedi.api.exceptions import WrongVersion from jedi.api.completion import search_in_module from jedi.api.helpers import split_search_string, get_module_names from jedi.inference.imports import load_module_from_path, \ load_namespace_from_path, iter_module_names from jedi.inference.sys_path import discover_buildout_paths from jedi.inference.cache import inference_state_as_method_param_cache from jedi.inference.references import recurse_find_python_folders_and_files, search_in_file_ios from jedi.file_io import FolderIO _CONFIG_FOLDER = '.jedi' _CONTAINS_POTENTIAL_PROJECT = \ 'setup.py', '.git', '.hg', 'requirements.txt', 'MANIFEST.in', 'pyproject.toml' _SERIALIZER_VERSION = 1 def _try_to_skip_duplicates(func): def wrapper(*args, **kwargs): found_tree_nodes = [] found_modules = [] for definition in func(*args, **kwargs): tree_node = definition._name.tree_name if tree_node is not None and tree_node in found_tree_nodes: continue if definition.type == 'module' and definition.module_path is not None: if definition.module_path in found_modules: continue found_modules.append(definition.module_path) yield definition found_tree_nodes.append(tree_node) return wrapper def _remove_duplicates_from_path(path): used = set() for p in path: if p in used: continue used.add(p) yield p class Project: """ Projects are a simple way to manage Python folders and define how Jedi does import resolution. It is mostly used as a parameter to :class:`.Script`. Additionally there are functions to search a whole project. """ _environment = None @staticmethod def _get_config_folder_path(base_path): return base_path.joinpath(_CONFIG_FOLDER) @staticmethod def _get_json_path(base_path): return Project._get_config_folder_path(base_path).joinpath('project.json') @classmethod def load(cls, path): """ Loads a project from a specific path. You should not provide the path to ``.jedi/project.json``, but rather the path to the project folder. :param path: The path of the directory you want to use as a project. """ if isinstance(path, str): path = Path(path) with open(cls._get_json_path(path)) as f: version, data = json.load(f) if version == 1: return cls(**data) else: raise WrongVersion( "The Jedi version of this project seems newer than what we can handle." ) def save(self): """ Saves the project configuration in the project in ``.jedi/project.json``. """ data = dict(self.__dict__) data.pop('_environment', None) data.pop('_django', None) # TODO make django setting public? data = {k.lstrip('_'): v for k, v in data.items()} data['path'] = str(data['path']) self._get_config_folder_path(self._path).mkdir(parents=True, exist_ok=True) with open(self._get_json_path(self._path), 'w') as f: return json.dump((_SERIALIZER_VERSION, data), f) def __init__( self, path, *, environment_path=None, load_unsafe_extensions=False, sys_path=None, added_sys_path=(), smart_sys_path=True, ) -> None: """ :param path: The base path for this project. :param environment_path: The Python executable path, typically the path of a virtual environment. :param load_unsafe_extensions: Default False, Loads extensions that are not in the sys path and in the local directories. With this option enabled, this is potentially unsafe if you clone a git repository and analyze it's code, because those compiled extensions will be important and therefore have execution privileges. :param sys_path: list of str. You can override the sys path if you want. By default the ``sys.path.`` is generated by the environment (virtualenvs, etc). :param added_sys_path: list of str. Adds these paths at the end of the sys path. :param smart_sys_path: If this is enabled (default), adds paths from local directories. Otherwise you will have to rely on your packages being properly configured on the ``sys.path``. """ if isinstance(path, str): path = Path(path).absolute() self._path = path self._environment_path = environment_path if sys_path is not None: # Remap potential pathlib.Path entries sys_path = list(map(str, sys_path)) self._sys_path = sys_path self._smart_sys_path = smart_sys_path self._load_unsafe_extensions = load_unsafe_extensions self._django = False # Remap potential pathlib.Path entries self.added_sys_path = list(map(str, added_sys_path)) """The sys path that is going to be added at the end of the """ @property def path(self): """ The base path for this project. """ return self._path @property def sys_path(self): """ The sys path provided to this project. This can be None and in that case will be auto generated. """ return self._sys_path @property def smart_sys_path(self): """ If the sys path is going to be calculated in a smart way, where additional paths are added. """ return self._smart_sys_path @property def load_unsafe_extensions(self): """ Wheter the project loads unsafe extensions. """ return self._load_unsafe_extensions @inference_state_as_method_param_cache() def _get_base_sys_path(self, inference_state): # The sys path has not been set explicitly. sys_path = list(inference_state.environment.get_sys_path()) try: sys_path.remove('') except ValueError: pass return sys_path @inference_state_as_method_param_cache() def _get_sys_path(self, inference_state, add_parent_paths=True, add_init_paths=False): """ Keep this method private for all users of jedi. However internally this one is used like a public method. """ suffixed = list(self.added_sys_path) prefixed = [] if self._sys_path is None: sys_path = list(self._get_base_sys_path(inference_state)) else: sys_path = list(self._sys_path) if self._smart_sys_path: prefixed.append(str(self._path)) if inference_state.script_path is not None: suffixed += map(str, discover_buildout_paths( inference_state, inference_state.script_path )) if add_parent_paths: # Collect directories in upward search by: # 1. Skipping directories with __init__.py # 2. Stopping immediately when above self._path traversed = [] for parent_path in inference_state.script_path.parents: if parent_path == self._path \ or self._path not in parent_path.parents: break if not add_init_paths \ and parent_path.joinpath("__init__.py").is_file(): continue traversed.append(str(parent_path)) # AFAIK some libraries have imports like `foo.foo.bar`, which # leads to the conclusion to by default prefer longer paths # rather than shorter ones by default. suffixed += reversed(traversed) if self._django: prefixed.append(str(self._path)) path = prefixed + sys_path + suffixed return list(_remove_duplicates_from_path(path)) def get_environment(self): if self._environment is None: if self._environment_path is not None: self._environment = create_environment(self._environment_path, safe=False) else: self._environment = get_cached_default_environment() return self._environment def search(self, string, *, all_scopes=False): """ Searches a name in the whole project. If the project is very big, at some point Jedi will stop searching. However it's also very much recommended to not exhaust the generator. Just display the first ten results to the user. There are currently three different search patterns: - ``foo`` to search for a definition foo in any file or a file called ``foo.py`` or ``foo.pyi``. - ``foo.bar`` to search for the ``foo`` and then an attribute ``bar`` in it. - ``class foo.bar.Bar`` or ``def foo.bar.baz`` to search for a specific API type. :param bool all_scopes: Default False; searches not only for definitions on the top level of a module level, but also in functions and classes. :yields: :class:`.Name` """ return self._search_func(string, all_scopes=all_scopes) def complete_search(self, string, **kwargs): """ Like :meth:`.Script.search`, but completes that string. An empty string lists all definitions in a project, so be careful with that. :param bool all_scopes: Default False; searches not only for definitions on the top level of a module level, but also in functions and classes. :yields: :class:`.Completion` """ return self._search_func(string, complete=True, **kwargs) @_try_to_skip_duplicates def _search_func(self, string, complete=False, all_scopes=False): # Using a Script is they easiest way to get an empty module context. from jedi import Script s = Script('', project=self) inference_state = s._inference_state empty_module_context = s._get_module_context() debug.dbg('Search for string %s, complete=%s', string, complete) wanted_type, wanted_names = split_search_string(string) name = wanted_names[0] stub_folder_name = name + '-stubs' ios = recurse_find_python_folders_and_files(FolderIO(str(self._path))) file_ios = [] # 1. Search for modules in the current project for folder_io, file_io in ios: if file_io is None: file_name = folder_io.get_base_name() if file_name == name or file_name == stub_folder_name: f = folder_io.get_file_io('__init__.py') try: m = load_module_from_path(inference_state, f).as_context() except FileNotFoundError: f = folder_io.get_file_io('__init__.pyi') try: m = load_module_from_path(inference_state, f).as_context() except FileNotFoundError: m = load_namespace_from_path(inference_state, folder_io).as_context() else: continue else: file_ios.append(file_io) if Path(file_io.path).name in (name + '.py', name + '.pyi'): m = load_module_from_path(inference_state, file_io).as_context() else: continue debug.dbg('Search of a specific module %s', m) yield from search_in_module( inference_state, m, names=[m.name], wanted_type=wanted_type, wanted_names=wanted_names, complete=complete, convert=True, ignore_imports=True, ) # 2. Search for identifiers in the project. for module_context in search_in_file_ios(inference_state, file_ios, name, complete=complete): names = get_module_names(module_context.tree_node, all_scopes=all_scopes) names = [module_context.create_name(n) for n in names] names = _remove_imports(names) yield from search_in_module( inference_state, module_context, names=names, wanted_type=wanted_type, wanted_names=wanted_names, complete=complete, ignore_imports=True, ) # 3. Search for modules on sys.path sys_path = [ p for p in self._get_sys_path(inference_state) # Exclude the current folder which is handled by recursing the folders. if p != self._path ] names = list(iter_module_names(inference_state, empty_module_context, sys_path)) yield from search_in_module( inference_state, empty_module_context, names=names, wanted_type=wanted_type, wanted_names=wanted_names, complete=complete, convert=True, ) def __repr__(self): return '<%s: %s>' % (self.__class__.__name__, self._path) def _is_potential_project(path): for name in _CONTAINS_POTENTIAL_PROJECT: try: if path.joinpath(name).exists(): return True except OSError: continue return False def _is_django_path(directory): """ Detects the path of the very well known Django library (if used) """ try: with open(directory.joinpath('manage.py'), 'rb') as f: return b"DJANGO_SETTINGS_MODULE" in f.read() except (FileNotFoundError, IsADirectoryError, PermissionError): return False def get_default_project(path=None): """ If a project is not defined by the user, Jedi tries to define a project by itself as well as possible. Jedi traverses folders until it finds one of the following: 1. A ``.jedi/config.json`` 2. One of the following files: ``setup.py``, ``.git``, ``.hg``, ``requirements.txt`` and ``MANIFEST.in``. """ if path is None: path = Path.cwd() elif isinstance(path, str): path = Path(path) check = path.absolute() probable_path = None first_no_init_file = None for dir in chain([check], check.parents): try: return Project.load(dir) except (FileNotFoundError, IsADirectoryError, PermissionError): pass except NotADirectoryError: continue if first_no_init_file is None: if dir.joinpath('__init__.py').exists(): # In the case that a __init__.py exists, it's in 99% just a # Python package and the project sits at least one level above. continue elif not dir.is_file(): first_no_init_file = dir if _is_django_path(dir): project = Project(dir) project._django = True return project if probable_path is None and _is_potential_project(dir): probable_path = dir if probable_path is not None: return Project(probable_path) if first_no_init_file is not None: return Project(first_no_init_file) curdir = path if path.is_dir() else path.parent return Project(curdir) def _remove_imports(names): return [ n for n in names if n.tree_name is None or n.api_type not in ('module', 'namespace') ] ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.3903792 jedi-0.19.1/jedi/api/refactoring/0000775000175000017500000000000000000000000016367 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/jedi/api/refactoring/__init__.py0000664000175000017500000002255300000000000020507 0ustar00davedave00000000000000import difflib from pathlib import Path from typing import Dict, Iterable, Tuple from parso import split_lines from jedi.api.exceptions import RefactoringError from jedi.inference.value.namespace import ImplicitNSName EXPRESSION_PARTS = ( 'or_test and_test not_test comparison ' 'expr xor_expr and_expr shift_expr arith_expr term factor power atom_expr' ).split() class ChangedFile: def __init__(self, inference_state, from_path, to_path, module_node, node_to_str_map): self._inference_state = inference_state self._from_path = from_path self._to_path = to_path self._module_node = module_node self._node_to_str_map = node_to_str_map def get_diff(self): old_lines = split_lines(self._module_node.get_code(), keepends=True) new_lines = split_lines(self.get_new_code(), keepends=True) # Add a newline at the end if it's missing. Otherwise the diff will be # very weird. A `diff -u file1 file2` would show the string: # # \ No newline at end of file # # This is not necessary IMO, because Jedi does not really play with # newlines and the ending newline does not really matter in Python # files. ~dave if old_lines[-1] != '': old_lines[-1] += '\n' if new_lines[-1] != '': new_lines[-1] += '\n' project_path = self._inference_state.project.path if self._from_path is None: from_p = '' else: try: from_p = self._from_path.relative_to(project_path) except ValueError: # Happens it the path is not on th project_path from_p = self._from_path if self._to_path is None: to_p = '' else: try: to_p = self._to_path.relative_to(project_path) except ValueError: to_p = self._to_path diff = difflib.unified_diff( old_lines, new_lines, fromfile=str(from_p), tofile=str(to_p), ) # Apparently there's a space at the end of the diff - for whatever # reason. return ''.join(diff).rstrip(' ') def get_new_code(self): return self._inference_state.grammar.refactor(self._module_node, self._node_to_str_map) def apply(self): if self._from_path is None: raise RefactoringError( 'Cannot apply a refactoring on a Script with path=None' ) with open(self._from_path, 'w', newline='') as f: f.write(self.get_new_code()) def __repr__(self): return '<%s: %s>' % (self.__class__.__name__, self._from_path) class Refactoring: def __init__(self, inference_state, file_to_node_changes, renames=()): self._inference_state = inference_state self._renames = renames self._file_to_node_changes = file_to_node_changes def get_changed_files(self) -> Dict[Path, ChangedFile]: def calculate_to_path(p): if p is None: return p p = str(p) for from_, to in renames: if p.startswith(str(from_)): p = str(to) + p[len(str(from_)):] return Path(p) renames = self.get_renames() return { path: ChangedFile( self._inference_state, from_path=path, to_path=calculate_to_path(path), module_node=next(iter(map_)).get_root_node(), node_to_str_map=map_ ) # We need to use `or`, because the path can be None for path, map_ in sorted( self._file_to_node_changes.items(), key=lambda x: x[0] or Path("") ) } def get_renames(self) -> Iterable[Tuple[Path, Path]]: """ Files can be renamed in a refactoring. """ return sorted(self._renames) def get_diff(self): text = '' project_path = self._inference_state.project.path for from_, to in self.get_renames(): text += 'rename from %s\nrename to %s\n' \ % (_try_relative_to(from_, project_path), _try_relative_to(to, project_path)) return text + ''.join(f.get_diff() for f in self.get_changed_files().values()) def apply(self): """ Applies the whole refactoring to the files, which includes renames. """ for f in self.get_changed_files().values(): f.apply() for old, new in self.get_renames(): old.rename(new) def _calculate_rename(path, new_name): dir_ = path.parent if path.name in ('__init__.py', '__init__.pyi'): return dir_, dir_.parent.joinpath(new_name) return path, dir_.joinpath(new_name + path.suffix) def rename(inference_state, definitions, new_name): file_renames = set() file_tree_name_map = {} if not definitions: raise RefactoringError("There is no name under the cursor") for d in definitions: # This private access is ok in a way. It's not public to # protect Jedi users from seeing it. tree_name = d._name.tree_name if d.type == 'module' and tree_name is None and d.module_path is not None: p = Path(d.module_path) file_renames.add(_calculate_rename(p, new_name)) elif isinstance(d._name, ImplicitNSName): for p in d._name._value.py__path__(): file_renames.add(_calculate_rename(Path(p), new_name)) else: if tree_name is not None: fmap = file_tree_name_map.setdefault(d.module_path, {}) fmap[tree_name] = tree_name.prefix + new_name return Refactoring(inference_state, file_tree_name_map, file_renames) def inline(inference_state, names): if not names: raise RefactoringError("There is no name under the cursor") if any(n.api_type in ('module', 'namespace') for n in names): raise RefactoringError("Cannot inline imports, modules or namespaces") if any(n.tree_name is None for n in names): raise RefactoringError("Cannot inline builtins/extensions") definitions = [n for n in names if n.tree_name.is_definition()] if len(definitions) == 0: raise RefactoringError("No definition found to inline") if len(definitions) > 1: raise RefactoringError("Cannot inline a name with multiple definitions") if len(names) == 1: raise RefactoringError("There are no references to this name") tree_name = definitions[0].tree_name expr_stmt = tree_name.get_definition() if expr_stmt.type != 'expr_stmt': type_ = dict( funcdef='function', classdef='class', ).get(expr_stmt.type, expr_stmt.type) raise RefactoringError("Cannot inline a %s" % type_) if len(expr_stmt.get_defined_names(include_setitem=True)) > 1: raise RefactoringError("Cannot inline a statement with multiple definitions") first_child = expr_stmt.children[1] if first_child.type == 'annassign' and len(first_child.children) == 4: first_child = first_child.children[2] if first_child != '=': if first_child.type == 'annassign': raise RefactoringError( 'Cannot inline a statement that is defined by an annotation' ) else: raise RefactoringError( 'Cannot inline a statement with "%s"' % first_child.get_code(include_prefix=False) ) rhs = expr_stmt.get_rhs() replace_code = rhs.get_code(include_prefix=False) references = [n for n in names if not n.tree_name.is_definition()] file_to_node_changes = {} for name in references: tree_name = name.tree_name path = name.get_root_context().py__file__() s = replace_code if rhs.type == 'testlist_star_expr' \ or tree_name.parent.type in EXPRESSION_PARTS \ or tree_name.parent.type == 'trailer' \ and tree_name.parent.get_next_sibling() is not None: s = '(' + replace_code + ')' of_path = file_to_node_changes.setdefault(path, {}) n = tree_name prefix = n.prefix par = n.parent if par.type == 'trailer' and par.children[0] == '.': prefix = par.parent.children[0].prefix n = par for some_node in par.parent.children[:par.parent.children.index(par)]: of_path[some_node] = '' of_path[n] = prefix + s path = definitions[0].get_root_context().py__file__() changes = file_to_node_changes.setdefault(path, {}) changes[expr_stmt] = _remove_indent_of_prefix(expr_stmt.get_first_leaf().prefix) next_leaf = expr_stmt.get_next_leaf() # Most of the time we have to remove the newline at the end of the # statement, but if there's a comment we might not need to. if next_leaf.prefix.strip(' \t') == '' \ and (next_leaf.type == 'newline' or next_leaf == ';'): changes[next_leaf] = '' return Refactoring(inference_state, file_to_node_changes) def _remove_indent_of_prefix(prefix): r""" Removes the last indentation of a prefix, e.g. " \n \n " becomes " \n \n". """ return ''.join(split_lines(prefix, keepends=True)[:-1]) def _try_relative_to(path: Path, base: Path) -> Path: try: return path.relative_to(base) except ValueError: return path ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/jedi/api/refactoring/extract.py0000664000175000017500000003315500000000000020422 0ustar00davedave00000000000000from textwrap import dedent from parso import split_lines from jedi import debug from jedi.api.exceptions import RefactoringError from jedi.api.refactoring import Refactoring, EXPRESSION_PARTS from jedi.common import indent_block from jedi.parser_utils import function_is_classmethod, function_is_staticmethod _DEFINITION_SCOPES = ('suite', 'file_input') _VARIABLE_EXCTRACTABLE = EXPRESSION_PARTS + \ ('atom testlist_star_expr testlist test lambdef lambdef_nocond ' 'keyword name number string fstring').split() def extract_variable(inference_state, path, module_node, name, pos, until_pos): nodes = _find_nodes(module_node, pos, until_pos) debug.dbg('Extracting nodes: %s', nodes) is_expression, message = _is_expression_with_error(nodes) if not is_expression: raise RefactoringError(message) generated_code = name + ' = ' + _expression_nodes_to_string(nodes) file_to_node_changes = {path: _replace(nodes, name, generated_code, pos)} return Refactoring(inference_state, file_to_node_changes) def _is_expression_with_error(nodes): """ Returns a tuple (is_expression, error_string). """ if any(node.type == 'name' and node.is_definition() for node in nodes): return False, 'Cannot extract a name that defines something' if nodes[0].type not in _VARIABLE_EXCTRACTABLE: return False, 'Cannot extract a "%s"' % nodes[0].type return True, '' def _find_nodes(module_node, pos, until_pos): """ Looks up a module and tries to find the appropriate amount of nodes that are in there. """ start_node = module_node.get_leaf_for_position(pos, include_prefixes=True) if until_pos is None: if start_node.type == 'operator': next_leaf = start_node.get_next_leaf() if next_leaf is not None and next_leaf.start_pos == pos: start_node = next_leaf if _is_not_extractable_syntax(start_node): start_node = start_node.parent if start_node.parent.type == 'trailer': start_node = start_node.parent.parent while start_node.parent.type in EXPRESSION_PARTS: start_node = start_node.parent nodes = [start_node] else: # Get the next leaf if we are at the end of a leaf if start_node.end_pos == pos: next_leaf = start_node.get_next_leaf() if next_leaf is not None: start_node = next_leaf # Some syntax is not exactable, just use its parent if _is_not_extractable_syntax(start_node): start_node = start_node.parent # Find the end end_leaf = module_node.get_leaf_for_position(until_pos, include_prefixes=True) if end_leaf.start_pos > until_pos: end_leaf = end_leaf.get_previous_leaf() if end_leaf is None: raise RefactoringError('Cannot extract anything from that') parent_node = start_node while parent_node.end_pos < end_leaf.end_pos: parent_node = parent_node.parent nodes = _remove_unwanted_expression_nodes(parent_node, pos, until_pos) # If the user marks just a return statement, we return the expression # instead of the whole statement, because the user obviously wants to # extract that part. if len(nodes) == 1 and start_node.type in ('return_stmt', 'yield_expr'): return [nodes[0].children[1]] return nodes def _replace(nodes, expression_replacement, extracted, pos, insert_before_leaf=None, remaining_prefix=None): # Now try to replace the nodes found with a variable and move the code # before the current statement. definition = _get_parent_definition(nodes[0]) if insert_before_leaf is None: insert_before_leaf = definition.get_first_leaf() first_node_leaf = nodes[0].get_first_leaf() lines = split_lines(insert_before_leaf.prefix, keepends=True) if first_node_leaf is insert_before_leaf: if remaining_prefix is not None: # The remaining prefix has already been calculated. lines[:-1] = remaining_prefix lines[-1:-1] = [indent_block(extracted, lines[-1]) + '\n'] extracted_prefix = ''.join(lines) replacement_dct = {} if first_node_leaf is insert_before_leaf: replacement_dct[nodes[0]] = extracted_prefix + expression_replacement else: if remaining_prefix is None: p = first_node_leaf.prefix else: p = remaining_prefix + _get_indentation(nodes[0]) replacement_dct[nodes[0]] = p + expression_replacement replacement_dct[insert_before_leaf] = extracted_prefix + insert_before_leaf.value for node in nodes[1:]: replacement_dct[node] = '' return replacement_dct def _expression_nodes_to_string(nodes): return ''.join(n.get_code(include_prefix=i != 0) for i, n in enumerate(nodes)) def _suite_nodes_to_string(nodes, pos): n = nodes[0] prefix, part_of_code = _split_prefix_at(n.get_first_leaf(), pos[0] - 1) code = part_of_code + n.get_code(include_prefix=False) \ + ''.join(n.get_code() for n in nodes[1:]) return prefix, code def _split_prefix_at(leaf, until_line): """ Returns a tuple of the leaf's prefix, split at the until_line position. """ # second means the second returned part second_line_count = leaf.start_pos[0] - until_line lines = split_lines(leaf.prefix, keepends=True) return ''.join(lines[:-second_line_count]), ''.join(lines[-second_line_count:]) def _get_indentation(node): return split_lines(node.get_first_leaf().prefix)[-1] def _get_parent_definition(node): """ Returns the statement where a node is defined. """ while node is not None: if node.parent.type in _DEFINITION_SCOPES: return node node = node.parent raise NotImplementedError('We should never even get here') def _remove_unwanted_expression_nodes(parent_node, pos, until_pos): """ This function makes it so for `1 * 2 + 3` you can extract `2 + 3`, even though it is not part of the expression. """ typ = parent_node.type is_suite_part = typ in ('suite', 'file_input') if typ in EXPRESSION_PARTS or is_suite_part: nodes = parent_node.children for i, n in enumerate(nodes): if n.end_pos > pos: start_index = i if n.type == 'operator': start_index -= 1 break for i, n in reversed(list(enumerate(nodes))): if n.start_pos < until_pos: end_index = i if n.type == 'operator': end_index += 1 # Something like `not foo or bar` should not be cut after not for n2 in nodes[i:]: if _is_not_extractable_syntax(n2): end_index += 1 else: break break nodes = nodes[start_index:end_index + 1] if not is_suite_part: nodes[0:1] = _remove_unwanted_expression_nodes(nodes[0], pos, until_pos) nodes[-1:] = _remove_unwanted_expression_nodes(nodes[-1], pos, until_pos) return nodes return [parent_node] def _is_not_extractable_syntax(node): return node.type == 'operator' \ or node.type == 'keyword' and node.value not in ('None', 'True', 'False') def extract_function(inference_state, path, module_context, name, pos, until_pos): nodes = _find_nodes(module_context.tree_node, pos, until_pos) assert len(nodes) is_expression, _ = _is_expression_with_error(nodes) context = module_context.create_context(nodes[0]) is_bound_method = context.is_bound_method() params, return_variables = list(_find_inputs_and_outputs(module_context, context, nodes)) # Find variables # Is a class method / method if context.is_module(): insert_before_leaf = None # Leaf will be determined later else: node = _get_code_insertion_node(context.tree_node, is_bound_method) insert_before_leaf = node.get_first_leaf() if is_expression: code_block = 'return ' + _expression_nodes_to_string(nodes) + '\n' remaining_prefix = None has_ending_return_stmt = False else: has_ending_return_stmt = _is_node_ending_return_stmt(nodes[-1]) if not has_ending_return_stmt: # Find the actually used variables (of the defined ones). If none are # used (e.g. if the range covers the whole function), return the last # defined variable. return_variables = list(_find_needed_output_variables( context, nodes[0].parent, nodes[-1].end_pos, return_variables )) or [return_variables[-1]] if return_variables else [] remaining_prefix, code_block = _suite_nodes_to_string(nodes, pos) after_leaf = nodes[-1].get_next_leaf() first, second = _split_prefix_at(after_leaf, until_pos[0]) code_block += first code_block = dedent(code_block) if not has_ending_return_stmt: output_var_str = ', '.join(return_variables) code_block += 'return ' + output_var_str + '\n' # Check if we have to raise RefactoringError _check_for_non_extractables(nodes[:-1] if has_ending_return_stmt else nodes) decorator = '' self_param = None if is_bound_method: if not function_is_staticmethod(context.tree_node): function_param_names = context.get_value().get_param_names() if len(function_param_names): self_param = function_param_names[0].string_name params = [p for p in params if p != self_param] if function_is_classmethod(context.tree_node): decorator = '@classmethod\n' else: code_block += '\n' function_code = '%sdef %s(%s):\n%s' % ( decorator, name, ', '.join(params if self_param is None else [self_param] + params), indent_block(code_block) ) function_call = '%s(%s)' % ( ('' if self_param is None else self_param + '.') + name, ', '.join(params) ) if is_expression: replacement = function_call else: if has_ending_return_stmt: replacement = 'return ' + function_call + '\n' else: replacement = output_var_str + ' = ' + function_call + '\n' replacement_dct = _replace(nodes, replacement, function_code, pos, insert_before_leaf, remaining_prefix) if not is_expression: replacement_dct[after_leaf] = second + after_leaf.value file_to_node_changes = {path: replacement_dct} return Refactoring(inference_state, file_to_node_changes) def _check_for_non_extractables(nodes): for n in nodes: try: children = n.children except AttributeError: if n.value == 'return': raise RefactoringError( 'Can only extract return statements if they are at the end.') if n.value == 'yield': raise RefactoringError('Cannot extract yield statements.') else: _check_for_non_extractables(children) def _is_name_input(module_context, names, first, last): for name in names: if name.api_type == 'param' or not name.parent_context.is_module(): if name.get_root_context() is not module_context: return True if name.start_pos is None or not (first <= name.start_pos < last): return True return False def _find_inputs_and_outputs(module_context, context, nodes): first = nodes[0].start_pos last = nodes[-1].end_pos inputs = [] outputs = [] for name in _find_non_global_names(nodes): if name.is_definition(): if name not in outputs: outputs.append(name.value) else: if name.value not in inputs: name_definitions = context.goto(name, name.start_pos) if not name_definitions \ or _is_name_input(module_context, name_definitions, first, last): inputs.append(name.value) # Check if outputs are really needed: return inputs, outputs def _find_non_global_names(nodes): for node in nodes: try: children = node.children except AttributeError: if node.type == 'name': yield node else: # We only want to check foo in foo.bar if node.type == 'trailer' and node.children[0] == '.': continue yield from _find_non_global_names(children) def _get_code_insertion_node(node, is_bound_method): if not is_bound_method or function_is_staticmethod(node): while node.parent.type != 'file_input': node = node.parent while node.parent.type in ('async_funcdef', 'decorated', 'async_stmt'): node = node.parent return node def _find_needed_output_variables(context, search_node, at_least_pos, return_variables): """ Searches everything after at_least_pos in a node and checks if any of the return_variables are used in there and returns those. """ for node in search_node.children: if node.start_pos < at_least_pos: continue return_variables = set(return_variables) for name in _find_non_global_names([node]): if not name.is_definition() and name.value in return_variables: return_variables.remove(name.value) yield name.value def _is_node_ending_return_stmt(node): t = node.type if t == 'simple_stmt': return _is_node_ending_return_stmt(node.children[0]) return t == 'return_stmt' ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/jedi/api/replstartup.py0000664000175000017500000000166600000000000017034 0ustar00davedave00000000000000""" To use Jedi completion in Python interpreter, add the following in your shell setup (e.g., ``.bashrc``). This works only on Linux/Mac, because readline is not available on Windows. If you still want Jedi autocompletion in your REPL, just use IPython instead:: export PYTHONSTARTUP="$(python -m jedi repl)" Then you will be able to use Jedi completer in your Python interpreter:: $ python Python 3.9.2+ (default, Jul 20 2020, 22:15:08) [GCC 4.6.1] on linux2 Type "help", "copyright", "credits" or "license" for more information. >>> import os >>> os.path.join('a', 'b').split().in # doctest: +SKIP ..dex ..sert """ import jedi.utils from jedi import __version__ as __jedi_version__ print('REPL completion using Jedi %s' % __jedi_version__) jedi.utils.setup_readline(fuzzy=False) del jedi # Note: try not to do many things here, as it will contaminate global # namespace of the interpreter. ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/jedi/api/strings.py0000664000175000017500000000717700000000000016143 0ustar00davedave00000000000000""" This module is here for string completions. This means mostly stuff where strings are returned, like `foo = dict(bar=3); foo["ba` would complete to `"bar"]`. It however does the same for numbers. The difference between string completions and other completions is mostly that this module doesn't return defined names in a module, but pretty much an arbitrary string. """ import re from jedi.inference.names import AbstractArbitraryName from jedi.inference.helpers import infer_call_of_leaf from jedi.api.classes import Completion from jedi.parser_utils import cut_value_at_position _sentinel = object() class StringName(AbstractArbitraryName): api_type = 'string' is_value_name = False def complete_dict(module_context, code_lines, leaf, position, string, fuzzy): bracket_leaf = leaf if bracket_leaf != '[': bracket_leaf = leaf.get_previous_leaf() cut_end_quote = '' if string: cut_end_quote = get_quote_ending(string, code_lines, position, invert_result=True) if bracket_leaf == '[': if string is None and leaf is not bracket_leaf: string = cut_value_at_position(leaf, position) context = module_context.create_context(bracket_leaf) before_node = before_bracket_leaf = bracket_leaf.get_previous_leaf() if before_node in (')', ']', '}'): before_node = before_node.parent if before_node.type in ('atom', 'trailer', 'name'): values = infer_call_of_leaf(context, before_bracket_leaf) return list(_completions_for_dicts( module_context.inference_state, values, '' if string is None else string, cut_end_quote, fuzzy=fuzzy, )) return [] def _completions_for_dicts(inference_state, dicts, literal_string, cut_end_quote, fuzzy): for dict_key in sorted(_get_python_keys(dicts), key=lambda x: repr(x)): dict_key_str = _create_repr_string(literal_string, dict_key) if dict_key_str.startswith(literal_string): name = StringName(inference_state, dict_key_str[:-len(cut_end_quote) or None]) yield Completion( inference_state, name, stack=None, like_name_length=len(literal_string), is_fuzzy=fuzzy ) def _create_repr_string(literal_string, dict_key): if not isinstance(dict_key, (str, bytes)) or not literal_string: return repr(dict_key) r = repr(dict_key) prefix, quote = _get_string_prefix_and_quote(literal_string) if quote is None: return r if quote == r[0]: return prefix + r return prefix + quote + r[1:-1] + quote def _get_python_keys(dicts): for dct in dicts: if dct.array_type == 'dict': for key in dct.get_key_values(): dict_key = key.get_safe_value(default=_sentinel) if dict_key is not _sentinel: yield dict_key def _get_string_prefix_and_quote(string): match = re.match(r'(\w*)("""|\'{3}|"|\')', string) if match is None: return None, None return match.group(1), match.group(2) def _matches_quote_at_position(code_lines, quote, position): string = code_lines[position[0] - 1][position[1]:position[1] + len(quote)] return string == quote def get_quote_ending(string, code_lines, position, invert_result=False): _, quote = _get_string_prefix_and_quote(string) if quote is None: return '' # Add a quote only if it's not already there. if _matches_quote_at_position(code_lines, quote, position) != invert_result: return '' return quote ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/jedi/cache.py0000664000175000017500000000713200000000000014733 0ustar00davedave00000000000000""" This caching is very important for speed and memory optimizations. There's nothing really spectacular, just some decorators. The following cache types are available: - ``time_cache`` can be used to cache something for just a limited time span, which can be useful if there's user interaction and the user cannot react faster than a certain time. This module is one of the reasons why |jedi| is not thread-safe. As you can see there are global variables, which are holding the cache information. Some of these variables are being cleaned after every API usage. """ import time from functools import wraps from typing import Any, Dict, Tuple from jedi import settings from parso.cache import parser_cache _time_caches: Dict[str, Dict[Any, Tuple[float, Any]]] = {} def clear_time_caches(delete_all: bool = False) -> None: """ Jedi caches many things, that should be completed after each completion finishes. :param delete_all: Deletes also the cache that is normally not deleted, like parser cache, which is important for faster parsing. """ global _time_caches if delete_all: for cache in _time_caches.values(): cache.clear() parser_cache.clear() else: # normally just kill the expired entries, not all for tc in _time_caches.values(): # check time_cache for expired entries for key, (t, value) in list(tc.items()): if t < time.time(): # delete expired entries del tc[key] def signature_time_cache(time_add_setting): """ This decorator works as follows: Call it with a setting and after that use the function with a callable that returns the key. But: This function is only called if the key is not available. After a certain amount of time (`time_add_setting`) the cache is invalid. If the given key is None, the function will not be cached. """ def _temp(key_func): dct = {} _time_caches[time_add_setting] = dct def wrapper(*args, **kwargs): generator = key_func(*args, **kwargs) key = next(generator) try: expiry, value = dct[key] if expiry > time.time(): return value except KeyError: pass value = next(generator) time_add = getattr(settings, time_add_setting) if key is not None: dct[key] = time.time() + time_add, value return value return wrapper return _temp def time_cache(seconds): def decorator(func): cache = {} @wraps(func) def wrapper(*args, **kwargs): key = (args, frozenset(kwargs.items())) try: created, result = cache[key] if time.time() < created + seconds: return result except KeyError: pass result = func(*args, **kwargs) cache[key] = time.time(), result return result wrapper.clear_cache = lambda: cache.clear() return wrapper return decorator def memoize_method(method): """A normal memoize function.""" @wraps(method) def wrapper(self, *args, **kwargs): cache_dict = self.__dict__.setdefault('_memoize_method_dct', {}) dct = cache_dict.setdefault(method, {}) key = (args, frozenset(kwargs.items())) try: return dct[key] except KeyError: result = method(self, *args, **kwargs) dct[key] = result return result return wrapper ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/jedi/common.py0000664000175000017500000000123400000000000015155 0ustar00davedave00000000000000from contextlib import contextmanager @contextmanager def monkeypatch(obj, attribute_name, new_value): """ Like pytest's monkeypatch, but as a value manager. """ old_value = getattr(obj, attribute_name) try: setattr(obj, attribute_name, new_value) yield finally: setattr(obj, attribute_name, old_value) def indent_block(text, indention=' '): """This function indents a text block with a default of four spaces.""" temp = '' while text and text[-1] == '\n': temp += text[-1] text = text[:-1] lines = text.split('\n') return '\n'.join(map(lambda s: indention + s, lines)) + temp ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/jedi/debug.py0000664000175000017500000000666000000000000014763 0ustar00davedave00000000000000import os import time from contextlib import contextmanager from typing import Callable, Optional _inited = False def _lazy_colorama_init(): """ Lazily init colorama if necessary, not to screw up stdout if debugging is not enabled. This version of the function does nothing. """ try: if os.name == 'nt': # Does not work on Windows, as pyreadline and colorama interfere raise ImportError else: # Use colorama for nicer console output. from colorama import Fore, init # type: ignore[import] from colorama import initialise def _lazy_colorama_init(): # noqa: F811 """ Lazily init colorama if necessary, not to screw up stdout is debug not enabled. This version of the function does init colorama. """ global _inited if not _inited: # pytest resets the stream at the end - causes troubles. Since # after every output the stream is reset automatically we don't # need this. initialise.atexit_done = True try: init(strip=False) except Exception: # Colorama fails with initializing under vim and is buggy in # version 0.3.6. pass _inited = True except ImportError: class Fore: # type: ignore[no-redef] RED = '' GREEN = '' YELLOW = '' MAGENTA = '' RESET = '' BLUE = '' NOTICE = object() WARNING = object() SPEED = object() enable_speed = False enable_warning = False enable_notice = False # callback, interface: level, str debug_function: Optional[Callable[[str, str], None]] = None _debug_indent = 0 _start_time = time.time() def reset_time(): global _start_time, _debug_indent _start_time = time.time() _debug_indent = 0 def increase_indent(func): """Decorator for makin """ def wrapper(*args, **kwargs): with increase_indent_cm(): return func(*args, **kwargs) return wrapper @contextmanager def increase_indent_cm(title=None, color='MAGENTA'): global _debug_indent if title: dbg('Start: ' + title, color=color) _debug_indent += 1 try: yield finally: _debug_indent -= 1 if title: dbg('End: ' + title, color=color) def dbg(message, *args, color='GREEN'): """ Looks at the stack, to see if a debug message should be printed. """ assert color if debug_function and enable_notice: i = ' ' * _debug_indent _lazy_colorama_init() debug_function(color, i + 'dbg: ' + message % tuple(repr(a) for a in args)) def warning(message, *args, format=True): if debug_function and enable_warning: i = ' ' * _debug_indent if format: message = message % tuple(repr(a) for a in args) debug_function('RED', i + 'warning: ' + message) def speed(name): if debug_function and enable_speed: now = time.time() i = ' ' * _debug_indent debug_function('YELLOW', i + 'speed: ' + '%s %s' % (name, now - _start_time)) def print_to_stdout(color, str_out): """ The default debug function that prints to standard out. :param str color: A string that is an attribute of ``colorama.Fore``. """ col = getattr(Fore, color) _lazy_colorama_init() print(col + str_out + Fore.RESET) ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/jedi/file_io.py0000664000175000017500000000444100000000000015276 0ustar00davedave00000000000000import os from parso import file_io class AbstractFolderIO: def __init__(self, path): self.path = path def get_base_name(self): raise NotImplementedError def list(self): raise NotImplementedError def get_file_io(self, name): raise NotImplementedError def get_parent_folder(self): raise NotImplementedError def __repr__(self): return '<%s: %s>' % (self.__class__.__name__, self.path) class FolderIO(AbstractFolderIO): def get_base_name(self): return os.path.basename(self.path) def list(self): return os.listdir(self.path) def get_file_io(self, name): return FileIO(os.path.join(self.path, name)) def get_parent_folder(self): return FolderIO(os.path.dirname(self.path)) def walk(self): for root, dirs, files in os.walk(self.path): root_folder_io = FolderIO(root) original_folder_ios = [FolderIO(os.path.join(root, d)) for d in dirs] modified_folder_ios = list(original_folder_ios) yield ( root_folder_io, modified_folder_ios, [FileIO(os.path.join(root, f)) for f in files], ) modified_iterator = iter(reversed(modified_folder_ios)) current = next(modified_iterator, None) i = len(original_folder_ios) for folder_io in reversed(original_folder_ios): i -= 1 # Basically enumerate but reversed if current is folder_io: current = next(modified_iterator, None) else: del dirs[i] class FileIOFolderMixin: def get_parent_folder(self): return FolderIO(os.path.dirname(self.path)) class ZipFileIO(file_io.KnownContentFileIO, FileIOFolderMixin): """For .zip and .egg archives""" def __init__(self, path, code, zip_path): super().__init__(path, code) self._zip_path = zip_path def get_last_modified(self): try: return os.path.getmtime(self._zip_path) except (FileNotFoundError, PermissionError, NotADirectoryError): return None class FileIO(file_io.FileIO, FileIOFolderMixin): pass class KnownContentFileIO(file_io.KnownContentFileIO, FileIOFolderMixin): pass ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.3903792 jedi-0.19.1/jedi/inference/0000775000175000017500000000000000000000000015251 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/jedi/inference/__init__.py0000664000175000017500000002047100000000000017366 0ustar00davedave00000000000000""" Type inference of Python code in |jedi| is based on three assumptions: * The code uses as least side effects as possible. Jedi understands certain list/tuple/set modifications, but there's no guarantee that Jedi detects everything (list.append in different modules for example). * No magic is being used: - metaclasses - ``setattr()`` / ``__import__()`` - writing to ``globals()``, ``locals()``, ``object.__dict__`` * The programmer is not a total dick, e.g. like `this `_ :-) The actual algorithm is based on a principle I call lazy type inference. That said, the typical entry point for static analysis is calling ``infer_expr_stmt``. There's separate logic for autocompletion in the API, the inference_state is all about inferring an expression. TODO this paragraph is not what jedi does anymore, it's similar, but not the same. Now you need to understand what follows after ``infer_expr_stmt``. Let's make an example:: import datetime datetime.date.toda# <-- cursor here First of all, this module doesn't care about completion. It really just cares about ``datetime.date``. At the end of the procedure ``infer_expr_stmt`` will return the ``date`` class. To *visualize* this (simplified): - ``InferenceState.infer_expr_stmt`` doesn't do much, because there's no assignment. - ``Context.infer_node`` cares for resolving the dotted path - ``InferenceState.find_types`` searches for global definitions of datetime, which it finds in the definition of an import, by scanning the syntax tree. - Using the import logic, the datetime module is found. - Now ``find_types`` is called again by ``infer_node`` to find ``date`` inside the datetime module. Now what would happen if we wanted ``datetime.date.foo.bar``? Two more calls to ``find_types``. However the second call would be ignored, because the first one would return nothing (there's no foo attribute in ``date``). What if the import would contain another ``ExprStmt`` like this:: from foo import bar Date = bar.baz Well... You get it. Just another ``infer_expr_stmt`` recursion. It's really easy. Python can obviously get way more complicated then this. To understand tuple assignments, list comprehensions and everything else, a lot more code had to be written. Jedi has been tested very well, so you can just start modifying code. It's best to write your own test first for your "new" feature. Don't be scared of breaking stuff. As long as the tests pass, you're most likely to be fine. I need to mention now that lazy type inference is really good because it only *inferes* what needs to be *inferred*. All the statements and modules that are not used are just being ignored. """ import parso from jedi.file_io import FileIO from jedi import debug from jedi import settings from jedi.inference import imports from jedi.inference import recursion from jedi.inference.cache import inference_state_function_cache from jedi.inference import helpers from jedi.inference.names import TreeNameDefinition from jedi.inference.base_value import ContextualizedNode, \ ValueSet, iterate_values from jedi.inference.value import ClassValue, FunctionValue from jedi.inference.syntax_tree import infer_expr_stmt, \ check_tuple_assignments, tree_name_to_values from jedi.inference.imports import follow_error_node_imports_if_possible from jedi.plugins import plugin_manager class InferenceState: def __init__(self, project, environment=None, script_path=None): if environment is None: environment = project.get_environment() self.environment = environment self.script_path = script_path self.compiled_subprocess = environment.get_inference_state_subprocess(self) self.grammar = environment.get_grammar() self.latest_grammar = parso.load_grammar(version='3.12') self.memoize_cache = {} # for memoize decorators self.module_cache = imports.ModuleCache() # does the job of `sys.modules`. self.stub_module_cache = {} # Dict[Tuple[str, ...], Optional[ModuleValue]] self.compiled_cache = {} # see `inference.compiled.create()` self.inferred_element_counts = {} self.mixed_cache = {} # see `inference.compiled.mixed._create()` self.analysis = [] self.dynamic_params_depth = 0 self.do_dynamic_params_search = settings.dynamic_params self.is_analysis = False self.project = project self.access_cache = {} self.allow_unsafe_executions = False self.flow_analysis_enabled = True self.reset_recursion_limitations() def import_module(self, import_names, sys_path=None, prefer_stubs=True): return imports.import_module_by_names( self, import_names, sys_path, prefer_stubs=prefer_stubs) @staticmethod @plugin_manager.decorate() def execute(value, arguments): debug.dbg('execute: %s %s', value, arguments) with debug.increase_indent_cm(): value_set = value.py__call__(arguments=arguments) debug.dbg('execute result: %s in %s', value_set, value) return value_set # mypy doesn't suppport decorated propeties (https://github.com/python/mypy/issues/1362) @property # type: ignore[misc] @inference_state_function_cache() def builtins_module(self): module_name = 'builtins' builtins_module, = self.import_module((module_name,), sys_path=[]) return builtins_module @property # type: ignore[misc] @inference_state_function_cache() def typing_module(self): typing_module, = self.import_module(('typing',)) return typing_module def reset_recursion_limitations(self): self.recursion_detector = recursion.RecursionDetector() self.execution_recursion_detector = recursion.ExecutionRecursionDetector(self) def get_sys_path(self, **kwargs): """Convenience function""" return self.project._get_sys_path(self, **kwargs) def infer(self, context, name): def_ = name.get_definition(import_name_always=True) if def_ is not None: type_ = def_.type is_classdef = type_ == 'classdef' if is_classdef or type_ == 'funcdef': if is_classdef: c = ClassValue(self, context, name.parent) else: c = FunctionValue.from_context(context, name.parent) return ValueSet([c]) if type_ == 'expr_stmt': is_simple_name = name.parent.type not in ('power', 'trailer') if is_simple_name: return infer_expr_stmt(context, def_, name) if type_ == 'for_stmt': container_types = context.infer_node(def_.children[3]) cn = ContextualizedNode(context, def_.children[3]) for_types = iterate_values(container_types, cn) n = TreeNameDefinition(context, name) return check_tuple_assignments(n, for_types) if type_ in ('import_from', 'import_name'): return imports.infer_import(context, name) if type_ == 'with_stmt': return tree_name_to_values(self, context, name) elif type_ == 'param': return context.py__getattribute__(name.value, position=name.end_pos) elif type_ == 'namedexpr_test': return context.infer_node(def_) else: result = follow_error_node_imports_if_possible(context, name) if result is not None: return result return helpers.infer_call_of_leaf(context, name) def parse_and_get_code(self, code=None, path=None, use_latest_grammar=False, file_io=None, **kwargs): if code is None: if file_io is None: file_io = FileIO(path) code = file_io.read() # We cannot just use parso, because it doesn't use errors='replace'. code = parso.python_bytes_to_unicode(code, encoding='utf-8', errors='replace') if len(code) > settings._cropped_file_size: code = code[:settings._cropped_file_size] grammar = self.latest_grammar if use_latest_grammar else self.grammar return grammar.parse(code=code, path=path, file_io=file_io, **kwargs), code def parse(self, *args, **kwargs): return self.parse_and_get_code(*args, **kwargs)[0] ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/jedi/inference/analysis.py0000664000175000017500000001712300000000000017452 0ustar00davedave00000000000000""" Module for statical analysis. """ from parso.python import tree from jedi import debug from jedi.inference.helpers import is_string CODES = { 'attribute-error': (1, AttributeError, 'Potential AttributeError.'), 'name-error': (2, NameError, 'Potential NameError.'), 'import-error': (3, ImportError, 'Potential ImportError.'), 'type-error-too-many-arguments': (4, TypeError, None), 'type-error-too-few-arguments': (5, TypeError, None), 'type-error-keyword-argument': (6, TypeError, None), 'type-error-multiple-values': (7, TypeError, None), 'type-error-star-star': (8, TypeError, None), 'type-error-star': (9, TypeError, None), 'type-error-operation': (10, TypeError, None), 'type-error-not-iterable': (11, TypeError, None), 'type-error-isinstance': (12, TypeError, None), 'type-error-not-subscriptable': (13, TypeError, None), 'value-error-too-many-values': (14, ValueError, None), 'value-error-too-few-values': (15, ValueError, None), } class Error: def __init__(self, name, module_path, start_pos, message=None): self.path = module_path self._start_pos = start_pos self.name = name if message is None: message = CODES[self.name][2] self.message = message @property def line(self): return self._start_pos[0] @property def column(self): return self._start_pos[1] @property def code(self): # The class name start first = self.__class__.__name__[0] return first + str(CODES[self.name][0]) def __str__(self): return '%s:%s:%s: %s %s' % (self.path, self.line, self.column, self.code, self.message) def __eq__(self, other): return (self.path == other.path and self.name == other.name and self._start_pos == other._start_pos) def __ne__(self, other): return not self.__eq__(other) def __hash__(self): return hash((self.path, self._start_pos, self.name)) def __repr__(self): return '<%s %s: %s@%s,%s>' % (self.__class__.__name__, self.name, self.path, self._start_pos[0], self._start_pos[1]) class Warning(Error): pass def add(node_context, error_name, node, message=None, typ=Error, payload=None): exception = CODES[error_name][1] if _check_for_exception_catch(node_context, node, exception, payload): return # TODO this path is probably not right module_context = node_context.get_root_context() module_path = module_context.py__file__() issue_instance = typ(error_name, module_path, node.start_pos, message) debug.warning(str(issue_instance), format=False) node_context.inference_state.analysis.append(issue_instance) return issue_instance def _check_for_setattr(instance): """ Check if there's any setattr method inside an instance. If so, return True. """ module = instance.get_root_context() node = module.tree_node if node is None: # If it's a compiled module or doesn't have a tree_node return False try: stmt_names = node.get_used_names()['setattr'] except KeyError: return False return any(node.start_pos < n.start_pos < node.end_pos # Check if it's a function called setattr. and not (n.parent.type == 'funcdef' and n.parent.name == n) for n in stmt_names) def add_attribute_error(name_context, lookup_value, name): message = ('AttributeError: %s has no attribute %s.' % (lookup_value, name)) # Check for __getattr__/__getattribute__ existance and issue a warning # instead of an error, if that happens. typ = Error if lookup_value.is_instance() and not lookup_value.is_compiled(): # TODO maybe make a warning for __getattr__/__getattribute__ if _check_for_setattr(lookup_value): typ = Warning payload = lookup_value, name add(name_context, 'attribute-error', name, message, typ, payload) def _check_for_exception_catch(node_context, jedi_name, exception, payload=None): """ Checks if a jedi object (e.g. `Statement`) sits inside a try/catch and doesn't count as an error (if equal to `exception`). Also checks `hasattr` for AttributeErrors and uses the `payload` to compare it. Returns True if the exception was catched. """ def check_match(cls, exception): if not cls.is_class(): return False for python_cls in exception.mro(): if cls.py__name__() == python_cls.__name__ \ and cls.parent_context.is_builtins_module(): return True return False def check_try_for_except(obj, exception): # Only nodes in try iterator = iter(obj.children) for branch_type in iterator: next(iterator) # The colon suite = next(iterator) if branch_type == 'try' \ and not (branch_type.start_pos < jedi_name.start_pos <= suite.end_pos): return False for node in obj.get_except_clause_tests(): if node is None: return True # An exception block that catches everything. else: except_classes = node_context.infer_node(node) for cls in except_classes: from jedi.inference.value import iterable if isinstance(cls, iterable.Sequence) and \ cls.array_type == 'tuple': # multiple exceptions for lazy_value in cls.py__iter__(): for typ in lazy_value.infer(): if check_match(typ, exception): return True else: if check_match(cls, exception): return True def check_hasattr(node, suite): try: assert suite.start_pos <= jedi_name.start_pos < suite.end_pos assert node.type in ('power', 'atom_expr') base = node.children[0] assert base.type == 'name' and base.value == 'hasattr' trailer = node.children[1] assert trailer.type == 'trailer' arglist = trailer.children[1] assert arglist.type == 'arglist' from jedi.inference.arguments import TreeArguments args = TreeArguments(node_context.inference_state, node_context, arglist) unpacked_args = list(args.unpack()) # Arguments should be very simple assert len(unpacked_args) == 2 # Check name key, lazy_value = unpacked_args[1] names = list(lazy_value.infer()) assert len(names) == 1 and is_string(names[0]) assert names[0].get_safe_value() == payload[1].value # Check objects key, lazy_value = unpacked_args[0] objects = lazy_value.infer() return payload[0] in objects except AssertionError: return False obj = jedi_name while obj is not None and not isinstance(obj, (tree.Function, tree.Class)): if isinstance(obj, tree.Flow): # try/except catch check if obj.type == 'try_stmt' and check_try_for_except(obj, exception): return True # hasattr check if exception == AttributeError and obj.type in ('if_stmt', 'while_stmt'): if check_hasattr(obj.children[1], obj.children[3]): return True obj = obj.parent return False ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/jedi/inference/arguments.py0000664000175000017500000002767200000000000017646 0ustar00davedave00000000000000import re from itertools import zip_longest from parso.python import tree from jedi import debug from jedi.inference.utils import PushBackIterator from jedi.inference import analysis from jedi.inference.lazy_value import LazyKnownValue, LazyKnownValues, \ LazyTreeValue, get_merged_lazy_value from jedi.inference.names import ParamName, TreeNameDefinition, AnonymousParamName from jedi.inference.base_value import NO_VALUES, ValueSet, ContextualizedNode from jedi.inference.value import iterable from jedi.inference.cache import inference_state_as_method_param_cache def try_iter_content(types, depth=0): """Helper method for static analysis.""" if depth > 10: # It's possible that a loop has references on itself (especially with # CompiledValue). Therefore don't loop infinitely. return for typ in types: try: f = typ.py__iter__ except AttributeError: pass else: for lazy_value in f(): try_iter_content(lazy_value.infer(), depth + 1) class ParamIssue(Exception): pass def repack_with_argument_clinic(clinic_string): """ Transforms a function or method with arguments to the signature that is given as an argument clinic notation. Argument clinic is part of CPython and used for all the functions that are implemented in C (Python 3.7): str.split.__text_signature__ # Results in: '($self, /, sep=None, maxsplit=-1)' """ def decorator(func): def wrapper(value, arguments): try: args = tuple(iterate_argument_clinic( value.inference_state, arguments, clinic_string, )) except ParamIssue: return NO_VALUES else: return func(value, *args) return wrapper return decorator def iterate_argument_clinic(inference_state, arguments, clinic_string): """Uses a list with argument clinic information (see PEP 436).""" clinic_args = list(_parse_argument_clinic(clinic_string)) iterator = PushBackIterator(arguments.unpack()) for i, (name, optional, allow_kwargs, stars) in enumerate(clinic_args): if stars == 1: lazy_values = [] for key, argument in iterator: if key is not None: iterator.push_back((key, argument)) break lazy_values.append(argument) yield ValueSet([iterable.FakeTuple(inference_state, lazy_values)]) lazy_values continue elif stars == 2: raise NotImplementedError() key, argument = next(iterator, (None, None)) if key is not None: debug.warning('Keyword arguments in argument clinic are currently not supported.') raise ParamIssue if argument is None and not optional: debug.warning('TypeError: %s expected at least %s arguments, got %s', name, len(clinic_args), i) raise ParamIssue value_set = NO_VALUES if argument is None else argument.infer() if not value_set and not optional: # For the stdlib we always want values. If we don't get them, # that's ok, maybe something is too hard to resolve, however, # we will not proceed with the type inference of that function. debug.warning('argument_clinic "%s" not resolvable.', name) raise ParamIssue yield value_set def _parse_argument_clinic(string): allow_kwargs = False optional = False while string: # Optional arguments have to begin with a bracket. And should always be # at the end of the arguments. This is therefore not a proper argument # clinic implementation. `range()` for exmple allows an optional start # value at the beginning. match = re.match(r'(?:(?:(\[),? ?|, ?|)(\**\w+)|, ?/)\]*', string) string = string[len(match.group(0)):] if not match.group(2): # A slash -> allow named arguments allow_kwargs = True continue optional = optional or bool(match.group(1)) word = match.group(2) stars = word.count('*') word = word[stars:] yield (word, optional, allow_kwargs, stars) if stars: allow_kwargs = True class _AbstractArgumentsMixin: def unpack(self, funcdef=None): raise NotImplementedError def get_calling_nodes(self): return [] class AbstractArguments(_AbstractArgumentsMixin): context = None argument_node = None trailer = None def unpack_arglist(arglist): if arglist is None: return if arglist.type != 'arglist' and not ( arglist.type == 'argument' and arglist.children[0] in ('*', '**')): yield 0, arglist return iterator = iter(arglist.children) for child in iterator: if child == ',': continue elif child in ('*', '**'): c = next(iterator, None) assert c is not None yield len(child.value), c elif child.type == 'argument' and \ child.children[0] in ('*', '**'): assert len(child.children) == 2 yield len(child.children[0].value), child.children[1] else: yield 0, child class TreeArguments(AbstractArguments): def __init__(self, inference_state, context, argument_node, trailer=None): """ :param argument_node: May be an argument_node or a list of nodes. """ self.argument_node = argument_node self.context = context self._inference_state = inference_state self.trailer = trailer # Can be None, e.g. in a class definition. @classmethod @inference_state_as_method_param_cache() def create_cached(cls, *args, **kwargs): return cls(*args, **kwargs) def unpack(self, funcdef=None): named_args = [] for star_count, el in unpack_arglist(self.argument_node): if star_count == 1: arrays = self.context.infer_node(el) iterators = [_iterate_star_args(self.context, a, el, funcdef) for a in arrays] for values in list(zip_longest(*iterators)): yield None, get_merged_lazy_value( [v for v in values if v is not None] ) elif star_count == 2: arrays = self.context.infer_node(el) for dct in arrays: yield from _star_star_dict(self.context, dct, el, funcdef) else: if el.type == 'argument': c = el.children if len(c) == 3: # Keyword argument. named_args.append((c[0].value, LazyTreeValue(self.context, c[2]),)) else: # Generator comprehension. # Include the brackets with the parent. sync_comp_for = el.children[1] if sync_comp_for.type == 'comp_for': sync_comp_for = sync_comp_for.children[1] comp = iterable.GeneratorComprehension( self._inference_state, defining_context=self.context, sync_comp_for_node=sync_comp_for, entry_node=el.children[0], ) yield None, LazyKnownValue(comp) else: yield None, LazyTreeValue(self.context, el) # Reordering arguments is necessary, because star args sometimes appear # after named argument, but in the actual order it's prepended. yield from named_args def _as_tree_tuple_objects(self): for star_count, argument in unpack_arglist(self.argument_node): default = None if argument.type == 'argument': if len(argument.children) == 3: # Keyword argument. argument, default = argument.children[::2] yield argument, default, star_count def iter_calling_names_with_star(self): for name, default, star_count in self._as_tree_tuple_objects(): # TODO this function is a bit strange. probably refactor? if not star_count or not isinstance(name, tree.Name): continue yield TreeNameDefinition(self.context, name) def __repr__(self): return '<%s: %s>' % (self.__class__.__name__, self.argument_node) def get_calling_nodes(self): old_arguments_list = [] arguments = self while arguments not in old_arguments_list: if not isinstance(arguments, TreeArguments): break old_arguments_list.append(arguments) for calling_name in reversed(list(arguments.iter_calling_names_with_star())): names = calling_name.goto() if len(names) != 1: break if isinstance(names[0], AnonymousParamName): # Dynamic parameters should not have calling nodes, because # they are dynamic and extremely random. return [] if not isinstance(names[0], ParamName): break executed_param_name = names[0].get_executed_param_name() arguments = executed_param_name.arguments break if arguments.argument_node is not None: return [ContextualizedNode(arguments.context, arguments.argument_node)] if arguments.trailer is not None: return [ContextualizedNode(arguments.context, arguments.trailer)] return [] class ValuesArguments(AbstractArguments): def __init__(self, values_list): self._values_list = values_list def unpack(self, funcdef=None): for values in self._values_list: yield None, LazyKnownValues(values) def __repr__(self): return '<%s: %s>' % (self.__class__.__name__, self._values_list) class TreeArgumentsWrapper(_AbstractArgumentsMixin): def __init__(self, arguments): self._wrapped_arguments = arguments @property def context(self): return self._wrapped_arguments.context @property def argument_node(self): return self._wrapped_arguments.argument_node @property def trailer(self): return self._wrapped_arguments.trailer def unpack(self, func=None): raise NotImplementedError def get_calling_nodes(self): return self._wrapped_arguments.get_calling_nodes() def __repr__(self): return '<%s: %s>' % (self.__class__.__name__, self._wrapped_arguments) def _iterate_star_args(context, array, input_node, funcdef=None): if not array.py__getattribute__('__iter__'): if funcdef is not None: # TODO this funcdef should not be needed. m = "TypeError: %s() argument after * must be a sequence, not %s" \ % (funcdef.name.value, array) analysis.add(context, 'type-error-star', input_node, message=m) try: iter_ = array.py__iter__ except AttributeError: pass else: yield from iter_() def _star_star_dict(context, array, input_node, funcdef): from jedi.inference.value.instance import CompiledInstance if isinstance(array, CompiledInstance) and array.name.string_name == 'dict': # For now ignore this case. In the future add proper iterators and just # make one call without crazy isinstance checks. return {} elif isinstance(array, iterable.Sequence) and array.array_type == 'dict': return array.exact_key_items() else: if funcdef is not None: m = "TypeError: %s argument after ** must be a mapping, not %s" \ % (funcdef.name.value, array) analysis.add(context, 'type-error-star-star', input_node, message=m) return {} ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/jedi/inference/base_value.py0000664000175000017500000004345300000000000017742 0ustar00davedave00000000000000""" Values are the "values" that Python would return. However Values are at the same time also the "values" that a user is currently sitting in. A ValueSet is typically used to specify the return of a function or any other static analysis operation. In jedi there are always multiple returns and not just one. """ from functools import reduce from operator import add from itertools import zip_longest from parso.python.tree import Name from jedi import debug from jedi.parser_utils import clean_scope_docstring from jedi.inference.helpers import SimpleGetItemNotFound from jedi.inference.utils import safe_property from jedi.inference.cache import inference_state_as_method_param_cache from jedi.cache import memoize_method sentinel = object() class HasNoContext(Exception): pass class HelperValueMixin: def get_root_context(self): value = self if value.parent_context is None: return value.as_context() while True: if value.parent_context is None: return value value = value.parent_context def execute(self, arguments): return self.inference_state.execute(self, arguments=arguments) def execute_with_values(self, *value_list): from jedi.inference.arguments import ValuesArguments arguments = ValuesArguments([ValueSet([value]) for value in value_list]) return self.inference_state.execute(self, arguments) def execute_annotation(self): return self.execute_with_values() def gather_annotation_classes(self): return ValueSet([self]) def merge_types_of_iterate(self, contextualized_node=None, is_async=False): return ValueSet.from_sets( lazy_value.infer() for lazy_value in self.iterate(contextualized_node, is_async) ) def _get_value_filters(self, name_or_str): origin_scope = name_or_str if isinstance(name_or_str, Name) else None yield from self.get_filters(origin_scope=origin_scope) # This covers the case where a stub files are incomplete. if self.is_stub(): from jedi.inference.gradual.conversion import convert_values for c in convert_values(ValueSet({self})): yield from c.get_filters() def goto(self, name_or_str, name_context=None, analysis_errors=True): from jedi.inference import finder filters = self._get_value_filters(name_or_str) names = finder.filter_name(filters, name_or_str) debug.dbg('context.goto %s in (%s): %s', name_or_str, self, names) return names def py__getattribute__(self, name_or_str, name_context=None, position=None, analysis_errors=True): """ :param position: Position of the last statement -> tuple of line, column """ if name_context is None: name_context = self names = self.goto(name_or_str, name_context, analysis_errors) values = ValueSet.from_sets(name.infer() for name in names) if not values: n = name_or_str.value if isinstance(name_or_str, Name) else name_or_str values = self.py__getattribute__alternatives(n) if not names and not values and analysis_errors: if isinstance(name_or_str, Name): from jedi.inference import analysis analysis.add_attribute_error( name_context, self, name_or_str) debug.dbg('context.names_to_types: %s -> %s', names, values) return values def py__await__(self): await_value_set = self.py__getattribute__("__await__") if not await_value_set: debug.warning('Tried to run __await__ on value %s', self) return await_value_set.execute_with_values() def py__name__(self): return self.name.string_name def iterate(self, contextualized_node=None, is_async=False): debug.dbg('iterate %s', self) if is_async: from jedi.inference.lazy_value import LazyKnownValues # TODO if no __aiter__ values are there, error should be: # TypeError: 'async for' requires an object with __aiter__ method, got int return iter([ LazyKnownValues( self.py__getattribute__('__aiter__').execute_with_values() .py__getattribute__('__anext__').execute_with_values() .py__getattribute__('__await__').execute_with_values() .py__stop_iteration_returns() ) # noqa: E124 ]) return self.py__iter__(contextualized_node) def is_sub_class_of(self, class_value): with debug.increase_indent_cm('subclass matching of %s <=> %s' % (self, class_value), color='BLUE'): for cls in self.py__mro__(): if cls.is_same_class(class_value): debug.dbg('matched subclass True', color='BLUE') return True debug.dbg('matched subclass False', color='BLUE') return False def is_same_class(self, class2): # Class matching should prefer comparisons that are not this function. if type(class2).is_same_class != HelperValueMixin.is_same_class: return class2.is_same_class(self) return self == class2 @memoize_method def as_context(self, *args, **kwargs): return self._as_context(*args, **kwargs) class Value(HelperValueMixin): """ To be implemented by subclasses. """ tree_node = None # Possible values: None, tuple, list, dict and set. Here to deal with these # very important containers. array_type = None api_type = 'not_defined_please_report_bug' def __init__(self, inference_state, parent_context=None): self.inference_state = inference_state self.parent_context = parent_context def py__getitem__(self, index_value_set, contextualized_node): from jedi.inference import analysis # TODO this value is probably not right. analysis.add( contextualized_node.context, 'type-error-not-subscriptable', contextualized_node.node, message="TypeError: '%s' object is not subscriptable" % self ) return NO_VALUES def py__simple_getitem__(self, index): raise SimpleGetItemNotFound def py__iter__(self, contextualized_node=None): if contextualized_node is not None: from jedi.inference import analysis analysis.add( contextualized_node.context, 'type-error-not-iterable', contextualized_node.node, message="TypeError: '%s' object is not iterable" % self) return iter([]) def py__next__(self, contextualized_node=None): return self.py__iter__(contextualized_node) def get_signatures(self): return [] def is_class(self): return False def is_class_mixin(self): return False def is_instance(self): return False def is_function(self): return False def is_module(self): return False def is_namespace(self): return False def is_compiled(self): return False def is_bound_method(self): return False def is_builtins_module(self): return False def py__bool__(self): """ Since Wrapper is a super class for classes, functions and modules, the return value will always be true. """ return True def py__doc__(self): try: self.tree_node.get_doc_node except AttributeError: return '' else: return clean_scope_docstring(self.tree_node) def get_safe_value(self, default=sentinel): if default is sentinel: raise ValueError("There exists no safe value for value %s" % self) return default def execute_operation(self, other, operator): debug.warning("%s not possible between %s and %s", operator, self, other) return NO_VALUES def py__call__(self, arguments): debug.warning("no execution possible %s", self) return NO_VALUES def py__stop_iteration_returns(self): debug.warning("Not possible to return the stop iterations of %s", self) return NO_VALUES def py__getattribute__alternatives(self, name_or_str): """ For now a way to add values in cases like __getattr__. """ return NO_VALUES def py__get__(self, instance, class_value): debug.warning("No __get__ defined on %s", self) return ValueSet([self]) def py__get__on_class(self, calling_instance, instance, class_value): return NotImplemented def get_qualified_names(self): # Returns Optional[Tuple[str, ...]] return None def is_stub(self): # The root value knows if it's a stub or not. return self.parent_context.is_stub() def _as_context(self): raise HasNoContext @property def name(self): raise NotImplementedError def get_type_hint(self, add_class_info=True): return None def infer_type_vars(self, value_set): """ When the current instance represents a type annotation, this method tries to find information about undefined type vars and returns a dict from type var name to value set. This is for example important to understand what `iter([1])` returns. According to typeshed, `iter` returns an `Iterator[_T]`: def iter(iterable: Iterable[_T]) -> Iterator[_T]: ... This functions would generate `int` for `_T` in this case, because it unpacks the `Iterable`. Parameters ---------- `self`: represents the annotation of the current parameter to infer the value for. In the above example, this would initially be the `Iterable[_T]` of the `iterable` parameter and then, when recursing, just the `_T` generic parameter. `value_set`: represents the actual argument passed to the parameter we're inferred for, or (for recursive calls) their types. In the above example this would first be the representation of the list `[1]` and then, when recursing, just of `1`. """ return {} def iterate_values(values, contextualized_node=None, is_async=False): """ Calls `iterate`, on all values but ignores the ordering and just returns all values that the iterate functions yield. """ return ValueSet.from_sets( lazy_value.infer() for lazy_value in values.iterate(contextualized_node, is_async=is_async) ) class _ValueWrapperBase(HelperValueMixin): @safe_property def name(self): from jedi.inference.names import ValueName wrapped_name = self._wrapped_value.name if wrapped_name.tree_name is not None: return ValueName(self, wrapped_name.tree_name) else: from jedi.inference.compiled import CompiledValueName return CompiledValueName(self, wrapped_name.string_name) @classmethod @inference_state_as_method_param_cache() def create_cached(cls, inference_state, *args, **kwargs): return cls(*args, **kwargs) def __getattr__(self, name): assert name != '_wrapped_value', 'Problem with _get_wrapped_value' return getattr(self._wrapped_value, name) class LazyValueWrapper(_ValueWrapperBase): @safe_property @memoize_method def _wrapped_value(self): with debug.increase_indent_cm('Resolve lazy value wrapper'): return self._get_wrapped_value() def __repr__(self): return '<%s>' % (self.__class__.__name__) def _get_wrapped_value(self): raise NotImplementedError class ValueWrapper(_ValueWrapperBase): def __init__(self, wrapped_value): self._wrapped_value = wrapped_value def __repr__(self): return '%s(%s)' % (self.__class__.__name__, self._wrapped_value) class TreeValue(Value): def __init__(self, inference_state, parent_context, tree_node): super().__init__(inference_state, parent_context) self.tree_node = tree_node def __repr__(self): return '<%s: %s>' % (self.__class__.__name__, self.tree_node) class ContextualizedNode: def __init__(self, context, node): self.context = context self.node = node def get_root_context(self): return self.context.get_root_context() def infer(self): return self.context.infer_node(self.node) def __repr__(self): return '<%s: %s in %s>' % (self.__class__.__name__, self.node, self.context) def _getitem(value, index_values, contextualized_node): # The actual getitem call. result = NO_VALUES unused_values = set() for index_value in index_values: index = index_value.get_safe_value(default=None) if type(index) in (float, int, str, slice, bytes): try: result |= value.py__simple_getitem__(index) continue except SimpleGetItemNotFound: pass unused_values.add(index_value) # The index was somehow not good enough or simply a wrong type. # Therefore we now iterate through all the values and just take # all results. if unused_values or not index_values: result |= value.py__getitem__( ValueSet(unused_values), contextualized_node ) debug.dbg('py__getitem__ result: %s', result) return result class ValueSet: def __init__(self, iterable): self._set = frozenset(iterable) for value in iterable: assert not isinstance(value, ValueSet) @classmethod def _from_frozen_set(cls, frozenset_): self = cls.__new__(cls) self._set = frozenset_ return self @classmethod def from_sets(cls, sets): """ Used to work with an iterable of set. """ aggregated = set() for set_ in sets: if isinstance(set_, ValueSet): aggregated |= set_._set else: aggregated |= frozenset(set_) return cls._from_frozen_set(frozenset(aggregated)) def __or__(self, other): return self._from_frozen_set(self._set | other._set) def __and__(self, other): return self._from_frozen_set(self._set & other._set) def __iter__(self): return iter(self._set) def __bool__(self): return bool(self._set) def __len__(self): return len(self._set) def __repr__(self): return 'S{%s}' % (', '.join(str(s) for s in self._set)) def filter(self, filter_func): return self.__class__(filter(filter_func, self._set)) def __getattr__(self, name): def mapper(*args, **kwargs): return self.from_sets( getattr(value, name)(*args, **kwargs) for value in self._set ) return mapper def __eq__(self, other): return self._set == other._set def __ne__(self, other): return not self.__eq__(other) def __hash__(self): return hash(self._set) def py__class__(self): return ValueSet(c.py__class__() for c in self._set) def iterate(self, contextualized_node=None, is_async=False): from jedi.inference.lazy_value import get_merged_lazy_value type_iters = [c.iterate(contextualized_node, is_async=is_async) for c in self._set] for lazy_values in zip_longest(*type_iters): yield get_merged_lazy_value( [l for l in lazy_values if l is not None] ) def execute(self, arguments): return ValueSet.from_sets(c.inference_state.execute(c, arguments) for c in self._set) def execute_with_values(self, *args, **kwargs): return ValueSet.from_sets(c.execute_with_values(*args, **kwargs) for c in self._set) def goto(self, *args, **kwargs): return reduce(add, [c.goto(*args, **kwargs) for c in self._set], []) def py__getattribute__(self, *args, **kwargs): return ValueSet.from_sets(c.py__getattribute__(*args, **kwargs) for c in self._set) def get_item(self, *args, **kwargs): return ValueSet.from_sets(_getitem(c, *args, **kwargs) for c in self._set) def try_merge(self, function_name): value_set = self.__class__([]) for c in self._set: try: method = getattr(c, function_name) except AttributeError: pass else: value_set |= method() return value_set def gather_annotation_classes(self): return ValueSet.from_sets([c.gather_annotation_classes() for c in self._set]) def get_signatures(self): return [sig for c in self._set for sig in c.get_signatures()] def get_type_hint(self, add_class_info=True): t = [v.get_type_hint(add_class_info=add_class_info) for v in self._set] type_hints = sorted(filter(None, t)) if len(type_hints) == 1: return type_hints[0] optional = 'None' in type_hints if optional: type_hints.remove('None') if len(type_hints) == 0: return None elif len(type_hints) == 1: s = type_hints[0] else: s = 'Union[%s]' % ', '.join(type_hints) if optional: s = 'Optional[%s]' % s return s def infer_type_vars(self, value_set): # Circular from jedi.inference.gradual.annotation import merge_type_var_dicts type_var_dict = {} for value in self._set: merge_type_var_dicts( type_var_dict, value.infer_type_vars(value_set), ) return type_var_dict NO_VALUES = ValueSet([]) def iterator_to_value_set(func): def wrapper(*args, **kwargs): return ValueSet(func(*args, **kwargs)) return wrapper ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/jedi/inference/cache.py0000664000175000017500000001013700000000000016670 0ustar00davedave00000000000000""" - the popular ``_memoize_default`` works like a typical memoize and returns the default otherwise. - ``CachedMetaClass`` uses ``_memoize_default`` to do the same with classes. """ from functools import wraps from jedi import debug _NO_DEFAULT = object() _RECURSION_SENTINEL = object() def _memoize_default(default=_NO_DEFAULT, inference_state_is_first_arg=False, second_arg_is_inference_state=False): """ This is a typical memoization decorator, BUT there is one difference: To prevent recursion it sets defaults. Preventing recursion is in this case the much bigger use than speed. I don't think, that there is a big speed difference, but there are many cases where recursion could happen (think about a = b; b = a). """ def func(function): def wrapper(obj, *args, **kwargs): # TODO These checks are kind of ugly and slow. if inference_state_is_first_arg: cache = obj.memoize_cache elif second_arg_is_inference_state: cache = args[0].memoize_cache # needed for meta classes else: cache = obj.inference_state.memoize_cache try: memo = cache[function] except KeyError: cache[function] = memo = {} key = (obj, args, frozenset(kwargs.items())) if key in memo: return memo[key] else: if default is not _NO_DEFAULT: memo[key] = default rv = function(obj, *args, **kwargs) memo[key] = rv return rv return wrapper return func def inference_state_function_cache(default=_NO_DEFAULT): def decorator(func): return _memoize_default(default=default, inference_state_is_first_arg=True)(func) return decorator def inference_state_method_cache(default=_NO_DEFAULT): def decorator(func): return _memoize_default(default=default)(func) return decorator def inference_state_as_method_param_cache(): def decorator(call): return _memoize_default(second_arg_is_inference_state=True)(call) return decorator class CachedMetaClass(type): """ This is basically almost the same than the decorator above, it just caches class initializations. Either you do it this way or with decorators, but with decorators you lose class access (isinstance, etc). """ @inference_state_as_method_param_cache() def __call__(self, *args, **kwargs): return super().__call__(*args, **kwargs) def inference_state_method_generator_cache(): """ This is a special memoizer. It memoizes generators and also checks for recursion errors and returns no further iterator elemends in that case. """ def func(function): @wraps(function) def wrapper(obj, *args, **kwargs): cache = obj.inference_state.memoize_cache try: memo = cache[function] except KeyError: cache[function] = memo = {} key = (obj, args, frozenset(kwargs.items())) if key in memo: actual_generator, cached_lst = memo[key] else: actual_generator = function(obj, *args, **kwargs) cached_lst = [] memo[key] = actual_generator, cached_lst i = 0 while True: try: next_element = cached_lst[i] if next_element is _RECURSION_SENTINEL: debug.warning('Found a generator recursion for %s' % obj) # This means we have hit a recursion. return except IndexError: cached_lst.append(_RECURSION_SENTINEL) next_element = next(actual_generator, None) if next_element is None: cached_lst.pop() return cached_lst[-1] = next_element yield next_element i += 1 return wrapper return func ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.3903792 jedi-0.19.1/jedi/inference/compiled/0000775000175000017500000000000000000000000017045 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/jedi/inference/compiled/__init__.py0000664000175000017500000000513300000000000021160 0ustar00davedave00000000000000# This file also re-exports symbols for wider use. We configure mypy and flake8 # to be aware that this file does this. from jedi.inference.compiled.value import CompiledValue, CompiledName, \ CompiledValueFilter, CompiledValueName, create_from_access_path from jedi.inference.base_value import LazyValueWrapper def builtin_from_name(inference_state, string): typing_builtins_module = inference_state.builtins_module if string in ('None', 'True', 'False'): builtins, = typing_builtins_module.non_stub_value_set filter_ = next(builtins.get_filters()) else: filter_ = next(typing_builtins_module.get_filters()) name, = filter_.get(string) value, = name.infer() return value class ExactValue(LazyValueWrapper): """ This class represents exact values, that makes operations like additions and exact boolean values possible, while still being a "normal" stub. """ def __init__(self, compiled_value): self.inference_state = compiled_value.inference_state self._compiled_value = compiled_value def __getattribute__(self, name): if name in ('get_safe_value', 'execute_operation', 'access_handle', 'negate', 'py__bool__', 'is_compiled'): return getattr(self._compiled_value, name) return super().__getattribute__(name) def _get_wrapped_value(self): instance, = builtin_from_name( self.inference_state, self._compiled_value.name.string_name).execute_with_values() return instance def __repr__(self): return '<%s: %s>' % (self.__class__.__name__, self._compiled_value) def create_simple_object(inference_state, obj): """ Only allows creations of objects that are easily picklable across Python versions. """ assert type(obj) in (int, float, str, bytes, slice, complex, bool), repr(obj) compiled_value = create_from_access_path( inference_state, inference_state.compiled_subprocess.create_simple_object(obj) ) return ExactValue(compiled_value) def get_string_value_set(inference_state): return builtin_from_name(inference_state, 'str').execute_with_values() def load_module(inference_state, dotted_name, **kwargs): # Temporary, some tensorflow builtins cannot be loaded, so it's tried again # and again and it's really slow. if dotted_name.startswith('tensorflow.'): return None access_path = inference_state.compiled_subprocess.load_module(dotted_name=dotted_name, **kwargs) if access_path is None: return None return create_from_access_path(inference_state, access_path) ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/jedi/inference/compiled/access.py0000664000175000017500000004474200000000000020673 0ustar00davedave00000000000000import inspect import types import traceback import sys import operator as op from collections import namedtuple import warnings import re import builtins import typing from pathlib import Path from typing import Optional, Tuple from jedi.inference.compiled.getattr_static import getattr_static ALLOWED_GETITEM_TYPES = (str, list, tuple, bytes, bytearray, dict) MethodDescriptorType = type(str.replace) # These are not considered classes and access is granted even though they have # a __class__ attribute. NOT_CLASS_TYPES = ( types.BuiltinFunctionType, types.CodeType, types.FrameType, types.FunctionType, types.GeneratorType, types.GetSetDescriptorType, types.LambdaType, types.MemberDescriptorType, types.MethodType, types.ModuleType, types.TracebackType, MethodDescriptorType, types.MappingProxyType, types.SimpleNamespace, types.DynamicClassAttribute, ) # Those types don't exist in typing. MethodDescriptorType = type(str.replace) WrapperDescriptorType = type(set.__iter__) # `object.__subclasshook__` is an already executed descriptor. object_class_dict = type.__dict__["__dict__"].__get__(object) # type: ignore[index] ClassMethodDescriptorType = type(object_class_dict['__subclasshook__']) _sentinel = object() # Maps Python syntax to the operator module. COMPARISON_OPERATORS = { '==': op.eq, '!=': op.ne, 'is': op.is_, 'is not': op.is_not, '<': op.lt, '<=': op.le, '>': op.gt, '>=': op.ge, } _OPERATORS = { '+': op.add, '-': op.sub, } _OPERATORS.update(COMPARISON_OPERATORS) ALLOWED_DESCRIPTOR_ACCESS = ( types.FunctionType, types.GetSetDescriptorType, types.MemberDescriptorType, MethodDescriptorType, WrapperDescriptorType, ClassMethodDescriptorType, staticmethod, classmethod, ) def safe_getattr(obj, name, default=_sentinel): try: attr, is_get_descriptor = getattr_static(obj, name) except AttributeError: if default is _sentinel: raise return default else: if isinstance(attr, ALLOWED_DESCRIPTOR_ACCESS): # In case of descriptors that have get methods we cannot return # it's value, because that would mean code execution. # Since it's an isinstance call, code execution is still possible, # but this is not really a security feature, but much more of a # safety feature. Code execution is basically always possible when # a module is imported. This is here so people don't shoot # themselves in the foot. return getattr(obj, name) return attr SignatureParam = namedtuple( 'SignatureParam', 'name has_default default default_string has_annotation annotation annotation_string kind_name' ) def shorten_repr(func): def wrapper(self): r = func(self) if len(r) > 50: r = r[:50] + '..' return r return wrapper def create_access(inference_state, obj): return inference_state.compiled_subprocess.get_or_create_access_handle(obj) def load_module(inference_state, dotted_name, sys_path): temp, sys.path = sys.path, sys_path try: __import__(dotted_name) except ImportError: # If a module is "corrupt" or not really a Python module or whatever. warnings.warn( "Module %s not importable in path %s." % (dotted_name, sys_path), UserWarning, stacklevel=2, ) return None except Exception: # Since __import__ pretty much makes code execution possible, just # catch any error here and print it. warnings.warn( "Cannot import:\n%s" % traceback.format_exc(), UserWarning, stacklevel=2 ) return None finally: sys.path = temp # Just access the cache after import, because of #59 as well as the very # complicated import structure of Python. module = sys.modules[dotted_name] return create_access_path(inference_state, module) class AccessPath: def __init__(self, accesses): self.accesses = accesses def create_access_path(inference_state, obj) -> AccessPath: access = create_access(inference_state, obj) return AccessPath(access.get_access_path_tuples()) def get_api_type(obj): if inspect.isclass(obj): return 'class' elif inspect.ismodule(obj): return 'module' elif inspect.isbuiltin(obj) or inspect.ismethod(obj) \ or inspect.ismethoddescriptor(obj) or inspect.isfunction(obj): return 'function' # Everything else... return 'instance' class DirectObjectAccess: def __init__(self, inference_state, obj): self._inference_state = inference_state self._obj = obj def __repr__(self): return '%s(%s)' % (self.__class__.__name__, self.get_repr()) def _create_access(self, obj): return create_access(self._inference_state, obj) def _create_access_path(self, obj) -> AccessPath: return create_access_path(self._inference_state, obj) def py__bool__(self): return bool(self._obj) def py__file__(self) -> Optional[Path]: try: return Path(self._obj.__file__) except AttributeError: return None def py__doc__(self): return inspect.getdoc(self._obj) or '' def py__name__(self): if not _is_class_instance(self._obj) or \ inspect.ismethoddescriptor(self._obj): # slots cls = self._obj else: try: cls = self._obj.__class__ except AttributeError: # happens with numpy.core.umath._UFUNC_API (you get it # automatically by doing `import numpy`. return None try: return cls.__name__ except AttributeError: return None def py__mro__accesses(self): return tuple(self._create_access_path(cls) for cls in self._obj.__mro__[1:]) def py__getitem__all_values(self): if isinstance(self._obj, dict): return [self._create_access_path(v) for v in self._obj.values()] if isinstance(self._obj, (list, tuple)): return [self._create_access_path(v) for v in self._obj] if self.is_instance(): cls = DirectObjectAccess(self._inference_state, self._obj.__class__) return cls.py__getitem__all_values() try: getitem = self._obj.__getitem__ except AttributeError: pass else: annotation = DirectObjectAccess(self._inference_state, getitem).get_return_annotation() if annotation is not None: return [annotation] return None def py__simple_getitem__(self, index, *, safe=True): if safe and type(self._obj) not in ALLOWED_GETITEM_TYPES: # Get rid of side effects, we won't call custom `__getitem__`s. return None return self._create_access_path(self._obj[index]) def py__iter__list(self): try: iter_method = self._obj.__iter__ except AttributeError: return None else: p = DirectObjectAccess(self._inference_state, iter_method).get_return_annotation() if p is not None: return [p] if type(self._obj) not in ALLOWED_GETITEM_TYPES: # Get rid of side effects, we won't call custom `__getitem__`s. return [] lst = [] for i, part in enumerate(self._obj): if i > 20: # Should not go crazy with large iterators break lst.append(self._create_access_path(part)) return lst def py__class__(self): return self._create_access_path(self._obj.__class__) def py__bases__(self): return [self._create_access_path(base) for base in self._obj.__bases__] def py__path__(self): paths = getattr(self._obj, '__path__', None) # Avoid some weird hacks that would just fail, because they cannot be # used by pickle. if not isinstance(paths, list) \ or not all(isinstance(p, str) for p in paths): return None return paths @shorten_repr def get_repr(self): if inspect.ismodule(self._obj): return repr(self._obj) # Try to avoid execution of the property. if safe_getattr(self._obj, '__module__', default='') == 'builtins': return repr(self._obj) type_ = type(self._obj) if type_ == type: return type.__repr__(self._obj) if safe_getattr(type_, '__module__', default='') == 'builtins': # Allow direct execution of repr for builtins. return repr(self._obj) return object.__repr__(self._obj) def is_class(self): return inspect.isclass(self._obj) def is_function(self): return inspect.isfunction(self._obj) or inspect.ismethod(self._obj) def is_module(self): return inspect.ismodule(self._obj) def is_instance(self): return _is_class_instance(self._obj) def ismethoddescriptor(self): return inspect.ismethoddescriptor(self._obj) def get_qualified_names(self): def try_to_get_name(obj): return getattr(obj, '__qualname__', getattr(obj, '__name__', None)) if self.is_module(): return () name = try_to_get_name(self._obj) if name is None: name = try_to_get_name(type(self._obj)) if name is None: return () return tuple(name.split('.')) def dir(self): return dir(self._obj) def has_iter(self): try: iter(self._obj) return True except TypeError: return False def is_allowed_getattr(self, name, safe=True) -> Tuple[bool, bool, Optional[AccessPath]]: # TODO this API is ugly. try: attr, is_get_descriptor = getattr_static(self._obj, name) except AttributeError: if not safe: # Unsafe is mostly used to check for __getattr__/__getattribute__. # getattr_static works for properties, but the underscore methods # are just ignored (because it's safer and avoids more code # execution). See also GH #1378. # Avoid warnings, see comment in the next function. with warnings.catch_warnings(record=True): warnings.simplefilter("always") try: return hasattr(self._obj, name), False, None except Exception: # Obviously has an attribute (probably a property) that # gets executed, so just avoid all exceptions here. pass return False, False, None else: if is_get_descriptor and type(attr) not in ALLOWED_DESCRIPTOR_ACCESS: if isinstance(attr, property): if hasattr(attr.fget, '__annotations__'): a = DirectObjectAccess(self._inference_state, attr.fget) return True, True, a.get_return_annotation() # In case of descriptors that have get methods we cannot return # it's value, because that would mean code execution. return True, True, None return True, False, None def getattr_paths(self, name, default=_sentinel): try: # Make sure no warnings are printed here, this is autocompletion, # warnings should not be shown. See also GH #1383. with warnings.catch_warnings(record=True): warnings.simplefilter("always") return_obj = getattr(self._obj, name) except Exception as e: if default is _sentinel: if isinstance(e, AttributeError): # Happens e.g. in properties of # PyQt4.QtGui.QStyleOptionComboBox.currentText # -> just set it to None raise # Just in case anything happens, return an AttributeError. It # should not crash. raise AttributeError return_obj = default access = self._create_access(return_obj) if inspect.ismodule(return_obj): return [access] try: module = return_obj.__module__ except AttributeError: pass else: if module is not None and isinstance(module, str): try: __import__(module) # For some modules like _sqlite3, the __module__ for classes is # different, in this case it's sqlite3. So we have to try to # load that "original" module, because it's not loaded yet. If # we don't do that, we don't really have a "parent" module and # we would fall back to builtins. except ImportError: pass module = inspect.getmodule(return_obj) if module is None: module = inspect.getmodule(type(return_obj)) if module is None: module = builtins return [self._create_access(module), access] def get_safe_value(self): if type(self._obj) in (bool, bytes, float, int, str, slice) or self._obj is None: return self._obj raise ValueError("Object is type %s and not simple" % type(self._obj)) def get_api_type(self): return get_api_type(self._obj) def get_array_type(self): if isinstance(self._obj, dict): return 'dict' return None def get_key_paths(self): def iter_partial_keys(): # We could use list(keys()), but that might take a lot more memory. for (i, k) in enumerate(self._obj.keys()): # Limit key listing at some point. This is artificial, but this # way we don't get stalled because of slow completions if i > 50: break yield k return [self._create_access_path(k) for k in iter_partial_keys()] def get_access_path_tuples(self): accesses = [create_access(self._inference_state, o) for o in self._get_objects_path()] return [(access.py__name__(), access) for access in accesses] def _get_objects_path(self): def get(): obj = self._obj yield obj try: obj = obj.__objclass__ except AttributeError: pass else: yield obj try: # Returns a dotted string path. imp_plz = obj.__module__ except AttributeError: # Unfortunately in some cases like `int` there's no __module__ if not inspect.ismodule(obj): yield builtins else: if imp_plz is None: # Happens for example in `(_ for _ in []).send.__module__`. yield builtins else: try: yield sys.modules[imp_plz] except KeyError: # __module__ can be something arbitrary that doesn't exist. yield builtins return list(reversed(list(get()))) def execute_operation(self, other_access_handle, operator): other_access = other_access_handle.access op = _OPERATORS[operator] return self._create_access_path(op(self._obj, other_access._obj)) def get_annotation_name_and_args(self): """ Returns Tuple[Optional[str], Tuple[AccessPath, ...]] """ name = None args = () if safe_getattr(self._obj, '__module__', default='') == 'typing': m = re.match(r'typing.(\w+)\[', repr(self._obj)) if m is not None: name = m.group(1) import typing if sys.version_info >= (3, 8): args = typing.get_args(self._obj) else: args = safe_getattr(self._obj, '__args__', default=None) return name, tuple(self._create_access_path(arg) for arg in args) def needs_type_completions(self): return inspect.isclass(self._obj) and self._obj != type def _annotation_to_str(self, annotation): return inspect.formatannotation(annotation) def get_signature_params(self): return [ SignatureParam( name=p.name, has_default=p.default is not p.empty, default=self._create_access_path(p.default), default_string=repr(p.default), has_annotation=p.annotation is not p.empty, annotation=self._create_access_path(p.annotation), annotation_string=self._annotation_to_str(p.annotation), kind_name=str(p.kind) ) for p in self._get_signature().parameters.values() ] def _get_signature(self): obj = self._obj try: return inspect.signature(obj) except (RuntimeError, TypeError): # Reading the code of the function in Python 3.6 implies there are # at least these errors that might occur if something is wrong with # the signature. In that case we just want a simple escape for now. raise ValueError def get_return_annotation(self) -> Optional[AccessPath]: try: o = self._obj.__annotations__.get('return') except AttributeError: return None if o is None: return None try: o = typing.get_type_hints(self._obj).get('return') except Exception: pass return self._create_access_path(o) def negate(self): return self._create_access_path(-self._obj) def get_dir_infos(self): """ Used to return a couple of infos that are needed when accessing the sub objects of an objects """ tuples = dict( (name, self.is_allowed_getattr(name)) for name in self.dir() ) return self.needs_type_completions(), tuples def _is_class_instance(obj): """Like inspect.* methods.""" try: cls = obj.__class__ except AttributeError: return False else: # The isinstance check for cls is just there so issubclass doesn't # raise an exception. return cls != type and isinstance(cls, type) and not issubclass(cls, NOT_CLASS_TYPES) ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/jedi/inference/compiled/getattr_static.py0000664000175000017500000000742600000000000022451 0ustar00davedave00000000000000""" A static version of getattr. This is a backport of the Python 3 code with a little bit of additional information returned to enable Jedi to make decisions. """ import types from jedi import debug _sentinel = object() def _check_instance(obj, attr): instance_dict = {} try: instance_dict = object.__getattribute__(obj, "__dict__") except AttributeError: pass return dict.get(instance_dict, attr, _sentinel) def _check_class(klass, attr): for entry in _static_getmro(klass): if _shadowed_dict(type(entry)) is _sentinel: try: return entry.__dict__[attr] except KeyError: pass return _sentinel def _is_type(obj): try: _static_getmro(obj) except TypeError: return False return True def _shadowed_dict(klass): dict_attr = type.__dict__["__dict__"] for entry in _static_getmro(klass): try: class_dict = dict_attr.__get__(entry)["__dict__"] except KeyError: pass else: if not (type(class_dict) is types.GetSetDescriptorType and class_dict.__name__ == "__dict__" and class_dict.__objclass__ is entry): return class_dict return _sentinel def _static_getmro(klass): mro = type.__dict__['__mro__'].__get__(klass) if not isinstance(mro, (tuple, list)): # There are unfortunately no tests for this, I was not able to # reproduce this in pure Python. However should still solve the issue # raised in GH #1517. debug.warning('mro of %s returned %s, should be a tuple' % (klass, mro)) return () return mro def _safe_hasattr(obj, name): return _check_class(type(obj), name) is not _sentinel def _safe_is_data_descriptor(obj): return _safe_hasattr(obj, '__set__') or _safe_hasattr(obj, '__delete__') def getattr_static(obj, attr, default=_sentinel): """Retrieve attributes without triggering dynamic lookup via the descriptor protocol, __getattr__ or __getattribute__. Note: this function may not be able to retrieve all attributes that getattr can fetch (like dynamically created attributes) and may find attributes that getattr can't (like descriptors that raise AttributeError). It can also return descriptor objects instead of instance members in some cases. See the documentation for details. Returns a tuple `(attr, is_get_descriptor)`. is_get_descripter means that the attribute is a descriptor that has a `__get__` attribute. """ instance_result = _sentinel if not _is_type(obj): klass = type(obj) dict_attr = _shadowed_dict(klass) if (dict_attr is _sentinel or type(dict_attr) is types.MemberDescriptorType): instance_result = _check_instance(obj, attr) else: klass = obj klass_result = _check_class(klass, attr) if instance_result is not _sentinel and klass_result is not _sentinel: if _safe_hasattr(klass_result, '__get__') \ and _safe_is_data_descriptor(klass_result): # A get/set descriptor has priority over everything. return klass_result, True if instance_result is not _sentinel: return instance_result, False if klass_result is not _sentinel: return klass_result, _safe_hasattr(klass_result, '__get__') if obj is klass: # for types we check the metaclass too for entry in _static_getmro(type(klass)): if _shadowed_dict(type(entry)) is _sentinel: try: return entry.__dict__[attr], False except KeyError: pass if default is not _sentinel: return default, False raise AttributeError(attr) ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/jedi/inference/compiled/mixed.py0000664000175000017500000002615600000000000020537 0ustar00davedave00000000000000""" Used only for REPL Completion. """ import inspect from pathlib import Path from jedi.parser_utils import get_cached_code_lines from jedi import settings from jedi.cache import memoize_method from jedi.inference import compiled from jedi.file_io import FileIO from jedi.inference.names import NameWrapper from jedi.inference.base_value import ValueSet, ValueWrapper, NO_VALUES from jedi.inference.value import ModuleValue from jedi.inference.cache import inference_state_function_cache, \ inference_state_method_cache from jedi.inference.compiled.access import ALLOWED_GETITEM_TYPES, get_api_type from jedi.inference.gradual.conversion import to_stub from jedi.inference.context import CompiledContext, CompiledModuleContext, \ TreeContextMixin _sentinel = object() class MixedObject(ValueWrapper): """ A ``MixedObject`` is used in two ways: 1. It uses the default logic of ``parser.python.tree`` objects, 2. except for getattr calls and signatures. The names dicts are generated in a fashion like ``CompiledValue``. This combined logic makes it possible to provide more powerful REPL completion. It allows side effects that are not noticable with the default parser structure to still be completable. The biggest difference from CompiledValue to MixedObject is that we are generally dealing with Python code and not with C code. This will generate fewer special cases, because we in Python you don't have the same freedoms to modify the runtime. """ def __init__(self, compiled_value, tree_value): super().__init__(tree_value) self.compiled_value = compiled_value self.access_handle = compiled_value.access_handle def get_filters(self, *args, **kwargs): yield MixedObjectFilter( self.inference_state, self.compiled_value, self._wrapped_value) def get_signatures(self): # Prefer `inspect.signature` over somehow analyzing Python code. It # should be very precise, especially for stuff like `partial`. return self.compiled_value.get_signatures() @inference_state_method_cache(default=NO_VALUES) def py__call__(self, arguments): # Fallback to the wrapped value if to stub returns no values. values = to_stub(self._wrapped_value) if not values: values = self._wrapped_value return values.py__call__(arguments) def get_safe_value(self, default=_sentinel): if default is _sentinel: return self.compiled_value.get_safe_value() else: return self.compiled_value.get_safe_value(default) @property def array_type(self): return self.compiled_value.array_type def get_key_values(self): return self.compiled_value.get_key_values() def py__simple_getitem__(self, index): python_object = self.compiled_value.access_handle.access._obj if type(python_object) in ALLOWED_GETITEM_TYPES: return self.compiled_value.py__simple_getitem__(index) return self._wrapped_value.py__simple_getitem__(index) def negate(self): return self.compiled_value.negate() def _as_context(self): if self.parent_context is None: return MixedModuleContext(self) return MixedContext(self) def __repr__(self): return '<%s: %s; %s>' % ( type(self).__name__, self.access_handle.get_repr(), self._wrapped_value, ) class MixedContext(CompiledContext, TreeContextMixin): @property def compiled_value(self): return self._value.compiled_value class MixedModuleContext(CompiledModuleContext, MixedContext): pass class MixedName(NameWrapper): """ The ``CompiledName._compiled_value`` is our MixedObject. """ def __init__(self, wrapped_name, parent_tree_value): super().__init__(wrapped_name) self._parent_tree_value = parent_tree_value @property def start_pos(self): values = list(self.infer()) if not values: # This means a start_pos that doesn't exist (compiled objects). return 0, 0 return values[0].name.start_pos @memoize_method def infer(self): compiled_value = self._wrapped_name.infer_compiled_value() tree_value = self._parent_tree_value if tree_value.is_instance() or tree_value.is_class(): tree_values = tree_value.py__getattribute__(self.string_name) if compiled_value.is_function(): return ValueSet({MixedObject(compiled_value, v) for v in tree_values}) module_context = tree_value.get_root_context() return _create(self._inference_state, compiled_value, module_context) class MixedObjectFilter(compiled.CompiledValueFilter): def __init__(self, inference_state, compiled_value, tree_value): super().__init__(inference_state, compiled_value) self._tree_value = tree_value def _create_name(self, *args, **kwargs): return MixedName( super()._create_name(*args, **kwargs), self._tree_value, ) @inference_state_function_cache() def _load_module(inference_state, path): return inference_state.parse( path=path, cache=True, diff_cache=settings.fast_parser, cache_path=settings.cache_directory ).get_root_node() def _get_object_to_check(python_object): """Check if inspect.getfile has a chance to find the source.""" try: python_object = inspect.unwrap(python_object) except ValueError: # Can return a ValueError when it wraps around pass if (inspect.ismodule(python_object) or inspect.isclass(python_object) or inspect.ismethod(python_object) or inspect.isfunction(python_object) or inspect.istraceback(python_object) or inspect.isframe(python_object) or inspect.iscode(python_object)): return python_object try: return python_object.__class__ except AttributeError: raise TypeError # Prevents computation of `repr` within inspect. def _find_syntax_node_name(inference_state, python_object): original_object = python_object try: python_object = _get_object_to_check(python_object) path = inspect.getsourcefile(python_object) except (OSError, TypeError): # The type might not be known (e.g. class_with_dict.__weakref__) return None path = None if path is None else Path(path) try: if path is None or not path.exists(): # The path might not exist or be e.g. . return None except OSError: # Might raise an OSError on Windows: # # [WinError 123] The filename, directory name, or volume label # syntax is incorrect: '' return None file_io = FileIO(path) module_node = _load_module(inference_state, path) if inspect.ismodule(python_object): # We don't need to check names for modules, because there's not really # a way to write a module in a module in Python (and also __name__ can # be something like ``email.utils``). code_lines = get_cached_code_lines(inference_state.grammar, path) return module_node, module_node, file_io, code_lines try: name_str = python_object.__name__ except AttributeError: # Stuff like python_function.__code__. return None if name_str == '': return None # It's too hard to find lambdas. # Doesn't always work (e.g. os.stat_result) names = module_node.get_used_names().get(name_str, []) # Only functions and classes are relevant. If a name e.g. points to an # import, it's probably a builtin (like collections.deque) and needs to be # ignored. names = [ n for n in names if n.parent.type in ('funcdef', 'classdef') and n.parent.name == n ] if not names: return None try: code = python_object.__code__ # By using the line number of a code object we make the lookup in a # file pretty easy. There's still a possibility of people defining # stuff like ``a = 3; foo(a); a = 4`` on the same line, but if people # do so we just don't care. line_nr = code.co_firstlineno except AttributeError: pass else: line_names = [name for name in names if name.start_pos[0] == line_nr] # There's a chance that the object is not available anymore, because # the code has changed in the background. if line_names: names = line_names code_lines = get_cached_code_lines(inference_state.grammar, path) # It's really hard to actually get the right definition, here as a last # resort we just return the last one. This chance might lead to odd # completions at some points but will lead to mostly correct type # inference, because people tend to define a public name in a module only # once. tree_node = names[-1].parent if tree_node.type == 'funcdef' and get_api_type(original_object) == 'instance': # If an instance is given and we're landing on a function (e.g. # partial in 3.5), something is completely wrong and we should not # return that. return None return module_node, tree_node, file_io, code_lines @inference_state_function_cache() def _create(inference_state, compiled_value, module_context): # TODO accessing this is bad, but it probably doesn't matter that much, # because we're working with interpreters only here. python_object = compiled_value.access_handle.access._obj result = _find_syntax_node_name(inference_state, python_object) if result is None: # TODO Care about generics from stuff like `[1]` and don't return like this. if type(python_object) in (dict, list, tuple): return ValueSet({compiled_value}) tree_values = to_stub(compiled_value) if not tree_values: return ValueSet({compiled_value}) else: module_node, tree_node, file_io, code_lines = result if module_context is None or module_context.tree_node != module_node: root_compiled_value = compiled_value.get_root_context().get_value() # TODO this __name__ might be wrong. name = root_compiled_value.py__name__() string_names = tuple(name.split('.')) module_value = ModuleValue( inference_state, module_node, file_io=file_io, string_names=string_names, code_lines=code_lines, is_package=root_compiled_value.is_package(), ) if name is not None: inference_state.module_cache.add(string_names, ValueSet([module_value])) module_context = module_value.as_context() tree_values = ValueSet({module_context.create_value(tree_node)}) if tree_node.type == 'classdef': if not compiled_value.is_class(): # Is an instance, not a class. tree_values = tree_values.execute_with_values() return ValueSet( MixedObject(compiled_value, tree_value=tree_value) for tree_value in tree_values ) ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.3903792 jedi-0.19.1/jedi/inference/compiled/subprocess/0000775000175000017500000000000000000000000021235 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/jedi/inference/compiled/subprocess/__init__.py0000664000175000017500000003226200000000000023353 0ustar00davedave00000000000000""" Makes it possible to do the compiled analysis in a subprocess. This has two goals: 1. Making it safer - Segfaults and RuntimeErrors as well as stdout/stderr can be ignored and dealt with. 2. Make it possible to handle different Python versions as well as virtualenvs. """ import collections import os import sys import queue import subprocess import traceback import weakref from functools import partial from threading import Thread from jedi._compatibility import pickle_dump, pickle_load from jedi import debug from jedi.cache import memoize_method from jedi.inference.compiled.subprocess import functions from jedi.inference.compiled.access import DirectObjectAccess, AccessPath, \ SignatureParam from jedi.api.exceptions import InternalError _MAIN_PATH = os.path.join(os.path.dirname(__file__), '__main__.py') PICKLE_PROTOCOL = 4 def _GeneralizedPopen(*args, **kwargs): if os.name == 'nt': try: # Was introduced in Python 3.7. CREATE_NO_WINDOW = subprocess.CREATE_NO_WINDOW except AttributeError: CREATE_NO_WINDOW = 0x08000000 kwargs['creationflags'] = CREATE_NO_WINDOW # The child process doesn't need file descriptors except 0, 1, 2. # This is unix only. kwargs['close_fds'] = 'posix' in sys.builtin_module_names return subprocess.Popen(*args, **kwargs) def _enqueue_output(out, queue_): for line in iter(out.readline, b''): queue_.put(line) def _add_stderr_to_debug(stderr_queue): while True: # Try to do some error reporting from the subprocess and print its # stderr contents. try: line = stderr_queue.get_nowait() line = line.decode('utf-8', 'replace') debug.warning('stderr output: %s' % line.rstrip('\n')) except queue.Empty: break def _get_function(name): return getattr(functions, name) def _cleanup_process(process, thread): try: process.kill() process.wait() except OSError: # Raised if the process is already killed. pass thread.join() for stream in [process.stdin, process.stdout, process.stderr]: try: stream.close() except OSError: # Raised if the stream is broken. pass class _InferenceStateProcess: def __init__(self, inference_state): self._inference_state_weakref = weakref.ref(inference_state) self._inference_state_id = id(inference_state) self._handles = {} def get_or_create_access_handle(self, obj): id_ = id(obj) try: return self.get_access_handle(id_) except KeyError: access = DirectObjectAccess(self._inference_state_weakref(), obj) handle = AccessHandle(self, access, id_) self.set_access_handle(handle) return handle def get_access_handle(self, id_): return self._handles[id_] def set_access_handle(self, handle): self._handles[handle.id] = handle class InferenceStateSameProcess(_InferenceStateProcess): """ Basically just an easy access to functions.py. It has the same API as InferenceStateSubprocess and does the same thing without using a subprocess. This is necessary for the Interpreter process. """ def __getattr__(self, name): return partial(_get_function(name), self._inference_state_weakref()) class InferenceStateSubprocess(_InferenceStateProcess): def __init__(self, inference_state, compiled_subprocess): super().__init__(inference_state) self._used = False self._compiled_subprocess = compiled_subprocess def __getattr__(self, name): func = _get_function(name) def wrapper(*args, **kwargs): self._used = True result = self._compiled_subprocess.run( self._inference_state_weakref(), func, args=args, kwargs=kwargs, ) # IMO it should be possible to create a hook in pickle.load to # mess with the loaded objects. However it's extremely complicated # to work around this so just do it with this call. ~ dave return self._convert_access_handles(result) return wrapper def _convert_access_handles(self, obj): if isinstance(obj, SignatureParam): return SignatureParam(*self._convert_access_handles(tuple(obj))) elif isinstance(obj, tuple): return tuple(self._convert_access_handles(o) for o in obj) elif isinstance(obj, list): return [self._convert_access_handles(o) for o in obj] elif isinstance(obj, AccessHandle): try: # Rewrite the access handle to one we're already having. obj = self.get_access_handle(obj.id) except KeyError: obj.add_subprocess(self) self.set_access_handle(obj) elif isinstance(obj, AccessPath): return AccessPath(self._convert_access_handles(obj.accesses)) return obj def __del__(self): if self._used and not self._compiled_subprocess.is_crashed: self._compiled_subprocess.delete_inference_state(self._inference_state_id) class CompiledSubprocess: is_crashed = False def __init__(self, executable, env_vars=None): self._executable = executable self._env_vars = env_vars self._inference_state_deletion_queue = collections.deque() self._cleanup_callable = lambda: None def __repr__(self): pid = os.getpid() return '<%s _executable=%r, is_crashed=%r, pid=%r>' % ( self.__class__.__name__, self._executable, self.is_crashed, pid, ) @memoize_method def _get_process(self): debug.dbg('Start environment subprocess %s', self._executable) parso_path = sys.modules['parso'].__file__ args = ( self._executable, _MAIN_PATH, os.path.dirname(os.path.dirname(parso_path)), '.'.join(str(x) for x in sys.version_info[:3]), ) process = _GeneralizedPopen( args, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE, env=self._env_vars ) self._stderr_queue = queue.Queue() self._stderr_thread = t = Thread( target=_enqueue_output, args=(process.stderr, self._stderr_queue) ) t.daemon = True t.start() # Ensure the subprocess is properly cleaned up when the object # is garbage collected. self._cleanup_callable = weakref.finalize(self, _cleanup_process, process, t) return process def run(self, inference_state, function, args=(), kwargs={}): # Delete old inference_states. while True: try: inference_state_id = self._inference_state_deletion_queue.pop() except IndexError: break else: self._send(inference_state_id, None) assert callable(function) return self._send(id(inference_state), function, args, kwargs) def get_sys_path(self): return self._send(None, functions.get_sys_path, (), {}) def _kill(self): self.is_crashed = True self._cleanup_callable() def _send(self, inference_state_id, function, args=(), kwargs={}): if self.is_crashed: raise InternalError("The subprocess %s has crashed." % self._executable) data = inference_state_id, function, args, kwargs try: pickle_dump(data, self._get_process().stdin, PICKLE_PROTOCOL) except BrokenPipeError: self._kill() raise InternalError("The subprocess %s was killed. Maybe out of memory?" % self._executable) try: is_exception, traceback, result = pickle_load(self._get_process().stdout) except EOFError as eof_error: try: stderr = self._get_process().stderr.read().decode('utf-8', 'replace') except Exception as exc: stderr = '' % exc self._kill() _add_stderr_to_debug(self._stderr_queue) raise InternalError( "The subprocess %s has crashed (%r, stderr=%s)." % ( self._executable, eof_error, stderr, )) _add_stderr_to_debug(self._stderr_queue) if is_exception: # Replace the attribute error message with a the traceback. It's # way more informative. result.args = (traceback,) raise result return result def delete_inference_state(self, inference_state_id): """ Currently we are not deleting inference_state instantly. They only get deleted once the subprocess is used again. It would probably a better solution to move all of this into a thread. However, the memory usage of a single inference_state shouldn't be that high. """ # With an argument - the inference_state gets deleted. self._inference_state_deletion_queue.append(inference_state_id) class Listener: def __init__(self): self._inference_states = {} # TODO refactor so we don't need to process anymore just handle # controlling. self._process = _InferenceStateProcess(Listener) def _get_inference_state(self, function, inference_state_id): from jedi.inference import InferenceState try: inference_state = self._inference_states[inference_state_id] except KeyError: from jedi import InterpreterEnvironment inference_state = InferenceState( # The project is not actually needed. Nothing should need to # access it. project=None, environment=InterpreterEnvironment() ) self._inference_states[inference_state_id] = inference_state return inference_state def _run(self, inference_state_id, function, args, kwargs): if inference_state_id is None: return function(*args, **kwargs) elif function is None: del self._inference_states[inference_state_id] else: inference_state = self._get_inference_state(function, inference_state_id) # Exchange all handles args = list(args) for i, arg in enumerate(args): if isinstance(arg, AccessHandle): args[i] = inference_state.compiled_subprocess.get_access_handle(arg.id) for key, value in kwargs.items(): if isinstance(value, AccessHandle): kwargs[key] = inference_state.compiled_subprocess.get_access_handle(value.id) return function(inference_state, *args, **kwargs) def listen(self): stdout = sys.stdout # Mute stdout. Nobody should actually be able to write to it, # because stdout is used for IPC. sys.stdout = open(os.devnull, 'w') stdin = sys.stdin stdout = stdout.buffer stdin = stdin.buffer while True: try: payload = pickle_load(stdin) except EOFError: # It looks like the parent process closed. # Don't make a big fuss here and just exit. exit(0) try: result = False, None, self._run(*payload) except Exception as e: result = True, traceback.format_exc(), e pickle_dump(result, stdout, PICKLE_PROTOCOL) class AccessHandle: def __init__(self, subprocess, access, id_): self.access = access self._subprocess = subprocess self.id = id_ def add_subprocess(self, subprocess): self._subprocess = subprocess def __repr__(self): try: detail = self.access except AttributeError: detail = '#' + str(self.id) return '<%s of %s>' % (self.__class__.__name__, detail) def __getstate__(self): return self.id def __setstate__(self, state): self.id = state def __getattr__(self, name): if name in ('id', 'access') or name.startswith('_'): raise AttributeError("Something went wrong with unpickling") # print('getattr', name, file=sys.stderr) return partial(self._workaround, name) def _workaround(self, name, *args, **kwargs): """ TODO Currently we're passing slice objects around. This should not happen. They are also the only unhashable objects that we're passing around. """ if args and isinstance(args[0], slice): return self._subprocess.get_compiled_method_return(self.id, name, *args, **kwargs) return self._cached_results(name, *args, **kwargs) @memoize_method def _cached_results(self, name, *args, **kwargs): return self._subprocess.get_compiled_method_return(self.id, name, *args, **kwargs) ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/jedi/inference/compiled/subprocess/__main__.py0000664000175000017500000000224300000000000023330 0ustar00davedave00000000000000import os import sys from importlib.abc import MetaPathFinder from importlib.machinery import PathFinder # Remove the first entry, because it's simply a directory entry that equals # this directory. del sys.path[0] def _get_paths(): # Get the path to jedi. _d = os.path.dirname _jedi_path = _d(_d(_d(_d(_d(__file__))))) _parso_path = sys.argv[1] # The paths are the directory that jedi and parso lie in. return {'jedi': _jedi_path, 'parso': _parso_path} class _ExactImporter(MetaPathFinder): def __init__(self, path_dct): self._path_dct = path_dct def find_spec(self, fullname, path=None, target=None): if path is None and fullname in self._path_dct: p = self._path_dct[fullname] spec = PathFinder.find_spec(fullname, path=[p], target=target) return spec return None # Try to import jedi/parso. sys.meta_path.insert(0, _ExactImporter(_get_paths())) from jedi.inference.compiled import subprocess # noqa: E402 sys.meta_path.pop(0) # Retrieve the pickle protocol. host_sys_version = [int(x) for x in sys.argv[2].split('.')] # And finally start the client. subprocess.Listener().listen() ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/jedi/inference/compiled/subprocess/functions.py0000664000175000017500000002042000000000000023615 0ustar00davedave00000000000000import sys import os import inspect import importlib from pathlib import Path from zipfile import ZipFile from zipimport import zipimporter, ZipImportError from importlib.machinery import all_suffixes from jedi.inference.compiled import access from jedi import debug from jedi import parser_utils from jedi.file_io import KnownContentFileIO, ZipFileIO def get_sys_path(): return sys.path def load_module(inference_state, **kwargs): return access.load_module(inference_state, **kwargs) def get_compiled_method_return(inference_state, id, attribute, *args, **kwargs): handle = inference_state.compiled_subprocess.get_access_handle(id) return getattr(handle.access, attribute)(*args, **kwargs) def create_simple_object(inference_state, obj): return access.create_access_path(inference_state, obj) def get_module_info(inference_state, sys_path=None, full_name=None, **kwargs): """ Returns Tuple[Union[NamespaceInfo, FileIO, None], Optional[bool]] """ if sys_path is not None: sys.path, temp = sys_path, sys.path try: return _find_module(full_name=full_name, **kwargs) except ImportError: return None, None finally: if sys_path is not None: sys.path = temp def get_builtin_module_names(inference_state): return sys.builtin_module_names def _test_raise_error(inference_state, exception_type): """ Raise an error to simulate certain problems for unit tests. """ raise exception_type def _test_print(inference_state, stderr=None, stdout=None): """ Force some prints in the subprocesses. This exists for unit tests. """ if stderr is not None: print(stderr, file=sys.stderr) sys.stderr.flush() if stdout is not None: print(stdout) sys.stdout.flush() def _get_init_path(directory_path): """ The __init__ file can be searched in a directory. If found return it, else None. """ for suffix in all_suffixes(): path = os.path.join(directory_path, '__init__' + suffix) if os.path.exists(path): return path return None def safe_literal_eval(inference_state, value): return parser_utils.safe_literal_eval(value) def iter_module_names(*args, **kwargs): return list(_iter_module_names(*args, **kwargs)) def _iter_module_names(inference_state, paths): # Python modules/packages for path in paths: try: dir_entries = ((entry.name, entry.is_dir()) for entry in os.scandir(path)) except OSError: try: zip_import_info = zipimporter(path) # Unfortunately, there is no public way to access zipimporter's # private _files member. We therefore have to use a # custom function to iterate over the files. dir_entries = _zip_list_subdirectory( zip_import_info.archive, zip_import_info.prefix) except ZipImportError: # The file might not exist or reading it might lead to an error. debug.warning("Not possible to list directory: %s", path) continue for name, is_dir in dir_entries: # First Namespaces then modules/stubs if is_dir: # pycache is obviously not an interesting namespace. Also the # name must be a valid identifier. if name != '__pycache__' and name.isidentifier(): yield name else: if name.endswith('.pyi'): # Stub files modname = name[:-4] else: modname = inspect.getmodulename(name) if modname and '.' not in modname: if modname != '__init__': yield modname def _find_module(string, path=None, full_name=None, is_global_search=True): """ Provides information about a module. This function isolates the differences in importing libraries introduced with python 3.3 on; it gets a module name and optionally a path. It will return a tuple containin an open file for the module (if not builtin), the filename or the name of the module if it is a builtin one and a boolean indicating if the module is contained in a package. """ spec = None loader = None for finder in sys.meta_path: if is_global_search and finder != importlib.machinery.PathFinder: p = None else: p = path try: find_spec = finder.find_spec except AttributeError: # These are old-school clases that still have a different API, just # ignore those. continue spec = find_spec(string, p) if spec is not None: if spec.origin == "frozen": continue loader = spec.loader if loader is None and not spec.has_location: # This is a namespace package. full_name = string if not path else full_name implicit_ns_info = ImplicitNSInfo(full_name, spec.submodule_search_locations._path) return implicit_ns_info, True break return _find_module_py33(string, path, loader) def _find_module_py33(string, path=None, loader=None, full_name=None, is_global_search=True): if not loader: spec = importlib.machinery.PathFinder.find_spec(string, path) if spec is not None: loader = spec.loader if loader is None and path is None: # Fallback to find builtins try: spec = importlib.util.find_spec(string) if spec is not None: loader = spec.loader except ValueError as e: # See #491. Importlib might raise a ValueError, to avoid this, we # just raise an ImportError to fix the issue. raise ImportError("Originally " + repr(e)) if loader is None: raise ImportError("Couldn't find a loader for {}".format(string)) return _from_loader(loader, string) def _from_loader(loader, string): try: is_package_method = loader.is_package except AttributeError: is_package = False else: is_package = is_package_method(string) try: get_filename = loader.get_filename except AttributeError: return None, is_package else: module_path = get_filename(string) # To avoid unicode and read bytes, "overwrite" loader.get_source if # possible. try: f = type(loader).get_source except AttributeError: raise ImportError("get_source was not defined on loader") if f is not importlib.machinery.SourceFileLoader.get_source: # Unfortunately we are reading unicode here, not bytes. # It seems hard to get bytes, because the zip importer # logic just unpacks the zip file and returns a file descriptor # that we cannot as easily access. Therefore we just read it as # a string in the cases where get_source was overwritten. code = loader.get_source(string) else: code = _get_source(loader, string) if code is None: return None, is_package if isinstance(loader, zipimporter): return ZipFileIO(module_path, code, Path(loader.archive)), is_package return KnownContentFileIO(module_path, code), is_package def _get_source(loader, fullname): """ This method is here as a replacement for SourceLoader.get_source. That method returns unicode, but we prefer bytes. """ path = loader.get_filename(fullname) try: return loader.get_data(path) except OSError: raise ImportError('source not available through get_data()', name=fullname) def _zip_list_subdirectory(zip_path, zip_subdir_path): zip_file = ZipFile(zip_path) zip_subdir_path = Path(zip_subdir_path) zip_content_file_paths = zip_file.namelist() for raw_file_name in zip_content_file_paths: file_path = Path(raw_file_name) if file_path.parent == zip_subdir_path: file_path = file_path.relative_to(zip_subdir_path) yield file_path.name, raw_file_name.endswith("/") class ImplicitNSInfo: """Stores information returned from an implicit namespace spec""" def __init__(self, name, paths): self.name = name self.paths = paths ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/jedi/inference/compiled/value.py0000664000175000017500000005141600000000000020542 0ustar00davedave00000000000000""" Imitate the parser representation. """ import re from functools import partial from inspect import Parameter from pathlib import Path from typing import Optional from jedi import debug from jedi.inference.utils import to_list from jedi.cache import memoize_method from jedi.inference.filters import AbstractFilter from jedi.inference.names import AbstractNameDefinition, ValueNameMixin, \ ParamNameInterface from jedi.inference.base_value import Value, ValueSet, NO_VALUES from jedi.inference.lazy_value import LazyKnownValue from jedi.inference.compiled.access import _sentinel from jedi.inference.cache import inference_state_function_cache from jedi.inference.helpers import reraise_getitem_errors from jedi.inference.signature import BuiltinSignature from jedi.inference.context import CompiledContext, CompiledModuleContext class CheckAttribute: """Raises :exc:`AttributeError` if the attribute X is not available.""" def __init__(self, check_name=None): # Remove the py in front of e.g. py__call__. self.check_name = check_name def __call__(self, func): self.func = func if self.check_name is None: self.check_name = func.__name__[2:] return self def __get__(self, instance, owner): if instance is None: return self # This might raise an AttributeError. That's wanted. instance.access_handle.getattr_paths(self.check_name) return partial(self.func, instance) class CompiledValue(Value): def __init__(self, inference_state, access_handle, parent_context=None): super().__init__(inference_state, parent_context) self.access_handle = access_handle def py__call__(self, arguments): return_annotation = self.access_handle.get_return_annotation() if return_annotation is not None: return create_from_access_path( self.inference_state, return_annotation ).execute_annotation() try: self.access_handle.getattr_paths('__call__') except AttributeError: return super().py__call__(arguments) else: if self.access_handle.is_class(): from jedi.inference.value import CompiledInstance return ValueSet([ CompiledInstance(self.inference_state, self.parent_context, self, arguments) ]) else: return ValueSet(self._execute_function(arguments)) @CheckAttribute() def py__class__(self): return create_from_access_path(self.inference_state, self.access_handle.py__class__()) @CheckAttribute() def py__mro__(self): return (self,) + tuple( create_from_access_path(self.inference_state, access) for access in self.access_handle.py__mro__accesses() ) @CheckAttribute() def py__bases__(self): return tuple( create_from_access_path(self.inference_state, access) for access in self.access_handle.py__bases__() ) def get_qualified_names(self): return self.access_handle.get_qualified_names() def py__bool__(self): return self.access_handle.py__bool__() def is_class(self): return self.access_handle.is_class() def is_function(self): return self.access_handle.is_function() def is_module(self): return self.access_handle.is_module() def is_compiled(self): return True def is_stub(self): return False def is_instance(self): return self.access_handle.is_instance() def py__doc__(self): return self.access_handle.py__doc__() @to_list def get_param_names(self): try: signature_params = self.access_handle.get_signature_params() except ValueError: # Has no signature params_str, ret = self._parse_function_doc() if not params_str: tokens = [] else: tokens = params_str.split(',') if self.access_handle.ismethoddescriptor(): tokens.insert(0, 'self') for p in tokens: name, _, default = p.strip().partition('=') yield UnresolvableParamName(self, name, default) else: for signature_param in signature_params: yield SignatureParamName(self, signature_param) def get_signatures(self): _, return_string = self._parse_function_doc() return [BuiltinSignature(self, return_string)] def __repr__(self): return '<%s: %s>' % (self.__class__.__name__, self.access_handle.get_repr()) @memoize_method def _parse_function_doc(self): doc = self.py__doc__() if doc is None: return '', '' return _parse_function_doc(doc) @property def api_type(self): return self.access_handle.get_api_type() def get_filters(self, is_instance=False, origin_scope=None): yield self._ensure_one_filter(is_instance) @memoize_method def _ensure_one_filter(self, is_instance): return CompiledValueFilter(self.inference_state, self, is_instance) def py__simple_getitem__(self, index): with reraise_getitem_errors(IndexError, KeyError, TypeError): try: access = self.access_handle.py__simple_getitem__( index, safe=not self.inference_state.allow_unsafe_executions ) except AttributeError: return super().py__simple_getitem__(index) if access is None: return super().py__simple_getitem__(index) return ValueSet([create_from_access_path(self.inference_state, access)]) def py__getitem__(self, index_value_set, contextualized_node): all_access_paths = self.access_handle.py__getitem__all_values() if all_access_paths is None: # This means basically that no __getitem__ has been defined on this # object. return super().py__getitem__(index_value_set, contextualized_node) return ValueSet( create_from_access_path(self.inference_state, access) for access in all_access_paths ) def py__iter__(self, contextualized_node=None): if not self.access_handle.has_iter(): yield from super().py__iter__(contextualized_node) access_path_list = self.access_handle.py__iter__list() if access_path_list is None: # There is no __iter__ method on this object. return for access in access_path_list: yield LazyKnownValue(create_from_access_path(self.inference_state, access)) def py__name__(self): return self.access_handle.py__name__() @property def name(self): name = self.py__name__() if name is None: name = self.access_handle.get_repr() return CompiledValueName(self, name) def _execute_function(self, params): from jedi.inference import docstrings from jedi.inference.compiled import builtin_from_name if self.api_type != 'function': return for name in self._parse_function_doc()[1].split(): try: # TODO wtf is this? this is exactly the same as the thing # below. It uses getattr as well. self.inference_state.builtins_module.access_handle.getattr_paths(name) except AttributeError: continue else: bltn_obj = builtin_from_name(self.inference_state, name) yield from self.inference_state.execute(bltn_obj, params) yield from docstrings.infer_return_types(self) def get_safe_value(self, default=_sentinel): try: return self.access_handle.get_safe_value() except ValueError: if default == _sentinel: raise return default def execute_operation(self, other, operator): try: return ValueSet([create_from_access_path( self.inference_state, self.access_handle.execute_operation(other.access_handle, operator) )]) except TypeError: return NO_VALUES def execute_annotation(self): if self.access_handle.get_repr() == 'None': # None as an annotation doesn't need to be executed. return ValueSet([self]) name, args = self.access_handle.get_annotation_name_and_args() arguments = [ ValueSet([create_from_access_path(self.inference_state, path)]) for path in args ] if name == 'Union': return ValueSet.from_sets(arg.execute_annotation() for arg in arguments) elif name: # While with_generics only exists on very specific objects, we # should probably be fine, because we control all the typing # objects. return ValueSet([ v.with_generics(arguments) for v in self.inference_state.typing_module.py__getattribute__(name) ]).execute_annotation() return super().execute_annotation() def negate(self): return create_from_access_path(self.inference_state, self.access_handle.negate()) def get_metaclasses(self): return NO_VALUES def _as_context(self): return CompiledContext(self) @property def array_type(self): return self.access_handle.get_array_type() def get_key_values(self): return [ create_from_access_path(self.inference_state, k) for k in self.access_handle.get_key_paths() ] def get_type_hint(self, add_class_info=True): if self.access_handle.get_repr() in ('None', ""): return 'None' return None class CompiledModule(CompiledValue): file_io = None # For modules def _as_context(self): return CompiledModuleContext(self) def py__path__(self): return self.access_handle.py__path__() def is_package(self): return self.py__path__() is not None @property def string_names(self): # For modules name = self.py__name__() if name is None: return () return tuple(name.split('.')) def py__file__(self) -> Optional[Path]: return self.access_handle.py__file__() # type: ignore[no-any-return] class CompiledName(AbstractNameDefinition): def __init__(self, inference_state, parent_value, name, is_descriptor): self._inference_state = inference_state self.parent_context = parent_value.as_context() self._parent_value = parent_value self.string_name = name self.is_descriptor = is_descriptor def py__doc__(self): return self.infer_compiled_value().py__doc__() def _get_qualified_names(self): parent_qualified_names = self.parent_context.get_qualified_names() if parent_qualified_names is None: return None return parent_qualified_names + (self.string_name,) def get_defining_qualified_value(self): context = self.parent_context if context.is_module() or context.is_class(): return self.parent_context.get_value() # Might be None return None def __repr__(self): try: name = self.parent_context.name # __name__ is not defined all the time except AttributeError: name = None return '<%s: (%s).%s>' % (self.__class__.__name__, name, self.string_name) @property def api_type(self): if self.is_descriptor: # In case of properties we want to avoid executions as much as # possible. Since the api_type can be wrong for other reasons # anyway, we just return instance here. return "instance" return self.infer_compiled_value().api_type def infer(self): return ValueSet([self.infer_compiled_value()]) @memoize_method def infer_compiled_value(self): return create_from_name(self._inference_state, self._parent_value, self.string_name) class SignatureParamName(ParamNameInterface, AbstractNameDefinition): def __init__(self, compiled_value, signature_param): self.parent_context = compiled_value.parent_context self._signature_param = signature_param @property def string_name(self): return self._signature_param.name def to_string(self): s = self._kind_string() + self.string_name if self._signature_param.has_annotation: s += ': ' + self._signature_param.annotation_string if self._signature_param.has_default: s += '=' + self._signature_param.default_string return s def get_kind(self): return getattr(Parameter, self._signature_param.kind_name) def infer(self): p = self._signature_param inference_state = self.parent_context.inference_state values = NO_VALUES if p.has_default: values = ValueSet([create_from_access_path(inference_state, p.default)]) if p.has_annotation: annotation = create_from_access_path(inference_state, p.annotation) values |= annotation.execute_with_values() return values class UnresolvableParamName(ParamNameInterface, AbstractNameDefinition): def __init__(self, compiled_value, name, default): self.parent_context = compiled_value.parent_context self.string_name = name self._default = default def get_kind(self): return Parameter.POSITIONAL_ONLY def to_string(self): string = self.string_name if self._default: string += '=' + self._default return string def infer(self): return NO_VALUES class CompiledValueName(ValueNameMixin, AbstractNameDefinition): def __init__(self, value, name): self.string_name = name self._value = value self.parent_context = value.parent_context class EmptyCompiledName(AbstractNameDefinition): """ Accessing some names will raise an exception. To avoid not having any completions, just give Jedi the option to return this object. It infers to nothing. """ def __init__(self, inference_state, name): self.parent_context = inference_state.builtins_module self.string_name = name def infer(self): return NO_VALUES class CompiledValueFilter(AbstractFilter): def __init__(self, inference_state, compiled_value, is_instance=False): self._inference_state = inference_state self.compiled_value = compiled_value self.is_instance = is_instance def get(self, name): access_handle = self.compiled_value.access_handle safe = not self._inference_state.allow_unsafe_executions return self._get( name, lambda name: access_handle.is_allowed_getattr(name, safe=safe), lambda name: name in access_handle.dir(), check_has_attribute=True ) def _get(self, name, allowed_getattr_callback, in_dir_callback, check_has_attribute=False): """ To remove quite a few access calls we introduced the callback here. """ has_attribute, is_descriptor, property_return_annotation = allowed_getattr_callback( name, ) if property_return_annotation is not None: values = create_from_access_path( self._inference_state, property_return_annotation ).execute_annotation() if values: return [CompiledValueName(v, name) for v in values] if check_has_attribute and not has_attribute: return [] if (is_descriptor or not has_attribute) \ and not self._inference_state.allow_unsafe_executions: return [self._get_cached_name(name, is_empty=True)] if self.is_instance and not in_dir_callback(name): return [] return [self._get_cached_name(name, is_descriptor=is_descriptor)] @memoize_method def _get_cached_name(self, name, is_empty=False, *, is_descriptor=False): if is_empty: return EmptyCompiledName(self._inference_state, name) else: return self._create_name(name, is_descriptor=is_descriptor) def values(self): from jedi.inference.compiled import builtin_from_name names = [] needs_type_completions, dir_infos = self.compiled_value.access_handle.get_dir_infos() # We could use `safe=False` here as well, especially as a parameter to # get_dir_infos. But this would lead to a lot of property executions # that are probably not wanted. The drawback for this is that we # have a different name for `get` and `values`. For `get` we always # execute. for name in dir_infos: names += self._get( name, lambda name: dir_infos[name], lambda name: name in dir_infos, ) # ``dir`` doesn't include the type names. if not self.is_instance and needs_type_completions: for filter in builtin_from_name(self._inference_state, 'type').get_filters(): names += filter.values() return names def _create_name(self, name, is_descriptor): return CompiledName( self._inference_state, self.compiled_value, name, is_descriptor, ) def __repr__(self): return "<%s: %s>" % (self.__class__.__name__, self.compiled_value) docstr_defaults = { 'floating point number': 'float', 'character': 'str', 'integer': 'int', 'dictionary': 'dict', 'string': 'str', } def _parse_function_doc(doc): """ Takes a function and returns the params and return value as a tuple. This is nothing more than a docstring parser. TODO docstrings like utime(path, (atime, mtime)) and a(b [, b]) -> None TODO docstrings like 'tuple of integers' """ # parse round parentheses: def func(a, (b,c)) try: count = 0 start = doc.index('(') for i, s in enumerate(doc[start:]): if s == '(': count += 1 elif s == ')': count -= 1 if count == 0: end = start + i break param_str = doc[start + 1:end] except (ValueError, UnboundLocalError): # ValueError for doc.index # UnboundLocalError for undefined end in last line debug.dbg('no brackets found - no param') end = 0 param_str = '' else: # remove square brackets, that show an optional param ( = None) def change_options(m): args = m.group(1).split(',') for i, a in enumerate(args): if a and '=' not in a: args[i] += '=None' return ','.join(args) while True: param_str, changes = re.subn(r' ?\[([^\[\]]+)\]', change_options, param_str) if changes == 0: break param_str = param_str.replace('-', '_') # see: isinstance.__doc__ # parse return value r = re.search('-[>-]* ', doc[end:end + 7]) if r is None: ret = '' else: index = end + r.end() # get result type, which can contain newlines pattern = re.compile(r'(,\n|[^\n-])+') ret_str = pattern.match(doc, index).group(0).strip() # New object -> object() ret_str = re.sub(r'[nN]ew (.*)', r'\1()', ret_str) ret = docstr_defaults.get(ret_str, ret_str) return param_str, ret def create_from_name(inference_state, compiled_value, name): access_paths = compiled_value.access_handle.getattr_paths(name, default=None) value = None for access_path in access_paths: value = create_cached_compiled_value( inference_state, access_path, parent_context=None if value is None else value.as_context(), ) return value def _normalize_create_args(func): """The cache doesn't care about keyword vs. normal args.""" def wrapper(inference_state, obj, parent_context=None): return func(inference_state, obj, parent_context) return wrapper def create_from_access_path(inference_state, access_path): value = None for name, access in access_path.accesses: value = create_cached_compiled_value( inference_state, access, parent_context=None if value is None else value.as_context() ) return value @_normalize_create_args @inference_state_function_cache() def create_cached_compiled_value(inference_state, access_handle, parent_context): assert not isinstance(parent_context, CompiledValue) if parent_context is None: cls = CompiledModule else: cls = CompiledValue return cls(inference_state, access_handle, parent_context) ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/jedi/inference/context.py0000664000175000017500000004141400000000000017313 0ustar00davedave00000000000000from abc import abstractmethod from contextlib import contextmanager from pathlib import Path from typing import Optional from parso.tree import search_ancestor from parso.python.tree import Name from jedi.inference.filters import ParserTreeFilter, MergedFilter, \ GlobalNameFilter from jedi.inference.names import AnonymousParamName, TreeNameDefinition from jedi.inference.base_value import NO_VALUES, ValueSet from jedi.parser_utils import get_parent_scope from jedi import debug from jedi import parser_utils class AbstractContext: # Must be defined: inference_state and tree_node and parent_context as an attribute/property def __init__(self, inference_state): self.inference_state = inference_state self.predefined_names = {} @abstractmethod def get_filters(self, until_position=None, origin_scope=None): raise NotImplementedError def goto(self, name_or_str, position): from jedi.inference import finder filters = _get_global_filters_for_name( self, name_or_str if isinstance(name_or_str, Name) else None, position, ) names = finder.filter_name(filters, name_or_str) debug.dbg('context.goto %s in (%s): %s', name_or_str, self, names) return names def py__getattribute__(self, name_or_str, name_context=None, position=None, analysis_errors=True): """ :param position: Position of the last statement -> tuple of line, column """ if name_context is None: name_context = self names = self.goto(name_or_str, position) string_name = name_or_str.value if isinstance(name_or_str, Name) else name_or_str # This paragraph is currently needed for proper branch type inference # (static analysis). found_predefined_types = None if self.predefined_names and isinstance(name_or_str, Name): node = name_or_str while node is not None and not parser_utils.is_scope(node): node = node.parent if node.type in ("if_stmt", "for_stmt", "comp_for", 'sync_comp_for'): try: name_dict = self.predefined_names[node] types = name_dict[string_name] except KeyError: continue else: found_predefined_types = types break if found_predefined_types is not None and names: from jedi.inference import flow_analysis check = flow_analysis.reachability_check( context=self, value_scope=self.tree_node, node=name_or_str, ) if check is flow_analysis.UNREACHABLE: values = NO_VALUES else: values = found_predefined_types else: values = ValueSet.from_sets(name.infer() for name in names) if not names and not values and analysis_errors: if isinstance(name_or_str, Name): from jedi.inference import analysis message = ("NameError: name '%s' is not defined." % string_name) analysis.add(name_context, 'name-error', name_or_str, message) debug.dbg('context.names_to_types: %s -> %s', names, values) if values: return values return self._check_for_additional_knowledge(name_or_str, name_context, position) def _check_for_additional_knowledge(self, name_or_str, name_context, position): name_context = name_context or self # Add isinstance and other if/assert knowledge. if isinstance(name_or_str, Name) and not name_context.is_instance(): flow_scope = name_or_str base_nodes = [name_context.tree_node] if any(b.type in ('comp_for', 'sync_comp_for') for b in base_nodes): return NO_VALUES from jedi.inference.finder import check_flow_information while True: flow_scope = get_parent_scope(flow_scope, include_flows=True) n = check_flow_information(name_context, flow_scope, name_or_str, position) if n is not None: return n if flow_scope in base_nodes: break return NO_VALUES def get_root_context(self): parent_context = self.parent_context if parent_context is None: return self return parent_context.get_root_context() def is_module(self): return False def is_builtins_module(self): return False def is_class(self): return False def is_stub(self): return False def is_instance(self): return False def is_compiled(self): return False def is_bound_method(self): return False @abstractmethod def py__name__(self): raise NotImplementedError def get_value(self): raise NotImplementedError @property def name(self): return None def get_qualified_names(self): return () def py__doc__(self): return '' @contextmanager def predefine_names(self, flow_scope, dct): predefined = self.predefined_names predefined[flow_scope] = dct try: yield finally: del predefined[flow_scope] class ValueContext(AbstractContext): """ Should be defined, otherwise the API returns empty types. """ def __init__(self, value): super().__init__(value.inference_state) self._value = value @property def tree_node(self): return self._value.tree_node @property def parent_context(self): return self._value.parent_context def is_module(self): return self._value.is_module() def is_builtins_module(self): return self._value == self.inference_state.builtins_module def is_class(self): return self._value.is_class() def is_stub(self): return self._value.is_stub() def is_instance(self): return self._value.is_instance() def is_compiled(self): return self._value.is_compiled() def is_bound_method(self): return self._value.is_bound_method() def py__name__(self): return self._value.py__name__() @property def name(self): return self._value.name def get_qualified_names(self): return self._value.get_qualified_names() def py__doc__(self): return self._value.py__doc__() def get_value(self): return self._value def __repr__(self): return '%s(%s)' % (self.__class__.__name__, self._value) class TreeContextMixin: def infer_node(self, node): from jedi.inference.syntax_tree import infer_node return infer_node(self, node) def create_value(self, node): from jedi.inference import value if node == self.tree_node: assert self.is_module() return self.get_value() parent_context = self.create_context(node) if node.type in ('funcdef', 'lambdef'): func = value.FunctionValue.from_context(parent_context, node) if parent_context.is_class(): class_value = parent_context.parent_context.create_value(parent_context.tree_node) instance = value.AnonymousInstance( self.inference_state, parent_context.parent_context, class_value) func = value.BoundMethod( instance=instance, class_context=class_value.as_context(), function=func ) return func elif node.type == 'classdef': return value.ClassValue(self.inference_state, parent_context, node) else: raise NotImplementedError("Probably shouldn't happen: %s" % node) def create_context(self, node): def from_scope_node(scope_node, is_nested=True): if scope_node == self.tree_node: return self if scope_node.type in ('funcdef', 'lambdef', 'classdef'): return self.create_value(scope_node).as_context() elif scope_node.type in ('comp_for', 'sync_comp_for'): parent_context = from_scope_node(parent_scope(scope_node.parent)) if node.start_pos >= scope_node.children[-1].start_pos: return parent_context return CompForContext(parent_context, scope_node) raise Exception("There's a scope that was not managed: %s" % scope_node) def parent_scope(node): while True: node = node.parent if parser_utils.is_scope(node): return node elif node.type in ('argument', 'testlist_comp'): if node.children[1].type in ('comp_for', 'sync_comp_for'): return node.children[1] elif node.type == 'dictorsetmaker': for n in node.children[1:4]: # In dictionaries it can be pretty much anything. if n.type in ('comp_for', 'sync_comp_for'): return n scope_node = parent_scope(node) if scope_node.type in ('funcdef', 'classdef'): colon = scope_node.children[scope_node.children.index(':')] if node.start_pos < colon.start_pos: parent = node.parent if not (parent.type == 'param' and parent.name == node): scope_node = parent_scope(scope_node) return from_scope_node(scope_node, is_nested=True) def create_name(self, tree_name): definition = tree_name.get_definition() if definition and definition.type == 'param' and definition.name == tree_name: funcdef = search_ancestor(definition, 'funcdef', 'lambdef') func = self.create_value(funcdef) return AnonymousParamName(func, tree_name) else: context = self.create_context(tree_name) return TreeNameDefinition(context, tree_name) class FunctionContext(TreeContextMixin, ValueContext): def get_filters(self, until_position=None, origin_scope=None): yield ParserTreeFilter( self.inference_state, parent_context=self, until_position=until_position, origin_scope=origin_scope ) class ModuleContext(TreeContextMixin, ValueContext): def py__file__(self) -> Optional[Path]: return self._value.py__file__() # type: ignore[no-any-return] def get_filters(self, until_position=None, origin_scope=None): filters = self._value.get_filters(origin_scope) # Skip the first filter and replace it. next(filters, None) yield MergedFilter( ParserTreeFilter( parent_context=self, until_position=until_position, origin_scope=origin_scope ), self.get_global_filter(), ) yield from filters def get_global_filter(self): return GlobalNameFilter(self) @property def string_names(self): return self._value.string_names @property def code_lines(self): return self._value.code_lines def get_value(self): """ This is the only function that converts a context back to a value. This is necessary for stub -> python conversion and vice versa. However this method shouldn't be moved to AbstractContext. """ return self._value class NamespaceContext(TreeContextMixin, ValueContext): def get_filters(self, until_position=None, origin_scope=None): return self._value.get_filters() def get_value(self): return self._value @property def string_names(self): return self._value.string_names def py__file__(self) -> Optional[Path]: return self._value.py__file__() # type: ignore[no-any-return] class ClassContext(TreeContextMixin, ValueContext): def get_filters(self, until_position=None, origin_scope=None): yield self.get_global_filter(until_position, origin_scope) def get_global_filter(self, until_position=None, origin_scope=None): return ParserTreeFilter( parent_context=self, until_position=until_position, origin_scope=origin_scope ) class CompForContext(TreeContextMixin, AbstractContext): def __init__(self, parent_context, comp_for): super().__init__(parent_context.inference_state) self.tree_node = comp_for self.parent_context = parent_context def get_filters(self, until_position=None, origin_scope=None): yield ParserTreeFilter(self) def get_value(self): return None def py__name__(self): return '' def __repr__(self): return '%s(%s)' % (self.__class__.__name__, self.tree_node) class CompiledContext(ValueContext): def get_filters(self, until_position=None, origin_scope=None): return self._value.get_filters() class CompiledModuleContext(CompiledContext): code_lines = None def get_value(self): return self._value @property def string_names(self): return self._value.string_names def py__file__(self) -> Optional[Path]: return self._value.py__file__() # type: ignore[no-any-return] def _get_global_filters_for_name(context, name_or_none, position): # For functions and classes the defaults don't belong to the # function and get inferred in the value before the function. So # make sure to exclude the function/class name. if name_or_none is not None: ancestor = search_ancestor(name_or_none, 'funcdef', 'classdef', 'lambdef') lambdef = None if ancestor == 'lambdef': # For lambdas it's even more complicated since parts will # be inferred later. lambdef = ancestor ancestor = search_ancestor(name_or_none, 'funcdef', 'classdef') if ancestor is not None: colon = ancestor.children[-2] if position is not None and position < colon.start_pos: if lambdef is None or position < lambdef.children[-2].start_pos: position = ancestor.start_pos return get_global_filters(context, position, name_or_none) def get_global_filters(context, until_position, origin_scope): """ Returns all filters in order of priority for name resolution. For global name lookups. The filters will handle name resolution themselves, but here we gather possible filters downwards. >>> from jedi import Script >>> script = Script(''' ... x = ['a', 'b', 'c'] ... def func(): ... y = None ... ''') >>> module_node = script._module_node >>> scope = next(module_node.iter_funcdefs()) >>> scope >>> context = script._get_module_context().create_context(scope) >>> filters = list(get_global_filters(context, (4, 0), None)) First we get the names from the function scope. >>> print(filters[0]) # doctest: +ELLIPSIS MergedFilter(, ) >>> sorted(str(n) for n in filters[0].values()) # doctest: +NORMALIZE_WHITESPACE ['', ''] >>> filters[0]._filters[0]._until_position (4, 0) >>> filters[0]._filters[1]._until_position Then it yields the names from one level "lower". In this example, this is the module scope (including globals). As a side note, you can see, that the position in the filter is None on the globals filter, because there the whole module is searched. >>> list(filters[1].values()) # package modules -> Also empty. [] >>> sorted(name.string_name for name in filters[2].values()) # Module attributes ['__doc__', '__name__', '__package__'] Finally, it yields the builtin filter, if `include_builtin` is true (default). >>> list(filters[3].values()) # doctest: +ELLIPSIS [...] """ base_context = context from jedi.inference.value.function import BaseFunctionExecutionContext while context is not None: # Names in methods cannot be resolved within the class. yield from context.get_filters( until_position=until_position, origin_scope=origin_scope ) if isinstance(context, (BaseFunctionExecutionContext, ModuleContext)): # The position should be reset if the current scope is a function. until_position = None context = context.parent_context b = next(base_context.inference_state.builtins_module.get_filters(), None) assert b is not None # Add builtins to the global scope. yield b ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/jedi/inference/docstring_utils.py0000664000175000017500000000136700000000000021046 0ustar00davedave00000000000000from jedi.inference.value import ModuleValue from jedi.inference.context import ModuleContext class DocstringModule(ModuleValue): def __init__(self, in_module_context, **kwargs): super().__init__(**kwargs) self._in_module_context = in_module_context def _as_context(self): return DocstringModuleContext(self, self._in_module_context) class DocstringModuleContext(ModuleContext): def __init__(self, module_value, in_module_context): super().__init__(module_value) self._in_module_context = in_module_context def get_filters(self, origin_scope=None, until_position=None): yield from super().get_filters(until_position=until_position) yield from self._in_module_context.get_filters() ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/jedi/inference/docstrings.py0000664000175000017500000002314000000000000020002 0ustar00davedave00000000000000""" Docstrings are another source of information for functions and classes. :mod:`jedi.inference.dynamic_params` tries to find all executions of functions, while the docstring parsing is much easier. There are three different types of docstrings that |jedi| understands: - `Sphinx `_ - `Epydoc `_ - `Numpydoc `_ For example, the sphinx annotation ``:type foo: str`` clearly states that the type of ``foo`` is ``str``. As an addition to parameter searching, this module also provides return annotations. """ import re import warnings from parso import parse, ParserSyntaxError from jedi import debug from jedi.inference.cache import inference_state_method_cache from jedi.inference.base_value import iterator_to_value_set, ValueSet, \ NO_VALUES from jedi.inference.lazy_value import LazyKnownValues DOCSTRING_PARAM_PATTERNS = [ r'\s*:type\s+%s:\s*([^\n]+)', # Sphinx r'\s*:param\s+(\w+)\s+%s:[^\n]*', # Sphinx param with type r'\s*@type\s+%s:\s*([^\n]+)', # Epydoc ] DOCSTRING_RETURN_PATTERNS = [ re.compile(r'\s*:rtype:\s*([^\n]+)', re.M), # Sphinx re.compile(r'\s*@rtype:\s*([^\n]+)', re.M), # Epydoc ] REST_ROLE_PATTERN = re.compile(r':[^`]+:`([^`]+)`') _numpy_doc_string_cache = None def _get_numpy_doc_string_cls(): global _numpy_doc_string_cache if isinstance(_numpy_doc_string_cache, (ImportError, SyntaxError)): raise _numpy_doc_string_cache from numpydoc.docscrape import NumpyDocString # type: ignore[import] _numpy_doc_string_cache = NumpyDocString return _numpy_doc_string_cache def _search_param_in_numpydocstr(docstr, param_str): """Search `docstr` (in numpydoc format) for type(-s) of `param_str`.""" with warnings.catch_warnings(): warnings.simplefilter("ignore") try: # This is a non-public API. If it ever changes we should be # prepared and return gracefully. params = _get_numpy_doc_string_cls()(docstr)._parsed_data['Parameters'] except Exception: return [] for p_name, p_type, p_descr in params: if p_name == param_str: m = re.match(r'([^,]+(,[^,]+)*?)(,[ ]*optional)?$', p_type) if m: p_type = m.group(1) return list(_expand_typestr(p_type)) return [] def _search_return_in_numpydocstr(docstr): """ Search `docstr` (in numpydoc format) for type(-s) of function returns. """ with warnings.catch_warnings(): warnings.simplefilter("ignore") try: doc = _get_numpy_doc_string_cls()(docstr) except Exception: return try: # This is a non-public API. If it ever changes we should be # prepared and return gracefully. returns = doc._parsed_data['Returns'] returns += doc._parsed_data['Yields'] except Exception: return for r_name, r_type, r_descr in returns: # Return names are optional and if so the type is in the name if not r_type: r_type = r_name yield from _expand_typestr(r_type) def _expand_typestr(type_str): """ Attempts to interpret the possible types in `type_str` """ # Check if alternative types are specified with 'or' if re.search(r'\bor\b', type_str): for t in type_str.split('or'): yield t.split('of')[0].strip() # Check if like "list of `type`" and set type to list elif re.search(r'\bof\b', type_str): yield type_str.split('of')[0] # Check if type has is a set of valid literal values eg: {'C', 'F', 'A'} elif type_str.startswith('{'): node = parse(type_str, version='3.7').children[0] if node.type == 'atom': for leaf in getattr(node.children[1], "children", []): if leaf.type == 'number': if '.' in leaf.value: yield 'float' else: yield 'int' elif leaf.type == 'string': if 'b' in leaf.string_prefix.lower(): yield 'bytes' else: yield 'str' # Ignore everything else. # Otherwise just work with what we have. else: yield type_str def _search_param_in_docstr(docstr, param_str): """ Search `docstr` for type(-s) of `param_str`. >>> _search_param_in_docstr(':type param: int', 'param') ['int'] >>> _search_param_in_docstr('@type param: int', 'param') ['int'] >>> _search_param_in_docstr( ... ':type param: :class:`threading.Thread`', 'param') ['threading.Thread'] >>> bool(_search_param_in_docstr('no document', 'param')) False >>> _search_param_in_docstr(':param int param: some description', 'param') ['int'] """ # look at #40 to see definitions of those params patterns = [re.compile(p % re.escape(param_str)) for p in DOCSTRING_PARAM_PATTERNS] for pattern in patterns: match = pattern.search(docstr) if match: return [_strip_rst_role(match.group(1))] return _search_param_in_numpydocstr(docstr, param_str) def _strip_rst_role(type_str): """ Strip off the part looks like a ReST role in `type_str`. >>> _strip_rst_role(':class:`ClassName`') # strip off :class: 'ClassName' >>> _strip_rst_role(':py:obj:`module.Object`') # works with domain 'module.Object' >>> _strip_rst_role('ClassName') # do nothing when not ReST role 'ClassName' See also: http://sphinx-doc.org/domains.html#cross-referencing-python-objects """ match = REST_ROLE_PATTERN.match(type_str) if match: return match.group(1) else: return type_str def _infer_for_statement_string(module_context, string): if string is None: return [] potential_imports = re.findall(r'((?:\w+\.)*\w+)\.', string) # Try to import module part in dotted name. # (e.g., 'threading' in 'threading.Thread'). imports = "\n".join(f"import {p}" for p in potential_imports) string = f'{imports}\n{string}' debug.dbg('Parse docstring code %s', string, color='BLUE') grammar = module_context.inference_state.grammar try: module = grammar.parse(string, error_recovery=False) except ParserSyntaxError: return [] try: # It's not the last item, because that's an end marker. stmt = module.children[-2] except (AttributeError, IndexError): return [] if stmt.type not in ('name', 'atom', 'atom_expr'): return [] # Here we basically use a fake module that also uses the filters in # the actual module. from jedi.inference.docstring_utils import DocstringModule m = DocstringModule( in_module_context=module_context, inference_state=module_context.inference_state, module_node=module, code_lines=[], ) return list(_execute_types_in_stmt(m.as_context(), stmt)) def _execute_types_in_stmt(module_context, stmt): """ Executing all types or general elements that we find in a statement. This doesn't include tuple, list and dict literals, because the stuff they contain is executed. (Used as type information). """ definitions = module_context.infer_node(stmt) return ValueSet.from_sets( _execute_array_values(module_context.inference_state, d) for d in definitions ) def _execute_array_values(inference_state, array): """ Tuples indicate that there's not just one return value, but the listed ones. `(str, int)` means that it returns a tuple with both types. """ from jedi.inference.value.iterable import SequenceLiteralValue, FakeTuple, FakeList if isinstance(array, SequenceLiteralValue) and array.array_type in ('tuple', 'list'): values = [] for lazy_value in array.py__iter__(): objects = ValueSet.from_sets( _execute_array_values(inference_state, typ) for typ in lazy_value.infer() ) values.append(LazyKnownValues(objects)) cls = FakeTuple if array.array_type == 'tuple' else FakeList return {cls(inference_state, values)} else: return array.execute_annotation() @inference_state_method_cache() def infer_param(function_value, param): def infer_docstring(docstring): return ValueSet( p for param_str in _search_param_in_docstr(docstring, param.name.value) for p in _infer_for_statement_string(module_context, param_str) ) module_context = function_value.get_root_context() func = param.get_parent_function() if func.type == 'lambdef': return NO_VALUES types = infer_docstring(function_value.py__doc__()) if function_value.is_bound_method() \ and function_value.py__name__() == '__init__': types |= infer_docstring(function_value.class_context.py__doc__()) debug.dbg('Found param types for docstring: %s', types, color='BLUE') return types @inference_state_method_cache() @iterator_to_value_set def infer_return_types(function_value): def search_return_in_docstr(code): for p in DOCSTRING_RETURN_PATTERNS: match = p.search(code) if match: yield _strip_rst_role(match.group(1)) # Check for numpy style return hint yield from _search_return_in_numpydocstr(code) for type_str in search_return_in_docstr(function_value.py__doc__()): yield from _infer_for_statement_string(function_value.get_root_context(), type_str) ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/jedi/inference/dynamic_params.py0000664000175000017500000001773200000000000020624 0ustar00davedave00000000000000""" One of the really important features of |jedi| is to have an option to understand code like this:: def foo(bar): bar. # completion here foo(1) There's no doubt wheter bar is an ``int`` or not, but if there's also a call like ``foo('str')``, what would happen? Well, we'll just show both. Because that's what a human would expect. It works as follows: - |Jedi| sees a param - search for function calls named ``foo`` - execute these calls and check the input. """ from jedi import settings from jedi import debug from jedi.parser_utils import get_parent_scope from jedi.inference.cache import inference_state_method_cache from jedi.inference.arguments import TreeArguments from jedi.inference.param import get_executed_param_names from jedi.inference.helpers import is_stdlib_path from jedi.inference.utils import to_list from jedi.inference.value import instance from jedi.inference.base_value import ValueSet, NO_VALUES from jedi.inference.references import get_module_contexts_containing_name from jedi.inference import recursion MAX_PARAM_SEARCHES = 20 def _avoid_recursions(func): def wrapper(function_value, param_index): inf = function_value.inference_state with recursion.execution_allowed(inf, function_value.tree_node) as allowed: # We need to catch recursions that may occur, because an # anonymous functions can create an anonymous parameter that is # more or less self referencing. if allowed: inf.dynamic_params_depth += 1 try: return func(function_value, param_index) finally: inf.dynamic_params_depth -= 1 return NO_VALUES return wrapper @debug.increase_indent @_avoid_recursions def dynamic_param_lookup(function_value, param_index): """ A dynamic search for param values. If you try to complete a type: >>> def func(foo): ... foo >>> func(1) >>> func("") It is not known what the type ``foo`` without analysing the whole code. You have to look for all calls to ``func`` to find out what ``foo`` possibly is. """ if not function_value.inference_state.do_dynamic_params_search: return NO_VALUES funcdef = function_value.tree_node path = function_value.get_root_context().py__file__() if path is not None and is_stdlib_path(path): # We don't want to search for references in the stdlib. Usually people # don't work with it (except if you are a core maintainer, sorry). # This makes everything slower. Just disable it and run the tests, # you will see the slowdown, especially in 3.6. return NO_VALUES if funcdef.type == 'lambdef': string_name = _get_lambda_name(funcdef) if string_name is None: return NO_VALUES else: string_name = funcdef.name.value debug.dbg('Dynamic param search in %s.', string_name, color='MAGENTA') module_context = function_value.get_root_context() arguments_list = _search_function_arguments(module_context, funcdef, string_name) values = ValueSet.from_sets( get_executed_param_names( function_value, arguments )[param_index].infer() for arguments in arguments_list ) debug.dbg('Dynamic param result finished', color='MAGENTA') return values @inference_state_method_cache(default=None) @to_list def _search_function_arguments(module_context, funcdef, string_name): """ Returns a list of param names. """ compare_node = funcdef if string_name == '__init__': cls = get_parent_scope(funcdef) if cls.type == 'classdef': string_name = cls.name.value compare_node = cls found_arguments = False i = 0 inference_state = module_context.inference_state if settings.dynamic_params_for_other_modules: module_contexts = get_module_contexts_containing_name( inference_state, [module_context], string_name, # Limit the amounts of files to be opened massively. limit_reduction=5, ) else: module_contexts = [module_context] for for_mod_context in module_contexts: for name, trailer in _get_potential_nodes(for_mod_context, string_name): i += 1 # This is a simple way to stop Jedi's dynamic param recursion # from going wild: The deeper Jedi's in the recursion, the less # code should be inferred. if i * inference_state.dynamic_params_depth > MAX_PARAM_SEARCHES: return random_context = for_mod_context.create_context(name) for arguments in _check_name_for_execution( inference_state, random_context, compare_node, name, trailer): found_arguments = True yield arguments # If there are results after processing a module, we're probably # good to process. This is a speed optimization. if found_arguments: return def _get_lambda_name(node): stmt = node.parent if stmt.type == 'expr_stmt': first_operator = next(stmt.yield_operators(), None) if first_operator == '=': first = stmt.children[0] if first.type == 'name': return first.value return None def _get_potential_nodes(module_value, func_string_name): try: names = module_value.tree_node.get_used_names()[func_string_name] except KeyError: return for name in names: bracket = name.get_next_leaf() trailer = bracket.parent if trailer.type == 'trailer' and bracket == '(': yield name, trailer def _check_name_for_execution(inference_state, context, compare_node, name, trailer): from jedi.inference.value.function import BaseFunctionExecutionContext def create_args(value): arglist = trailer.children[1] if arglist == ')': arglist = None args = TreeArguments(inference_state, context, arglist, trailer) from jedi.inference.value.instance import InstanceArguments if value.tree_node.type == 'classdef': created_instance = instance.TreeInstance( inference_state, value.parent_context, value, args ) return InstanceArguments(created_instance, args) else: if value.is_bound_method(): args = InstanceArguments(value.instance, args) return args for value in inference_state.infer(context, name): value_node = value.tree_node if compare_node == value_node: yield create_args(value) elif isinstance(value.parent_context, BaseFunctionExecutionContext) \ and compare_node.type == 'funcdef': # Here we're trying to find decorators by checking the first # parameter. It's not very generic though. Should find a better # solution that also applies to nested decorators. param_names = value.parent_context.get_param_names() if len(param_names) != 1: continue values = param_names[0].infer() if [v.tree_node for v in values] == [compare_node]: # Found a decorator. module_context = context.get_root_context() execution_context = value.as_context(create_args(value)) potential_nodes = _get_potential_nodes(module_context, param_names[0].string_name) for name, trailer in potential_nodes: if value_node.start_pos < name.start_pos < value_node.end_pos: random_context = execution_context.create_context(name) yield from _check_name_for_execution( inference_state, random_context, compare_node, name, trailer ) ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/jedi/inference/filters.py0000664000175000017500000003031500000000000017275 0ustar00davedave00000000000000""" Filters are objects that you can use to filter names in different scopes. They are needed for name resolution. """ from abc import abstractmethod from typing import List, MutableMapping, Type import weakref from parso.tree import search_ancestor from parso.python.tree import Name, UsedNamesMapping from jedi.inference import flow_analysis from jedi.inference.base_value import ValueSet, ValueWrapper, \ LazyValueWrapper from jedi.parser_utils import get_cached_parent_scope, get_parso_cache_node from jedi.inference.utils import to_list from jedi.inference.names import TreeNameDefinition, ParamName, \ AnonymousParamName, AbstractNameDefinition, NameWrapper _definition_name_cache: MutableMapping[UsedNamesMapping, List[Name]] _definition_name_cache = weakref.WeakKeyDictionary() class AbstractFilter: _until_position = None def _filter(self, names): if self._until_position is not None: return [n for n in names if n.start_pos < self._until_position] return names @abstractmethod def get(self, name): raise NotImplementedError @abstractmethod def values(self): raise NotImplementedError class FilterWrapper: name_wrapper_class: Type[NameWrapper] def __init__(self, wrapped_filter): self._wrapped_filter = wrapped_filter def wrap_names(self, names): return [self.name_wrapper_class(name) for name in names] def get(self, name): return self.wrap_names(self._wrapped_filter.get(name)) def values(self): return self.wrap_names(self._wrapped_filter.values()) def _get_definition_names(parso_cache_node, used_names, name_key): if parso_cache_node is None: names = used_names.get(name_key, ()) return tuple(name for name in names if name.is_definition(include_setitem=True)) try: for_module = _definition_name_cache[parso_cache_node] except KeyError: for_module = _definition_name_cache[parso_cache_node] = {} try: return for_module[name_key] except KeyError: names = used_names.get(name_key, ()) result = for_module[name_key] = tuple( name for name in names if name.is_definition(include_setitem=True) ) return result class _AbstractUsedNamesFilter(AbstractFilter): name_class = TreeNameDefinition def __init__(self, parent_context, node_context=None): if node_context is None: node_context = parent_context self._node_context = node_context self._parser_scope = node_context.tree_node module_context = node_context.get_root_context() # It is quite hacky that we have to use that. This is for caching # certain things with a WeakKeyDictionary. However, parso intentionally # uses slots (to save memory) and therefore we end up with having to # have a weak reference to the object that caches the tree. # # Previously we have tried to solve this by using a weak reference onto # used_names. However that also does not work, because it has a # reference from the module, which itself is referenced by any node # through parents. path = module_context.py__file__() if path is None: # If the path is None, there is no guarantee that parso caches it. self._parso_cache_node = None else: self._parso_cache_node = get_parso_cache_node( module_context.inference_state.latest_grammar if module_context.is_stub() else module_context.inference_state.grammar, path ) self._used_names = module_context.tree_node.get_used_names() self.parent_context = parent_context def get(self, name): return self._convert_names(self._filter( _get_definition_names(self._parso_cache_node, self._used_names, name), )) def _convert_names(self, names): return [self.name_class(self.parent_context, name) for name in names] def values(self): return self._convert_names( name for name_key in self._used_names for name in self._filter( _get_definition_names(self._parso_cache_node, self._used_names, name_key), ) ) def __repr__(self): return '<%s: %s>' % (self.__class__.__name__, self.parent_context) class ParserTreeFilter(_AbstractUsedNamesFilter): def __init__(self, parent_context, node_context=None, until_position=None, origin_scope=None): """ node_context is an option to specify a second value for use cases like the class mro where the parent class of a new name would be the value, but for some type inference it's important to have a local value of the other classes. """ super().__init__(parent_context, node_context) self._origin_scope = origin_scope self._until_position = until_position def _filter(self, names): names = super()._filter(names) names = [n for n in names if self._is_name_reachable(n)] return list(self._check_flows(names)) def _is_name_reachable(self, name): parent = name.parent if parent.type == 'trailer': return False base_node = parent if parent.type in ('classdef', 'funcdef') else name return get_cached_parent_scope(self._parso_cache_node, base_node) == self._parser_scope def _check_flows(self, names): for name in sorted(names, key=lambda name: name.start_pos, reverse=True): check = flow_analysis.reachability_check( context=self._node_context, value_scope=self._parser_scope, node=name, origin_scope=self._origin_scope ) if check is not flow_analysis.UNREACHABLE: yield name if check is flow_analysis.REACHABLE: break class _FunctionExecutionFilter(ParserTreeFilter): def __init__(self, parent_context, function_value, until_position, origin_scope): super().__init__( parent_context, until_position=until_position, origin_scope=origin_scope, ) self._function_value = function_value def _convert_param(self, param, name): raise NotImplementedError @to_list def _convert_names(self, names): for name in names: param = search_ancestor(name, 'param') # Here we don't need to check if the param is a default/annotation, # because those are not definitions and never make it to this # point. if param: yield self._convert_param(param, name) else: yield TreeNameDefinition(self.parent_context, name) class FunctionExecutionFilter(_FunctionExecutionFilter): def __init__(self, *args, arguments, **kwargs): super().__init__(*args, **kwargs) self._arguments = arguments def _convert_param(self, param, name): return ParamName(self._function_value, name, self._arguments) class AnonymousFunctionExecutionFilter(_FunctionExecutionFilter): def _convert_param(self, param, name): return AnonymousParamName(self._function_value, name) class GlobalNameFilter(_AbstractUsedNamesFilter): def get(self, name): try: names = self._used_names[name] except KeyError: return [] return self._convert_names(self._filter(names)) @to_list def _filter(self, names): for name in names: if name.parent.type == 'global_stmt': yield name def values(self): return self._convert_names( name for name_list in self._used_names.values() for name in self._filter(name_list) ) class DictFilter(AbstractFilter): def __init__(self, dct): self._dct = dct def get(self, name): try: value = self._convert(name, self._dct[name]) except KeyError: return [] else: return list(self._filter([value])) def values(self): def yielder(): for item in self._dct.items(): try: yield self._convert(*item) except KeyError: pass return self._filter(yielder()) def _convert(self, name, value): return value def __repr__(self): keys = ', '.join(self._dct.keys()) return '<%s: for {%s}>' % (self.__class__.__name__, keys) class MergedFilter: def __init__(self, *filters): self._filters = filters def get(self, name): return [n for filter in self._filters for n in filter.get(name)] def values(self): return [n for filter in self._filters for n in filter.values()] def __repr__(self): return '%s(%s)' % (self.__class__.__name__, ', '.join(str(f) for f in self._filters)) class _BuiltinMappedMethod(ValueWrapper): """``Generator.__next__`` ``dict.values`` methods and so on.""" api_type = 'function' def __init__(self, value, method, builtin_func): super().__init__(builtin_func) self._value = value self._method = method def py__call__(self, arguments): # TODO add TypeError if params are given/or not correct. return self._method(self._value, arguments) class SpecialMethodFilter(DictFilter): """ A filter for methods that are defined in this module on the corresponding classes like Generator (for __next__, etc). """ class SpecialMethodName(AbstractNameDefinition): api_type = 'function' def __init__(self, parent_context, string_name, callable_, builtin_value): self.parent_context = parent_context self.string_name = string_name self._callable = callable_ self._builtin_value = builtin_value def infer(self): for filter in self._builtin_value.get_filters(): # We can take the first index, because on builtin methods there's # always only going to be one name. The same is true for the # inferred values. for name in filter.get(self.string_name): builtin_func = next(iter(name.infer())) break else: continue break return ValueSet([ _BuiltinMappedMethod(self.parent_context, self._callable, builtin_func) ]) def __init__(self, value, dct, builtin_value): super().__init__(dct) self.value = value self._builtin_value = builtin_value """ This value is what will be used to introspect the name, where as the other value will be used to execute the function. We distinguish, because we have to. """ def _convert(self, name, value): return self.SpecialMethodName(self.value, name, value, self._builtin_value) class _OverwriteMeta(type): def __init__(cls, name, bases, dct): super().__init__(name, bases, dct) base_dct = {} for base_cls in reversed(cls.__bases__): try: base_dct.update(base_cls.overwritten_methods) except AttributeError: pass for func in cls.__dict__.values(): try: base_dct.update(func.registered_overwritten_methods) except AttributeError: pass cls.overwritten_methods = base_dct class _AttributeOverwriteMixin: def get_filters(self, *args, **kwargs): yield SpecialMethodFilter(self, self.overwritten_methods, self._wrapped_value) yield from self._wrapped_value.get_filters(*args, **kwargs) class LazyAttributeOverwrite(_AttributeOverwriteMixin, LazyValueWrapper, metaclass=_OverwriteMeta): def __init__(self, inference_state): self.inference_state = inference_state class AttributeOverwrite(_AttributeOverwriteMixin, ValueWrapper, metaclass=_OverwriteMeta): pass def publish_method(method_name): def decorator(func): dct = func.__dict__.setdefault('registered_overwritten_methods', {}) dct[method_name] = func return func return decorator ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/jedi/inference/finder.py0000664000175000017500000001231600000000000017075 0ustar00davedave00000000000000""" Searching for names with given scope and name. This is very central in Jedi and Python. The name resolution is quite complicated with descripter, ``__getattribute__``, ``__getattr__``, ``global``, etc. If you want to understand name resolution, please read the first few chapters in http://blog.ionelmc.ro/2015/02/09/understanding-python-metaclasses/. Flow checks +++++++++++ Flow checks are not really mature. There's only a check for ``isinstance``. It would check whether a flow has the form of ``if isinstance(a, type_or_tuple)``. Unfortunately every other thing is being ignored (e.g. a == '' would be easy to check for -> a is a string). There's big potential in these checks. """ from parso.tree import search_ancestor from parso.python.tree import Name from jedi import settings from jedi.inference.arguments import TreeArguments from jedi.inference.value import iterable from jedi.inference.base_value import NO_VALUES from jedi.parser_utils import is_scope def filter_name(filters, name_or_str): """ Searches names that are defined in a scope (the different ``filters``), until a name fits. """ string_name = name_or_str.value if isinstance(name_or_str, Name) else name_or_str names = [] for filter in filters: names = filter.get(string_name) if names: break return list(_remove_del_stmt(names)) def _remove_del_stmt(names): # Catch del statements and remove them from results. for name in names: if name.tree_name is not None: definition = name.tree_name.get_definition() if definition is not None and definition.type == 'del_stmt': continue yield name def check_flow_information(value, flow, search_name, pos): """ Try to find out the type of a variable just with the information that is given by the flows: e.g. It is also responsible for assert checks.:: if isinstance(k, str): k. # <- completion here ensures that `k` is a string. """ if not settings.dynamic_flow_information: return None result = None if is_scope(flow): # Check for asserts. module_node = flow.get_root_node() try: names = module_node.get_used_names()[search_name.value] except KeyError: return None names = reversed([ n for n in names if flow.start_pos <= n.start_pos < (pos or flow.end_pos) ]) for name in names: ass = search_ancestor(name, 'assert_stmt') if ass is not None: result = _check_isinstance_type(value, ass.assertion, search_name) if result is not None: return result if flow.type in ('if_stmt', 'while_stmt'): potential_ifs = [c for c in flow.children[1::4] if c != ':'] for if_test in reversed(potential_ifs): if search_name.start_pos > if_test.end_pos: return _check_isinstance_type(value, if_test, search_name) return result def _get_isinstance_trailer_arglist(node): if node.type in ('power', 'atom_expr') and len(node.children) == 2: # This might be removed if we analyze and, etc first, trailer = node.children if first.type == 'name' and first.value == 'isinstance' \ and trailer.type == 'trailer' and trailer.children[0] == '(': return trailer return None def _check_isinstance_type(value, node, search_name): lazy_cls = None trailer = _get_isinstance_trailer_arglist(node) if trailer is not None and len(trailer.children) == 3: arglist = trailer.children[1] args = TreeArguments(value.inference_state, value, arglist, trailer) param_list = list(args.unpack()) # Disallow keyword arguments if len(param_list) == 2 and len(arglist.children) == 3: (key1, _), (key2, lazy_value_cls) = param_list if key1 is None and key2 is None: call = _get_call_string(search_name) is_instance_call = _get_call_string(arglist.children[0]) # Do a simple get_code comparison of the strings . They should # just have the same code, and everything will be all right. # There are ways that this is not correct, if some stuff is # redefined in between. However here we don't care, because # it's a heuristic that works pretty well. if call == is_instance_call: lazy_cls = lazy_value_cls if lazy_cls is None: return None value_set = NO_VALUES for cls_or_tup in lazy_cls.infer(): if isinstance(cls_or_tup, iterable.Sequence) and cls_or_tup.array_type == 'tuple': for lazy_value in cls_or_tup.py__iter__(): value_set |= lazy_value.infer().execute_with_values() else: value_set |= cls_or_tup.execute_with_values() return value_set def _get_call_string(node): if node.parent.type == 'atom_expr': return _get_call_string(node.parent) code = '' leaf = node.get_first_leaf() end = node.get_last_leaf().end_pos while leaf.start_pos < end: code += leaf.value leaf = leaf.get_next_leaf() return code ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/jedi/inference/flow_analysis.py0000664000175000017500000001074700000000000020506 0ustar00davedave00000000000000from typing import Dict, Optional from jedi.parser_utils import get_flow_branch_keyword, is_scope, get_parent_scope from jedi.inference.recursion import execution_allowed from jedi.inference.helpers import is_big_annoying_library class Status: lookup_table: Dict[Optional[bool], 'Status'] = {} def __init__(self, value: Optional[bool], name: str) -> None: self._value = value self._name = name Status.lookup_table[value] = self def invert(self): if self is REACHABLE: return UNREACHABLE elif self is UNREACHABLE: return REACHABLE else: return UNSURE def __and__(self, other): if UNSURE in (self, other): return UNSURE else: return REACHABLE if self._value and other._value else UNREACHABLE def __repr__(self): return '<%s: %s>' % (type(self).__name__, self._name) REACHABLE = Status(True, 'reachable') UNREACHABLE = Status(False, 'unreachable') UNSURE = Status(None, 'unsure') def _get_flow_scopes(node): while True: node = get_parent_scope(node, include_flows=True) if node is None or is_scope(node): return yield node def reachability_check(context, value_scope, node, origin_scope=None): if is_big_annoying_library(context) \ or not context.inference_state.flow_analysis_enabled: return UNSURE first_flow_scope = get_parent_scope(node, include_flows=True) if origin_scope is not None: origin_flow_scopes = list(_get_flow_scopes(origin_scope)) node_flow_scopes = list(_get_flow_scopes(node)) branch_matches = True for flow_scope in origin_flow_scopes: if flow_scope in node_flow_scopes: node_keyword = get_flow_branch_keyword(flow_scope, node) origin_keyword = get_flow_branch_keyword(flow_scope, origin_scope) branch_matches = node_keyword == origin_keyword if flow_scope.type == 'if_stmt': if not branch_matches: return UNREACHABLE elif flow_scope.type == 'try_stmt': if not branch_matches and origin_keyword == 'else' \ and node_keyword == 'except': return UNREACHABLE if branch_matches: break # Direct parents get resolved, we filter scopes that are separate # branches. This makes sense for autocompletion and static analysis. # For actual Python it doesn't matter, because we're talking about # potentially unreachable code. # e.g. `if 0:` would cause all name lookup within the flow make # unaccessible. This is not a "problem" in Python, because the code is # never called. In Jedi though, we still want to infer types. while origin_scope is not None: if first_flow_scope == origin_scope and branch_matches: return REACHABLE origin_scope = origin_scope.parent return _break_check(context, value_scope, first_flow_scope, node) def _break_check(context, value_scope, flow_scope, node): reachable = REACHABLE if flow_scope.type == 'if_stmt': if flow_scope.is_node_after_else(node): for check_node in flow_scope.get_test_nodes(): reachable = _check_if(context, check_node) if reachable in (REACHABLE, UNSURE): break reachable = reachable.invert() else: flow_node = flow_scope.get_corresponding_test_node(node) if flow_node is not None: reachable = _check_if(context, flow_node) elif flow_scope.type in ('try_stmt', 'while_stmt'): return UNSURE # Only reachable branches need to be examined further. if reachable in (UNREACHABLE, UNSURE): return reachable if value_scope != flow_scope and value_scope != flow_scope.parent: flow_scope = get_parent_scope(flow_scope, include_flows=True) return reachable & _break_check(context, value_scope, flow_scope, node) else: return reachable def _check_if(context, node): with execution_allowed(context.inference_state, node) as allowed: if not allowed: return UNSURE types = context.infer_node(node) values = set(x.py__bool__() for x in types) if len(values) == 1: return Status.lookup_table[values.pop()] else: return UNSURE ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.3903792 jedi-0.19.1/jedi/inference/gradual/0000775000175000017500000000000000000000000016670 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/jedi/inference/gradual/__init__.py0000664000175000017500000000021700000000000021001 0ustar00davedave00000000000000""" It is unfortunately not well documented how stubs and annotations work in Jedi. If somebody needs an introduction, please let me know. """ ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/jedi/inference/gradual/annotation.py0000664000175000017500000003731400000000000021424 0ustar00davedave00000000000000""" PEP 0484 ( https://www.python.org/dev/peps/pep-0484/ ) describes type hints through function annotations. There is a strong suggestion in this document that only the type of type hinting defined in PEP0484 should be allowed as annotations in future python versions. """ import re from inspect import Parameter from parso import ParserSyntaxError, parse from jedi.inference.cache import inference_state_method_cache from jedi.inference.base_value import ValueSet, NO_VALUES from jedi.inference.gradual.base import DefineGenericBaseClass, GenericClass from jedi.inference.gradual.generics import TupleGenericManager from jedi.inference.gradual.type_var import TypeVar from jedi.inference.helpers import is_string from jedi.inference.compiled import builtin_from_name from jedi.inference.param import get_executed_param_names from jedi import debug from jedi import parser_utils def infer_annotation(context, annotation): """ Inferes an annotation node. This means that it inferes the part of `int` here: foo: int = 3 Also checks for forward references (strings) """ value_set = context.infer_node(annotation) if len(value_set) != 1: debug.warning("Inferred typing index %s should lead to 1 object, " " not %s" % (annotation, value_set)) return value_set inferred_value = list(value_set)[0] if is_string(inferred_value): result = _get_forward_reference_node(context, inferred_value.get_safe_value()) if result is not None: return context.infer_node(result) return value_set def _infer_annotation_string(context, string, index=None): node = _get_forward_reference_node(context, string) if node is None: return NO_VALUES value_set = context.infer_node(node) if index is not None: value_set = value_set.filter( lambda value: ( value.array_type == 'tuple' and len(list(value.py__iter__())) >= index ) ).py__simple_getitem__(index) return value_set def _get_forward_reference_node(context, string): try: new_node = context.inference_state.grammar.parse( string, start_symbol='eval_input', error_recovery=False ) except ParserSyntaxError: debug.warning('Annotation not parsed: %s' % string) return None else: module = context.tree_node.get_root_node() parser_utils.move(new_node, module.end_pos[0]) new_node.parent = context.tree_node return new_node def _split_comment_param_declaration(decl_text): """ Split decl_text on commas, but group generic expressions together. For example, given "foo, Bar[baz, biz]" we return ['foo', 'Bar[baz, biz]']. """ try: node = parse(decl_text, error_recovery=False).children[0] except ParserSyntaxError: debug.warning('Comment annotation is not valid Python: %s' % decl_text) return [] if node.type in ['name', 'atom_expr', 'power']: return [node.get_code().strip()] params = [] try: children = node.children except AttributeError: return [] else: for child in children: if child.type in ['name', 'atom_expr', 'power']: params.append(child.get_code().strip()) return params @inference_state_method_cache() def infer_param(function_value, param, ignore_stars=False): values = _infer_param(function_value, param) if ignore_stars or not values: return values inference_state = function_value.inference_state if param.star_count == 1: tuple_ = builtin_from_name(inference_state, 'tuple') return ValueSet([GenericClass( tuple_, TupleGenericManager((values,)), )]) elif param.star_count == 2: dct = builtin_from_name(inference_state, 'dict') generics = ( ValueSet([builtin_from_name(inference_state, 'str')]), values ) return ValueSet([GenericClass( dct, TupleGenericManager(generics), )]) return values def _infer_param(function_value, param): """ Infers the type of a function parameter, using type annotations. """ annotation = param.annotation if annotation is None: # If no Python 3-style annotation, look for a comment annotation. # Identify parameters to function in the same sequence as they would # appear in a type comment. all_params = [child for child in param.parent.children if child.type == 'param'] node = param.parent.parent comment = parser_utils.get_following_comment_same_line(node) if comment is None: return NO_VALUES match = re.match(r"^#\s*type:\s*\(([^#]*)\)\s*->", comment) if not match: return NO_VALUES params_comments = _split_comment_param_declaration(match.group(1)) # Find the specific param being investigated index = all_params.index(param) # If the number of parameters doesn't match length of type comment, # ignore first parameter (assume it's self). if len(params_comments) != len(all_params): debug.warning( "Comments length != Params length %s %s", params_comments, all_params ) if function_value.is_bound_method(): if index == 0: # Assume it's self, which is already handled return NO_VALUES index -= 1 if index >= len(params_comments): return NO_VALUES param_comment = params_comments[index] return _infer_annotation_string( function_value.get_default_param_context(), param_comment ) # Annotations are like default params and resolve in the same way. context = function_value.get_default_param_context() return infer_annotation(context, annotation) def py__annotations__(funcdef): dct = {} for function_param in funcdef.get_params(): param_annotation = function_param.annotation if param_annotation is not None: dct[function_param.name.value] = param_annotation return_annotation = funcdef.annotation if return_annotation: dct['return'] = return_annotation return dct def resolve_forward_references(context, all_annotations): def resolve(node): if node is None or node.type != 'string': return node node = _get_forward_reference_node( context, context.inference_state.compiled_subprocess.safe_literal_eval( node.value, ), ) if node is None: # There was a string, but it's not a valid annotation return None # The forward reference tree has an additional root node ('eval_input') # that we don't want. Extract the node we do want, that is equivalent to # the nodes returned by `py__annotations__` for a non-quoted node. node = node.children[0] return node return {name: resolve(node) for name, node in all_annotations.items()} @inference_state_method_cache() def infer_return_types(function, arguments): """ Infers the type of a function's return value, according to type annotations. """ context = function.get_default_param_context() all_annotations = resolve_forward_references( context, py__annotations__(function.tree_node), ) annotation = all_annotations.get("return", None) if annotation is None: # If there is no Python 3-type annotation, look for an annotation # comment. node = function.tree_node comment = parser_utils.get_following_comment_same_line(node) if comment is None: return NO_VALUES match = re.match(r"^#\s*type:\s*\([^#]*\)\s*->\s*([^#]*)", comment) if not match: return NO_VALUES return _infer_annotation_string( context, match.group(1).strip() ).execute_annotation() unknown_type_vars = find_unknown_type_vars(context, annotation) annotation_values = infer_annotation(context, annotation) if not unknown_type_vars: return annotation_values.execute_annotation() type_var_dict = infer_type_vars_for_execution(function, arguments, all_annotations) return ValueSet.from_sets( ann.define_generics(type_var_dict) if isinstance(ann, (DefineGenericBaseClass, TypeVar)) else ValueSet({ann}) for ann in annotation_values ).execute_annotation() def infer_type_vars_for_execution(function, arguments, annotation_dict): """ Some functions use type vars that are not defined by the class, but rather only defined in the function. See for example `iter`. In those cases we want to: 1. Search for undefined type vars. 2. Infer type vars with the execution state we have. 3. Return the union of all type vars that have been found. """ context = function.get_default_param_context() annotation_variable_results = {} executed_param_names = get_executed_param_names(function, arguments) for executed_param_name in executed_param_names: try: annotation_node = annotation_dict[executed_param_name.string_name] except KeyError: continue annotation_variables = find_unknown_type_vars(context, annotation_node) if annotation_variables: # Infer unknown type var annotation_value_set = context.infer_node(annotation_node) kind = executed_param_name.get_kind() actual_value_set = executed_param_name.infer() if kind is Parameter.VAR_POSITIONAL: actual_value_set = actual_value_set.merge_types_of_iterate() elif kind is Parameter.VAR_KEYWORD: # TODO _dict_values is not public. actual_value_set = actual_value_set.try_merge('_dict_values') merge_type_var_dicts( annotation_variable_results, annotation_value_set.infer_type_vars(actual_value_set), ) return annotation_variable_results def infer_return_for_callable(arguments, param_values, result_values): all_type_vars = {} for pv in param_values: if pv.array_type == 'list': type_var_dict = _infer_type_vars_for_callable(arguments, pv.py__iter__()) all_type_vars.update(type_var_dict) return ValueSet.from_sets( v.define_generics(all_type_vars) if isinstance(v, (DefineGenericBaseClass, TypeVar)) else ValueSet({v}) for v in result_values ).execute_annotation() def _infer_type_vars_for_callable(arguments, lazy_params): """ Infers type vars for the Calllable class: def x() -> Callable[[Callable[..., _T]], _T]: ... """ annotation_variable_results = {} for (_, lazy_value), lazy_callable_param in zip(arguments.unpack(), lazy_params): callable_param_values = lazy_callable_param.infer() # Infer unknown type var actual_value_set = lazy_value.infer() merge_type_var_dicts( annotation_variable_results, callable_param_values.infer_type_vars(actual_value_set), ) return annotation_variable_results def merge_type_var_dicts(base_dict, new_dict): for type_var_name, values in new_dict.items(): if values: try: base_dict[type_var_name] |= values except KeyError: base_dict[type_var_name] = values def merge_pairwise_generics(annotation_value, annotated_argument_class): """ Match up the generic parameters from the given argument class to the target annotation. This walks the generic parameters immediately within the annotation and argument's type, in order to determine the concrete values of the annotation's parameters for the current case. For example, given the following code: def values(mapping: Mapping[K, V]) -> List[V]: ... for val in values({1: 'a'}): val Then this function should be given representations of `Mapping[K, V]` and `Mapping[int, str]`, so that it can determine that `K` is `int and `V` is `str`. Note that it is responsibility of the caller to traverse the MRO of the argument type as needed in order to find the type matching the annotation (in this case finding `Mapping[int, str]` as a parent of `Dict[int, str]`). Parameters ---------- `annotation_value`: represents the annotation to infer the concrete parameter types of. `annotated_argument_class`: represents the annotated class of the argument being passed to the object annotated by `annotation_value`. """ type_var_dict = {} if not isinstance(annotated_argument_class, DefineGenericBaseClass): return type_var_dict annotation_generics = annotation_value.get_generics() actual_generics = annotated_argument_class.get_generics() for annotation_generics_set, actual_generic_set in zip(annotation_generics, actual_generics): merge_type_var_dicts( type_var_dict, annotation_generics_set.infer_type_vars(actual_generic_set.execute_annotation()), ) return type_var_dict def find_type_from_comment_hint_for(context, node, name): return _find_type_from_comment_hint(context, node, node.children[1], name) def find_type_from_comment_hint_with(context, node, name): if len(node.children) > 4: # In case there are multiple with_items, we do not want a type hint for # now. return [] assert len(node.children[1].children) == 3, \ "Can only be here when children[1] is 'foo() as f'" varlist = node.children[1].children[2] return _find_type_from_comment_hint(context, node, varlist, name) def find_type_from_comment_hint_assign(context, node, name): return _find_type_from_comment_hint(context, node, node.children[0], name) def _find_type_from_comment_hint(context, node, varlist, name): index = None if varlist.type in ("testlist_star_expr", "exprlist", "testlist"): # something like "a, b = 1, 2" index = 0 for child in varlist.children: if child == name: break if child.type == "operator": continue index += 1 else: return [] comment = parser_utils.get_following_comment_same_line(node) if comment is None: return [] match = re.match(r"^#\s*type:\s*([^#]*)", comment) if match is None: return [] return _infer_annotation_string( context, match.group(1).strip(), index ).execute_annotation() def find_unknown_type_vars(context, node): def check_node(node): if node.type in ('atom_expr', 'power'): trailer = node.children[-1] if trailer.type == 'trailer' and trailer.children[0] == '[': for subscript_node in _unpack_subscriptlist(trailer.children[1]): check_node(subscript_node) else: found[:] = _filter_type_vars(context.infer_node(node), found) found = [] # We're not using a set, because the order matters. check_node(node) return found def _filter_type_vars(value_set, found=()): new_found = list(found) for type_var in value_set: if isinstance(type_var, TypeVar) and type_var not in found: new_found.append(type_var) return new_found def _unpack_subscriptlist(subscriptlist): if subscriptlist.type == 'subscriptlist': for subscript in subscriptlist.children[::2]: if subscript.type != 'subscript': yield subscript else: if subscriptlist.type != 'subscript': yield subscriptlist ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/jedi/inference/gradual/base.py0000664000175000017500000003630200000000000020160 0ustar00davedave00000000000000from jedi.inference.cache import inference_state_method_cache from jedi.inference.base_value import ValueSet, NO_VALUES, Value, \ iterator_to_value_set, LazyValueWrapper, ValueWrapper from jedi.inference.compiled import builtin_from_name from jedi.inference.value.klass import ClassFilter from jedi.inference.value.klass import ClassMixin from jedi.inference.utils import to_list from jedi.inference.names import AbstractNameDefinition, ValueName from jedi.inference.context import ClassContext from jedi.inference.gradual.generics import TupleGenericManager class _BoundTypeVarName(AbstractNameDefinition): """ This type var was bound to a certain type, e.g. int. """ def __init__(self, type_var, value_set): self._type_var = type_var self.parent_context = type_var.parent_context self._value_set = value_set def infer(self): def iter_(): for value in self._value_set: # Replace any with the constraints if they are there. from jedi.inference.gradual.typing import AnyClass if isinstance(value, AnyClass): yield from self._type_var.constraints else: yield value return ValueSet(iter_()) def py__name__(self): return self._type_var.py__name__() def __repr__(self): return '<%s %s -> %s>' % (self.__class__.__name__, self.py__name__(), self._value_set) class _TypeVarFilter: """ A filter for all given variables in a class. A = TypeVar('A') B = TypeVar('B') class Foo(Mapping[A, B]): ... In this example we would have two type vars given: A and B """ def __init__(self, generics, type_vars): self._generics = generics self._type_vars = type_vars def get(self, name): for i, type_var in enumerate(self._type_vars): if type_var.py__name__() == name: try: return [_BoundTypeVarName(type_var, self._generics[i])] except IndexError: return [type_var.name] return [] def values(self): # The values are not relevant. If it's not searched exactly, the type # vars are just global and should be looked up as that. return [] class _AnnotatedClassContext(ClassContext): def get_filters(self, *args, **kwargs): filters = super().get_filters( *args, **kwargs ) yield from filters # The type vars can only be looked up if it's a global search and # not a direct lookup on the class. yield self._value.get_type_var_filter() class DefineGenericBaseClass(LazyValueWrapper): def __init__(self, generics_manager): self._generics_manager = generics_manager def _create_instance_with_generics(self, generics_manager): raise NotImplementedError @inference_state_method_cache() def get_generics(self): return self._generics_manager.to_tuple() def define_generics(self, type_var_dict): from jedi.inference.gradual.type_var import TypeVar changed = False new_generics = [] for generic_set in self.get_generics(): values = NO_VALUES for generic in generic_set: if isinstance(generic, (DefineGenericBaseClass, TypeVar)): result = generic.define_generics(type_var_dict) values |= result if result != ValueSet({generic}): changed = True else: values |= ValueSet([generic]) new_generics.append(values) if not changed: # There might not be any type vars that change. In that case just # return itself, because it does not make sense to potentially lose # cached results. return ValueSet([self]) return ValueSet([self._create_instance_with_generics( TupleGenericManager(tuple(new_generics)) )]) def is_same_class(self, other): if not isinstance(other, DefineGenericBaseClass): return False if self.tree_node != other.tree_node: # TODO not sure if this is nice. return False given_params1 = self.get_generics() given_params2 = other.get_generics() if len(given_params1) != len(given_params2): # If the amount of type vars doesn't match, the class doesn't # match. return False # Now compare generics return all( any( # TODO why is this ordering the correct one? cls2.is_same_class(cls1) # TODO I'm still not sure gather_annotation_classes is a good # idea. They are essentially here to avoid comparing Tuple <=> # tuple and instead compare tuple <=> tuple, but at the moment # the whole `is_same_class` and `is_sub_class` matching is just # not in the best shape. for cls1 in class_set1.gather_annotation_classes() for cls2 in class_set2.gather_annotation_classes() ) for class_set1, class_set2 in zip(given_params1, given_params2) ) def get_signatures(self): return [] def __repr__(self): return '<%s: %s%s>' % ( self.__class__.__name__, self._wrapped_value, list(self.get_generics()), ) class GenericClass(DefineGenericBaseClass, ClassMixin): """ A class that is defined with generics, might be something simple like: class Foo(Generic[T]): ... my_foo_int_cls = Foo[int] """ def __init__(self, class_value, generics_manager): super().__init__(generics_manager) self._class_value = class_value def _get_wrapped_value(self): return self._class_value def get_type_hint(self, add_class_info=True): n = self.py__name__() # Not sure if this is the best way to do this, but all of these types # are a bit special in that they have type aliases and other ways to # become lower case. It's probably better to make them upper case, # because that's what you can use in annotations. n = dict(list="List", dict="Dict", set="Set", tuple="Tuple").get(n, n) s = n + self._generics_manager.get_type_hint() if add_class_info: return 'Type[%s]' % s return s def get_type_var_filter(self): return _TypeVarFilter(self.get_generics(), self.list_type_vars()) def py__call__(self, arguments): instance, = super().py__call__(arguments) return ValueSet([_GenericInstanceWrapper(instance)]) def _as_context(self): return _AnnotatedClassContext(self) @to_list def py__bases__(self): for base in self._wrapped_value.py__bases__(): yield _LazyGenericBaseClass(self, base, self._generics_manager) def _create_instance_with_generics(self, generics_manager): return GenericClass(self._class_value, generics_manager) def is_sub_class_of(self, class_value): if super().is_sub_class_of(class_value): return True return self._class_value.is_sub_class_of(class_value) def with_generics(self, generics_tuple): return self._class_value.with_generics(generics_tuple) def infer_type_vars(self, value_set): # Circular from jedi.inference.gradual.annotation import merge_pairwise_generics, merge_type_var_dicts annotation_name = self.py__name__() type_var_dict = {} if annotation_name == 'Iterable': annotation_generics = self.get_generics() if annotation_generics: return annotation_generics[0].infer_type_vars( value_set.merge_types_of_iterate(), ) else: # Note: we need to handle the MRO _in order_, so we need to extract # the elements from the set first, then handle them, even if we put # them back in a set afterwards. for py_class in value_set: if py_class.is_instance() and not py_class.is_compiled(): py_class = py_class.get_annotated_class_object() else: continue if py_class.api_type != 'class': # Functions & modules don't have an MRO and we're not # expecting a Callable (those are handled separately within # TypingClassValueWithIndex). continue for parent_class in py_class.py__mro__(): class_name = parent_class.py__name__() if annotation_name == class_name: merge_type_var_dicts( type_var_dict, merge_pairwise_generics(self, parent_class), ) break return type_var_dict class _LazyGenericBaseClass: def __init__(self, class_value, lazy_base_class, generics_manager): self._class_value = class_value self._lazy_base_class = lazy_base_class self._generics_manager = generics_manager @iterator_to_value_set def infer(self): for base in self._lazy_base_class.infer(): if isinstance(base, GenericClass): # Here we have to recalculate the given types. yield GenericClass.create_cached( base.inference_state, base._wrapped_value, TupleGenericManager(tuple(self._remap_type_vars(base))), ) else: if base.is_class_mixin(): # This case basically allows classes like `class Foo(List)` # to be used like `Foo[int]`. The generics are not # necessary and can be used later. yield GenericClass.create_cached( base.inference_state, base, self._generics_manager, ) else: yield base def _remap_type_vars(self, base): from jedi.inference.gradual.type_var import TypeVar filter = self._class_value.get_type_var_filter() for type_var_set in base.get_generics(): new = NO_VALUES for type_var in type_var_set: if isinstance(type_var, TypeVar): names = filter.get(type_var.py__name__()) new |= ValueSet.from_sets( name.infer() for name in names ) else: # Mostly will be type vars, except if in some cases # a concrete type will already be there. In that # case just add it to the value set. new |= ValueSet([type_var]) yield new def __repr__(self): return '<%s: %s>' % (self.__class__.__name__, self._lazy_base_class) class _GenericInstanceWrapper(ValueWrapper): def py__stop_iteration_returns(self): for cls in self._wrapped_value.class_value.py__mro__(): if cls.py__name__() == 'Generator': generics = cls.get_generics() try: return generics[2].execute_annotation() except IndexError: pass elif cls.py__name__() == 'Iterator': return ValueSet([builtin_from_name(self.inference_state, 'None')]) return self._wrapped_value.py__stop_iteration_returns() def get_type_hint(self, add_class_info=True): return self._wrapped_value.class_value.get_type_hint(add_class_info=False) class _PseudoTreeNameClass(Value): """ In typeshed, some classes are defined like this: Tuple: _SpecialForm = ... Now this is not a real class, therefore we have to do some workarounds like this class. Essentially this class makes it possible to goto that `Tuple` name, without affecting anything else negatively. """ api_type = 'class' def __init__(self, parent_context, tree_name): super().__init__( parent_context.inference_state, parent_context ) self._tree_name = tree_name @property def tree_node(self): return self._tree_name def get_filters(self, *args, **kwargs): # TODO this is obviously wrong. Is it though? class EmptyFilter(ClassFilter): def __init__(self): pass def get(self, name, **kwargs): return [] def values(self, **kwargs): return [] yield EmptyFilter() def py__class__(self): # This might not be 100% correct, but it is good enough. The details of # the typing library are not really an issue for Jedi. return builtin_from_name(self.inference_state, 'type') @property def name(self): return ValueName(self, self._tree_name) def get_qualified_names(self): return (self._tree_name.value,) def __repr__(self): return '%s(%s)' % (self.__class__.__name__, self._tree_name.value) class BaseTypingValue(LazyValueWrapper): def __init__(self, parent_context, tree_name): self.inference_state = parent_context.inference_state self.parent_context = parent_context self._tree_name = tree_name @property def name(self): return ValueName(self, self._tree_name) def _get_wrapped_value(self): return _PseudoTreeNameClass(self.parent_context, self._tree_name) def get_signatures(self): return self._wrapped_value.get_signatures() def __repr__(self): return '%s(%s)' % (self.__class__.__name__, self._tree_name.value) class BaseTypingClassWithGenerics(DefineGenericBaseClass): def __init__(self, parent_context, tree_name, generics_manager): super().__init__(generics_manager) self.inference_state = parent_context.inference_state self.parent_context = parent_context self._tree_name = tree_name def _get_wrapped_value(self): return _PseudoTreeNameClass(self.parent_context, self._tree_name) def __repr__(self): return '%s(%s%s)' % (self.__class__.__name__, self._tree_name.value, self._generics_manager) class BaseTypingInstance(LazyValueWrapper): def __init__(self, parent_context, class_value, tree_name, generics_manager): self.inference_state = class_value.inference_state self.parent_context = parent_context self._class_value = class_value self._tree_name = tree_name self._generics_manager = generics_manager def py__class__(self): return self._class_value def get_annotated_class_object(self): return self._class_value def get_qualified_names(self): return (self.py__name__(),) @property def name(self): return ValueName(self, self._tree_name) def _get_wrapped_value(self): object_, = builtin_from_name(self.inference_state, 'object').execute_annotation() return object_ def __repr__(self): return '<%s: %s>' % (self.__class__.__name__, self._generics_manager) ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/jedi/inference/gradual/conversion.py0000664000175000017500000001666100000000000021441 0ustar00davedave00000000000000from jedi import debug from jedi.inference.base_value import ValueSet, \ NO_VALUES from jedi.inference.utils import to_list from jedi.inference.gradual.stub_value import StubModuleValue from jedi.inference.gradual.typeshed import try_to_load_stub_cached from jedi.inference.value.decorator import Decoratee def _stub_to_python_value_set(stub_value, ignore_compiled=False): stub_module_context = stub_value.get_root_context() if not stub_module_context.is_stub(): return ValueSet([stub_value]) decorates = None if isinstance(stub_value, Decoratee): decorates = stub_value._original_value was_instance = stub_value.is_instance() if was_instance: arguments = getattr(stub_value, '_arguments', None) stub_value = stub_value.py__class__() qualified_names = stub_value.get_qualified_names() if qualified_names is None: return NO_VALUES was_bound_method = stub_value.is_bound_method() if was_bound_method: # Infer the object first. We can infer the method later. method_name = qualified_names[-1] qualified_names = qualified_names[:-1] was_instance = True arguments = None values = _infer_from_stub(stub_module_context, qualified_names, ignore_compiled) if was_instance: values = ValueSet.from_sets( c.execute_with_values() if arguments is None else c.execute(arguments) for c in values if c.is_class() ) if was_bound_method: # Now that the instance has been properly created, we can simply get # the method. values = values.py__getattribute__(method_name) if decorates is not None: values = ValueSet(Decoratee(v, decorates) for v in values) return values def _infer_from_stub(stub_module_context, qualified_names, ignore_compiled): from jedi.inference.compiled.mixed import MixedObject stub_module = stub_module_context.get_value() assert isinstance(stub_module, (StubModuleValue, MixedObject)), stub_module_context non_stubs = stub_module.non_stub_value_set if ignore_compiled: non_stubs = non_stubs.filter(lambda c: not c.is_compiled()) for name in qualified_names: non_stubs = non_stubs.py__getattribute__(name) return non_stubs @to_list def _try_stub_to_python_names(names, prefer_stub_to_compiled=False): for name in names: module_context = name.get_root_context() if not module_context.is_stub(): yield name continue if name.api_type == 'module': values = convert_values(name.infer(), ignore_compiled=prefer_stub_to_compiled) if values: for v in values: yield v.name continue else: v = name.get_defining_qualified_value() if v is not None: converted = _stub_to_python_value_set(v, ignore_compiled=prefer_stub_to_compiled) if converted: converted_names = converted.goto(name.get_public_name()) if converted_names: for n in converted_names: if n.get_root_context().is_stub(): # If it's a stub again, it means we're going in # a circle. Probably some imports make it a # stub again. yield name else: yield n continue yield name def _load_stub_module(module): if module.is_stub(): return module return try_to_load_stub_cached( module.inference_state, import_names=module.string_names, python_value_set=ValueSet([module]), parent_module_value=None, sys_path=module.inference_state.get_sys_path(), ) @to_list def _python_to_stub_names(names, fallback_to_python=False): for name in names: module_context = name.get_root_context() if module_context.is_stub(): yield name continue if name.api_type == 'module': found_name = False for n in name.goto(): if n.api_type == 'module': values = convert_values(n.infer(), only_stubs=True) for v in values: yield v.name found_name = True else: for x in _python_to_stub_names([n], fallback_to_python=fallback_to_python): yield x found_name = True if found_name: continue else: v = name.get_defining_qualified_value() if v is not None: converted = to_stub(v) if converted: converted_names = converted.goto(name.get_public_name()) if converted_names: yield from converted_names continue if fallback_to_python: # This is the part where if we haven't found anything, just return # the stub name. yield name def convert_names(names, only_stubs=False, prefer_stubs=False, prefer_stub_to_compiled=True): if only_stubs and prefer_stubs: raise ValueError("You cannot use both of only_stubs and prefer_stubs.") with debug.increase_indent_cm('convert names'): if only_stubs or prefer_stubs: return _python_to_stub_names(names, fallback_to_python=prefer_stubs) else: return _try_stub_to_python_names( names, prefer_stub_to_compiled=prefer_stub_to_compiled) def convert_values(values, only_stubs=False, prefer_stubs=False, ignore_compiled=True): assert not (only_stubs and prefer_stubs) with debug.increase_indent_cm('convert values'): if only_stubs or prefer_stubs: return ValueSet.from_sets( to_stub(value) or (ValueSet({value}) if prefer_stubs else NO_VALUES) for value in values ) else: return ValueSet.from_sets( _stub_to_python_value_set(stub_value, ignore_compiled=ignore_compiled) or ValueSet({stub_value}) for stub_value in values ) def to_stub(value): if value.is_stub(): return ValueSet([value]) was_instance = value.is_instance() if was_instance: value = value.py__class__() qualified_names = value.get_qualified_names() stub_module = _load_stub_module(value.get_root_context().get_value()) if stub_module is None or qualified_names is None: return NO_VALUES was_bound_method = value.is_bound_method() if was_bound_method: # Infer the object first. We can infer the method later. method_name = qualified_names[-1] qualified_names = qualified_names[:-1] was_instance = True stub_values = ValueSet([stub_module]) for name in qualified_names: stub_values = stub_values.py__getattribute__(name) if was_instance: stub_values = ValueSet.from_sets( c.execute_with_values() for c in stub_values if c.is_class() ) if was_bound_method: # Now that the instance has been properly created, we can simply get # the method. stub_values = stub_values.py__getattribute__(method_name) return stub_values ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/jedi/inference/gradual/generics.py0000664000175000017500000000611000000000000021037 0ustar00davedave00000000000000""" This module is about generics, like the `int` in `List[int]`. It's not about the Generic class. """ from jedi import debug from jedi.cache import memoize_method from jedi.inference.utils import to_tuple from jedi.inference.base_value import ValueSet, NO_VALUES from jedi.inference.value.iterable import SequenceLiteralValue from jedi.inference.helpers import is_string def _resolve_forward_references(context, value_set): for value in value_set: if is_string(value): from jedi.inference.gradual.annotation import _get_forward_reference_node node = _get_forward_reference_node(context, value.get_safe_value()) if node is not None: for c in context.infer_node(node): yield c else: yield value class _AbstractGenericManager: def get_index_and_execute(self, index): try: return self[index].execute_annotation() except IndexError: debug.warning('No param #%s found for annotation %s', index, self) return NO_VALUES def get_type_hint(self): return '[%s]' % ', '.join(t.get_type_hint(add_class_info=False) for t in self.to_tuple()) class LazyGenericManager(_AbstractGenericManager): def __init__(self, context_of_index, index_value): self._context_of_index = context_of_index self._index_value = index_value @memoize_method def __getitem__(self, index): return self._tuple()[index]() def __len__(self): return len(self._tuple()) @memoize_method @to_tuple def _tuple(self): def lambda_scoping_in_for_loop_sucks(lazy_value): return lambda: ValueSet(_resolve_forward_references( self._context_of_index, lazy_value.infer() )) if isinstance(self._index_value, SequenceLiteralValue): for lazy_value in self._index_value.py__iter__(contextualized_node=None): yield lambda_scoping_in_for_loop_sucks(lazy_value) else: yield lambda: ValueSet(_resolve_forward_references( self._context_of_index, ValueSet([self._index_value]) )) @to_tuple def to_tuple(self): for callable_ in self._tuple(): yield callable_() def is_homogenous_tuple(self): if isinstance(self._index_value, SequenceLiteralValue): entries = self._index_value.get_tree_entries() if len(entries) == 2 and entries[1] == '...': return True return False def __repr__(self): return '[%s]' % (', '.join(repr(x) for x in self.to_tuple())) class TupleGenericManager(_AbstractGenericManager): def __init__(self, tup): self._tuple = tup def __getitem__(self, index): return self._tuple[index] def __len__(self): return len(self._tuple) def to_tuple(self): return self._tuple def is_homogenous_tuple(self): return False def __repr__(self): return '[%s]' % (', '.join(repr(x) for x in self.to_tuple())) ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/jedi/inference/gradual/stub_value.py0000664000175000017500000000647100000000000021423 0ustar00davedave00000000000000from jedi.inference.base_value import ValueWrapper from jedi.inference.value.module import ModuleValue from jedi.inference.filters import ParserTreeFilter from jedi.inference.names import StubName, StubModuleName from jedi.inference.gradual.typing import TypingModuleFilterWrapper from jedi.inference.context import ModuleContext class StubModuleValue(ModuleValue): _module_name_class = StubModuleName def __init__(self, non_stub_value_set, *args, **kwargs): super().__init__(*args, **kwargs) self.non_stub_value_set = non_stub_value_set def is_stub(self): return True def sub_modules_dict(self): """ We have to overwrite this, because it's possible to have stubs that don't have code for all the child modules. At the time of writing this there are for example no stubs for `json.tool`. """ names = {} for value in self.non_stub_value_set: try: method = value.sub_modules_dict except AttributeError: pass else: names.update(method()) names.update(super().sub_modules_dict()) return names def _get_stub_filters(self, origin_scope): return [StubFilter( parent_context=self.as_context(), origin_scope=origin_scope )] + list(self.iter_star_filters()) def get_filters(self, origin_scope=None): filters = super().get_filters(origin_scope) next(filters, None) # Ignore the first filter and replace it with our own stub_filters = self._get_stub_filters(origin_scope=origin_scope) yield from stub_filters yield from filters def _as_context(self): return StubModuleContext(self) class StubModuleContext(ModuleContext): def get_filters(self, until_position=None, origin_scope=None): # Make sure to ignore the position, because positions are not relevant # for stubs. return super().get_filters(origin_scope=origin_scope) class TypingModuleWrapper(StubModuleValue): def get_filters(self, *args, **kwargs): filters = super().get_filters(*args, **kwargs) f = next(filters, None) assert f is not None yield TypingModuleFilterWrapper(f) yield from filters def _as_context(self): return TypingModuleContext(self) class TypingModuleContext(ModuleContext): def get_filters(self, *args, **kwargs): filters = super().get_filters(*args, **kwargs) yield TypingModuleFilterWrapper(next(filters, None)) yield from filters class StubFilter(ParserTreeFilter): name_class = StubName def _is_name_reachable(self, name): if not super()._is_name_reachable(name): return False # Imports in stub files are only public if they have an "as" # export. definition = name.get_definition() if definition is None: return False if definition.type in ('import_from', 'import_name'): if name.parent.type not in ('import_as_name', 'dotted_as_name'): return False n = name.value # TODO rewrite direct return if n.startswith('_') and not (n.startswith('__') and n.endswith('__')): return False return True class VersionInfo(ValueWrapper): pass ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/jedi/inference/gradual/type_var.py0000664000175000017500000001005300000000000021072 0ustar00davedave00000000000000from jedi import debug from jedi.inference.base_value import ValueSet, NO_VALUES, ValueWrapper from jedi.inference.gradual.base import BaseTypingValue class TypeVarClass(ValueWrapper): def py__call__(self, arguments): unpacked = arguments.unpack() key, lazy_value = next(unpacked, (None, None)) var_name = self._find_string_name(lazy_value) # The name must be given, otherwise it's useless. if var_name is None or key is not None: debug.warning('Found a variable without a name %s', arguments) return NO_VALUES return ValueSet([TypeVar.create_cached( self.inference_state, self.parent_context, tree_name=self.tree_node.name, var_name=var_name, unpacked_args=unpacked, )]) def _find_string_name(self, lazy_value): if lazy_value is None: return None value_set = lazy_value.infer() if not value_set: return None if len(value_set) > 1: debug.warning('Found multiple values for a type variable: %s', value_set) name_value = next(iter(value_set)) try: method = name_value.get_safe_value except AttributeError: return None else: safe_value = method(default=None) if isinstance(safe_value, str): return safe_value return None class TypeVar(BaseTypingValue): def __init__(self, parent_context, tree_name, var_name, unpacked_args): super().__init__(parent_context, tree_name) self._var_name = var_name self._constraints_lazy_values = [] self._bound_lazy_value = None self._covariant_lazy_value = None self._contravariant_lazy_value = None for key, lazy_value in unpacked_args: if key is None: self._constraints_lazy_values.append(lazy_value) else: if key == 'bound': self._bound_lazy_value = lazy_value elif key == 'covariant': self._covariant_lazy_value = lazy_value elif key == 'contravariant': self._contra_variant_lazy_value = lazy_value else: debug.warning('Invalid TypeVar param name %s', key) def py__name__(self): return self._var_name def get_filters(self, *args, **kwargs): return iter([]) def _get_classes(self): if self._bound_lazy_value is not None: return self._bound_lazy_value.infer() if self._constraints_lazy_values: return self.constraints debug.warning('Tried to infer the TypeVar %s without a given type', self._var_name) return NO_VALUES def is_same_class(self, other): # Everything can match an undefined type var. return True @property def constraints(self): return ValueSet.from_sets( lazy.infer() for lazy in self._constraints_lazy_values ) def define_generics(self, type_var_dict): try: found = type_var_dict[self.py__name__()] except KeyError: pass else: if found: return found return ValueSet({self}) def execute_annotation(self): return self._get_classes().execute_annotation() def infer_type_vars(self, value_set): def iterate(): for v in value_set: cls = v.py__class__() if v.is_function() or v.is_class(): cls = TypeWrapper(cls, v) yield cls annotation_name = self.py__name__() return {annotation_name: ValueSet(iterate())} def __repr__(self): return '<%s: %s>' % (self.__class__.__name__, self.py__name__()) class TypeWrapper(ValueWrapper): def __init__(self, wrapped_value, original_value): super().__init__(wrapped_value) self._original_value = original_value def execute_annotation(self): return ValueSet({self._original_value}) ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/jedi/inference/gradual/typeshed.py0000664000175000017500000002631300000000000021074 0ustar00davedave00000000000000import os import re from functools import wraps from collections import namedtuple from typing import Dict, Mapping, Tuple from pathlib import Path from jedi import settings from jedi.file_io import FileIO from jedi.parser_utils import get_cached_code_lines from jedi.inference.base_value import ValueSet, NO_VALUES from jedi.inference.gradual.stub_value import TypingModuleWrapper, StubModuleValue from jedi.inference.value import ModuleValue _jedi_path = Path(__file__).parent.parent.parent TYPESHED_PATH = _jedi_path.joinpath('third_party', 'typeshed') DJANGO_INIT_PATH = _jedi_path.joinpath('third_party', 'django-stubs', 'django-stubs', '__init__.pyi') _IMPORT_MAP = dict( _collections='collections', _socket='socket', ) PathInfo = namedtuple('PathInfo', 'path is_third_party') def _merge_create_stub_map(path_infos): map_ = {} for directory_path_info in path_infos: map_.update(_create_stub_map(directory_path_info)) return map_ def _create_stub_map(directory_path_info): """ Create a mapping of an importable name in Python to a stub file. """ def generate(): try: listed = os.listdir(directory_path_info.path) except (FileNotFoundError, NotADirectoryError): return for entry in listed: path = os.path.join(directory_path_info.path, entry) if os.path.isdir(path): init = os.path.join(path, '__init__.pyi') if os.path.isfile(init): yield entry, PathInfo(init, directory_path_info.is_third_party) elif entry.endswith('.pyi') and os.path.isfile(path): name = entry[:-4] if name != '__init__': yield name, PathInfo(path, directory_path_info.is_third_party) # Create a dictionary from the tuple generator. return dict(generate()) def _get_typeshed_directories(version_info): check_version_list = ['2and3', '3'] for base in ['stdlib', 'third_party']: base_path = TYPESHED_PATH.joinpath(base) base_list = os.listdir(base_path) for base_list_entry in base_list: match = re.match(r'(\d+)\.(\d+)$', base_list_entry) if match is not None: if match.group(1) == '3' and int(match.group(2)) <= version_info.minor: check_version_list.append(base_list_entry) for check_version in check_version_list: is_third_party = base != 'stdlib' yield PathInfo(str(base_path.joinpath(check_version)), is_third_party) _version_cache: Dict[Tuple[int, int], Mapping[str, PathInfo]] = {} def _cache_stub_file_map(version_info): """ Returns a map of an importable name in Python to a stub file. """ # TODO this caches the stub files indefinitely, maybe use a time cache # for that? version = version_info[:2] try: return _version_cache[version] except KeyError: pass _version_cache[version] = file_set = \ _merge_create_stub_map(_get_typeshed_directories(version_info)) return file_set def import_module_decorator(func): @wraps(func) def wrapper(inference_state, import_names, parent_module_value, sys_path, prefer_stubs): python_value_set = inference_state.module_cache.get(import_names) if python_value_set is None: if parent_module_value is not None and parent_module_value.is_stub(): parent_module_values = parent_module_value.non_stub_value_set else: parent_module_values = [parent_module_value] if import_names == ('os', 'path'): # This is a huge exception, we follow a nested import # ``os.path``, because it's a very important one in Python # that is being achieved by messing with ``sys.modules`` in # ``os``. python_value_set = ValueSet.from_sets( func(inference_state, (n,), None, sys_path,) for n in ['posixpath', 'ntpath', 'macpath', 'os2emxpath'] ) else: python_value_set = ValueSet.from_sets( func(inference_state, import_names, p, sys_path,) for p in parent_module_values ) inference_state.module_cache.add(import_names, python_value_set) if not prefer_stubs or import_names[0] in settings.auto_import_modules: return python_value_set stub = try_to_load_stub_cached(inference_state, import_names, python_value_set, parent_module_value, sys_path) if stub is not None: return ValueSet([stub]) return python_value_set return wrapper def try_to_load_stub_cached(inference_state, import_names, *args, **kwargs): if import_names is None: return None try: return inference_state.stub_module_cache[import_names] except KeyError: pass # TODO is this needed? where are the exceptions coming from that make this # necessary? Just remove this line. inference_state.stub_module_cache[import_names] = None inference_state.stub_module_cache[import_names] = result = \ _try_to_load_stub(inference_state, import_names, *args, **kwargs) return result def _try_to_load_stub(inference_state, import_names, python_value_set, parent_module_value, sys_path): """ Trying to load a stub for a set of import_names. This is modelled to work like "PEP 561 -- Distributing and Packaging Type Information", see https://www.python.org/dev/peps/pep-0561. """ if parent_module_value is None and len(import_names) > 1: try: parent_module_value = try_to_load_stub_cached( inference_state, import_names[:-1], NO_VALUES, parent_module_value=None, sys_path=sys_path) except KeyError: pass # 1. Try to load foo-stubs folders on path for import name foo. if len(import_names) == 1: # foo-stubs for p in sys_path: init = os.path.join(p, *import_names) + '-stubs' + os.path.sep + '__init__.pyi' m = _try_to_load_stub_from_file( inference_state, python_value_set, file_io=FileIO(init), import_names=import_names, ) if m is not None: return m if import_names[0] == 'django' and python_value_set: return _try_to_load_stub_from_file( inference_state, python_value_set, file_io=FileIO(str(DJANGO_INIT_PATH)), import_names=import_names, ) # 2. Try to load pyi files next to py files. for c in python_value_set: try: method = c.py__file__ except AttributeError: pass else: file_path = method() file_paths = [] if c.is_namespace(): file_paths = [os.path.join(p, '__init__.pyi') for p in c.py__path__()] elif file_path is not None and file_path.suffix == '.py': file_paths = [str(file_path) + 'i'] for file_path in file_paths: m = _try_to_load_stub_from_file( inference_state, python_value_set, # The file path should end with .pyi file_io=FileIO(file_path), import_names=import_names, ) if m is not None: return m # 3. Try to load typeshed m = _load_from_typeshed(inference_state, python_value_set, parent_module_value, import_names) if m is not None: return m # 4. Try to load pyi file somewhere if python_value_set was not defined. if not python_value_set: if parent_module_value is not None: check_path = parent_module_value.py__path__() or [] # In case import_names names_for_path = (import_names[-1],) else: check_path = sys_path names_for_path = import_names for p in check_path: m = _try_to_load_stub_from_file( inference_state, python_value_set, file_io=FileIO(os.path.join(p, *names_for_path) + '.pyi'), import_names=import_names, ) if m is not None: return m # If no stub is found, that's fine, the calling function has to deal with # it. return None def _load_from_typeshed(inference_state, python_value_set, parent_module_value, import_names): import_name = import_names[-1] map_ = None if len(import_names) == 1: map_ = _cache_stub_file_map(inference_state.grammar.version_info) import_name = _IMPORT_MAP.get(import_name, import_name) elif isinstance(parent_module_value, ModuleValue): if not parent_module_value.is_package(): # Only if it's a package (= a folder) something can be # imported. return None paths = parent_module_value.py__path__() # Once the initial package has been loaded, the sub packages will # always be loaded, regardless if they are there or not. This makes # sense, IMO, because stubs take preference, even if the original # library doesn't provide a module (it could be dynamic). ~dave map_ = _merge_create_stub_map([PathInfo(p, is_third_party=False) for p in paths]) if map_ is not None: path_info = map_.get(import_name) if path_info is not None and (not path_info.is_third_party or python_value_set): return _try_to_load_stub_from_file( inference_state, python_value_set, file_io=FileIO(path_info.path), import_names=import_names, ) def _try_to_load_stub_from_file(inference_state, python_value_set, file_io, import_names): try: stub_module_node = parse_stub_module(inference_state, file_io) except OSError: # The file that you're looking for doesn't exist (anymore). return None else: return create_stub_module( inference_state, inference_state.latest_grammar, python_value_set, stub_module_node, file_io, import_names ) def parse_stub_module(inference_state, file_io): return inference_state.parse( file_io=file_io, cache=True, diff_cache=settings.fast_parser, cache_path=settings.cache_directory, use_latest_grammar=True ) def create_stub_module(inference_state, grammar, python_value_set, stub_module_node, file_io, import_names): if import_names == ('typing',): module_cls = TypingModuleWrapper else: module_cls = StubModuleValue file_name = os.path.basename(file_io.path) stub_module_value = module_cls( python_value_set, inference_state, stub_module_node, file_io=file_io, string_names=import_names, # The code was loaded with latest_grammar, so use # that. code_lines=get_cached_code_lines(grammar, file_io.path), is_package=file_name == '__init__.pyi', ) return stub_module_value ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/jedi/inference/gradual/typing.py0000664000175000017500000004154700000000000020567 0ustar00davedave00000000000000""" We need to somehow work with the typing objects. Since the typing objects are pretty bare we need to add all the Jedi customizations to make them work as values. This file deals with all the typing.py cases. """ import itertools from jedi import debug from jedi.inference.compiled import builtin_from_name, create_simple_object from jedi.inference.base_value import ValueSet, NO_VALUES, Value, \ LazyValueWrapper, ValueWrapper from jedi.inference.lazy_value import LazyKnownValues from jedi.inference.arguments import repack_with_argument_clinic from jedi.inference.filters import FilterWrapper from jedi.inference.names import NameWrapper, ValueName from jedi.inference.value.klass import ClassMixin from jedi.inference.gradual.base import BaseTypingValue, \ BaseTypingClassWithGenerics, BaseTypingInstance from jedi.inference.gradual.type_var import TypeVarClass from jedi.inference.gradual.generics import LazyGenericManager, TupleGenericManager _PROXY_CLASS_TYPES = 'Tuple Generic Protocol Callable Type'.split() _TYPE_ALIAS_TYPES = { 'List': 'builtins.list', 'Dict': 'builtins.dict', 'Set': 'builtins.set', 'FrozenSet': 'builtins.frozenset', 'ChainMap': 'collections.ChainMap', 'Counter': 'collections.Counter', 'DefaultDict': 'collections.defaultdict', 'Deque': 'collections.deque', } _PROXY_TYPES = 'Optional Union ClassVar Annotated'.split() class TypingModuleName(NameWrapper): def infer(self): return ValueSet(self._remap()) def _remap(self): name = self.string_name inference_state = self.parent_context.inference_state try: actual = _TYPE_ALIAS_TYPES[name] except KeyError: pass else: yield TypeAlias.create_cached( inference_state, self.parent_context, self.tree_name, actual) return if name in _PROXY_CLASS_TYPES: yield ProxyTypingClassValue.create_cached( inference_state, self.parent_context, self.tree_name) elif name in _PROXY_TYPES: yield ProxyTypingValue.create_cached( inference_state, self.parent_context, self.tree_name) elif name == 'runtime': # We don't want anything here, not sure what this function is # supposed to do, since it just appears in the stubs and shouldn't # have any effects there (because it's never executed). return elif name == 'TypeVar': cls, = self._wrapped_name.infer() yield TypeVarClass.create_cached(inference_state, cls) elif name == 'Any': yield AnyClass.create_cached( inference_state, self.parent_context, self.tree_name) elif name == 'TYPE_CHECKING': # This is needed for e.g. imports that are only available for type # checking or are in cycles. The user can then check this variable. yield builtin_from_name(inference_state, 'True') elif name == 'overload': yield OverloadFunction.create_cached( inference_state, self.parent_context, self.tree_name) elif name == 'NewType': v, = self._wrapped_name.infer() yield NewTypeFunction.create_cached(inference_state, v) elif name == 'cast': cast_fn, = self._wrapped_name.infer() yield CastFunction.create_cached(inference_state, cast_fn) elif name == 'TypedDict': # TODO doesn't even exist in typeshed/typing.py, yet. But will be # added soon. yield TypedDictClass.create_cached( inference_state, self.parent_context, self.tree_name) else: # Not necessary, as long as we are not doing type checking: # no_type_check & no_type_check_decorator # Everything else shouldn't be relevant... yield from self._wrapped_name.infer() class TypingModuleFilterWrapper(FilterWrapper): name_wrapper_class = TypingModuleName class ProxyWithGenerics(BaseTypingClassWithGenerics): def execute_annotation(self): string_name = self._tree_name.value if string_name == 'Union': # This is kind of a special case, because we have Unions (in Jedi # ValueSets). return self.gather_annotation_classes().execute_annotation() elif string_name == 'Optional': # Optional is basically just saying it's either None or the actual # type. return self.gather_annotation_classes().execute_annotation() \ | ValueSet([builtin_from_name(self.inference_state, 'None')]) elif string_name == 'Type': # The type is actually already given in the index_value return self._generics_manager[0] elif string_name in ['ClassVar', 'Annotated']: # For now don't do anything here, ClassVars are always used. return self._generics_manager[0].execute_annotation() mapped = { 'Tuple': Tuple, 'Generic': Generic, 'Protocol': Protocol, 'Callable': Callable, } cls = mapped[string_name] return ValueSet([cls( self.parent_context, self, self._tree_name, generics_manager=self._generics_manager, )]) def gather_annotation_classes(self): return ValueSet.from_sets(self._generics_manager.to_tuple()) def _create_instance_with_generics(self, generics_manager): return ProxyWithGenerics( self.parent_context, self._tree_name, generics_manager ) def infer_type_vars(self, value_set): annotation_generics = self.get_generics() if not annotation_generics: return {} annotation_name = self.py__name__() if annotation_name == 'Optional': # Optional[T] is equivalent to Union[T, None]. In Jedi unions # are represented by members within a ValueSet, so we extract # the T from the Optional[T] by removing the None value. none = builtin_from_name(self.inference_state, 'None') return annotation_generics[0].infer_type_vars( value_set.filter(lambda x: x != none), ) return {} class ProxyTypingValue(BaseTypingValue): index_class = ProxyWithGenerics def with_generics(self, generics_tuple): return self.index_class.create_cached( self.inference_state, self.parent_context, self._tree_name, generics_manager=TupleGenericManager(generics_tuple) ) def py__getitem__(self, index_value_set, contextualized_node): return ValueSet( self.index_class.create_cached( self.inference_state, self.parent_context, self._tree_name, generics_manager=LazyGenericManager( context_of_index=contextualized_node.context, index_value=index_value, ) ) for index_value in index_value_set ) class _TypingClassMixin(ClassMixin): def py__bases__(self): return [LazyKnownValues( self.inference_state.builtins_module.py__getattribute__('object') )] def get_metaclasses(self): return [] @property def name(self): return ValueName(self, self._tree_name) class TypingClassWithGenerics(ProxyWithGenerics, _TypingClassMixin): def infer_type_vars(self, value_set): type_var_dict = {} annotation_generics = self.get_generics() if not annotation_generics: return type_var_dict annotation_name = self.py__name__() if annotation_name == 'Type': return annotation_generics[0].infer_type_vars( # This is basically a trick to avoid extra code: We execute the # incoming classes to be able to use the normal code for type # var inference. value_set.execute_annotation(), ) elif annotation_name == 'Callable': if len(annotation_generics) == 2: return annotation_generics[1].infer_type_vars( value_set.execute_annotation(), ) elif annotation_name == 'Tuple': tuple_annotation, = self.execute_annotation() return tuple_annotation.infer_type_vars(value_set) return type_var_dict def _create_instance_with_generics(self, generics_manager): return TypingClassWithGenerics( self.parent_context, self._tree_name, generics_manager ) class ProxyTypingClassValue(ProxyTypingValue, _TypingClassMixin): index_class = TypingClassWithGenerics class TypeAlias(LazyValueWrapper): def __init__(self, parent_context, origin_tree_name, actual): self.inference_state = parent_context.inference_state self.parent_context = parent_context self._origin_tree_name = origin_tree_name self._actual = actual # e.g. builtins.list @property def name(self): return ValueName(self, self._origin_tree_name) def py__name__(self): return self.name.string_name def __repr__(self): return '<%s: %s>' % (self.__class__.__name__, self._actual) def _get_wrapped_value(self): module_name, class_name = self._actual.split('.') # TODO use inference_state.import_module? from jedi.inference.imports import Importer module, = Importer( self.inference_state, [module_name], self.inference_state.builtins_module ).follow() classes = module.py__getattribute__(class_name) # There should only be one, because it's code that we control. assert len(classes) == 1, classes cls = next(iter(classes)) return cls def gather_annotation_classes(self): return ValueSet([self._get_wrapped_value()]) def get_signatures(self): return [] class Callable(BaseTypingInstance): def py__call__(self, arguments): """ def x() -> Callable[[Callable[..., _T]], _T]: ... """ # The 0th index are the arguments. try: param_values = self._generics_manager[0] result_values = self._generics_manager[1] except IndexError: debug.warning('Callable[...] defined without two arguments') return NO_VALUES else: from jedi.inference.gradual.annotation import infer_return_for_callable return infer_return_for_callable(arguments, param_values, result_values) def py__get__(self, instance, class_value): return ValueSet([self]) class Tuple(BaseTypingInstance): def _is_homogenous(self): # To specify a variable-length tuple of homogeneous type, Tuple[T, ...] # is used. return self._generics_manager.is_homogenous_tuple() def py__simple_getitem__(self, index): if self._is_homogenous(): return self._generics_manager.get_index_and_execute(0) else: if isinstance(index, int): return self._generics_manager.get_index_and_execute(index) debug.dbg('The getitem type on Tuple was %s' % index) return NO_VALUES def py__iter__(self, contextualized_node=None): if self._is_homogenous(): yield LazyKnownValues(self._generics_manager.get_index_and_execute(0)) else: for v in self._generics_manager.to_tuple(): yield LazyKnownValues(v.execute_annotation()) def py__getitem__(self, index_value_set, contextualized_node): if self._is_homogenous(): return self._generics_manager.get_index_and_execute(0) return ValueSet.from_sets( self._generics_manager.to_tuple() ).execute_annotation() def _get_wrapped_value(self): tuple_, = self.inference_state.builtins_module \ .py__getattribute__('tuple').execute_annotation() return tuple_ @property def name(self): return self._wrapped_value.name def infer_type_vars(self, value_set): # Circular from jedi.inference.gradual.annotation import merge_pairwise_generics, merge_type_var_dicts value_set = value_set.filter( lambda x: x.py__name__().lower() == 'tuple', ) if self._is_homogenous(): # The parameter annotation is of the form `Tuple[T, ...]`, # so we treat the incoming tuple like a iterable sequence # rather than a positional container of elements. return self._class_value.get_generics()[0].infer_type_vars( value_set.merge_types_of_iterate(), ) else: # The parameter annotation has only explicit type parameters # (e.g: `Tuple[T]`, `Tuple[T, U]`, `Tuple[T, U, V]`, etc.) so we # treat the incoming values as needing to match the annotation # exactly, just as we would for non-tuple annotations. type_var_dict = {} for element in value_set: try: method = element.get_annotated_class_object except AttributeError: # This might still happen, because the tuple name matching # above is not 100% correct, so just catch the remaining # cases here. continue py_class = method() merge_type_var_dicts( type_var_dict, merge_pairwise_generics(self._class_value, py_class), ) return type_var_dict class Generic(BaseTypingInstance): pass class Protocol(BaseTypingInstance): pass class AnyClass(BaseTypingValue): def execute_annotation(self): debug.warning('Used Any - returned no results') return NO_VALUES class OverloadFunction(BaseTypingValue): @repack_with_argument_clinic('func, /') def py__call__(self, func_value_set): # Just pass arguments through. return func_value_set class NewTypeFunction(ValueWrapper): def py__call__(self, arguments): ordered_args = arguments.unpack() next(ordered_args, (None, None)) _, second_arg = next(ordered_args, (None, None)) if second_arg is None: return NO_VALUES return ValueSet( NewType( self.inference_state, contextualized_node.context, contextualized_node.node, second_arg.infer(), ) for contextualized_node in arguments.get_calling_nodes()) class NewType(Value): def __init__(self, inference_state, parent_context, tree_node, type_value_set): super().__init__(inference_state, parent_context) self._type_value_set = type_value_set self.tree_node = tree_node def py__class__(self): c, = self._type_value_set.py__class__() return c def py__call__(self, arguments): return self._type_value_set.execute_annotation() @property def name(self): from jedi.inference.compiled.value import CompiledValueName return CompiledValueName(self, 'NewType') def __repr__(self) -> str: return '%s' % (self.tree_node, self._type_value_set) class CastFunction(ValueWrapper): @repack_with_argument_clinic('type, object, /') def py__call__(self, type_value_set, object_value_set): return type_value_set.execute_annotation() class TypedDictClass(BaseTypingValue): """ This class has no responsibilities and is just here to make sure that typed dicts can be identified. """ class TypedDict(LazyValueWrapper): """Represents the instance version of ``TypedDictClass``.""" def __init__(self, definition_class): self.inference_state = definition_class.inference_state self.parent_context = definition_class.parent_context self.tree_node = definition_class.tree_node self._definition_class = definition_class @property def name(self): return ValueName(self, self.tree_node.name) def py__simple_getitem__(self, index): if isinstance(index, str): return ValueSet.from_sets( name.infer() for filter in self._definition_class.get_filters(is_instance=True) for name in filter.get(index) ) return NO_VALUES def get_key_values(self): filtered_values = itertools.chain.from_iterable(( f.values() for f in self._definition_class.get_filters(is_instance=True) )) return ValueSet({ create_simple_object(self.inference_state, v.string_name) for v in filtered_values }) def _get_wrapped_value(self): d, = self.inference_state.builtins_module.py__getattribute__('dict') result, = d.execute_with_values() return result ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/jedi/inference/gradual/utils.py0000664000175000017500000000217300000000000020405 0ustar00davedave00000000000000from pathlib import Path from jedi.inference.gradual.typeshed import TYPESHED_PATH, create_stub_module def load_proper_stub_module(inference_state, grammar, file_io, import_names, module_node): """ This function is given a random .pyi file and should return the proper module. """ path = file_io.path path = Path(path) assert path.suffix == '.pyi' try: relative_path = path.relative_to(TYPESHED_PATH) except ValueError: pass else: # /[...]/stdlib/3/os/__init__.pyi -> stdlib/3/os/__init__ rest = relative_path.with_suffix('') # Remove the stdlib/3 or third_party/3.6 part import_names = rest.parts[2:] if rest.name == '__init__': import_names = import_names[:-1] if import_names is not None: actual_value_set = inference_state.import_module(import_names, prefer_stubs=False) stub = create_stub_module( inference_state, grammar, actual_value_set, module_node, file_io, import_names ) inference_state.stub_module_cache[import_names] = stub return stub return None ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/jedi/inference/helpers.py0000664000175000017500000001346700000000000017300 0ustar00davedave00000000000000import copy import sys import re import os from itertools import chain from contextlib import contextmanager from parso.python import tree def is_stdlib_path(path): # Python standard library paths look like this: # /usr/lib/python3.9/... # TODO The implementation below is probably incorrect and not complete. parts = path.parts if 'dist-packages' in parts or 'site-packages' in parts: return False base_path = os.path.join(sys.prefix, 'lib', 'python') return bool(re.match(re.escape(base_path) + r'\d.\d', str(path))) def deep_ast_copy(obj): """ Much, much faster than copy.deepcopy, but just for parser tree nodes. """ # If it's already in the cache, just return it. new_obj = copy.copy(obj) # Copy children new_children = [] for child in obj.children: if isinstance(child, tree.Leaf): new_child = copy.copy(child) new_child.parent = new_obj else: new_child = deep_ast_copy(child) new_child.parent = new_obj new_children.append(new_child) new_obj.children = new_children return new_obj def infer_call_of_leaf(context, leaf, cut_own_trailer=False): """ Creates a "call" node that consist of all ``trailer`` and ``power`` objects. E.g. if you call it with ``append``:: list([]).append(3) or None You would get a node with the content ``list([]).append`` back. This generates a copy of the original ast node. If you're using the leaf, e.g. the bracket `)` it will return ``list([])``. We use this function for two purposes. Given an expression ``bar.foo``, we may want to - infer the type of ``foo`` to offer completions after foo - infer the type of ``bar`` to be able to jump to the definition of foo The option ``cut_own_trailer`` must be set to true for the second purpose. """ trailer = leaf.parent if trailer.type == 'fstring': from jedi.inference import compiled return compiled.get_string_value_set(context.inference_state) # The leaf may not be the last or first child, because there exist three # different trailers: `( x )`, `[ x ]` and `.x`. In the first two examples # we should not match anything more than x. if trailer.type != 'trailer' or leaf not in (trailer.children[0], trailer.children[-1]): if leaf == ':': # Basically happens with foo[:] when the cursor is on the colon from jedi.inference.base_value import NO_VALUES return NO_VALUES if trailer.type == 'atom': return context.infer_node(trailer) return context.infer_node(leaf) power = trailer.parent index = power.children.index(trailer) if cut_own_trailer: cut = index else: cut = index + 1 if power.type == 'error_node': start = index while True: start -= 1 base = power.children[start] if base.type != 'trailer': break trailers = power.children[start + 1:cut] else: base = power.children[0] trailers = power.children[1:cut] if base == 'await': base = trailers[0] trailers = trailers[1:] values = context.infer_node(base) from jedi.inference.syntax_tree import infer_trailer for trailer in trailers: values = infer_trailer(context, values, trailer) return values def get_names_of_node(node): try: children = node.children except AttributeError: if node.type == 'name': return [node] else: return [] else: return list(chain.from_iterable(get_names_of_node(c) for c in children)) def is_string(value): return value.is_compiled() and isinstance(value.get_safe_value(default=None), str) def is_literal(value): return is_number(value) or is_string(value) def _get_safe_value_or_none(value, accept): value = value.get_safe_value(default=None) if isinstance(value, accept): return value def get_int_or_none(value): return _get_safe_value_or_none(value, int) def get_str_or_none(value): return _get_safe_value_or_none(value, str) def is_number(value): return _get_safe_value_or_none(value, (int, float)) is not None class SimpleGetItemNotFound(Exception): pass @contextmanager def reraise_getitem_errors(*exception_classes): try: yield except exception_classes as e: raise SimpleGetItemNotFound(e) def parse_dotted_names(nodes, is_import_from, until_node=None): level = 0 names = [] for node in nodes[1:]: if node in ('.', '...'): if not names: level += len(node.value) elif node.type == 'dotted_name': for n in node.children[::2]: names.append(n) if n is until_node: break else: continue break elif node.type == 'name': names.append(node) if node is until_node: break elif node == ',': if not is_import_from: names = [] else: # Here if the keyword `import` comes along it stops checking # for names. break return level, names def values_from_qualified_names(inference_state, *names): return inference_state.import_module(names[:-1]).py__getattribute__(names[-1]) def is_big_annoying_library(context): string_names = context.get_root_context().string_names if string_names is None: return False # Especially pandas and tensorflow are huge complicated Python libraries # that get even slower than they already are when Jedi tries to undrstand # dynamic features like decorators, ifs and other stuff. return string_names[0] in ('pandas', 'numpy', 'tensorflow', 'matplotlib') ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/jedi/inference/imports.py0000664000175000017500000005505200000000000017327 0ustar00davedave00000000000000""" :mod:`jedi.inference.imports` is here to resolve import statements and return the modules/classes/functions/whatever, which they stand for. However there's not any actual importing done. This module is about finding modules in the filesystem. This can be quite tricky sometimes, because Python imports are not always that simple. This module also supports import autocompletion, which means to complete statements like ``from datetim`` (cursor at the end would return ``datetime``). """ import os from pathlib import Path from parso.python import tree from parso.tree import search_ancestor from jedi import debug from jedi import settings from jedi.file_io import FolderIO from jedi.parser_utils import get_cached_code_lines from jedi.inference import sys_path from jedi.inference import helpers from jedi.inference import compiled from jedi.inference import analysis from jedi.inference.utils import unite from jedi.inference.cache import inference_state_method_cache from jedi.inference.names import ImportName, SubModuleName from jedi.inference.base_value import ValueSet, NO_VALUES from jedi.inference.gradual.typeshed import import_module_decorator, \ create_stub_module, parse_stub_module from jedi.inference.compiled.subprocess.functions import ImplicitNSInfo from jedi.plugins import plugin_manager class ModuleCache: def __init__(self): self._name_cache = {} def add(self, string_names, value_set): if string_names is not None: self._name_cache[string_names] = value_set def get(self, string_names): return self._name_cache.get(string_names) # This memoization is needed, because otherwise we will infinitely loop on # certain imports. @inference_state_method_cache(default=NO_VALUES) def infer_import(context, tree_name): module_context = context.get_root_context() from_import_name, import_path, level, values = \ _prepare_infer_import(module_context, tree_name) if values: if from_import_name is not None: values = values.py__getattribute__( from_import_name, name_context=context, analysis_errors=False ) if not values: path = import_path + (from_import_name,) importer = Importer(context.inference_state, path, module_context, level) values = importer.follow() debug.dbg('after import: %s', values) return values @inference_state_method_cache(default=[]) def goto_import(context, tree_name): module_context = context.get_root_context() from_import_name, import_path, level, values = \ _prepare_infer_import(module_context, tree_name) if not values: return [] if from_import_name is not None: names = unite([ c.goto( from_import_name, name_context=context, analysis_errors=False ) for c in values ]) # Avoid recursion on the same names. if names and not any(n.tree_name is tree_name for n in names): return names path = import_path + (from_import_name,) importer = Importer(context.inference_state, path, module_context, level) values = importer.follow() return set(s.name for s in values) def _prepare_infer_import(module_context, tree_name): import_node = search_ancestor(tree_name, 'import_name', 'import_from') import_path = import_node.get_path_for_name(tree_name) from_import_name = None try: from_names = import_node.get_from_names() except AttributeError: # Is an import_name pass else: if len(from_names) + 1 == len(import_path): # We have to fetch the from_names part first and then check # if from_names exists in the modules. from_import_name = import_path[-1] import_path = from_names importer = Importer(module_context.inference_state, tuple(import_path), module_context, import_node.level) return from_import_name, tuple(import_path), import_node.level, importer.follow() def _add_error(value, name, message): if hasattr(name, 'parent') and value is not None: analysis.add(value, 'import-error', name, message) else: debug.warning('ImportError without origin: ' + message) def _level_to_base_import_path(project_path, directory, level): """ In case the level is outside of the currently known package (something like import .....foo), we can still try our best to help the user for completions. """ for i in range(level - 1): old = directory directory = os.path.dirname(directory) if old == directory: return None, None d = directory level_import_paths = [] # Now that we are on the level that the user wants to be, calculate the # import path for it. while True: if d == project_path: return level_import_paths, d dir_name = os.path.basename(d) if dir_name: level_import_paths.insert(0, dir_name) d = os.path.dirname(d) else: return None, directory class Importer: def __init__(self, inference_state, import_path, module_context, level=0): """ An implementation similar to ``__import__``. Use `follow` to actually follow the imports. *level* specifies whether to use absolute or relative imports. 0 (the default) means only perform absolute imports. Positive values for level indicate the number of parent directories to search relative to the directory of the module calling ``__import__()`` (see PEP 328 for the details). :param import_path: List of namespaces (strings or Names). """ debug.speed('import %s %s' % (import_path, module_context)) self._inference_state = inference_state self.level = level self._module_context = module_context self._fixed_sys_path = None self._infer_possible = True if level: base = module_context.get_value().py__package__() # We need to care for two cases, the first one is if it's a valid # Python import. This import has a properly defined module name # chain like `foo.bar.baz` and an import in baz is made for # `..lala.` It can then resolve to `foo.bar.lala`. # The else here is a heuristic for all other cases, if for example # in `foo` you search for `...bar`, it's obviously out of scope. # However since Jedi tries to just do it's best, we help the user # here, because he might have specified something wrong in his # project. if level <= len(base): # Here we basically rewrite the level to 0. base = tuple(base) if level > 1: base = base[:-level + 1] import_path = base + tuple(import_path) else: path = module_context.py__file__() project_path = self._inference_state.project.path import_path = list(import_path) if path is None: # If no path is defined, our best guess is that the current # file is edited by a user on the current working # directory. We need to add an initial path, because it # will get removed as the name of the current file. directory = project_path else: directory = os.path.dirname(path) base_import_path, base_directory = _level_to_base_import_path( project_path, directory, level, ) if base_directory is None: # Everything is lost, the relative import does point # somewhere out of the filesystem. self._infer_possible = False else: self._fixed_sys_path = [base_directory] if base_import_path is None: if import_path: _add_error( module_context, import_path[0], message='Attempted relative import beyond top-level package.' ) else: import_path = base_import_path + import_path self.import_path = import_path @property def _str_import_path(self): """Returns the import path as pure strings instead of `Name`.""" return tuple( name.value if isinstance(name, tree.Name) else name for name in self.import_path ) def _sys_path_with_modifications(self, is_completion): if self._fixed_sys_path is not None: return self._fixed_sys_path return ( # For import completions we don't want to see init paths, but for # inference we want to show the user as much as possible. # See GH #1446. self._inference_state.get_sys_path(add_init_paths=not is_completion) + [ str(p) for p in sys_path.check_sys_path_modifications(self._module_context) ] ) def follow(self): if not self.import_path: if self._fixed_sys_path: # This is a bit of a special case, that maybe should be # revisited. If the project path is wrong or the user uses # relative imports the wrong way, we might end up here, where # the `fixed_sys_path == project.path` in that case we kind of # use the project.path.parent directory as our path. This is # usually not a problem, except if imports in other places are # using the same names. Example: # # foo/ < #1 # - setup.py # - foo/ < #2 # - __init__.py # - foo.py < #3 # # If the top foo is our project folder and somebody uses # `from . import foo` in `setup.py`, it will resolve to foo #2, # which means that the import for foo.foo is cached as # `__init__.py` (#2) and not as `foo.py` (#3). This is usually # not an issue, because this case is probably pretty rare, but # might be an issue for some people. # # However for most normal cases where we work with different # file names, this code path hits where we basically change the # project path to an ancestor of project path. from jedi.inference.value.namespace import ImplicitNamespaceValue import_path = (os.path.basename(self._fixed_sys_path[0]),) ns = ImplicitNamespaceValue( self._inference_state, string_names=import_path, paths=self._fixed_sys_path, ) return ValueSet({ns}) return NO_VALUES if not self._infer_possible: return NO_VALUES # Check caches first from_cache = self._inference_state.stub_module_cache.get(self._str_import_path) if from_cache is not None: return ValueSet({from_cache}) from_cache = self._inference_state.module_cache.get(self._str_import_path) if from_cache is not None: return from_cache sys_path = self._sys_path_with_modifications(is_completion=False) return import_module_by_names( self._inference_state, self.import_path, sys_path, self._module_context ) def _get_module_names(self, search_path=None, in_module=None): """ Get the names of all modules in the search_path. This means file names and not names defined in the files. """ if search_path is None: sys_path = self._sys_path_with_modifications(is_completion=True) else: sys_path = search_path return list(iter_module_names( self._inference_state, self._module_context, sys_path, module_cls=ImportName if in_module is None else SubModuleName, add_builtin_modules=search_path is None and in_module is None, )) def completion_names(self, inference_state, only_modules=False): """ :param only_modules: Indicates wheter it's possible to import a definition that is not defined in a module. """ if not self._infer_possible: return [] names = [] if self.import_path: # flask if self._str_import_path == ('flask', 'ext'): # List Flask extensions like ``flask_foo`` for mod in self._get_module_names(): modname = mod.string_name if modname.startswith('flask_'): extname = modname[len('flask_'):] names.append(ImportName(self._module_context, extname)) # Now the old style: ``flaskext.foo`` for dir in self._sys_path_with_modifications(is_completion=True): flaskext = os.path.join(dir, 'flaskext') if os.path.isdir(flaskext): names += self._get_module_names([flaskext]) values = self.follow() for value in values: # Non-modules are not completable. if value.api_type not in ('module', 'namespace'): # not a module continue if not value.is_compiled(): # sub_modules_dict is not implemented for compiled modules. names += value.sub_modules_dict().values() if not only_modules: from jedi.inference.gradual.conversion import convert_values both_values = values | convert_values(values) for c in both_values: for filter in c.get_filters(): names += filter.values() else: if self.level: # We only get here if the level cannot be properly calculated. names += self._get_module_names(self._fixed_sys_path) else: # This is just the list of global imports. names += self._get_module_names() return names def import_module_by_names(inference_state, import_names, sys_path=None, module_context=None, prefer_stubs=True): if sys_path is None: sys_path = inference_state.get_sys_path() str_import_names = tuple( i.value if isinstance(i, tree.Name) else i for i in import_names ) value_set = [None] for i, name in enumerate(import_names): value_set = ValueSet.from_sets([ import_module( inference_state, str_import_names[:i+1], parent_module_value, sys_path, prefer_stubs=prefer_stubs, ) for parent_module_value in value_set ]) if not value_set: message = 'No module named ' + '.'.join(str_import_names) if module_context is not None: _add_error(module_context, name, message) else: debug.warning(message) return NO_VALUES return value_set @plugin_manager.decorate() @import_module_decorator def import_module(inference_state, import_names, parent_module_value, sys_path): """ This method is very similar to importlib's `_gcd_import`. """ if import_names[0] in settings.auto_import_modules: module = _load_builtin_module(inference_state, import_names, sys_path) if module is None: return NO_VALUES return ValueSet([module]) module_name = '.'.join(import_names) if parent_module_value is None: # Override the sys.path. It works only good that way. # Injecting the path directly into `find_module` did not work. file_io_or_ns, is_pkg = inference_state.compiled_subprocess.get_module_info( string=import_names[-1], full_name=module_name, sys_path=sys_path, is_global_search=True, ) if is_pkg is None: return NO_VALUES else: paths = parent_module_value.py__path__() if paths is None: # The module might not be a package. return NO_VALUES file_io_or_ns, is_pkg = inference_state.compiled_subprocess.get_module_info( string=import_names[-1], path=paths, full_name=module_name, is_global_search=False, ) if is_pkg is None: return NO_VALUES if isinstance(file_io_or_ns, ImplicitNSInfo): from jedi.inference.value.namespace import ImplicitNamespaceValue module = ImplicitNamespaceValue( inference_state, string_names=tuple(file_io_or_ns.name.split('.')), paths=file_io_or_ns.paths, ) elif file_io_or_ns is None: module = _load_builtin_module(inference_state, import_names, sys_path) if module is None: return NO_VALUES else: module = _load_python_module( inference_state, file_io_or_ns, import_names=import_names, is_package=is_pkg, ) if parent_module_value is None: debug.dbg('global search_module %s: %s', import_names[-1], module) else: debug.dbg('search_module %s in paths %s: %s', module_name, paths, module) return ValueSet([module]) def _load_python_module(inference_state, file_io, import_names=None, is_package=False): module_node = inference_state.parse( file_io=file_io, cache=True, diff_cache=settings.fast_parser, cache_path=settings.cache_directory, ) from jedi.inference.value import ModuleValue return ModuleValue( inference_state, module_node, file_io=file_io, string_names=import_names, code_lines=get_cached_code_lines(inference_state.grammar, file_io.path), is_package=is_package, ) def _load_builtin_module(inference_state, import_names=None, sys_path=None): project = inference_state.project if sys_path is None: sys_path = inference_state.get_sys_path() if not project._load_unsafe_extensions: safe_paths = project._get_base_sys_path(inference_state) sys_path = [p for p in sys_path if p in safe_paths] dotted_name = '.'.join(import_names) assert dotted_name is not None module = compiled.load_module(inference_state, dotted_name=dotted_name, sys_path=sys_path) if module is None: # The file might raise an ImportError e.g. and therefore not be # importable. return None return module def load_module_from_path(inference_state, file_io, import_names=None, is_package=None): """ This should pretty much only be used for get_modules_containing_name. It's here to ensure that a random path is still properly loaded into the Jedi module structure. """ path = Path(file_io.path) if import_names is None: e_sys_path = inference_state.get_sys_path() import_names, is_package = sys_path.transform_path_to_dotted(e_sys_path, path) else: assert isinstance(is_package, bool) is_stub = path.suffix == '.pyi' if is_stub: folder_io = file_io.get_parent_folder() if folder_io.path.endswith('-stubs'): folder_io = FolderIO(folder_io.path[:-6]) if path.name == '__init__.pyi': python_file_io = folder_io.get_file_io('__init__.py') else: python_file_io = folder_io.get_file_io(import_names[-1] + '.py') try: v = load_module_from_path( inference_state, python_file_io, import_names, is_package=is_package ) values = ValueSet([v]) except FileNotFoundError: values = NO_VALUES return create_stub_module( inference_state, inference_state.latest_grammar, values, parse_stub_module(inference_state, file_io), file_io, import_names ) else: module = _load_python_module( inference_state, file_io, import_names=import_names, is_package=is_package, ) inference_state.module_cache.add(import_names, ValueSet([module])) return module def load_namespace_from_path(inference_state, folder_io): import_names, is_package = sys_path.transform_path_to_dotted( inference_state.get_sys_path(), Path(folder_io.path) ) from jedi.inference.value.namespace import ImplicitNamespaceValue return ImplicitNamespaceValue(inference_state, import_names, [folder_io.path]) def follow_error_node_imports_if_possible(context, name): error_node = tree.search_ancestor(name, 'error_node') if error_node is not None: # Get the first command start of a started simple_stmt. The error # node is sometimes a small_stmt and sometimes a simple_stmt. Check # for ; leaves that start a new statements. start_index = 0 for index, n in enumerate(error_node.children): if n.start_pos > name.start_pos: break if n == ';': start_index = index + 1 nodes = error_node.children[start_index:] first_name = nodes[0].get_first_leaf().value # Make it possible to infer stuff like `import foo.` or # `from foo.bar`. if first_name in ('from', 'import'): is_import_from = first_name == 'from' level, names = helpers.parse_dotted_names( nodes, is_import_from=is_import_from, until_node=name, ) return Importer( context.inference_state, names, context.get_root_context(), level).follow() return None def iter_module_names(inference_state, module_context, search_path, module_cls=ImportName, add_builtin_modules=True): """ Get the names of all modules in the search_path. This means file names and not names defined in the files. """ # add builtin module names if add_builtin_modules: for name in inference_state.compiled_subprocess.get_builtin_module_names(): yield module_cls(module_context, name) for name in inference_state.compiled_subprocess.iter_module_names(search_path): yield module_cls(module_context, name) ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/jedi/inference/lazy_value.py0000664000175000017500000000320300000000000017774 0ustar00davedave00000000000000from jedi.inference.base_value import ValueSet, NO_VALUES from jedi.common import monkeypatch class AbstractLazyValue: def __init__(self, data, min=1, max=1): self.data = data self.min = min self.max = max def __repr__(self): return '<%s: %s>' % (self.__class__.__name__, self.data) def infer(self): raise NotImplementedError class LazyKnownValue(AbstractLazyValue): """data is a Value.""" def infer(self): return ValueSet([self.data]) class LazyKnownValues(AbstractLazyValue): """data is a ValueSet.""" def infer(self): return self.data class LazyUnknownValue(AbstractLazyValue): def __init__(self, min=1, max=1): super().__init__(None, min, max) def infer(self): return NO_VALUES class LazyTreeValue(AbstractLazyValue): def __init__(self, context, node, min=1, max=1): super().__init__(node, min, max) self.context = context # We need to save the predefined names. It's an unfortunate side effect # that needs to be tracked otherwise results will be wrong. self._predefined_names = dict(context.predefined_names) def infer(self): with monkeypatch(self.context, 'predefined_names', self._predefined_names): return self.context.infer_node(self.data) def get_merged_lazy_value(lazy_values): if len(lazy_values) > 1: return MergedLazyValues(lazy_values) else: return lazy_values[0] class MergedLazyValues(AbstractLazyValue): """data is a list of lazy values.""" def infer(self): return ValueSet.from_sets(l.infer() for l in self.data) ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/jedi/inference/names.py0000664000175000017500000005525600000000000016743 0ustar00davedave00000000000000from abc import abstractmethod from inspect import Parameter from typing import Optional, Tuple from parso.tree import search_ancestor from jedi.parser_utils import find_statement_documentation, clean_scope_docstring from jedi.inference.utils import unite from jedi.inference.base_value import ValueSet, NO_VALUES from jedi.inference.cache import inference_state_method_cache from jedi.inference import docstrings from jedi.cache import memoize_method from jedi.inference.helpers import deep_ast_copy, infer_call_of_leaf from jedi.plugins import plugin_manager def _merge_name_docs(names): doc = '' for name in names: if doc: # In case we have multiple values, just return all of them # separated by a few dashes. doc += '\n' + '-' * 30 + '\n' doc += name.py__doc__() return doc class AbstractNameDefinition: start_pos: Optional[Tuple[int, int]] = None string_name: str parent_context = None tree_name = None is_value_name = True """ Used for the Jedi API to know if it's a keyword or an actual name. """ @abstractmethod def infer(self): raise NotImplementedError @abstractmethod def goto(self): # Typically names are already definitions and therefore a goto on that # name will always result on itself. return {self} def get_qualified_names(self, include_module_names=False): qualified_names = self._get_qualified_names() if qualified_names is None or not include_module_names: return qualified_names module_names = self.get_root_context().string_names if module_names is None: return None return module_names + qualified_names def _get_qualified_names(self): # By default, a name has no qualified names. return None def get_root_context(self): return self.parent_context.get_root_context() def get_public_name(self): return self.string_name def __repr__(self): if self.start_pos is None: return '<%s: string_name=%s>' % (self.__class__.__name__, self.string_name) return '<%s: string_name=%s start_pos=%s>' % (self.__class__.__name__, self.string_name, self.start_pos) def is_import(self): return False def py__doc__(self): return '' @property def api_type(self): return self.parent_context.api_type def get_defining_qualified_value(self): """ Returns either None or the value that is public and qualified. Won't return a function, because a name in a function is never public. """ return None class AbstractArbitraryName(AbstractNameDefinition): """ When you e.g. want to complete dicts keys, you probably want to complete string literals, which is not really a name, but for Jedi we use this concept of Name for completions as well. """ is_value_name = False def __init__(self, inference_state, string): self.inference_state = inference_state self.string_name = string self.parent_context = inference_state.builtins_module def infer(self): return NO_VALUES class AbstractTreeName(AbstractNameDefinition): def __init__(self, parent_context, tree_name): self.parent_context = parent_context self.tree_name = tree_name def get_qualified_names(self, include_module_names=False): import_node = search_ancestor(self.tree_name, 'import_name', 'import_from') # For import nodes we cannot just have names, because it's very unclear # how they would look like. For now we just ignore them in most cases. # In case of level == 1, it works always, because it's like a submodule # lookup. if import_node is not None and not (import_node.level == 1 and self.get_root_context().get_value().is_package()): # TODO improve the situation for when level is present. if include_module_names and not import_node.level: return tuple(n.value for n in import_node.get_path_for_name(self.tree_name)) else: return None return super().get_qualified_names(include_module_names) def _get_qualified_names(self): parent_names = self.parent_context.get_qualified_names() if parent_names is None: return None return parent_names + (self.tree_name.value,) def get_defining_qualified_value(self): if self.is_import(): raise NotImplementedError("Shouldn't really happen, please report") elif self.parent_context: return self.parent_context.get_value() # Might be None return None def goto(self): context = self.parent_context name = self.tree_name definition = name.get_definition(import_name_always=True) if definition is not None: type_ = definition.type if type_ == 'expr_stmt': # Only take the parent, because if it's more complicated than just # a name it's something you can "goto" again. is_simple_name = name.parent.type not in ('power', 'trailer') if is_simple_name: return [self] elif type_ in ('import_from', 'import_name'): from jedi.inference.imports import goto_import module_names = goto_import(context, name) return module_names else: return [self] else: from jedi.inference.imports import follow_error_node_imports_if_possible values = follow_error_node_imports_if_possible(context, name) if values is not None: return [value.name for value in values] par = name.parent node_type = par.type if node_type == 'argument' and par.children[1] == '=' and par.children[0] == name: # Named param goto. trailer = par.parent if trailer.type == 'arglist': trailer = trailer.parent if trailer.type != 'classdef': if trailer.type == 'decorator': value_set = context.infer_node(trailer.children[1]) else: i = trailer.parent.children.index(trailer) to_infer = trailer.parent.children[:i] if to_infer[0] == 'await': to_infer.pop(0) value_set = context.infer_node(to_infer[0]) from jedi.inference.syntax_tree import infer_trailer for trailer in to_infer[1:]: value_set = infer_trailer(context, value_set, trailer) param_names = [] for value in value_set: for signature in value.get_signatures(): for param_name in signature.get_param_names(): if param_name.string_name == name.value: param_names.append(param_name) return param_names elif node_type == 'dotted_name': # Is a decorator. index = par.children.index(name) if index > 0: new_dotted = deep_ast_copy(par) new_dotted.children[index - 1:] = [] values = context.infer_node(new_dotted) return unite( value.goto(name, name_context=context) for value in values ) if node_type == 'trailer' and par.children[0] == '.': values = infer_call_of_leaf(context, name, cut_own_trailer=True) return values.goto(name, name_context=context) else: stmt = search_ancestor( name, 'expr_stmt', 'lambdef' ) or name if stmt.type == 'lambdef': stmt = name return context.goto(name, position=stmt.start_pos) def is_import(self): imp = search_ancestor(self.tree_name, 'import_from', 'import_name') return imp is not None @property def string_name(self): return self.tree_name.value @property def start_pos(self): return self.tree_name.start_pos class ValueNameMixin: def infer(self): return ValueSet([self._value]) def py__doc__(self): doc = self._value.py__doc__() if not doc and self._value.is_stub(): from jedi.inference.gradual.conversion import convert_names names = convert_names([self], prefer_stub_to_compiled=False) if self not in names: return _merge_name_docs(names) return doc def _get_qualified_names(self): return self._value.get_qualified_names() def get_root_context(self): if self.parent_context is None: # A module return self._value.as_context() return super().get_root_context() def get_defining_qualified_value(self): context = self.parent_context if context is not None and (context.is_module() or context.is_class()): return self.parent_context.get_value() # Might be None return None @property def api_type(self): return self._value.api_type class ValueName(ValueNameMixin, AbstractTreeName): def __init__(self, value, tree_name): super().__init__(value.parent_context, tree_name) self._value = value def goto(self): return ValueSet([self._value.name]) class TreeNameDefinition(AbstractTreeName): _API_TYPES = dict( import_name='module', import_from='module', funcdef='function', param='param', classdef='class', ) def infer(self): # Refactor this, should probably be here. from jedi.inference.syntax_tree import tree_name_to_values return tree_name_to_values( self.parent_context.inference_state, self.parent_context, self.tree_name ) @property def api_type(self): definition = self.tree_name.get_definition(import_name_always=True) if definition is None: return 'statement' return self._API_TYPES.get(definition.type, 'statement') def assignment_indexes(self): """ Returns an array of tuple(int, node) of the indexes that are used in tuple assignments. For example if the name is ``y`` in the following code:: x, (y, z) = 2, '' would result in ``[(1, xyz_node), (0, yz_node)]``. When searching for b in the case ``a, *b, c = [...]`` it will return:: [(slice(1, -1), abc_node)] """ indexes = [] is_star_expr = False node = self.tree_name.parent compare = self.tree_name while node is not None: if node.type in ('testlist', 'testlist_comp', 'testlist_star_expr', 'exprlist'): for i, child in enumerate(node.children): if child == compare: index = int(i / 2) if is_star_expr: from_end = int((len(node.children) - i) / 2) index = slice(index, -from_end) indexes.insert(0, (index, node)) break else: raise LookupError("Couldn't find the assignment.") is_star_expr = False elif node.type == 'star_expr': is_star_expr = True elif node.type in ('expr_stmt', 'sync_comp_for'): break compare = node node = node.parent return indexes @property def inference_state(self): # Used by the cache function below return self.parent_context.inference_state @inference_state_method_cache(default='') def py__doc__(self): api_type = self.api_type if api_type in ('function', 'class', 'property'): if self.parent_context.get_root_context().is_stub(): from jedi.inference.gradual.conversion import convert_names names = convert_names([self], prefer_stub_to_compiled=False) if self not in names: return _merge_name_docs(names) # Make sure the names are not TreeNameDefinitions anymore. return clean_scope_docstring(self.tree_name.get_definition()) if api_type == 'module': names = self.goto() if self not in names: return _merge_name_docs(names) if api_type == 'statement' and self.tree_name.is_definition(): return find_statement_documentation(self.tree_name.get_definition()) return '' class _ParamMixin: def maybe_positional_argument(self, include_star=True): options = [Parameter.POSITIONAL_ONLY, Parameter.POSITIONAL_OR_KEYWORD] if include_star: options.append(Parameter.VAR_POSITIONAL) return self.get_kind() in options def maybe_keyword_argument(self, include_stars=True): options = [Parameter.KEYWORD_ONLY, Parameter.POSITIONAL_OR_KEYWORD] if include_stars: options.append(Parameter.VAR_KEYWORD) return self.get_kind() in options def _kind_string(self): kind = self.get_kind() if kind == Parameter.VAR_POSITIONAL: # *args return '*' if kind == Parameter.VAR_KEYWORD: # **kwargs return '**' return '' def get_qualified_names(self, include_module_names=False): return None class ParamNameInterface(_ParamMixin): api_type = 'param' def get_kind(self): raise NotImplementedError def to_string(self): raise NotImplementedError def get_executed_param_name(self): """ For dealing with type inference and working around the graph, we sometimes want to have the param name of the execution. This feels a bit strange and we might have to refactor at some point. For now however it exists to avoid infering params when we don't really need them (e.g. when we can just instead use annotations. """ return None @property def star_count(self): kind = self.get_kind() if kind == Parameter.VAR_POSITIONAL: return 1 if kind == Parameter.VAR_KEYWORD: return 2 return 0 def infer_default(self): return NO_VALUES class BaseTreeParamName(ParamNameInterface, AbstractTreeName): annotation_node = None default_node = None def to_string(self): output = self._kind_string() + self.get_public_name() annotation = self.annotation_node default = self.default_node if annotation is not None: output += ': ' + annotation.get_code(include_prefix=False) if default is not None: output += '=' + default.get_code(include_prefix=False) return output def get_public_name(self): name = self.string_name if name.startswith('__'): # Params starting with __ are an equivalent to positional only # variables in typeshed. name = name[2:] return name def goto(self, **kwargs): return [self] class _ActualTreeParamName(BaseTreeParamName): def __init__(self, function_value, tree_name): super().__init__( function_value.get_default_param_context(), tree_name) self.function_value = function_value def _get_param_node(self): return search_ancestor(self.tree_name, 'param') @property def annotation_node(self): return self._get_param_node().annotation def infer_annotation(self, execute_annotation=True, ignore_stars=False): from jedi.inference.gradual.annotation import infer_param values = infer_param( self.function_value, self._get_param_node(), ignore_stars=ignore_stars) if execute_annotation: values = values.execute_annotation() return values def infer_default(self): node = self.default_node if node is None: return NO_VALUES return self.parent_context.infer_node(node) @property def default_node(self): return self._get_param_node().default def get_kind(self): tree_param = self._get_param_node() if tree_param.star_count == 1: # *args return Parameter.VAR_POSITIONAL if tree_param.star_count == 2: # **kwargs return Parameter.VAR_KEYWORD # Params starting with __ are an equivalent to positional only # variables in typeshed. if tree_param.name.value.startswith('__'): return Parameter.POSITIONAL_ONLY parent = tree_param.parent param_appeared = False for p in parent.children: if param_appeared: if p == '/': return Parameter.POSITIONAL_ONLY else: if p == '*': return Parameter.KEYWORD_ONLY if p.type == 'param': if p.star_count: return Parameter.KEYWORD_ONLY if p == tree_param: param_appeared = True return Parameter.POSITIONAL_OR_KEYWORD def infer(self): values = self.infer_annotation() if values: return values doc_params = docstrings.infer_param(self.function_value, self._get_param_node()) return doc_params class AnonymousParamName(_ActualTreeParamName): @plugin_manager.decorate(name='goto_anonymous_param') def goto(self): return super().goto() @plugin_manager.decorate(name='infer_anonymous_param') def infer(self): values = super().infer() if values: return values from jedi.inference.dynamic_params import dynamic_param_lookup param = self._get_param_node() values = dynamic_param_lookup(self.function_value, param.position_index) if values: return values if param.star_count == 1: from jedi.inference.value.iterable import FakeTuple value = FakeTuple(self.function_value.inference_state, []) elif param.star_count == 2: from jedi.inference.value.iterable import FakeDict value = FakeDict(self.function_value.inference_state, {}) elif param.default is None: return NO_VALUES else: return self.function_value.parent_context.infer_node(param.default) return ValueSet({value}) class ParamName(_ActualTreeParamName): def __init__(self, function_value, tree_name, arguments): super().__init__(function_value, tree_name) self.arguments = arguments def infer(self): values = super().infer() if values: return values return self.get_executed_param_name().infer() def get_executed_param_name(self): from jedi.inference.param import get_executed_param_names params_names = get_executed_param_names(self.function_value, self.arguments) return params_names[self._get_param_node().position_index] class ParamNameWrapper(_ParamMixin): def __init__(self, param_name): self._wrapped_param_name = param_name def __getattr__(self, name): return getattr(self._wrapped_param_name, name) def __repr__(self): return '<%s: %s>' % (self.__class__.__name__, self._wrapped_param_name) class ImportName(AbstractNameDefinition): start_pos = (1, 0) _level = 0 def __init__(self, parent_context, string_name): self._from_module_context = parent_context self.string_name = string_name def get_qualified_names(self, include_module_names=False): if include_module_names: if self._level: assert self._level == 1, "Everything else is not supported for now" module_names = self._from_module_context.string_names if module_names is None: return module_names return module_names + (self.string_name,) return (self.string_name,) return () @property def parent_context(self): m = self._from_module_context import_values = self.infer() if not import_values: return m # It's almost always possible to find the import or to not find it. The # importing returns only one value, pretty much always. return next(iter(import_values)).as_context() @memoize_method def infer(self): from jedi.inference.imports import Importer m = self._from_module_context return Importer(m.inference_state, [self.string_name], m, level=self._level).follow() def goto(self): return [m.name for m in self.infer()] @property def api_type(self): return 'module' def py__doc__(self): return _merge_name_docs(self.goto()) class SubModuleName(ImportName): _level = 1 class NameWrapper: def __init__(self, wrapped_name): self._wrapped_name = wrapped_name def __getattr__(self, name): return getattr(self._wrapped_name, name) def __repr__(self): return '%s(%s)' % (self.__class__.__name__, self._wrapped_name) class StubNameMixin: def py__doc__(self): from jedi.inference.gradual.conversion import convert_names # Stubs are not complicated and we can just follow simple statements # that have an equals in them, because they typically make something # else public. See e.g. stubs for `requests`. names = [self] if self.api_type == 'statement' and '=' in self.tree_name.get_definition().children: names = [v.name for v in self.infer()] names = convert_names(names, prefer_stub_to_compiled=False) if self in names: return super().py__doc__() else: # We have signatures ourselves in stubs, so don't use signatures # from the implementation. return _merge_name_docs(names) # From here on down we make looking up the sys.version_info fast. class StubName(StubNameMixin, TreeNameDefinition): def infer(self): inferred = super().infer() if self.string_name == 'version_info' and self.get_root_context().py__name__() == 'sys': from jedi.inference.gradual.stub_value import VersionInfo return ValueSet(VersionInfo(c) for c in inferred) return inferred class ModuleName(ValueNameMixin, AbstractNameDefinition): start_pos = 1, 0 def __init__(self, value, name): self._value = value self._name = name @property def string_name(self): return self._name class StubModuleName(StubNameMixin, ModuleName): pass ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/jedi/inference/param.py0000664000175000017500000002432200000000000016726 0ustar00davedave00000000000000from collections import defaultdict from inspect import Parameter from jedi import debug from jedi.inference.utils import PushBackIterator from jedi.inference import analysis from jedi.inference.lazy_value import LazyKnownValue, \ LazyTreeValue, LazyUnknownValue from jedi.inference.value import iterable from jedi.inference.names import ParamName def _add_argument_issue(error_name, lazy_value, message): if isinstance(lazy_value, LazyTreeValue): node = lazy_value.data if node.parent.type == 'argument': node = node.parent return analysis.add(lazy_value.context, error_name, node, message) class ExecutedParamName(ParamName): def __init__(self, function_value, arguments, param_node, lazy_value, is_default=False): super().__init__(function_value, param_node.name, arguments=arguments) self._lazy_value = lazy_value self._is_default = is_default def infer(self): return self._lazy_value.infer() def matches_signature(self): if self._is_default: return True argument_values = self.infer().py__class__() if self.get_kind() in (Parameter.VAR_POSITIONAL, Parameter.VAR_KEYWORD): return True annotations = self.infer_annotation(execute_annotation=False) if not annotations: # If we cannot infer annotations - or there aren't any - pretend # that the signature matches. return True matches = any(c1.is_sub_class_of(c2) for c1 in argument_values for c2 in annotations.gather_annotation_classes()) debug.dbg("param compare %s: %s <=> %s", matches, argument_values, annotations, color='BLUE') return matches def __repr__(self): return '<%s: %s>' % (self.__class__.__name__, self.string_name) def get_executed_param_names_and_issues(function_value, arguments): """ Return a tuple of: - a list of `ExecutedParamName`s corresponding to the arguments of the function execution `function_value`, containing the inferred value of those arguments (whether explicit or default) - a list of the issues encountered while building that list For example, given: ``` def foo(a, b, c=None, d='d'): ... foo(42, c='c') ``` Then for the execution of `foo`, this will return a tuple containing: - a list with entries for each parameter a, b, c & d; the entries for a, c, & d will have their values (42, 'c' and 'd' respectively) included. - a list with a single entry about the lack of a value for `b` """ def too_many_args(argument): m = _error_argument_count(funcdef, len(unpacked_va)) # Just report an error for the first param that is not needed (like # cPython). if arguments.get_calling_nodes(): # There might not be a valid calling node so check for that first. issues.append( _add_argument_issue( 'type-error-too-many-arguments', argument, message=m ) ) else: issues.append(None) debug.warning('non-public warning: %s', m) issues = [] # List[Optional[analysis issue]] result_params = [] param_dict = {} funcdef = function_value.tree_node # Default params are part of the value where the function was defined. # This means that they might have access on class variables that the # function itself doesn't have. default_param_context = function_value.get_default_param_context() for param in funcdef.get_params(): param_dict[param.name.value] = param unpacked_va = list(arguments.unpack(funcdef)) var_arg_iterator = PushBackIterator(iter(unpacked_va)) non_matching_keys = defaultdict(lambda: []) keys_used = {} keys_only = False had_multiple_value_error = False for param in funcdef.get_params(): # The value and key can both be null. There, the defaults apply. # args / kwargs will just be empty arrays / dicts, respectively. # Wrong value count is just ignored. If you try to test cases that are # not allowed in Python, Jedi will maybe not show any completions. is_default = False key, argument = next(var_arg_iterator, (None, None)) while key is not None: keys_only = True try: key_param = param_dict[key] except KeyError: non_matching_keys[key] = argument else: if key in keys_used: had_multiple_value_error = True m = ("TypeError: %s() got multiple values for keyword argument '%s'." % (funcdef.name, key)) for contextualized_node in arguments.get_calling_nodes(): issues.append( analysis.add(contextualized_node.context, 'type-error-multiple-values', contextualized_node.node, message=m) ) else: keys_used[key] = ExecutedParamName( function_value, arguments, key_param, argument) key, argument = next(var_arg_iterator, (None, None)) try: result_params.append(keys_used[param.name.value]) continue except KeyError: pass if param.star_count == 1: # *args param lazy_value_list = [] if argument is not None: lazy_value_list.append(argument) for key, argument in var_arg_iterator: # Iterate until a key argument is found. if key: var_arg_iterator.push_back((key, argument)) break lazy_value_list.append(argument) seq = iterable.FakeTuple(function_value.inference_state, lazy_value_list) result_arg = LazyKnownValue(seq) elif param.star_count == 2: if argument is not None: too_many_args(argument) # **kwargs param dct = iterable.FakeDict(function_value.inference_state, dict(non_matching_keys)) result_arg = LazyKnownValue(dct) non_matching_keys = {} else: # normal param if argument is None: # No value: Return an empty container if param.default is None: result_arg = LazyUnknownValue() if not keys_only: for contextualized_node in arguments.get_calling_nodes(): m = _error_argument_count(funcdef, len(unpacked_va)) issues.append( analysis.add( contextualized_node.context, 'type-error-too-few-arguments', contextualized_node.node, message=m, ) ) else: result_arg = LazyTreeValue(default_param_context, param.default) is_default = True else: result_arg = argument result_params.append(ExecutedParamName( function_value, arguments, param, result_arg, is_default=is_default )) if not isinstance(result_arg, LazyUnknownValue): keys_used[param.name.value] = result_params[-1] if keys_only: # All arguments should be handed over to the next function. It's not # about the values inside, it's about the names. Jedi needs to now that # there's nothing to find for certain names. for k in set(param_dict) - set(keys_used): param = param_dict[k] if not (non_matching_keys or had_multiple_value_error or param.star_count or param.default): # add a warning only if there's not another one. for contextualized_node in arguments.get_calling_nodes(): m = _error_argument_count(funcdef, len(unpacked_va)) issues.append( analysis.add(contextualized_node.context, 'type-error-too-few-arguments', contextualized_node.node, message=m) ) for key, lazy_value in non_matching_keys.items(): m = "TypeError: %s() got an unexpected keyword argument '%s'." \ % (funcdef.name, key) issues.append( _add_argument_issue( 'type-error-keyword-argument', lazy_value, message=m ) ) remaining_arguments = list(var_arg_iterator) if remaining_arguments: first_key, lazy_value = remaining_arguments[0] too_many_args(lazy_value) return result_params, issues def get_executed_param_names(function_value, arguments): """ Return a list of `ExecutedParamName`s corresponding to the arguments of the function execution `function_value`, containing the inferred value of those arguments (whether explicit or default). Any issues building this list (for example required arguments which are missing in the invocation) are ignored. For example, given: ``` def foo(a, b, c=None, d='d'): ... foo(42, c='c') ``` Then for the execution of `foo`, this will return a list containing entries for each parameter a, b, c & d; the entries for a, c, & d will have their values (42, 'c' and 'd' respectively) included. """ return get_executed_param_names_and_issues(function_value, arguments)[0] def _error_argument_count(funcdef, actual_count): params = funcdef.get_params() default_arguments = sum(1 for p in params if p.default or p.star_count) if default_arguments == 0: before = 'exactly ' else: before = 'from %s to ' % (len(params) - default_arguments) return ('TypeError: %s() takes %s%s arguments (%s given).' % (funcdef.name, before, len(params), actual_count)) ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/jedi/inference/parser_cache.py0000664000175000017500000000027700000000000020250 0ustar00davedave00000000000000from jedi.inference.cache import inference_state_function_cache @inference_state_function_cache() def get_yield_exprs(inference_state, funcdef): return list(funcdef.iter_yield_exprs()) ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/jedi/inference/recursion.py0000664000175000017500000001150400000000000017635 0ustar00davedave00000000000000""" Recursions are the recipe of |jedi| to conquer Python code. However, someone must stop recursions going mad. Some settings are here to make |jedi| stop at the right time. You can read more about them :ref:`here `. Next to the internal ``jedi.inference.cache`` this module also makes |jedi| not thread-safe, because ``execution_recursion_decorator`` uses class variables to count the function calls. .. _settings-recursion: Settings ~~~~~~~~~~ Recursion settings are important if you don't want extremely recursive python code to go absolutely crazy. The default values are based on experiments while completing the |jedi| library itself (inception!). But I don't think there's any other Python library that uses recursion in a similarly extreme way. Completion should also be fast and therefore the quality might not always be maximal. .. autodata:: recursion_limit .. autodata:: total_function_execution_limit .. autodata:: per_function_execution_limit .. autodata:: per_function_recursion_limit """ from contextlib import contextmanager from jedi import debug from jedi.inference.base_value import NO_VALUES recursion_limit = 15 """ Like :func:`sys.getrecursionlimit()`, just for |jedi|. """ total_function_execution_limit = 200 """ This is a hard limit of how many non-builtin functions can be executed. """ per_function_execution_limit = 6 """ The maximal amount of times a specific function may be executed. """ per_function_recursion_limit = 2 """ A function may not be executed more than this number of times recursively. """ class RecursionDetector: def __init__(self): self.pushed_nodes = [] @contextmanager def execution_allowed(inference_state, node): """ A decorator to detect recursions in statements. In a recursion a statement at the same place, in the same module may not be executed two times. """ pushed_nodes = inference_state.recursion_detector.pushed_nodes if node in pushed_nodes: debug.warning('catched stmt recursion: %s @%s', node, getattr(node, 'start_pos', None)) yield False else: try: pushed_nodes.append(node) yield True finally: pushed_nodes.pop() def execution_recursion_decorator(default=NO_VALUES): def decorator(func): def wrapper(self, **kwargs): detector = self.inference_state.execution_recursion_detector limit_reached = detector.push_execution(self) try: if limit_reached: result = default else: result = func(self, **kwargs) finally: detector.pop_execution() return result return wrapper return decorator class ExecutionRecursionDetector: """ Catches recursions of executions. """ def __init__(self, inference_state): self._inference_state = inference_state self._recursion_level = 0 self._parent_execution_funcs = [] self._funcdef_execution_counts = {} self._execution_count = 0 def pop_execution(self): self._parent_execution_funcs.pop() self._recursion_level -= 1 def push_execution(self, execution): funcdef = execution.tree_node # These two will be undone in pop_execution. self._recursion_level += 1 self._parent_execution_funcs.append(funcdef) module_context = execution.get_root_context() if module_context.is_builtins_module(): # We have control over builtins so we know they are not recursing # like crazy. Therefore we just let them execute always, because # they usually just help a lot with getting good results. return False if self._recursion_level > recursion_limit: debug.warning('Recursion limit (%s) reached', recursion_limit) return True if self._execution_count >= total_function_execution_limit: debug.warning('Function execution limit (%s) reached', total_function_execution_limit) return True self._execution_count += 1 if self._funcdef_execution_counts.setdefault(funcdef, 0) >= per_function_execution_limit: if module_context.py__name__() == 'typing': return False debug.warning( 'Per function execution limit (%s) reached: %s', per_function_execution_limit, funcdef ) return True self._funcdef_execution_counts[funcdef] += 1 if self._parent_execution_funcs.count(funcdef) > per_function_recursion_limit: debug.warning( 'Per function recursion limit (%s) reached: %s', per_function_recursion_limit, funcdef ) return True return False ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/jedi/inference/references.py0000664000175000017500000002621700000000000017754 0ustar00davedave00000000000000import os import re from parso import python_bytes_to_unicode from jedi.debug import dbg from jedi.file_io import KnownContentFileIO, FolderIO from jedi.inference.names import SubModuleName from jedi.inference.imports import load_module_from_path from jedi.inference.filters import ParserTreeFilter from jedi.inference.gradual.conversion import convert_names _IGNORE_FOLDERS = ('.tox', '.venv', '.mypy_cache', 'venv', '__pycache__') _OPENED_FILE_LIMIT = 2000 """ Stats from a 2016 Lenovo Notebook running Linux: With os.walk, it takes about 10s to scan 11'000 files (without filesystem caching). Once cached it only takes 5s. So it is expected that reading all those files might take a few seconds, but not a lot more. """ _PARSED_FILE_LIMIT = 30 """ For now we keep the amount of parsed files really low, since parsing might take easily 100ms for bigger files. """ def _resolve_names(definition_names, avoid_names=()): for name in definition_names: if name in avoid_names: # Avoiding recursions here, because goto on a module name lands # on the same module. continue if not isinstance(name, SubModuleName): # SubModuleNames are not actually existing names but created # names when importing something like `import foo.bar.baz`. yield name if name.api_type == 'module': yield from _resolve_names(name.goto(), definition_names) def _dictionarize(names): return dict( (n if n.tree_name is None else n.tree_name, n) for n in names ) def _find_defining_names(module_context, tree_name): found_names = _find_names(module_context, tree_name) for name in list(found_names): # Convert from/to stubs, because those might also be usages. found_names |= set(convert_names( [name], only_stubs=not name.get_root_context().is_stub(), prefer_stub_to_compiled=False )) found_names |= set(_find_global_variables(found_names, tree_name.value)) for name in list(found_names): if name.api_type == 'param' or name.tree_name is None \ or name.tree_name.parent.type == 'trailer': continue found_names |= set(_add_names_in_same_context(name.parent_context, name.string_name)) return set(_resolve_names(found_names)) def _find_names(module_context, tree_name): name = module_context.create_name(tree_name) found_names = set(name.goto()) found_names.add(name) return set(_resolve_names(found_names)) def _add_names_in_same_context(context, string_name): if context.tree_node is None: return until_position = None while True: filter_ = ParserTreeFilter( parent_context=context, until_position=until_position, ) names = set(filter_.get(string_name)) if not names: break yield from names ordered = sorted(names, key=lambda x: x.start_pos) until_position = ordered[0].start_pos def _find_global_variables(names, search_name): for name in names: if name.tree_name is None: continue module_context = name.get_root_context() try: method = module_context.get_global_filter except AttributeError: continue else: for global_name in method().get(search_name): yield global_name c = module_context.create_context(global_name.tree_name) yield from _add_names_in_same_context(c, global_name.string_name) def find_references(module_context, tree_name, only_in_module=False): inf = module_context.inference_state search_name = tree_name.value # We disable flow analysis, because if we have ifs that are only true in # certain cases, we want both sides. try: inf.flow_analysis_enabled = False found_names = _find_defining_names(module_context, tree_name) finally: inf.flow_analysis_enabled = True found_names_dct = _dictionarize(found_names) module_contexts = [module_context] if not only_in_module: for m in set(d.get_root_context() for d in found_names): if m != module_context and m.tree_node is not None \ and inf.project.path in m.py__file__().parents: module_contexts.append(m) # For param no search for other modules is necessary. if only_in_module or any(n.api_type == 'param' for n in found_names): potential_modules = module_contexts else: potential_modules = get_module_contexts_containing_name( inf, module_contexts, search_name, ) non_matching_reference_maps = {} for module_context in potential_modules: for name_leaf in module_context.tree_node.get_used_names().get(search_name, []): new = _dictionarize(_find_names(module_context, name_leaf)) if any(tree_name in found_names_dct for tree_name in new): found_names_dct.update(new) for tree_name in new: for dct in non_matching_reference_maps.get(tree_name, []): # A reference that was previously searched for matches # with a now found name. Merge. found_names_dct.update(dct) try: del non_matching_reference_maps[tree_name] except KeyError: pass else: for name in new: non_matching_reference_maps.setdefault(name, []).append(new) result = found_names_dct.values() if only_in_module: return [n for n in result if n.get_root_context() == module_context] return result def _check_fs(inference_state, file_io, regex): try: code = file_io.read() except FileNotFoundError: return None code = python_bytes_to_unicode(code, errors='replace') if not regex.search(code): return None new_file_io = KnownContentFileIO(file_io.path, code) m = load_module_from_path(inference_state, new_file_io) if m.is_compiled(): return None return m.as_context() def gitignored_paths(folder_io, file_io): ignored_paths_abs = set() ignored_paths_rel = set() for l in file_io.read().splitlines(): if not l or l.startswith(b'#') or l.startswith(b'!') or b'*' in l: continue p = l.decode('utf-8', 'ignore').rstrip('/') if '/' in p: name = p.lstrip('/') ignored_paths_abs.add(os.path.join(folder_io.path, name)) else: name = p ignored_paths_rel.add((folder_io.path, name)) return ignored_paths_abs, ignored_paths_rel def expand_relative_ignore_paths(folder_io, relative_paths): curr_path = folder_io.path return {os.path.join(curr_path, p[1]) for p in relative_paths if curr_path.startswith(p[0])} def recurse_find_python_folders_and_files(folder_io, except_paths=()): except_paths = set(except_paths) except_paths_relative = set() for root_folder_io, folder_ios, file_ios in folder_io.walk(): # Delete folders that we don't want to iterate over. for file_io in file_ios: path = file_io.path if path.suffix in ('.py', '.pyi'): if path not in except_paths: yield None, file_io if path.name == '.gitignore': ignored_paths_abs, ignored_paths_rel = gitignored_paths( root_folder_io, file_io ) except_paths |= ignored_paths_abs except_paths_relative |= ignored_paths_rel except_paths_relative_expanded = expand_relative_ignore_paths( root_folder_io, except_paths_relative ) folder_ios[:] = [ folder_io for folder_io in folder_ios if folder_io.path not in except_paths and folder_io.path not in except_paths_relative_expanded and folder_io.get_base_name() not in _IGNORE_FOLDERS ] for folder_io in folder_ios: yield folder_io, None def recurse_find_python_files(folder_io, except_paths=()): for folder_io, file_io in recurse_find_python_folders_and_files(folder_io, except_paths): if file_io is not None: yield file_io def _find_python_files_in_sys_path(inference_state, module_contexts): sys_path = inference_state.get_sys_path() except_paths = set() yielded_paths = [m.py__file__() for m in module_contexts] for module_context in module_contexts: file_io = module_context.get_value().file_io if file_io is None: continue folder_io = file_io.get_parent_folder() while True: path = folder_io.path if not any(path.startswith(p) for p in sys_path) or path in except_paths: break for file_io in recurse_find_python_files(folder_io, except_paths): if file_io.path not in yielded_paths: yield file_io except_paths.add(path) folder_io = folder_io.get_parent_folder() def _find_project_modules(inference_state, module_contexts): except_ = [m.py__file__() for m in module_contexts] yield from recurse_find_python_files(FolderIO(inference_state.project.path), except_) def get_module_contexts_containing_name(inference_state, module_contexts, name, limit_reduction=1): """ Search a name in the directories of modules. :param limit_reduction: Divides the limits on opening/parsing files by this factor. """ # Skip non python modules for module_context in module_contexts: if module_context.is_compiled(): continue yield module_context # Very short names are not searched in other modules for now to avoid lots # of file lookups. if len(name) <= 2: return # Currently not used, because there's only `scope=project` and `scope=file` # At the moment there is no such thing as `scope=sys.path`. # file_io_iterator = _find_python_files_in_sys_path(inference_state, module_contexts) file_io_iterator = _find_project_modules(inference_state, module_contexts) yield from search_in_file_ios(inference_state, file_io_iterator, name, limit_reduction=limit_reduction) def search_in_file_ios(inference_state, file_io_iterator, name, limit_reduction=1, complete=False): parse_limit = _PARSED_FILE_LIMIT / limit_reduction open_limit = _OPENED_FILE_LIMIT / limit_reduction file_io_count = 0 parsed_file_count = 0 regex = re.compile(r'\b' + re.escape(name) + (r'' if complete else r'\b')) for file_io in file_io_iterator: file_io_count += 1 m = _check_fs(inference_state, file_io, regex) if m is not None: parsed_file_count += 1 yield m if parsed_file_count >= parse_limit: dbg('Hit limit of parsed files: %s', parse_limit) break if file_io_count >= open_limit: dbg('Hit limit of opened files: %s', open_limit) break ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/jedi/inference/signature.py0000664000175000017500000001137300000000000017631 0ustar00davedave00000000000000from inspect import Parameter from jedi.cache import memoize_method from jedi import debug from jedi import parser_utils class _SignatureMixin: def to_string(self): def param_strings(): is_positional = False is_kw_only = False for n in self.get_param_names(resolve_stars=True): kind = n.get_kind() is_positional |= kind == Parameter.POSITIONAL_ONLY if is_positional and kind != Parameter.POSITIONAL_ONLY: yield '/' is_positional = False if kind == Parameter.VAR_POSITIONAL: is_kw_only = True elif kind == Parameter.KEYWORD_ONLY and not is_kw_only: yield '*' is_kw_only = True yield n.to_string() if is_positional: yield '/' s = self.name.string_name + '(' + ', '.join(param_strings()) + ')' annotation = self.annotation_string if annotation: s += ' -> ' + annotation return s class AbstractSignature(_SignatureMixin): def __init__(self, value, is_bound=False): self.value = value self.is_bound = is_bound @property def name(self): return self.value.name @property def annotation_string(self): return '' def get_param_names(self, resolve_stars=False): param_names = self._function_value.get_param_names() if self.is_bound: return param_names[1:] return param_names def bind(self, value): raise NotImplementedError def matches_signature(self, arguments): return True def __repr__(self): if self.value is self._function_value: return '<%s: %s>' % (self.__class__.__name__, self.value) return '<%s: %s, %s>' % (self.__class__.__name__, self.value, self._function_value) class TreeSignature(AbstractSignature): def __init__(self, value, function_value=None, is_bound=False): super().__init__(value, is_bound) self._function_value = function_value or value def bind(self, value): return TreeSignature(value, self._function_value, is_bound=True) @property def _annotation(self): # Classes don't need annotations, even if __init__ has one. They always # return themselves. if self.value.is_class(): return None return self._function_value.tree_node.annotation @property def annotation_string(self): a = self._annotation if a is None: return '' return a.get_code(include_prefix=False) @memoize_method def get_param_names(self, resolve_stars=False): params = self._function_value.get_param_names() if resolve_stars: from jedi.inference.star_args import process_params params = process_params(params) if self.is_bound: return params[1:] return params def matches_signature(self, arguments): from jedi.inference.param import get_executed_param_names_and_issues executed_param_names, issues = \ get_executed_param_names_and_issues(self._function_value, arguments) if issues: return False matches = all(executed_param_name.matches_signature() for executed_param_name in executed_param_names) if debug.enable_notice: tree_node = self._function_value.tree_node signature = parser_utils.get_signature(tree_node) if matches: debug.dbg("Overloading match: %s@%s (%s)", signature, tree_node.start_pos[0], arguments, color='BLUE') else: debug.dbg("Overloading no match: %s@%s (%s)", signature, tree_node.start_pos[0], arguments, color='BLUE') return matches class BuiltinSignature(AbstractSignature): def __init__(self, value, return_string, function_value=None, is_bound=False): super().__init__(value, is_bound) self._return_string = return_string self.__function_value = function_value @property def annotation_string(self): return self._return_string @property def _function_value(self): if self.__function_value is None: return self.value return self.__function_value def bind(self, value): return BuiltinSignature( value, self._return_string, function_value=self.value, is_bound=True ) class SignatureWrapper(_SignatureMixin): def __init__(self, wrapped_signature): self._wrapped_signature = wrapped_signature def __getattr__(self, name): return getattr(self._wrapped_signature, name) ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/jedi/inference/star_args.py0000664000175000017500000001732700000000000017622 0ustar00davedave00000000000000""" This module is responsible for inferring *args and **kwargs for signatures. This means for example in this case:: def foo(a, b, c): ... def bar(*args): return foo(1, *args) The signature here for bar should be `bar(b, c)` instead of bar(*args). """ from inspect import Parameter from parso import tree from jedi.inference.utils import to_list from jedi.inference.names import ParamNameWrapper from jedi.inference.helpers import is_big_annoying_library def _iter_nodes_for_param(param_name): from parso.python.tree import search_ancestor from jedi.inference.arguments import TreeArguments execution_context = param_name.parent_context # Walk up the parso tree to get the FunctionNode we want. We use the parso # tree rather than going via the execution context so that we're agnostic of # the specific scope we're evaluating within (i.e: module or function, # etc.). function_node = tree.search_ancestor(param_name.tree_name, 'funcdef', 'lambdef') module_node = function_node.get_root_node() start = function_node.children[-1].start_pos end = function_node.children[-1].end_pos for name in module_node.get_used_names().get(param_name.string_name): if start <= name.start_pos < end: # Is used in the function argument = name.parent if argument.type == 'argument' \ and argument.children[0] == '*' * param_name.star_count: trailer = search_ancestor(argument, 'trailer') if trailer is not None: # Make sure we're in a function context = execution_context.create_context(trailer) if _goes_to_param_name(param_name, context, name): values = _to_callables(context, trailer) args = TreeArguments.create_cached( execution_context.inference_state, context=context, argument_node=trailer.children[1], trailer=trailer, ) for c in values: yield c, args def _goes_to_param_name(param_name, context, potential_name): if potential_name.type != 'name': return False from jedi.inference.names import TreeNameDefinition found = TreeNameDefinition(context, potential_name).goto() return any(param_name.parent_context == p.parent_context and param_name.start_pos == p.start_pos for p in found) def _to_callables(context, trailer): from jedi.inference.syntax_tree import infer_trailer atom_expr = trailer.parent index = atom_expr.children[0] == 'await' # Infer atom first values = context.infer_node(atom_expr.children[index]) for trailer2 in atom_expr.children[index + 1:]: if trailer == trailer2: break values = infer_trailer(context, values, trailer2) return values def _remove_given_params(arguments, param_names): count = 0 used_keys = set() for key, _ in arguments.unpack(): if key is None: count += 1 else: used_keys.add(key) for p in param_names: if count and p.maybe_positional_argument(): count -= 1 continue if p.string_name in used_keys and p.maybe_keyword_argument(): continue yield p @to_list def process_params(param_names, star_count=3): # default means both * and ** if param_names: if is_big_annoying_library(param_names[0].parent_context): # At first this feature can look innocent, but it does a lot of # type inference in some cases, so we just ditch it. yield from param_names return used_names = set() arg_callables = [] kwarg_callables = [] kw_only_names = [] kwarg_names = [] arg_names = [] original_arg_name = None original_kwarg_name = None for p in param_names: kind = p.get_kind() if kind == Parameter.VAR_POSITIONAL: if star_count & 1: arg_callables = _iter_nodes_for_param(p) original_arg_name = p elif p.get_kind() == Parameter.VAR_KEYWORD: if star_count & 2: kwarg_callables = list(_iter_nodes_for_param(p)) original_kwarg_name = p elif kind == Parameter.KEYWORD_ONLY: if star_count & 2: kw_only_names.append(p) elif kind == Parameter.POSITIONAL_ONLY: if star_count & 1: yield p else: if star_count == 1: yield ParamNameFixedKind(p, Parameter.POSITIONAL_ONLY) elif star_count == 2: kw_only_names.append(ParamNameFixedKind(p, Parameter.KEYWORD_ONLY)) else: used_names.add(p.string_name) yield p # First process *args longest_param_names = () found_arg_signature = False found_kwarg_signature = False for func_and_argument in arg_callables: func, arguments = func_and_argument new_star_count = star_count if func_and_argument in kwarg_callables: kwarg_callables.remove(func_and_argument) else: new_star_count = 1 for signature in func.get_signatures(): found_arg_signature = True if new_star_count == 3: found_kwarg_signature = True args_for_this_func = [] for p in process_params( list(_remove_given_params( arguments, signature.get_param_names(resolve_stars=False) )), new_star_count): if p.get_kind() == Parameter.VAR_KEYWORD: kwarg_names.append(p) elif p.get_kind() == Parameter.VAR_POSITIONAL: arg_names.append(p) elif p.get_kind() == Parameter.KEYWORD_ONLY: kw_only_names.append(p) else: args_for_this_func.append(p) if len(args_for_this_func) > len(longest_param_names): longest_param_names = args_for_this_func for p in longest_param_names: if star_count == 1 and p.get_kind() != Parameter.VAR_POSITIONAL: yield ParamNameFixedKind(p, Parameter.POSITIONAL_ONLY) else: if p.get_kind() == Parameter.POSITIONAL_OR_KEYWORD: used_names.add(p.string_name) yield p if not found_arg_signature and original_arg_name is not None: yield original_arg_name elif arg_names: yield arg_names[0] # Then process **kwargs for func, arguments in kwarg_callables: for signature in func.get_signatures(): found_kwarg_signature = True for p in process_params( list(_remove_given_params( arguments, signature.get_param_names(resolve_stars=False) )), star_count=2): if p.get_kind() == Parameter.VAR_KEYWORD: kwarg_names.append(p) elif p.get_kind() == Parameter.KEYWORD_ONLY: kw_only_names.append(p) for p in kw_only_names: if p.string_name in used_names: continue yield p used_names.add(p.string_name) if not found_kwarg_signature and original_kwarg_name is not None: yield original_kwarg_name elif kwarg_names: yield kwarg_names[0] class ParamNameFixedKind(ParamNameWrapper): def __init__(self, param_name, new_kind): super().__init__(param_name) self._new_kind = new_kind def get_kind(self): return self._new_kind ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/jedi/inference/syntax_tree.py0000664000175000017500000010565100000000000020200 0ustar00davedave00000000000000""" Functions inferring the syntax tree. """ import copy import itertools from parso.python import tree from jedi import debug from jedi import parser_utils from jedi.inference.base_value import ValueSet, NO_VALUES, ContextualizedNode, \ iterator_to_value_set, iterate_values from jedi.inference.lazy_value import LazyTreeValue from jedi.inference import compiled from jedi.inference import recursion from jedi.inference import analysis from jedi.inference import imports from jedi.inference import arguments from jedi.inference.value import ClassValue, FunctionValue from jedi.inference.value import iterable from jedi.inference.value.dynamic_arrays import ListModification, DictModification from jedi.inference.value import TreeInstance from jedi.inference.helpers import is_string, is_literal, is_number, \ get_names_of_node, is_big_annoying_library from jedi.inference.compiled.access import COMPARISON_OPERATORS from jedi.inference.cache import inference_state_method_cache from jedi.inference.gradual.stub_value import VersionInfo from jedi.inference.gradual import annotation from jedi.inference.names import TreeNameDefinition from jedi.inference.context import CompForContext from jedi.inference.value.decorator import Decoratee from jedi.plugins import plugin_manager operator_to_magic_method = { '+': '__add__', '-': '__sub__', '*': '__mul__', '@': '__matmul__', '/': '__truediv__', '//': '__floordiv__', '%': '__mod__', '**': '__pow__', '<<': '__lshift__', '>>': '__rshift__', '&': '__and__', '|': '__or__', '^': '__xor__', } reverse_operator_to_magic_method = { k: '__r' + v[2:] for k, v in operator_to_magic_method.items() } def _limit_value_infers(func): """ This is for now the way how we limit type inference going wild. There are other ways to ensure recursion limits as well. This is mostly necessary because of instance (self) access that can be quite tricky to limit. I'm still not sure this is the way to go, but it looks okay for now and we can still go anther way in the future. Tests are there. ~ dave """ def wrapper(context, *args, **kwargs): n = context.tree_node inference_state = context.inference_state try: inference_state.inferred_element_counts[n] += 1 maximum = 300 if context.parent_context is None \ and context.get_value() is inference_state.builtins_module: # Builtins should have a more generous inference limit. # It is important that builtins can be executed, otherwise some # functions that depend on certain builtins features would be # broken, see e.g. GH #1432 maximum *= 100 if inference_state.inferred_element_counts[n] > maximum: debug.warning('In value %s there were too many inferences.', n) return NO_VALUES except KeyError: inference_state.inferred_element_counts[n] = 1 return func(context, *args, **kwargs) return wrapper def infer_node(context, element): if isinstance(context, CompForContext): return _infer_node(context, element) if_stmt = element while if_stmt is not None: if_stmt = if_stmt.parent if if_stmt.type in ('if_stmt', 'for_stmt'): break if parser_utils.is_scope(if_stmt): if_stmt = None break predefined_if_name_dict = context.predefined_names.get(if_stmt) # TODO there's a lot of issues with this one. We actually should do # this in a different way. Caching should only be active in certain # cases and this all sucks. if predefined_if_name_dict is None and if_stmt \ and if_stmt.type == 'if_stmt' and context.inference_state.is_analysis: if_stmt_test = if_stmt.children[1] name_dicts = [{}] # If we already did a check, we don't want to do it again -> If # value.predefined_names is filled, we stop. # We don't want to check the if stmt itself, it's just about # the content. if element.start_pos > if_stmt_test.end_pos: # Now we need to check if the names in the if_stmt match the # names in the suite. if_names = get_names_of_node(if_stmt_test) element_names = get_names_of_node(element) str_element_names = [e.value for e in element_names] if any(i.value in str_element_names for i in if_names): for if_name in if_names: definitions = context.inference_state.infer(context, if_name) # Every name that has multiple different definitions # causes the complexity to rise. The complexity should # never fall below 1. if len(definitions) > 1: if len(name_dicts) * len(definitions) > 16: debug.dbg('Too many options for if branch inference %s.', if_stmt) # There's only a certain amount of branches # Jedi can infer, otherwise it will take to # long. name_dicts = [{}] break original_name_dicts = list(name_dicts) name_dicts = [] for definition in definitions: new_name_dicts = list(original_name_dicts) for i, name_dict in enumerate(new_name_dicts): new_name_dicts[i] = name_dict.copy() new_name_dicts[i][if_name.value] = ValueSet([definition]) name_dicts += new_name_dicts else: for name_dict in name_dicts: name_dict[if_name.value] = definitions if len(name_dicts) > 1: result = NO_VALUES for name_dict in name_dicts: with context.predefine_names(if_stmt, name_dict): result |= _infer_node(context, element) return result else: return _infer_node_if_inferred(context, element) else: if predefined_if_name_dict: return _infer_node(context, element) else: return _infer_node_if_inferred(context, element) def _infer_node_if_inferred(context, element): """ TODO This function is temporary: Merge with infer_node. """ parent = element while parent is not None: parent = parent.parent predefined_if_name_dict = context.predefined_names.get(parent) if predefined_if_name_dict is not None: return _infer_node(context, element) return _infer_node_cached(context, element) @inference_state_method_cache(default=NO_VALUES) def _infer_node_cached(context, element): return _infer_node(context, element) @debug.increase_indent @_limit_value_infers def _infer_node(context, element): debug.dbg('infer_node %s@%s in %s', element, element.start_pos, context) inference_state = context.inference_state typ = element.type if typ in ('name', 'number', 'string', 'atom', 'strings', 'keyword', 'fstring'): return infer_atom(context, element) elif typ == 'lambdef': return ValueSet([FunctionValue.from_context(context, element)]) elif typ == 'expr_stmt': return infer_expr_stmt(context, element) elif typ in ('power', 'atom_expr'): first_child = element.children[0] children = element.children[1:] had_await = False if first_child.type == 'keyword' and first_child.value == 'await': had_await = True first_child = children.pop(0) value_set = context.infer_node(first_child) for (i, trailer) in enumerate(children): if trailer == '**': # has a power operation. right = context.infer_node(children[i + 1]) value_set = _infer_comparison( context, value_set, trailer, right ) break value_set = infer_trailer(context, value_set, trailer) if had_await: return value_set.py__await__().py__stop_iteration_returns() return value_set elif typ in ('testlist_star_expr', 'testlist',): # The implicit tuple in statements. return ValueSet([iterable.SequenceLiteralValue(inference_state, context, element)]) elif typ in ('not_test', 'factor'): value_set = context.infer_node(element.children[-1]) for operator in element.children[:-1]: value_set = infer_factor(value_set, operator) return value_set elif typ == 'test': # `x if foo else y` case. return (context.infer_node(element.children[0]) | context.infer_node(element.children[-1])) elif typ == 'operator': # Must be an ellipsis, other operators are not inferred. if element.value != '...': origin = element.parent raise AssertionError("unhandled operator %s in %s " % (repr(element.value), origin)) return ValueSet([compiled.builtin_from_name(inference_state, 'Ellipsis')]) elif typ == 'dotted_name': value_set = infer_atom(context, element.children[0]) for next_name in element.children[2::2]: value_set = value_set.py__getattribute__(next_name, name_context=context) return value_set elif typ == 'eval_input': return context.infer_node(element.children[0]) elif typ == 'annassign': return annotation.infer_annotation(context, element.children[1]) \ .execute_annotation() elif typ == 'yield_expr': if len(element.children) and element.children[1].type == 'yield_arg': # Implies that it's a yield from. element = element.children[1].children[1] generators = context.infer_node(element) \ .py__getattribute__('__iter__').execute_with_values() return generators.py__stop_iteration_returns() # Generator.send() is not implemented. return NO_VALUES elif typ == 'namedexpr_test': return context.infer_node(element.children[2]) else: return infer_or_test(context, element) def infer_trailer(context, atom_values, trailer): trailer_op, node = trailer.children[:2] if node == ')': # `arglist` is optional. node = None if trailer_op == '[': trailer_op, node, _ = trailer.children return atom_values.get_item( _infer_subscript_list(context, node), ContextualizedNode(context, trailer) ) else: debug.dbg('infer_trailer: %s in %s', trailer, atom_values) if trailer_op == '.': return atom_values.py__getattribute__( name_context=context, name_or_str=node ) else: assert trailer_op == '(', 'trailer_op is actually %s' % trailer_op args = arguments.TreeArguments(context.inference_state, context, node, trailer) return atom_values.execute(args) def infer_atom(context, atom): """ Basically to process ``atom`` nodes. The parser sometimes doesn't generate the node (because it has just one child). In that case an atom might be a name or a literal as well. """ state = context.inference_state if atom.type == 'name': # This is the first global lookup. stmt = tree.search_ancestor(atom, 'expr_stmt', 'lambdef', 'if_stmt') or atom if stmt.type == 'if_stmt': if not any(n.start_pos <= atom.start_pos < n.end_pos for n in stmt.get_test_nodes()): stmt = atom elif stmt.type == 'lambdef': stmt = atom position = stmt.start_pos if _is_annotation_name(atom): # Since Python 3.7 (with from __future__ import annotations), # annotations are essentially strings and can reference objects # that are defined further down in code. Therefore just set the # position to None, so the finder will not try to stop at a certain # position in the module. position = None return context.py__getattribute__(atom, position=position) elif atom.type == 'keyword': # For False/True/None if atom.value in ('False', 'True', 'None'): return ValueSet([compiled.builtin_from_name(state, atom.value)]) elif atom.value == 'yield': # Contrary to yield from, yield can just appear alone to return a # value when used with `.send()`. return NO_VALUES assert False, 'Cannot infer the keyword %s' % atom elif isinstance(atom, tree.Literal): string = state.compiled_subprocess.safe_literal_eval(atom.value) return ValueSet([compiled.create_simple_object(state, string)]) elif atom.type == 'strings': # Will be multiple string. value_set = infer_atom(context, atom.children[0]) for string in atom.children[1:]: right = infer_atom(context, string) value_set = _infer_comparison(context, value_set, '+', right) return value_set elif atom.type == 'fstring': return compiled.get_string_value_set(state) else: c = atom.children # Parentheses without commas are not tuples. if c[0] == '(' and not len(c) == 2 \ and not (c[1].type == 'testlist_comp' and len(c[1].children) > 1): return context.infer_node(c[1]) try: comp_for = c[1].children[1] except (IndexError, AttributeError): pass else: if comp_for == ':': # Dict comprehensions have a colon at the 3rd index. try: comp_for = c[1].children[3] except IndexError: pass if comp_for.type in ('comp_for', 'sync_comp_for'): return ValueSet([iterable.comprehension_from_atom( state, context, atom )]) # It's a dict/list/tuple literal. array_node = c[1] try: array_node_c = array_node.children except AttributeError: array_node_c = [] if c[0] == '{' and (array_node == '}' or ':' in array_node_c or '**' in array_node_c): new_value = iterable.DictLiteralValue(state, context, atom) else: new_value = iterable.SequenceLiteralValue(state, context, atom) return ValueSet([new_value]) @_limit_value_infers def infer_expr_stmt(context, stmt, seek_name=None): with recursion.execution_allowed(context.inference_state, stmt) as allowed: if allowed: if seek_name is not None: pep0484_values = \ annotation.find_type_from_comment_hint_assign(context, stmt, seek_name) if pep0484_values: return pep0484_values return _infer_expr_stmt(context, stmt, seek_name) return NO_VALUES @debug.increase_indent def _infer_expr_stmt(context, stmt, seek_name=None): """ The starting point of the completion. A statement always owns a call list, which are the calls, that a statement does. In case multiple names are defined in the statement, `seek_name` returns the result for this name. expr_stmt: testlist_star_expr (annassign | augassign (yield_expr|testlist) | ('=' (yield_expr|testlist_star_expr))*) annassign: ':' test ['=' test] augassign: ('+=' | '-=' | '*=' | '@=' | '/=' | '%=' | '&=' | '|=' | '^=' | '<<=' | '>>=' | '**=' | '//=') :param stmt: A `tree.ExprStmt`. """ def check_setitem(stmt): atom_expr = stmt.children[0] if atom_expr.type not in ('atom_expr', 'power'): return False, None name = atom_expr.children[0] if name.type != 'name' or len(atom_expr.children) != 2: return False, None trailer = atom_expr.children[-1] return trailer.children[0] == '[', trailer.children[1] debug.dbg('infer_expr_stmt %s (%s)', stmt, seek_name) rhs = stmt.get_rhs() value_set = context.infer_node(rhs) if seek_name: n = TreeNameDefinition(context, seek_name) value_set = check_tuple_assignments(n, value_set) first_operator = next(stmt.yield_operators(), None) is_setitem, subscriptlist = check_setitem(stmt) is_annassign = first_operator not in ('=', None) and first_operator.type == 'operator' if is_annassign or is_setitem: # `=` is always the last character in aug assignments -> -1 name = stmt.get_defined_names(include_setitem=True)[0].value left_values = context.py__getattribute__(name, position=stmt.start_pos) if is_setitem: def to_mod(v): c = ContextualizedSubscriptListNode(context, subscriptlist) if v.array_type == 'dict': return DictModification(v, value_set, c) elif v.array_type == 'list': return ListModification(v, value_set, c) return v value_set = ValueSet(to_mod(v) for v in left_values) else: operator = copy.copy(first_operator) operator.value = operator.value[:-1] for_stmt = tree.search_ancestor(stmt, 'for_stmt') if for_stmt is not None and for_stmt.type == 'for_stmt' and value_set \ and parser_utils.for_stmt_defines_one_name(for_stmt): # Iterate through result and add the values, that's possible # only in for loops without clutter, because they are # predictable. Also only do it, if the variable is not a tuple. node = for_stmt.get_testlist() cn = ContextualizedNode(context, node) ordered = list(cn.infer().iterate(cn)) for lazy_value in ordered: dct = {for_stmt.children[1].value: lazy_value.infer()} with context.predefine_names(for_stmt, dct): t = context.infer_node(rhs) left_values = _infer_comparison(context, left_values, operator, t) value_set = left_values else: value_set = _infer_comparison(context, left_values, operator, value_set) debug.dbg('infer_expr_stmt result %s', value_set) return value_set def infer_or_test(context, or_test): iterator = iter(or_test.children) types = context.infer_node(next(iterator)) for operator in iterator: right = next(iterator) if operator.type == 'comp_op': # not in / is not operator = ' '.join(c.value for c in operator.children) # handle type inference of and/or here. if operator in ('and', 'or'): left_bools = set(left.py__bool__() for left in types) if left_bools == {True}: if operator == 'and': types = context.infer_node(right) elif left_bools == {False}: if operator != 'and': types = context.infer_node(right) # Otherwise continue, because of uncertainty. else: types = _infer_comparison(context, types, operator, context.infer_node(right)) debug.dbg('infer_or_test types %s', types) return types @iterator_to_value_set def infer_factor(value_set, operator): """ Calculates `+`, `-`, `~` and `not` prefixes. """ for value in value_set: if operator == '-': if is_number(value): yield value.negate() elif operator == 'not': b = value.py__bool__() if b is None: # Uncertainty. return yield compiled.create_simple_object(value.inference_state, not b) else: yield value def _literals_to_types(inference_state, result): # Changes literals ('a', 1, 1.0, etc) to its type instances (str(), # int(), float(), etc). new_result = NO_VALUES for typ in result: if is_literal(typ): # Literals are only valid as long as the operations are # correct. Otherwise add a value-free instance. cls = compiled.builtin_from_name(inference_state, typ.name.string_name) new_result |= cls.execute_with_values() else: new_result |= ValueSet([typ]) return new_result def _infer_comparison(context, left_values, operator, right_values): state = context.inference_state if isinstance(operator, str): operator_str = operator else: operator_str = str(operator.value) if not left_values or not right_values: # illegal slices e.g. cause left/right_result to be None result = (left_values or NO_VALUES) | (right_values or NO_VALUES) return _literals_to_types(state, result) elif operator_str == "|" and all( value.is_class() or value.is_compiled() for value in itertools.chain(left_values, right_values) ): # ^^^ A naive hack for PEP 604 return ValueSet.from_sets((left_values, right_values)) else: # I don't think there's a reasonable chance that a string # operation is still correct, once we pass something like six # objects. if len(left_values) * len(right_values) > 6: return _literals_to_types(state, left_values | right_values) else: return ValueSet.from_sets( _infer_comparison_part(state, context, left, operator, right) for left in left_values for right in right_values ) def _is_annotation_name(name): ancestor = tree.search_ancestor(name, 'param', 'funcdef', 'expr_stmt') if ancestor is None: return False if ancestor.type in ('param', 'funcdef'): ann = ancestor.annotation if ann is not None: return ann.start_pos <= name.start_pos < ann.end_pos elif ancestor.type == 'expr_stmt': c = ancestor.children if len(c) > 1 and c[1].type == 'annassign': return c[1].start_pos <= name.start_pos < c[1].end_pos return False def _is_list(value): return value.array_type == 'list' def _is_tuple(value): return value.array_type == 'tuple' def _bool_to_value(inference_state, bool_): return compiled.builtin_from_name(inference_state, str(bool_)) def _get_tuple_ints(value): if not isinstance(value, iterable.SequenceLiteralValue): return None numbers = [] for lazy_value in value.py__iter__(): if not isinstance(lazy_value, LazyTreeValue): return None node = lazy_value.data if node.type != 'number': return None try: numbers.append(int(node.value)) except ValueError: return None return numbers def _infer_comparison_part(inference_state, context, left, operator, right): l_is_num = is_number(left) r_is_num = is_number(right) if isinstance(operator, str): str_operator = operator else: str_operator = str(operator.value) if str_operator == '*': # for iterables, ignore * operations if isinstance(left, iterable.Sequence) or is_string(left): return ValueSet([left]) elif isinstance(right, iterable.Sequence) or is_string(right): return ValueSet([right]) elif str_operator == '+': if l_is_num and r_is_num or is_string(left) and is_string(right): return left.execute_operation(right, str_operator) elif _is_list(left) and _is_list(right) or _is_tuple(left) and _is_tuple(right): return ValueSet([iterable.MergedArray(inference_state, (left, right))]) elif str_operator == '-': if l_is_num and r_is_num: return left.execute_operation(right, str_operator) elif str_operator == '%': # With strings and numbers the left type typically remains. Except for # `int() % float()`. return ValueSet([left]) elif str_operator in COMPARISON_OPERATORS: if left.is_compiled() and right.is_compiled(): # Possible, because the return is not an option. Just compare. result = left.execute_operation(right, str_operator) if result: return result else: if str_operator in ('is', '!=', '==', 'is not'): operation = COMPARISON_OPERATORS[str_operator] bool_ = operation(left, right) # Only if == returns True or != returns False, we can continue. # There's no guarantee that they are not equal. This can help # in some cases, but does not cover everything. if (str_operator in ('is', '==')) == bool_: return ValueSet([_bool_to_value(inference_state, bool_)]) if isinstance(left, VersionInfo): version_info = _get_tuple_ints(right) if version_info is not None: bool_result = compiled.access.COMPARISON_OPERATORS[operator]( inference_state.environment.version_info, tuple(version_info) ) return ValueSet([_bool_to_value(inference_state, bool_result)]) return ValueSet([ _bool_to_value(inference_state, True), _bool_to_value(inference_state, False) ]) elif str_operator in ('in', 'not in'): return NO_VALUES def check(obj): """Checks if a Jedi object is either a float or an int.""" return isinstance(obj, TreeInstance) and \ obj.name.string_name in ('int', 'float') # Static analysis, one is a number, the other one is not. if str_operator in ('+', '-') and l_is_num != r_is_num \ and not (check(left) or check(right)): message = "TypeError: unsupported operand type(s) for +: %s and %s" analysis.add(context, 'type-error-operation', operator, message % (left, right)) if left.is_class() or right.is_class(): return NO_VALUES method_name = operator_to_magic_method[str_operator] magic_methods = left.py__getattribute__(method_name) if magic_methods: result = magic_methods.execute_with_values(right) if result: return result if not magic_methods: reverse_method_name = reverse_operator_to_magic_method[str_operator] magic_methods = right.py__getattribute__(reverse_method_name) result = magic_methods.execute_with_values(left) if result: return result result = ValueSet([left, right]) debug.dbg('Used operator %s resulting in %s', operator, result) return result @plugin_manager.decorate() def tree_name_to_values(inference_state, context, tree_name): value_set = NO_VALUES module_node = context.get_root_context().tree_node # First check for annotations, like: `foo: int = 3` if module_node is not None: names = module_node.get_used_names().get(tree_name.value, []) found_annotation = False for name in names: expr_stmt = name.parent if expr_stmt.type == "expr_stmt" and expr_stmt.children[1].type == "annassign": correct_scope = parser_utils.get_parent_scope(name) == context.tree_node if correct_scope: found_annotation = True value_set |= annotation.infer_annotation( context, expr_stmt.children[1].children[1] ).execute_annotation() if found_annotation: return value_set types = [] node = tree_name.get_definition(import_name_always=True, include_setitem=True) if node is None: node = tree_name.parent if node.type == 'global_stmt': c = context.create_context(tree_name) if c.is_module(): # In case we are already part of the module, there is no point # in looking up the global statement anymore, because it's not # valid at that point anyway. return NO_VALUES # For global_stmt lookups, we only need the first possible scope, # which means the function itself. filter = next(c.get_filters()) names = filter.get(tree_name.value) return ValueSet.from_sets(name.infer() for name in names) elif node.type not in ('import_from', 'import_name'): c = context.create_context(tree_name) return infer_atom(c, tree_name) typ = node.type if typ == 'for_stmt': types = annotation.find_type_from_comment_hint_for(context, node, tree_name) if types: return types if typ == 'with_stmt': types = annotation.find_type_from_comment_hint_with(context, node, tree_name) if types: return types if typ in ('for_stmt', 'comp_for', 'sync_comp_for'): try: types = context.predefined_names[node][tree_name.value] except KeyError: cn = ContextualizedNode(context, node.children[3]) for_types = iterate_values( cn.infer(), contextualized_node=cn, is_async=node.parent.type == 'async_stmt', ) n = TreeNameDefinition(context, tree_name) types = check_tuple_assignments(n, for_types) elif typ == 'expr_stmt': types = infer_expr_stmt(context, node, tree_name) elif typ == 'with_stmt': value_managers = context.infer_node(node.get_test_node_from_name(tree_name)) if node.parent.type == 'async_stmt': # In the case of `async with` statements, we need to # first get the coroutine from the `__aenter__` method, # then "unwrap" via the `__await__` method enter_methods = value_managers.py__getattribute__('__aenter__') coro = enter_methods.execute_with_values() return coro.py__await__().py__stop_iteration_returns() enter_methods = value_managers.py__getattribute__('__enter__') return enter_methods.execute_with_values() elif typ in ('import_from', 'import_name'): types = imports.infer_import(context, tree_name) elif typ in ('funcdef', 'classdef'): types = _apply_decorators(context, node) elif typ == 'try_stmt': # TODO an exception can also be a tuple. Check for those. # TODO check for types that are not classes and add it to # the static analysis report. exceptions = context.infer_node(tree_name.get_previous_sibling().get_previous_sibling()) types = exceptions.execute_with_values() elif typ == 'param': types = NO_VALUES elif typ == 'del_stmt': types = NO_VALUES elif typ == 'namedexpr_test': types = infer_node(context, node) else: raise ValueError("Should not happen. type: %s" % typ) return types # We don't want to have functions/classes that are created by the same # tree_node. @inference_state_method_cache() def _apply_decorators(context, node): """ Returns the function, that should to be executed in the end. This is also the places where the decorators are processed. """ if node.type == 'classdef': decoratee_value = ClassValue( context.inference_state, parent_context=context, tree_node=node ) else: decoratee_value = FunctionValue.from_context(context, node) initial = values = ValueSet([decoratee_value]) if is_big_annoying_library(context): return values for dec in reversed(node.get_decorators()): debug.dbg('decorator: %s %s', dec, values, color="MAGENTA") with debug.increase_indent_cm(): dec_values = context.infer_node(dec.children[1]) trailer_nodes = dec.children[2:-1] if trailer_nodes: # Create a trailer and infer it. trailer = tree.PythonNode('trailer', trailer_nodes) trailer.parent = dec dec_values = infer_trailer(context, dec_values, trailer) if not len(dec_values): code = dec.get_code(include_prefix=False) # For the short future, we don't want to hear about the runtime # decorator in typing that was intentionally omitted. This is not # "correct", but helps with debugging. if code != '@runtime\n': debug.warning('decorator not found: %s on %s', dec, node) return initial values = dec_values.execute(arguments.ValuesArguments([values])) if not len(values): debug.warning('not possible to resolve wrappers found %s', node) return initial debug.dbg('decorator end %s', values, color="MAGENTA") if values != initial: return ValueSet([Decoratee(c, decoratee_value) for c in values]) return values def check_tuple_assignments(name, value_set): """ Checks if tuples are assigned. """ lazy_value = None for index, node in name.assignment_indexes(): cn = ContextualizedNode(name.parent_context, node) iterated = value_set.iterate(cn) if isinstance(index, slice): # For no star unpacking is not possible. return NO_VALUES i = 0 while i <= index: try: lazy_value = next(iterated) except StopIteration: # We could do this with the default param in next. But this # would allow this loop to run for a very long time if the # index number is high. Therefore break if the loop is # finished. return NO_VALUES else: i += lazy_value.max value_set = lazy_value.infer() return value_set class ContextualizedSubscriptListNode(ContextualizedNode): def infer(self): return _infer_subscript_list(self.context, self.node) def _infer_subscript_list(context, index): """ Handles slices in subscript nodes. """ if index == ':': # Like array[:] return ValueSet([iterable.Slice(context, None, None, None)]) elif index.type == 'subscript' and not index.children[0] == '.': # subscript basically implies a slice operation # e.g. array[:3] result = [] for el in index.children: if el == ':': if not result: result.append(None) elif el.type == 'sliceop': if len(el.children) == 2: result.append(el.children[1]) else: result.append(el) result += [None] * (3 - len(result)) return ValueSet([iterable.Slice(context, *result)]) elif index.type == 'subscriptlist': return ValueSet([iterable.SequenceLiteralValue(context.inference_state, context, index)]) # No slices return context.infer_node(index) ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/jedi/inference/sys_path.py0000664000175000017500000002375200000000000017466 0ustar00davedave00000000000000import os import re from pathlib import Path from importlib.machinery import all_suffixes from jedi.inference.cache import inference_state_method_cache from jedi.inference.base_value import ContextualizedNode from jedi.inference.helpers import is_string, get_str_or_none from jedi.parser_utils import get_cached_code_lines from jedi.file_io import FileIO from jedi import settings from jedi import debug _BUILDOUT_PATH_INSERTION_LIMIT = 10 def _abs_path(module_context, str_path: str): path = Path(str_path) if path.is_absolute(): return path module_path = module_context.py__file__() if module_path is None: # In this case we have no idea where we actually are in the file # system. return None base_dir = module_path.parent return base_dir.joinpath(path).absolute() def _paths_from_assignment(module_context, expr_stmt): """ Extracts the assigned strings from an assignment that looks as follows:: sys.path[0:0] = ['module/path', 'another/module/path'] This function is in general pretty tolerant (and therefore 'buggy'). However, it's not a big issue usually to add more paths to Jedi's sys_path, because it will only affect Jedi in very random situations and by adding more paths than necessary, it usually benefits the general user. """ for assignee, operator in zip(expr_stmt.children[::2], expr_stmt.children[1::2]): try: assert operator in ['=', '+='] assert assignee.type in ('power', 'atom_expr') and \ len(assignee.children) > 1 c = assignee.children assert c[0].type == 'name' and c[0].value == 'sys' trailer = c[1] assert trailer.children[0] == '.' and trailer.children[1].value == 'path' # TODO Essentially we're not checking details on sys.path # manipulation. Both assigment of the sys.path and changing/adding # parts of the sys.path are the same: They get added to the end of # the current sys.path. """ execution = c[2] assert execution.children[0] == '[' subscript = execution.children[1] assert subscript.type == 'subscript' assert ':' in subscript.children """ except AssertionError: continue cn = ContextualizedNode(module_context.create_context(expr_stmt), expr_stmt) for lazy_value in cn.infer().iterate(cn): for value in lazy_value.infer(): if is_string(value): abs_path = _abs_path(module_context, value.get_safe_value()) if abs_path is not None: yield abs_path def _paths_from_list_modifications(module_context, trailer1, trailer2): """ extract the path from either "sys.path.append" or "sys.path.insert" """ # Guarantee that both are trailers, the first one a name and the second one # a function execution with at least one param. if not (trailer1.type == 'trailer' and trailer1.children[0] == '.' and trailer2.type == 'trailer' and trailer2.children[0] == '(' and len(trailer2.children) == 3): return name = trailer1.children[1].value if name not in ['insert', 'append']: return arg = trailer2.children[1] if name == 'insert' and len(arg.children) in (3, 4): # Possible trailing comma. arg = arg.children[2] for value in module_context.create_context(arg).infer_node(arg): p = get_str_or_none(value) if p is None: continue abs_path = _abs_path(module_context, p) if abs_path is not None: yield abs_path @inference_state_method_cache(default=[]) def check_sys_path_modifications(module_context): """ Detect sys.path modifications within module. """ def get_sys_path_powers(names): for name in names: power = name.parent.parent if power is not None and power.type in ('power', 'atom_expr'): c = power.children if c[0].type == 'name' and c[0].value == 'sys' \ and c[1].type == 'trailer': n = c[1].children[1] if n.type == 'name' and n.value == 'path': yield name, power if module_context.tree_node is None: return [] added = [] try: possible_names = module_context.tree_node.get_used_names()['path'] except KeyError: pass else: for name, power in get_sys_path_powers(possible_names): expr_stmt = power.parent if len(power.children) >= 4: added.extend( _paths_from_list_modifications( module_context, *power.children[2:4] ) ) elif expr_stmt is not None and expr_stmt.type == 'expr_stmt': added.extend(_paths_from_assignment(module_context, expr_stmt)) return added def discover_buildout_paths(inference_state, script_path): buildout_script_paths = set() for buildout_script_path in _get_buildout_script_paths(script_path): for path in _get_paths_from_buildout_script(inference_state, buildout_script_path): buildout_script_paths.add(path) if len(buildout_script_paths) >= _BUILDOUT_PATH_INSERTION_LIMIT: break return buildout_script_paths def _get_paths_from_buildout_script(inference_state, buildout_script_path): file_io = FileIO(str(buildout_script_path)) try: module_node = inference_state.parse( file_io=file_io, cache=True, cache_path=settings.cache_directory ) except IOError: debug.warning('Error trying to read buildout_script: %s', buildout_script_path) return from jedi.inference.value import ModuleValue module_context = ModuleValue( inference_state, module_node, file_io=file_io, string_names=None, code_lines=get_cached_code_lines(inference_state.grammar, buildout_script_path), ).as_context() yield from check_sys_path_modifications(module_context) def _get_parent_dir_with_file(path: Path, filename): for parent in path.parents: try: if parent.joinpath(filename).is_file(): return parent except OSError: continue return None def _get_buildout_script_paths(search_path: Path): """ if there is a 'buildout.cfg' file in one of the parent directories of the given module it will return a list of all files in the buildout bin directory that look like python files. :param search_path: absolute path to the module. """ project_root = _get_parent_dir_with_file(search_path, 'buildout.cfg') if not project_root: return bin_path = project_root.joinpath('bin') if not bin_path.exists(): return for filename in os.listdir(bin_path): try: filepath = bin_path.joinpath(filename) with open(filepath, 'r') as f: firstline = f.readline() if firstline.startswith('#!') and 'python' in firstline: yield filepath except (UnicodeDecodeError, IOError) as e: # Probably a binary file; permission error or race cond. because # file got deleted. Ignore it. debug.warning(str(e)) continue def remove_python_path_suffix(path): for suffix in all_suffixes() + ['.pyi']: if path.suffix == suffix: path = path.with_name(path.stem) break return path def transform_path_to_dotted(sys_path, module_path): """ Returns the dotted path inside a sys.path as a list of names. e.g. >>> transform_path_to_dotted([str(Path("/foo").absolute())], Path('/foo/bar/baz.py').absolute()) (('bar', 'baz'), False) Returns (None, False) if the path doesn't really resolve to anything. The second return part is if it is a package. """ # First remove the suffix. module_path = remove_python_path_suffix(module_path) if module_path.name.startswith('.'): return None, False # Once the suffix was removed we are using the files as we know them. This # means that if someone uses an ending like .vim for a Python file, .vim # will be part of the returned dotted part. is_package = module_path.name == '__init__' if is_package: module_path = module_path.parent def iter_potential_solutions(): for p in sys_path: if str(module_path).startswith(p): # Strip the trailing slash/backslash rest = str(module_path)[len(p):] # On Windows a path can also use a slash. if rest.startswith(os.path.sep) or rest.startswith('/'): # Remove a slash in cases it's still there. rest = rest[1:] if rest: split = rest.split(os.path.sep) if not all(split): # This means that part of the file path was empty, this # is very strange and is probably a file that is called # `.py`. return # Stub folders for foo can end with foo-stubs. Just remove # it. yield tuple(re.sub(r'-stubs$', '', s) for s in split) potential_solutions = tuple(iter_potential_solutions()) if not potential_solutions: return None, False # Try to find the shortest path, this makes more sense usually, because the # user usually has venvs somewhere. This means that a path like # .tox/py37/lib/python3.7/os.py can be normal for a file. However in that # case we definitely want to return ['os'] as a path and not a crazy # ['.tox', 'py37', 'lib', 'python3.7', 'os']. Keep in mind that this is a # heuristic and there's now ay to "always" do it right. return sorted(potential_solutions, key=lambda p: len(p))[0], is_package ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/jedi/inference/utils.py0000664000175000017500000000522200000000000016764 0ustar00davedave00000000000000""" A universal module with functions / classes without dependencies. """ import functools import re import os _sep = os.path.sep if os.path.altsep is not None: _sep += os.path.altsep _path_re = re.compile(r'(?:\.[^{0}]+|[{0}]__init__\.py)$'.format(re.escape(_sep))) del _sep def to_list(func): def wrapper(*args, **kwargs): return list(func(*args, **kwargs)) return wrapper def to_tuple(func): def wrapper(*args, **kwargs): return tuple(func(*args, **kwargs)) return wrapper def unite(iterable): """Turns a two dimensional array into a one dimensional.""" return set(typ for types in iterable for typ in types) class UncaughtAttributeError(Exception): """ Important, because `__getattr__` and `hasattr` catch AttributeErrors implicitly. This is really evil (mainly because of `__getattr__`). Therefore this class originally had to be derived from `BaseException` instead of `Exception`. But because I removed relevant `hasattr` from the code base, we can now switch back to `Exception`. :param base: return values of sys.exc_info(). """ def safe_property(func): return property(reraise_uncaught(func)) def reraise_uncaught(func): """ Re-throw uncaught `AttributeError`. Usage: Put ``@rethrow_uncaught`` in front of the function which does **not** suppose to raise `AttributeError`. AttributeError is easily get caught by `hasattr` and another ``except AttributeError`` clause. This becomes problem when you use a lot of "dynamic" attributes (e.g., using ``@property``) because you can't distinguish if the property does not exist for real or some code inside of the "dynamic" attribute through that error. In a well written code, such error should not exist but getting there is very difficult. This decorator is to help us getting there by changing `AttributeError` to `UncaughtAttributeError` to avoid unexpected catch. This helps us noticing bugs earlier and facilitates debugging. """ @functools.wraps(func) def wrapper(*args, **kwds): try: return func(*args, **kwds) except AttributeError as e: raise UncaughtAttributeError(e) from e return wrapper class PushBackIterator: def __init__(self, iterator): self.pushes = [] self.iterator = iterator self.current = None def push_back(self, value): self.pushes.append(value) def __iter__(self): return self def __next__(self): if self.pushes: self.current = self.pushes.pop() else: self.current = next(self.iterator) return self.current ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.3903792 jedi-0.19.1/jedi/inference/value/0000775000175000017500000000000000000000000016365 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/jedi/inference/value/__init__.py0000664000175000017500000000064000000000000020476 0ustar00davedave00000000000000# Re-export symbols for wider use. We configure mypy and flake8 to be aware that # this file does this. from jedi.inference.value.module import ModuleValue from jedi.inference.value.klass import ClassValue from jedi.inference.value.function import FunctionValue, \ MethodValue from jedi.inference.value.instance import AnonymousInstance, BoundMethod, \ CompiledInstance, AbstractInstanceValue, TreeInstance ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/jedi/inference/value/decorator.py0000664000175000017500000000226700000000000020730 0ustar00davedave00000000000000''' Decorators are not really values, however we need some wrappers to improve docstrings and other things around decorators. ''' from jedi.inference.base_value import ValueWrapper, ValueSet class Decoratee(ValueWrapper): def __init__(self, wrapped_value, original_value): super().__init__(wrapped_value) self._original_value = original_value def py__doc__(self): return self._original_value.py__doc__() def py__get__(self, instance, class_value): return ValueSet( Decoratee(v, self._original_value) for v in self._wrapped_value.py__get__(instance, class_value) ) def get_signatures(self): signatures = self._wrapped_value.get_signatures() if signatures: return signatures # Fallback to signatures of the original function/class if the # decorator has no signature or it is not inferrable. # # __get__ means that it's a descriptor. In that case we don't return # signatures, because they are usually properties. if not self._wrapped_value.py__getattribute__('__get__'): return self._original_value.get_signatures() return [] ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/jedi/inference/value/dynamic_arrays.py0000664000175000017500000001654700000000000021761 0ustar00davedave00000000000000""" A module to deal with stuff like `list.append` and `set.add`. Array modifications ******************* If the content of an array (``set``/``list``) is requested somewhere, the current module will be checked for appearances of ``arr.append``, ``arr.insert``, etc. If the ``arr`` name points to an actual array, the content will be added This can be really cpu intensive, as you can imagine. Because |jedi| has to follow **every** ``append`` and check whether it's the right array. However this works pretty good, because in *slow* cases, the recursion detector and other settings will stop this process. It is important to note that: 1. Array modifications work only in the current module. 2. Jedi only checks Array additions; ``list.pop``, etc are ignored. """ from jedi import debug from jedi import settings from jedi.inference import recursion from jedi.inference.base_value import ValueSet, NO_VALUES, HelperValueMixin, \ ValueWrapper from jedi.inference.lazy_value import LazyKnownValues from jedi.inference.helpers import infer_call_of_leaf from jedi.inference.cache import inference_state_method_cache _sentinel = object() def check_array_additions(context, sequence): """ Just a mapper function for the internal _internal_check_array_additions """ if sequence.array_type not in ('list', 'set'): # TODO also check for dict updates return NO_VALUES return _internal_check_array_additions(context, sequence) @inference_state_method_cache(default=NO_VALUES) @debug.increase_indent def _internal_check_array_additions(context, sequence): """ Checks if a `Array` has "add" (append, insert, extend) statements: >>> a = [""] >>> a.append(1) """ from jedi.inference import arguments debug.dbg('Dynamic array search for %s' % sequence, color='MAGENTA') module_context = context.get_root_context() if not settings.dynamic_array_additions or module_context.is_compiled(): debug.dbg('Dynamic array search aborted.', color='MAGENTA') return NO_VALUES def find_additions(context, arglist, add_name): params = list(arguments.TreeArguments(context.inference_state, context, arglist).unpack()) result = set() if add_name in ['insert']: params = params[1:] if add_name in ['append', 'add', 'insert']: for key, lazy_value in params: result.add(lazy_value) elif add_name in ['extend', 'update']: for key, lazy_value in params: result |= set(lazy_value.infer().iterate()) return result temp_param_add, settings.dynamic_params_for_other_modules = \ settings.dynamic_params_for_other_modules, False is_list = sequence.name.string_name == 'list' search_names = (['append', 'extend', 'insert'] if is_list else ['add', 'update']) added_types = set() for add_name in search_names: try: possible_names = module_context.tree_node.get_used_names()[add_name] except KeyError: continue else: for name in possible_names: value_node = context.tree_node if not (value_node.start_pos < name.start_pos < value_node.end_pos): continue trailer = name.parent power = trailer.parent trailer_pos = power.children.index(trailer) try: execution_trailer = power.children[trailer_pos + 1] except IndexError: continue else: if execution_trailer.type != 'trailer' \ or execution_trailer.children[0] != '(' \ or execution_trailer.children[1] == ')': continue random_context = context.create_context(name) with recursion.execution_allowed(context.inference_state, power) as allowed: if allowed: found = infer_call_of_leaf( random_context, name, cut_own_trailer=True ) if sequence in found: # The arrays match. Now add the results added_types |= find_additions( random_context, execution_trailer.children[1], add_name ) # reset settings settings.dynamic_params_for_other_modules = temp_param_add debug.dbg('Dynamic array result %s', added_types, color='MAGENTA') return added_types def get_dynamic_array_instance(instance, arguments): """Used for set() and list() instances.""" ai = _DynamicArrayAdditions(instance, arguments) from jedi.inference import arguments return arguments.ValuesArguments([ValueSet([ai])]) class _DynamicArrayAdditions(HelperValueMixin): """ Used for the usage of set() and list(). This is definitely a hack, but a good one :-) It makes it possible to use set/list conversions. This is not a proper context, because it doesn't have to be. It's not used in the wild, it's just used within typeshed as an argument to `__init__` for set/list and never used in any other place. """ def __init__(self, instance, arguments): self._instance = instance self._arguments = arguments def py__class__(self): tuple_, = self._instance.inference_state.builtins_module.py__getattribute__('tuple') return tuple_ def py__iter__(self, contextualized_node=None): arguments = self._arguments try: _, lazy_value = next(arguments.unpack()) except StopIteration: pass else: yield from lazy_value.infer().iterate() from jedi.inference.arguments import TreeArguments if isinstance(arguments, TreeArguments): additions = _internal_check_array_additions(arguments.context, self._instance) yield from additions def iterate(self, contextualized_node=None, is_async=False): return self.py__iter__(contextualized_node) class _Modification(ValueWrapper): def __init__(self, wrapped_value, assigned_values, contextualized_key): super().__init__(wrapped_value) self._assigned_values = assigned_values self._contextualized_key = contextualized_key def py__getitem__(self, *args, **kwargs): return self._wrapped_value.py__getitem__(*args, **kwargs) | self._assigned_values def py__simple_getitem__(self, index): actual = [ v.get_safe_value(_sentinel) for v in self._contextualized_key.infer() ] if index in actual: return self._assigned_values return self._wrapped_value.py__simple_getitem__(index) class DictModification(_Modification): def py__iter__(self, contextualized_node=None): yield from self._wrapped_value.py__iter__(contextualized_node) yield self._contextualized_key def get_key_values(self): return self._wrapped_value.get_key_values() | self._contextualized_key.infer() class ListModification(_Modification): def py__iter__(self, contextualized_node=None): yield from self._wrapped_value.py__iter__(contextualized_node) yield LazyKnownValues(self._assigned_values) ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/jedi/inference/value/function.py0000664000175000017500000004202000000000000020562 0ustar00davedave00000000000000from parso.python import tree from jedi import debug from jedi.inference.cache import inference_state_method_cache, CachedMetaClass from jedi.inference import compiled from jedi.inference import recursion from jedi.inference import docstrings from jedi.inference import flow_analysis from jedi.inference.signature import TreeSignature from jedi.inference.filters import ParserTreeFilter, FunctionExecutionFilter, \ AnonymousFunctionExecutionFilter from jedi.inference.names import ValueName, AbstractNameDefinition, \ AnonymousParamName, ParamName, NameWrapper from jedi.inference.base_value import ContextualizedNode, NO_VALUES, \ ValueSet, TreeValue, ValueWrapper from jedi.inference.lazy_value import LazyKnownValues, LazyKnownValue, \ LazyTreeValue from jedi.inference.context import ValueContext, TreeContextMixin from jedi.inference.value import iterable from jedi import parser_utils from jedi.inference.parser_cache import get_yield_exprs from jedi.inference.helpers import values_from_qualified_names from jedi.inference.gradual.generics import TupleGenericManager class LambdaName(AbstractNameDefinition): string_name = '' api_type = 'function' def __init__(self, lambda_value): self._lambda_value = lambda_value self.parent_context = lambda_value.parent_context @property def start_pos(self): return self._lambda_value.tree_node.start_pos def infer(self): return ValueSet([self._lambda_value]) class FunctionAndClassBase(TreeValue): def get_qualified_names(self): if self.parent_context.is_class(): n = self.parent_context.get_qualified_names() if n is None: # This means that the parent class lives within a function. return None return n + (self.py__name__(),) elif self.parent_context.is_module(): return (self.py__name__(),) else: return None class FunctionMixin: api_type = 'function' def get_filters(self, origin_scope=None): cls = self.py__class__() for instance in cls.execute_with_values(): yield from instance.get_filters(origin_scope=origin_scope) def py__get__(self, instance, class_value): from jedi.inference.value.instance import BoundMethod if instance is None: # Calling the Foo.bar results in the original bar function. return ValueSet([self]) return ValueSet([BoundMethod(instance, class_value.as_context(), self)]) def get_param_names(self): return [AnonymousParamName(self, param.name) for param in self.tree_node.get_params()] @property def name(self): if self.tree_node.type == 'lambdef': return LambdaName(self) return ValueName(self, self.tree_node.name) def is_function(self): return True def py__name__(self): return self.name.string_name def get_type_hint(self, add_class_info=True): return_annotation = self.tree_node.annotation if return_annotation is None: def param_name_to_str(n): s = n.string_name annotation = n.infer().get_type_hint() if annotation is not None: s += ': ' + annotation if n.default_node is not None: s += '=' + n.default_node.get_code(include_prefix=False) return s function_execution = self.as_context() result = function_execution.infer() return_hint = result.get_type_hint() body = self.py__name__() + '(%s)' % ', '.join([ param_name_to_str(n) for n in function_execution.get_param_names() ]) if return_hint is None: return body else: return_hint = return_annotation.get_code(include_prefix=False) body = self.py__name__() + self.tree_node.children[2].get_code(include_prefix=False) return body + ' -> ' + return_hint def py__call__(self, arguments): function_execution = self.as_context(arguments) return function_execution.infer() def _as_context(self, arguments=None): if arguments is None: return AnonymousFunctionExecution(self) return FunctionExecutionContext(self, arguments) def get_signatures(self): return [TreeSignature(f) for f in self.get_signature_functions()] class FunctionValue(FunctionMixin, FunctionAndClassBase, metaclass=CachedMetaClass): @classmethod def from_context(cls, context, tree_node): def create(tree_node): if context.is_class(): return MethodValue( context.inference_state, context, parent_context=parent_context, tree_node=tree_node ) else: return cls( context.inference_state, parent_context=parent_context, tree_node=tree_node ) overloaded_funcs = list(_find_overload_functions(context, tree_node)) parent_context = context while parent_context.is_class() or parent_context.is_instance(): parent_context = parent_context.parent_context function = create(tree_node) if overloaded_funcs: return OverloadedFunctionValue( function, # Get them into the correct order: lower line first. list(reversed([create(f) for f in overloaded_funcs])) ) return function def py__class__(self): c, = values_from_qualified_names(self.inference_state, 'types', 'FunctionType') return c def get_default_param_context(self): return self.parent_context def get_signature_functions(self): return [self] class FunctionNameInClass(NameWrapper): def __init__(self, class_context, name): super().__init__(name) self._class_context = class_context def get_defining_qualified_value(self): return self._class_context.get_value() # Might be None. class MethodValue(FunctionValue): def __init__(self, inference_state, class_context, *args, **kwargs): super().__init__(inference_state, *args, **kwargs) self.class_context = class_context def get_default_param_context(self): return self.class_context def get_qualified_names(self): # Need to implement this, because the parent value of a method # value is not the class value but the module. names = self.class_context.get_qualified_names() if names is None: return None return names + (self.py__name__(),) @property def name(self): return FunctionNameInClass(self.class_context, super().name) class BaseFunctionExecutionContext(ValueContext, TreeContextMixin): def infer_annotations(self): raise NotImplementedError @inference_state_method_cache(default=NO_VALUES) @recursion.execution_recursion_decorator() def get_return_values(self, check_yields=False): funcdef = self.tree_node if funcdef.type == 'lambdef': return self.infer_node(funcdef.children[-1]) if check_yields: value_set = NO_VALUES returns = get_yield_exprs(self.inference_state, funcdef) else: value_set = self.infer_annotations() if value_set: # If there are annotations, prefer them over anything else. # This will make it faster. return value_set value_set |= docstrings.infer_return_types(self._value) returns = funcdef.iter_return_stmts() for r in returns: if check_yields: value_set |= ValueSet.from_sets( lazy_value.infer() for lazy_value in self._get_yield_lazy_value(r) ) else: check = flow_analysis.reachability_check(self, funcdef, r) if check is flow_analysis.UNREACHABLE: debug.dbg('Return unreachable: %s', r) else: try: children = r.children except AttributeError: ctx = compiled.builtin_from_name(self.inference_state, 'None') value_set |= ValueSet([ctx]) else: value_set |= self.infer_node(children[1]) if check is flow_analysis.REACHABLE: debug.dbg('Return reachable: %s', r) break return value_set def _get_yield_lazy_value(self, yield_expr): if yield_expr.type == 'keyword': # `yield` just yields None. ctx = compiled.builtin_from_name(self.inference_state, 'None') yield LazyKnownValue(ctx) return node = yield_expr.children[1] if node.type == 'yield_arg': # It must be a yield from. cn = ContextualizedNode(self, node.children[1]) yield from cn.infer().iterate(cn) else: yield LazyTreeValue(self, node) @recursion.execution_recursion_decorator(default=iter([])) def get_yield_lazy_values(self, is_async=False): # TODO: if is_async, wrap yield statements in Awaitable/async_generator_asend for_parents = [(y, tree.search_ancestor(y, 'for_stmt', 'funcdef', 'while_stmt', 'if_stmt')) for y in get_yield_exprs(self.inference_state, self.tree_node)] # Calculate if the yields are placed within the same for loop. yields_order = [] last_for_stmt = None for yield_, for_stmt in for_parents: # For really simple for loops we can predict the order. Otherwise # we just ignore it. parent = for_stmt.parent if parent.type == 'suite': parent = parent.parent if for_stmt.type == 'for_stmt' and parent == self.tree_node \ and parser_utils.for_stmt_defines_one_name(for_stmt): # Simplicity for now. if for_stmt == last_for_stmt: yields_order[-1][1].append(yield_) else: yields_order.append((for_stmt, [yield_])) elif for_stmt == self.tree_node: yields_order.append((None, [yield_])) else: types = self.get_return_values(check_yields=True) if types: yield LazyKnownValues(types, min=0, max=float('inf')) return last_for_stmt = for_stmt for for_stmt, yields in yields_order: if for_stmt is None: # No for_stmt, just normal yields. for yield_ in yields: yield from self._get_yield_lazy_value(yield_) else: input_node = for_stmt.get_testlist() cn = ContextualizedNode(self, input_node) ordered = cn.infer().iterate(cn) ordered = list(ordered) for lazy_value in ordered: dct = {str(for_stmt.children[1].value): lazy_value.infer()} with self.predefine_names(for_stmt, dct): for yield_in_same_for_stmt in yields: yield from self._get_yield_lazy_value(yield_in_same_for_stmt) def merge_yield_values(self, is_async=False): return ValueSet.from_sets( lazy_value.infer() for lazy_value in self.get_yield_lazy_values() ) def is_generator(self): return bool(get_yield_exprs(self.inference_state, self.tree_node)) def infer(self): """ Created to be used by inheritance. """ inference_state = self.inference_state is_coroutine = self.tree_node.parent.type in ('async_stmt', 'async_funcdef') from jedi.inference.gradual.base import GenericClass if is_coroutine: if self.is_generator(): async_generator_classes = inference_state.typing_module \ .py__getattribute__('AsyncGenerator') yield_values = self.merge_yield_values(is_async=True) # The contravariant doesn't seem to be defined. generics = (yield_values.py__class__(), NO_VALUES) return ValueSet( GenericClass(c, TupleGenericManager(generics)) for c in async_generator_classes ).execute_annotation() else: async_classes = inference_state.typing_module.py__getattribute__('Coroutine') return_values = self.get_return_values() # Only the first generic is relevant. generics = (return_values.py__class__(), NO_VALUES, NO_VALUES) return ValueSet( GenericClass(c, TupleGenericManager(generics)) for c in async_classes ).execute_annotation() else: # If there are annotations, prefer them over anything else. if self.is_generator() and not self.infer_annotations(): return ValueSet([iterable.Generator(inference_state, self)]) else: return self.get_return_values() class FunctionExecutionContext(BaseFunctionExecutionContext): def __init__(self, function_value, arguments): super().__init__(function_value) self._arguments = arguments def get_filters(self, until_position=None, origin_scope=None): yield FunctionExecutionFilter( self, self._value, until_position=until_position, origin_scope=origin_scope, arguments=self._arguments ) def infer_annotations(self): from jedi.inference.gradual.annotation import infer_return_types return infer_return_types(self._value, self._arguments) def get_param_names(self): return [ ParamName(self._value, param.name, self._arguments) for param in self._value.tree_node.get_params() ] class AnonymousFunctionExecution(BaseFunctionExecutionContext): def infer_annotations(self): # I don't think inferring anonymous executions is a big thing. # Anonymous contexts are mostly there for the user to work in. ~ dave return NO_VALUES def get_filters(self, until_position=None, origin_scope=None): yield AnonymousFunctionExecutionFilter( self, self._value, until_position=until_position, origin_scope=origin_scope, ) def get_param_names(self): return self._value.get_param_names() class OverloadedFunctionValue(FunctionMixin, ValueWrapper): def __init__(self, function, overloaded_functions): super().__init__(function) self._overloaded_functions = overloaded_functions def py__call__(self, arguments): debug.dbg("Execute overloaded function %s", self._wrapped_value, color='BLUE') function_executions = [] for signature in self.get_signatures(): function_execution = signature.value.as_context(arguments) function_executions.append(function_execution) if signature.matches_signature(arguments): return function_execution.infer() if self.inference_state.is_analysis: # In this case we want precision. return NO_VALUES return ValueSet.from_sets(fe.infer() for fe in function_executions) def get_signature_functions(self): return self._overloaded_functions def get_type_hint(self, add_class_info=True): return 'Union[%s]' % ', '.join(f.get_type_hint() for f in self._overloaded_functions) def _find_overload_functions(context, tree_node): def _is_overload_decorated(funcdef): if funcdef.parent.type == 'decorated': decorators = funcdef.parent.children[0] if decorators.type == 'decorator': decorators = [decorators] else: decorators = decorators.children for decorator in decorators: dotted_name = decorator.children[1] if dotted_name.type == 'name' and dotted_name.value == 'overload': # TODO check with values if it's the right overload return True return False if tree_node.type == 'lambdef': return if _is_overload_decorated(tree_node): yield tree_node while True: filter = ParserTreeFilter( context, until_position=tree_node.start_pos ) names = filter.get(tree_node.name.value) assert isinstance(names, list) if not names: break found = False for name in names: funcdef = name.tree_name.parent if funcdef.type == 'funcdef' and _is_overload_decorated(funcdef): tree_node = funcdef found = True yield funcdef if not found: break ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/jedi/inference/value/instance.py0000664000175000017500000005375700000000000020564 0ustar00davedave00000000000000from abc import abstractproperty from parso.tree import search_ancestor from jedi import debug from jedi import settings from jedi.inference import compiled from jedi.inference.compiled.value import CompiledValueFilter from jedi.inference.helpers import values_from_qualified_names, is_big_annoying_library from jedi.inference.filters import AbstractFilter, AnonymousFunctionExecutionFilter from jedi.inference.names import ValueName, TreeNameDefinition, ParamName, \ NameWrapper from jedi.inference.base_value import Value, NO_VALUES, ValueSet, \ iterator_to_value_set, ValueWrapper from jedi.inference.lazy_value import LazyKnownValue, LazyKnownValues from jedi.inference.cache import inference_state_method_cache from jedi.inference.arguments import ValuesArguments, TreeArgumentsWrapper from jedi.inference.value.function import \ FunctionValue, FunctionMixin, OverloadedFunctionValue, \ BaseFunctionExecutionContext, FunctionExecutionContext, FunctionNameInClass from jedi.inference.value.klass import ClassFilter from jedi.inference.value.dynamic_arrays import get_dynamic_array_instance from jedi.parser_utils import function_is_staticmethod, function_is_classmethod class InstanceExecutedParamName(ParamName): def __init__(self, instance, function_value, tree_name): super().__init__( function_value, tree_name, arguments=None) self._instance = instance def infer(self): return ValueSet([self._instance]) def matches_signature(self): return True class AnonymousMethodExecutionFilter(AnonymousFunctionExecutionFilter): def __init__(self, instance, *args, **kwargs): super().__init__(*args, **kwargs) self._instance = instance def _convert_param(self, param, name): if param.position_index == 0: if function_is_classmethod(self._function_value.tree_node): return InstanceExecutedParamName( self._instance.py__class__(), self._function_value, name ) elif not function_is_staticmethod(self._function_value.tree_node): return InstanceExecutedParamName( self._instance, self._function_value, name ) return super()._convert_param(param, name) class AnonymousMethodExecutionContext(BaseFunctionExecutionContext): def __init__(self, instance, value): super().__init__(value) self.instance = instance def get_filters(self, until_position=None, origin_scope=None): yield AnonymousMethodExecutionFilter( self.instance, self, self._value, until_position=until_position, origin_scope=origin_scope, ) def get_param_names(self): param_names = list(self._value.get_param_names()) # set the self name param_names[0] = InstanceExecutedParamName( self.instance, self._value, param_names[0].tree_name ) return param_names class MethodExecutionContext(FunctionExecutionContext): def __init__(self, instance, *args, **kwargs): super().__init__(*args, **kwargs) self.instance = instance class AbstractInstanceValue(Value): api_type = 'instance' def __init__(self, inference_state, parent_context, class_value): super().__init__(inference_state, parent_context) # Generated instances are classes that are just generated by self # (No arguments) used. self.class_value = class_value def is_instance(self): return True def get_qualified_names(self): return self.class_value.get_qualified_names() def get_annotated_class_object(self): return self.class_value # This is the default. def py__class__(self): return self.class_value def py__bool__(self): # Signalize that we don't know about the bool type. return None @abstractproperty def name(self): raise NotImplementedError def get_signatures(self): call_funcs = self.py__getattribute__('__call__').py__get__(self, self.class_value) return [s.bind(self) for s in call_funcs.get_signatures()] def get_function_slot_names(self, name): # Python classes don't look at the dictionary of the instance when # looking up `__call__`. This is something that has to do with Python's # internal slot system (note: not __slots__, but C slots). for filter in self.get_filters(include_self_names=False): names = filter.get(name) if names: return names return [] def execute_function_slots(self, names, *inferred_args): return ValueSet.from_sets( name.infer().execute_with_values(*inferred_args) for name in names ) def get_type_hint(self, add_class_info=True): return self.py__name__() def py__getitem__(self, index_value_set, contextualized_node): names = self.get_function_slot_names('__getitem__') if not names: return super().py__getitem__( index_value_set, contextualized_node, ) args = ValuesArguments([index_value_set]) return ValueSet.from_sets(name.infer().execute(args) for name in names) def py__iter__(self, contextualized_node=None): iter_slot_names = self.get_function_slot_names('__iter__') if not iter_slot_names: return super().py__iter__(contextualized_node) def iterate(): for generator in self.execute_function_slots(iter_slot_names): yield from generator.py__next__(contextualized_node) return iterate() def __repr__(self): return "<%s of %s>" % (self.__class__.__name__, self.class_value) class CompiledInstance(AbstractInstanceValue): # This is not really a compiled class, it's just an instance from a # compiled class. def __init__(self, inference_state, parent_context, class_value, arguments): super().__init__(inference_state, parent_context, class_value) self._arguments = arguments def get_filters(self, origin_scope=None, include_self_names=True): class_value = self.get_annotated_class_object() class_filters = class_value.get_filters( origin_scope=origin_scope, is_instance=True, ) for f in class_filters: yield CompiledInstanceClassFilter(self, f) @property def name(self): return compiled.CompiledValueName(self, self.class_value.name.string_name) def is_stub(self): return False class _BaseTreeInstance(AbstractInstanceValue): @property def array_type(self): name = self.class_value.py__name__() if name in ['list', 'set', 'dict'] \ and self.parent_context.get_root_context().is_builtins_module(): return name return None @property def name(self): return ValueName(self, self.class_value.name.tree_name) def get_filters(self, origin_scope=None, include_self_names=True): class_value = self.get_annotated_class_object() if include_self_names: for cls in class_value.py__mro__(): if not cls.is_compiled(): # In this case we're excluding compiled objects that are # not fake objects. It doesn't make sense for normal # compiled objects to search for self variables. yield SelfAttributeFilter(self, class_value, cls.as_context(), origin_scope) class_filters = class_value.get_filters( origin_scope=origin_scope, is_instance=True, ) for f in class_filters: if isinstance(f, ClassFilter): yield InstanceClassFilter(self, f) elif isinstance(f, CompiledValueFilter): yield CompiledInstanceClassFilter(self, f) else: # Propably from the metaclass. yield f @inference_state_method_cache() def create_instance_context(self, class_context, node): new = node while True: func_node = new new = search_ancestor(new, 'funcdef', 'classdef') if class_context.tree_node is new: func = FunctionValue.from_context(class_context, func_node) bound_method = BoundMethod(self, class_context, func) if func_node.name.value == '__init__': context = bound_method.as_context(self._arguments) else: context = bound_method.as_context() break return context.create_context(node) def py__getattribute__alternatives(self, string_name): ''' Since nothing was inferred, now check the __getattr__ and __getattribute__ methods. Stubs don't need to be checked, because they don't contain any logic. ''' if self.is_stub(): return NO_VALUES name = compiled.create_simple_object(self.inference_state, string_name) # This is a little bit special. `__getattribute__` is in Python # executed before `__getattr__`. But: I know no use case, where # this could be practical and where Jedi would return wrong types. # If you ever find something, let me know! # We are inversing this, because a hand-crafted `__getattribute__` # could still call another hand-crafted `__getattr__`, but not the # other way around. if is_big_annoying_library(self.parent_context): return NO_VALUES names = (self.get_function_slot_names('__getattr__') or self.get_function_slot_names('__getattribute__')) return self.execute_function_slots(names, name) def py__next__(self, contextualized_node=None): name = u'__next__' next_slot_names = self.get_function_slot_names(name) if next_slot_names: yield LazyKnownValues( self.execute_function_slots(next_slot_names) ) else: debug.warning('Instance has no __next__ function in %s.', self) def py__call__(self, arguments): names = self.get_function_slot_names('__call__') if not names: # Means the Instance is not callable. return super().py__call__(arguments) return ValueSet.from_sets(name.infer().execute(arguments) for name in names) def py__get__(self, instance, class_value): """ obj may be None. """ # Arguments in __get__ descriptors are obj, class. # `method` is the new parent of the array, don't know if that's good. for cls in self.class_value.py__mro__(): result = cls.py__get__on_class(self, instance, class_value) if result is not NotImplemented: return result names = self.get_function_slot_names('__get__') if names: if instance is None: instance = compiled.builtin_from_name(self.inference_state, 'None') return self.execute_function_slots(names, instance, class_value) else: return ValueSet([self]) class TreeInstance(_BaseTreeInstance): def __init__(self, inference_state, parent_context, class_value, arguments): # I don't think that dynamic append lookups should happen here. That # sounds more like something that should go to py__iter__. if class_value.py__name__() in ['list', 'set'] \ and parent_context.get_root_context().is_builtins_module(): # compare the module path with the builtin name. if settings.dynamic_array_additions: arguments = get_dynamic_array_instance(self, arguments) super().__init__(inference_state, parent_context, class_value) self._arguments = arguments self.tree_node = class_value.tree_node # This can recurse, if the initialization of the class includes a reference # to itself. @inference_state_method_cache(default=None) def _get_annotated_class_object(self): from jedi.inference.gradual.annotation import py__annotations__, \ infer_type_vars_for_execution args = InstanceArguments(self, self._arguments) for signature in self.class_value.py__getattribute__('__init__').get_signatures(): # Just take the first result, it should always be one, because we # control the typeshed code. funcdef = signature.value.tree_node if funcdef is None or funcdef.type != 'funcdef' \ or not signature.matches_signature(args): # First check if the signature even matches, if not we don't # need to infer anything. continue bound_method = BoundMethod(self, self.class_value.as_context(), signature.value) all_annotations = py__annotations__(funcdef) type_var_dict = infer_type_vars_for_execution(bound_method, args, all_annotations) if type_var_dict: defined, = self.class_value.define_generics( infer_type_vars_for_execution(signature.value, args, all_annotations), ) debug.dbg('Inferred instance value as %s', defined, color='BLUE') return defined return None def get_annotated_class_object(self): return self._get_annotated_class_object() or self.class_value def get_key_values(self): values = NO_VALUES if self.array_type == 'dict': for i, (key, instance) in enumerate(self._arguments.unpack()): if key is None and i == 0: values |= ValueSet.from_sets( v.get_key_values() for v in instance.infer() if v.array_type == 'dict' ) if key: values |= ValueSet([compiled.create_simple_object( self.inference_state, key, )]) return values def py__simple_getitem__(self, index): if self.array_type == 'dict': # Logic for dict({'foo': bar}) and dict(foo=bar) # reversed, because: # >>> dict({'a': 1}, a=3) # {'a': 3} # TODO tuple initializations # >>> dict([('a', 4)]) # {'a': 4} for key, lazy_context in reversed(list(self._arguments.unpack())): if key is None: values = ValueSet.from_sets( dct_value.py__simple_getitem__(index) for dct_value in lazy_context.infer() if dct_value.array_type == 'dict' ) if values: return values else: if key == index: return lazy_context.infer() return super().py__simple_getitem__(index) def __repr__(self): return "<%s of %s(%s)>" % (self.__class__.__name__, self.class_value, self._arguments) class AnonymousInstance(_BaseTreeInstance): _arguments = None class CompiledInstanceName(NameWrapper): @iterator_to_value_set def infer(self): for result_value in self._wrapped_name.infer(): if result_value.api_type == 'function': yield CompiledBoundMethod(result_value) else: yield result_value class CompiledInstanceClassFilter(AbstractFilter): def __init__(self, instance, f): self._instance = instance self._class_filter = f def get(self, name): return self._convert(self._class_filter.get(name)) def values(self): return self._convert(self._class_filter.values()) def _convert(self, names): return [CompiledInstanceName(n) for n in names] class BoundMethod(FunctionMixin, ValueWrapper): def __init__(self, instance, class_context, function): super().__init__(function) self.instance = instance self._class_context = class_context def is_bound_method(self): return True @property def name(self): return FunctionNameInClass( self._class_context, super().name ) def py__class__(self): c, = values_from_qualified_names(self.inference_state, 'types', 'MethodType') return c def _get_arguments(self, arguments): assert arguments is not None return InstanceArguments(self.instance, arguments) def _as_context(self, arguments=None): if arguments is None: return AnonymousMethodExecutionContext(self.instance, self) arguments = self._get_arguments(arguments) return MethodExecutionContext(self.instance, self, arguments) def py__call__(self, arguments): if isinstance(self._wrapped_value, OverloadedFunctionValue): return self._wrapped_value.py__call__(self._get_arguments(arguments)) function_execution = self.as_context(arguments) return function_execution.infer() def get_signature_functions(self): return [ BoundMethod(self.instance, self._class_context, f) for f in self._wrapped_value.get_signature_functions() ] def get_signatures(self): return [sig.bind(self) for sig in super().get_signatures()] def __repr__(self): return '<%s: %s>' % (self.__class__.__name__, self._wrapped_value) class CompiledBoundMethod(ValueWrapper): def is_bound_method(self): return True def get_signatures(self): return [sig.bind(self) for sig in self._wrapped_value.get_signatures()] class SelfName(TreeNameDefinition): """ This name calculates the parent_context lazily. """ def __init__(self, instance, class_context, tree_name): self._instance = instance self.class_context = class_context self.tree_name = tree_name @property def parent_context(self): return self._instance.create_instance_context(self.class_context, self.tree_name) def get_defining_qualified_value(self): return self._instance def infer(self): stmt = search_ancestor(self.tree_name, 'expr_stmt') if stmt is not None: if stmt.children[1].type == "annassign": from jedi.inference.gradual.annotation import infer_annotation values = infer_annotation( self.parent_context, stmt.children[1].children[1] ).execute_annotation() if values: return values return super().infer() class LazyInstanceClassName(NameWrapper): def __init__(self, instance, class_member_name): super().__init__(class_member_name) self._instance = instance @iterator_to_value_set def infer(self): for result_value in self._wrapped_name.infer(): yield from result_value.py__get__(self._instance, self._instance.py__class__()) def get_signatures(self): return self.infer().get_signatures() def get_defining_qualified_value(self): return self._instance class InstanceClassFilter(AbstractFilter): """ This filter is special in that it uses the class filter and wraps the resulting names in LazyInstanceClassName. The idea is that the class name filtering can be very flexible and always be reflected in instances. """ def __init__(self, instance, class_filter): self._instance = instance self._class_filter = class_filter def get(self, name): return self._convert(self._class_filter.get(name)) def values(self): return self._convert(self._class_filter.values()) def _convert(self, names): return [ LazyInstanceClassName(self._instance, n) for n in names ] def __repr__(self): return '<%s for %s>' % (self.__class__.__name__, self._class_filter) class SelfAttributeFilter(ClassFilter): """ This class basically filters all the use cases where `self.*` was assigned. """ def __init__(self, instance, instance_class, node_context, origin_scope): super().__init__( class_value=instance_class, node_context=node_context, origin_scope=origin_scope, is_instance=True, ) self._instance = instance def _filter(self, names): start, end = self._parser_scope.start_pos, self._parser_scope.end_pos names = [n for n in names if start < n.start_pos < end] return self._filter_self_names(names) def _filter_self_names(self, names): for name in names: trailer = name.parent if trailer.type == 'trailer' \ and len(trailer.parent.children) == 2 \ and trailer.children[0] == '.': if name.is_definition() and self._access_possible(name): # TODO filter non-self assignments instead of this bad # filter. if self._is_in_right_scope(trailer.parent.children[0], name): yield name def _is_in_right_scope(self, self_name, name): self_context = self._node_context.create_context(self_name) names = self_context.goto(self_name, position=self_name.start_pos) return any( n.api_type == 'param' and n.tree_name.get_definition().position_index == 0 and n.parent_context.tree_node is self._parser_scope for n in names ) def _convert_names(self, names): return [SelfName(self._instance, self._node_context, name) for name in names] def _check_flows(self, names): return names class InstanceArguments(TreeArgumentsWrapper): def __init__(self, instance, arguments): super().__init__(arguments) self.instance = instance def unpack(self, func=None): yield None, LazyKnownValue(self.instance) yield from self._wrapped_arguments.unpack(func) ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/jedi/inference/value/iterable.py0000664000175000017500000005541100000000000020534 0ustar00davedave00000000000000""" Contains all classes and functions to deal with lists, dicts, generators and iterators in general. """ from jedi.inference import compiled from jedi.inference import analysis from jedi.inference.lazy_value import LazyKnownValue, LazyKnownValues, \ LazyTreeValue from jedi.inference.helpers import get_int_or_none, is_string, \ reraise_getitem_errors, SimpleGetItemNotFound from jedi.inference.utils import safe_property, to_list from jedi.inference.cache import inference_state_method_cache from jedi.inference.filters import LazyAttributeOverwrite, publish_method from jedi.inference.base_value import ValueSet, Value, NO_VALUES, \ ContextualizedNode, iterate_values, sentinel, \ LazyValueWrapper from jedi.parser_utils import get_sync_comp_fors from jedi.inference.context import CompForContext from jedi.inference.value.dynamic_arrays import check_array_additions class IterableMixin: def py__next__(self, contextualized_node=None): return self.py__iter__(contextualized_node) def py__stop_iteration_returns(self): return ValueSet([compiled.builtin_from_name(self.inference_state, 'None')]) # At the moment, safe values are simple values like "foo", 1 and not # lists/dicts. Therefore as a small speed optimization we can just do the # default instead of resolving the lazy wrapped values, that are just # doing this in the end as well. # This mostly speeds up patterns like `sys.version_info >= (3, 0)` in # typeshed. get_safe_value = Value.get_safe_value class GeneratorBase(LazyAttributeOverwrite, IterableMixin): array_type = None def _get_wrapped_value(self): instance, = self._get_cls().execute_annotation() return instance def _get_cls(self): generator, = self.inference_state.typing_module.py__getattribute__('Generator') return generator def py__bool__(self): return True @publish_method('__iter__') def _iter(self, arguments): return ValueSet([self]) @publish_method('send') @publish_method('__next__') def _next(self, arguments): return ValueSet.from_sets(lazy_value.infer() for lazy_value in self.py__iter__()) def py__stop_iteration_returns(self): return ValueSet([compiled.builtin_from_name(self.inference_state, 'None')]) @property def name(self): return compiled.CompiledValueName(self, 'Generator') def get_annotated_class_object(self): from jedi.inference.gradual.generics import TupleGenericManager gen_values = self.merge_types_of_iterate().py__class__() gm = TupleGenericManager((gen_values, NO_VALUES, NO_VALUES)) return self._get_cls().with_generics(gm) class Generator(GeneratorBase): """Handling of `yield` functions.""" def __init__(self, inference_state, func_execution_context): super().__init__(inference_state) self._func_execution_context = func_execution_context def py__iter__(self, contextualized_node=None): iterators = self._func_execution_context.infer_annotations() if iterators: return iterators.iterate(contextualized_node) return self._func_execution_context.get_yield_lazy_values() def py__stop_iteration_returns(self): return self._func_execution_context.get_return_values() def __repr__(self): return "<%s of %s>" % (type(self).__name__, self._func_execution_context) def comprehension_from_atom(inference_state, value, atom): bracket = atom.children[0] test_list_comp = atom.children[1] if bracket == '{': if atom.children[1].children[1] == ':': sync_comp_for = test_list_comp.children[3] if sync_comp_for.type == 'comp_for': sync_comp_for = sync_comp_for.children[1] return DictComprehension( inference_state, value, sync_comp_for_node=sync_comp_for, key_node=test_list_comp.children[0], value_node=test_list_comp.children[2], ) else: cls = SetComprehension elif bracket == '(': cls = GeneratorComprehension elif bracket == '[': cls = ListComprehension sync_comp_for = test_list_comp.children[1] if sync_comp_for.type == 'comp_for': sync_comp_for = sync_comp_for.children[1] return cls( inference_state, defining_context=value, sync_comp_for_node=sync_comp_for, entry_node=test_list_comp.children[0], ) class ComprehensionMixin: @inference_state_method_cache() def _get_comp_for_context(self, parent_context, comp_for): return CompForContext(parent_context, comp_for) def _nested(self, comp_fors, parent_context=None): comp_for = comp_fors[0] is_async = comp_for.parent.type == 'comp_for' input_node = comp_for.children[3] parent_context = parent_context or self._defining_context input_types = parent_context.infer_node(input_node) cn = ContextualizedNode(parent_context, input_node) iterated = input_types.iterate(cn, is_async=is_async) exprlist = comp_for.children[1] for i, lazy_value in enumerate(iterated): types = lazy_value.infer() dct = unpack_tuple_to_dict(parent_context, types, exprlist) context = self._get_comp_for_context( parent_context, comp_for, ) with context.predefine_names(comp_for, dct): try: yield from self._nested(comp_fors[1:], context) except IndexError: iterated = context.infer_node(self._entry_node) if self.array_type == 'dict': yield iterated, context.infer_node(self._value_node) else: yield iterated @inference_state_method_cache(default=[]) @to_list def _iterate(self): comp_fors = tuple(get_sync_comp_fors(self._sync_comp_for_node)) yield from self._nested(comp_fors) def py__iter__(self, contextualized_node=None): for set_ in self._iterate(): yield LazyKnownValues(set_) def __repr__(self): return "<%s of %s>" % (type(self).__name__, self._sync_comp_for_node) class _DictMixin: def _get_generics(self): return tuple(c_set.py__class__() for c_set in self.get_mapping_item_values()) class Sequence(LazyAttributeOverwrite, IterableMixin): api_type = 'instance' @property def name(self): return compiled.CompiledValueName(self, self.array_type) def _get_generics(self): return (self.merge_types_of_iterate().py__class__(),) @inference_state_method_cache(default=()) def _cached_generics(self): return self._get_generics() def _get_wrapped_value(self): from jedi.inference.gradual.base import GenericClass from jedi.inference.gradual.generics import TupleGenericManager klass = compiled.builtin_from_name(self.inference_state, self.array_type) c, = GenericClass( klass, TupleGenericManager(self._cached_generics()) ).execute_annotation() return c def py__bool__(self): return None # We don't know the length, because of appends. @safe_property def parent(self): return self.inference_state.builtins_module def py__getitem__(self, index_value_set, contextualized_node): if self.array_type == 'dict': return self._dict_values() return iterate_values(ValueSet([self])) class _BaseComprehension(ComprehensionMixin): def __init__(self, inference_state, defining_context, sync_comp_for_node, entry_node): assert sync_comp_for_node.type == 'sync_comp_for' super().__init__(inference_state) self._defining_context = defining_context self._sync_comp_for_node = sync_comp_for_node self._entry_node = entry_node class ListComprehension(_BaseComprehension, Sequence): array_type = 'list' def py__simple_getitem__(self, index): if isinstance(index, slice): return ValueSet([self]) all_types = list(self.py__iter__()) with reraise_getitem_errors(IndexError, TypeError): lazy_value = all_types[index] return lazy_value.infer() class SetComprehension(_BaseComprehension, Sequence): array_type = 'set' class GeneratorComprehension(_BaseComprehension, GeneratorBase): pass class _DictKeyMixin: # TODO merge with _DictMixin? def get_mapping_item_values(self): return self._dict_keys(), self._dict_values() def get_key_values(self): # TODO merge with _dict_keys? return self._dict_keys() class DictComprehension(ComprehensionMixin, Sequence, _DictKeyMixin): array_type = 'dict' def __init__(self, inference_state, defining_context, sync_comp_for_node, key_node, value_node): assert sync_comp_for_node.type == 'sync_comp_for' super().__init__(inference_state) self._defining_context = defining_context self._sync_comp_for_node = sync_comp_for_node self._entry_node = key_node self._value_node = value_node def py__iter__(self, contextualized_node=None): for keys, values in self._iterate(): yield LazyKnownValues(keys) def py__simple_getitem__(self, index): for keys, values in self._iterate(): for k in keys: # Be careful in the future if refactoring, index could be a # slice object. if k.get_safe_value(default=object()) == index: return values raise SimpleGetItemNotFound() def _dict_keys(self): return ValueSet.from_sets(keys for keys, values in self._iterate()) def _dict_values(self): return ValueSet.from_sets(values for keys, values in self._iterate()) @publish_method('values') def _imitate_values(self, arguments): lazy_value = LazyKnownValues(self._dict_values()) return ValueSet([FakeList(self.inference_state, [lazy_value])]) @publish_method('items') def _imitate_items(self, arguments): lazy_values = [ LazyKnownValue( FakeTuple( self.inference_state, [LazyKnownValues(key), LazyKnownValues(value)] ) ) for key, value in self._iterate() ] return ValueSet([FakeList(self.inference_state, lazy_values)]) def exact_key_items(self): # NOTE: A smarter thing can probably done here to achieve better # completions, but at least like this jedi doesn't crash return [] class SequenceLiteralValue(Sequence): _TUPLE_LIKE = 'testlist_star_expr', 'testlist', 'subscriptlist' mapping = {'(': 'tuple', '[': 'list', '{': 'set'} def __init__(self, inference_state, defining_context, atom): super().__init__(inference_state) self.atom = atom self._defining_context = defining_context if self.atom.type in self._TUPLE_LIKE: self.array_type = 'tuple' else: self.array_type = SequenceLiteralValue.mapping[atom.children[0]] """The builtin name of the array (list, set, tuple or dict).""" def _get_generics(self): if self.array_type == 'tuple': return tuple(x.infer().py__class__() for x in self.py__iter__()) return super()._get_generics() def py__simple_getitem__(self, index): """Here the index is an int/str. Raises IndexError/KeyError.""" if isinstance(index, slice): return ValueSet([self]) else: with reraise_getitem_errors(TypeError, KeyError, IndexError): node = self.get_tree_entries()[index] if node == ':' or node.type == 'subscript': return NO_VALUES return self._defining_context.infer_node(node) def py__iter__(self, contextualized_node=None): """ While values returns the possible values for any array field, this function returns the value for a certain index. """ for node in self.get_tree_entries(): if node == ':' or node.type == 'subscript': # TODO this should probably use at least part of the code # of infer_subscript_list. yield LazyKnownValue(Slice(self._defining_context, None, None, None)) else: yield LazyTreeValue(self._defining_context, node) yield from check_array_additions(self._defining_context, self) def py__len__(self): # This function is not really used often. It's more of a try. return len(self.get_tree_entries()) def get_tree_entries(self): c = self.atom.children if self.atom.type in self._TUPLE_LIKE: return c[::2] array_node = c[1] if array_node in (']', '}', ')'): return [] # Direct closing bracket, doesn't contain items. if array_node.type == 'testlist_comp': # filter out (for now) pep 448 single-star unpacking return [value for value in array_node.children[::2] if value.type != "star_expr"] elif array_node.type == 'dictorsetmaker': kv = [] iterator = iter(array_node.children) for key in iterator: if key == "**": # dict with pep 448 double-star unpacking # for now ignoring the values imported by ** next(iterator) next(iterator, None) # Possible comma. else: op = next(iterator, None) if op is None or op == ',': if key.type == "star_expr": # pep 448 single-star unpacking # for now ignoring values imported by * pass else: kv.append(key) # A set. else: assert op == ':' # A dict. kv.append((key, next(iterator))) next(iterator, None) # Possible comma. return kv else: if array_node.type == "star_expr": # pep 448 single-star unpacking # for now ignoring values imported by * return [] else: return [array_node] def __repr__(self): return "<%s of %s>" % (self.__class__.__name__, self.atom) class DictLiteralValue(_DictMixin, SequenceLiteralValue, _DictKeyMixin): array_type = 'dict' def __init__(self, inference_state, defining_context, atom): # Intentionally don't call the super class. This is definitely a sign # that the architecture is bad and we should refactor. Sequence.__init__(self, inference_state) self._defining_context = defining_context self.atom = atom def py__simple_getitem__(self, index): """Here the index is an int/str. Raises IndexError/KeyError.""" compiled_value_index = compiled.create_simple_object(self.inference_state, index) for key, value in self.get_tree_entries(): for k in self._defining_context.infer_node(key): for key_v in k.execute_operation(compiled_value_index, '=='): if key_v.get_safe_value(): return self._defining_context.infer_node(value) raise SimpleGetItemNotFound('No key found in dictionary %s.' % self) def py__iter__(self, contextualized_node=None): """ While values returns the possible values for any array field, this function returns the value for a certain index. """ # Get keys. types = NO_VALUES for k, _ in self.get_tree_entries(): types |= self._defining_context.infer_node(k) # We don't know which dict index comes first, therefore always # yield all the types. for _ in types: yield LazyKnownValues(types) @publish_method('values') def _imitate_values(self, arguments): lazy_value = LazyKnownValues(self._dict_values()) return ValueSet([FakeList(self.inference_state, [lazy_value])]) @publish_method('items') def _imitate_items(self, arguments): lazy_values = [ LazyKnownValue(FakeTuple( self.inference_state, (LazyTreeValue(self._defining_context, key_node), LazyTreeValue(self._defining_context, value_node)) )) for key_node, value_node in self.get_tree_entries() ] return ValueSet([FakeList(self.inference_state, lazy_values)]) def exact_key_items(self): """ Returns a generator of tuples like dict.items(), where the key is resolved (as a string) and the values are still lazy values. """ for key_node, value in self.get_tree_entries(): for key in self._defining_context.infer_node(key_node): if is_string(key): yield key.get_safe_value(), LazyTreeValue(self._defining_context, value) def _dict_values(self): return ValueSet.from_sets( self._defining_context.infer_node(v) for k, v in self.get_tree_entries() ) def _dict_keys(self): return ValueSet.from_sets( self._defining_context.infer_node(k) for k, v in self.get_tree_entries() ) class _FakeSequence(Sequence): def __init__(self, inference_state, lazy_value_list): """ type should be one of "tuple", "list" """ super().__init__(inference_state) self._lazy_value_list = lazy_value_list def py__simple_getitem__(self, index): if isinstance(index, slice): return ValueSet([self]) with reraise_getitem_errors(IndexError, TypeError): lazy_value = self._lazy_value_list[index] return lazy_value.infer() def py__iter__(self, contextualized_node=None): return self._lazy_value_list def py__bool__(self): return bool(len(self._lazy_value_list)) def __repr__(self): return "<%s of %s>" % (type(self).__name__, self._lazy_value_list) class FakeTuple(_FakeSequence): array_type = 'tuple' class FakeList(_FakeSequence): array_type = 'tuple' class FakeDict(_DictMixin, Sequence, _DictKeyMixin): array_type = 'dict' def __init__(self, inference_state, dct): super().__init__(inference_state) self._dct = dct def py__iter__(self, contextualized_node=None): for key in self._dct: yield LazyKnownValue(compiled.create_simple_object(self.inference_state, key)) def py__simple_getitem__(self, index): with reraise_getitem_errors(KeyError, TypeError): lazy_value = self._dct[index] return lazy_value.infer() @publish_method('values') def _values(self, arguments): return ValueSet([FakeTuple( self.inference_state, [LazyKnownValues(self._dict_values())] )]) def _dict_values(self): return ValueSet.from_sets(lazy_value.infer() for lazy_value in self._dct.values()) def _dict_keys(self): return ValueSet.from_sets(lazy_value.infer() for lazy_value in self.py__iter__()) def exact_key_items(self): return self._dct.items() def __repr__(self): return '<%s: %s>' % (self.__class__.__name__, self._dct) class MergedArray(Sequence): def __init__(self, inference_state, arrays): super().__init__(inference_state) self.array_type = arrays[-1].array_type self._arrays = arrays def py__iter__(self, contextualized_node=None): for array in self._arrays: yield from array.py__iter__() def py__simple_getitem__(self, index): return ValueSet.from_sets(lazy_value.infer() for lazy_value in self.py__iter__()) def unpack_tuple_to_dict(context, types, exprlist): """ Unpacking tuple assignments in for statements and expr_stmts. """ if exprlist.type == 'name': return {exprlist.value: types} elif exprlist.type == 'atom' and exprlist.children[0] in ('(', '['): return unpack_tuple_to_dict(context, types, exprlist.children[1]) elif exprlist.type in ('testlist', 'testlist_comp', 'exprlist', 'testlist_star_expr'): dct = {} parts = iter(exprlist.children[::2]) n = 0 for lazy_value in types.iterate(ContextualizedNode(context, exprlist)): n += 1 try: part = next(parts) except StopIteration: analysis.add(context, 'value-error-too-many-values', part, message="ValueError: too many values to unpack (expected %s)" % n) else: dct.update(unpack_tuple_to_dict(context, lazy_value.infer(), part)) has_parts = next(parts, None) if types and has_parts is not None: analysis.add(context, 'value-error-too-few-values', has_parts, message="ValueError: need more than %s values to unpack" % n) return dct elif exprlist.type == 'power' or exprlist.type == 'atom_expr': # Something like ``arr[x], var = ...``. # This is something that is not yet supported, would also be difficult # to write into a dict. return {} elif exprlist.type == 'star_expr': # `a, *b, c = x` type unpackings # Currently we're not supporting them. return {} raise NotImplementedError class Slice(LazyValueWrapper): def __init__(self, python_context, start, stop, step): self.inference_state = python_context.inference_state self._context = python_context # All of them are either a Precedence or None. self._start = start self._stop = stop self._step = step def _get_wrapped_value(self): value = compiled.builtin_from_name(self._context.inference_state, 'slice') slice_value, = value.execute_with_values() return slice_value def get_safe_value(self, default=sentinel): """ Imitate CompiledValue.obj behavior and return a ``builtin.slice()`` object. """ def get(element): if element is None: return None result = self._context.infer_node(element) if len(result) != 1: # For simplicity, we want slices to be clear defined with just # one type. Otherwise we will return an empty slice object. raise IndexError value, = result return get_int_or_none(value) try: return slice(get(self._start), get(self._stop), get(self._step)) except IndexError: return slice(None, None, None) ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/jedi/inference/value/klass.py0000664000175000017500000003710400000000000020061 0ustar00davedave00000000000000""" Like described in the :mod:`parso.python.tree` module, there's a need for an ast like module to represent the states of parsed modules. But now there are also structures in Python that need a little bit more than that. An ``Instance`` for example is only a ``Class`` before it is instantiated. This class represents these cases. So, why is there also a ``Class`` class here? Well, there are decorators and they change classes in Python 3. Representation modules also define "magic methods". Those methods look like ``py__foo__`` and are typically mappable to the Python equivalents ``__call__`` and others. Here's a list: ====================================== ======================================== **Method** **Description** -------------------------------------- ---------------------------------------- py__call__(arguments: Array) On callable objects, returns types. py__bool__() Returns True/False/None; None means that there's no certainty. py__bases__() Returns a list of base classes. py__iter__() Returns a generator of a set of types. py__class__() Returns the class of an instance. py__simple_getitem__(index: int/str) Returns a a set of types of the index. Can raise an IndexError/KeyError. py__getitem__(indexes: ValueSet) Returns a a set of types of the index. py__file__() Only on modules. Returns None if does not exist. py__package__() -> List[str] Only on modules. For the import system. py__path__() Only on modules. For the import system. py__get__(call_object) Only on instances. Simulates descriptors. py__doc__() Returns the docstring for a value. ====================================== ======================================== """ from jedi import debug from jedi.parser_utils import get_cached_parent_scope, expr_is_dotted, \ function_is_property from jedi.inference.cache import inference_state_method_cache, CachedMetaClass, \ inference_state_method_generator_cache from jedi.inference import compiled from jedi.inference.lazy_value import LazyKnownValues, LazyTreeValue from jedi.inference.filters import ParserTreeFilter from jedi.inference.names import TreeNameDefinition, ValueName from jedi.inference.arguments import unpack_arglist, ValuesArguments from jedi.inference.base_value import ValueSet, iterator_to_value_set, \ NO_VALUES from jedi.inference.context import ClassContext from jedi.inference.value.function import FunctionAndClassBase from jedi.inference.gradual.generics import LazyGenericManager, TupleGenericManager from jedi.plugins import plugin_manager class ClassName(TreeNameDefinition): def __init__(self, class_value, tree_name, name_context, apply_decorators): super().__init__(name_context, tree_name) self._apply_decorators = apply_decorators self._class_value = class_value @iterator_to_value_set def infer(self): # We're using a different value to infer, so we cannot call super(). from jedi.inference.syntax_tree import tree_name_to_values inferred = tree_name_to_values( self.parent_context.inference_state, self.parent_context, self.tree_name) for result_value in inferred: if self._apply_decorators: yield from result_value.py__get__(instance=None, class_value=self._class_value) else: yield result_value @property def api_type(self): type_ = super().api_type if type_ == 'function': definition = self.tree_name.get_definition() if definition is None: return type_ if function_is_property(definition): # This essentially checks if there is an @property before # the function. @property could be something different, but # any programmer that redefines property as something that # is not really a property anymore, should be shot. (i.e. # this is a heuristic). return 'property' return type_ class ClassFilter(ParserTreeFilter): def __init__(self, class_value, node_context=None, until_position=None, origin_scope=None, is_instance=False): super().__init__( class_value.as_context(), node_context, until_position=until_position, origin_scope=origin_scope, ) self._class_value = class_value self._is_instance = is_instance def _convert_names(self, names): return [ ClassName( class_value=self._class_value, tree_name=name, name_context=self._node_context, apply_decorators=not self._is_instance, ) for name in names ] def _equals_origin_scope(self): node = self._origin_scope while node is not None: if node == self._parser_scope or node == self.parent_context: return True node = get_cached_parent_scope(self._parso_cache_node, node) return False def _access_possible(self, name): # Filter for name mangling of private variables like __foo return not name.value.startswith('__') or name.value.endswith('__') \ or self._equals_origin_scope() def _filter(self, names): names = super()._filter(names) return [name for name in names if self._access_possible(name)] class ClassMixin: def is_class(self): return True def is_class_mixin(self): return True def py__call__(self, arguments): from jedi.inference.value import TreeInstance from jedi.inference.gradual.typing import TypedDict if self.is_typeddict(): return ValueSet([TypedDict(self)]) return ValueSet([TreeInstance(self.inference_state, self.parent_context, self, arguments)]) def py__class__(self): return compiled.builtin_from_name(self.inference_state, 'type') @property def name(self): return ValueName(self, self.tree_node.name) def py__name__(self): return self.name.string_name @inference_state_method_generator_cache() def py__mro__(self): mro = [self] yield self # TODO Do a proper mro resolution. Currently we are just listing # classes. However, it's a complicated algorithm. for lazy_cls in self.py__bases__(): # TODO there's multiple different mro paths possible if this yields # multiple possibilities. Could be changed to be more correct. for cls in lazy_cls.infer(): # TODO detect for TypeError: duplicate base class str, # e.g. `class X(str, str): pass` try: mro_method = cls.py__mro__ except AttributeError: # TODO add a TypeError like: """ >>> class Y(lambda: test): pass Traceback (most recent call last): File "", line 1, in TypeError: function() argument 1 must be code, not str >>> class Y(1): pass Traceback (most recent call last): File "", line 1, in TypeError: int() takes at most 2 arguments (3 given) """ debug.warning('Super class of %s is not a class: %s', self, cls) else: for cls_new in mro_method(): if cls_new not in mro: mro.append(cls_new) yield cls_new def get_filters(self, origin_scope=None, is_instance=False, include_metaclasses=True, include_type_when_class=True): if include_metaclasses: metaclasses = self.get_metaclasses() if metaclasses: yield from self.get_metaclass_filters(metaclasses, is_instance) for cls in self.py__mro__(): if cls.is_compiled(): yield from cls.get_filters(is_instance=is_instance) else: yield ClassFilter( self, node_context=cls.as_context(), origin_scope=origin_scope, is_instance=is_instance ) if not is_instance and include_type_when_class: from jedi.inference.compiled import builtin_from_name type_ = builtin_from_name(self.inference_state, 'type') assert isinstance(type_, ClassValue) if type_ != self: # We are not using execute_with_values here, because the # plugin function for type would get executed instead of an # instance creation. args = ValuesArguments([]) for instance in type_.py__call__(args): instance_filters = instance.get_filters() # Filter out self filters next(instance_filters, None) next(instance_filters, None) x = next(instance_filters, None) assert x is not None yield x def get_signatures(self): # Since calling staticmethod without a function is illegal, the Jedi # plugin doesn't return anything. Therefore call directly and get what # we want: An instance of staticmethod. metaclasses = self.get_metaclasses() if metaclasses: sigs = self.get_metaclass_signatures(metaclasses) if sigs: return sigs args = ValuesArguments([]) init_funcs = self.py__call__(args).py__getattribute__('__init__') return [sig.bind(self) for sig in init_funcs.get_signatures()] def _as_context(self): return ClassContext(self) def get_type_hint(self, add_class_info=True): if add_class_info: return 'Type[%s]' % self.py__name__() return self.py__name__() @inference_state_method_cache(default=False) def is_typeddict(self): # TODO Do a proper mro resolution. Currently we are just listing # classes. However, it's a complicated algorithm. from jedi.inference.gradual.typing import TypedDictClass for lazy_cls in self.py__bases__(): if not isinstance(lazy_cls, LazyTreeValue): return False tree_node = lazy_cls.data # Only resolve simple classes, stuff like Iterable[str] are more # intensive to resolve and if generics are involved, we know it's # not a TypedDict. if not expr_is_dotted(tree_node): return False for cls in lazy_cls.infer(): if isinstance(cls, TypedDictClass): return True try: method = cls.is_typeddict except AttributeError: # We're only dealing with simple classes, so just returning # here should be fine. This only happens with e.g. compiled # classes. return False else: if method(): return True return False def py__getitem__(self, index_value_set, contextualized_node): from jedi.inference.gradual.base import GenericClass if not index_value_set: debug.warning('Class indexes inferred to nothing. Returning class instead') return ValueSet([self]) return ValueSet( GenericClass( self, LazyGenericManager( context_of_index=contextualized_node.context, index_value=index_value, ) ) for index_value in index_value_set ) def with_generics(self, generics_tuple): from jedi.inference.gradual.base import GenericClass return GenericClass( self, TupleGenericManager(generics_tuple) ) def define_generics(self, type_var_dict): from jedi.inference.gradual.base import GenericClass def remap_type_vars(): """ The TypeVars in the resulting classes have sometimes different names and we need to check for that, e.g. a signature can be: def iter(iterable: Iterable[_T]) -> Iterator[_T]: ... However, the iterator is defined as Iterator[_T_co], which means it has a different type var name. """ for type_var in self.list_type_vars(): yield type_var_dict.get(type_var.py__name__(), NO_VALUES) if type_var_dict: return ValueSet([GenericClass( self, TupleGenericManager(tuple(remap_type_vars())) )]) return ValueSet({self}) class ClassValue(ClassMixin, FunctionAndClassBase, metaclass=CachedMetaClass): api_type = 'class' @inference_state_method_cache() def list_type_vars(self): found = [] arglist = self.tree_node.get_super_arglist() if arglist is None: return [] for stars, node in unpack_arglist(arglist): if stars: continue # These are not relevant for this search. from jedi.inference.gradual.annotation import find_unknown_type_vars for type_var in find_unknown_type_vars(self.parent_context, node): if type_var not in found: # The order matters and it's therefore a list. found.append(type_var) return found def _get_bases_arguments(self): arglist = self.tree_node.get_super_arglist() if arglist: from jedi.inference import arguments return arguments.TreeArguments(self.inference_state, self.parent_context, arglist) return None @inference_state_method_cache(default=()) def py__bases__(self): args = self._get_bases_arguments() if args is not None: lst = [value for key, value in args.unpack() if key is None] if lst: return lst if self.py__name__() == 'object' \ and self.parent_context.is_builtins_module(): return [] return [LazyKnownValues( self.inference_state.builtins_module.py__getattribute__('object') )] @plugin_manager.decorate() def get_metaclass_filters(self, metaclasses, is_instance): debug.warning('Unprocessed metaclass %s', metaclasses) return [] @inference_state_method_cache(default=NO_VALUES) def get_metaclasses(self): args = self._get_bases_arguments() if args is not None: m = [value for key, value in args.unpack() if key == 'metaclass'] metaclasses = ValueSet.from_sets(lazy_value.infer() for lazy_value in m) metaclasses = ValueSet(m for m in metaclasses if m.is_class()) if metaclasses: return metaclasses for lazy_base in self.py__bases__(): for value in lazy_base.infer(): if value.is_class(): values = value.get_metaclasses() if values: return values return NO_VALUES @plugin_manager.decorate() def get_metaclass_signatures(self, metaclasses): return [] ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/jedi/inference/value/module.py0000664000175000017500000001766600000000000020244 0ustar00davedave00000000000000import os from pathlib import Path from typing import Optional from jedi.inference.cache import inference_state_method_cache from jedi.inference.names import AbstractNameDefinition, ModuleName from jedi.inference.filters import GlobalNameFilter, ParserTreeFilter, DictFilter, MergedFilter from jedi.inference import compiled from jedi.inference.base_value import TreeValue from jedi.inference.names import SubModuleName from jedi.inference.helpers import values_from_qualified_names from jedi.inference.compiled import create_simple_object from jedi.inference.base_value import ValueSet from jedi.inference.context import ModuleContext class _ModuleAttributeName(AbstractNameDefinition): """ For module attributes like __file__, __str__ and so on. """ api_type = 'instance' def __init__(self, parent_module, string_name, string_value=None): self.parent_context = parent_module self.string_name = string_name self._string_value = string_value def infer(self): if self._string_value is not None: s = self._string_value return ValueSet([ create_simple_object(self.parent_context.inference_state, s) ]) return compiled.get_string_value_set(self.parent_context.inference_state) class SubModuleDictMixin: @inference_state_method_cache() def sub_modules_dict(self): """ Lists modules in the directory of this module (if this module is a package). """ names = {} if self.is_package(): mods = self.inference_state.compiled_subprocess.iter_module_names( self.py__path__() ) for name in mods: # It's obviously a relative import to the current module. names[name] = SubModuleName(self.as_context(), name) # In the case of an import like `from x.` we don't need to # add all the variables, this is only about submodules. return names class ModuleMixin(SubModuleDictMixin): _module_name_class = ModuleName def get_filters(self, origin_scope=None): yield MergedFilter( ParserTreeFilter( parent_context=self.as_context(), origin_scope=origin_scope ), GlobalNameFilter(self.as_context()), ) yield DictFilter(self.sub_modules_dict()) yield DictFilter(self._module_attributes_dict()) yield from self.iter_star_filters() def py__class__(self): c, = values_from_qualified_names(self.inference_state, 'types', 'ModuleType') return c def is_module(self): return True def is_stub(self): return False @property # type: ignore[misc] @inference_state_method_cache() def name(self): return self._module_name_class(self, self.string_names[-1]) @inference_state_method_cache() def _module_attributes_dict(self): names = ['__package__', '__doc__', '__name__'] # All the additional module attributes are strings. dct = dict((n, _ModuleAttributeName(self, n)) for n in names) path = self.py__file__() if path is not None: dct['__file__'] = _ModuleAttributeName(self, '__file__', str(path)) return dct def iter_star_filters(self): for star_module in self.star_imports(): f = next(star_module.get_filters(), None) assert f is not None yield f # I'm not sure if the star import cache is really that effective anymore # with all the other really fast import caches. Recheck. Also we would need # to push the star imports into InferenceState.module_cache, if we reenable this. @inference_state_method_cache([]) def star_imports(self): from jedi.inference.imports import Importer modules = [] module_context = self.as_context() for i in self.tree_node.iter_imports(): if i.is_star_import(): new = Importer( self.inference_state, import_path=i.get_paths()[-1], module_context=module_context, level=i.level ).follow() for module in new: if isinstance(module, ModuleValue): modules += module.star_imports() modules += new return modules def get_qualified_names(self): """ A module doesn't have a qualified name, but it's important to note that it's reachable and not `None`. With this information we can add qualified names on top for all value children. """ return () class ModuleValue(ModuleMixin, TreeValue): api_type = 'module' def __init__(self, inference_state, module_node, code_lines, file_io=None, string_names=None, is_package=False): super().__init__( inference_state, parent_context=None, tree_node=module_node ) self.file_io = file_io if file_io is None: self._path: Optional[Path] = None else: self._path = file_io.path self.string_names = string_names # Optional[Tuple[str, ...]] self.code_lines = code_lines self._is_package = is_package def is_stub(self): if self._path is not None and self._path.suffix == '.pyi': # Currently this is the way how we identify stubs when e.g. goto is # used in them. This could be changed if stubs would be identified # sooner and used as StubModuleValue. return True return super().is_stub() def py__name__(self): if self.string_names is None: return None return '.'.join(self.string_names) def py__file__(self) -> Optional[Path]: """ In contrast to Python's __file__ can be None. """ if self._path is None: return None return self._path.absolute() def is_package(self): return self._is_package def py__package__(self): if self.string_names is None: return [] if self._is_package: return self.string_names return self.string_names[:-1] def py__path__(self): """ In case of a package, this returns Python's __path__ attribute, which is a list of paths (strings). Returns None if the module is not a package. """ if not self._is_package: return None # A namespace package is typically auto generated and ~10 lines long. first_few_lines = ''.join(self.code_lines[:50]) # these are strings that need to be used for namespace packages, # the first one is ``pkgutil``, the second ``pkg_resources``. options = ('declare_namespace(__name__)', 'extend_path(__path__') if options[0] in first_few_lines or options[1] in first_few_lines: # It is a namespace, now try to find the rest of the # modules on sys_path or whatever the search_path is. paths = set() for s in self.inference_state.get_sys_path(): other = os.path.join(s, self.name.string_name) if os.path.isdir(other): paths.add(other) if paths: return list(paths) # Nested namespace packages will not be supported. Nobody ever # asked for it and in Python 3 they are there without using all the # crap above. # Default to the of this file. file = self.py__file__() assert file is not None # Shouldn't be a package in the first place. return [os.path.dirname(file)] def _as_context(self): return ModuleContext(self) def __repr__(self): return "<%s: %s@%s-%s is_stub=%s>" % ( self.__class__.__name__, self.py__name__(), self.tree_node.start_pos[0], self.tree_node.end_pos[0], self.is_stub() ) ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/jedi/inference/value/namespace.py0000664000175000017500000000406500000000000020700 0ustar00davedave00000000000000from pathlib import Path from typing import Optional from jedi.inference.cache import inference_state_method_cache from jedi.inference.filters import DictFilter from jedi.inference.names import ValueNameMixin, AbstractNameDefinition from jedi.inference.base_value import Value from jedi.inference.value.module import SubModuleDictMixin from jedi.inference.context import NamespaceContext class ImplicitNSName(ValueNameMixin, AbstractNameDefinition): """ Accessing names for implicit namespace packages should infer to nothing. This object will prevent Jedi from raising exceptions """ def __init__(self, implicit_ns_value, string_name): self._value = implicit_ns_value self.string_name = string_name class ImplicitNamespaceValue(Value, SubModuleDictMixin): """ Provides support for implicit namespace packages """ api_type = 'namespace' parent_context = None def __init__(self, inference_state, string_names, paths): super().__init__(inference_state, parent_context=None) self.inference_state = inference_state self.string_names = string_names self._paths = paths def get_filters(self, origin_scope=None): yield DictFilter(self.sub_modules_dict()) def get_qualified_names(self): return () @property # type: ignore[misc] @inference_state_method_cache() def name(self): string_name = self.py__package__()[-1] return ImplicitNSName(self, string_name) def py__file__(self) -> Optional[Path]: return None def py__package__(self): """Return the fullname """ return self.string_names def py__path__(self): return self._paths def py__name__(self): return '.'.join(self.string_names) def is_namespace(self): return True def is_stub(self): return False def is_package(self): return True def as_context(self): return NamespaceContext(self) def __repr__(self): return '<%s: %s>' % (self.__class__.__name__, self.py__name__()) ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/jedi/parser_utils.py0000664000175000017500000002522400000000000016406 0ustar00davedave00000000000000import re import textwrap from ast import literal_eval from inspect import cleandoc from weakref import WeakKeyDictionary from parso.python import tree from parso.cache import parser_cache from parso import split_lines _EXECUTE_NODES = {'funcdef', 'classdef', 'import_from', 'import_name', 'test', 'or_test', 'and_test', 'not_test', 'comparison', 'expr', 'xor_expr', 'and_expr', 'shift_expr', 'arith_expr', 'atom_expr', 'term', 'factor', 'power', 'atom'} _FLOW_KEYWORDS = ( 'try', 'except', 'finally', 'else', 'if', 'elif', 'with', 'for', 'while' ) def get_executable_nodes(node, last_added=False): """ For static analysis. """ result = [] typ = node.type if typ == 'name': next_leaf = node.get_next_leaf() if last_added is False and node.parent.type != 'param' and next_leaf != '=': result.append(node) elif typ == 'expr_stmt': # I think inferring the statement (and possibly returned arrays), # should be enough for static analysis. result.append(node) for child in node.children: result += get_executable_nodes(child, last_added=True) elif typ == 'decorator': # decorator if node.children[-2] == ')': node = node.children[-3] if node != '(': result += get_executable_nodes(node) else: try: children = node.children except AttributeError: pass else: if node.type in _EXECUTE_NODES and not last_added: result.append(node) for child in children: result += get_executable_nodes(child, last_added) return result def get_sync_comp_fors(comp_for): yield comp_for last = comp_for.children[-1] while True: if last.type == 'comp_for': yield last.children[1] # Ignore the async. elif last.type == 'sync_comp_for': yield last elif not last.type == 'comp_if': break last = last.children[-1] def for_stmt_defines_one_name(for_stmt): """ Returns True if only one name is returned: ``for x in y``. Returns False if the for loop is more complicated: ``for x, z in y``. :returns: bool """ return for_stmt.children[1].type == 'name' def get_flow_branch_keyword(flow_node, node): start_pos = node.start_pos if not (flow_node.start_pos < start_pos <= flow_node.end_pos): raise ValueError('The node is not part of the flow.') keyword = None for i, child in enumerate(flow_node.children): if start_pos < child.start_pos: return keyword first_leaf = child.get_first_leaf() if first_leaf in _FLOW_KEYWORDS: keyword = first_leaf return None def clean_scope_docstring(scope_node): """ Returns a cleaned version of the docstring token. """ node = scope_node.get_doc_node() if node is not None: # TODO We have to check next leaves until there are no new # leaves anymore that might be part of the docstring. A # docstring can also look like this: ``'foo' 'bar' # Returns a literal cleaned version of the ``Token``. return cleandoc(safe_literal_eval(node.value)) return '' def find_statement_documentation(tree_node): if tree_node.type == 'expr_stmt': tree_node = tree_node.parent # simple_stmt maybe_string = tree_node.get_next_sibling() if maybe_string is not None: if maybe_string.type == 'simple_stmt': maybe_string = maybe_string.children[0] if maybe_string.type == 'string': return cleandoc(safe_literal_eval(maybe_string.value)) return '' def safe_literal_eval(value): first_two = value[:2].lower() if first_two[0] == 'f' or first_two in ('fr', 'rf'): # literal_eval is not able to resovle f literals. We have to do that # manually, but that's right now not implemented. return '' return literal_eval(value) def get_signature(funcdef, width=72, call_string=None, omit_first_param=False, omit_return_annotation=False): """ Generate a string signature of a function. :param width: Fold lines if a line is longer than this value. :type width: int :arg func_name: Override function name when given. :type func_name: str :rtype: str """ # Lambdas have no name. if call_string is None: if funcdef.type == 'lambdef': call_string = '' else: call_string = funcdef.name.value params = funcdef.get_params() if omit_first_param: params = params[1:] p = '(' + ''.join(param.get_code() for param in params).strip() + ')' # TODO this is pretty bad, we should probably just normalize. p = re.sub(r'\s+', ' ', p) if funcdef.annotation and not omit_return_annotation: rtype = " ->" + funcdef.annotation.get_code() else: rtype = "" code = call_string + p + rtype return '\n'.join(textwrap.wrap(code, width)) def move(node, line_offset): """ Move the `Node` start_pos. """ try: children = node.children except AttributeError: node.line += line_offset else: for c in children: move(c, line_offset) def get_following_comment_same_line(node): """ returns (as string) any comment that appears on the same line, after the node, including the # """ try: if node.type == 'for_stmt': whitespace = node.children[5].get_first_leaf().prefix elif node.type == 'with_stmt': whitespace = node.children[3].get_first_leaf().prefix elif node.type == 'funcdef': # actually on the next line whitespace = node.children[4].get_first_leaf().get_next_leaf().prefix else: whitespace = node.get_last_leaf().get_next_leaf().prefix except AttributeError: return None except ValueError: # TODO in some particular cases, the tree doesn't seem to be linked # correctly return None if "#" not in whitespace: return None comment = whitespace[whitespace.index("#"):] if "\r" in comment: comment = comment[:comment.index("\r")] if "\n" in comment: comment = comment[:comment.index("\n")] return comment def is_scope(node): t = node.type if t == 'comp_for': # Starting with Python 3.8, async is outside of the statement. return node.children[1].type != 'sync_comp_for' return t in ('file_input', 'classdef', 'funcdef', 'lambdef', 'sync_comp_for') def _get_parent_scope_cache(func): cache = WeakKeyDictionary() def wrapper(parso_cache_node, node, include_flows=False): if parso_cache_node is None: return func(node, include_flows) try: for_module = cache[parso_cache_node] except KeyError: for_module = cache[parso_cache_node] = {} try: return for_module[node] except KeyError: result = for_module[node] = func(node, include_flows) return result return wrapper def get_parent_scope(node, include_flows=False): """ Returns the underlying scope. """ scope = node.parent if scope is None: return None # It's a module already. while True: if is_scope(scope): if scope.type in ('classdef', 'funcdef', 'lambdef'): index = scope.children.index(':') if scope.children[index].start_pos >= node.start_pos: if node.parent.type == 'param' and node.parent.name == node: pass elif node.parent.type == 'tfpdef' and node.parent.children[0] == node: pass else: scope = scope.parent continue return scope elif include_flows and isinstance(scope, tree.Flow): # The cursor might be on `if foo`, so the parent scope will not be # the if, but the parent of the if. if not (scope.type == 'if_stmt' and any(n.start_pos <= node.start_pos < n.end_pos for n in scope.get_test_nodes())): return scope scope = scope.parent get_cached_parent_scope = _get_parent_scope_cache(get_parent_scope) def get_cached_code_lines(grammar, path): """ Basically access the cached code lines in parso. This is not the nicest way to do this, but we avoid splitting all the lines again. """ return get_parso_cache_node(grammar, path).lines def get_parso_cache_node(grammar, path): """ This is of course not public. But as long as I control parso, this shouldn't be a problem. ~ Dave The reason for this is mostly caching. This is obviously also a sign of a broken caching architecture. """ return parser_cache[grammar._hashed][path] def cut_value_at_position(leaf, position): """ Cuts of the value of the leaf at position """ lines = split_lines(leaf.value, keepends=True)[:position[0] - leaf.line + 1] column = position[1] if leaf.line == position[0]: column -= leaf.column if not lines: return '' lines[-1] = lines[-1][:column] return ''.join(lines) def expr_is_dotted(node): """ Checks if a path looks like `name` or `name.foo.bar` and not `name()`. """ if node.type == 'atom': if len(node.children) == 3 and node.children[0] == '(': return expr_is_dotted(node.children[1]) return False if node.type == 'atom_expr': children = node.children if children[0] == 'await': return False if not expr_is_dotted(children[0]): return False # Check trailers return all(c.children[0] == '.' for c in children[1:]) return node.type == 'name' def _function_is_x_method(*method_names): def wrapper(function_node): """ This is a heuristic. It will not hold ALL the times, but it will be correct pretty much for anyone that doesn't try to beat it. staticmethod/classmethod are builtins and unless overwritten, this will be correct. """ for decorator in function_node.get_decorators(): dotted_name = decorator.children[1] if dotted_name.get_code() in method_names: return True return False return wrapper function_is_staticmethod = _function_is_x_method('staticmethod') function_is_classmethod = _function_is_x_method('classmethod') function_is_property = _function_is_x_method('property', 'cached_property') ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.3903792 jedi-0.19.1/jedi/plugins/0000775000175000017500000000000000000000000014774 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/jedi/plugins/__init__.py0000664000175000017500000000264500000000000017114 0ustar00davedave00000000000000from functools import wraps class _PluginManager: def __init__(self): self._registered_plugins = [] self._cached_base_callbacks = {} self._built_functions = {} def register(self, *plugins): """ Makes it possible to register your plugin. """ self._registered_plugins.extend(plugins) self._build_functions() def decorate(self, name=None): def decorator(callback): @wraps(callback) def wrapper(*args, **kwargs): return built_functions[public_name](*args, **kwargs) public_name = name or callback.__name__ assert public_name not in self._built_functions built_functions = self._built_functions built_functions[public_name] = callback self._cached_base_callbacks[public_name] = callback return wrapper return decorator def _build_functions(self): for name, callback in self._cached_base_callbacks.items(): for plugin in reversed(self._registered_plugins): # Need to reverse so the first plugin is run first. try: func = getattr(plugin, name) except AttributeError: pass else: callback = func(callback) self._built_functions[name] = callback plugin_manager = _PluginManager() ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/jedi/plugins/django.py0000664000175000017500000002521700000000000016617 0ustar00davedave00000000000000""" Module is used to infer Django model fields. """ from inspect import Parameter from jedi import debug from jedi.inference.cache import inference_state_function_cache from jedi.inference.base_value import ValueSet, iterator_to_value_set, ValueWrapper from jedi.inference.filters import DictFilter, AttributeOverwrite from jedi.inference.names import NameWrapper, BaseTreeParamName from jedi.inference.compiled.value import EmptyCompiledName from jedi.inference.value.instance import TreeInstance from jedi.inference.value.klass import ClassMixin from jedi.inference.gradual.base import GenericClass from jedi.inference.gradual.generics import TupleGenericManager from jedi.inference.signature import AbstractSignature mapping = { 'IntegerField': (None, 'int'), 'BigIntegerField': (None, 'int'), 'PositiveIntegerField': (None, 'int'), 'SmallIntegerField': (None, 'int'), 'CharField': (None, 'str'), 'TextField': (None, 'str'), 'EmailField': (None, 'str'), 'GenericIPAddressField': (None, 'str'), 'URLField': (None, 'str'), 'FloatField': (None, 'float'), 'BinaryField': (None, 'bytes'), 'BooleanField': (None, 'bool'), 'DecimalField': ('decimal', 'Decimal'), 'TimeField': ('datetime', 'time'), 'DurationField': ('datetime', 'timedelta'), 'DateField': ('datetime', 'date'), 'DateTimeField': ('datetime', 'datetime'), 'UUIDField': ('uuid', 'UUID'), } _FILTER_LIKE_METHODS = ('create', 'filter', 'exclude', 'update', 'get', 'get_or_create', 'update_or_create') @inference_state_function_cache() def _get_deferred_attributes(inference_state): return inference_state.import_module( ('django', 'db', 'models', 'query_utils') ).py__getattribute__('DeferredAttribute').execute_annotation() def _infer_scalar_field(inference_state, field_name, field_tree_instance, is_instance): try: module_name, attribute_name = mapping[field_tree_instance.py__name__()] except KeyError: return None if not is_instance: return _get_deferred_attributes(inference_state) if module_name is None: module = inference_state.builtins_module else: module = inference_state.import_module((module_name,)) for attribute in module.py__getattribute__(attribute_name): return attribute.execute_with_values() @iterator_to_value_set def _get_foreign_key_values(cls, field_tree_instance): if isinstance(field_tree_instance, TreeInstance): # TODO private access.. argument_iterator = field_tree_instance._arguments.unpack() key, lazy_values = next(argument_iterator, (None, None)) if key is None and lazy_values is not None: for value in lazy_values.infer(): if value.py__name__() == 'str': foreign_key_class_name = value.get_safe_value() module = cls.get_root_context() for v in module.py__getattribute__(foreign_key_class_name): if v.is_class(): yield v elif value.is_class(): yield value def _infer_field(cls, field_name, is_instance): inference_state = cls.inference_state result = field_name.infer() for field_tree_instance in result: scalar_field = _infer_scalar_field( inference_state, field_name, field_tree_instance, is_instance) if scalar_field is not None: return scalar_field name = field_tree_instance.py__name__() is_many_to_many = name == 'ManyToManyField' if name in ('ForeignKey', 'OneToOneField') or is_many_to_many: if not is_instance: return _get_deferred_attributes(inference_state) values = _get_foreign_key_values(cls, field_tree_instance) if is_many_to_many: return ValueSet(filter(None, [ _create_manager_for(v, 'RelatedManager') for v in values ])) else: return values.execute_with_values() debug.dbg('django plugin: fail to infer `%s` from class `%s`', field_name.string_name, cls.py__name__()) return result class DjangoModelName(NameWrapper): def __init__(self, cls, name, is_instance): super().__init__(name) self._cls = cls self._is_instance = is_instance def infer(self): return _infer_field(self._cls, self._wrapped_name, self._is_instance) def _create_manager_for(cls, manager_cls='BaseManager'): managers = cls.inference_state.import_module( ('django', 'db', 'models', 'manager') ).py__getattribute__(manager_cls) for m in managers: if m.is_class_mixin(): generics_manager = TupleGenericManager((ValueSet([cls]),)) for c in GenericClass(m, generics_manager).execute_annotation(): return c return None def _new_dict_filter(cls, is_instance): filters = list(cls.get_filters( is_instance=is_instance, include_metaclasses=False, include_type_when_class=False) ) dct = { name.string_name: DjangoModelName(cls, name, is_instance) for filter_ in reversed(filters) for name in filter_.values() } if is_instance: # Replace the objects with a name that amounts to nothing when accessed # in an instance. This is not perfect and still completes "objects" in # that case, but it at least not inferes stuff like `.objects.filter`. # It would be nicer to do that in a better way, so that it also doesn't # show up in completions, but it's probably just not worth doing that # for the extra amount of work. dct['objects'] = EmptyCompiledName(cls.inference_state, 'objects') return DictFilter(dct) def is_django_model_base(value): return value.py__name__() == 'ModelBase' \ and value.get_root_context().py__name__() == 'django.db.models.base' def get_metaclass_filters(func): def wrapper(cls, metaclasses, is_instance): for metaclass in metaclasses: if is_django_model_base(metaclass): return [_new_dict_filter(cls, is_instance)] return func(cls, metaclasses, is_instance) return wrapper def tree_name_to_values(func): def wrapper(inference_state, context, tree_name): result = func(inference_state, context, tree_name) if tree_name.value in _FILTER_LIKE_METHODS: # Here we try to overwrite stuff like User.objects.filter. We need # this to make sure that keyword param completion works on these # kind of methods. for v in result: if v.get_qualified_names() == ('_BaseQuerySet', tree_name.value) \ and v.parent_context.is_module() \ and v.parent_context.py__name__() == 'django.db.models.query': qs = context.get_value() generics = qs.get_generics() if len(generics) >= 1: return ValueSet(QuerySetMethodWrapper(v, model) for model in generics[0]) elif tree_name.value == 'BaseManager' and context.is_module() \ and context.py__name__() == 'django.db.models.manager': return ValueSet(ManagerWrapper(r) for r in result) elif tree_name.value == 'Field' and context.is_module() \ and context.py__name__() == 'django.db.models.fields': return ValueSet(FieldWrapper(r) for r in result) return result return wrapper def _find_fields(cls): for name in _new_dict_filter(cls, is_instance=False).values(): for value in name.infer(): if value.name.get_qualified_names(include_module_names=True) \ == ('django', 'db', 'models', 'query_utils', 'DeferredAttribute'): yield name def _get_signatures(cls): return [DjangoModelSignature(cls, field_names=list(_find_fields(cls)))] def get_metaclass_signatures(func): def wrapper(cls, metaclasses): for metaclass in metaclasses: if is_django_model_base(metaclass): return _get_signatures(cls) return func(cls, metaclass) return wrapper class ManagerWrapper(ValueWrapper): def py__getitem__(self, index_value_set, contextualized_node): return ValueSet( GenericManagerWrapper(generic) for generic in self._wrapped_value.py__getitem__( index_value_set, contextualized_node) ) class GenericManagerWrapper(AttributeOverwrite, ClassMixin): def py__get__on_class(self, calling_instance, instance, class_value): return calling_instance.class_value.with_generics( (ValueSet({class_value}),) ).py__call__(calling_instance._arguments) def with_generics(self, generics_tuple): return self._wrapped_value.with_generics(generics_tuple) class FieldWrapper(ValueWrapper): def py__getitem__(self, index_value_set, contextualized_node): return ValueSet( GenericFieldWrapper(generic) for generic in self._wrapped_value.py__getitem__( index_value_set, contextualized_node) ) class GenericFieldWrapper(AttributeOverwrite, ClassMixin): def py__get__on_class(self, calling_instance, instance, class_value): # This is mostly an optimization to avoid Jedi aborting inference, # because of too many function executions of Field.__get__. return ValueSet({calling_instance}) class DjangoModelSignature(AbstractSignature): def __init__(self, value, field_names): super().__init__(value) self._field_names = field_names def get_param_names(self, resolve_stars=False): return [DjangoParamName(name) for name in self._field_names] class DjangoParamName(BaseTreeParamName): def __init__(self, field_name): super().__init__(field_name.parent_context, field_name.tree_name) self._field_name = field_name def get_kind(self): return Parameter.KEYWORD_ONLY def infer(self): return self._field_name.infer() class QuerySetMethodWrapper(ValueWrapper): def __init__(self, method, model_cls): super().__init__(method) self._model_cls = model_cls def py__get__(self, instance, class_value): return ValueSet({QuerySetBoundMethodWrapper(v, self._model_cls) for v in self._wrapped_value.py__get__(instance, class_value)}) class QuerySetBoundMethodWrapper(ValueWrapper): def __init__(self, method, model_cls): super().__init__(method) self._model_cls = model_cls def get_signatures(self): return _get_signatures(self._model_cls) ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/jedi/plugins/flask.py0000664000175000017500000000162400000000000016451 0ustar00davedave00000000000000def import_module(callback): """ Handle "magic" Flask extension imports: ``flask.ext.foo`` is really ``flask_foo`` or ``flaskext.foo``. """ def wrapper(inference_state, import_names, module_context, *args, **kwargs): if len(import_names) == 3 and import_names[:2] == ('flask', 'ext'): # New style. ipath = ('flask_' + import_names[2]), value_set = callback(inference_state, ipath, None, *args, **kwargs) if value_set: return value_set value_set = callback(inference_state, ('flaskext',), None, *args, **kwargs) return callback( inference_state, ('flaskext', import_names[2]), next(iter(value_set)), *args, **kwargs ) return callback(inference_state, import_names, module_context, *args, **kwargs) return wrapper ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/jedi/plugins/pytest.py0000664000175000017500000002243600000000000016705 0ustar00davedave00000000000000import sys from typing import List from pathlib import Path from parso.tree import search_ancestor from jedi.inference.cache import inference_state_method_cache from jedi.inference.imports import goto_import, load_module_from_path from jedi.inference.filters import ParserTreeFilter from jedi.inference.base_value import NO_VALUES, ValueSet from jedi.inference.helpers import infer_call_of_leaf _PYTEST_FIXTURE_MODULES = [ ('_pytest', 'monkeypatch'), ('_pytest', 'capture'), ('_pytest', 'logging'), ('_pytest', 'tmpdir'), ('_pytest', 'pytester'), ] def execute(callback): def wrapper(value, arguments): # This might not be necessary anymore in pytest 4/5, definitely needed # for pytest 3. if value.py__name__() == 'fixture' \ and value.parent_context.py__name__() == '_pytest.fixtures': return NO_VALUES return callback(value, arguments) return wrapper def infer_anonymous_param(func): def get_returns(value): if value.tree_node.annotation is not None: result = value.execute_with_values() if any(v.name.get_qualified_names(include_module_names=True) == ('typing', 'Generator') for v in result): return ValueSet.from_sets( v.py__getattribute__('__next__').execute_annotation() for v in result ) return result # In pytest we need to differentiate between generators and normal # returns. # Parameters still need to be anonymous, .as_context() ensures that. function_context = value.as_context() if function_context.is_generator(): return function_context.merge_yield_values() else: return function_context.get_return_values() def wrapper(param_name): # parameters with an annotation do not need special handling if param_name.annotation_node: return func(param_name) is_pytest_param, param_name_is_function_name = \ _is_a_pytest_param_and_inherited(param_name) if is_pytest_param: module = param_name.get_root_context() fixtures = _goto_pytest_fixture( module, param_name.string_name, # This skips the current module, because we are basically # inheriting a fixture from somewhere else. skip_own_module=param_name_is_function_name, ) if fixtures: return ValueSet.from_sets( get_returns(value) for fixture in fixtures for value in fixture.infer() ) return func(param_name) return wrapper def goto_anonymous_param(func): def wrapper(param_name): is_pytest_param, param_name_is_function_name = \ _is_a_pytest_param_and_inherited(param_name) if is_pytest_param: names = _goto_pytest_fixture( param_name.get_root_context(), param_name.string_name, skip_own_module=param_name_is_function_name, ) if names: return names return func(param_name) return wrapper def complete_param_names(func): def wrapper(context, func_name, decorator_nodes): module_context = context.get_root_context() if _is_pytest_func(func_name, decorator_nodes): names = [] for module_context in _iter_pytest_modules(module_context): names += FixtureFilter(module_context).values() if names: return names return func(context, func_name, decorator_nodes) return wrapper def _goto_pytest_fixture(module_context, name, skip_own_module): for module_context in _iter_pytest_modules(module_context, skip_own_module=skip_own_module): names = FixtureFilter(module_context).get(name) if names: return names def _is_a_pytest_param_and_inherited(param_name): """ Pytest params are either in a `test_*` function or have a pytest fixture with the decorator @pytest.fixture. This is a heuristic and will work in most cases. """ funcdef = search_ancestor(param_name.tree_name, 'funcdef') if funcdef is None: # A lambda return False, False decorators = funcdef.get_decorators() return _is_pytest_func(funcdef.name.value, decorators), \ funcdef.name.value == param_name.string_name def _is_pytest_func(func_name, decorator_nodes): return func_name.startswith('test') \ or any('fixture' in n.get_code() for n in decorator_nodes) def _find_pytest_plugin_modules() -> List[List[str]]: """ Finds pytest plugin modules hooked by setuptools entry points See https://docs.pytest.org/en/stable/how-to/writing_plugins.html#setuptools-entry-points """ if sys.version_info >= (3, 8): from importlib.metadata import entry_points if sys.version_info >= (3, 10): pytest_entry_points = entry_points(group="pytest11") else: pytest_entry_points = entry_points().get("pytest11", ()) if sys.version_info >= (3, 9): return [ep.module.split(".") for ep in pytest_entry_points] else: # Python 3.8 doesn't have `EntryPoint.module`. Implement equivalent # to what Python 3.9 does (with additional None check to placate `mypy`) matches = [ ep.pattern.match(ep.value) for ep in pytest_entry_points ] return [x.group('module').split(".") for x in matches if x] else: from pkg_resources import iter_entry_points return [ep.module_name.split(".") for ep in iter_entry_points(group="pytest11")] @inference_state_method_cache() def _iter_pytest_modules(module_context, skip_own_module=False): if not skip_own_module: yield module_context file_io = module_context.get_value().file_io if file_io is not None: folder = file_io.get_parent_folder() sys_path = module_context.inference_state.get_sys_path() # prevent an infinite loop when reaching the root of the current drive last_folder = None while any(folder.path.startswith(p) for p in sys_path): file_io = folder.get_file_io('conftest.py') if Path(file_io.path) != module_context.py__file__(): try: m = load_module_from_path(module_context.inference_state, file_io) yield m.as_context() except FileNotFoundError: pass folder = folder.get_parent_folder() # prevent an infinite for loop if the same parent folder is return twice if last_folder is not None and folder.path == last_folder.path: break last_folder = folder # keep track of the last found parent name for names in _PYTEST_FIXTURE_MODULES + _find_pytest_plugin_modules(): for module_value in module_context.inference_state.import_module(names): yield module_value.as_context() class FixtureFilter(ParserTreeFilter): def _filter(self, names): for name in super()._filter(names): # look for fixture definitions of imported names if name.parent.type == "import_from": imported_names = goto_import(self.parent_context, name) if any( self._is_fixture(iname.parent_context, iname.tree_name) for iname in imported_names # discard imports of whole modules, that have no tree_name if iname.tree_name ): yield name elif self._is_fixture(self.parent_context, name): yield name def _is_fixture(self, context, name): funcdef = name.parent # Class fixtures are not supported if funcdef.type != "funcdef": return False decorated = funcdef.parent if decorated.type != "decorated": return False decorators = decorated.children[0] if decorators.type == 'decorators': decorators = decorators.children else: decorators = [decorators] for decorator in decorators: dotted_name = decorator.children[1] # A heuristic, this makes it faster. if 'fixture' in dotted_name.get_code(): if dotted_name.type == 'atom_expr': # Since Python3.9 a decorator does not have dotted names # anymore. last_trailer = dotted_name.children[-1] last_leaf = last_trailer.get_last_leaf() if last_leaf == ')': values = infer_call_of_leaf( context, last_leaf, cut_own_trailer=True ) else: values = context.infer_node(dotted_name) else: values = context.infer_node(dotted_name) for value in values: if value.name.get_qualified_names(include_module_names=True) \ == ('_pytest', 'fixtures', 'fixture'): return True return False ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/jedi/plugins/registry.py0000664000175000017500000000046300000000000017221 0ustar00davedave00000000000000""" This is not a plugin, this is just the place were plugins are registered. """ from jedi.plugins import stdlib from jedi.plugins import flask from jedi.plugins import pytest from jedi.plugins import django from jedi.plugins import plugin_manager plugin_manager.register(stdlib, flask, pytest, django) ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/jedi/plugins/stdlib.py0000664000175000017500000007306600000000000016643 0ustar00davedave00000000000000""" Implementations of standard library functions, because it's not possible to understand them with Jedi. To add a new implementation, create a function and add it to the ``_implemented`` dict at the bottom of this module. Note that this module exists only to implement very specific functionality in the standard library. The usual way to understand the standard library is the compiled module that returns the types for C-builtins. """ import parso import os from inspect import Parameter from jedi import debug from jedi.inference.utils import safe_property from jedi.inference.helpers import get_str_or_none from jedi.inference.arguments import iterate_argument_clinic, ParamIssue, \ repack_with_argument_clinic, AbstractArguments, TreeArgumentsWrapper from jedi.inference import analysis from jedi.inference import compiled from jedi.inference.value.instance import \ AnonymousMethodExecutionContext, MethodExecutionContext from jedi.inference.base_value import ContextualizedNode, \ NO_VALUES, ValueSet, ValueWrapper, LazyValueWrapper from jedi.inference.value import ClassValue, ModuleValue from jedi.inference.value.klass import ClassMixin from jedi.inference.value.function import FunctionMixin from jedi.inference.value import iterable from jedi.inference.lazy_value import LazyTreeValue, LazyKnownValue, \ LazyKnownValues from jedi.inference.names import ValueName, BaseTreeParamName from jedi.inference.filters import AttributeOverwrite, publish_method, \ ParserTreeFilter, DictFilter from jedi.inference.signature import AbstractSignature, SignatureWrapper # Copied from Python 3.6's stdlib. _NAMEDTUPLE_CLASS_TEMPLATE = """\ _property = property _tuple = tuple from operator import itemgetter as _itemgetter from collections import OrderedDict class {typename}(tuple): __slots__ = () _fields = {field_names!r} def __new__(_cls, {arg_list}): 'Create new instance of {typename}({arg_list})' return _tuple.__new__(_cls, ({arg_list})) @classmethod def _make(cls, iterable, new=tuple.__new__, len=len): 'Make a new {typename} object from a sequence or iterable' result = new(cls, iterable) if len(result) != {num_fields:d}: raise TypeError('Expected {num_fields:d} arguments, got %d' % len(result)) return result def _replace(_self, **kwds): 'Return a new {typename} object replacing specified fields with new values' result = _self._make(map(kwds.pop, {field_names!r}, _self)) if kwds: raise ValueError('Got unexpected field names: %r' % list(kwds)) return result def __repr__(self): 'Return a nicely formatted representation string' return self.__class__.__name__ + '({repr_fmt})' % self def _asdict(self): 'Return a new OrderedDict which maps field names to their values.' return OrderedDict(zip(self._fields, self)) def __getnewargs__(self): 'Return self as a plain tuple. Used by copy and pickle.' return tuple(self) # These methods were added by Jedi. # __new__ doesn't really work with Jedi. So adding this to nametuples seems # like the easiest way. def __init__(self, {arg_list}): 'A helper function for namedtuple.' self.__iterable = ({arg_list}) def __iter__(self): for i in self.__iterable: yield i def __getitem__(self, y): return self.__iterable[y] {field_defs} """ _NAMEDTUPLE_FIELD_TEMPLATE = '''\ {name} = _property(_itemgetter({index:d}), doc='Alias for field number {index:d}') ''' def execute(callback): def wrapper(value, arguments): def call(): return callback(value, arguments=arguments) try: obj_name = value.name.string_name except AttributeError: pass else: p = value.parent_context if p is not None and p.is_builtins_module(): module_name = 'builtins' elif p is not None and p.is_module(): module_name = p.py__name__() else: return call() if value.is_bound_method() or value.is_instance(): # value can be an instance for example if it is a partial # object. return call() # for now we just support builtin functions. try: func = _implemented[module_name][obj_name] except KeyError: pass else: return func(value, arguments=arguments, callback=call) return call() return wrapper def _follow_param(inference_state, arguments, index): try: key, lazy_value = list(arguments.unpack())[index] except IndexError: return NO_VALUES else: return lazy_value.infer() def argument_clinic(clinic_string, want_value=False, want_context=False, want_arguments=False, want_inference_state=False, want_callback=False): """ Works like Argument Clinic (PEP 436), to validate function params. """ def f(func): def wrapper(value, arguments, callback): try: args = tuple(iterate_argument_clinic( value.inference_state, arguments, clinic_string)) except ParamIssue: return NO_VALUES debug.dbg('builtin start %s' % value, color='MAGENTA') kwargs = {} if want_context: kwargs['context'] = arguments.context if want_value: kwargs['value'] = value if want_inference_state: kwargs['inference_state'] = value.inference_state if want_arguments: kwargs['arguments'] = arguments if want_callback: kwargs['callback'] = callback result = func(*args, **kwargs) debug.dbg('builtin end: %s', result, color='MAGENTA') return result return wrapper return f @argument_clinic('iterator[, default], /', want_inference_state=True) def builtins_next(iterators, defaults, inference_state): # TODO theoretically we have to check here if something is an iterator. # That is probably done by checking if it's not a class. return defaults | iterators.py__getattribute__('__next__').execute_with_values() @argument_clinic('iterator[, default], /') def builtins_iter(iterators_or_callables, defaults): # TODO implement this if it's a callable. return iterators_or_callables.py__getattribute__('__iter__').execute_with_values() @argument_clinic('object, name[, default], /') def builtins_getattr(objects, names, defaults=None): # follow the first param for value in objects: for name in names: string = get_str_or_none(name) if string is None: debug.warning('getattr called without str') continue else: return value.py__getattribute__(string) return NO_VALUES @argument_clinic('object[, bases, dict], /') def builtins_type(objects, bases, dicts): if bases or dicts: # It's a type creation... maybe someday... return NO_VALUES else: return objects.py__class__() class SuperInstance(LazyValueWrapper): """To be used like the object ``super`` returns.""" def __init__(self, inference_state, instance): self.inference_state = inference_state self._instance = instance # Corresponds to super().__self__ def _get_bases(self): return self._instance.py__class__().py__bases__() def _get_wrapped_value(self): objs = self._get_bases()[0].infer().execute_with_values() if not objs: # This is just a fallback and will only be used, if it's not # possible to find a class return self._instance return next(iter(objs)) def get_filters(self, origin_scope=None): for b in self._get_bases(): for value in b.infer().execute_with_values(): for f in value.get_filters(): yield f @argument_clinic('[type[, value]], /', want_context=True) def builtins_super(types, objects, context): instance = None if isinstance(context, AnonymousMethodExecutionContext): instance = context.instance elif isinstance(context, MethodExecutionContext): instance = context.instance if instance is None: return NO_VALUES return ValueSet({SuperInstance(instance.inference_state, instance)}) class ReversedObject(AttributeOverwrite): def __init__(self, reversed_obj, iter_list): super().__init__(reversed_obj) self._iter_list = iter_list def py__iter__(self, contextualized_node=None): return self._iter_list @publish_method('__next__') def _next(self, arguments): return ValueSet.from_sets( lazy_value.infer() for lazy_value in self._iter_list ) @argument_clinic('sequence, /', want_value=True, want_arguments=True) def builtins_reversed(sequences, value, arguments): # While we could do without this variable (just by using sequences), we # want static analysis to work well. Therefore we need to generated the # values again. key, lazy_value = next(arguments.unpack()) cn = None if isinstance(lazy_value, LazyTreeValue): cn = ContextualizedNode(lazy_value.context, lazy_value.data) ordered = list(sequences.iterate(cn)) # Repack iterator values and then run it the normal way. This is # necessary, because `reversed` is a function and autocompletion # would fail in certain cases like `reversed(x).__iter__` if we # just returned the result directly. seq, = value.inference_state.typing_module.py__getattribute__('Iterator').execute_with_values() return ValueSet([ReversedObject(seq, list(reversed(ordered)))]) @argument_clinic('value, type, /', want_arguments=True, want_inference_state=True) def builtins_isinstance(objects, types, arguments, inference_state): bool_results = set() for o in objects: cls = o.py__class__() try: cls.py__bases__ except AttributeError: # This is temporary. Everything should have a class attribute in # Python?! Maybe we'll leave it here, because some numpy objects or # whatever might not. bool_results = set([True, False]) break mro = list(cls.py__mro__()) for cls_or_tup in types: if cls_or_tup.is_class(): bool_results.add(cls_or_tup in mro) elif cls_or_tup.name.string_name == 'tuple' \ and cls_or_tup.get_root_context().is_builtins_module(): # Check for tuples. classes = ValueSet.from_sets( lazy_value.infer() for lazy_value in cls_or_tup.iterate() ) bool_results.add(any(cls in mro for cls in classes)) else: _, lazy_value = list(arguments.unpack())[1] if isinstance(lazy_value, LazyTreeValue): node = lazy_value.data message = 'TypeError: isinstance() arg 2 must be a ' \ 'class, type, or tuple of classes and types, ' \ 'not %s.' % cls_or_tup analysis.add(lazy_value.context, 'type-error-isinstance', node, message) return ValueSet( compiled.builtin_from_name(inference_state, str(b)) for b in bool_results ) class StaticMethodObject(ValueWrapper): def py__get__(self, instance, class_value): return ValueSet([self._wrapped_value]) @argument_clinic('sequence, /') def builtins_staticmethod(functions): return ValueSet(StaticMethodObject(f) for f in functions) class ClassMethodObject(ValueWrapper): def __init__(self, class_method_obj, function): super().__init__(class_method_obj) self._function = function def py__get__(self, instance, class_value): return ValueSet([ ClassMethodGet(__get__, class_value, self._function) for __get__ in self._wrapped_value.py__getattribute__('__get__') ]) class ClassMethodGet(ValueWrapper): def __init__(self, get_method, klass, function): super().__init__(get_method) self._class = klass self._function = function def get_signatures(self): return [sig.bind(self._function) for sig in self._function.get_signatures()] def py__call__(self, arguments): return self._function.execute(ClassMethodArguments(self._class, arguments)) class ClassMethodArguments(TreeArgumentsWrapper): def __init__(self, klass, arguments): super().__init__(arguments) self._class = klass def unpack(self, func=None): yield None, LazyKnownValue(self._class) for values in self._wrapped_arguments.unpack(func): yield values @argument_clinic('sequence, /', want_value=True, want_arguments=True) def builtins_classmethod(functions, value, arguments): return ValueSet( ClassMethodObject(class_method_object, function) for class_method_object in value.py__call__(arguments=arguments) for function in functions ) class PropertyObject(AttributeOverwrite, ValueWrapper): api_type = 'property' def __init__(self, property_obj, function): super().__init__(property_obj) self._function = function def py__get__(self, instance, class_value): if instance is None: return ValueSet([self]) return self._function.execute_with_values(instance) @publish_method('deleter') @publish_method('getter') @publish_method('setter') def _return_self(self, arguments): return ValueSet({self}) @argument_clinic('func, /', want_callback=True) def builtins_property(functions, callback): return ValueSet( PropertyObject(property_value, function) for property_value in callback() for function in functions ) def collections_namedtuple(value, arguments, callback): """ Implementation of the namedtuple function. This has to be done by processing the namedtuple class template and inferring the result. """ inference_state = value.inference_state # Process arguments name = 'jedi_unknown_namedtuple' for c in _follow_param(inference_state, arguments, 0): x = get_str_or_none(c) if x is not None: name = x break # TODO here we only use one of the types, we should use all. param_values = _follow_param(inference_state, arguments, 1) if not param_values: return NO_VALUES _fields = list(param_values)[0] string = get_str_or_none(_fields) if string is not None: fields = string.replace(',', ' ').split() elif isinstance(_fields, iterable.Sequence): fields = [ get_str_or_none(v) for lazy_value in _fields.py__iter__() for v in lazy_value.infer() ] fields = [f for f in fields if f is not None] else: return NO_VALUES # Build source code code = _NAMEDTUPLE_CLASS_TEMPLATE.format( typename=name, field_names=tuple(fields), num_fields=len(fields), arg_list=repr(tuple(fields)).replace("'", "")[1:-1], repr_fmt='', field_defs='\n'.join(_NAMEDTUPLE_FIELD_TEMPLATE.format(index=index, name=name) for index, name in enumerate(fields)) ) # Parse source code module = inference_state.grammar.parse(code) generated_class = next(module.iter_classdefs()) parent_context = ModuleValue( inference_state, module, code_lines=parso.split_lines(code, keepends=True), ).as_context() return ValueSet([ClassValue(inference_state, parent_context, generated_class)]) class PartialObject(ValueWrapper): def __init__(self, actual_value, arguments, instance=None): super().__init__(actual_value) self._arguments = arguments self._instance = instance def _get_functions(self, unpacked_arguments): key, lazy_value = next(unpacked_arguments, (None, None)) if key is not None or lazy_value is None: debug.warning("Partial should have a proper function %s", self._arguments) return None return lazy_value.infer() def get_signatures(self): unpacked_arguments = self._arguments.unpack() funcs = self._get_functions(unpacked_arguments) if funcs is None: return [] arg_count = 0 if self._instance is not None: arg_count = 1 keys = set() for key, _ in unpacked_arguments: if key is None: arg_count += 1 else: keys.add(key) return [PartialSignature(s, arg_count, keys) for s in funcs.get_signatures()] def py__call__(self, arguments): funcs = self._get_functions(self._arguments.unpack()) if funcs is None: return NO_VALUES return funcs.execute( MergedPartialArguments(self._arguments, arguments, self._instance) ) def py__doc__(self): """ In CPython partial does not replace the docstring. However we are still imitating it here, because we want this docstring to be worth something for the user. """ callables = self._get_functions(self._arguments.unpack()) if callables is None: return '' for callable_ in callables: return callable_.py__doc__() return '' def py__get__(self, instance, class_value): return ValueSet([self]) class PartialMethodObject(PartialObject): def py__get__(self, instance, class_value): if instance is None: return ValueSet([self]) return ValueSet([PartialObject(self._wrapped_value, self._arguments, instance)]) class PartialSignature(SignatureWrapper): def __init__(self, wrapped_signature, skipped_arg_count, skipped_arg_set): super().__init__(wrapped_signature) self._skipped_arg_count = skipped_arg_count self._skipped_arg_set = skipped_arg_set def get_param_names(self, resolve_stars=False): names = self._wrapped_signature.get_param_names()[self._skipped_arg_count:] return [n for n in names if n.string_name not in self._skipped_arg_set] class MergedPartialArguments(AbstractArguments): def __init__(self, partial_arguments, call_arguments, instance=None): self._partial_arguments = partial_arguments self._call_arguments = call_arguments self._instance = instance def unpack(self, funcdef=None): unpacked = self._partial_arguments.unpack(funcdef) # Ignore this one, it's the function. It was checked before that it's # there. next(unpacked, None) if self._instance is not None: yield None, LazyKnownValue(self._instance) for key_lazy_value in unpacked: yield key_lazy_value for key_lazy_value in self._call_arguments.unpack(funcdef): yield key_lazy_value def functools_partial(value, arguments, callback): return ValueSet( PartialObject(instance, arguments) for instance in value.py__call__(arguments) ) def functools_partialmethod(value, arguments, callback): return ValueSet( PartialMethodObject(instance, arguments) for instance in value.py__call__(arguments) ) @argument_clinic('first, /') def _return_first_param(firsts): return firsts @argument_clinic('seq') def _random_choice(sequences): return ValueSet.from_sets( lazy_value.infer() for sequence in sequences for lazy_value in sequence.py__iter__() ) def _dataclass(value, arguments, callback): for c in _follow_param(value.inference_state, arguments, 0): if c.is_class(): return ValueSet([DataclassWrapper(c)]) else: return ValueSet([value]) return NO_VALUES class DataclassWrapper(ValueWrapper, ClassMixin): def get_signatures(self): param_names = [] for cls in reversed(list(self.py__mro__())): if isinstance(cls, DataclassWrapper): filter_ = cls.as_context().get_global_filter() # .values ordering is not guaranteed, at least not in # Python < 3.6, when dicts where not ordered, which is an # implementation detail anyway. for name in sorted(filter_.values(), key=lambda name: name.start_pos): d = name.tree_name.get_definition() annassign = d.children[1] if d.type == 'expr_stmt' and annassign.type == 'annassign': if len(annassign.children) < 4: default = None else: default = annassign.children[3] param_names.append(DataclassParamName( parent_context=cls.parent_context, tree_name=name.tree_name, annotation_node=annassign.children[1], default_node=default, )) return [DataclassSignature(cls, param_names)] class DataclassSignature(AbstractSignature): def __init__(self, value, param_names): super().__init__(value) self._param_names = param_names def get_param_names(self, resolve_stars=False): return self._param_names class DataclassParamName(BaseTreeParamName): def __init__(self, parent_context, tree_name, annotation_node, default_node): super().__init__(parent_context, tree_name) self.annotation_node = annotation_node self.default_node = default_node def get_kind(self): return Parameter.POSITIONAL_OR_KEYWORD def infer(self): if self.annotation_node is None: return NO_VALUES else: return self.parent_context.infer_node(self.annotation_node) class ItemGetterCallable(ValueWrapper): def __init__(self, instance, args_value_set): super().__init__(instance) self._args_value_set = args_value_set @repack_with_argument_clinic('item, /') def py__call__(self, item_value_set): value_set = NO_VALUES for args_value in self._args_value_set: lazy_values = list(args_value.py__iter__()) if len(lazy_values) == 1: # TODO we need to add the contextualized value. value_set |= item_value_set.get_item(lazy_values[0].infer(), None) else: value_set |= ValueSet([iterable.FakeList( self._wrapped_value.inference_state, [ LazyKnownValues(item_value_set.get_item(lazy_value.infer(), None)) for lazy_value in lazy_values ], )]) return value_set @argument_clinic('func, /') def _functools_wraps(funcs): return ValueSet(WrapsCallable(func) for func in funcs) class WrapsCallable(ValueWrapper): # XXX this is not the correct wrapped value, it should be a weird # partials object, but it doesn't matter, because it's always used as a # decorator anyway. @repack_with_argument_clinic('func, /') def py__call__(self, funcs): return ValueSet({Wrapped(func, self._wrapped_value) for func in funcs}) class Wrapped(ValueWrapper, FunctionMixin): def __init__(self, func, original_function): super().__init__(func) self._original_function = original_function @property def name(self): return self._original_function.name def get_signature_functions(self): return [self] @argument_clinic('*args, /', want_value=True, want_arguments=True) def _operator_itemgetter(args_value_set, value, arguments): return ValueSet([ ItemGetterCallable(instance, args_value_set) for instance in value.py__call__(arguments) ]) def _create_string_input_function(func): @argument_clinic('string, /', want_value=True, want_arguments=True) def wrapper(strings, value, arguments): def iterate(): for value in strings: s = get_str_or_none(value) if s is not None: s = func(s) yield compiled.create_simple_object(value.inference_state, s) values = ValueSet(iterate()) if values: return values return value.py__call__(arguments) return wrapper @argument_clinic('*args, /', want_callback=True) def _os_path_join(args_set, callback): if len(args_set) == 1: string = '' sequence, = args_set is_first = True for lazy_value in sequence.py__iter__(): string_values = lazy_value.infer() if len(string_values) != 1: break s = get_str_or_none(next(iter(string_values))) if s is None: break if not is_first: string += os.path.sep string += s is_first = False else: return ValueSet([compiled.create_simple_object(sequence.inference_state, string)]) return callback() _implemented = { 'builtins': { 'getattr': builtins_getattr, 'type': builtins_type, 'super': builtins_super, 'reversed': builtins_reversed, 'isinstance': builtins_isinstance, 'next': builtins_next, 'iter': builtins_iter, 'staticmethod': builtins_staticmethod, 'classmethod': builtins_classmethod, 'property': builtins_property, }, 'copy': { 'copy': _return_first_param, 'deepcopy': _return_first_param, }, 'json': { 'load': lambda value, arguments, callback: NO_VALUES, 'loads': lambda value, arguments, callback: NO_VALUES, }, 'collections': { 'namedtuple': collections_namedtuple, }, 'functools': { 'partial': functools_partial, 'partialmethod': functools_partialmethod, 'wraps': _functools_wraps, }, '_weakref': { 'proxy': _return_first_param, }, 'random': { 'choice': _random_choice, }, 'operator': { 'itemgetter': _operator_itemgetter, }, 'abc': { # Not sure if this is necessary, but it's used a lot in typeshed and # it's for now easier to just pass the function. 'abstractmethod': _return_first_param, }, 'typing': { # The _alias function just leads to some annoying type inference. # Therefore, just make it return nothing, which leads to the stubs # being used instead. This only matters for 3.7+. '_alias': lambda value, arguments, callback: NO_VALUES, # runtime_checkable doesn't really change anything and is just # adding logs for infering stuff, so we can safely ignore it. 'runtime_checkable': lambda value, arguments, callback: NO_VALUES, }, 'dataclasses': { # For now this works at least better than Jedi trying to understand it. 'dataclass': _dataclass }, # attrs exposes declaration interface roughly compatible with dataclasses # via attrs.define, attrs.frozen and attrs.mutable # https://www.attrs.org/en/stable/names.html 'attr': { 'define': _dataclass, 'frozen': _dataclass, }, 'attrs': { 'define': _dataclass, 'frozen': _dataclass, }, 'os.path': { 'dirname': _create_string_input_function(os.path.dirname), 'abspath': _create_string_input_function(os.path.abspath), 'relpath': _create_string_input_function(os.path.relpath), 'join': _os_path_join, } } def get_metaclass_filters(func): def wrapper(cls, metaclasses, is_instance): for metaclass in metaclasses: if metaclass.py__name__() == 'EnumMeta' \ and metaclass.get_root_context().py__name__() == 'enum': filter_ = ParserTreeFilter(parent_context=cls.as_context()) return [DictFilter({ name.string_name: EnumInstance(cls, name).name for name in filter_.values() })] return func(cls, metaclasses, is_instance) return wrapper class EnumInstance(LazyValueWrapper): def __init__(self, cls, name): self.inference_state = cls.inference_state self._cls = cls # Corresponds to super().__self__ self._name = name self.tree_node = self._name.tree_name @safe_property def name(self): return ValueName(self, self._name.tree_name) def _get_wrapped_value(self): n = self._name.string_name if n.startswith('__') and n.endswith('__') or self._name.api_type == 'function': inferred = self._name.infer() if inferred: return next(iter(inferred)) o, = self.inference_state.builtins_module.py__getattribute__('object') return o value, = self._cls.execute_with_values() return value def get_filters(self, origin_scope=None): yield DictFilter(dict( name=compiled.create_simple_object(self.inference_state, self._name.string_name).name, value=self._name, )) for f in self._get_wrapped_value().get_filters(): yield f def tree_name_to_values(func): def wrapper(inference_state, context, tree_name): if tree_name.value == 'sep' and context.is_module() and context.py__name__() == 'os.path': return ValueSet({ compiled.create_simple_object(inference_state, os.path.sep), }) return func(inference_state, context, tree_name) return wrapper ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/jedi/settings.py0000664000175000017500000000736300000000000015536 0ustar00davedave00000000000000""" This module contains variables with global |jedi| settings. To change the behavior of |jedi|, change the variables defined in :mod:`jedi.settings`. Plugins should expose an interface so that the user can adjust the configuration. Example usage:: from jedi import settings settings.case_insensitive_completion = True Completion output ~~~~~~~~~~~~~~~~~ .. autodata:: case_insensitive_completion .. autodata:: add_bracket_after_function Filesystem cache ~~~~~~~~~~~~~~~~ .. autodata:: cache_directory Parser ~~~~~~ .. autodata:: fast_parser Dynamic stuff ~~~~~~~~~~~~~ .. autodata:: dynamic_array_additions .. autodata:: dynamic_params .. autodata:: dynamic_params_for_other_modules .. autodata:: auto_import_modules Caching ~~~~~~~ .. autodata:: call_signatures_validity """ import os import platform # ---------------- # Completion Output Settings # ---------------- case_insensitive_completion = True """ Completions are by default case insensitive. """ add_bracket_after_function = False """ Adds an opening bracket after a function for completions. """ # ---------------- # Filesystem Cache # ---------------- if platform.system().lower() == 'windows': _cache_directory = os.path.join( os.getenv('LOCALAPPDATA') or os.path.expanduser('~'), 'Jedi', 'Jedi', ) elif platform.system().lower() == 'darwin': _cache_directory = os.path.join('~', 'Library', 'Caches', 'Jedi') else: _cache_directory = os.path.join(os.getenv('XDG_CACHE_HOME') or '~/.cache', 'jedi') cache_directory = os.path.expanduser(_cache_directory) """ The path where the cache is stored. On Linux, this defaults to ``~/.cache/jedi/``, on OS X to ``~/Library/Caches/Jedi/`` and on Windows to ``%LOCALAPPDATA%\\Jedi\\Jedi\\``. On Linux, if the environment variable ``$XDG_CACHE_HOME`` is set, ``$XDG_CACHE_HOME/jedi`` is used instead of the default one. """ # ---------------- # Parser # ---------------- fast_parser = True """ Uses Parso's diff parser. If it is enabled, this might cause issues, please read the warning on :class:`.Script`. This feature makes it possible to only parse the parts again that have changed, while reusing the rest of the syntax tree. """ _cropped_file_size = int(10e6) # 1 Megabyte """ Jedi gets extremely slow if the file size exceed a few thousand lines. To avoid getting stuck completely Jedi crops the file at some point. One megabyte of typical Python code equals about 20'000 lines of code. """ # ---------------- # Dynamic Stuff # ---------------- dynamic_array_additions = True """ check for `append`, etc. on arrays: [], {}, () as well as list/set calls. """ dynamic_params = True """ A dynamic param completion, finds the callees of the function, which define the params of a function. """ dynamic_params_for_other_modules = True """ Do the same for other modules. """ dynamic_flow_information = True """ Check for `isinstance` and other information to infer a type. """ auto_import_modules = [ 'gi', # This third-party repository (GTK stuff) doesn't really work with jedi ] """ Modules that will not be analyzed but imported, if they contain Python code. This improves autocompletion for libraries that use ``setattr`` or ``globals()`` modifications a lot. """ allow_unsafe_interpreter_executions = True """ Controls whether descriptors are evaluated when using an Interpreter. This is something you might want to control when using Jedi from a Repl (e.g. IPython) Generally this setting allows Jedi to execute __getitem__ and descriptors like `property`. """ # ---------------- # Caching Validity # ---------------- call_signatures_validity = 3.0 """ Finding function calls might be slow (0.1-0.5s). This is not acceptible for normal writing. Therefore cache it for a short time. """ ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.3823793 jedi-0.19.1/jedi/third_party/0000775000175000017500000000000000000000000015644 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.3903792 jedi-0.19.1/jedi/third_party/django-stubs/0000775000175000017500000000000000000000000020244 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/LICENSE.txt0000664000175000017500000000206300000000000022070 0ustar00davedave00000000000000Copyright (c) Maxim Kurnikov. All rights reserved. Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.3903792 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/0000775000175000017500000000000000000000000022644 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/__init__.pyi0000664000175000017500000000066000000000000025130 0ustar00davedave00000000000000from typing import Any, NamedTuple from .utils.version import get_version as get_version VERSION: Any __version__: str def setup(set_prefix: bool = ...) -> None: ... # Used by mypy_django_plugin when returning a QuerySet row that is a NamedTuple where the field names are unknown class _NamedTupleAnyAttr(NamedTuple): def __getattr__(self, item: str) -> Any: ... def __setattr__(self, item: str, value: Any) -> None: ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.3903792 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/apps/0000775000175000017500000000000000000000000023607 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/apps/__init__.pyi0000664000175000017500000000011700000000000026070 0ustar00davedave00000000000000from .config import AppConfig as AppConfig from .registry import apps as apps ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/apps/config.pyi0000664000175000017500000000150200000000000025575 0ustar00davedave00000000000000from typing import Any, Iterator, Type, Optional, Dict from django.apps.registry import Apps from django.db.models.base import Model MODELS_MODULE_NAME: str class AppConfig: name: str = ... module: Optional[Any] = ... apps: Optional[Apps] = ... label: str = ... verbose_name: str = ... path: str = ... models_module: Optional[str] = ... models: Dict[str, Type[Model]] = ... def __init__(self, app_name: str, app_module: Optional[Any]) -> None: ... @classmethod def create(cls, entry: str) -> AppConfig: ... def get_model(self, model_name: str, require_ready: bool = ...) -> Type[Model]: ... def get_models(self, include_auto_created: bool = ..., include_swapped: bool = ...) -> Iterator[Type[Model]]: ... def import_models(self) -> None: ... def ready(self) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/apps/registry.pyi0000664000175000017500000000400200000000000026176 0ustar00davedave00000000000000import threading from typing import Any, Callable, Dict, Iterable, List, Optional, Tuple, Type, Union from django.db.models.base import Model from .config import AppConfig class Apps: all_models: Dict[str, Dict[str, Type[Model]]] = ... app_configs: Dict[str, AppConfig] = ... stored_app_configs: List[Any] = ... apps_ready: bool = ... ready_event: threading.Event = ... loading: bool = ... _pending_operations: Dict[Tuple[str, str], List] models_ready: bool = ... ready: bool = ... def __init__(self, installed_apps: Optional[Iterable[Union[AppConfig, str]]] = ...) -> None: ... def populate(self, installed_apps: Iterable[Union[AppConfig, str]] = ...) -> None: ... def check_apps_ready(self) -> None: ... def check_models_ready(self) -> None: ... def get_app_configs(self) -> Iterable[AppConfig]: ... def get_app_config(self, app_label: str) -> AppConfig: ... # it's not possible to support it in plugin properly now def get_models(self, include_auto_created: bool = ..., include_swapped: bool = ...) -> List[Type[Model]]: ... def get_model(self, app_label: str, model_name: Optional[str] = ..., require_ready: bool = ...) -> Type[Any]: ... def register_model(self, app_label: str, model: Type[Model]) -> None: ... def is_installed(self, app_name: str) -> bool: ... def get_containing_app_config(self, object_name: str) -> Optional[AppConfig]: ... def get_registered_model(self, app_label: str, model_name: str) -> Type[Model]: ... def get_swappable_settings_name(self, to_string: str) -> Optional[str]: ... def set_available_apps(self, available: Iterable[str]) -> None: ... def unset_available_apps(self) -> None: ... def set_installed_apps(self, installed: Iterable[str]) -> None: ... def unset_installed_apps(self) -> None: ... def clear_cache(self) -> None: ... def lazy_model_operation(self, function: Callable, *model_keys: Any) -> None: ... def do_pending_operations(self, model: Type[Model]) -> None: ... apps: Apps ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.3903792 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/conf/0000775000175000017500000000000000000000000023571 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/conf/__init__.pyi0000664000175000017500000000160300000000000026053 0ustar00davedave00000000000000from typing import Any from django.utils.functional import LazyObject # explicit dependency on standard settings to make it loaded from . import global_settings ENVIRONMENT_VARIABLE: str = ... DEFAULT_CONTENT_TYPE_DEPRECATED_MSG: str = ... FILE_CHARSET_DEPRECATED_MSG: str = ... # required for plugin to be able to distinguish this specific instance of LazySettings from others class _DjangoConfLazyObject(LazyObject): def __getattr__(self, item: Any) -> Any: ... class LazySettings(_DjangoConfLazyObject): configured: bool def configure(self, default_settings: Any = ..., **options: Any) -> Any: ... settings: LazySettings = ... class Settings: def __init__(self, settings_module: str): ... def is_overridden(self, setting: str) -> bool: ... class UserSettingsHolder: ... class SettingsReference(str): def __init__(self, value: str, setting_name: str) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/conf/global_settings.pyi0000664000175000017500000004206600000000000027504 0ustar00davedave00000000000000""" Default Django settings. Override these with settings in the module pointed to by the DJANGO_SETTINGS_MODULE environment variable. """ # This is defined here as a do-nothing function because we can't import # django.utils.translation -- that module depends on the settings. from typing import Any, Dict, List, Optional, Pattern, Protocol, Sequence, Tuple, Union #################### # CORE # #################### DEBUG: bool = ... # Whether the framework should propagate raw exceptions rather than catching # them. This is useful under some testing situations and should never be used # on a live site. DEBUG_PROPAGATE_EXCEPTIONS: bool = ... # People who get code error notifications. # In the format [('Full Name', 'email@example.com'), ('Full Name', 'anotheremail@example.com')] ADMINS: List[Tuple[str, str]] = ... # List of IP addresses, as strings, that: # * See debug comments, when DEBUG is true # * Receive x-headers INTERNAL_IPS: List[str] = ... # Hosts/domain names that are valid for this site. # "*" matches anything, ".example.com" matches example.com and all subdomains ALLOWED_HOSTS: List[str] = ... # Local time zone for this installation. All choices can be found here: # https://en.wikipedia.org/wiki/List_of_tz_zones_by_name (although not all # systems may support all possibilities). When USE_TZ is True, this is # interpreted as the default user time zone. TIME_ZONE: str = ... # If you set this to True, Django will use timezone-aware datetimes. USE_TZ: bool = ... # Language code for this installation. All choices can be found here: # http://www.i18nguy.com/unicode/language-identifiers.html LANGUAGE_CODE: str = ... # Languages we provide translations for, out of the box. LANGUAGES: List[Tuple[str, str]] = ... # Languages using BiDi (right-to-left) layout LANGUAGES_BIDI: List[str] = ... # If you set this to False, Django will make some optimizations so as not # to load the internationalization machinery. USE_I18N: bool = ... LOCALE_PATHS: List[str] = ... # Settings for language cookie LANGUAGE_COOKIE_NAME: str = ... LANGUAGE_COOKIE_AGE: Optional[int] = ... LANGUAGE_COOKIE_DOMAIN: Optional[str] = ... LANGUAGE_COOKIE_PATH: str = ... # If you set this to True, Django will format dates, numbers and calendars # according to user current locale. USE_L10N: bool = ... # Not-necessarily-technical managers of the site. They get broken link # notifications and other various emails. MANAGERS = ADMINS # Default content type and charset to use for all HttpResponse objects, if a # MIME type isn't manually specified. These are used to construct the # Content-Type header. DEFAULT_CONTENT_TYPE: str = ... DEFAULT_CHARSET: str = ... # Encoding of files read from disk (template and initial SQL files). FILE_CHARSET: str = ... # Email address that error messages come from. SERVER_EMAIL: str = ... # Database connection info. If left empty, will default to the dummy backend. DATABASES: Dict[str, Dict[str, Any]] = ... # Classes used to implement DB routing behavior. class Router(Protocol): def allow_migrate(self, db, app_label, **hints): ... DATABASE_ROUTERS: List[Union[str, Router]] = ... # The email backend to use. For possible shortcuts see django.core.mail. # The default is to use the SMTP backend. # Third-party backends can be specified by providing a Python path # to a module that defines an EmailBackend class. EMAIL_BACKEND: str = ... # Host for sending email. EMAIL_HOST: str = ... # Port for sending email. EMAIL_PORT: int = ... # Whether to send SMTP 'Date' header in the local time zone or in UTC. EMAIL_USE_LOCALTIME: bool = ... # Optional SMTP authentication information for EMAIL_HOST. EMAIL_HOST_USER: str = ... EMAIL_HOST_PASSWORD: str = ... EMAIL_USE_TLS: bool = ... EMAIL_USE_SSL: bool = ... EMAIL_SSL_CERTFILE: Optional[str] = ... EMAIL_SSL_KEYFILE: Optional[str] = ... EMAIL_TIMEOUT: Optional[int] = ... # List of strings representing installed apps. INSTALLED_APPS: List[str] = ... TEMPLATES: List[Dict[str, Any]] = ... # Default form rendering class. FORM_RENDERER: str = ... # Default email address to use for various automated correspondence from # the site managers. DEFAULT_FROM_EMAIL: str = ... # Subject-line prefix for email messages send with django.core.mail.mail_admins # or ...mail_managers. Make sure to include the trailing space. EMAIL_SUBJECT_PREFIX: str = ... # Whether to append trailing slashes to URLs. APPEND_SLASH: bool = ... # Whether to prepend the "www." subdomain to URLs that don't have it. PREPEND_WWW: bool = ... # Override the server-derived value of SCRIPT_NAME FORCE_SCRIPT_NAME = None # List of compiled regular expression objects representing User-Agent strings # that are not allowed to visit any page, systemwide. Use this for bad # robots/crawlers. Here are a few examples: # import re # DISALLOWED_USER_AGENTS = [ # re.compile(r'^NaverBot.*'), # re.compile(r'^EmailSiphon.*'), # re.compile(r'^SiteSucker.*'), # re.compile(r'^sohu-search'), # ] DISALLOWED_USER_AGENTS: List[Pattern] = ... ABSOLUTE_URL_OVERRIDES: Dict[str, Any] = ... # List of compiled regular expression objects representing URLs that need not # be reported by BrokenLinkEmailsMiddleware. Here are a few examples: # import re # IGNORABLE_404_URLS = [ # re.compile(r'^/apple-touch-icon.*\.png$'), # re.compile(r'^/favicon.ico$'), # re.compile(r'^/robots.txt$'), # re.compile(r'^/phpmyadmin/'), # re.compile(r'\.(cgi|php|pl)$'), # ] IGNORABLE_404_URLS: List[Pattern] = ... # A secret key for this particular Django installation. Used in secret-key # hashing algorithms. Set this in your settings, or Django will complain # loudly. SECRET_KEY: str = ... # Default file storage mechanism that holds media. DEFAULT_FILE_STORAGE: str = ... # Absolute filesystem path to the directory that will hold user-uploaded files. # Example: "/var/www/example.com/media/" MEDIA_ROOT: str = ... # URL that handles the media served from MEDIA_ROOT. # Examples: "http://example.com/media/", "http://media.example.com/" MEDIA_URL: str = ... # Absolute path to the directory static files should be collected to. # Example: "/var/www/example.com/static/" STATIC_ROOT: Optional[str] = ... # URL that handles the static files served from STATIC_ROOT. # Example: "http://example.com/static/", "http://static.example.com/" STATIC_URL: Optional[str] = ... # List of upload handler classes to be applied in order. FILE_UPLOAD_HANDLERS: List[str] = ... # Maximum size, in bytes, of a request before it will be streamed to the # file system instead of into memory. FILE_UPLOAD_MAX_MEMORY_SIZE: int = ... # i.e. 2.5 MB # Maximum size in bytes of request data (excluding file uploads) that will be # read before a SuspiciousOperation (RequestDataTooBig) is raised. DATA_UPLOAD_MAX_MEMORY_SIZE: int = ... # i.e. 2.5 MB # Maximum number of GET/POST parameters that will be read before a # SuspiciousOperation (TooManyFieldsSent) is raised. DATA_UPLOAD_MAX_NUMBER_FIELDS: int = ... # Directory in which upload streamed files will be temporarily saved. A value of # `None` will make Django use the operating system's default temporary directory # (i.e. "/tmp" on *nix systems). FILE_UPLOAD_TEMP_DIR: Optional[str] = ... # The numeric mode to set newly-uploaded files to. The value should be a mode # you'd pass directly to os.chmod; see https://docs.python.org/library/os.html#files-and-directories. FILE_UPLOAD_PERMISSIONS = None # The numeric mode to assign to newly-created directories, when uploading files. # The value should be a mode as you'd pass to os.chmod; # see https://docs.python.org/library/os.html#files-and-directories. FILE_UPLOAD_DIRECTORY_PERMISSIONS = None # Python module path where user will place custom format definition. # The directory where this setting is pointing should contain subdirectories # named as the locales, containing a formats.py file # (i.e. "myproject.locale" for myproject/locale/en/formats.py etc. use) FORMAT_MODULE_PATH: Optional[str] = ... # Default formatting for date objects. See all available format strings here: # https://docs.djangoproject.com/en/dev/ref/templates/builtins/#date DATE_FORMAT: str = ... # Default formatting for datetime objects. See all available format strings here: # https://docs.djangoproject.com/en/dev/ref/templates/builtins/#date DATETIME_FORMAT: str = ... # Default formatting for time objects. See all available format strings here: # https://docs.djangoproject.com/en/dev/ref/templates/builtins/#date TIME_FORMAT: str = ... # Default formatting for date objects when only the year and month are relevant. # See all available format strings here: # https://docs.djangoproject.com/en/dev/ref/templates/builtins/#date YEAR_MONTH_FORMAT: str = ... # Default formatting for date objects when only the month and day are relevant. # See all available format strings here: # https://docs.djangoproject.com/en/dev/ref/templates/builtins/#date MONTH_DAY_FORMAT: str = ... # Default short formatting for date objects. See all available format strings here: # https://docs.djangoproject.com/en/dev/ref/templates/builtins/#date SHORT_DATE_FORMAT: str = ... # Default short formatting for datetime objects. # See all available format strings here: # https://docs.djangoproject.com/en/dev/ref/templates/builtins/#date SHORT_DATETIME_FORMAT: str = ... # Default formats to be used when parsing dates from input boxes, in order # See all available format string here: # https://docs.python.org/library/datetime.html#strftime-behavior # * Note that these format strings are different from the ones to display dates DATE_INPUT_FORMATS: List[str] = ... # Default formats to be used when parsing times from input boxes, in order # See all available format string here: # https://docs.python.org/library/datetime.html#strftime-behavior # * Note that these format strings are different from the ones to display dates TIME_INPUT_FORMATS: List[str] = ... # '14:30:59' # '14:30:59.000200' # '14:30' # Default formats to be used when parsing dates and times from input boxes, # in order # See all available format string here: # https://docs.python.org/library/datetime.html#strftime-behavior # * Note that these format strings are different from the ones to display dates DATETIME_INPUT_FORMATS: List[str] = ... # First day of week, to be used on calendars # 0 means Sunday, 1 means Monday... FIRST_DAY_OF_WEEK: int = ... # Decimal separator symbol DECIMAL_SEPARATOR: str = ... # Boolean that sets whether to add thousand separator when formatting numbers USE_THOUSAND_SEPARATOR: bool = ... # Number of digits that will be together, when splitting them by # THOUSAND_SEPARATOR. 0 means no grouping, 3 means splitting by thousands... NUMBER_GROUPING: int = ... # Thousand separator symbol THOUSAND_SEPARATOR: str = ... # The tablespaces to use for each model when not specified otherwise. DEFAULT_TABLESPACE: str = ... DEFAULT_INDEX_TABLESPACE: str = ... # Default X-Frame-Options header value X_FRAME_OPTIONS: str = ... USE_X_FORWARDED_HOST: bool = ... USE_X_FORWARDED_PORT: bool = ... # The Python dotted path to the WSGI application that Django's internal server # (runserver) will use. If `None`, the return value of # 'django.core.wsgi.get_wsgi_application' is used, thus preserving the same # behavior as previous versions of Django. Otherwise this should point to an # actual WSGI application object. WSGI_APPLICATION: Optional[str] = ... # If your Django app is behind a proxy that sets a header to specify secure # connections, AND that proxy ensures that user-submitted headers with the # same name are ignored (so that people can't spoof it), set this value to # a tuple of (header_name, header_value). For any requests that come in with # that header/value, request.is_secure() will return True. # WARNING! Only set this if you fully understand what you're doing. Otherwise, # you may be opening yourself up to a security risk. SECURE_PROXY_SSL_HEADER: Optional[Tuple[str, str]] = ... ############## # MIDDLEWARE # ############## # List of middleware to use. Order is important; in the request phase, these # middleware will be applied in the order given, and in the response # phase the middleware will be applied in reverse order. MIDDLEWARE: List[str] = ... ############ # SESSIONS # ############ # Cache to store session data if using the cache session backend. SESSION_CACHE_ALIAS = "default" # Cookie name. This can be whatever you want. SESSION_COOKIE_NAME = "sessionid" # Age of cookie, in seconds (default: 2 weeks). SESSION_COOKIE_AGE = 60 * 60 * 24 * 7 * 2 # A string like "example.com", or None for standard domain cookie. SESSION_COOKIE_DOMAIN: Optional[str] = ... # Whether the session cookie should be secure (https:// only). SESSION_COOKIE_SECURE = False # The path of the session cookie. SESSION_COOKIE_PATH = "/" # Whether to use the non-RFC standard httpOnly flag (IE, FF3+, others) SESSION_COOKIE_HTTPONLY = True # Whether to set the flag restricting cookie leaks on cross-site requests. # This can be 'Lax', 'Strict', or None to disable the flag. SESSION_COOKIE_SAMESITE: Optional[str] = ... # Whether to save the session data on every request. SESSION_SAVE_EVERY_REQUEST = False # Whether a user's session cookie expires when the Web browser is closed. SESSION_EXPIRE_AT_BROWSER_CLOSE = False # The module to store session data SESSION_ENGINE = "django.contrib.sessions.backends.db" # Directory to store session files if using the file session module. If None, # the backend will use a sensible default. SESSION_FILE_PATH: Optional[str] = ... # class to serialize session data SESSION_SERIALIZER = "django.contrib.sessions.serializers.JSONSerializer" ######### # CACHE # ######### # The cache backends to use. CACHES: Dict[str, Dict[str, Any]] = ... CACHE_MIDDLEWARE_KEY_PREFIX = "" CACHE_MIDDLEWARE_SECONDS = 600 CACHE_MIDDLEWARE_ALIAS = "default" ################## # AUTHENTICATION # ################## AUTH_USER_MODEL: str = ... AUTHENTICATION_BACKENDS: Sequence[str] = ... LOGIN_URL = "/accounts/login/" LOGIN_REDIRECT_URL: str = ... LOGOUT_REDIRECT_URL: Optional[str] = ... # The number of days a password reset link is valid for PASSWORD_RESET_TIMEOUT_DAYS = 3 # the first hasher in this list is the preferred algorithm. any # password using different algorithms will be converted automatically # upon login PASSWORD_HASHERS: List[str] = ... AUTH_PASSWORD_VALIDATORS: List[Dict[str, str]] = ... ########### # SIGNING # ########### SIGNING_BACKEND = "django.core.signing.TimestampSigner" ######## # CSRF # ######## # Dotted path to callable to be used as view when a request is # rejected by the CSRF middleware. CSRF_FAILURE_VIEW = "django.views.csrf.csrf_failure" # Settings for CSRF cookie. CSRF_COOKIE_NAME = "csrftoken" CSRF_COOKIE_AGE = 60 * 60 * 24 * 7 * 52 CSRF_COOKIE_DOMAIN = None CSRF_COOKIE_PATH = "/" CSRF_COOKIE_SECURE = False CSRF_COOKIE_HTTPONLY = False CSRF_COOKIE_SAMESITE: Optional[str] = ... CSRF_HEADER_NAME = "HTTP_X_CSRFTOKEN" CSRF_TRUSTED_ORIGINS: List[str] = ... CSRF_USE_SESSIONS = False ############ # MESSAGES # ############ # Class to use as messages backend MESSAGE_STORAGE = "django.contrib.messages.storage.fallback.FallbackStorage" # Default values of MESSAGE_LEVEL and MESSAGE_TAGS are defined within # django.contrib.messages to avoid imports in this settings file. ########### # LOGGING # ########### # The callable to use to configure logging LOGGING_CONFIG = "logging.config.dictConfig" # Custom logging configuration. LOGGING: Dict[str, Any] = ... # Default exception reporter filter class used in case none has been # specifically assigned to the HttpRequest instance. DEFAULT_EXCEPTION_REPORTER_FILTER = "django.views.debug.SafeExceptionReporterFilter" ########### # TESTING # ########### # The name of the class to use to run the test suite TEST_RUNNER = "django.test.runner.DiscoverRunner" # Apps that don't need to be serialized at test database creation time # (only apps with migrations are to start with) TEST_NON_SERIALIZED_APPS: List[str] = ... ############ # FIXTURES # ############ # The list of directories to search for fixtures FIXTURE_DIRS: List[str] = ... ############### # STATICFILES # ############### # A list of locations of additional static files STATICFILES_DIRS: List[str] = ... # The default file storage backend used during the build process STATICFILES_STORAGE: str = ... # List of finder classes that know how to find static files in # various locations. STATICFILES_FINDERS: List[str] = ... ############## # MIGRATIONS # ############## # Migration module overrides for apps, by app label. MIGRATION_MODULES: Dict[str, str] = ... ################# # SYSTEM CHECKS # ################# # List of all issues generated by system checks that should be silenced. Light # issues like warnings, infos or debugs will not generate a message. Silencing # serious issues like errors and criticals does not result in hiding the # message, but Django will not stop you from e.g. running server. SILENCED_SYSTEM_CHECKS: List[str] = ... ####################### # SECURITY MIDDLEWARE # ####################### SECURE_BROWSER_XSS_FILTER = False SECURE_CONTENT_TYPE_NOSNIFF = False SECURE_HSTS_INCLUDE_SUBDOMAINS = False SECURE_HSTS_PRELOAD = False SECURE_HSTS_SECONDS = 0 SECURE_REDIRECT_EXEMPT: List[str] = ... SECURE_SSL_HOST = None SECURE_SSL_REDIRECT = False ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.3903792 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/conf/locale/0000775000175000017500000000000000000000000025030 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/conf/locale/__init__.pyi0000664000175000017500000000007600000000000027315 0ustar00davedave00000000000000from typing import Dict, Any LANG_INFO: Dict[str, Any] = ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.3903792 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/conf/urls/0000775000175000017500000000000000000000000024556 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/conf/urls/__init__.pyi0000664000175000017500000000201100000000000027032 0ustar00davedave00000000000000# Stubs for django.conf.urls (Python 3.5) from typing import Any, Callable, Dict, List, Optional, overload, Tuple, Union from django.http.response import HttpResponse, HttpResponseBase from django.urls import URLResolver, URLPattern handler400: Union[str, Callable[..., HttpResponse]] = ... handler403: Union[str, Callable[..., HttpResponse]] = ... handler404: Union[str, Callable[..., HttpResponse]] = ... handler500: Union[str, Callable[..., HttpResponse]] = ... IncludedURLConf = Tuple[List[URLResolver], Optional[str], Optional[str]] def include(arg: Any, namespace: str = ..., app_name: str = ...) -> IncludedURLConf: ... @overload def url( regex: str, view: Callable[..., HttpResponseBase], kwargs: Dict[str, Any] = ..., name: str = ... ) -> URLPattern: ... @overload def url(regex: str, view: IncludedURLConf, kwargs: Dict[str, Any] = ..., name: str = ...) -> URLResolver: ... @overload def url( regex: str, view: List[Union[URLResolver, str]], kwargs: Dict[str, Any] = ..., name: str = ... ) -> URLResolver: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/conf/urls/i18n.pyi0000664000175000017500000000045100000000000026060 0ustar00davedave00000000000000from typing import Any, List, Tuple, Callable from django.urls.resolvers import URLPattern def i18n_patterns(*urls: Any, prefix_default_language: bool = ...) -> List[List[URLPattern]]: ... def is_language_prefix_patterns_used(urlconf: str) -> Tuple[bool, bool]: ... urlpatterns: List[Callable] ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/conf/urls/static.pyi0000664000175000017500000000025400000000000026571 0ustar00davedave00000000000000from typing import Any, Callable, List from django.urls.resolvers import URLPattern def static(prefix: str, view: Callable = ..., **kwargs: Any) -> List[URLPattern]: ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.3903792 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/0000775000175000017500000000000000000000000024304 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/__init__.pyi0000664000175000017500000000000000000000000026554 0ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.3943791 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/admin/0000775000175000017500000000000000000000000025374 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/admin/__init__.pyi0000664000175000017500000000156100000000000027661 0ustar00davedave00000000000000from .decorators import register as register from .filters import ( AllValuesFieldListFilter as AllValuesFieldListFilter, BooleanFieldListFilter as BooleanFieldListFilter, ChoicesFieldListFilter as ChoicesFieldListFilter, DateFieldListFilter as DateFieldListFilter, FieldListFilter as FieldListFilter, ListFilter as ListFilter, RelatedFieldListFilter as RelatedFieldListFilter, RelatedOnlyFieldListFilter as RelatedOnlyFieldListFilter, SimpleListFilter as SimpleListFilter, ) from .helpers import ACTION_CHECKBOX_NAME as ACTION_CHECKBOX_NAME from .options import ( HORIZONTAL as HORIZONTAL, VERTICAL as VERTICAL, ModelAdmin as ModelAdmin, StackedInline as StackedInline, TabularInline as TabularInline, ) from .sites import AdminSite as AdminSite, site as site from . import checks as checks def autodiscover() -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/admin/actions.pyi0000664000175000017500000000053700000000000027564 0ustar00davedave00000000000000from typing import Optional from django.contrib.admin.options import ModelAdmin from django.core.handlers.wsgi import WSGIRequest from django.db.models.query import QuerySet from django.template.response import TemplateResponse def delete_selected(modeladmin: ModelAdmin, request: WSGIRequest, queryset: QuerySet) -> Optional[TemplateResponse]: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/admin/apps.pyi0000664000175000017500000000021600000000000027061 0ustar00davedave00000000000000from django.apps import AppConfig class SimpleAdminConfig(AppConfig): default_site: str = ... class AdminConfig(SimpleAdminConfig): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/admin/checks.pyi0000664000175000017500000000152100000000000027356 0ustar00davedave00000000000000from typing import Any, List, Union, Iterable, Optional from django.contrib.admin.options import BaseModelAdmin from django.core.checks.messages import Error from django.apps.config import AppConfig _CheckError = Union[str, Error] def check_admin_app(app_configs: Optional[Iterable[AppConfig]], **kwargs: Any) -> List[_CheckError]: ... def check_dependencies(**kwargs: Any) -> List[_CheckError]: ... class BaseModelAdminChecks: def check(self, admin_obj: BaseModelAdmin, **kwargs: Any) -> List[_CheckError]: ... class ModelAdminChecks(BaseModelAdminChecks): ... class InlineModelAdminChecks(BaseModelAdminChecks): ... def must_be(type: Any, option: Any, obj: Any, id: Any): ... def must_inherit_from(parent: Any, option: Any, obj: Any, id: Any): ... def refer_to_missing_field(field: Any, option: Any, model: Any, obj: Any, id: Any): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/admin/decorators.pyi0000664000175000017500000000025200000000000030263 0ustar00davedave00000000000000from typing import Any, Callable, Optional, Type from django.db.models.base import Model def register(*models: Type[Model], site: Optional[Any] = ...) -> Callable: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/admin/filters.pyi0000664000175000017500000000663700000000000027603 0ustar00davedave00000000000000from typing import Any, Callable, Dict, List, Optional, Tuple, Type, Iterator from django.contrib.admin.options import ModelAdmin from django.core.handlers.wsgi import WSGIRequest from django.db.models.base import Model from django.db.models.fields.related import RelatedField from django.db.models.query import QuerySet from django.db.models.fields import Field class ListFilter: title: Any = ... template: str = ... used_parameters: Any = ... def __init__( self, request: WSGIRequest, params: Dict[str, str], model: Type[Model], model_admin: ModelAdmin ) -> None: ... def has_output(self) -> bool: ... def choices(self, changelist: Any) -> Optional[Iterator[Dict[str, Any]]]: ... def queryset(self, request: Any, queryset: QuerySet) -> Optional[QuerySet]: ... def expected_parameters(self) -> Optional[List[str]]: ... class SimpleListFilter(ListFilter): parameter_name: Any = ... lookup_choices: Any = ... def value(self) -> Optional[str]: ... def lookups(self, request: Any, model_admin: Any) -> List[Tuple[Any, str]]: ... class FieldListFilter(ListFilter): field: Field = ... field_path: Any = ... title: Any = ... def __init__( self, field: Field, request: WSGIRequest, params: Dict[str, str], model: Type[Model], model_admin: ModelAdmin, field_path: str, ) -> None: ... @classmethod def register(cls, test: Callable, list_filter_class: Type[FieldListFilter], take_priority: bool = ...) -> None: ... @classmethod def create( cls, field: Field, request: WSGIRequest, params: Dict[str, str], model: Type[Model], model_admin: ModelAdmin, field_path: str, ) -> FieldListFilter: ... class RelatedFieldListFilter(FieldListFilter): used_parameters: Dict[Any, Any] lookup_kwarg: str = ... lookup_kwarg_isnull: str = ... lookup_val: None = ... lookup_val_isnull: None = ... lookup_choices: Any = ... lookup_title: Any = ... title: str = ... empty_value_display: Any = ... @property def include_empty_choice(self) -> bool: ... def field_choices( self, field: RelatedField, request: WSGIRequest, model_admin: ModelAdmin ) -> List[Tuple[str, str]]: ... class BooleanFieldListFilter(FieldListFilter): lookup_kwarg: Any = ... lookup_kwarg2: Any = ... lookup_val: Any = ... lookup_val2: Any = ... def choices(self, changelist: Any) -> None: ... class ChoicesFieldListFilter(FieldListFilter): title: str used_parameters: Dict[Any, Any] lookup_kwarg: str = ... lookup_kwarg_isnull: str = ... lookup_val: None = ... lookup_val_isnull: None = ... class DateFieldListFilter(FieldListFilter): field_generic: Any = ... date_params: Any = ... lookup_kwarg_since: Any = ... lookup_kwarg_until: Any = ... links: Any = ... lookup_kwarg_isnull: Any = ... class AllValuesFieldListFilter(FieldListFilter): title: str used_parameters: Dict[Any, Any] lookup_kwarg: str = ... lookup_kwarg_isnull: str = ... lookup_val: None = ... lookup_val_isnull: None = ... empty_value_display: str = ... lookup_choices: QuerySet = ... class RelatedOnlyFieldListFilter(RelatedFieldListFilter): lookup_kwarg: str lookup_kwarg_isnull: str lookup_val: None lookup_val_isnull: None title: str used_parameters: Dict[Any, Any] ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/admin/forms.pyi0000664000175000017500000000037100000000000027246 0ustar00davedave00000000000000from django.contrib.auth.forms import AuthenticationForm, PasswordChangeForm class AdminAuthenticationForm(AuthenticationForm): required_css_class: str = ... class AdminPasswordChangeForm(PasswordChangeForm): required_css_class: str = ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/admin/helpers.pyi0000664000175000017500000001126600000000000027567 0ustar00davedave00000000000000from typing import Any, Callable, Dict, Iterator, List, Optional, Tuple, Union, Iterable from django.forms.boundfield import BoundField from django.forms.forms import BaseForm from django.forms.utils import ErrorDict from django.forms.widgets import Media, Widget from django.utils.safestring import SafeText from django import forms from django.db.models.fields import AutoField ACTION_CHECKBOX_NAME: str class ActionForm(forms.Form): action: Any = ... select_across: Any = ... checkbox: Any class AdminForm: prepopulated_fields: Any = ... model_admin: Any = ... readonly_fields: Any = ... def __init__( self, form: BaseForm, fieldsets: List[Tuple[None, Dict[str, List[str]]]], prepopulated_fields: Dict[Any, Any], readonly_fields: Optional[Iterable[Any]] = ..., model_admin: Any = ..., ) -> None: ... def __iter__(self) -> Iterator[Fieldset]: ... @property def errors(self) -> ErrorDict: ... @property def non_field_errors(self) -> Callable: ... @property def media(self) -> Media: ... class Fieldset: form: Any = ... classes: Any = ... description: Any = ... model_admin: Any = ... readonly_fields: Any = ... def __init__( self, form: Any, name: Optional[Any] = ..., readonly_fields: Optional[Iterable[Any]] = ..., fields: Any = ..., classes: Any = ..., description: Optional[Any] = ..., model_admin: Optional[Any] = ..., ) -> None: ... @property def media(self) -> Media: ... def __iter__(self) -> Iterator[Fieldline]: ... class Fieldline: form: Any = ... fields: Any = ... has_visible_field: Any = ... model_admin: Any = ... readonly_fields: Any = ... def __init__( self, form: Any, field: Any, readonly_fields: Optional[Iterable[Any]] = ..., model_admin: Optional[Any] = ... ) -> None: ... def __iter__(self) -> Iterator[Union[AdminField, AdminReadonlyField]]: ... def errors(self) -> SafeText: ... class AdminField: field: BoundField = ... is_first: bool = ... is_checkbox: bool = ... is_readonly: bool = ... def __init__(self, form: Any, field: Any, is_first: Any) -> None: ... def label_tag(self) -> SafeText: ... def errors(self) -> SafeText: ... class AdminReadonlyField: field: Any = ... form: Any = ... model_admin: Any = ... is_first: Any = ... is_checkbox: bool = ... is_readonly: bool = ... empty_value_display: Any = ... def __init__(self, form: Any, field: Any, is_first: Any, model_admin: Optional[Any] = ...) -> None: ... def label_tag(self) -> SafeText: ... def contents(self) -> SafeText: ... class InlineAdminFormSet: opts: Any = ... formset: Any = ... fieldsets: Any = ... model_admin: Any = ... readonly_fields: Any = ... prepopulated_fields: Any = ... classes: Any = ... has_add_permission: Any = ... has_change_permission: Any = ... has_delete_permission: Any = ... has_view_permission: Any = ... def __init__( self, inline: Any, formset: Any, fieldsets: Any, prepopulated_fields: Optional[Any] = ..., readonly_fields: Optional[Any] = ..., model_admin: Optional[Any] = ..., has_add_permission: bool = ..., has_change_permission: bool = ..., has_delete_permission: bool = ..., has_view_permission: bool = ..., ) -> None: ... def __iter__(self) -> Iterator[InlineAdminForm]: ... def fields(self) -> Iterator[Dict[str, Union[Dict[str, bool], bool, Widget, str]]]: ... def inline_formset_data(self) -> str: ... @property def forms(self): ... @property def non_form_errors(self) -> Callable: ... @property def media(self) -> Media: ... class InlineAdminForm(AdminForm): formset: Any = ... original: Any = ... show_url: Any = ... absolute_url: Any = ... def __init__( self, formset: Any, form: Any, fieldsets: Any, prepopulated_fields: Any, original: Any, readonly_fields: Optional[Any] = ..., model_admin: Optional[Any] = ..., view_on_site_url: Optional[Any] = ..., ) -> None: ... def needs_explicit_pk_field(self) -> Union[bool, AutoField]: ... def pk_field(self) -> AdminField: ... def fk_field(self) -> AdminField: ... def deletion_field(self) -> AdminField: ... def ordering_field(self): ... class InlineFieldset(Fieldset): formset: Any = ... def __init__(self, formset: Any, *args: Any, **kwargs: Any) -> None: ... class AdminErrorList(forms.utils.ErrorList): def __init__(self, form: Any, inline_formsets: Any) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/admin/models.pyi0000664000175000017500000000230400000000000027401 0ustar00davedave00000000000000from typing import Any, Optional, Union from uuid import UUID from django.contrib.contenttypes.models import ContentType from django.db.models.base import Model from django.db import models ADDITION: int CHANGE: int DELETION: int ACTION_FLAG_CHOICES: Any class LogEntryManager(models.Manager["LogEntry"]): def log_action( self, user_id: int, content_type_id: int, object_id: Union[int, str, UUID], object_repr: str, action_flag: int, change_message: Any = ..., ) -> LogEntry: ... class LogEntry(models.Model): action_time: models.DateTimeField = ... user: models.ForeignKey = ... content_type: models.ForeignKey = models.ForeignKey(ContentType, on_delete=models.CASCADE) object_id: models.TextField = ... object_repr: models.CharField = ... action_flag: models.PositiveSmallIntegerField = ... change_message: models.TextField = ... objects: LogEntryManager = ... def is_addition(self) -> bool: ... def is_change(self) -> bool: ... def is_deletion(self) -> bool: ... def get_change_message(self) -> str: ... def get_edited_object(self) -> Model: ... def get_admin_url(self) -> Optional[str]: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/admin/options.pyi0000664000175000017500000003300400000000000027612 0ustar00davedave00000000000000from collections import OrderedDict from typing import Any, Callable, Dict, Iterator, List, Optional, Sequence, Set, Tuple, Type, Union, Mapping, TypeVar from django.forms.forms import BaseForm from django.forms.formsets import BaseFormSet from typing_extensions import Literal, TypedDict from django.contrib.admin.filters import ListFilter from django.contrib.admin.models import LogEntry from django.contrib.admin.sites import AdminSite from django.contrib.admin.views.main import ChangeList from django.contrib.auth.forms import AdminPasswordChangeForm from django.contrib.contenttypes.models import ContentType from django.core.checks.messages import Error from django.core.paginator import Paginator from django.db.models.base import Model from django.db.models.fields.related import ForeignKey, ManyToManyField, RelatedField from django.db.models.options import Options from django.db.models.query import QuerySet from django.forms.fields import TypedChoiceField from django.forms.models import ModelChoiceField, ModelMultipleChoiceField from django.forms.widgets import Media from django.http.request import HttpRequest from django.http.response import HttpResponse, HttpResponseBase, HttpResponseRedirect, JsonResponse from django.template.response import TemplateResponse from django.urls.resolvers import URLPattern from django.utils.safestring import SafeText from django.db.models.fields import Field IS_POPUP_VAR: str TO_FIELD_VAR: str HORIZONTAL: Literal[1] = ... VERTICAL: Literal[2] = ... _Direction = Union[Literal[1], Literal[2]] def get_content_type_for_model(obj: Union[Type[Model], Model]) -> ContentType: ... def get_ul_class(radio_style: int) -> str: ... class IncorrectLookupParameters(Exception): ... FORMFIELD_FOR_DBFIELD_DEFAULTS: Any csrf_protect_m: Any class _OptionalFieldOpts(TypedDict, total=False): classes: Sequence[str] description: str class _FieldOpts(_OptionalFieldOpts, total=True): fields: Sequence[Union[str, Sequence[str]]] # Workaround for mypy issue, a Sequence type should be preferred here. # https://github.com/python/mypy/issues/8921 # _FieldsetSpec = Sequence[Tuple[Optional[str], _FieldOpts]] _T = TypeVar("_T") _ListOrTuple = Union[Tuple[_T, ...], List[_T]] _FieldsetSpec = _ListOrTuple[Tuple[Optional[str], _FieldOpts]] class BaseModelAdmin: autocomplete_fields: Sequence[str] = ... raw_id_fields: Sequence[str] = ... fields: Sequence[Union[str, Sequence[str]]] = ... exclude: Sequence[str] = ... fieldsets: _FieldsetSpec = ... form: Type[BaseForm] = ... filter_vertical: Sequence[str] = ... filter_horizontal: Sequence[str] = ... radio_fields: Mapping[str, _Direction] = ... prepopulated_fields: Mapping[str, Sequence[str]] = ... formfield_overrides: Mapping[Type[Field], Mapping[str, Any]] = ... readonly_fields: Sequence[Union[str, Callable[[Model], Any]]] = ... ordering: Sequence[str] = ... sortable_by: Sequence[str] = ... view_on_site: bool = ... show_full_result_count: bool = ... checks_class: Any = ... def check(self, **kwargs: Any) -> List[Union[str, Error]]: ... def formfield_for_dbfield( self, db_field: Field, request: Optional[HttpRequest], **kwargs: Any ) -> Optional[Field]: ... def formfield_for_choice_field( self, db_field: Field, request: Optional[HttpRequest], **kwargs: Any ) -> TypedChoiceField: ... def get_field_queryset( self, db: None, db_field: RelatedField, request: Optional[HttpRequest] ) -> Optional[QuerySet]: ... def formfield_for_foreignkey( self, db_field: ForeignKey, request: Optional[HttpRequest], **kwargs: Any ) -> Optional[ModelChoiceField]: ... def formfield_for_manytomany( self, db_field: ManyToManyField, request: Optional[HttpRequest], **kwargs: Any ) -> ModelMultipleChoiceField: ... def get_autocomplete_fields(self, request: HttpRequest) -> Tuple: ... def get_view_on_site_url(self, obj: Optional[Model] = ...) -> Optional[str]: ... def get_empty_value_display(self) -> SafeText: ... def get_exclude(self, request: HttpRequest, obj: Optional[Model] = ...) -> Any: ... def get_fields(self, request: HttpRequest, obj: Optional[Model] = ...) -> Sequence[Union[Callable, str]]: ... def get_fieldsets( self, request: HttpRequest, obj: Optional[Model] = ... ) -> List[Tuple[Optional[str], Dict[str, Any]]]: ... def get_ordering(self, request: HttpRequest) -> Union[List[str], Tuple]: ... def get_readonly_fields(self, request: HttpRequest, obj: Optional[Model] = ...) -> Union[List[str], Tuple]: ... def get_prepopulated_fields(self, request: HttpRequest, obj: Optional[Model] = ...) -> Dict[str, Tuple[str]]: ... def get_queryset(self, request: HttpRequest) -> QuerySet: ... def get_sortable_by(self, request: HttpRequest) -> Union[List[Callable], List[str], Tuple]: ... def lookup_allowed(self, lookup: str, value: str) -> bool: ... def to_field_allowed(self, request: HttpRequest, to_field: str) -> bool: ... def has_add_permission(self, request: HttpRequest) -> bool: ... def has_change_permission(self, request: HttpRequest, obj: Optional[Model] = ...) -> bool: ... def has_delete_permission(self, request: HttpRequest, obj: Optional[Model] = ...) -> bool: ... def has_view_permission(self, request: HttpRequest, obj: Optional[Model] = ...) -> bool: ... def has_module_permission(self, request: HttpRequest) -> bool: ... class ModelAdmin(BaseModelAdmin): list_display: Sequence[Union[str, Callable[[Model], Any]]] = ... list_display_links: Optional[Sequence[Union[str, Callable]]] = ... list_filter: Sequence[Union[str, Type[ListFilter], Tuple[str, Type[ListFilter]]]] = ... list_select_related: Union[bool, Sequence[str]] = ... list_per_page: int = ... list_max_show_all: int = ... list_editable: Sequence[str] = ... search_fields: Sequence[str] = ... date_hierarchy: Optional[str] = ... save_as: bool = ... save_as_continue: bool = ... save_on_top: bool = ... paginator: Type = ... preserve_filters: bool = ... inlines: Sequence[Type[InlineModelAdmin]] = ... add_form_template: str = ... change_form_template: str = ... change_list_template: str = ... delete_confirmation_template: str = ... delete_selected_confirmation_template: str = ... object_history_template: str = ... popup_response_template: str = ... actions: Sequence[Callable[[ModelAdmin, HttpRequest, QuerySet], None]] = ... action_form: Any = ... actions_on_top: bool = ... actions_on_bottom: bool = ... actions_selection_counter: bool = ... model: Type[Model] = ... opts: Options = ... admin_site: AdminSite = ... def __init__(self, model: Type[Model], admin_site: Optional[AdminSite]) -> None: ... def get_inline_instances(self, request: HttpRequest, obj: Optional[Model] = ...) -> List[InlineModelAdmin]: ... def get_urls(self) -> List[URLPattern]: ... @property def urls(self) -> List[URLPattern]: ... @property def media(self) -> Media: ... def get_model_perms(self, request: HttpRequest) -> Dict[str, bool]: ... def get_form(self, request: Any, obj: Optional[Any] = ..., change: bool = ..., **kwargs: Any): ... def get_changelist(self, request: HttpRequest, **kwargs: Any) -> Type[ChangeList]: ... def get_changelist_instance(self, request: HttpRequest) -> ChangeList: ... def get_object(self, request: HttpRequest, object_id: str, from_field: None = ...) -> Optional[Model]: ... def get_changelist_form(self, request: Any, **kwargs: Any): ... def get_changelist_formset(self, request: Any, **kwargs: Any): ... def get_formsets_with_inlines(self, request: HttpRequest, obj: Optional[Model] = ...) -> Iterator[Any]: ... def get_paginator( self, request: HttpRequest, queryset: QuerySet, per_page: int, orphans: int = ..., allow_empty_first_page: bool = ..., ) -> Paginator: ... def log_addition(self, request: HttpRequest, object: Model, message: Any) -> LogEntry: ... def log_change(self, request: HttpRequest, object: Model, message: Any) -> LogEntry: ... def log_deletion(self, request: HttpRequest, object: Model, object_repr: str) -> LogEntry: ... def action_checkbox(self, obj: Model) -> SafeText: ... def get_actions(self, request: HttpRequest) -> OrderedDict: ... def get_action_choices( self, request: HttpRequest, default_choices: List[Tuple[str, str]] = ... ) -> List[Tuple[str, str]]: ... def get_action(self, action: Union[Callable, str]) -> Tuple[Callable, str, str]: ... def get_list_display(self, request: HttpRequest) -> Sequence[str]: ... def get_list_display_links(self, request: HttpRequest, list_display: Sequence[str]) -> Optional[Sequence[str]]: ... def get_list_filter(self, request: HttpRequest) -> Sequence[str]: ... def get_list_select_related(self, request: HttpRequest) -> Sequence[str]: ... def get_search_fields(self, request: HttpRequest) -> List[str]: ... def get_search_results( self, request: HttpRequest, queryset: QuerySet, search_term: str ) -> Tuple[QuerySet, bool]: ... def get_preserved_filters(self, request: HttpRequest) -> str: ... def _get_edited_object_pks(self, request: HttpRequest, prefix: str) -> List[str]: ... def _get_list_editable_queryset(self, request: HttpRequest, prefix: str) -> QuerySet: ... def construct_change_message( self, request: HttpRequest, form: AdminPasswordChangeForm, formsets: None, add: bool = ... ) -> List[Dict[str, Dict[str, List[str]]]]: ... def message_user( self, request: HttpRequest, message: str, level: Union[int, str] = ..., extra_tags: str = ..., fail_silently: bool = ..., ) -> None: ... def save_form(self, request: Any, form: Any, change: Any): ... def save_model(self, request: Any, obj: Any, form: Any, change: Any) -> None: ... def delete_model(self, request: HttpRequest, obj: Model) -> None: ... def delete_queryset(self, request: HttpRequest, queryset: QuerySet) -> None: ... def save_formset(self, request: Any, form: Any, formset: Any, change: Any) -> None: ... def save_related(self, request: Any, form: Any, formsets: Any, change: Any) -> None: ... def render_change_form( self, request: Any, context: Any, add: bool = ..., change: bool = ..., form_url: str = ..., obj: Optional[Any] = ..., ): ... def response_add( self, request: HttpRequest, obj: Model, post_url_continue: Optional[str] = ... ) -> HttpResponse: ... def response_change(self, request: HttpRequest, obj: Model) -> HttpResponse: ... def response_post_save_add(self, request: HttpRequest, obj: Model) -> HttpResponseRedirect: ... def response_post_save_change(self, request: HttpRequest, obj: Model) -> HttpResponseRedirect: ... def response_action(self, request: HttpRequest, queryset: QuerySet) -> Optional[HttpResponseBase]: ... def response_delete(self, request: HttpRequest, obj_display: str, obj_id: int) -> HttpResponse: ... def render_delete_form(self, request: Any, context: Any): ... def get_inline_formsets( self, request: HttpRequest, formsets: List[Any], inline_instances: List[Any], obj: Optional[Model] = ... ) -> List[Any]: ... def get_changeform_initial_data(self, request: HttpRequest) -> Dict[str, str]: ... def changeform_view( self, request: HttpRequest, object_id: Optional[str] = ..., form_url: str = ..., extra_context: Optional[Dict[str, bool]] = ..., ) -> Any: ... def autocomplete_view(self, request: HttpRequest) -> JsonResponse: ... def add_view(self, request: HttpRequest, form_url: str = ..., extra_context: None = ...) -> HttpResponse: ... def change_view( self, request: HttpRequest, object_id: str, form_url: str = ..., extra_context: Optional[Dict[str, bool]] = ... ) -> HttpResponse: ... def changelist_view( self, request: HttpRequest, extra_context: Optional[Dict[str, str]] = ... ) -> TemplateResponse: ... def get_deleted_objects( self, objs: QuerySet, request: HttpRequest ) -> Tuple[List[Any], Dict[Any, Any], Set[Any], List[Any]]: ... def delete_view(self, request: HttpRequest, object_id: str, extra_context: None = ...) -> Any: ... def history_view(self, request: HttpRequest, object_id: str, extra_context: None = ...) -> HttpResponse: ... class InlineModelAdmin(BaseModelAdmin): model: Type[Model] = ... fk_name: str = ... formset: BaseFormSet = ... extra: int = ... min_num: Optional[int] = ... max_num: Optional[int] = ... template: str = ... verbose_name: Optional[str] = ... verbose_name_plural: Optional[str] = ... can_delete: bool = ... show_change_link: bool = ... classes: Optional[Sequence[str]] = ... admin_site: AdminSite = ... parent_model: Any = ... opts: Any = ... has_registered_model: Any = ... def __init__(self, parent_model: Union[Type[Model], Model], admin_site: AdminSite) -> None: ... @property def media(self) -> Media: ... def get_extra(self, request: HttpRequest, obj: Optional[Model] = ..., **kwargs: Any) -> int: ... def get_min_num(self, request: HttpRequest, obj: Optional[Model] = ..., **kwargs: Any) -> Optional[int]: ... def get_max_num(self, request: HttpRequest, obj: Optional[Model] = ..., **kwargs: Any) -> Optional[int]: ... def get_formset(self, request: Any, obj: Optional[Any] = ..., **kwargs: Any): ... class StackedInline(InlineModelAdmin): ... class TabularInline(InlineModelAdmin): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/admin/sites.pyi0000664000175000017500000000633000000000000027250 0ustar00davedave00000000000000from typing import Any, Callable, Dict, Iterable, List, Optional, Tuple, Type, Union from django.contrib.admin.options import ModelAdmin from django.core.handlers.wsgi import WSGIRequest from django.db.models.base import Model from django.http.response import HttpResponse from django.template.response import TemplateResponse from django.urls.resolvers import URLResolver from django.utils.functional import LazyObject from django.apps.config import AppConfig all_sites: Any class AlreadyRegistered(Exception): ... class NotRegistered(Exception): ... class AdminSite: site_title: Any = ... site_header: Any = ... index_title: Any = ... site_url: str = ... login_form: Any = ... index_template: Any = ... app_index_template: Any = ... login_template: Any = ... logout_template: Any = ... password_change_template: Any = ... password_change_done_template: Any = ... name: str = ... _registry: Dict[Type[Model], ModelAdmin] def __init__(self, name: str = ...) -> None: ... def check(self, app_configs: Optional[Iterable[AppConfig]]) -> List[Any]: ... def register( self, model_or_iterable: Union[Type[Model], Iterable[Type[Model]]], admin_class: Optional[Type[ModelAdmin]] = ..., **options: Any ) -> None: ... def unregister(self, model_or_iterable: Union[Type[Model], Iterable[Type[Model]]]) -> None: ... def is_registered(self, model: Type[Model]) -> bool: ... def add_action(self, action: Callable, name: Optional[str] = ...) -> None: ... def disable_action(self, name: str) -> None: ... def get_action(self, name: str) -> Callable: ... @property def actions(self): ... @property def empty_value_display(self): ... @empty_value_display.setter def empty_value_display(self, empty_value_display: Any) -> None: ... def has_permission(self, request: WSGIRequest) -> bool: ... def admin_view(self, view: Callable, cacheable: bool = ...) -> Callable: ... def get_urls(self) -> List[URLResolver]: ... @property def urls(self) -> Tuple[List[URLResolver], str, str]: ... def each_context(self, request: Any): ... def password_change( self, request: WSGIRequest, extra_context: Optional[Dict[str, Any]] = ... ) -> TemplateResponse: ... def password_change_done( self, request: WSGIRequest, extra_context: Optional[Dict[str, Any]] = ... ) -> TemplateResponse: ... def i18n_javascript(self, request: WSGIRequest, extra_context: Optional[Dict[Any, Any]] = ...) -> HttpResponse: ... def logout(self, request: WSGIRequest, extra_context: Optional[Dict[str, Any]] = ...) -> TemplateResponse: ... def login(self, request: WSGIRequest, extra_context: Optional[Dict[str, Any]] = ...) -> HttpResponse: ... def _build_app_dict(self, request: WSGIRequest, label: Optional[str] = ...) -> Dict[str, Any]: ... def get_app_list(self, request: WSGIRequest) -> List[Any]: ... def index(self, request: WSGIRequest, extra_context: Optional[Dict[str, Any]] = ...) -> TemplateResponse: ... def app_index( self, request: WSGIRequest, app_label: str, extra_context: Optional[Dict[str, Any]] = ... ) -> TemplateResponse: ... class DefaultAdminSite(LazyObject): ... site: Any ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.3943791 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/admin/templatetags/0000775000175000017500000000000000000000000030066 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/admin/templatetags/__init__.pyi0000664000175000017500000000000000000000000032336 0ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/admin/templatetags/admin_list.pyi0000664000175000017500000000375400000000000032745 0ustar00davedave00000000000000from typing import Any, Dict, Iterator, List, Optional, Union, Iterable from django.contrib.admin.filters import FieldListFilter from django.contrib.admin.templatetags.base import InclusionAdminNode from django.contrib.admin.views.main import ChangeList from django.db.models.base import Model from django.forms.boundfield import BoundField from django.template.base import Parser, Token from django.template.context import RequestContext from django.utils.safestring import SafeText from .base import InclusionAdminNode register: Any DOT: str def paginator_number(cl: ChangeList, i: int) -> SafeText: ... def pagination(cl: ChangeList) -> Dict[str, Iterable[Any]]: ... def pagination_tag(parser: Parser, token: Token) -> InclusionAdminNode: ... def result_headers(cl: ChangeList) -> Iterator[Dict[str, Optional[Union[int, str]]]]: ... def items_for_result(cl: ChangeList, result: Model, form: None) -> Iterator[SafeText]: ... class ResultList(list): form: None = ... def __init__(self, form: None, *items: Any) -> None: ... def results(cl: ChangeList) -> Iterator[ResultList]: ... def result_hidden_fields(cl: ChangeList) -> Iterator[BoundField]: ... def result_list( cl: ChangeList, ) -> Dict[ str, Union[List[Dict[str, Optional[Union[int, str]]]], List[ResultList], List[BoundField], ChangeList, int] ]: ... def result_list_tag(parser: Parser, token: Token) -> InclusionAdminNode: ... def date_hierarchy(cl: ChangeList) -> Optional[Dict[str, Any]]: ... def date_hierarchy_tag(parser: Parser, token: Token) -> InclusionAdminNode: ... def search_form(cl: ChangeList) -> Dict[str, Union[bool, ChangeList, str]]: ... def search_form_tag(parser: Parser, token: Token) -> InclusionAdminNode: ... def admin_list_filter(cl: ChangeList, spec: FieldListFilter) -> SafeText: ... def admin_actions(context: RequestContext) -> RequestContext: ... def admin_actions_tag(parser: Parser, token: Token) -> InclusionAdminNode: ... def change_list_object_tools_tag(parser: Parser, token: Token) -> InclusionAdminNode: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/admin/templatetags/admin_modify.pyi0000664000175000017500000000126200000000000033251 0ustar00davedave00000000000000from typing import Any from django.contrib.admin.helpers import InlineAdminForm from django.template.base import Parser, Token from django.template.context import Context, RequestContext from .base import InclusionAdminNode register: Any def prepopulated_fields_js(context: RequestContext) -> RequestContext: ... def prepopulated_fields_js_tag(parser: Parser, token: Token) -> InclusionAdminNode: ... def submit_row(context: RequestContext) -> Context: ... def submit_row_tag(parser: Parser, token: Token) -> InclusionAdminNode: ... def change_form_object_tools_tag(parser: Parser, token: Token) -> InclusionAdminNode: ... def cell_count(inline_admin_form: InlineAdminForm) -> int: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/admin/templatetags/admin_static.pyi0000664000175000017500000000011100000000000033241 0ustar00davedave00000000000000from typing import Any register: Any def static(path: str) -> str: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/admin/templatetags/admin_urls.pyi0000664000175000017500000000104300000000000032744 0ustar00davedave00000000000000from typing import Any, Dict, Optional, Union from uuid import UUID from django.db.models.options import Options from django.template.context import RequestContext from django.utils.safestring import SafeText register: Any def admin_urlname(value: Options, arg: SafeText) -> str: ... def admin_urlquote(value: Union[int, str, UUID]) -> Union[int, str, UUID]: ... def add_preserved_filters( context: Union[Dict[str, Union[Options, str]], RequestContext], url: str, popup: bool = ..., to_field: Optional[str] = ..., ) -> str: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/admin/templatetags/base.pyi0000664000175000017500000000112000000000000031515 0ustar00davedave00000000000000from typing import Any, Callable, Dict, List from django.template.base import Parser, Token from django.template.context import Context from django.template.library import InclusionNode from django.utils.safestring import SafeText class InclusionAdminNode(InclusionNode): args: List[Any] func: Callable kwargs: Dict[Any, Any] takes_context: bool template_name: str = ... def __init__( self, parser: Parser, token: Token, func: Callable, template_name: str, takes_context: bool = ... ) -> None: ... def render(self, context: Context) -> SafeText: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/admin/templatetags/log.pyi0000664000175000017500000000070600000000000031375 0ustar00davedave00000000000000from typing import Any, Optional from django import template from django.template.base import Parser, Token from django.template.context import Context register: Any class AdminLogNode(template.Node): limit: str user: str varname: str def __init__(self, limit: str, varname: str, user: Optional[str]) -> None: ... def render(self, context: Context) -> str: ... def get_admin_log(parser: Parser, token: Token) -> AdminLogNode: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/admin/tests.pyi0000664000175000017500000000261100000000000027261 0ustar00davedave00000000000000from typing import Any, Callable from django.contrib.staticfiles.testing import StaticLiveServerTestCase from django.test.selenium import SeleniumTestCase from django.utils.deprecation import MiddlewareMixin class CSPMiddleware(MiddlewareMixin): ... class AdminSeleniumTestCase(SeleniumTestCase, StaticLiveServerTestCase): def wait_until(self, callback: Callable, timeout: int = ...) -> None: ... def wait_for_popup(self, num_windows: int = ..., timeout: int = ...) -> None: ... def wait_for(self, css_selector: str, timeout: int = ...) -> None: ... def wait_for_text(self, css_selector: str, text: str, timeout: int = ...) -> None: ... def wait_for_value(self, css_selector: str, text: str, timeout: int = ...) -> None: ... def wait_until_visible(self, css_selector: str, timeout: int = ...) -> None: ... def wait_until_invisible(self, css_selector: str, timeout: int = ...) -> None: ... def wait_page_loaded(self) -> None: ... def admin_login(self, username: str, password: str, login_url: str = ...) -> None: ... def get_css_value(self, selector: str, attribute: str) -> Any: ... def get_select_option(self, selector: str, value: Any) -> Any: ... def assertSelectOptions(self, selector: str, values: Any) -> None: ... def assertSelectedOptions(self, selector: str, values: Any) -> None: ... def has_css_class(self, selector: str, klass: str) -> bool: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/admin/utils.pyi0000664000175000017500000000604300000000000027262 0ustar00davedave00000000000000import collections from datetime import datetime from typing import Any, Callable, Dict, List, Optional, Sequence, Set, Tuple, Type, Union from uuid import UUID from django.contrib.admin.options import BaseModelAdmin from django.contrib.admin.sites import AdminSite from django.contrib.auth.forms import AdminPasswordChangeForm from django.core.handlers.wsgi import WSGIRequest from django.db.models.base import Model from django.db.models.deletion import Collector from django.db.models.fields.reverse_related import ManyToOneRel from django.db.models.options import Options from django.db.models.query import QuerySet from django.forms.forms import BaseForm from django.db.models.fields import Field, reverse_related class FieldIsAForeignKeyColumnName(Exception): ... def lookup_needs_distinct(opts: Options, lookup_path: str) -> bool: ... def prepare_lookup_value(key: str, value: Union[datetime, str]) -> Union[bool, datetime, str]: ... def quote(s: Union[int, str, UUID]) -> str: ... def unquote(s: str) -> str: ... def flatten(fields: Any) -> List[Union[Callable, str]]: ... def flatten_fieldsets(fieldsets: Any) -> List[Union[Callable, str]]: ... def get_deleted_objects( objs: Sequence[Optional[Model]], request: WSGIRequest, admin_site: AdminSite ) -> Tuple[List[Any], Dict[Any, Any], Set[Any], List[Any]]: ... class NestedObjects(Collector): data: collections.OrderedDict dependencies: Dict[Any, Any] fast_deletes: List[Any] field_updates: Dict[Any, Any] using: str edges: Any = ... protected: Any = ... model_objs: Any = ... def __init__(self, *args: Any, **kwargs: Any) -> None: ... def add_edge(self, source: Optional[Model], target: Model) -> None: ... def related_objects(self, related: ManyToOneRel, objs: Sequence[Optional[Model]]) -> QuerySet: ... def nested(self, format_callback: Callable = ...) -> List[Any]: ... def model_format_dict(obj: Any): ... def model_ngettext(obj: Union[Options, QuerySet], n: Optional[int] = ...) -> str: ... def lookup_field( name: Union[Callable, str], obj: Model, model_admin: BaseModelAdmin = ... ) -> Tuple[Optional[Field], Any, Any]: ... def label_for_field( name: Union[Callable, str], model: Type[Model], model_admin: Optional[BaseModelAdmin] = ..., return_attr: bool = ..., form: Optional[BaseForm] = ..., ) -> Union[Tuple[Optional[str], Union[Callable, Type[str]]], str]: ... def help_text_for_field(name: str, model: Type[Model]) -> str: ... def display_for_field(value: Any, field: Field, empty_value_display: str) -> str: ... def display_for_value(value: Any, empty_value_display: str, boolean: bool = ...) -> str: ... class NotRelationField(Exception): ... def get_model_from_relation(field: Union[Field, reverse_related.ForeignObjectRel]) -> Type[Model]: ... def reverse_field_path(model: Type[Model], path: str) -> Tuple[Type[Model], str]: ... def get_fields_from_path(model: Type[Model], path: str) -> List[Field]: ... def construct_change_message( form: AdminPasswordChangeForm, formsets: None, add: bool ) -> List[Dict[str, Dict[str, List[str]]]]: ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.3943791 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/admin/views/0000775000175000017500000000000000000000000026531 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/admin/views/__init__.pyi0000664000175000017500000000000000000000000031001 0ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/admin/views/autocomplete.pyi0000664000175000017500000000053500000000000031760 0ustar00davedave00000000000000from typing import Any from django.contrib.admin.options import ModelAdmin from django.core.handlers.wsgi import WSGIRequest from django.views.generic.list import BaseListView class AutocompleteJsonView(BaseListView): model_admin: ModelAdmin = ... term: Any = ... def has_perm(self, request: WSGIRequest, obj: None = ...) -> bool: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/admin/views/decorators.pyi0000664000175000017500000000051700000000000031424 0ustar00davedave00000000000000from typing import Callable, TypeVar, overload _C = TypeVar("_C", bound=Callable) @overload def staff_member_required(view_func: _C = ..., redirect_field_name: str = ..., login_url: str = ...) -> _C: ... @overload def staff_member_required(view_func: None = ..., redirect_field_name: str = ..., login_url: str = ...) -> Callable: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/admin/views/main.pyi0000664000175000017500000000647600000000000030215 0ustar00davedave00000000000000from collections import OrderedDict from typing import Any, Callable, Dict, List, Optional, Tuple, Type, Union from django.contrib.admin.filters import ListFilter, SimpleListFilter from django.contrib.admin.options import ( # noqa: F401 ModelAdmin, IS_POPUP_VAR as IS_POPUP_VAR, TO_FIELD_VAR as TO_FIELD_VAR, ) from django.core.handlers.wsgi import WSGIRequest from django.db.models.base import Model from django.db.models.expressions import Combinable, CombinedExpression, OrderBy from django.db.models.query import QuerySet from django.db.models.options import Options from django.forms.formsets import BaseFormSet ALL_VAR: str ORDER_VAR: str ORDER_TYPE_VAR: str PAGE_VAR: str SEARCH_VAR: str ERROR_FLAG: str IGNORED_PARAMS: Any class ChangeList: model: Type[Model] = ... opts: Options = ... lookup_opts: Options = ... root_queryset: QuerySet = ... list_display: List[str] = ... list_display_links: List[str] = ... list_filter: Tuple = ... date_hierarchy: None = ... search_fields: Tuple = ... list_select_related: bool = ... list_per_page: int = ... list_max_show_all: int = ... model_admin: ModelAdmin = ... preserved_filters: str = ... sortable_by: Tuple[str] = ... page_num: int = ... show_all: bool = ... is_popup: bool = ... to_field: None = ... params: Dict[Any, Any] = ... list_editable: Tuple = ... query: str = ... queryset: Any = ... title: Any = ... pk_attname: Any = ... formset: Optional[BaseFormSet] def __init__( self, request: WSGIRequest, model: Type[Model], list_display: Union[List[Union[Callable, str]], Tuple[str]], list_display_links: Optional[Union[List[Callable], List[str], Tuple[str]]], list_filter: Union[List[Type[SimpleListFilter]], List[str], Tuple], date_hierarchy: Optional[str], search_fields: Union[List[str], Tuple], list_select_related: Union[Tuple, bool], list_per_page: int, list_max_show_all: int, list_editable: Union[List[str], Tuple], model_admin: ModelAdmin, sortable_by: Union[List[Callable], List[str], Tuple], ) -> None: ... def get_filters_params(self, params: None = ...) -> Dict[str, str]: ... def get_filters(self, request: WSGIRequest) -> Tuple[List[ListFilter], bool, Dict[str, Union[bool, str]], bool]: ... def get_query_string( self, new_params: Optional[Dict[str, None]] = ..., remove: Optional[List[str]] = ... ) -> str: ... result_count: Any = ... show_full_result_count: Any = ... show_admin_actions: Any = ... full_result_count: Any = ... result_list: Any = ... can_show_all: Any = ... multi_page: Any = ... paginator: Any = ... def get_results(self, request: WSGIRequest) -> None: ... def get_ordering_field(self, field_name: Union[Callable, str]) -> Optional[Union[CombinedExpression, str]]: ... def get_ordering(self, request: WSGIRequest, queryset: QuerySet) -> List[Union[OrderBy, Combinable, str]]: ... def get_ordering_field_columns(self) -> OrderedDict: ... def get_queryset(self, request: WSGIRequest) -> QuerySet: ... def apply_select_related(self, qs: QuerySet) -> QuerySet: ... def has_related_field_in_list_display(self) -> bool: ... def url_for_result(self, result: Model) -> str: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/admin/widgets.pyi0000664000175000017500000000645700000000000027601 0ustar00davedave00000000000000from typing import Any, Dict, Optional, Tuple, Union from uuid import UUID from django.contrib.admin.sites import AdminSite from django.db.models.fields.reverse_related import ForeignObjectRel, ManyToOneRel from django.forms.models import ModelChoiceIterator from django.forms.widgets import Media from django import forms class FilteredSelectMultiple(forms.SelectMultiple): @property def media(self) -> Media: ... verbose_name: Any = ... is_stacked: Any = ... def __init__(self, verbose_name: str, is_stacked: bool, attrs: None = ..., choices: Tuple = ...) -> None: ... class AdminDateWidget(forms.DateInput): @property def media(self) -> Media: ... class AdminTimeWidget(forms.TimeInput): @property def media(self) -> Media: ... class AdminSplitDateTime(forms.SplitDateTimeWidget): ... class AdminRadioSelect(forms.RadioSelect): ... class AdminFileWidget(forms.ClearableFileInput): ... def url_params_from_lookup_dict(lookups: Any) -> Dict[str, str]: ... class ForeignKeyRawIdWidget(forms.TextInput): rel: ManyToOneRel = ... admin_site: AdminSite = ... db: None = ... def __init__(self, rel: ForeignObjectRel, admin_site: AdminSite, attrs: None = ..., using: None = ...) -> None: ... def base_url_parameters(self) -> Dict[str, str]: ... def url_parameters(self) -> Dict[str, str]: ... def label_and_url_for_value(self, value: Union[int, str, UUID]) -> Tuple[str, str]: ... class ManyToManyRawIdWidget(ForeignKeyRawIdWidget): ... class RelatedFieldWidgetWrapper(forms.Widget): template_name: str = ... choices: ModelChoiceIterator = ... widget: forms.Widget = ... rel: ManyToOneRel = ... can_add_related: bool = ... can_change_related: bool = ... can_delete_related: bool = ... can_view_related: bool = ... admin_site: AdminSite = ... def __init__( self, widget: forms.Widget, rel: ForeignObjectRel, admin_site: AdminSite, can_add_related: Optional[bool] = ..., can_change_related: bool = ..., can_delete_related: bool = ..., can_view_related: bool = ..., ) -> None: ... @property def media(self) -> Media: ... def get_related_url(self, info: Tuple[str, str], action: str, *args: Any) -> str: ... class AdminTextareaWidget(forms.Textarea): ... class AdminTextInputWidget(forms.TextInput): ... class AdminEmailInputWidget(forms.EmailInput): ... class AdminURLFieldWidget(forms.URLInput): ... class AdminIntegerFieldWidget(forms.NumberInput): class_name: str = ... class AdminBigIntegerFieldWidget(AdminIntegerFieldWidget): ... class AdminUUIDInputWidget(forms.TextInput): def __init__(self, attrs: Optional[Dict[str, str]] = ...) -> None: ... SELECT2_TRANSLATIONS: Any class AutocompleteMixin: url_name: str = ... rel: Any = ... admin_site: Any = ... db: Any = ... choices: Any = ... attrs: Any = ... def __init__( self, rel: ForeignObjectRel, admin_site: AdminSite, attrs: Optional[Dict[str, str]] = ..., choices: Tuple = ..., using: None = ..., ) -> None: ... def get_url(self) -> str: ... @property def media(self) -> Media: ... class AutocompleteSelect(AutocompleteMixin, forms.Select): ... class AutocompleteSelectMultiple(AutocompleteMixin, forms.SelectMultiple): ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.3943791 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/admindocs/0000775000175000017500000000000000000000000026245 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/admindocs/__init__.pyi0000664000175000017500000000000000000000000030515 0ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/admindocs/middleware.pyi0000664000175000017500000000063100000000000031105 0ustar00davedave00000000000000from typing import Any, Callable, Dict, Optional, Tuple from django.core.handlers.wsgi import WSGIRequest from django.http.response import HttpResponse from django.utils.deprecation import MiddlewareMixin class XViewMiddleware(MiddlewareMixin): def process_view( self, request: WSGIRequest, view_func: Callable, view_args: Tuple, view_kwargs: Dict[Any, Any] ) -> Optional[HttpResponse]: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/admindocs/urls.pyi0000664000175000017500000000007300000000000027755 0ustar00davedave00000000000000from typing import Any, List urlpatterns: List[Any] = ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/admindocs/utils.pyi0000664000175000017500000000132500000000000030131 0ustar00davedave00000000000000from typing import Any, Callable, Optional docutils_is_available: bool def get_view_name(view_func: Callable) -> str: ... def trim_docstring(docstring: Any): ... def parse_docstring(docstring: Any): ... def parse_rst(text: Any, default_reference_context: Any, thing_being_parsed: Optional[Any] = ...): ... ROLES: Any def create_reference_role(rolename: Any, urlbase: Any): ... def default_reference_role( name: Any, rawtext: Any, text: Any, lineno: Any, inliner: Any, options: Optional[Any] = ..., content: Optional[Any] = ..., ): ... named_group_matcher: Any unnamed_group_matcher: Any def replace_named_groups(pattern: str) -> str: ... def replace_unnamed_groups(pattern: str) -> str: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/admindocs/views.pyi0000664000175000017500000000152400000000000030127 0ustar00davedave00000000000000from typing import Any, Optional, Union from django.db.models.fields import Field from django.views.generic import TemplateView MODEL_METHODS_EXCLUDE: Any class BaseAdminDocsView(TemplateView): ... class BookmarkletsView(BaseAdminDocsView): ... class TemplateTagIndexView(BaseAdminDocsView): ... class TemplateFilterIndexView(BaseAdminDocsView): ... class ViewIndexView(BaseAdminDocsView): ... class ViewDetailView(BaseAdminDocsView): ... class ModelIndexView(BaseAdminDocsView): ... class ModelDetailView(BaseAdminDocsView): ... class TemplateDetailView(BaseAdminDocsView): ... def get_return_data_type(func_name: Any): ... def get_readable_field_data_type(field: Union[Field, str]) -> str: ... def extract_views_from_urlpatterns(urlpatterns: Any, base: str = ..., namespace: Optional[Any] = ...): ... def simplify_regex(pattern: str) -> str: ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.3943791 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/auth/0000775000175000017500000000000000000000000025245 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/auth/__init__.pyi0000664000175000017500000000244400000000000027533 0ustar00davedave00000000000000from typing import Any, List, Optional, Type, Union from django.contrib.auth.backends import ModelBackend from django.contrib.auth.base_user import AbstractBaseUser from django.contrib.auth.models import AbstractUser, AnonymousUser from django.core.handlers.wsgi import WSGIRequest from django.db.models.base import Model from django.db.models.options import Options from django.http.request import HttpRequest from .signals import ( user_logged_in as user_logged_in, user_logged_out as user_logged_out, user_login_failed as user_login_failed, ) SESSION_KEY: str BACKEND_SESSION_KEY: str HASH_SESSION_KEY: str REDIRECT_FIELD_NAME: str def load_backend(path: str) -> ModelBackend: ... def get_backends() -> List[ModelBackend]: ... def authenticate(request: Any = ..., **credentials: Any) -> Optional[AbstractBaseUser]: ... def login( request: HttpRequest, user: AbstractBaseUser, backend: Optional[Union[Type[ModelBackend], str]] = ... ) -> None: ... def logout(request: HttpRequest) -> None: ... def get_user_model() -> Type[Model]: ... def get_user(request: HttpRequest) -> Union[AbstractBaseUser, AnonymousUser]: ... def get_permission_codename(action: str, opts: Options) -> str: ... def update_session_auth_hash(request: WSGIRequest, user: AbstractUser) -> None: ... default_app_config: str ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/auth/admin.pyi0000664000175000017500000000101700000000000027057 0ustar00davedave00000000000000from typing import Any from django.core.handlers.wsgi import WSGIRequest from django.http.response import HttpResponse from django.contrib import admin csrf_protect_m: Any sensitive_post_parameters_m: Any class GroupAdmin(admin.ModelAdmin): ... class UserAdmin(admin.ModelAdmin): change_user_password_template: Any = ... add_fieldsets: Any = ... add_form: Any = ... change_password_form: Any = ... def user_change_password(self, request: WSGIRequest, id: str, form_url: str = ...) -> HttpResponse: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/auth/apps.pyi0000664000175000017500000000010400000000000026726 0ustar00davedave00000000000000from django.apps import AppConfig class AuthConfig(AppConfig): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/auth/backends.pyi0000664000175000017500000000310500000000000027541 0ustar00davedave00000000000000from typing import Any, Optional, Set, Union from django.contrib.auth.base_user import AbstractBaseUser from django.contrib.auth.models import AnonymousUser, User, Permission from django.db.models.base import Model _AnyUser = Union[Model, AnonymousUser] UserModel: Any class BaseBackend: def authenticate( self, request: Any, username: Optional[str] = ..., password: Optional[str] = ..., **kwargs: Any ) -> Optional[AbstractBaseUser]: ... def get_user(self, user_id: int) -> Optional[AbstractBaseUser]: ... def get_user_permissions(self, user_obj: _AnyUser, obj: Optional[Model] = ...) -> Set[str]: ... def get_group_permissions(self, user_obj: _AnyUser, obj: Optional[Model] = ...) -> Set[str]: ... def get_all_permissions(self, user_obj: _AnyUser, obj: Optional[Model] = ...) -> Set[str]: ... def has_perm(self, user_obj: _AnyUser, perm: str, obj: Optional[Model] = ...) -> bool: ... class ModelBackend(BaseBackend): def has_module_perms(self, user_obj: _AnyUser, app_label: str) -> bool: ... def user_can_authenticate(self, user: Optional[_AnyUser]) -> bool: ... def with_perm( self, perm: Union[str, Permission], is_active: bool = ..., include_superusers: bool = ..., obj: Optional[Model] = ..., ): ... class AllowAllUsersModelBackend(ModelBackend): ... class RemoteUserBackend(ModelBackend): create_unknown_user: bool = ... def clean_username(self, username: str) -> str: ... def configure_user(self, user: User) -> User: ... class AllowAllUsersRemoteUserBackend(RemoteUserBackend): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/auth/base_user.pyi0000664000175000017500000000272500000000000027746 0ustar00davedave00000000000000import sys from typing import Any, Optional, Tuple, List, overload, TypeVar from django.db.models.base import Model from django.db import models if sys.version_info < (3, 8): from typing_extensions import Literal else: from typing import Literal _T = TypeVar("_T", bound=Model) class BaseUserManager(models.Manager[_T]): @classmethod def normalize_email(cls, email: Optional[str]) -> str: ... def make_random_password(self, length: int = ..., allowed_chars: str = ...) -> str: ... def get_by_natural_key(self, username: Optional[str]) -> _T: ... class AbstractBaseUser(models.Model): REQUIRED_FIELDS: List[str] = ... password = models.CharField(max_length=128) last_login = models.DateTimeField(blank=True, null=True) def get_username(self) -> str: ... def natural_key(self) -> Tuple[str]: ... @property def is_anonymous(self) -> Literal[False]: ... @property def is_authenticated(self) -> Literal[True]: ... def set_password(self, raw_password: Optional[str]) -> None: ... def check_password(self, raw_password: str) -> bool: ... def set_unusable_password(self) -> None: ... def has_usable_password(self) -> bool: ... def get_session_auth_hash(self) -> str: ... @classmethod def get_email_field_name(cls) -> str: ... @classmethod @overload def normalize_username(cls, username: str) -> str: ... @classmethod @overload def normalize_username(cls, username: Any) -> Any: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/auth/checks.pyi0000664000175000017500000000056300000000000027234 0ustar00davedave00000000000000from typing import Any, List, Iterable, Optional from django.core.checks.messages import CheckMessage from django.apps.config import AppConfig def check_user_model(app_configs: Optional[Iterable[AppConfig]] = ..., **kwargs: Any) -> List[CheckMessage]: ... def check_models_permissions(app_configs: Optional[Iterable[AppConfig]] = ..., **kwargs: Any) -> List[Any]: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/auth/context_processors.pyi0000664000175000017500000000115100000000000031734 0ustar00davedave00000000000000from typing import Any, Dict from django.http.request import HttpRequest class PermLookupDict: app_label: str user: Any def __init__(self, user: Any, app_label: str) -> None: ... def __getitem__(self, perm_name: str) -> bool: ... def __iter__(self) -> Any: ... def __bool__(self) -> bool: ... class PermWrapper: user: Any = ... def __init__(self, user: Any) -> None: ... def __getitem__(self, app_label: str) -> PermLookupDict: ... def __iter__(self) -> Any: ... def __contains__(self, perm_name: Any) -> bool: ... def auth(request: HttpRequest) -> Dict[str, Any]: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/auth/decorators.pyi0000664000175000017500000000172600000000000030143 0ustar00davedave00000000000000from typing import Callable, List, Optional, Set, Union, TypeVar, overload from django.contrib.auth import REDIRECT_FIELD_NAME as REDIRECT_FIELD_NAME # noqa: F401 from django.http.response import HttpResponseBase from django.contrib.auth.models import AbstractUser _VIEW = TypeVar("_VIEW", bound=Callable[..., HttpResponseBase]) def user_passes_test( test_func: Callable[[AbstractUser], bool], login_url: Optional[str] = ..., redirect_field_name: str = ... ) -> Callable[[_VIEW], _VIEW]: ... # There are two ways of calling @login_required: @with(arguments) and @bare @overload def login_required(redirect_field_name: str = ..., login_url: Optional[str] = ...) -> Callable[[_VIEW], _VIEW]: ... @overload def login_required(function: _VIEW, redirect_field_name: str = ..., login_url: Optional[str] = ...) -> _VIEW: ... def permission_required( perm: Union[List[str], Set[str], str], login_url: None = ..., raise_exception: bool = ... ) -> Callable[[_VIEW], _VIEW]: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/auth/forms.pyi0000664000175000017500000000611500000000000027121 0ustar00davedave00000000000000from typing import Any, Dict, Iterator, Optional from django.contrib.auth.base_user import AbstractBaseUser from django.contrib.auth.models import AbstractUser, User from django.contrib.auth.tokens import PasswordResetTokenGenerator from django.core.exceptions import ValidationError from django.core.handlers.wsgi import WSGIRequest from django import forms UserModel: Any class ReadOnlyPasswordHashWidget(forms.Widget): template_name: str = ... class ReadOnlyPasswordHashField(forms.Field): def __init__(self, *args: Any, **kwargs: Any) -> None: ... class UsernameField(forms.CharField): ... class UserCreationForm(forms.ModelForm): error_messages: Any = ... password1: Any = ... password2: Any = ... def __init__(self, *args: Any, **kwargs: Any) -> None: ... def clean_password2(self) -> str: ... class UserChangeForm(forms.ModelForm): password: Any = ... def __init__(self, *args: Any, **kwargs: Any) -> None: ... def clean_password(self) -> str: ... class AuthenticationForm(forms.Form): username: Any = ... password: Any = ... error_messages: Any = ... request: WSGIRequest = ... user_cache: None = ... username_field: Any = ... def __init__(self, request: Any = ..., *args: Any, **kwargs: Any) -> None: ... def confirm_login_allowed(self, user: AbstractBaseUser) -> None: ... def get_user(self) -> User: ... def get_invalid_login_error(self) -> ValidationError: ... class PasswordResetForm(forms.Form): email: Any = ... def send_mail( self, subject_template_name: str, email_template_name: str, context: Dict[str, Any], from_email: Optional[str], to_email: str, html_email_template_name: Optional[str] = ..., ) -> None: ... def get_users(self, email: str) -> Iterator[Any]: ... def save( self, domain_override: Optional[str] = ..., subject_template_name: str = ..., email_template_name: str = ..., use_https: bool = ..., token_generator: PasswordResetTokenGenerator = ..., from_email: Optional[str] = ..., request: Optional[WSGIRequest] = ..., html_email_template_name: Optional[str] = ..., extra_email_context: Optional[Dict[str, str]] = ..., ) -> None: ... class SetPasswordForm(forms.Form): error_messages: Any = ... new_password1: Any = ... new_password2: Any = ... user: User = ... def __init__(self, user: Optional[AbstractBaseUser], *args: Any, **kwargs: Any) -> None: ... def clean_new_password2(self) -> str: ... def save(self, commit: bool = ...) -> AbstractBaseUser: ... class PasswordChangeForm(SetPasswordForm): old_password: Any = ... def clean_old_password(self) -> str: ... class AdminPasswordChangeForm(forms.Form): error_messages: Any = ... required_css_class: str = ... password1: Any = ... password2: Any = ... user: User = ... def __init__(self, user: AbstractUser, *args: Any, **kwargs: Any) -> None: ... def clean_password2(self) -> str: ... def save(self, commit: bool = ...) -> AbstractUser: ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.3943791 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/auth/handlers/0000775000175000017500000000000000000000000027045 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/auth/handlers/__init__.pyi0000664000175000017500000000000000000000000031315 0ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/auth/handlers/modwsgi.pyi0000664000175000017500000000031400000000000031237 0ustar00davedave00000000000000from typing import Any, Dict UserModel: Any def check_password(environ: Dict[Any, Any], username: str, password: str) -> Any: ... def groups_for_user(environ: Dict[Any, Any], username: str) -> Any: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/auth/hashers.pyi0000664000175000017500000000366100000000000027433 0ustar00davedave00000000000000from typing import Any, Callable, Dict, List, Optional UNUSABLE_PASSWORD_PREFIX: str UNUSABLE_PASSWORD_SUFFIX_LENGTH: int def is_password_usable(encoded: Optional[str]) -> bool: ... def check_password( password: Optional[str], encoded: str, setter: Optional[Callable] = ..., preferred: str = ... ) -> bool: ... def make_password(password: Optional[str], salt: Optional[str] = ..., hasher: str = ...) -> str: ... def get_hashers() -> List[BasePasswordHasher]: ... def get_hashers_by_algorithm() -> Dict[str, BasePasswordHasher]: ... def reset_hashers(**kwargs: Any) -> None: ... def get_hasher(algorithm: str = ...) -> BasePasswordHasher: ... def identify_hasher(encoded: str) -> BasePasswordHasher: ... def mask_hash(hash: str, show: int = ..., char: str = ...) -> str: ... class BasePasswordHasher: algorithm: str = ... library: str = ... rounds: int = ... time_cost: int = ... memory_cost: int = ... parallelism: int = ... digest: Any = ... iterations: int = ... def salt(self) -> str: ... def verify(self, password: str, encoded: str) -> bool: ... def encode(self, password: str, salt: str) -> Any: ... def safe_summary(self, encoded: str) -> Any: ... def must_update(self, encoded: str) -> bool: ... def harden_runtime(self, password: str, encoded: str) -> None: ... class PBKDF2PasswordHasher(BasePasswordHasher): def encode(self, password: str, salt: str, iterations: Optional[int] = ...) -> str: ... class PBKDF2SHA1PasswordHasher(PBKDF2PasswordHasher): ... class Argon2PasswordHasher(BasePasswordHasher): ... class BCryptSHA256PasswordHasher(BasePasswordHasher): ... class BCryptPasswordHasher(BCryptSHA256PasswordHasher): ... class SHA1PasswordHasher(BasePasswordHasher): ... class MD5PasswordHasher(BasePasswordHasher): ... class UnsaltedSHA1PasswordHasher(BasePasswordHasher): ... class UnsaltedMD5PasswordHasher(BasePasswordHasher): ... class CryptPasswordHasher(BasePasswordHasher): ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.3943791 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/auth/management/0000775000175000017500000000000000000000000027361 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/auth/management/__init__.pyi0000664000175000017500000000060000000000000031637 0ustar00davedave00000000000000from typing import Any from django.apps.config import AppConfig from django.apps.registry import Apps def create_permissions( app_config: AppConfig, verbosity: int = ..., interactive: bool = ..., using: str = ..., apps: Apps = ..., **kwargs: Any ) -> None: ... def get_system_username() -> str: ... def get_default_username(check_db: bool = ...) -> str: ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.3943791 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/auth/management/commands/0000775000175000017500000000000000000000000031162 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/auth/management/commands/__init__.pyi0000664000175000017500000000000000000000000033432 0ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000021200000000000011450 xustar0000000000000000116 path=jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/auth/management/commands/changepassword.pyi 22 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/auth/management/commands/changepasswo0000664000175000017500000000017500000000000033572 0ustar00davedave00000000000000from typing import Any from django.core.management.base import BaseCommand UserModel: Any class Command(BaseCommand): ... ././@PaxHeader0000000000000000000000000000021300000000000011451 xustar0000000000000000117 path=jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/auth/management/commands/createsuperuser.pyi 22 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/auth/management/commands/createsuperu0000664000175000017500000000032000000000000033607 0ustar00davedave00000000000000import getpass as getpass # noqa: F401 from typing import Any from django.core.management.base import BaseCommand class NotRunningInTTYException(Exception): ... class Command(BaseCommand): stdin: Any ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/auth/middleware.pyi0000664000175000017500000000140600000000000030106 0ustar00davedave00000000000000from typing import Union from django.contrib.auth.models import AnonymousUser, User from django.core.handlers.wsgi import WSGIRequest from django.http.request import HttpRequest from django.utils.deprecation import MiddlewareMixin def get_user(request: WSGIRequest) -> Union[AnonymousUser, User]: ... class AuthenticationMiddleware(MiddlewareMixin): def process_request(self, request: HttpRequest) -> None: ... class RemoteUserMiddleware(MiddlewareMixin): header: str = ... force_logout_if_no_header: bool = ... def process_request(self, request: HttpRequest) -> None: ... def clean_username(self, username: str, request: HttpRequest) -> str: ... class PersistentRemoteUserMiddleware(RemoteUserMiddleware): force_logout_if_no_header: bool = ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/auth/mixins.pyi0000664000175000017500000000217600000000000027305 0ustar00davedave00000000000000from typing import Any, Callable, List, Optional from django import http from django.http.response import HttpResponse, HttpResponseRedirect class AccessMixin: login_url: Any = ... permission_denied_message: str = ... raise_exception: bool = ... redirect_field_name: Any = ... def get_login_url(self) -> str: ... def get_permission_denied_message(self) -> str: ... def get_redirect_field_name(self) -> str: ... def handle_no_permission(self) -> HttpResponseRedirect: ... class LoginRequiredMixin(AccessMixin): def dispatch(self, request: http.HttpRequest, *args: Any, **kwargs: Any) -> HttpResponse: ... class PermissionRequiredMixin(AccessMixin): permission_required: Any = ... def get_permission_required(self) -> List[str]: ... def has_permission(self) -> bool: ... def dispatch(self, request: http.HttpRequest, *args: Any, **kwargs: Any) -> HttpResponse: ... class UserPassesTestMixin(AccessMixin): def test_func(self) -> Optional[bool]: ... def get_test_func(self) -> Callable: ... def dispatch(self, request: http.HttpRequest, *args: Any, **kwargs: Any) -> HttpResponse: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/auth/models.pyi0000664000175000017500000001104100000000000027250 0ustar00davedave00000000000000import sys from typing import Any, Collection, Optional, Set, Tuple, Type, TypeVar, Union from django.contrib.auth.backends import ModelBackend from django.contrib.auth.base_user import AbstractBaseUser as AbstractBaseUser, BaseUserManager as BaseUserManager from django.contrib.auth.validators import UnicodeUsernameValidator from django.contrib.contenttypes.models import ContentType from django.db.models.base import Model from django.db.models.manager import EmptyManager from django.db import models if sys.version_info < (3, 8): from typing_extensions import Literal else: from typing import Literal _AnyUser = Union[Model, "AnonymousUser"] def update_last_login(sender: Type[AbstractBaseUser], user: AbstractBaseUser, **kwargs: Any) -> None: ... class PermissionManager(models.Manager["Permission"]): def get_by_natural_key(self, codename: str, app_label: str, model: str) -> Permission: ... class Permission(models.Model): content_type_id: int objects: PermissionManager name = models.CharField(max_length=255) content_type = models.ForeignKey(ContentType, on_delete=models.CASCADE) codename = models.CharField(max_length=100) def natural_key(self) -> Tuple[str, str, str]: ... class GroupManager(models.Manager["Group"]): def get_by_natural_key(self, name: str) -> Group: ... class Group(models.Model): objects: GroupManager name = models.CharField(max_length=150) permissions = models.ManyToManyField(Permission) def natural_key(self): ... _T = TypeVar("_T", bound=Model) class UserManager(BaseUserManager[_T]): def create_user( self, username: str, email: Optional[str] = ..., password: Optional[str] = ..., **extra_fields: Any ) -> _T: ... def create_superuser( self, username: str, email: Optional[str], password: Optional[str], **extra_fields: Any ) -> _T: ... def with_perm( self, perm: Union[str, Permission], is_active: bool = ..., include_superusers: bool = ..., backend: Optional[Union[Type[ModelBackend], str]] = ..., obj: Optional[Model] = ..., ): ... class PermissionsMixin(models.Model): is_superuser = models.BooleanField() groups = models.ManyToManyField(Group) user_permissions = models.ManyToManyField(Permission) def get_user_permissions(self, obj: Optional[_AnyUser] = ...) -> Set[str]: ... def get_group_permissions(self, obj: Optional[_AnyUser] = ...) -> Set[str]: ... def get_all_permissions(self, obj: Optional[_AnyUser] = ...) -> Set[str]: ... def has_perm(self, perm: str, obj: Optional[_AnyUser] = ...) -> bool: ... def has_perms(self, perm_list: Collection[str], obj: Optional[_AnyUser] = ...) -> bool: ... def has_module_perms(self, app_label: str) -> bool: ... class AbstractUser(AbstractBaseUser, PermissionsMixin): # type: ignore username_validator: UnicodeUsernameValidator = ... username = models.CharField(max_length=150) first_name = models.CharField(max_length=30, blank=True) last_name = models.CharField(max_length=150, blank=True) email = models.EmailField(blank=True) is_staff = models.BooleanField() is_active = models.BooleanField() date_joined = models.DateTimeField() EMAIL_FIELD: str = ... USERNAME_FIELD: str = ... def get_full_name(self) -> str: ... def get_short_name(self) -> str: ... def email_user(self, subject: str, message: str, from_email: str = ..., **kwargs: Any) -> None: ... class User(AbstractUser): ... class AnonymousUser: id: Any = ... pk: Any = ... username: str = ... is_staff: bool = ... is_active: bool = ... is_superuser: bool = ... def save(self) -> Any: ... def delete(self) -> Any: ... def set_password(self, raw_password: str) -> Any: ... def check_password(self, raw_password: str) -> Any: ... @property def groups(self) -> EmptyManager: ... @property def user_permissions(self) -> EmptyManager: ... def get_user_permissions(self, obj: Optional[_AnyUser] = ...) -> Set[str]: ... def get_group_permissions(self, obj: Optional[_AnyUser] = ...) -> Set[Any]: ... def get_all_permissions(self, obj: Optional[_AnyUser] = ...) -> Set[str]: ... def has_perm(self, perm: str, obj: Optional[_AnyUser] = ...) -> bool: ... def has_perms(self, perm_list: Collection[str], obj: Optional[_AnyUser] = ...) -> bool: ... def has_module_perms(self, module: str) -> bool: ... @property def is_anonymous(self) -> Literal[True]: ... @property def is_authenticated(self) -> Literal[False]: ... def get_username(self) -> str: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/auth/password_validation.pyi0000664000175000017500000000400400000000000032042 0ustar00davedave00000000000000from pathlib import Path, PosixPath from typing import Any, List, Mapping, Optional, Protocol, Sequence, Set, Union from django.db.models.base import Model _UserModel = Model class PasswordValidator(Protocol): def password_changed(self, password: str, user: Optional[_UserModel] = ...): ... def get_default_password_validators() -> List[PasswordValidator]: ... def get_password_validators(validator_config: Sequence[Mapping[str, Any]]) -> List[PasswordValidator]: ... def validate_password( password: str, user: Optional[_UserModel] = ..., password_validators: Optional[Sequence[PasswordValidator]] = ... ) -> None: ... def password_changed( password: str, user: Optional[_UserModel] = ..., password_validators: Optional[Sequence[PasswordValidator]] = ... ) -> None: ... def password_validators_help_texts(password_validators: Optional[Sequence[PasswordValidator]] = ...) -> List[str]: ... password_validators_help_text_html: Any class MinimumLengthValidator: min_length: int = ... def __init__(self, min_length: int = ...) -> None: ... def validate(self, password: str, user: Optional[_UserModel] = ...) -> None: ... def get_help_text(self) -> str: ... class UserAttributeSimilarityValidator: DEFAULT_USER_ATTRIBUTES: Sequence[str] = ... user_attributes: Sequence[str] = ... max_similarity: float = ... def __init__(self, user_attributes: Sequence[str] = ..., max_similarity: float = ...) -> None: ... def validate(self, password: str, user: Optional[_UserModel] = ...) -> None: ... def get_help_text(self) -> str: ... class CommonPasswordValidator: DEFAULT_PASSWORD_LIST_PATH: Path = ... passwords: Set[str] = ... def __init__(self, password_list_path: Union[PosixPath, str] = ...) -> None: ... def validate(self, password: str, user: Optional[_UserModel] = ...) -> None: ... def get_help_text(self) -> str: ... class NumericPasswordValidator: def validate(self, password: str, user: Optional[_UserModel] = ...) -> None: ... def get_help_text(self) -> str: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/auth/signals.pyi0000664000175000017500000000017000000000000027426 0ustar00davedave00000000000000from django.dispatch.dispatcher import Signal user_logged_in: Signal user_login_failed: Signal user_logged_out: Signal ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/auth/tokens.pyi0000664000175000017500000000055100000000000027274 0ustar00davedave00000000000000from typing import Any, Optional from django.contrib.auth.base_user import AbstractBaseUser class PasswordResetTokenGenerator: key_salt: str = ... secret: Any = ... def make_token(self, user: AbstractBaseUser) -> str: ... def check_token(self, user: Optional[AbstractBaseUser], token: Optional[str]) -> bool: ... default_token_generator: Any ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/auth/urls.pyi0000664000175000017500000000007300000000000026755 0ustar00davedave00000000000000from typing import Any, List urlpatterns: List[Any] = ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/auth/validators.pyi0000664000175000017500000000024000000000000030134 0ustar00davedave00000000000000from django.core import validators class ASCIIUsernameValidator(validators.RegexValidator): ... class UnicodeUsernameValidator(validators.RegexValidator): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/auth/views.pyi0000664000175000017500000000465600000000000027140 0ustar00davedave00000000000000from typing import Any, Optional, Set from django.contrib.auth.base_user import AbstractBaseUser from django.core.handlers.wsgi import WSGIRequest from django.http.request import HttpRequest from django.http.response import HttpResponseRedirect from django.template.response import TemplateResponse from django.views.generic.base import TemplateView from django.views.generic.edit import FormView UserModel: Any class SuccessURLAllowedHostsMixin: success_url_allowed_hosts: Any = ... def get_success_url_allowed_hosts(self) -> Set[str]: ... class LoginView(SuccessURLAllowedHostsMixin, FormView): authentication_form: Any = ... redirect_field_name: Any = ... redirect_authenticated_user: bool = ... extra_context: Any = ... def get_redirect_url(self) -> str: ... class LogoutView(SuccessURLAllowedHostsMixin, TemplateView): next_page: Any = ... redirect_field_name: Any = ... extra_context: Any = ... def post(self, request: WSGIRequest, *args: Any, **kwargs: Any) -> TemplateResponse: ... def get_next_page(self) -> Optional[str]: ... def logout_then_login(request: HttpRequest, login_url: Optional[str] = ...) -> HttpResponseRedirect: ... def redirect_to_login( next: str, login_url: Optional[str] = ..., redirect_field_name: Optional[str] = ... ) -> HttpResponseRedirect: ... class PasswordContextMixin: extra_context: Any = ... def get_context_data(self, **kwargs: Any): ... class PasswordResetView(PasswordContextMixin, FormView): email_template_name: str = ... extra_email_context: Any = ... from_email: Any = ... html_email_template_name: Any = ... subject_template_name: str = ... title: Any = ... token_generator: Any = ... INTERNAL_RESET_URL_TOKEN: str INTERNAL_RESET_SESSION_TOKEN: str class PasswordResetDoneView(PasswordContextMixin, TemplateView): title: Any = ... class PasswordResetConfirmView(PasswordContextMixin, FormView): post_reset_login: bool = ... post_reset_login_backend: Any = ... reset_url_token: str = ... title: Any = ... token_generator: Any = ... validlink: bool = ... user: Any = ... def get_user(self, uidb64: str) -> Optional[AbstractBaseUser]: ... class PasswordResetCompleteView(PasswordContextMixin, TemplateView): title: Any = ... class PasswordChangeView(PasswordContextMixin, FormView): title: Any = ... class PasswordChangeDoneView(PasswordContextMixin, TemplateView): title: Any = ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.3943791 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/contenttypes/0000775000175000017500000000000000000000000027043 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/contenttypes/__init__.pyi0000664000175000017500000000000000000000000031313 0ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/contenttypes/admin.pyi0000664000175000017500000000111200000000000030651 0ustar00davedave00000000000000from typing import Any, List, Type from django.contrib.admin.options import InlineModelAdmin from django.db.models.base import Model class GenericInlineModelAdminChecks: def _check_exclude_of_parent_model(self, obj: GenericInlineModelAdmin, parent_model: Type[Model]) -> List[Any]: ... def _check_relation(self, obj: GenericInlineModelAdmin, parent_model: Type[Model]) -> List[Any]: ... class GenericInlineModelAdmin(InlineModelAdmin): template: str = ... class GenericStackedInline(GenericInlineModelAdmin): ... class GenericTabularInline(GenericInlineModelAdmin): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/contenttypes/apps.pyi0000664000175000017500000000011400000000000030525 0ustar00davedave00000000000000from django.apps import AppConfig class ContentTypesConfig(AppConfig): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/contenttypes/checks.pyi0000664000175000017500000000047600000000000031035 0ustar00davedave00000000000000from typing import Any, List, Iterable, Optional from django.apps.config import AppConfig def check_generic_foreign_keys(app_configs: Optional[Iterable[AppConfig]] = ..., **kwargs: Any) -> List[Any]: ... def check_model_name_lengths(app_configs: Optional[Iterable[AppConfig]] = ..., **kwargs: Any) -> List[Any]: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/contenttypes/fields.pyi0000664000175000017500000001000100000000000031024 0ustar00davedave00000000000000from typing import Any, Callable, Dict, List, Optional, Tuple, Type, Union from django.contrib.contenttypes.models import ContentType from django.core.checks.messages import Error from django.db.models.base import Model from django.db.models.expressions import Combinable from django.db.models.fields.mixins import FieldCacheMixin from django.db.models.fields.related import ForeignObject from django.db.models.fields.related_descriptors import ReverseManyToOneDescriptor from django.db.models.fields.reverse_related import ForeignObjectRel from django.db.models.query import QuerySet from django.db.models.query_utils import FilteredRelation, PathInfo from django.db.models.sql.where import WhereNode from django.db.models.fields import Field, PositiveIntegerField class GenericForeignKey(FieldCacheMixin): # django-stubs implementation only fields _pyi_private_set_type: Union[Any, Combinable] _pyi_private_get_type: Any # attributes auto_created: bool = ... concrete: bool = ... editable: bool = ... hidden: bool = ... is_relation: bool = ... many_to_many: bool = ... many_to_one: bool = ... one_to_many: bool = ... one_to_one: bool = ... related_model: Any = ... remote_field: Any = ... ct_field: str = ... fk_field: str = ... for_concrete_model: bool = ... rel: None = ... column: None = ... def __init__(self, ct_field: str = ..., fk_field: str = ..., for_concrete_model: bool = ...) -> None: ... name: Any = ... model: Any = ... def contribute_to_class(self, cls: Type[Model], name: str, **kwargs: Any) -> None: ... def get_filter_kwargs_for_object(self, obj: Model) -> Dict[str, Optional[ContentType]]: ... def get_forward_related_filter(self, obj: Model) -> Dict[str, int]: ... def check(self, **kwargs: Any) -> List[Error]: ... def get_cache_name(self) -> str: ... def get_content_type( self, obj: Optional[Model] = ..., id: Optional[int] = ..., using: Optional[str] = ... ) -> ContentType: ... def get_prefetch_queryset( self, instances: Union[List[Model], QuerySet], queryset: Optional[QuerySet] = ... ) -> Tuple[List[Model], Callable, Callable, bool, str, bool]: ... def __get__(self, instance: Optional[Model], cls: Type[Model] = ...) -> Optional[Any]: ... def __set__(self, instance: Model, value: Optional[Any]) -> None: ... class GenericRel(ForeignObjectRel): field: GenericRelation def __init__( self, field: GenericRelation, to: Union[Type[Model], str], related_name: Optional[str] = ..., related_query_name: Optional[str] = ..., limit_choices_to: Optional[Union[Dict[str, Any], Callable[[], Any]]] = ..., ) -> None: ... class GenericRelation(ForeignObject): rel_class: Any = ... mti_inherited: bool = ... object_id_field_name: Any = ... content_type_field_name: Any = ... for_concrete_model: Any = ... to_fields: Any = ... def __init__( self, to: Union[Type[Model], str], object_id_field: str = ..., content_type_field: str = ..., for_concrete_model: bool = ..., related_query_name: Optional[str] = ..., limit_choices_to: Optional[Union[Dict[str, Any], Callable[[], Any]]] = ..., **kwargs: Any ) -> None: ... def resolve_related_fields(self) -> List[Tuple[PositiveIntegerField, Field]]: ... def get_path_info(self, filtered_relation: Optional[FilteredRelation] = ...) -> List[PathInfo]: ... def get_reverse_path_info(self, filtered_relation: None = ...) -> List[PathInfo]: ... def value_to_string(self, obj: Model) -> str: ... def get_content_type(self) -> ContentType: ... def get_extra_restriction( self, where_class: Type[WhereNode], alias: Optional[str], remote_alias: str ) -> WhereNode: ... def bulk_related_objects(self, objs: List[Model], using: str = ...) -> QuerySet: ... class ReverseGenericManyToOneDescriptor(ReverseManyToOneDescriptor): ... def create_generic_related_manager(superclass: Any, rel: Any): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/contenttypes/forms.pyi0000664000175000017500000000220700000000000030715 0ustar00davedave00000000000000from typing import Any, Optional from django.forms.models import BaseModelFormSet class BaseGenericInlineFormSet(BaseModelFormSet): instance: Any = ... rel_name: Any = ... save_as_new: Any = ... def __init__( self, data: Optional[Any] = ..., files: Optional[Any] = ..., instance: Optional[Any] = ..., save_as_new: bool = ..., prefix: Optional[Any] = ..., queryset: Optional[Any] = ..., **kwargs: Any ) -> None: ... def initial_form_count(self): ... @classmethod def get_default_prefix(cls): ... def save_new(self, form: Any, commit: bool = ...): ... def generic_inlineformset_factory( model: Any, form: Any = ..., formset: Any = ..., ct_field: str = ..., fk_field: str = ..., fields: Optional[Any] = ..., exclude: Optional[Any] = ..., extra: int = ..., can_order: bool = ..., can_delete: bool = ..., max_num: Optional[Any] = ..., formfield_callback: Optional[Any] = ..., validate_max: bool = ..., for_concrete_model: bool = ..., min_num: Optional[Any] = ..., validate_min: bool = ..., ): ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.3943791 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/contenttypes/management/0000775000175000017500000000000000000000000031157 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/contenttypes/management/__init__.pyi0000664000175000017500000000250600000000000033444 0ustar00davedave00000000000000from typing import Any, Dict, List, Optional, Tuple, Type from django.apps.config import AppConfig from django.apps.registry import Apps from django.contrib.contenttypes.models import ContentType from django.db import migrations from django.db.backends.sqlite3.schema import DatabaseSchemaEditor from django.db.migrations.migration import Migration from django.db.migrations.state import StateApps from django.db.models.base import Model class RenameContentType(migrations.RunPython): app_label: Any = ... old_model: Any = ... new_model: Any = ... def __init__(self, app_label: str, old_model: str, new_model: str) -> None: ... def rename_forward(self, apps: StateApps, schema_editor: DatabaseSchemaEditor) -> None: ... def rename_backward(self, apps: StateApps, schema_editor: DatabaseSchemaEditor) -> None: ... def inject_rename_contenttypes_operations( plan: List[Tuple[Migration, bool]] = ..., apps: StateApps = ..., using: str = ..., **kwargs: Any ) -> None: ... def get_contenttypes_and_models( app_config: AppConfig, using: str, ContentType: Type[ContentType] ) -> Tuple[Dict[str, ContentType], Dict[str, Type[Model]]]: ... def create_contenttypes( app_config: AppConfig, verbosity: int = ..., interactive: bool = ..., using: str = ..., apps: Apps = ..., **kwargs: Any ) -> None: ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.3943791 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/contenttypes/management/commands/0000775000175000017500000000000000000000000032760 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000021400000000000011452 xustar0000000000000000118 path=jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/contenttypes/management/commands/__init__.pyi 22 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/contenttypes/management/commands/__in0000664000175000017500000000000000000000000033575 0ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000023500000000000011455 xustar0000000000000000135 path=jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/contenttypes/management/commands/remove_stale_contenttypes.pyi 22 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/contenttypes/management/commands/remo0000664000175000017500000000063300000000000033647 0ustar00davedave00000000000000from typing import Any, Dict, List from django.db.models.deletion import Collector from django.core.management import BaseCommand class Command(BaseCommand): ... class NoFastDeleteCollector(Collector): data: Dict[str, Any] dependencies: Dict[Any, Any] fast_deletes: List[Any] field_updates: Dict[Any, Any] using: str def can_fast_delete(self, *args: Any, **kwargs: Any) -> bool: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/contenttypes/models.pyi0000664000175000017500000000207500000000000031055 0ustar00davedave00000000000000from typing import Any, Dict, Optional, Tuple, Type, Union from django.db import models from django.db.models.base import Model from django.db.models.query import QuerySet class ContentTypeManager(models.Manager["ContentType"]): def get_by_natural_key(self, app_label: str, model: str) -> ContentType: ... def get_for_model(self, model: Union[Type[Model], Model], for_concrete_model: bool = ...) -> ContentType: ... def get_for_models(self, *models: Any, for_concrete_models: bool = ...) -> Dict[Type[Model], ContentType]: ... def get_for_id(self, id: int) -> ContentType: ... def clear_cache(self) -> None: ... class ContentType(models.Model): id: int app_label: models.CharField = ... model: models.CharField = ... objects: ContentTypeManager = ... @property def name(self) -> str: ... def model_class(self) -> Optional[Type[Model]]: ... def get_object_for_this_type(self, **kwargs: Any) -> Model: ... def get_all_objects_for_this_type(self, **kwargs: Any) -> QuerySet: ... def natural_key(self) -> Tuple[str, str]: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/contenttypes/views.pyi0000664000175000017500000000040100000000000030716 0ustar00davedave00000000000000from typing import Union from django.http.request import HttpRequest from django.http.response import HttpResponseRedirect def shortcut( request: HttpRequest, content_type_id: Union[int, str], object_id: Union[int, str] ) -> HttpResponseRedirect: ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.3943791 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/flatpages/0000775000175000017500000000000000000000000026252 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/flatpages/__init__.pyi0000664000175000017500000000000000000000000030522 0ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/flatpages/forms.pyi0000664000175000017500000000021600000000000030122 0ustar00davedave00000000000000from typing import Any from django import forms class FlatpageForm(forms.ModelForm): url: Any = ... def clean_url(self) -> str: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/flatpages/middleware.pyi0000664000175000017500000000045300000000000031114 0ustar00davedave00000000000000from django.core.handlers.wsgi import WSGIRequest from django.http.response import HttpResponse from django.utils.deprecation import MiddlewareMixin class FlatpageFallbackMiddleware(MiddlewareMixin): def process_response(self, request: WSGIRequest, response: HttpResponse) -> HttpResponse: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/flatpages/models.pyi0000664000175000017500000000067500000000000030270 0ustar00davedave00000000000000from django.contrib.sites.models import Site from django.db import models class FlatPage(models.Model): url: models.CharField = ... title: models.CharField = ... content: models.TextField = ... enable_comments: models.BooleanField = ... template_name: models.CharField = ... registration_required: models.BooleanField = ... sites: models.ManyToManyField[Site, Site] = ... def get_absolute_url(self) -> str: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/flatpages/sitemaps.pyi0000664000175000017500000000012100000000000030614 0ustar00davedave00000000000000from django.contrib.sitemaps import Sitemap class FlatPageSitemap(Sitemap): ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.3943791 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/flatpages/templatetags/0000775000175000017500000000000000000000000030744 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/flatpages/templatetags/__init__.pyi0000664000175000017500000000000000000000000033214 0ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/flatpages/templatetags/flatpages.pyi0000664000175000017500000000100600000000000033432 0ustar00davedave00000000000000from typing import Any, Optional from django import template from django.template.base import Parser, Token from django.template.context import Context register: Any class FlatpageNode(template.Node): context_name: str = ... starts_with: None = ... user: None = ... def __init__(self, context_name: str, starts_with: Optional[str] = ..., user: Optional[str] = ...) -> None: ... def render(self, context: Context) -> str: ... def get_flatpages(parser: Parser, token: Token) -> FlatpageNode: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/flatpages/urls.pyi0000664000175000017500000000007300000000000027762 0ustar00davedave00000000000000from typing import Any, List urlpatterns: List[Any] = ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/flatpages/views.pyi0000664000175000017500000000047300000000000030136 0ustar00davedave00000000000000from django.contrib.flatpages.models import FlatPage from django.core.handlers.wsgi import WSGIRequest from django.http.response import HttpResponse DEFAULT_TEMPLATE: str def flatpage(request: WSGIRequest, url: str) -> HttpResponse: ... def render_flatpage(request: WSGIRequest, f: FlatPage) -> HttpResponse: ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.3943791 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/gis/0000775000175000017500000000000000000000000025066 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/gis/__init__.pyi0000664000175000017500000000000000000000000027336 0ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.3943791 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/gis/db/0000775000175000017500000000000000000000000025453 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/gis/db/__init__.pyi0000664000175000017500000000000000000000000027723 0ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.3943791 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/gis/db/models/0000775000175000017500000000000000000000000026736 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/gis/db/models/__init__.pyi0000664000175000017500000000064200000000000031222 0ustar00davedave00000000000000from django.db.models import * from .fields import ( GeometryField as GeometryField, LineStringField as LineStringField, MultiLineStringField as MultiLineStringField, MultiPointField as MultiPointField, MultiPolygonField as MultiPolygonField, PointField as PointField, PolygonField as PolygonField, GeometryCollectionField as GeometryCollectionField, RasterField as RasterField, ) ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/gis/db/models/fields.pyi0000664000175000017500000000607500000000000030737 0ustar00davedave00000000000000from typing import Any, Iterable, NamedTuple, Optional, TypeVar, Union, Tuple from django.db.models.fields import Field, _ErrorMessagesToOverride, _FieldChoices, _ValidatorCallable _Connection = Any # __set__ value type _ST = TypeVar("_ST") # __get__ return type _GT = TypeVar("_GT") class SRIDCacheEntry(NamedTuple): units: Any units_name: str geodetic: bool spheroid: str def get_srid_info(srid: int, connection: _Connection) -> SRIDCacheEntry: ... class BaseSpatialField(Field[_ST, _GT]): def __init__( self, verbose_name: Optional[Union[str, bytes]] = ..., srid: int = ..., spatial_index: bool = ..., name: Optional[str] = ..., primary_key: bool = ..., max_length: Optional[int] = ..., unique: bool = ..., blank: bool = ..., null: bool = ..., db_index: bool = ..., default: Any = ..., editable: bool = ..., auto_created: bool = ..., serialize: bool = ..., unique_for_date: Optional[str] = ..., unique_for_month: Optional[str] = ..., unique_for_year: Optional[str] = ..., choices: Optional[_FieldChoices] = ..., help_text: str = ..., db_column: Optional[str] = ..., db_tablespace: Optional[str] = ..., validators: Iterable[_ValidatorCallable] = ..., error_messages: Optional[_ErrorMessagesToOverride] = ..., ): ... def spheroid(self, connection: _Connection) -> str: ... def units(self, connection: _Connection) -> Any: ... def units_name(self, connection: _Connection) -> str: ... def geodetic(self, connection: _Connection) -> bool: ... class GeometryField(BaseSpatialField): def __init__( self, verbose_name: Optional[Union[str, bytes]] = ..., dim: int = ..., geography: bool = ..., extent: Tuple[float, float, float, float] = ..., tolerance: float = ..., srid: int = ..., spatial_index: bool = ..., name: Optional[str] = ..., primary_key: bool = ..., max_length: Optional[int] = ..., unique: bool = ..., blank: bool = ..., null: bool = ..., db_index: bool = ..., default: Any = ..., editable: bool = ..., auto_created: bool = ..., serialize: bool = ..., unique_for_date: Optional[str] = ..., unique_for_month: Optional[str] = ..., unique_for_year: Optional[str] = ..., choices: Optional[_FieldChoices] = ..., help_text: str = ..., db_column: Optional[str] = ..., db_tablespace: Optional[str] = ..., validators: Iterable[_ValidatorCallable] = ..., error_messages: Optional[_ErrorMessagesToOverride] = ..., ): ... class PointField(GeometryField): ... class LineStringField(GeometryField): ... class PolygonField(GeometryField): ... class MultiPointField(GeometryField): ... class MultiLineStringField(GeometryField): ... class MultiPolygonField(GeometryField): ... class GeometryCollectionField(GeometryField): ... class RasterField(BaseSpatialField): ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.3943791 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/humanize/0000775000175000017500000000000000000000000026124 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/humanize/__init__.pyi0000664000175000017500000000000000000000000030374 0ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.3943791 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/humanize/templatetags/0000775000175000017500000000000000000000000030616 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/humanize/templatetags/__init__.pyi0000664000175000017500000000000000000000000033066 0ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/humanize/templatetags/humanize.pyi0000664000175000017500000000115300000000000033161 0ustar00davedave00000000000000from datetime import date, datetime as datetime from typing import Any, Optional, SupportsInt, Union register: Any def ordinal(value: Optional[Union[str, SupportsInt]]) -> Optional[str]: ... def intcomma(value: Optional[Union[str, SupportsInt]], use_l10n: bool = ...) -> str: ... intword_converters: Any def intword(value: Optional[Union[str, SupportsInt]]) -> Optional[Union[int, str]]: ... def apnumber(value: Optional[Union[str, SupportsInt]]) -> Optional[Union[int, str]]: ... def naturalday(value: Optional[Union[date, str]], arg: None = ...) -> Optional[str]: ... def naturaltime(value: datetime) -> str: ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.3943791 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/messages/0000775000175000017500000000000000000000000026113 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/messages/__init__.pyi0000664000175000017500000000101400000000000030371 0ustar00davedave00000000000000from .api import ( get_level as get_level, set_level as set_level, add_message as add_message, debug as debug, error as error, success as success, get_messages as get_messages, MessageFailure as MessageFailure, info as info, warning as warning, ) from .constants import ( DEBUG as DEBUG, DEFAULT_LEVELS as DEFAULT_LEVELS, DEFAULT_TAGS as DEFAULT_TAGS, ERROR as ERROR, INFO as INFO, SUCCESS as SUCCESS, WARNING as WARNING, ) default_app_config: str = ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/messages/api.pyi0000664000175000017500000000222100000000000027404 0ustar00davedave00000000000000from typing import Any, List, Optional, Union from django.contrib.messages.storage.base import BaseStorage from django.http.request import HttpRequest class MessageFailure(Exception): ... def add_message( request: Optional[HttpRequest], level: int, message: str, extra_tags: str = ..., fail_silently: Union[bool, str] = ..., ) -> None: ... def get_messages(request: HttpRequest) -> Union[List[Any], BaseStorage]: ... def get_level(request: HttpRequest) -> int: ... def set_level(request: HttpRequest, level: int) -> bool: ... def debug(request: HttpRequest, message: str, extra_tags: str = ..., fail_silently: Union[bool, str] = ...) -> None: ... def info(request: HttpRequest, message: str, extra_tags: str = ..., fail_silently: Union[bool, str] = ...) -> None: ... def success( request: HttpRequest, message: str, extra_tags: str = ..., fail_silently: Union[bool, str] = ... ) -> None: ... def warning( request: HttpRequest, message: str, extra_tags: str = ..., fail_silently: Union[bool, str] = ... ) -> None: ... def error(request: HttpRequest, message: str, extra_tags: str = ..., fail_silently: Union[bool, str] = ...) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/messages/constants.pyi0000664000175000017500000000027300000000000030654 0ustar00davedave00000000000000from typing import Dict DEBUG: int = ... INFO: int = ... SUCCESS: int = ... WARNING: int = ... ERROR: int = ... DEFAULT_TAGS: Dict[int, str] = ... DEFAULT_LEVELS: Dict[str, int] = ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/messages/context_processors.pyi0000664000175000017500000000037100000000000032605 0ustar00davedave00000000000000from typing import Any, Dict, List, Union from django.contrib.messages.storage.base import BaseStorage from django.http.request import HttpRequest def messages(request: HttpRequest) -> Dict[str, Union[Dict[str, int], List[Any], BaseStorage]]: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/messages/middleware.pyi0000664000175000017500000000053500000000000030756 0ustar00davedave00000000000000from django.http.request import HttpRequest from django.http.response import HttpResponse from django.utils.deprecation import MiddlewareMixin class MessageMiddleware(MiddlewareMixin): def process_request(self, request: HttpRequest) -> None: ... def process_response(self, request: HttpRequest, response: HttpResponse) -> HttpResponse: ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.3943791 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/messages/storage/0000775000175000017500000000000000000000000027557 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/messages/storage/__init__.pyi0000664000175000017500000000031200000000000032035 0ustar00davedave00000000000000from typing import Any, Optional from django.contrib.messages.storage.base import BaseStorage from django.http.request import HttpRequest def default_storage(request: HttpRequest) -> BaseStorage: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/messages/storage/base.pyi0000664000175000017500000000161300000000000031215 0ustar00davedave00000000000000from typing import Any, List, Optional from django.http.request import HttpRequest from django.http.response import HttpResponseBase LEVEL_TAGS: Any class Message: level: int = ... message: str = ... extra_tags: str = ... def __init__(self, level: int, message: str, extra_tags: Optional[str] = ...) -> None: ... @property def tags(self) -> str: ... @property def level_tag(self) -> str: ... class BaseStorage: request: HttpRequest = ... used: bool = ... added_new: bool = ... def __init__(self, request: HttpRequest, *args: Any, **kwargs: Any) -> None: ... def __len__(self) -> int: ... def __iter__(self): ... def __contains__(self, item: Any): ... def update(self, response: HttpResponseBase) -> Optional[List[Message]]: ... def add(self, level: int, message: str, extra_tags: Optional[str] = ...) -> None: ... level: Any = ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/messages/storage/cookie.pyi0000664000175000017500000000074700000000000031563 0ustar00davedave00000000000000import json from typing import Any from django.contrib.messages.storage.base import BaseStorage class MessageEncoder(json.JSONEncoder): allow_nan: bool check_circular: bool ensure_ascii: bool skipkeys: bool sort_keys: bool message_key: str = ... class MessageDecoder(json.JSONDecoder): def process_messages(self, obj: Any) -> Any: ... class CookieStorage(BaseStorage): cookie_name: str = ... max_cookie_size: int = ... not_finished: str = ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/messages/storage/fallback.pyi0000664000175000017500000000036000000000000032040 0ustar00davedave00000000000000from typing import Any from django.contrib.messages.storage.base import BaseStorage class FallbackStorage(BaseStorage): storage_classes: Any = ... storages: Any = ... def __init__(self, *args: Any, **kwargs: Any) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/messages/storage/session.pyi0000664000175000017500000000074200000000000031770 0ustar00davedave00000000000000from typing import Any, List, Optional, Sequence, Union from django.contrib.messages.storage.base import BaseStorage from django.http.request import HttpRequest class SessionStorage(BaseStorage): session_key: str = ... def __init__(self, request: HttpRequest, *args: Any, **kwargs: Any) -> None: ... def serialize_messages(self, messages: Sequence[Any]) -> str: ... def deserialize_messages(self, data: Optional[Union[List[Any], str]]) -> Optional[List[Any]]: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/messages/utils.pyi0000664000175000017500000000010500000000000027772 0ustar00davedave00000000000000from typing import Dict def get_level_tags() -> Dict[int, str]: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/messages/views.pyi0000664000175000017500000000046400000000000027777 0ustar00davedave00000000000000from typing import Dict from django.forms.forms import BaseForm from django.http.response import HttpResponse class SuccessMessageMixin: success_message: str = ... def form_valid(self, form: BaseForm) -> HttpResponse: ... def get_success_message(self, cleaned_data: Dict[str, str]) -> str: ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.3943791 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/postgres/0000775000175000017500000000000000000000000026152 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/postgres/__init__.pyi0000664000175000017500000000000000000000000030422 0ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.3943791 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/postgres/aggregates/0000775000175000017500000000000000000000000030263 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/postgres/aggregates/__init__.pyi0000664000175000017500000000103400000000000032543 0ustar00davedave00000000000000from .general import ( ArrayAgg as ArrayAgg, BitAnd as BitAnd, BitOr as BitOr, BoolAnd as BoolAnd, BoolOr as BoolOr, JSONBAgg as JSONBAgg, StringAgg as StringAgg, ) from .statistics import ( Corr as Corr, CovarPop as CovarPop, RegrAvgX as RegrAvgX, RegrAvgY as RegrAvgY, RegrCount as RegrCount, RegrIntercept as RegrIntercept, RegrR2 as RegrR2, RegrSlope as RegrSlope, RegrSXX as RegrSXX, RegrSXY as RegrSXY, RegrSYY as RegrSYY, StatAggregate as StatAggregate, ) ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/postgres/aggregates/general.pyi0000664000175000017500000000052200000000000032422 0ustar00davedave00000000000000from django.db.models.aggregates import Aggregate from .mixins import OrderableAggMixin class ArrayAgg(OrderableAggMixin, Aggregate): ... class BitAnd(Aggregate): ... class BitOr(Aggregate): ... class BoolAnd(Aggregate): ... class BoolOr(Aggregate): ... class JSONBAgg(Aggregate): ... class StringAgg(OrderableAggMixin, Aggregate): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/postgres/aggregates/mixins.pyi0000664000175000017500000000003500000000000032313 0ustar00davedave00000000000000class OrderableAggMixin: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/postgres/aggregates/statistics.pyi0000664000175000017500000000072600000000000033205 0ustar00davedave00000000000000from django.db.models.aggregates import Aggregate class StatAggregate(Aggregate): ... class Corr(StatAggregate): ... class CovarPop(StatAggregate): ... class RegrAvgX(StatAggregate): ... class RegrAvgY(StatAggregate): ... class RegrCount(StatAggregate): ... class RegrIntercept(StatAggregate): ... class RegrR2(StatAggregate): ... class RegrSlope(StatAggregate): ... class RegrSXX(StatAggregate): ... class RegrSXY(StatAggregate): ... class RegrSYY(StatAggregate): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/postgres/constraints.pyi0000664000175000017500000000110000000000000031234 0ustar00davedave00000000000000from typing import Optional, Sequence, Tuple, Union from django.db.models.constraints import BaseConstraint from django.db.models.expressions import Combinable from django.db.models.query_utils import Q class ExclusionConstraint(BaseConstraint): expressions: Sequence[Tuple[Union[str, Combinable], str]] index_type: str condition: Optional[Q] def __init__( self, *, name: str, expressions: Sequence[Tuple[Union[str, Combinable], str]], condition: Optional[Q] = ..., index_type: Optional[str] = ..., ): ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.3983793 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/postgres/fields/0000775000175000017500000000000000000000000027420 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/postgres/fields/__init__.pyi0000664000175000017500000000126700000000000031710 0ustar00davedave00000000000000from .array import ArrayField as ArrayField from .jsonb import JSONField as JSONField, JsonAdapter as JsonAdapter from .ranges import ( RangeField as RangeField, IntegerRangeField as IntegerRangeField, BigIntegerRangeField as BigIntegerRangeField, DecimalRangeField as DecimalRangeField, FloatRangeField as FloatRangeField, DateRangeField as DateRangeField, DateTimeRangeField as DateTimeRangeField, RangeOperators as RangeOperators, RangeBoundary as RangeBoundary, ) from .hstore import HStoreField as HStoreField from .citext import ( CICharField as CICharField, CIEmailField as CIEmailField, CIText as CIText, CITextField as CITextField, ) ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/postgres/fields/array.pyi0000664000175000017500000000330100000000000031256 0ustar00davedave00000000000000from typing import Any, Iterable, List, Optional, Sequence, TypeVar, Union from django.db.models.expressions import Combinable from django.db.models.fields import Field, _ErrorMessagesToOverride, _FieldChoices, _ValidatorCallable from .mixins import CheckFieldDefaultMixin # __set__ value type _ST = TypeVar("_ST") # __get__ return type _GT = TypeVar("_GT") class ArrayField(CheckFieldDefaultMixin, Field[_ST, _GT]): _pyi_private_set_type: Union[Sequence[Any], Combinable] _pyi_private_get_type: List[Any] empty_strings_allowed: bool = ... default_error_messages: Any = ... base_field: Any = ... size: Any = ... default_validators: Any = ... from_db_value: Any = ... def __init__( self, base_field: Field, size: Optional[int] = ..., verbose_name: Optional[Union[str, bytes]] = ..., name: Optional[str] = ..., primary_key: bool = ..., max_length: Optional[int] = ..., unique: bool = ..., blank: bool = ..., null: bool = ..., db_index: bool = ..., default: Any = ..., editable: bool = ..., auto_created: bool = ..., serialize: bool = ..., unique_for_date: Optional[str] = ..., unique_for_month: Optional[str] = ..., unique_for_year: Optional[str] = ..., choices: Optional[_FieldChoices] = ..., help_text: str = ..., db_column: Optional[str] = ..., db_tablespace: Optional[str] = ..., validators: Iterable[_ValidatorCallable] = ..., error_messages: Optional[_ErrorMessagesToOverride] = ..., ) -> None: ... @property def description(self): ... def get_transform(self, name: Any): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/postgres/fields/citext.pyi0000664000175000017500000000033000000000000031437 0ustar00davedave00000000000000from django.db.models.fields import CharField, EmailField, TextField class CIText: ... class CICharField(CIText, CharField): ... class CIEmailField(CIText, EmailField): ... class CITextField(CIText, TextField): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/postgres/fields/hstore.pyi0000664000175000017500000000100700000000000031445 0ustar00davedave00000000000000from typing import Any from django.db.models import Field, Transform from .mixins import CheckFieldDefaultMixin class HStoreField(CheckFieldDefaultMixin, Field): def get_transform(self, name) -> Any: ... class KeyTransform(Transform): def __init__(self, key_name: str, *args: Any, **kwargs: Any): ... class KeyTransformFactory: def __init__(self, key_name: str): ... def __call__(self, *args, **kwargs) -> KeyTransform: ... class KeysTransform(Transform): ... class ValuesTransform(Transform): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/postgres/fields/jsonb.pyi0000664000175000017500000000176300000000000031265 0ustar00davedave00000000000000from json import JSONEncoder from typing import Any, Optional, Type from django.db.models import Field from django.db.models.lookups import Transform from .mixins import CheckFieldDefaultMixin class JsonAdapter: encoder: Any = ... def __init__(self, adapted: Any, dumps: Optional[Any] = ..., encoder: Optional[Any] = ...) -> None: ... def dumps(self, obj: Any): ... class JSONField(CheckFieldDefaultMixin, Field): empty_strings_allowed: bool = ... description: Any = ... default_error_messages: Any = ... encoder: Any = ... def __init__( self, verbose_name: Optional[str] = ..., name: Optional[str] = ..., encoder: Optional[Type[JSONEncoder]] = ..., **kwargs: Any ) -> None: ... def value_to_string(self, obj: Any): ... class KeyTransform(Transform): operator: str = ... nested_operator: str = ... def __init__(self, key_name: str, *args: Any, **kwargs: Any) -> None: ... class KeyTextTransform(KeyTransform): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/postgres/fields/mixins.pyi0000664000175000017500000000016100000000000031450 0ustar00davedave00000000000000from typing import Any, List class CheckFieldDefaultMixin: def check(self, **kwargs: Any) -> List[Any]: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/postgres/fields/ranges.pyi0000664000175000017500000000247600000000000031433 0ustar00davedave00000000000000from typing import Any from django.db import models from psycopg2.extras import DateRange, DateTimeTZRange, NumericRange # type: ignore class RangeField(models.Field): empty_strings_allowed: bool = ... base_field: Any = ... range_type: Any = ... def get_prep_value(self, value: Any): ... def to_python(self, value: Any): ... def value_to_string(self, obj: Any): ... class IntegerRangeField(RangeField): def __get__(self, instance, owner) -> NumericRange: ... class BigIntegerRangeField(RangeField): def __get__(self, instance, owner) -> NumericRange: ... class DecimalRangeField(RangeField): def __get__(self, instance, owner) -> NumericRange: ... class FloatRangeField(RangeField): def __get__(self, instance, owner) -> NumericRange: ... class DateTimeRangeField(RangeField): def __get__(self, instance, owner) -> DateTimeTZRange: ... class DateRangeField(RangeField): def __get__(self, instance, owner) -> DateRange: ... class RangeOperators: EQUAL: str NOT_EQUAL: str CONTAINS: str CONTAINED_BY: str OVERLAPS: str FULLY_LT: str FULLY_GT: str NOT_LT: str NOT_GT: str ADJACENT_TO: str class RangeBoundary(models.Expression): lower: str upper: str def __init__(self, inclusive_lower: bool = ..., inclusive_upper: bool = ...): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/postgres/functions.pyi0000664000175000017500000000013700000000000030706 0ustar00davedave00000000000000from django.db.models import Func class RandomUUID(Func): ... class TransactionNow(Func): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/postgres/indexes.pyi0000664000175000017500000000434000000000000030335 0ustar00davedave00000000000000from typing import Optional, Sequence from django.db.models.query_utils import Q from django.db.models import Index class PostgresIndex(Index): ... class BrinIndex(PostgresIndex): def __init__( self, *, autosummarize: Optional[bool] = ..., pages_per_range: Optional[int] = ..., fields: Sequence[str] = ..., name: Optional[str] = ..., db_tablespace: Optional[str] = ..., opclasses: Sequence[str] = ..., condition: Optional[Q] = ... ) -> None: ... class BTreeIndex(PostgresIndex): def __init__( self, *, fillfactor: Optional[int] = ..., fields: Sequence[str] = ..., name: Optional[str] = ..., db_tablespace: Optional[str] = ..., opclasses: Sequence[str] = ..., condition: Optional[Q] = ... ) -> None: ... class GinIndex(PostgresIndex): def __init__( self, *, fastupdate: Optional[bool] = ..., gin_pending_list_limit: Optional[int] = ..., fields: Sequence[str] = ..., name: Optional[str] = ..., db_tablespace: Optional[str] = ..., opclasses: Sequence[str] = ..., condition: Optional[Q] = ... ) -> None: ... class GistIndex(PostgresIndex): def __init__( self, *, buffering: Optional[bool] = ..., fillfactor: Optional[int] = ..., fields: Sequence[str] = ..., name: Optional[str] = ..., db_tablespace: Optional[str] = ..., opclasses: Sequence[str] = ..., condition: Optional[Q] = ... ) -> None: ... class HashIndex(PostgresIndex): def __init__( self, *, fillfactor: Optional[int] = ..., fields: Sequence[str] = ..., name: Optional[str] = ..., db_tablespace: Optional[str] = ..., opclasses: Sequence[str] = ..., condition: Optional[Q] = ... ) -> None: ... class SpGistIndex(PostgresIndex): def __init__( self, *, fillfactor: Optional[int] = ..., fields: Sequence[str] = ..., name: Optional[str] = ..., db_tablespace: Optional[str] = ..., opclasses: Sequence[str] = ..., condition: Optional[Q] = ... ) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/postgres/lookups.pyi0000664000175000017500000000110300000000000030364 0ustar00davedave00000000000000from django.db.models.lookups import Exact from django.db.models import Lookup, Transform from .search import SearchVectorExact class PostgresSimpleLookup(Lookup): operator: str class DataContains(PostgresSimpleLookup): ... class ContainedBy(PostgresSimpleLookup): ... class Overlap(PostgresSimpleLookup): ... class HasKey(PostgresSimpleLookup): ... class HasKeys(PostgresSimpleLookup): ... class HasAnyKeys(HasKeys): ... class Unaccent(Transform): ... class SearchLookup(SearchVectorExact): ... class TrigramSimilar(PostgresSimpleLookup): ... class JSONExact(Exact): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/postgres/operations.pyi0000664000175000017500000000133700000000000031064 0ustar00davedave00000000000000from django.db.migrations.operations.base import Operation class CreateExtension(Operation): reversible: bool = ... name: str = ... def __init__(self, name: str) -> None: ... class BtreeGinExtension(CreateExtension): def __init__(self) -> None: ... class BtreeGistExtension(CreateExtension): def __init__(self) -> None: ... class CITextExtension(CreateExtension): def __init__(self) -> None: ... class CryptoExtension(CreateExtension): def __init__(self) -> None: ... class HStoreExtension(CreateExtension): def __init__(self) -> None: ... class TrigramExtension(CreateExtension): def __init__(self) -> None: ... class UnaccentExtension(CreateExtension): def __init__(self) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/postgres/search.pyi0000664000175000017500000000422300000000000030143 0ustar00davedave00000000000000from typing import Any, Dict, Optional, TypeVar, Union from django.db.models.expressions import Combinable, CombinedExpression, Func, Value, _OutputField from django.db.models.lookups import Lookup from django.db.models import Field _Expression = Union[str, Combinable, "SearchQueryCombinable"] class SearchVectorExact(Lookup): ... class SearchVectorField(Field): ... class SearchQueryField(Field): ... class SearchVectorCombinable: ADD: str = ... class SearchVector(SearchVectorCombinable, Func): config: Optional[Any] = ... def __init__(self, *expressions: _Expression, **extra: Any): ... class CombinedSearchVector(SearchVectorCombinable, CombinedExpression): def __init__( self, lhs, connector, rhs, config: Optional[_Expression] = ..., output_field: Optional[_OutputField] = ... ): ... _T = TypeVar("_T", bound="SearchQueryCombinable") class SearchQueryCombinable: BITAND: str = ... BITOR: str = ... def __or__(self: _T, other: SearchQueryCombinable) -> _T: ... def __ror__(self: _T, other: SearchQueryCombinable) -> _T: ... def __and__(self: _T, other: SearchQueryCombinable) -> _T: ... def __rand__(self: _T, other: SearchQueryCombinable) -> _T: ... class SearchQuery(SearchQueryCombinable, Value): # type: ignore SEARCH_TYPES: Dict[str, str] = ... def __init__( self, value: str, output_field: Optional[_OutputField] = ..., *, config: Optional[_Expression] = ..., invert: bool = ..., search_type: str = ... ): ... def __invert__(self: _T) -> _T: ... class CombinedSearchQuery(SearchQueryCombinable, CombinedExpression): # type: ignore def __init__( self, lhs, connector, rhs, config: Optional[_Expression] = ..., output_field: Optional[_OutputField] = ... ) -> None: ... class SearchRank(Func): def __init__( self, vector: Union[SearchVector, _Expression], query: Union[SearchQuery, _Expression], **extra: Any ) -> None: ... class TrigramBase(Func): def __init__(self, expression: _Expression, string, **extra: Any) -> None: ... class TrigramSimilarity(TrigramBase): ... class TrigramDistance(TrigramBase): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/postgres/signals.pyi0000664000175000017500000000035500000000000030340 0ustar00davedave00000000000000from typing import Any, Tuple def get_hstore_oids(connection_alias: str) -> Tuple[Any, ...]: ... def get_citext_oids(connection_alias: str) -> Tuple[Any, ...]: ... def register_type_handlers(connection: Any, **kwargs: Any) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/postgres/validators.pyi0000664000175000017500000000121500000000000031044 0ustar00davedave00000000000000from typing import Any, Dict, Iterable, Mapping, Optional from django.core.validators import MaxLengthValidator, MaxValueValidator, MinLengthValidator, MinValueValidator class ArrayMaxLengthValidator(MaxLengthValidator): ... class ArrayMinLengthValidator(MinLengthValidator): ... class KeysValidator: messages: Dict[str, str] = ... strict: bool = ... def __init__( self, keys: Iterable[str], strict: bool = ..., messages: Optional[Mapping[str, str]] = ... ) -> None: ... def __call__(self, value: Any) -> None: ... class RangeMaxValueValidator(MaxValueValidator): ... class RangeMinValueValidator(MinValueValidator): ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.3983793 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/redirects/0000775000175000017500000000000000000000000026270 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/redirects/__init__.pyi0000664000175000017500000000000000000000000030540 0ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/redirects/middleware.pyi0000664000175000017500000000060700000000000031133 0ustar00davedave00000000000000from typing import Any from django.http.request import HttpRequest from django.http.response import HttpResponse from django.utils.deprecation import MiddlewareMixin class RedirectFallbackMiddleware(MiddlewareMixin): response_gone_class: Any = ... response_redirect_class: Any = ... def process_response(self, request: HttpRequest, response: HttpResponse) -> HttpResponse: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/redirects/models.pyi0000664000175000017500000000025000000000000030273 0ustar00davedave00000000000000from django.db import models class Redirect(models.Model): site: models.ForeignKey = ... old_path: models.CharField = ... new_path: models.CharField = ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.3983793 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/sessions/0000775000175000017500000000000000000000000026152 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/sessions/__init__.pyi0000664000175000017500000000000000000000000030422 0ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.3983793 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/sessions/backends/0000775000175000017500000000000000000000000027724 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/sessions/backends/__init__.pyi0000664000175000017500000000000000000000000032174 0ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/sessions/backends/base.pyi0000664000175000017500000000276700000000000031375 0ustar00davedave00000000000000from datetime import datetime from typing import Any, Dict, Optional, Union VALID_KEY_CHARS: Any class CreateError(Exception): ... class UpdateError(Exception): ... class SessionBase(Dict[str, Any]): TEST_COOKIE_NAME: str = ... TEST_COOKIE_VALUE: str = ... accessed: bool = ... modified: bool = ... serializer: Any = ... def __init__(self, session_key: Optional[str] = ...) -> None: ... def set_test_cookie(self) -> None: ... def test_cookie_worked(self) -> bool: ... def delete_test_cookie(self) -> None: ... def encode(self, session_dict: Dict[str, Any]) -> str: ... def decode(self, session_data: Union[bytes, str]) -> Dict[str, Any]: ... def has_key(self, key: Any): ... def keys(self): ... def values(self): ... def items(self): ... def clear(self) -> None: ... def is_empty(self) -> bool: ... session_key: Any = ... def get_expiry_age(self, **kwargs: Any) -> int: ... def get_expiry_date(self, **kwargs: Any) -> datetime: ... def set_expiry(self, value: Optional[Union[datetime, int]]) -> None: ... def get_expire_at_browser_close(self) -> bool: ... def flush(self) -> None: ... def cycle_key(self) -> None: ... def exists(self, session_key: str) -> bool: ... def create(self) -> None: ... def save(self, must_create: bool = ...) -> None: ... def delete(self, session_key: Optional[Any] = ...) -> None: ... def load(self) -> Dict[str, Any]: ... @classmethod def clear_expired(cls) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/sessions/backends/cache.pyi0000664000175000017500000000045300000000000031514 0ustar00davedave00000000000000from typing import Any, Optional from django.contrib.sessions.backends.base import SessionBase KEY_PREFIX: str class SessionStore(SessionBase): cache_key_prefix: Any = ... def __init__(self, session_key: Optional[str] = ...) -> None: ... @property def cache_key(self) -> str: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/sessions/backends/cached_db.pyi0000664000175000017500000000046100000000000032324 0ustar00davedave00000000000000from typing import Any, Optional from django.contrib.sessions.backends.db import SessionStore as DBStore KEY_PREFIX: str class SessionStore(DBStore): cache_key_prefix: Any = ... def __init__(self, session_key: Optional[str] = ...) -> None: ... @property def cache_key(self) -> str: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/sessions/backends/db.pyi0000664000175000017500000000110100000000000031025 0ustar00davedave00000000000000from typing import Dict, Optional, Type from django.contrib.sessions.backends.base import SessionBase from django.contrib.sessions.base_session import AbstractBaseSession from django.contrib.sessions.models import Session from django.db.models.base import Model class SessionStore(SessionBase): def __init__(self, session_key: Optional[str] = ...) -> None: ... @classmethod def get_model_class(cls) -> Type[Session]: ... def model(self) -> Type[AbstractBaseSession]: ... def create_model_instance(self, data: Dict[str, Model]) -> AbstractBaseSession: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/sessions/backends/file.pyi0000664000175000017500000000043300000000000031366 0ustar00davedave00000000000000from typing import Optional from django.contrib.sessions.backends.base import SessionBase class SessionStore(SessionBase): storage_path: str = ... file_prefix: str = ... def __init__(self, session_key: Optional[str] = ...) -> None: ... def clean(self) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/sessions/backends/signed_cookies.pyi0000664000175000017500000000014400000000000033433 0ustar00davedave00000000000000from django.contrib.sessions.backends.base import SessionBase class SessionStore(SessionBase): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/sessions/base_session.pyi0000664000175000017500000000123100000000000031347 0ustar00davedave00000000000000from datetime import datetime from typing import Any, Dict, Optional, Type from django.contrib.sessions.backends.base import SessionBase from django.db import models class BaseSessionManager(models.Manager): def encode(self, session_dict: Dict[str, int]) -> str: ... def save(self, session_key: str, session_dict: Dict[str, int], expire_date: datetime) -> AbstractBaseSession: ... class AbstractBaseSession(models.Model): expire_date: datetime session_data: str session_key: str objects: Any = ... @classmethod def get_session_store_class(cls) -> Optional[Type[SessionBase]]: ... def get_decoded(self) -> Dict[str, int]: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/sessions/exceptions.pyi0000664000175000017500000000023400000000000031055 0ustar00davedave00000000000000from django.core.exceptions import SuspiciousOperation class InvalidSessionKey(SuspiciousOperation): ... class SuspiciousSession(SuspiciousOperation): ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.3983793 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/sessions/management/0000775000175000017500000000000000000000000030266 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/sessions/management/__init__.pyi0000664000175000017500000000000000000000000032536 0ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.3983793 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/sessions/management/commands/0000775000175000017500000000000000000000000032067 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000021000000000000011446 xustar0000000000000000114 path=jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/sessions/management/commands/__init__.pyi 22 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/sessions/management/commands/__init__0000664000175000017500000000000000000000000033537 0ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000021500000000000011453 xustar0000000000000000119 path=jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/sessions/management/commands/clearsessions.pyi 22 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/sessions/management/commands/clearses0000664000175000017500000000012500000000000033611 0ustar00davedave00000000000000from django.core.management.base import BaseCommand class Command(BaseCommand): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/sessions/middleware.pyi0000664000175000017500000000073600000000000031020 0ustar00davedave00000000000000from typing import Type from django.contrib.sessions.backends.base import SessionBase from django.http.request import HttpRequest from django.http.response import HttpResponse from django.utils.deprecation import MiddlewareMixin class SessionMiddleware(MiddlewareMixin): SessionStore: Type[SessionBase] = ... def process_request(self, request: HttpRequest) -> None: ... def process_response(self, request: HttpRequest, response: HttpResponse) -> HttpResponse: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/sessions/models.pyi0000664000175000017500000000026000000000000030156 0ustar00davedave00000000000000from django.contrib.sessions.base_session import AbstractBaseSession, BaseSessionManager class SessionManager(BaseSessionManager): ... class Session(AbstractBaseSession): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/sessions/serializers.pyi0000664000175000017500000000046700000000000031240 0ustar00davedave00000000000000from typing import Dict from django.core.signing import JSONSerializer as BaseJSONSerializer from django.db.models.base import Model class PickleSerializer: def dumps(self, obj: Dict[str, Model]) -> bytes: ... def loads(self, data: bytes) -> Dict[str, Model]: ... JSONSerializer = BaseJSONSerializer ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.3983793 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/sitemaps/0000775000175000017500000000000000000000000026131 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/sitemaps/__init__.pyi0000664000175000017500000000302700000000000030415 0ustar00davedave00000000000000from datetime import datetime from typing import Any, Dict, List, Optional, Union, Protocol from django.contrib.sites.models import Site from django.contrib.sites.requests import RequestSite from django.core.paginator import Paginator from django.db.models.base import Model from django.db.models.query import QuerySet PING_URL: str class SitemapNotFound(Exception): ... def ping_google(sitemap_url: Optional[str] = ..., ping_url: str = ...) -> None: ... class _SupportsLen(Protocol): def __len__(self) -> int: ... class _SupportsCount(Protocol): def count(self) -> int: ... class _SupportsOrdered(Protocol): ordered: bool = ... class Sitemap: limit: int = ... protocol: Optional[str] = ... def items(self) -> Union[_SupportsLen, _SupportsCount, _SupportsOrdered]: ... def location(self, obj: Model) -> str: ... @property def paginator(self) -> Paginator: ... def get_urls( self, page: Union[int, str] = ..., site: Optional[Union[Site, RequestSite]] = ..., protocol: Optional[str] = ... ) -> List[Dict[str, Any]]: ... class GenericSitemap(Sitemap): priority: Optional[float] = ... changefreq: Optional[str] = ... queryset: QuerySet = ... date_field: None = ... def __init__( self, info_dict: Dict[str, Union[datetime, QuerySet, str]], priority: Optional[float] = ..., changefreq: Optional[str] = ..., protocol: Optional[str] = ..., ) -> None: ... def lastmod(self, item: Model) -> Optional[datetime]: ... default_app_config: str ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.3983793 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/sitemaps/management/0000775000175000017500000000000000000000000030245 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/sitemaps/management/__init__.pyi0000664000175000017500000000000000000000000032515 0ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.3983793 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/sitemaps/management/commands/0000775000175000017500000000000000000000000032046 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000021000000000000011446 xustar0000000000000000114 path=jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/sitemaps/management/commands/__init__.pyi 22 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/sitemaps/management/commands/__init__0000664000175000017500000000000000000000000033516 0ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000021300000000000011451 xustar0000000000000000117 path=jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/sitemaps/management/commands/ping_google.pyi 22 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/sitemaps/management/commands/ping_goo0000664000175000017500000000012500000000000033570 0ustar00davedave00000000000000from django.core.management.base import BaseCommand class Command(BaseCommand): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/sitemaps/views.pyi0000664000175000017500000000137200000000000030014 0ustar00davedave00000000000000from collections import OrderedDict from typing import Callable, Dict, Optional, Type, Union from django.http.request import HttpRequest from django.template.response import TemplateResponse from django.contrib.sitemaps import GenericSitemap, Sitemap def x_robots_tag(func: Callable) -> Callable: ... def index( request: HttpRequest, sitemaps: Dict[str, Union[Type[Sitemap], Sitemap]], template_name: str = ..., content_type: str = ..., sitemap_url_name: str = ..., ) -> TemplateResponse: ... def sitemap( request: HttpRequest, sitemaps: Union[Dict[str, Type[Sitemap]], Dict[str, GenericSitemap], OrderedDict], section: Optional[str] = ..., template_name: str = ..., content_type: str = ..., ) -> TemplateResponse: ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.3983793 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/sites/0000775000175000017500000000000000000000000025433 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/sites/__init__.pyi0000664000175000017500000000000000000000000027703 0ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/sites/apps.pyi0000664000175000017500000000010500000000000027115 0ustar00davedave00000000000000from django.apps import AppConfig class SitesConfig(AppConfig): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/sites/management.pyi0000664000175000017500000000044000000000000030270 0ustar00davedave00000000000000from typing import Any from django.apps.config import AppConfig from django.apps.registry import Apps def create_default_site( app_config: AppConfig, verbosity: int = ..., interactive: bool = ..., using: str = ..., apps: Apps = ..., **kwargs: Any ) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/sites/managers.pyi0000664000175000017500000000025200000000000027752 0ustar00davedave00000000000000from typing import Optional from django.db import models class CurrentSiteManager(models.Manager): def __init__(self, field_name: Optional[str] = ...) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/sites/middleware.pyi0000664000175000017500000000032100000000000030267 0ustar00davedave00000000000000from django.http.request import HttpRequest from django.utils.deprecation import MiddlewareMixin class CurrentSiteMiddleware(MiddlewareMixin): def process_request(self, request: HttpRequest) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/sites/models.pyi0000664000175000017500000000114600000000000027443 0ustar00davedave00000000000000from typing import Any, Optional, Tuple, Type from django.http.request import HttpRequest from django.db import models SITE_CACHE: Any class SiteManager(models.Manager["Site"]): def get_current(self, request: Optional[HttpRequest] = ...) -> Site: ... def clear_cache(self) -> None: ... def get_by_natural_key(self, domain: str) -> Site: ... class Site(models.Model): objects: SiteManager domain = models.CharField(max_length=100) name = models.CharField(max_length=50) def natural_key(self) -> Tuple[str]: ... def clear_site_cache(sender: Type[Site], **kwargs: Any) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/sites/requests.pyi0000664000175000017500000000045200000000000030032 0ustar00davedave00000000000000from typing import Any from django.http.request import HttpRequest class RequestSite: name: str domain: str = ... def __init__(self, request: HttpRequest) -> None: ... def save(self, force_insert: bool = ..., force_update: bool = ...) -> Any: ... def delete(self) -> Any: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/sites/shortcuts.pyi0000664000175000017500000000041200000000000030211 0ustar00davedave00000000000000from typing import Optional, Union from django.contrib.sites.models import Site from django.contrib.sites.requests import RequestSite from django.http.request import HttpRequest def get_current_site(request: Optional[HttpRequest]) -> Union[Site, RequestSite]: ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.3983793 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/staticfiles/0000775000175000017500000000000000000000000026616 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/staticfiles/__init__.pyi0000664000175000017500000000000000000000000031066 0ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/staticfiles/apps.pyi0000664000175000017500000000017600000000000030310 0ustar00davedave00000000000000from typing import Any from django.apps import AppConfig class StaticFilesConfig(AppConfig): ignore_patterns: Any = ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/staticfiles/checks.pyi0000664000175000017500000000036200000000000030602 0ustar00davedave00000000000000from typing import Any, List, Iterable, Optional from django.core.checks.messages import Error from django.apps.config import AppConfig def check_finders(app_configs: Optional[Iterable[AppConfig]] = ..., **kwargs: Any) -> List[Error]: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/staticfiles/finders.pyi0000664000175000017500000000326300000000000030777 0ustar00davedave00000000000000from typing import Any, Iterable, Iterator, List, Mapping, Optional, Union, overload from django.core.checks.messages import Error from django.core.files.storage import Storage from typing_extensions import Literal searched_locations: Any class BaseFinder: def check(self, **kwargs: Any) -> List[Error]: ... def find(self, path: str, all: bool = ...) -> Optional[Any]: ... def list(self, ignore_patterns: Any) -> Iterable[Any]: ... class FileSystemFinder(BaseFinder): locations: List[Any] = ... storages: Mapping[str, Any] = ... def __init__(self, app_names: None = ..., *args: Any, **kwargs: Any) -> None: ... def find_location(self, root: str, path: str, prefix: str = ...) -> Optional[str]: ... class AppDirectoriesFinder(BaseFinder): storage_class: Any = ... source_dir: str = ... apps: List[str] = ... storages: Mapping[str, Any] = ... def __init__(self, app_names: None = ..., *args: Any, **kwargs: Any) -> None: ... def find_in_app(self, app: str, path: str) -> Optional[str]: ... class BaseStorageFinder(BaseFinder): storage: Storage = ... def __init__(self, storage: Optional[Storage] = ..., *args: Any, **kwargs: Any) -> None: ... class DefaultStorageFinder(BaseStorageFinder): ... def find(path: str, all: bool = ...) -> Optional[Union[List[str], str]]: ... def get_finders() -> Iterator[BaseFinder]: ... @overload def get_finder(import_path: Literal["django.contrib.staticfiles.finders.FileSystemFinder"]) -> FileSystemFinder: ... @overload def get_finder( import_path: Literal["django.contrib.staticfiles.finders.AppDirectoriesFinder"], ) -> AppDirectoriesFinder: ... @overload def get_finder(import_path: str) -> BaseFinder: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/staticfiles/handlers.pyi0000664000175000017500000000064100000000000031142 0ustar00davedave00000000000000from typing import Any from django.core.handlers.wsgi import WSGIHandler, WSGIRequest class StaticFilesHandler(WSGIHandler): handles_files: bool = ... application: WSGIHandler = ... base_url: Any = ... def __init__(self, application: WSGIHandler) -> None: ... def get_base_url(self) -> str: ... def file_path(self, url: str) -> str: ... def serve(self, request: WSGIRequest) -> Any: ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.3983793 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/staticfiles/management/0000775000175000017500000000000000000000000030732 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/staticfiles/management/__init__.pyi0000664000175000017500000000000000000000000033202 0ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.3983793 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/staticfiles/management/commands/0000775000175000017500000000000000000000000032533 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000021300000000000011451 xustar0000000000000000117 path=jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/staticfiles/management/commands/__init__.pyi 22 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/staticfiles/management/commands/__ini0000664000175000017500000000000000000000000033521 0ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000022000000000000011447 xustar0000000000000000122 path=jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/staticfiles/management/commands/collectstatic.pyi 22 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/staticfiles/management/commands/colle0000664000175000017500000000214500000000000033556 0ustar00davedave00000000000000from typing import Any, Dict, List from django.core.files.storage import Storage from django.core.management.base import BaseCommand class Command(BaseCommand): copied_files: Any = ... symlinked_files: Any = ... unmodified_files: Any = ... post_processed_files: Any = ... storage: Any = ... def __init__(self, *args: Any, **kwargs: Any) -> None: ... def local(self) -> bool: ... interactive: Any = ... verbosity: Any = ... symlink: Any = ... clear: Any = ... dry_run: Any = ... ignore_patterns: Any = ... post_process: Any = ... def set_options(self, **options: Any) -> None: ... def collect(self) -> Dict[str, List[str]]: ... def log(self, msg: str, level: int = ...) -> None: ... def is_local_storage(self) -> bool: ... def clear_dir(self, path: str) -> None: ... def delete_file(self, path: str, prefixed_path: str, source_storage: Storage) -> bool: ... def link_file(self, path: str, prefixed_path: str, source_storage: Storage) -> None: ... def copy_file(self, path: str, prefixed_path: str, source_storage: Storage) -> None: ... ././@PaxHeader0000000000000000000000000000021500000000000011453 xustar0000000000000000119 path=jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/staticfiles/management/commands/findstatic.pyi 22 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/staticfiles/management/commands/finds0000664000175000017500000000012700000000000033561 0ustar00davedave00000000000000from django.core.management.base import LabelCommand class Command(LabelCommand): ... ././@PaxHeader0000000000000000000000000000021400000000000011452 xustar0000000000000000118 path=jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/staticfiles/management/commands/runserver.pyi 22 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/staticfiles/management/commands/runse0000664000175000017500000000021000000000000033603 0ustar00davedave00000000000000from django.core.management.commands.runserver import Command as RunserverCommand # type: ignore class Command(RunserverCommand): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/staticfiles/storage.pyi0000664000175000017500000000432600000000000031012 0ustar00davedave00000000000000from collections import OrderedDict from typing import Any, Callable, Iterator, Optional, Tuple from django.core.files.base import File from django.core.files.storage import FileSystemStorage from django.utils.functional import LazyObject class StaticFilesStorage(FileSystemStorage): base_location: Any = ... location: Any = ... def __init__(self, location: Optional[str] = ..., base_url: None = ..., *args: Any, **kwargs: Any) -> None: ... def path(self, name: str) -> str: ... class HashedFilesMixin: default_template: str = ... max_post_process_passes: int = ... patterns: Any = ... hashed_files: Any = ... def __init__(self, *args: Any, **kwargs: Any) -> None: ... def file_hash(self, name: str, content: File = ...) -> str: ... def hashed_name(self, name: str, content: Optional[File] = ..., filename: Optional[str] = ...) -> str: ... def url_converter(self, name: str, hashed_files: OrderedDict, template: str = ...) -> Callable: ... def post_process( self, paths: OrderedDict, dry_run: bool = ..., **options: Any ) -> Iterator[Tuple[str, str, bool]]: ... def clean_name(self, name: str) -> str: ... def hash_key(self, name: str) -> str: ... def stored_name(self, name: str) -> str: ... class ManifestFilesMixin(HashedFilesMixin): manifest_version: str = ... manifest_name: str = ... manifest_strict: bool = ... def __init__(self, *args: Any, **kwargs: Any) -> None: ... def read_manifest(self) -> Any: ... def load_manifest(self) -> OrderedDict: ... def save_manifest(self) -> None: ... class _MappingCache: cache: Any = ... def __init__(self, cache: Any) -> None: ... def __setitem__(self, key: Any, value: Any) -> None: ... def __getitem__(self, key: Any): ... def clear(self) -> None: ... def update(self, data: Any) -> None: ... def get(self, key: Any, default: Optional[Any] = ...): ... class CachedFilesMixin(HashedFilesMixin): def __init__(self, *args: Any, **kwargs: Any) -> None: ... class CachedStaticFilesStorage(CachedFilesMixin, StaticFilesStorage): ... class ManifestStaticFilesStorage(ManifestFilesMixin, StaticFilesStorage): ... class ConfiguredStorage(LazyObject): ... staticfiles_storage: Any ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.3983793 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/staticfiles/templatetags/0000775000175000017500000000000000000000000031310 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/staticfiles/templatetags/__init__.pyi0000664000175000017500000000000000000000000033560 0ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000020700000000000011454 xustar0000000000000000113 path=jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/staticfiles/templatetags/staticfiles.pyi 22 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/staticfiles/templatetags/staticfiles.0000664000175000017500000000035200000000000033623 0ustar00davedave00000000000000from typing import Any from django.template.base import Parser, Token from django.templatetags.static import StaticNode register: Any def static(path: str) -> str: ... def do_static(parser: Parser, token: Token) -> StaticNode: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/staticfiles/testing.pyi0000664000175000017500000000014400000000000031015 0ustar00davedave00000000000000from django.test import LiveServerTestCase class StaticLiveServerTestCase(LiveServerTestCase): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/staticfiles/urls.pyi0000664000175000017500000000030600000000000030325 0ustar00davedave00000000000000from typing import Any, List, Optional from django.urls.resolvers import URLPattern urlpatterns: List[Any] = ... def staticfiles_urlpatterns(prefix: Optional[str] = ...) -> List[URLPattern]: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/staticfiles/utils.pyi0000664000175000017500000000066600000000000030511 0ustar00davedave00000000000000from collections import OrderedDict from typing import Iterator, List, Optional, Tuple, Union from django.core.files.storage import FileSystemStorage def matches_patterns(path: str, patterns: Union[List[str], Tuple[str], OrderedDict] = ...) -> bool: ... def get_files(storage: FileSystemStorage, ignore_patterns: List[str] = ..., location: str = ...) -> Iterator[str]: ... def check_settings(base_url: Optional[str] = ...) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/staticfiles/views.pyi0000664000175000017500000000033600000000000030500 0ustar00davedave00000000000000from typing import Any from django.core.handlers.wsgi import WSGIRequest from django.http.response import FileResponse def serve(request: WSGIRequest, path: str, insecure: bool = ..., **kwargs: Any) -> FileResponse: ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.3983793 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/syndication/0000775000175000017500000000000000000000000026630 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/syndication/__init__.pyi0000664000175000017500000000000000000000000031100 0ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/contrib/syndication/views.pyi0000664000175000017500000000234300000000000030512 0ustar00davedave00000000000000from typing import Any, Dict, List from django.core.exceptions import ObjectDoesNotExist from django.core.handlers.wsgi import WSGIRequest from django.db.models.base import Model from django.http.response import HttpResponse from django.utils.feedgenerator import Enclosure, SyndicationFeed from django.utils.safestring import SafeText def add_domain(domain: str, url: str, secure: bool = ...) -> str: ... class FeedDoesNotExist(ObjectDoesNotExist): ... class Feed: feed_type: Any = ... title_template: Any = ... description_template: Any = ... def __call__(self, request: WSGIRequest, *args: Any, **kwargs: Any) -> HttpResponse: ... def item_title(self, item: Model) -> SafeText: ... def item_description(self, item: Model) -> str: ... def item_link(self, item: Model) -> str: ... def item_enclosures(self, item: Model) -> List[Enclosure]: ... def feed_extra_kwargs(self, obj: None) -> Dict[Any, Any]: ... def item_extra_kwargs(self, item: Model) -> Dict[Any, Any]: ... def get_object(self, request: WSGIRequest, *args: Any, **kwargs: Any) -> None: ... def get_context_data(self, **kwargs: Any) -> Dict[str, Any]: ... def get_feed(self, obj: None, request: WSGIRequest) -> SyndicationFeed: ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.3983793 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/core/0000775000175000017500000000000000000000000023574 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/core/__init__.pyi0000664000175000017500000000000000000000000026044 0ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.3983793 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/core/cache/0000775000175000017500000000000000000000000024637 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/core/cache/__init__.pyi0000664000175000017500000000131500000000000027121 0ustar00davedave00000000000000from collections import OrderedDict from typing import Any, Callable, Dict, Union from .backends.base import ( BaseCache as BaseCache, CacheKeyWarning as CacheKeyWarning, InvalidCacheBackendError as InvalidCacheBackendError, ) DEFAULT_CACHE_ALIAS: str class CacheHandler: def __init__(self) -> None: ... def __getitem__(self, alias: str) -> BaseCache: ... def all(self): ... class DefaultCacheProxy: def __getattr__(self, name: str) -> Union[Callable, Dict[str, float], OrderedDict, int]: ... def __setattr__(self, name: str, value: Callable) -> None: ... def __delattr__(self, name: Any): ... def __contains__(self, key: str) -> bool: ... cache: Any caches: CacheHandler ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.3983793 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/core/cache/backends/0000775000175000017500000000000000000000000026411 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/core/cache/backends/__init__.pyi0000664000175000017500000000000000000000000030661 0ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/core/cache/backends/base.pyi0000664000175000017500000000442700000000000030055 0ustar00davedave00000000000000from typing import Any, Callable, Dict, Iterable, List, Optional, Union from django.core.exceptions import ImproperlyConfigured class InvalidCacheBackendError(ImproperlyConfigured): ... class CacheKeyWarning(RuntimeWarning): ... DEFAULT_TIMEOUT: Any MEMCACHE_MAX_KEY_LENGTH: int def default_key_func(key: Any, key_prefix: str, version: Any) -> str: ... def get_key_func(key_func: Optional[Union[Callable, str]]) -> Callable: ... class BaseCache: default_timeout: int = ... key_prefix: str = ... version: int = ... key_func: Callable = ... def __init__(self, params: Dict[str, Any]) -> None: ... def get_backend_timeout(self, timeout: Any = ...) -> Optional[float]: ... def make_key(self, key: Any, version: Optional[Any] = ...) -> str: ... def add(self, key: Any, value: Any, timeout: Any = ..., version: Optional[Any] = ...) -> bool: ... def get(self, key: Any, default: Optional[Any] = ..., version: Optional[Any] = ...) -> Any: ... def set(self, key: Any, value: Any, timeout: Any = ..., version: Optional[Any] = ...) -> None: ... def touch(self, key: Any, timeout: Any = ..., version: Optional[Any] = ...) -> bool: ... def delete(self, key: Any, version: Optional[Any] = ...) -> None: ... def get_many(self, keys: List[str], version: Optional[int] = ...) -> Dict[str, Union[int, str]]: ... def get_or_set( self, key: Any, default: Optional[Any], timeout: Any = ..., version: Optional[int] = ... ) -> Optional[Any]: ... def has_key(self, key: Any, version: Optional[Any] = ...) -> bool: ... def incr(self, key: str, delta: int = ..., version: Optional[int] = ...) -> int: ... def decr(self, key: str, delta: int = ..., version: Optional[int] = ...) -> int: ... def __contains__(self, key: str) -> bool: ... def set_many(self, data: Dict[str, Any], timeout: Any = ..., version: Optional[Any] = ...) -> List[Any]: ... def delete_many(self, keys: Iterable[Any], version: Optional[Any] = ...) -> None: ... def clear(self) -> None: ... def validate_key(self, key: str) -> None: ... def incr_version(self, key: str, delta: int = ..., version: Optional[int] = ...) -> int: ... def decr_version(self, key: str, delta: int = ..., version: Optional[int] = ...) -> int: ... def close(self, **kwargs: Any) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/core/cache/backends/db.pyi0000664000175000017500000000112300000000000027516 0ustar00davedave00000000000000from typing import Any, Dict from django.core.cache.backends.base import BaseCache class Options: db_table: str = ... app_label: str = ... model_name: str = ... verbose_name: str = ... verbose_name_plural: str = ... object_name: str = ... abstract: bool = ... managed: bool = ... proxy: bool = ... swapped: bool = ... def __init__(self, table: str) -> None: ... class BaseDatabaseCache(BaseCache): cache_model_class: Any = ... def __init__(self, table: str, params: Dict[str, Any]) -> None: ... class DatabaseCache(BaseDatabaseCache): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/core/cache/backends/dummy.pyi0000664000175000017500000000026600000000000030273 0ustar00davedave00000000000000from typing import Any from django.core.cache.backends.base import BaseCache class DummyCache(BaseCache): def __init__(self, host: str, *args: Any, **kwargs: Any) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/core/cache/backends/filebased.pyi0000664000175000017500000000033000000000000031046 0ustar00davedave00000000000000from typing import Any, Dict from django.core.cache.backends.base import BaseCache class FileBasedCache(BaseCache): cache_suffix: str = ... def __init__(self, dir: str, params: Dict[str, Any]) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/core/cache/backends/locmem.pyi0000664000175000017500000000027200000000000030411 0ustar00davedave00000000000000from typing import Any, Dict from django.core.cache.backends.base import BaseCache class LocMemCache(BaseCache): def __init__(self, name: str, params: Dict[str, Any]) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/core/cache/backends/memcached.pyi0000664000175000017500000000054000000000000031041 0ustar00davedave00000000000000from django.core.cache.backends.base import BaseCache class BaseMemcachedCache(BaseCache): def __init__(self, server, params, library, value_not_found_exception) -> None: ... class MemcachedCache(BaseMemcachedCache): def __init__(self, server, params): ... class PyLibMCCache(BaseMemcachedCache): def __init__(self, server, params): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/core/cache/utils.pyi0000664000175000017500000000027000000000000026521 0ustar00davedave00000000000000from typing import Any, Iterable, Optional TEMPLATE_FRAGMENT_KEY_TEMPLATE: str def make_template_fragment_key(fragment_name: str, vary_on: Optional[Iterable[Any]] = ...) -> str: ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.3983793 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/core/checks/0000775000175000017500000000000000000000000025034 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/core/checks/__init__.pyi0000664000175000017500000000065600000000000027325 0ustar00davedave00000000000000from .messages import ( CheckMessage as CheckMessage, Debug as Debug, Info as Info, Warning as Warning, Error as Error, Critical as Critical, DEBUG as DEBUG, INFO as INFO, WARNING as WARNING, ERROR as ERROR, CRITICAL as CRITICAL, ) from .registry import register as register, run_checks as run_checks, tag_exists as tag_exists, Tags as Tags from . import model_checks as model_checks ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/core/checks/caches.pyi0000664000175000017500000000041300000000000027003 0ustar00davedave00000000000000from typing import Any, List, Iterable, Optional from django.core.checks.messages import Error from django.apps.config import AppConfig E001: Any def check_default_cache_is_configured(app_configs: Optional[Iterable[AppConfig]], **kwargs: Any) -> List[Error]: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/core/checks/database.pyi0000664000175000017500000000014700000000000027325 0ustar00davedave00000000000000from typing import Any, List def check_database_backends(*args: Any, **kwargs: Any) -> List[Any]: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/core/checks/messages.pyi0000664000175000017500000000163500000000000027373 0ustar00davedave00000000000000from typing import Any, Optional DEBUG: int INFO: int WARNING: int ERROR: int CRITICAL: int class CheckMessage: level: int = ... msg: str = ... hint: Optional[str] = ... obj: Any = ... id: Optional[str] = ... def __init__( self, level: int, msg: str, hint: Optional[str] = ..., obj: Any = ..., id: Optional[str] = ... ) -> None: ... def is_serious(self, level: int = ...) -> bool: ... def is_silenced(self) -> bool: ... class Debug(CheckMessage): def __init__(self, *args: Any, **kwargs: Any) -> None: ... class Info(CheckMessage): def __init__(self, *args: Any, **kwargs: Any) -> None: ... class Warning(CheckMessage): def __init__(self, *args: Any, **kwargs: Any) -> None: ... class Error(CheckMessage): def __init__(self, *args: Any, **kwargs: Any) -> None: ... class Critical(CheckMessage): def __init__(self, *args: Any, **kwargs: Any) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/core/checks/model_checks.pyi0000664000175000017500000000054600000000000030204 0ustar00davedave00000000000000from typing import Any, List, Iterable, Optional from django.core.checks.messages import Warning from django.apps.config import AppConfig def check_all_models(app_configs: Optional[Iterable[AppConfig]] = ..., **kwargs: Any) -> List[Warning]: ... def check_lazy_references(app_configs: Optional[Iterable[AppConfig]] = ..., **kwargs: Any) -> List[Any]: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/core/checks/registry.pyi0000664000175000017500000000227400000000000027434 0ustar00davedave00000000000000from typing import Any, Callable, List, Optional, Set, Union from django.apps.config import AppConfig from django.core.checks.messages import CheckMessage class Tags: admin: str = ... caches: str = ... compatibility: str = ... database: str = ... models: str = ... security: str = ... signals: str = ... templates: str = ... translation: str = ... urls: str = ... class CheckRegistry: registered_checks: Set[Callable] = ... deployment_checks: Set[Callable] = ... def __init__(self) -> None: ... def register(self, check: Optional[Union[Callable, str]] = ..., *tags: Any, **kwargs: Any) -> Callable: ... def run_checks( self, app_configs: Optional[List[AppConfig]] = ..., tags: Optional[List[str]] = ..., include_deployment_checks: bool = ..., ) -> Union[List[CheckMessage], List[int], List[str]]: ... def tag_exists(self, tag: str, include_deployment_checks: bool = ...) -> bool: ... def tags_available(self, deployment_checks: bool = ...) -> Set[str]: ... def get_checks(self, include_deployment_checks: bool = ...) -> List[Callable]: ... registry: Any register: Any run_checks: Any tag_exists: Any ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.3983793 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/core/checks/security/0000775000175000017500000000000000000000000026703 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/core/checks/security/__init__.pyi0000664000175000017500000000000000000000000031153 0ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/core/checks/security/base.pyi0000664000175000017500000000307000000000000030340 0ustar00davedave00000000000000from typing import Any, List, Iterable, Optional from django.core.checks.messages import Warning from django.apps.config import AppConfig SECRET_KEY_MIN_LENGTH: int SECRET_KEY_MIN_UNIQUE_CHARACTERS: int W001: Any W002: Any W004: Any W005: Any W006: Any W007: Any W008: Any W009: Any W018: Any W019: Any W020: Any W021: Any def check_security_middleware(app_configs: Optional[Iterable[AppConfig]], **kwargs: Any) -> List[Warning]: ... def check_xframe_options_middleware(app_configs: Optional[Iterable[AppConfig]], **kwargs: Any) -> List[Warning]: ... def check_sts(app_configs: Optional[Iterable[AppConfig]], **kwargs: Any) -> List[Warning]: ... def check_sts_include_subdomains(app_configs: Optional[Iterable[AppConfig]], **kwargs: Any) -> List[Warning]: ... def check_sts_preload(app_configs: Optional[Iterable[AppConfig]], **kwargs: Any) -> List[Warning]: ... def check_content_type_nosniff(app_configs: Optional[Iterable[AppConfig]], **kwargs: Any) -> List[Warning]: ... def check_xss_filter(app_configs: Optional[Iterable[AppConfig]], **kwargs: Any) -> List[Warning]: ... def check_ssl_redirect(app_configs: Optional[Iterable[AppConfig]], **kwargs: Any) -> List[Warning]: ... def check_secret_key(app_configs: Optional[Iterable[AppConfig]], **kwargs: Any) -> List[Warning]: ... def check_debug(app_configs: Optional[Iterable[AppConfig]], **kwargs: Any) -> List[Warning]: ... def check_xframe_deny(app_configs: Optional[Iterable[AppConfig]], **kwargs: Any) -> List[Warning]: ... def check_allowed_hosts(app_configs: Optional[Iterable[AppConfig]], **kwargs: Any) -> List[Warning]: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/core/checks/security/csrf.pyi0000664000175000017500000000057300000000000030370 0ustar00davedave00000000000000from typing import Any, List, Iterable, Optional from django.core.checks.messages import Warning from django.apps.config import AppConfig W003: Any W016: Any def check_csrf_middleware(app_configs: Optional[Iterable[AppConfig]], **kwargs: Any) -> List[Warning]: ... def check_csrf_cookie_secure(app_configs: Optional[Iterable[AppConfig]], **kwargs: Any) -> List[Warning]: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/core/checks/security/sessions.pyi0000664000175000017500000000101700000000000031273 0ustar00davedave00000000000000from typing import Any, List, Iterable, Optional from django.core.checks.messages import Warning from django.apps.config import AppConfig def add_session_cookie_message(message: Any): ... W010: Any W011: Any W012: Any def add_httponly_message(message: Any): ... W013: Any W014: Any W015: Any def check_session_cookie_secure(app_configs: Optional[Iterable[AppConfig]], **kwargs: Any) -> List[Warning]: ... def check_session_cookie_httponly(app_configs: Optional[Iterable[AppConfig]], **kwargs: Any) -> List[Warning]: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/core/checks/templates.pyi0000664000175000017500000000060700000000000027560 0ustar00davedave00000000000000from typing import Any, List, Iterable, Optional from django.core.checks.messages import Error from django.apps.config import AppConfig E001: Any E002: Any def check_setting_app_dirs_loaders(app_configs: Optional[Iterable[AppConfig]], **kwargs: Any) -> List[Error]: ... def check_string_if_invalid_is_string(app_configs: Optional[Iterable[AppConfig]], **kwargs: Any) -> List[Error]: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/core/checks/translation.pyi0000664000175000017500000000023300000000000030113 0ustar00davedave00000000000000from typing import Any, List from . import Error E001: Error = ... def check_setting_language_code(app_configs: Any, **kwargs: Any) -> List[Error]: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/core/checks/urls.pyi0000664000175000017500000000141400000000000026544 0ustar00davedave00000000000000from typing import Any, Callable, List, Tuple, Union, Iterable, Optional from django.core.checks.messages import CheckMessage, Error, Warning from django.urls.resolvers import URLPattern, URLResolver from django.apps.config import AppConfig def check_url_config(app_configs: Optional[Iterable[AppConfig]], **kwargs: Any) -> List[CheckMessage]: ... def check_resolver(resolver: Union[Tuple[str, Callable], URLPattern, URLResolver]) -> List[CheckMessage]: ... def check_url_namespaces_unique(app_configs: Optional[Iterable[AppConfig]], **kwargs: Any) -> List[Warning]: ... def get_warning_for_invalid_pattern(pattern: Any) -> List[Error]: ... def check_url_settings(app_configs: Optional[Iterable[AppConfig]], **kwargs: Any) -> List[Error]: ... def E006(name: str) -> Error: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/core/exceptions.pyi0000664000175000017500000000300700000000000026500 0ustar00davedave00000000000000from typing import Any, Dict, Iterator, List, Mapping, Optional, Tuple, Union from django.forms.utils import ErrorDict class FieldDoesNotExist(Exception): ... class AppRegistryNotReady(Exception): ... class ObjectDoesNotExist(Exception): silent_variable_failure: bool = ... class MultipleObjectsReturned(Exception): ... class SuspiciousOperation(Exception): ... class SuspiciousMultipartForm(SuspiciousOperation): ... class SuspiciousFileOperation(SuspiciousOperation): ... class DisallowedHost(SuspiciousOperation): ... class DisallowedRedirect(SuspiciousOperation): ... class TooManyFieldsSent(SuspiciousOperation): ... class RequestDataTooBig(SuspiciousOperation): ... class PermissionDenied(Exception): ... class ViewDoesNotExist(Exception): ... class MiddlewareNotUsed(Exception): ... class ImproperlyConfigured(Exception): ... class FieldError(Exception): ... NON_FIELD_ERRORS: str class ValidationError(Exception): error_dict: Any = ... error_list: Any = ... message: Any = ... code: Any = ... params: Any = ... def __init__(self, message: Any, code: Optional[str] = ..., params: Optional[Mapping[str, Any]] = ...) -> None: ... @property def message_dict(self) -> Dict[str, List[str]]: ... @property def messages(self) -> List[str]: ... def update_error_dict( self, error_dict: Mapping[str, Any] ) -> Union[Dict[str, List[ValidationError]], ErrorDict]: ... def __iter__(self) -> Iterator[Union[Tuple[str, List[str]], str]]: ... class EmptyResultSet(Exception): ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.3983793 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/core/files/0000775000175000017500000000000000000000000024676 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/core/files/__init__.pyi0000664000175000017500000000010400000000000027153 0ustar00davedave00000000000000from django.core.files.base import File as File __all__ = ["File"] ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/core/files/base.pyi0000664000175000017500000000263300000000000026337 0ustar00davedave00000000000000import types from io import StringIO from typing import Any, IO, Iterator, Optional, Type, TypeVar, Union from django.core.files.utils import FileProxyMixin _T = TypeVar("_T", bound="File") class File(FileProxyMixin, IO[Any]): DEFAULT_CHUNK_SIZE: Any = ... file: IO[Any] = ... name: str = ... mode: str = ... def __init__(self, file: Any, name: Optional[str] = ...) -> None: ... def __bool__(self) -> bool: ... def __len__(self) -> int: ... @property def size(self) -> int: ... def chunks(self, chunk_size: Optional[int] = ...) -> Iterator[bytes]: ... def multiple_chunks(self, chunk_size: Optional[int] = ...) -> bool: ... def __iter__(self) -> Iterator[Union[bytes, str]]: ... def __next__(self) -> Union[bytes, str]: ... def __enter__(self: _T) -> _T: ... def __exit__( self, exc_type: Optional[Type[BaseException]], exc_value: Optional[BaseException], tb: Optional[types.TracebackType], ) -> bool: ... def open(self: _T, mode: Optional[str] = ...) -> _T: ... def close(self) -> None: ... class ContentFile(File): file: StringIO size: Any = ... def __init__(self, content: Union[bytes, str], name: Optional[str] = ...) -> None: ... def write(self, data: str) -> int: ... def endswith_cr(line: bytes) -> bool: ... def endswith_lf(line: Union[bytes, str]) -> bool: ... def equals_lf(line: bytes) -> bool: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/core/files/images.pyi0000664000175000017500000000046500000000000026673 0ustar00davedave00000000000000from typing import Any, IO, Union from django.core.files import File class ImageFile(File): mode: str name: str @property def width(self) -> int: ... @property def height(self) -> int: ... def get_image_dimensions(file_or_path: Union[str, IO[bytes]], close: bool = ...) -> Any: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/core/files/locks.pyi0000664000175000017500000000046400000000000026540 0ustar00davedave00000000000000from ctypes import Structure, Union from typing import Any LOCK_SH: int LOCK_NB: int LOCK_EX: int ULONG_PTR: Any = ... PVOID: Any = ... class _OFFSET(Structure): ... class _OFFSET_UNION(Union): ... class OVERLAPPED(Structure): ... def lock(f: Any, flags: int) -> bool: ... def unlock(f: Any) -> bool: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/core/files/move.pyi0000664000175000017500000000020200000000000026361 0ustar00davedave00000000000000def file_move_safe( old_file_name: str, new_file_name: str, chunk_size: int = ..., allow_overwrite: bool = ... ) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/core/files/storage.pyi0000664000175000017500000000335100000000000027067 0ustar00davedave00000000000000from datetime import datetime from typing import Any, IO, List, Optional, Tuple, Type from django.core.files.base import File from django.utils.functional import LazyObject class Storage: def open(self, name: str, mode: str = ...) -> File: ... def save(self, name: Optional[str], content: IO[Any], max_length: Optional[int] = ...) -> str: ... def get_valid_name(self, name: str) -> str: ... def get_available_name(self, name: str, max_length: Optional[int] = ...) -> str: ... def generate_filename(self, filename: str) -> str: ... def path(self, name: str) -> str: ... def delete(self, name: str) -> None: ... def exists(self, name: str) -> bool: ... def listdir(self, path: str) -> Tuple[List[str], List[str]]: ... def size(self, name: str) -> int: ... def url(self, name: Optional[str]) -> str: ... def get_accessed_time(self, name: str) -> datetime: ... def get_created_time(self, name: str) -> datetime: ... def get_modified_time(self, name: str) -> datetime: ... class FileSystemStorage(Storage): OS_OPEN_FLAGS: int = ... def __init__( self, location: Optional[str] = ..., base_url: Optional[str] = ..., file_permissions_mode: Optional[int] = ..., directory_permissions_mode: Optional[int] = ..., ) -> None: ... @property def base_location(self) -> str: ... @property def location(self) -> str: ... @property def base_url(self) -> str: ... @property def file_permissions_mode(self) -> Optional[int]: ... @property def directory_permissions_mode(self) -> Optional[int]: ... class DefaultStorage(LazyObject): ... default_storage: Any def get_storage_class(import_path: Optional[str] = ...) -> Type[Storage]: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/core/files/temp.pyi0000664000175000017500000000014400000000000026365 0ustar00davedave00000000000000import tempfile NamedTemporaryFile = tempfile.NamedTemporaryFile gettempdir = tempfile.gettempdir ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/core/files/uploadedfile.pyi0000664000175000017500000000271600000000000030064 0ustar00davedave00000000000000from typing import Any, Dict, IO, Optional, Union from django.core.files.base import File class UploadedFile(File): content_type: Optional[str] = ... charset: Optional[str] = ... content_type_extra: Optional[Dict[str, str]] = ... def __init__( self, file: Optional[IO] = ..., name: Optional[str] = ..., content_type: Optional[str] = ..., size: Optional[int] = ..., charset: Optional[str] = ..., content_type_extra: Optional[Dict[str, str]] = ..., ) -> None: ... class TemporaryUploadedFile(UploadedFile): def __init__( self, name: Optional[str], content_type: Optional[str], size: Optional[int], charset: Optional[str], content_type_extra: Optional[Dict[str, str]] = ..., ) -> None: ... def temporary_file_path(self) -> str: ... class InMemoryUploadedFile(UploadedFile): field_name: Optional[str] = ... def __init__( self, file: IO, field_name: Optional[str], name: Optional[str], content_type: Optional[str], size: Optional[int], charset: Optional[str], content_type_extra: Dict[str, str] = ..., ) -> None: ... class SimpleUploadedFile(InMemoryUploadedFile): def __init__(self, name: str, content: Optional[Union[bytes, str]], content_type: str = ...) -> None: ... @classmethod def from_dict(cls: Any, file_dict: Dict[str, Union[str, bytes]]) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/core/files/uploadhandler.pyi0000664000175000017500000000617300000000000030252 0ustar00davedave00000000000000# Stubs for django.core.files.uploadhandler (Python 3.5) from typing import Any, Dict, IO, Optional, Tuple from django.core.files.uploadedfile import UploadedFile, TemporaryUploadedFile from django.http.request import HttpRequest, QueryDict from django.utils.datastructures import MultiValueDict class UploadFileException(Exception): ... class StopUpload(UploadFileException): connection_reset: bool = ... def __init__(self, connection_reset: bool = ...) -> None: ... class SkipFile(UploadFileException): ... class StopFutureHandlers(UploadFileException): ... class FileUploadHandler: chunk_size: int = ... file_name: Optional[str] = ... content_type: Optional[str] = ... content_length: Optional[int] = ... charset: Optional[str] = ... content_type_extra: Optional[Dict[str, str]] = ... request: Optional[HttpRequest] = ... field_name: str = ... def __init__(self, request: Optional[HttpRequest] = ...) -> None: ... def handle_raw_input( self, input_data: IO[bytes], META: Dict[str, str], content_length: int, boundary: str, encoding: Optional[str] = ..., ) -> Optional[Tuple[QueryDict, MultiValueDict[str, UploadedFile]]]: ... def new_file( self, field_name: str, file_name: str, content_type: str, content_length: Optional[int], charset: Optional[str] = ..., content_type_extra: Optional[Dict[str, str]] = ..., ) -> None: ... def receive_data_chunk(self, raw_data: bytes, start: int) -> Optional[bytes]: ... def file_complete(self, file_size: int) -> Optional[UploadedFile]: ... def upload_complete(self) -> None: ... class TemporaryFileUploadHandler(FileUploadHandler): def __init__(self, request: Optional[HttpRequest] = ...) -> None: ... file = ... # type: TemporaryUploadedFile def new_file( self, field_name: str, file_name: str, content_type: str, content_length: Optional[int], charset: Optional[str] = ..., content_type_extra: Optional[Dict[str, str]] = ..., ) -> None: ... def receive_data_chunk(self, raw_data: bytes, start: int) -> Optional[bytes]: ... def file_complete(self, file_size: int) -> Optional[UploadedFile]: ... class MemoryFileUploadHandler(FileUploadHandler): activated = ... # type: bool file = ... # type: IO[bytes] def handle_raw_input( self, input_data: IO[bytes], META: Dict[str, str], content_length: int, boundary: str, encoding: Optional[str] = ..., ) -> Optional[Tuple[QueryDict, MultiValueDict[str, UploadedFile]]]: ... def new_file( self, field_name: str, file_name: str, content_type: str, content_length: Optional[int], charset: Optional[str] = ..., content_type_extra: Optional[Dict[str, str]] = ..., ) -> None: ... def receive_data_chunk(self, raw_data: bytes, start: int) -> Optional[bytes]: ... def file_complete(self, file_size: int) -> Optional[UploadedFile]: ... def load_handler(path: str, *args: Any, **kwargs: Any) -> FileUploadHandler: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/core/files/utils.pyi0000664000175000017500000000104300000000000026557 0ustar00davedave00000000000000from typing import Any class FileProxyMixin: encoding: Any = ... fileno: Any = ... flush: Any = ... isatty: Any = ... newlines: Any = ... read: Any = ... readinto: Any = ... readline: Any = ... readlines: Any = ... seek: Any = ... tell: Any = ... truncate: Any = ... write: Any = ... writelines: Any = ... @property def closed(self) -> bool: ... def readable(self) -> bool: ... def writable(self) -> bool: ... def seekable(self) -> bool: ... def __iter__(self): ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.3983793 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/core/handlers/0000775000175000017500000000000000000000000025374 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/core/handlers/__init__.pyi0000664000175000017500000000000000000000000027644 0ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/core/handlers/base.pyi0000664000175000017500000000107400000000000027033 0ustar00davedave00000000000000from typing import Any, Callable from django.http.request import HttpRequest from django.http.response import HttpResponse, HttpResponseBase logger: Any class BaseHandler: def load_middleware(self) -> None: ... def make_view_atomic(self, view: Callable) -> Callable: ... def get_exception_response(self, request: Any, resolver: Any, status_code: Any, exception: Any): ... def get_response(self, request: HttpRequest) -> HttpResponseBase: ... def process_exception_by_middleware(self, exception: Exception, request: HttpRequest) -> HttpResponse: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/core/handlers/exception.pyi0000664000175000017500000000107200000000000030115 0ustar00davedave00000000000000from typing import Any, Callable from django.http.request import HttpRequest from django.http.response import HttpResponse from django.urls.resolvers import URLResolver def convert_exception_to_response(get_response: Callable) -> Callable: ... def response_for_exception(request: HttpRequest, exc: Exception) -> HttpResponse: ... def get_exception_response( request: HttpRequest, resolver: URLResolver, status_code: int, exception: Exception, sender: None = ... ) -> HttpResponse: ... def handle_uncaught_exception(request: Any, resolver: Any, exc_info: Any): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/core/handlers/wsgi.pyi0000664000175000017500000000245500000000000027076 0ustar00davedave00000000000000from io import BytesIO from typing import Any, Callable, Dict, Optional, Union from django.contrib.sessions.backends.base import SessionBase from django.core.handlers import base from django.http import HttpRequest from django.http.response import HttpResponse _Stream = Union[BytesIO, str] _WSGIEnviron = Dict[str, Any] class LimitedStream: stream: _Stream = ... remaining: int = ... buffer: bytes = ... buf_size: int = ... def __init__(self, stream: _Stream, limit: int, buf_size: int = ...) -> None: ... def read(self, size: Optional[int] = ...) -> bytes: ... def readline(self, size: Optional[int] = ...) -> bytes: ... class WSGIRequest(HttpRequest): environ: _WSGIEnviron = ... session: SessionBase encoding: Any = ... def __init__(self, environ: _WSGIEnviron) -> None: ... class WSGIHandler(base.BaseHandler): request_class: Any = ... def __init__(self, *args: Any, **kwargs: Any) -> None: ... def __call__(self, environ: _WSGIEnviron, start_response: Callable) -> HttpResponse: ... def get_path_info(environ: _WSGIEnviron) -> str: ... def get_script_name(environ: _WSGIEnviron) -> str: ... def get_bytes_from_wsgi(environ: _WSGIEnviron, key: str, default: str) -> bytes: ... def get_str_from_wsgi(environ: _WSGIEnviron, key: str, default: str) -> str: ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.3983793 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/core/mail/0000775000175000017500000000000000000000000024516 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/core/mail/__init__.pyi0000664000175000017500000000274000000000000027003 0ustar00davedave00000000000000from typing import Any, List, Optional, Tuple from .message import ( BadHeaderError as BadHeaderError, DEFAULT_ATTACHMENT_MIME_TYPE as DEFAULT_ATTACHMENT_MIME_TYPE, EmailMessage as EmailMessage, EmailMultiAlternatives as EmailMultiAlternatives, SafeMIMEMultipart as SafeMIMEMultipart, SafeMIMEText as SafeMIMEText, forbid_multi_line_headers as forbid_multi_line_headers, ) from .utils import CachedDnsName as CachedDnsName, DNS_NAME as DNS_NAME def get_connection(backend: Optional[str] = ..., fail_silently: bool = ..., **kwds: Any) -> Any: ... def send_mail( subject: str, message: str, from_email: Optional[str], recipient_list: List[str], fail_silently: bool = ..., auth_user: Optional[str] = ..., auth_password: Optional[str] = ..., connection: Optional[Any] = ..., html_message: Optional[str] = ..., ) -> int: ... def send_mass_mail( datatuple: List[Tuple[str, str, str, List[str]]], fail_silently: bool = ..., auth_user: Optional[str] = ..., auth_password: Optional[str] = ..., connection: Optional[Any] = ..., ) -> int: ... def mail_admins( subject: str, message: str, fail_silently: bool = ..., connection: Optional[Any] = ..., html_message: Optional[str] = ..., ) -> None: ... def mail_managers( subject: str, message: str, fail_silently: bool = ..., connection: Optional[Any] = ..., html_message: Optional[str] = ..., ) -> None: ... outbox: List[EmailMessage] = ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.3983793 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/core/mail/backends/0000775000175000017500000000000000000000000026270 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/core/mail/backends/__init__.pyi0000664000175000017500000000000000000000000030540 0ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/core/mail/backends/base.pyi0000664000175000017500000000113400000000000027724 0ustar00davedave00000000000000import types from typing import Any, TypeVar, Type, Iterable, Optional from django.core.mail.message import EmailMessage _T = TypeVar("_T", bound="BaseEmailBackend") class BaseEmailBackend: def __init__(self, fail_silently: bool = ..., **kwargs: Any) -> None: ... def open(self) -> Optional[bool]: ... def close(self) -> None: ... def __enter__(self: _T) -> _T: ... def __exit__( self, exc_type: Type[BaseException], exc_value: BaseException, traceback: types.TracebackType ) -> None: ... def send_messages(self, email_messages: Iterable[EmailMessage]) -> int: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/core/mail/backends/console.pyi0000664000175000017500000000014700000000000030457 0ustar00davedave00000000000000from django.core.mail.backends.base import BaseEmailBackend class EmailBackend(BaseEmailBackend): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/core/mail/backends/dummy.pyi0000664000175000017500000000014700000000000030150 0ustar00davedave00000000000000from django.core.mail.backends.base import BaseEmailBackend class EmailBackend(BaseEmailBackend): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/core/mail/backends/filebased.pyi0000664000175000017500000000014700000000000030733 0ustar00davedave00000000000000from django.core.mail.backends.base import BaseEmailBackend class EmailBackend(BaseEmailBackend): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/core/mail/backends/locmem.pyi0000664000175000017500000000014700000000000030271 0ustar00davedave00000000000000from django.core.mail.backends.base import BaseEmailBackend class EmailBackend(BaseEmailBackend): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/core/mail/backends/smtp.pyi0000664000175000017500000000077600000000000030010 0ustar00davedave00000000000000import smtplib import threading from typing import Optional, Union from django.core.mail.backends.base import BaseEmailBackend class EmailBackend(BaseEmailBackend): host: str = ... port: int = ... username: str = ... password: str = ... use_tls: bool = ... use_ssl: bool = ... timeout: Optional[int] = ... ssl_keyfile: Optional[str] = ... ssl_certfile: Optional[str] = ... connection: Union[smtplib.SMTP_SSL, smtplib.SMTP, None] = ... _lock: threading.RLock = ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/core/mail/message.pyi0000664000175000017500000000777600000000000026706 0ustar00davedave00000000000000from email._policybase import Policy # type: ignore from email.message import Message from email.mime.base import MIMEBase from email.mime.message import MIMEMessage from email.mime.multipart import MIMEMultipart from email.mime.text import MIMEText from typing import Any, Dict, List, Optional, Sequence, Tuple, Union, overload utf8_charset: Any utf8_charset_qp: Any DEFAULT_ATTACHMENT_MIME_TYPE: str RFC5322_EMAIL_LINE_LENGTH_LIMIT: int class BadHeaderError(ValueError): ... ADDRESS_HEADERS: Any def forbid_multi_line_headers(name: str, val: str, encoding: str) -> Tuple[str, str]: ... def split_addr(addr: str, encoding: str) -> Tuple[str, str]: ... def sanitize_address(addr: Union[Tuple[str, str], str], encoding: str) -> str: ... class MIMEMixin: ... class SafeMIMEMessage(MIMEMixin, MIMEMessage): defects: List[Any] epilogue: None policy: Policy preamble: None class SafeMIMEText(MIMEMixin, MIMEText): defects: List[Any] epilogue: None policy: Policy preamble: None encoding: str = ... def __init__(self, _text: str, _subtype: str = ..., _charset: str = ...) -> None: ... class SafeMIMEMultipart(MIMEMixin, MIMEMultipart): defects: List[Any] epilogue: None policy: Policy preamble: None encoding: str = ... def __init__( self, _subtype: str = ..., boundary: None = ..., _subparts: None = ..., encoding: str = ..., **_params: Any ) -> None: ... _AttachmentContent = Union[bytes, EmailMessage, Message, SafeMIMEText, str] _AttachmentTuple = Union[ Tuple[str, _AttachmentContent], Tuple[Optional[str], _AttachmentContent, str], Tuple[str, _AttachmentContent, None] ] class EmailMessage: content_subtype: str = ... mixed_subtype: str = ... encoding: Any = ... to: List[str] = ... cc: List[Any] = ... bcc: List[Any] = ... reply_to: List[Any] = ... from_email: str = ... subject: str = ... body: str = ... attachments: List[Any] = ... extra_headers: Dict[Any, Any] = ... connection: Any = ... def __init__( self, subject: str = ..., body: Optional[str] = ..., from_email: Optional[str] = ..., to: Optional[Sequence[str]] = ..., bcc: Optional[Sequence[str]] = ..., connection: Optional[Any] = ..., attachments: Optional[Sequence[Union[MIMEBase, _AttachmentTuple]]] = ..., headers: Optional[Dict[str, str]] = ..., cc: Optional[Sequence[str]] = ..., reply_to: Optional[Sequence[str]] = ..., ) -> None: ... def get_connection(self, fail_silently: bool = ...) -> Any: ... # TODO: when typeshed gets more types for email.Message, move it to MIMEMessage, now it has too many false-positives def message(self) -> Any: ... def recipients(self) -> List[str]: ... def send(self, fail_silently: bool = ...) -> int: ... @overload def attach(self, filename: MIMEText = ...) -> None: ... @overload def attach(self, filename: None = ..., content: _AttachmentContent = ..., mimetype: str = ...) -> None: ... @overload def attach(self, filename: str = ..., content: _AttachmentContent = ..., mimetype: Optional[str] = ...) -> None: ... def attach_file(self, path: str, mimetype: Optional[str] = ...) -> None: ... class EmailMultiAlternatives(EmailMessage): alternative_subtype: str = ... alternatives: Sequence[Tuple[_AttachmentContent, str]] = ... def __init__( self, subject: str = ..., body: str = ..., from_email: Optional[str] = ..., to: Optional[Sequence[str]] = ..., bcc: Optional[Sequence[str]] = ..., connection: Optional[Any] = ..., attachments: Optional[Sequence[Union[MIMEBase, _AttachmentTuple]]] = ..., headers: Optional[Dict[str, str]] = ..., alternatives: Optional[Sequence[Tuple[_AttachmentContent, str]]] = ..., cc: Optional[Sequence[str]] = ..., reply_to: Optional[Sequence[str]] = ..., ) -> None: ... def attach_alternative(self, content: _AttachmentContent, mimetype: str) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/core/mail/utils.pyi0000664000175000017500000000013700000000000026402 0ustar00davedave00000000000000from typing import Any class CachedDnsName: def get_fqdn(self) -> str: ... DNS_NAME: Any ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.3983793 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/core/management/0000775000175000017500000000000000000000000025710 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/core/management/__init__.pyi0000664000175000017500000000151100000000000030170 0ustar00davedave00000000000000from typing import Any, Dict, List, Tuple, Union from .base import BaseCommand as BaseCommand, CommandError as CommandError def find_commands(management_dir: str) -> List[str]: ... def load_command_class(app_name: str, name: str) -> BaseCommand: ... def get_commands() -> Dict[str, str]: ... def call_command(command_name: Union[Tuple[str], BaseCommand, str], *args: Any, **options: Any) -> str: ... class ManagementUtility: argv: List[str] = ... prog_name: str = ... settings_exception: None = ... def __init__(self, argv: List[str] = ...) -> None: ... def main_help_text(self, commands_only: bool = ...): ... def fetch_command(self, subcommand: str) -> BaseCommand: ... def autocomplete(self) -> None: ... def execute(self) -> None: ... def execute_from_command_line(argv: List[str] = ...) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/core/management/base.pyi0000664000175000017500000000555200000000000027354 0ustar00davedave00000000000000from argparse import ArgumentParser, HelpFormatter, Namespace from io import StringIO, TextIOBase, TextIOWrapper from typing import Any, Callable, List, Optional, Union, Tuple from django.apps.config import AppConfig from django.core.management.color import Style class CommandError(Exception): ... class SystemCheckError(CommandError): ... class CommandParser(ArgumentParser): missing_args_message: None = ... called_from_command_line: bool = ... def __init__(self, **kwargs: Any) -> None: ... def error(self, message: str) -> Any: ... def handle_default_options(options: Namespace) -> None: ... def no_translations(handle_func: Callable) -> Callable: ... class DjangoHelpFormatter(HelpFormatter): ... class OutputWrapper(TextIOBase): @property def style_func(self): ... @style_func.setter def style_func(self, style_func: Callable[[str], str]): ... ending: str = ... def __init__( self, out: Union[StringIO, TextIOWrapper], style_func: Optional[Callable[[str], str]] = ..., ending: str = ... ) -> None: ... def __getattr__(self, name: str) -> Callable: ... def isatty(self) -> bool: ... def write( # type: ignore[override] self, msg: str, style_func: Optional[Callable[[str], str]] = ..., ending: Optional[str] = ... ) -> None: ... class BaseCommand: help: str = ... output_transaction: bool = ... requires_migrations_checks: bool = ... requires_system_checks: bool = ... base_stealth_options: Tuple[str, ...] = ... stealth_options: Tuple[str, ...] = ... stdout: OutputWrapper = ... stderr: OutputWrapper = ... style: Style = ... def __init__( self, stdout: Optional[StringIO] = ..., stderr: Optional[StringIO] = ..., no_color: bool = ..., force_color: bool = ..., ) -> None: ... def get_version(self) -> str: ... def create_parser(self, prog_name: str, subcommand: str, **kwargs: Any) -> CommandParser: ... def add_arguments(self, parser: CommandParser) -> None: ... def print_help(self, prog_name: str, subcommand: str) -> None: ... def run_from_argv(self, argv: List[str]) -> None: ... def execute(self, *args: Any, **options: Any) -> Any: ... def check( self, app_configs: Optional[List[AppConfig]] = ..., tags: Optional[List[str]] = ..., display_num_errors: bool = ..., include_deployment_checks: bool = ..., fail_level: int = ..., ) -> None: ... def check_migrations(self) -> None: ... def handle(self, *args: Any, **options: Any) -> Optional[str]: ... class AppCommand(BaseCommand): missing_args_message: str = ... def handle_app_config(self, app_config: Any, **options: Any) -> None: ... class LabelCommand(BaseCommand): label: str = ... missing_args_message: Any = ... def handle_label(self, label: Any, **options: Any) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/core/management/color.pyi0000664000175000017500000000203400000000000027550 0ustar00davedave00000000000000def supports_color() -> bool: ... class Style: def ERROR(self, text: str) -> str: ... def SUCCESS(self, text: str) -> str: ... def WARNING(self, text: str) -> str: ... def NOTICE(self, text: str) -> str: ... def SQL_FIELD(self, text: str) -> str: ... def SQL_COLTYPE(self, text: str) -> str: ... def SQL_KEYWORD(self, text: str) -> str: ... def SQL_TABLE(self, text: str) -> str: ... def HTTP_INFO(self, text: str) -> str: ... def HTTP_SUCCESS(self, text: str) -> str: ... def HTTP_REDIRECT(self, text: str) -> str: ... def HTTP_NOT_MODIFIED(self, text: str) -> str: ... def HTTP_BAD_REQUEST(self, text: str) -> str: ... def HTTP_NOT_FOUND(self, text: str) -> str: ... def HTTP_SERVER_ERROR(self, text: str) -> str: ... def MIGRATE_HEADING(self, text: str) -> str: ... def MIGRATE_LABEL(self, text: str) -> str: ... def ERROR_OUTPUT(self, text: str) -> str: ... def make_style(config_string: str = ...) -> Style: ... def no_style() -> Style: ... def color_style() -> Style: ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4023793 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/core/management/commands/0000775000175000017500000000000000000000000027511 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/core/management/commands/__init__.pyi0000664000175000017500000000000000000000000031761 0ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/core/management/commands/dumpdata.pyi0000664000175000017500000000017300000000000032034 0ustar00davedave00000000000000from django.core.management.base import BaseCommand class ProxyModelWarning(Warning): ... class Command(BaseCommand): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/core/management/commands/loaddata.pyi0000664000175000017500000000116100000000000032004 0ustar00davedave00000000000000import zipfile from typing import Iterable, List, Optional, Tuple from django.core.management.base import BaseCommand READ_STDIN: str = ... class Command(BaseCommand): missing_args_message: str = ... def loaddata(self, fixture_labels: Iterable[str]) -> None: ... def load_label(self, fixture_label: str) -> None: ... def find_fixtures(self, fixture_label: str) -> List[Optional[str]]: ... @property def fixture_dirs(self) -> List[str]: ... def parse_name(self, fixture_name: str) -> Tuple[str, str, str]: ... class SingleZipReader(zipfile.ZipFile): ... def humanize(dirname: str) -> str: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/core/management/commands/makemessages.pyi0000664000175000017500000000215600000000000032705 0ustar00davedave00000000000000from typing import Any, Optional, Pattern, Type from django.core.management.base import BaseCommand plural_forms_re: Pattern = ... STATUS_OK: int = ... NO_LOCALE_DIR: Any = ... def check_programs(*programs: str) -> None: ... class TranslatableFile: dirpath: str file_name: str locale_dir: str def __init__(self, dirpath: str, file_name: str, locale_dir: Optional[str]) -> None: ... class BuildFile: """ Represent the state of a translatable file during the build process. """ def __init__(self, command: BaseCommand, domain: str, translatable: TranslatableFile) -> None: ... @property def is_templatized(self) -> bool: ... @property def path(self) -> str: ... @property def work_path(self) -> str: ... def preprocess(self) -> None: ... def postprocess_messages(self, msgs: str) -> str: ... def cleanup(self) -> None: ... def normalize_eols(raw_contents: str) -> str: ... def write_pot_file(potfile: str, msgs: str) -> None: ... class Command(BaseCommand): translatable_file_class: Type[TranslatableFile] = ... build_file_class: Type[BuildFile] = ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/core/management/commands/runserver.pyi0000664000175000017500000000030200000000000032262 0ustar00davedave00000000000000from django.core.management.base import BaseCommand class Command(BaseCommand): default_addr: str = ... default_addr_ipv6: str = ... default_port: int = ... protocol: str = ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/core/management/commands/testserver.pyi0000664000175000017500000000012500000000000032440 0ustar00davedave00000000000000from django.core.management.base import BaseCommand class Command(BaseCommand): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/core/management/sql.pyi0000664000175000017500000000065500000000000027240 0ustar00davedave00000000000000from typing import Any, List from django.core.management.color import Style def sql_flush( style: Style, connection: Any, only_django: bool = ..., reset_sequences: bool = ..., allow_cascade: bool = ... ) -> List[str]: ... def emit_pre_migrate_signal(verbosity: int, interactive: bool, db: str, **kwargs: Any) -> None: ... def emit_post_migrate_signal(verbosity: int, interactive: bool, db: str, **kwargs: Any) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/core/management/templates.pyi0000664000175000017500000000116000000000000030427 0ustar00davedave00000000000000from typing import Any from django.core.management.base import BaseCommand class TemplateCommand(BaseCommand): url_schemes: Any = ... rewrite_template_suffixes: Any = ... app_or_project: Any = ... paths_to_remove: Any = ... verbosity: Any = ... def handle_template(self, template: Any, subdir: Any): ... def validate_name(self, name: Any, app_or_project: Any) -> None: ... def download(self, url: Any): ... def splitext(self, the_path: Any): ... def extract(self, filename: Any): ... def is_url(self, template: Any): ... def make_writeable(self, filename: Any) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/core/management/utils.pyi0000664000175000017500000000101700000000000027572 0ustar00davedave00000000000000from typing import List, Optional, Set, Tuple, Type from django.apps.config import AppConfig from django.db.models.base import Model def popen_wrapper(args: List[str], stdout_encoding: str = ...) -> Tuple[str, str, int]: ... def handle_extensions(extensions: List[str]) -> Set[str]: ... def find_command(cmd: str, path: Optional[str] = ..., pathext: Optional[str] = ...) -> Optional[str]: ... def get_random_secret_key(): ... def parse_apps_and_model_labels(labels: List[str]) -> Tuple[Set[Type[Model]], Set[AppConfig]]: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/core/paginator.pyi0000664000175000017500000000355000000000000026306 0ustar00davedave00000000000000from typing import Dict, List, Optional, Protocol, Sequence, Union from django.db.models.base import Model from django.db.models.query import QuerySet class UnorderedObjectListWarning(RuntimeWarning): ... class InvalidPage(Exception): ... class PageNotAnInteger(InvalidPage): ... class EmptyPage(InvalidPage): ... class _SupportsLen(Protocol): def __len__(self) -> int: ... class _SupportsCount(Protocol): def count(self) -> int: ... class _SupportsOrdered(Protocol): ordered: bool = ... class Paginator: object_list: QuerySet = ... per_page: int = ... orphans: int = ... allow_empty_first_page: bool = ... def __init__( self, object_list: Union[_SupportsLen, _SupportsCount, _SupportsOrdered], per_page: Union[int, str], orphans: int = ..., allow_empty_first_page: bool = ..., ) -> None: ... def validate_number(self, number: Optional[Union[float, str]]) -> int: ... def get_page(self, number: Optional[int]) -> Page: ... def page(self, number: Union[int, str]) -> Page: ... @property def count(self) -> int: ... @property def num_pages(self) -> int: ... @property def page_range(self) -> range: ... QuerySetPaginator = Paginator class Page(Sequence): object_list: QuerySet = ... number: int = ... paginator: Paginator = ... def __init__( self, object_list: Union[List[Dict[str, str]], List[Model], List[int], QuerySet, str], number: int, paginator: Paginator, ) -> None: ... def __getitem__(self, item): ... def __len__(self): ... def has_next(self) -> bool: ... def has_previous(self) -> bool: ... def has_other_pages(self) -> bool: ... def next_page_number(self) -> int: ... def previous_page_number(self) -> int: ... def start_index(self) -> int: ... def end_index(self) -> int: ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4023793 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/core/serializers/0000775000175000017500000000000000000000000026130 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/core/serializers/__init__.pyi0000664000175000017500000000254100000000000030414 0ustar00davedave00000000000000from typing import Any, Callable, Dict, Iterable, Iterator, List, Optional, Type, Union from django.db.models.base import Model from .base import ( DeserializationError as DeserializationError, DeserializedObject, Deserializer as Deserializer, M2MDeserializationError as M2MDeserializationError, SerializationError as SerializationError, Serializer as Serializer, SerializerDoesNotExist as SerializerDoesNotExist, ) BUILTIN_SERIALIZERS: Any class BadSerializer: internal_use_only: bool = ... exception: BaseException = ... def __init__(self, exception: BaseException) -> None: ... def __call__(self, *args: Any, **kwargs: Any) -> Any: ... def register_serializer(format: str, serializer_module: str, serializers: Optional[Dict[str, Any]] = ...) -> None: ... def unregister_serializer(format: str) -> None: ... def get_serializer(format: str) -> Union[Type[Serializer], BadSerializer]: ... def get_serializer_formats() -> List[str]: ... def get_public_serializer_formats() -> List[str]: ... def get_deserializer(format: str) -> Union[Callable, Type[Deserializer]]: ... def serialize(format: str, queryset: Iterable[Model], **options: Any) -> Any: ... def deserialize(format: str, stream_or_string: Any, **options: Any) -> Iterator[DeserializedObject]: ... def sort_dependencies(app_list: Iterable[Any]) -> List[Type[Model]]: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/core/serializers/base.pyi0000664000175000017500000000647400000000000027600 0ustar00davedave00000000000000from datetime import date from io import BufferedReader, StringIO, TextIOWrapper from typing import Any, Dict, Iterable, List, Mapping, Optional, Type, Union, Collection from uuid import UUID from django.core.management.base import OutputWrapper from django.db.models.base import Model from django.db.models.fields.related import ForeignKey, ManyToManyField from django.db.models.fields import Field class SerializerDoesNotExist(KeyError): ... class SerializationError(Exception): ... class DeserializationError(Exception): @classmethod def WithData( cls, original_exc: Exception, model: str, fk: Union[int, str], field_value: Optional[Union[List[str], str]] ) -> DeserializationError: ... class M2MDeserializationError(Exception): original_exc: Exception = ... pk: List[str] = ... def __init__(self, original_exc: Exception, pk: Union[List[str], str]) -> None: ... class ProgressBar: progress_width: int = ... output: None = ... total_count: int = ... prev_done: int = ... def __init__(self, output: Optional[Union[StringIO, OutputWrapper]], total_count: int) -> None: ... def update(self, count: int) -> None: ... class Serializer: internal_use_only: bool = ... progress_class: Any = ... stream_class: Any = ... options: Dict[str, Any] = ... stream: Any = ... selected_fields: Optional[Collection[str]] = ... use_natural_foreign_keys: bool = ... use_natural_primary_keys: bool = ... first: bool = ... def serialize( self, queryset: Iterable[Model], *, stream: Optional[Any] = ..., fields: Optional[Collection[str]] = ..., use_natural_foreign_keys: bool = ..., use_natural_primary_keys: bool = ..., progress_output: Optional[Any] = ..., object_count: int = ..., **options: Any ) -> Any: ... def start_serialization(self) -> None: ... def end_serialization(self) -> None: ... def start_object(self, obj: Any) -> None: ... def end_object(self, obj: Any) -> None: ... def handle_field(self, obj: Any, field: Any) -> None: ... def handle_fk_field(self, obj: Any, field: Any) -> None: ... def handle_m2m_field(self, obj: Any, field: Any) -> None: ... def getvalue(self) -> Optional[Union[bytes, str]]: ... class Deserializer: options: Dict[str, Any] = ... stream: Any = ... def __init__(self, stream_or_string: Union[BufferedReader, TextIOWrapper, str], **options: Any) -> None: ... def __iter__(self) -> Deserializer: ... def __next__(self) -> None: ... class DeserializedObject: object: Any = ... m2m_data: Dict[str, List[int]] = ... deferred_fields: Mapping[Field, Any] def __init__( self, obj: Model, m2m_data: Optional[Dict[str, List[int]]] = ..., deferred_fields: Optional[Mapping[Field, Any]] = ..., ) -> None: ... def save(self, save_m2m: bool = ..., using: Optional[str] = ..., **kwargs: Any) -> None: ... def save_deferred_fields(self, using: Optional[str] = ...) -> None: ... def build_instance(Model: Type[Model], data: Dict[str, Optional[Union[date, int, str, UUID]]], db: str) -> Model: ... def deserialize_m2m_values(field: ManyToManyField, field_value: Any, using: str) -> List[Any]: ... def deserialize_fk_value(field: ForeignKey, field_value: Any, using: str) -> Any: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/core/serializers/json.pyi0000664000175000017500000000064600000000000027632 0ustar00davedave00000000000000import json from typing import Any, Dict from django.core.serializers.python import Serializer as PythonSerializer class Serializer(PythonSerializer): json_kwargs: Dict[str, Any] def Deserializer(stream_or_string: Any, **options: Any) -> None: ... class DjangoJSONEncoder(json.JSONEncoder): allow_nan: bool check_circular: bool ensure_ascii: bool indent: int skipkeys: bool sort_keys: bool ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/core/serializers/python.pyi0000664000175000017500000000102700000000000030174 0ustar00davedave00000000000000from collections import OrderedDict from typing import Any, Dict, Iterator, List, Optional from django.core.serializers.base import DeserializedObject from django.db.models.base import Model from django.core.serializers import base class Serializer(base.Serializer): objects: List[Any] = ... def get_dump_object(self, obj: Model) -> OrderedDict: ... def Deserializer( object_list: List[Dict[str, Any]], *, using: Optional[str] = ..., ignorenonexistent: bool = ..., **options: Any ) -> Iterator[DeserializedObject]: ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4023793 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/core/servers/0000775000175000017500000000000000000000000025265 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/core/servers/__init__.pyi0000664000175000017500000000000000000000000027535 0ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/core/servers/basehttp.pyi0000664000175000017500000000242500000000000027625 0ustar00davedave00000000000000import socketserver from io import BytesIO from typing import Any, Dict from wsgiref import simple_server from django.core.handlers.wsgi import WSGIRequest, WSGIHandler from django.core.wsgi import get_wsgi_application as get_wsgi_application # noqa: F401 class WSGIServer(simple_server.WSGIServer): request_queue_size: int = ... address_family: Any = ... allow_reuse_address: Any = ... def __init__(self, *args: Any, ipv6: bool = ..., allow_reuse_address: bool = ..., **kwargs: Any) -> None: ... def handle_error(self, request: Any, client_address: Any) -> None: ... class ThreadedWSGIServer(socketserver.ThreadingMixIn, WSGIServer): ... class ServerHandler(simple_server.ServerHandler): def handle_error(self) -> None: ... class WSGIRequestHandler(simple_server.WSGIRequestHandler): close_connection: bool connection: WSGIRequest request: WSGIRequest rfile: BytesIO wfile: BytesIO protocol_version: str = ... def address_string(self) -> str: ... def log_message(self, format: str, *args: Any) -> None: ... def get_environ(self) -> Dict[str, str]: ... raw_requestline: bytes = ... requestline: str = ... request_version: str = ... def handle(self) -> None: ... def get_internal_wsgi_application() -> WSGIHandler: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/core/signals.pyi0000664000175000017500000000024300000000000025756 0ustar00davedave00000000000000from django.dispatch import Signal request_started: Signal = ... request_finished: Signal = ... got_request_exception: Signal = ... setting_changed: Signal = ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/core/signing.pyi0000664000175000017500000000267300000000000025765 0ustar00davedave00000000000000from datetime import timedelta from typing import Any, Dict, Optional, Protocol, Type, Union class BadSignature(Exception): ... class SignatureExpired(BadSignature): ... def b64_encode(s: bytes) -> bytes: ... def b64_decode(s: bytes) -> bytes: ... def base64_hmac(salt: str, value: Union[bytes, str], key: Union[bytes, str]) -> str: ... def get_cookie_signer(salt: str = ...) -> TimestampSigner: ... class Serializer(Protocol): def dumps(self, obj: Any) -> bytes: ... def loads(self, data: bytes) -> Any: ... class JSONSerializer: def dumps(self, obj: Any) -> bytes: ... def loads(self, data: bytes) -> Dict[str, Union[int, str]]: ... def dumps( obj: Any, key: None = ..., salt: str = ..., serializer: Type[Serializer] = ..., compress: bool = ... ) -> str: ... def loads( s: str, key: None = ..., salt: str = ..., serializer: Type[Serializer] = ..., max_age: Optional[Union[int, timedelta]] = ..., ) -> Any: ... class Signer: key: str = ... sep: str = ... salt: str = ... def __init__(self, key: Optional[Union[bytes, str]] = ..., sep: str = ..., salt: Optional[str] = ...) -> None: ... def signature(self, value: Union[bytes, str]) -> str: ... def sign(self, value: str) -> str: ... def unsign(self, signed_value: str) -> str: ... class TimestampSigner(Signer): def timestamp(self) -> str: ... def unsign(self, value: str, max_age: Optional[Union[int, timedelta]] = ...) -> str: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/core/validators.pyi0000664000175000017500000000753600000000000026502 0ustar00davedave00000000000000from decimal import Decimal from re import RegexFlag from typing import Any, Callable, Collection, Dict, List, Optional, Pattern, Tuple, Union from django.core.files.base import File EMPTY_VALUES: Any _Regex = Union[str, Pattern[str]] _ErrorMessage = Union[str, Any] def _lazy_re_compile(regex: _Regex, flags: int = ...): ... class RegexValidator: regex: _Regex = ... message: str = ... code: str = ... inverse_match: bool = ... flags: int = ... def __init__( self, regex: Optional[_Regex] = ..., message: Optional[_ErrorMessage] = ..., code: Optional[str] = ..., inverse_match: Optional[bool] = ..., flags: Optional[RegexFlag] = ..., ) -> None: ... def __call__(self, value: Optional[str]) -> None: ... class URLValidator(RegexValidator): ul: str = ... ipv4_re: str = ... ipv6_re: str = ... hostname_re: str = ... domain_re: str = ... tld_re: str = ... host_re: str = ... schemes: List[str] = ... def __init__(self, schemes: Optional[Collection[str]] = ..., **kwargs: Any) -> None: ... integer_validator: RegexValidator = ... def validate_integer(value: Optional[Union[float, str]]) -> None: ... class EmailValidator: message: str = ... code: str = ... user_regex: Pattern = ... domain_regex: Pattern = ... literal_regex: Pattern = ... domain_whitelist: List[str] = ... def __init__( self, message: Optional[_ErrorMessage] = ..., code: Optional[str] = ..., whitelist: Optional[Collection[str]] = ..., ) -> None: ... def __call__(self, value: Optional[str]) -> None: ... def validate_domain_part(self, domain_part: str) -> bool: ... validate_email: EmailValidator = ... slug_re: Pattern = ... validate_slug: RegexValidator = ... slug_unicode_re: Pattern = ... validate_unicode_slug: RegexValidator = ... def validate_ipv4_address(value: str) -> None: ... def validate_ipv6_address(value: str) -> None: ... def validate_ipv46_address(value: str) -> None: ... _IPValidator = Tuple[Callable[[Any], None], str] ip_address_validator_map: Dict[str, _IPValidator] def ip_address_validators(protocol: str, unpack_ipv4: bool) -> _IPValidator: ... def int_list_validator( sep: str = ..., message: Optional[_ErrorMessage] = ..., code: str = ..., allow_negative: bool = ... ) -> RegexValidator: ... validate_comma_separated_integer_list: Any class BaseValidator: message: str = ... code: str = ... limit_value: Any = ... def __init__(self, limit_value: Any, message: Optional[_ErrorMessage] = ...) -> None: ... def __call__(self, value: Any) -> None: ... def compare(self, a: Any, b: Any) -> bool: ... def clean(self, x: Any) -> Any: ... class MaxValueValidator(BaseValidator): ... class MinValueValidator(BaseValidator): ... class MinLengthValidator(BaseValidator): ... class MaxLengthValidator(BaseValidator): ... class DecimalValidator: messages: Dict[str, str] = ... max_digits: int = ... decimal_places: int = ... def __init__(self, max_digits: Optional[Union[int, str]], decimal_places: Optional[Union[int, str]]) -> None: ... def __call__(self, value: Decimal) -> None: ... class FileExtensionValidator: message: str = ... code: str = ... allowed_extensions: List[str] = ... def __init__( self, allowed_extensions: Optional[Collection[str]] = ..., message: Optional[_ErrorMessage] = ..., code: Optional[str] = ..., ) -> None: ... def __call__(self, value: File) -> None: ... def get_available_image_extensions() -> List[str]: ... def validate_image_file_extension(value: File) -> None: ... class ProhibitNullCharactersValidator: message: str = ... code: str = ... def __init__(self, message: Optional[_ErrorMessage] = ..., code: Optional[str] = ...) -> None: ... def __call__(self, value: Any) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/core/wsgi.pyi0000664000175000017500000000014200000000000025265 0ustar00davedave00000000000000from django.core.handlers.wsgi import WSGIHandler def get_wsgi_application() -> WSGIHandler: ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4023793 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/db/0000775000175000017500000000000000000000000023231 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/db/__init__.pyi0000664000175000017500000000165000000000000025515 0ustar00davedave00000000000000from typing import Any from .utils import ( DEFAULT_DB_ALIAS as DEFAULT_DB_ALIAS, DJANGO_VERSION_PICKLE_KEY as DJANGO_VERSION_PICKLE_KEY, ProgrammingError as ProgrammingError, IntegrityError as IntegrityError, OperationalError as OperationalError, DatabaseError as DatabaseError, DataError as DataError, NotSupportedError as NotSupportedError, InternalError as InternalError, InterfaceError as InterfaceError, ConnectionHandler as ConnectionHandler, Error as Error, ConnectionDoesNotExist as ConnectionDoesNotExist, ) from . import migrations connections: Any router: Any connection: Any class DefaultConnectionProxy: def __getattr__(self, item: str) -> Any: ... def __setattr__(self, name: str, value: Any) -> None: ... def __delattr__(self, name: str) -> None: ... def close_old_connections(**kwargs: Any) -> None: ... def reset_queries(**kwargs: Any) -> None: ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4023793 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/db/backends/0000775000175000017500000000000000000000000025003 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/db/backends/__init__.pyi0000664000175000017500000000000000000000000027253 0ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4023793 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/db/backends/base/0000775000175000017500000000000000000000000025715 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/db/backends/base/__init__.pyi0000664000175000017500000000000000000000000030165 0ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/db/backends/base/base.pyi0000664000175000017500000001037400000000000027357 0ustar00davedave00000000000000from typing import Any, Callable, Dict, Iterator, List, Optional from django.db.backends.base.client import BaseDatabaseClient from django.db.backends.base.creation import BaseDatabaseCreation from django.db.backends.base.validation import BaseDatabaseValidation from django.db.backends.utils import CursorDebugWrapper, CursorWrapper from django.db.backends.base.schema import BaseDatabaseSchemaEditor from django.db.backends.base.features import BaseDatabaseFeatures from django.db.backends.base.introspection import BaseDatabaseIntrospection NO_DB_ALIAS: str class BaseDatabaseWrapper: data_types: Any = ... data_types_suffix: Any = ... data_type_check_constraints: Any = ... ops: Any = ... vendor: str = ... display_name: str = ... SchemaEditorClass: Optional[BaseDatabaseSchemaEditor] = ... client_class: Any = ... creation_class: Any = ... features_class: Any = ... introspection_class: Any = ... ops_class: Any = ... validation_class: Any = ... queries_limit: int = ... connection: Any = ... settings_dict: Any = ... alias: str = ... queries_log: Any = ... force_debug_cursor: bool = ... autocommit: bool = ... in_atomic_block: bool = ... savepoint_state: int = ... savepoint_ids: Any = ... commit_on_exit: bool = ... needs_rollback: bool = ... close_at: Optional[Any] = ... closed_in_transaction: bool = ... errors_occurred: bool = ... allow_thread_sharing: bool = ... run_on_commit: List[Any] = ... run_commit_hooks_on_set_autocommit_on: bool = ... execute_wrappers: List[Any] = ... client: BaseDatabaseClient = ... creation: BaseDatabaseCreation = ... features: BaseDatabaseFeatures = ... introspection: BaseDatabaseIntrospection = ... validation: BaseDatabaseValidation = ... def __init__( self, settings_dict: Dict[str, Dict[str, str]], alias: str = ..., allow_thread_sharing: bool = ... ) -> None: ... def ensure_timezone(self) -> bool: ... def timezone(self): ... def timezone_name(self): ... @property def queries_logged(self) -> bool: ... @property def queries(self) -> List[Dict[str, str]]: ... def get_connection_params(self) -> None: ... def get_new_connection(self, conn_params: Any) -> None: ... def init_connection_state(self) -> None: ... def create_cursor(self, name: Optional[Any] = ...) -> None: ... def connect(self) -> None: ... def check_settings(self) -> None: ... def ensure_connection(self) -> None: ... def cursor(self) -> CursorWrapper: ... def commit(self) -> None: ... def rollback(self) -> None: ... def close(self) -> None: ... def savepoint(self) -> str: ... def savepoint_rollback(self, sid: str) -> None: ... def savepoint_commit(self, sid: str) -> None: ... def clean_savepoints(self) -> None: ... def get_autocommit(self) -> bool: ... def set_autocommit(self, autocommit: bool, force_begin_transaction_with_broken_autocommit: bool = ...) -> None: ... def get_rollback(self) -> bool: ... def set_rollback(self, rollback: bool) -> None: ... def validate_no_atomic_block(self) -> None: ... def validate_no_broken_transaction(self) -> None: ... def constraint_checks_disabled(self) -> Iterator[None]: ... def disable_constraint_checking(self): ... def enable_constraint_checking(self) -> None: ... def check_constraints(self, table_names: Optional[Any] = ...) -> None: ... def is_usable(self) -> None: ... def close_if_unusable_or_obsolete(self) -> None: ... def validate_thread_sharing(self) -> None: ... def prepare_database(self) -> None: ... def wrap_database_errors(self) -> Any: ... def chunked_cursor(self) -> CursorWrapper: ... def make_debug_cursor(self, cursor: CursorWrapper) -> CursorDebugWrapper: ... def make_cursor(self, cursor: CursorWrapper) -> CursorWrapper: ... def temporary_connection(self) -> None: ... def schema_editor(self, *args: Any, **kwargs: Any) -> BaseDatabaseSchemaEditor: ... def on_commit(self, func: Callable) -> None: ... def run_and_clear_commit_hooks(self) -> None: ... def execute_wrapper(self, wrapper: Callable) -> Iterator[None]: ... def copy(self, alias: None = ..., allow_thread_sharing: None = ...) -> Any: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/db/backends/base/client.pyi0000664000175000017500000000042200000000000027714 0ustar00davedave00000000000000from typing import Any from django.db.backends.base.base import BaseDatabaseWrapper class BaseDatabaseClient: executable_name: Any = ... connection: Any = ... def __init__(self, connection: BaseDatabaseWrapper) -> None: ... def runshell(self) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/db/backends/base/creation.pyi0000664000175000017500000000211700000000000030245 0ustar00davedave00000000000000from typing import Any, Dict, Optional, Tuple, Union from django.db.backends.base.base import BaseDatabaseWrapper TEST_DATABASE_PREFIX: str class BaseDatabaseCreation: connection: Any = ... def __init__(self, connection: BaseDatabaseWrapper) -> None: ... def create_test_db( self, verbosity: int = ..., autoclobber: bool = ..., serialize: bool = ..., keepdb: bool = ... ) -> str: ... def set_as_test_mirror( self, primary_settings_dict: Dict[str, Optional[Union[Dict[str, None], int, str]]] ) -> None: ... def serialize_db_to_string(self) -> str: ... def deserialize_db_from_string(self, data: str) -> None: ... def clone_test_db(self, suffix: Any, verbosity: int = ..., autoclobber: bool = ..., keepdb: bool = ...) -> None: ... def get_test_db_clone_settings(self, suffix: Any): ... def destroy_test_db( self, old_database_name: str = ..., verbosity: int = ..., keepdb: bool = ..., suffix: None = ... ) -> None: ... def sql_table_creation_suffix(self): ... def test_db_signature(self) -> Tuple[str, str, str, str]: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/db/backends/base/features.pyi0000664000175000017500000001022400000000000030255 0ustar00davedave00000000000000from typing import Any from django.db.backends.base.base import BaseDatabaseWrapper class BaseDatabaseFeatures: gis_enabled: bool = ... allows_group_by_pk: bool = ... allows_group_by_selected_pks: bool = ... empty_fetchmany_value: Any = ... update_can_self_select: bool = ... interprets_empty_strings_as_nulls: bool = ... supports_nullable_unique_constraints: bool = ... supports_partially_nullable_unique_constraints: bool = ... can_use_chunked_reads: bool = ... can_return_id_from_insert: bool = ... can_return_ids_from_bulk_insert: bool = ... has_bulk_insert: bool = ... uses_savepoints: bool = ... can_release_savepoints: bool = ... related_fields_match_type: bool = ... allow_sliced_subqueries_with_in: bool = ... has_select_for_update: bool = ... has_select_for_update_nowait: bool = ... has_select_for_update_skip_locked: bool = ... has_select_for_update_of: bool = ... select_for_update_of_column: bool = ... test_db_allows_multiple_connections: bool = ... supports_unspecified_pk: bool = ... supports_forward_references: bool = ... truncates_names: bool = ... has_real_datatype: bool = ... supports_subqueries_in_group_by: bool = ... has_native_uuid_field: bool = ... has_native_duration_field: bool = ... supports_temporal_subtraction: bool = ... supports_regex_backreferencing: bool = ... supports_date_lookup_using_string: bool = ... supports_timezones: bool = ... has_zoneinfo_database: bool = ... requires_explicit_null_ordering_when_grouping: bool = ... nulls_order_largest: bool = ... max_query_params: Any = ... allows_auto_pk_0: bool = ... can_defer_constraint_checks: bool = ... supports_mixed_date_datetime_comparisons: bool = ... supports_tablespaces: bool = ... supports_sequence_reset: bool = ... can_introspect_default: bool = ... can_introspect_foreign_keys: bool = ... can_introspect_autofield: bool = ... can_introspect_big_integer_field: bool = ... can_introspect_binary_field: bool = ... can_introspect_decimal_field: bool = ... can_introspect_ip_address_field: bool = ... can_introspect_positive_integer_field: bool = ... can_introspect_small_integer_field: bool = ... can_introspect_time_field: bool = ... introspected_boolean_field_type: str = ... supports_index_column_ordering: bool = ... can_distinct_on_fields: bool = ... autocommits_when_autocommit_is_off: bool = ... atomic_transactions: bool = ... can_rollback_ddl: bool = ... supports_atomic_references_rename: bool = ... supports_combined_alters: bool = ... supports_foreign_keys: bool = ... supports_column_check_constraints: bool = ... supports_paramstyle_pyformat: bool = ... requires_literal_defaults: bool = ... connection_persists_old_columns: bool = ... closed_cursor_error_class: Any = ... has_case_insensitive_like: bool = ... requires_sqlparse_for_splitting: bool = ... bare_select_suffix: str = ... implied_column_null: bool = ... uppercases_column_names: bool = ... supports_select_for_update_with_limit: bool = ... greatest_least_ignores_nulls: bool = ... can_clone_databases: bool = ... ignores_table_name_case: bool = ... for_update_after_from: bool = ... supports_select_union: bool = ... supports_select_intersection: bool = ... supports_select_difference: bool = ... supports_slicing_ordering_in_compound: bool = ... supports_aggregate_filter_clause: bool = ... supports_index_on_text_field: bool = ... supports_over_clause: bool = ... supports_cast_with_precision: bool = ... create_test_procedure_without_params_sql: Any = ... create_test_procedure_with_int_param_sql: Any = ... supports_callproc_kwargs: bool = ... db_functions_convert_bytes_to_str: bool = ... supported_explain_formats: Any = ... validates_explain_options: bool = ... connection: Any = ... def __init__(self, connection: BaseDatabaseWrapper) -> None: ... def supports_explaining_query_execution(self) -> bool: ... def supports_transactions(self): ... def supports_stddev(self): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/db/backends/base/introspection.pyi0000664000175000017500000000272200000000000031343 0ustar00davedave00000000000000from collections import namedtuple from typing import Any, Dict, List, Optional, Set, Type from django.db.backends.base.base import BaseDatabaseWrapper from django.db.backends.utils import CursorWrapper from django.db.models.base import Model TableInfo = namedtuple("TableInfo", ["name", "type"]) FieldInfo = namedtuple("FieldInfo", "name type_code display_size internal_size precision scale null_ok default") class BaseDatabaseIntrospection: data_types_reverse: Any = ... connection: Any = ... def __init__(self, connection: BaseDatabaseWrapper) -> None: ... def get_field_type(self, data_type: str, description: FieldInfo) -> str: ... def table_name_converter(self, name: str) -> str: ... def column_name_converter(self, name: str) -> str: ... def table_names(self, cursor: Optional[CursorWrapper] = ..., include_views: bool = ...) -> List[str]: ... def get_table_list(self, cursor: Any) -> None: ... def django_table_names(self, only_existing: bool = ..., include_views: bool = ...) -> List[str]: ... def installed_models(self, tables: List[str]) -> Set[Type[Model]]: ... def sequence_list(self) -> List[Dict[str, str]]: ... def get_sequences(self, cursor: Any, table_name: Any, table_fields: Any = ...) -> None: ... def get_key_columns(self, cursor: Any, table_name: Any) -> None: ... def get_primary_key_column(self, cursor: Any, table_name: Any): ... def get_constraints(self, cursor: Any, table_name: Any) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/db/backends/base/operations.pyi0000664000175000017500000001413500000000000030627 0ustar00davedave00000000000000from datetime import date, datetime, timedelta, time from decimal import Decimal from typing import Any, List, Optional, Sequence, Tuple, Type, Union from django.core.management.color import Style from django.db.backends.base.base import BaseDatabaseWrapper from django.db.backends.utils import CursorWrapper from django.db.models.base import Model from django.db.models.expressions import Case, Expression from django.db.models.sql.compiler import SQLCompiler from django.db import DefaultConnectionProxy from django.db.models.fields import Field _Connection = Union[DefaultConnectionProxy, BaseDatabaseWrapper] class BaseDatabaseOperations: compiler_module: str = ... integer_field_ranges: Any = ... set_operators: Any = ... cast_data_types: Any = ... cast_char_field_without_max_length: Any = ... PRECEDING: str = ... FOLLOWING: str = ... UNBOUNDED_PRECEDING: Any = ... UNBOUNDED_FOLLOWING: Any = ... CURRENT_ROW: str = ... explain_prefix: Any = ... connection: _Connection = ... def __init__(self, connection: Optional[_Connection]) -> None: ... def autoinc_sql(self, table: str, column: str) -> None: ... def bulk_batch_size(self, fields: Any, objs: Any): ... def cache_key_culling_sql(self) -> str: ... def unification_cast_sql(self, output_field: Field) -> str: ... def date_extract_sql(self, lookup_type: None, field_name: None) -> Any: ... def date_interval_sql(self, timedelta: None) -> Any: ... def date_trunc_sql(self, lookup_type: None, field_name: None) -> Any: ... def datetime_cast_date_sql(self, field_name: None, tzname: None) -> Any: ... def datetime_cast_time_sql(self, field_name: None, tzname: None) -> Any: ... def datetime_extract_sql(self, lookup_type: None, field_name: None, tzname: None) -> Any: ... def datetime_trunc_sql(self, lookup_type: None, field_name: None, tzname: None) -> Any: ... def time_trunc_sql(self, lookup_type: None, field_name: None) -> Any: ... def time_extract_sql(self, lookup_type: None, field_name: None) -> Any: ... def deferrable_sql(self) -> str: ... def distinct_sql(self, fields: List[str], params: Optional[List[Any]]) -> Tuple[List[str], List[Any]]: ... def fetch_returned_insert_id(self, cursor: Any): ... def field_cast_sql(self, db_type: Optional[str], internal_type: str) -> str: ... def force_no_ordering(self) -> List[Any]: ... def for_update_sql(self, nowait: bool = ..., skip_locked: bool = ..., of: Any = ...): ... def limit_offset_sql(self, low_mark: int, high_mark: Optional[int]) -> str: ... def last_executed_query(self, cursor: Any, sql: Any, params: Any): ... def last_insert_id(self, cursor: CursorWrapper, table_name: str, pk_name: str) -> int: ... def lookup_cast(self, lookup_type: str, internal_type: str = ...) -> str: ... def max_in_list_size(self) -> None: ... def max_name_length(self) -> None: ... def no_limit_value(self) -> Any: ... def pk_default_value(self) -> str: ... def prepare_sql_script(self, sql: Any): ... def process_clob(self, value: str) -> str: ... def return_insert_id(self) -> None: ... def compiler(self, compiler_name: str) -> Type[SQLCompiler]: ... def quote_name(self, name: str) -> Any: ... def random_function_sql(self): ... def regex_lookup(self, lookup_type: str) -> Any: ... def savepoint_create_sql(self, sid: str) -> str: ... def savepoint_commit_sql(self, sid: str) -> str: ... def savepoint_rollback_sql(self, sid: str) -> str: ... def set_time_zone_sql(self) -> str: ... def sql_flush(self, style: None, tables: None, sequences: None, allow_cascade: bool = ...) -> Any: ... def execute_sql_flush(self, using: str, sql_list: List[str]) -> None: ... def sequence_reset_by_name_sql(self, style: None, sequences: List[Any]) -> List[Any]: ... def sequence_reset_sql(self, style: Style, model_list: Sequence[Type[Model]]) -> List[Any]: ... def start_transaction_sql(self) -> str: ... def end_transaction_sql(self, success: bool = ...) -> str: ... def tablespace_sql(self, tablespace: Optional[str], inline: bool = ...) -> str: ... def prep_for_like_query(self, x: str) -> str: ... prep_for_iexact_query: Any = ... def validate_autopk_value(self, value: int) -> int: ... def adapt_unknown_value(self, value: Any) -> Any: ... def adapt_datefield_value(self, value: Optional[date]) -> Optional[str]: ... def adapt_datetimefield_value(self, value: Optional[datetime]) -> Optional[str]: ... def adapt_timefield_value(self, value: Optional[Union[datetime, time]]) -> Optional[str]: ... def adapt_decimalfield_value( self, value: Optional[Decimal], max_digits: Optional[int] = ..., decimal_places: Optional[int] = ... ) -> Optional[str]: ... def adapt_ipaddressfield_value(self, value: Optional[str]) -> Optional[str]: ... def year_lookup_bounds_for_date_field(self, value: int) -> List[str]: ... def year_lookup_bounds_for_datetime_field(self, value: int) -> List[str]: ... def get_db_converters(self, expression: Expression) -> List[Any]: ... def convert_durationfield_value( self, value: Optional[float], expression: Expression, connection: _Connection ) -> Optional[timedelta]: ... def check_expression_support(self, expression: Any) -> None: ... def combine_expression(self, connector: str, sub_expressions: List[str]) -> str: ... def combine_duration_expression(self, connector: Any, sub_expressions: Any): ... def binary_placeholder_sql(self, value: Optional[Case]) -> str: ... def modify_insert_params(self, placeholder: str, params: Any) -> Any: ... def integer_field_range(self, internal_type: Any): ... def subtract_temporals(self, internal_type: Any, lhs: Any, rhs: Any): ... def window_frame_start(self, start: Any): ... def window_frame_end(self, end: Any): ... def window_frame_rows_start_end(self, start: Optional[int] = ..., end: Optional[int] = ...) -> Any: ... def window_frame_range_start_end(self, start: Optional[int] = ..., end: Optional[int] = ...) -> Any: ... def explain_query_prefix(self, format: Optional[str] = ..., **options: Any) -> str: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/db/backends/base/schema.pyi0000664000175000017500000000642200000000000027704 0ustar00davedave00000000000000from typing import Any, ContextManager, List, Optional, Sequence, Tuple, Type, Union from django.db.backends.ddl_references import Statement from django.db.models.base import Model from django.db.models.indexes import Index from django.db.models.fields import Field logger: Any class BaseDatabaseSchemaEditor(ContextManager[Any]): sql_create_table: str = ... sql_rename_table: str = ... sql_retablespace_table: str = ... sql_delete_table: str = ... sql_create_column: str = ... sql_alter_column: str = ... sql_alter_column_type: str = ... sql_alter_column_null: str = ... sql_alter_column_not_null: str = ... sql_alter_column_default: str = ... sql_alter_column_no_default: str = ... sql_delete_column: str = ... sql_rename_column: str = ... sql_update_with_default: str = ... sql_create_check: str = ... sql_delete_check: str = ... sql_create_unique: str = ... sql_delete_unique: str = ... sql_create_fk: str = ... sql_create_inline_fk: str = ... sql_delete_fk: str = ... sql_create_index: str = ... sql_delete_index: str = ... sql_create_pk: str = ... sql_delete_pk: str = ... sql_delete_procedure: str = ... connection: Any = ... collect_sql: bool = ... collected_sql: Any = ... atomic_migration: Any = ... def __init__(self, connection: Any, collect_sql: bool = ..., atomic: bool = ...) -> None: ... deferred_sql: Any = ... atomic: Any = ... def __enter__(self) -> BaseDatabaseSchemaEditor: ... def __exit__(self, exc_type: Any, exc_value: Any, traceback: Any) -> None: ... def execute(self, sql: Union[Statement, str], params: Optional[Union[List[int], Tuple]] = ...) -> None: ... def quote_name(self, name: str) -> str: ... def column_sql( self, model: Type[Model], field: Field, include_default: bool = ... ) -> Tuple[Optional[str], Optional[List[Any]]]: ... def skip_default(self, field: Any): ... def prepare_default(self, value: Any) -> None: ... def effective_default(self, field: Field) -> Optional[Union[int, str]]: ... def quote_value(self, value: Any) -> None: ... def create_model(self, model: Type[Model]) -> None: ... def delete_model(self, model: Type[Model]) -> None: ... def add_index(self, model: Type[Model], index: Index) -> None: ... def remove_index(self, model: Type[Model], index: Index) -> None: ... def alter_unique_together( self, model: Type[Model], old_unique_together: Sequence[Sequence[str]], new_unique_together: Sequence[Sequence[str]], ) -> None: ... def alter_index_together( self, model: Type[Model], old_index_together: Sequence[Sequence[str]], new_index_together: Sequence[Sequence[str]], ) -> None: ... def alter_db_table(self, model: Type[Model], old_db_table: str, new_db_table: str) -> None: ... def alter_db_tablespace(self, model: Any, old_db_tablespace: Any, new_db_tablespace: Any) -> None: ... def add_field(self, model: Any, field: Any): ... def remove_field(self, model: Any, field: Any): ... def alter_field(self, model: Type[Model], old_field: Field, new_field: Field, strict: bool = ...) -> None: ... def remove_procedure(self, procedure_name: Any, param_types: Any = ...) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/db/backends/base/validation.pyi0000664000175000017500000000060200000000000030570 0ustar00davedave00000000000000from typing import Any, List from django.db.backends.base.base import BaseDatabaseWrapper from django.db.models.fields import Field class BaseDatabaseValidation: connection: Any = ... def __init__(self, connection: BaseDatabaseWrapper) -> None: ... def check(self, **kwargs: Any) -> List[Any]: ... def check_field(self, field: Field, **kwargs: Any) -> List[Any]: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/db/backends/ddl_references.pyi0000664000175000017500000000514100000000000030473 0ustar00davedave00000000000000from typing import Any, Callable, List, Tuple, Union, Dict class Reference: def references_table(self, table: Any): ... def references_column(self, table: Any, column: Any): ... def rename_table_references(self, old_table: Any, new_table: Any) -> None: ... def rename_column_references(self, table: Any, old_column: Any, new_column: Any) -> None: ... class Table(Reference): table: str = ... quote_name: Callable = ... def __init__(self, table: str, quote_name: Callable) -> None: ... def references_table(self, table: str) -> bool: ... def rename_table_references(self, old_table: str, new_table: str) -> None: ... class TableColumns(Table): table: str = ... columns: List[str] = ... def __init__(self, table: str, columns: List[str]) -> None: ... def references_column(self, table: str, column: str) -> bool: ... def rename_column_references(self, table: str, old_column: str, new_column: str) -> None: ... class Columns(TableColumns): columns: List[str] table: str quote_name: Callable = ... col_suffixes: Tuple = ... def __init__( self, table: str, columns: List[str], quote_name: Callable, col_suffixes: Union[List[str], Tuple] = ... ) -> None: ... class IndexName(TableColumns): columns: List[str] table: str suffix: str = ... create_index_name: Callable = ... def __init__(self, table: str, columns: List[str], suffix: str, create_index_name: Callable) -> None: ... class ForeignKeyName(TableColumns): columns: List[str] table: str to_reference: TableColumns = ... suffix_template: str = ... create_fk_name: Callable = ... def __init__( self, from_table: str, from_columns: List[str], to_table: str, to_columns: List[str], suffix_template: str, create_fk_name: Callable, ) -> None: ... def references_table(self, table: str) -> bool: ... def references_column(self, table: str, column: str) -> bool: ... def rename_table_references(self, old_table: str, new_table: str) -> None: ... def rename_column_references(self, table: str, old_column: str, new_column: str) -> None: ... class Statement(Reference): template: str = ... parts: Dict[str, Table] = ... def __init__(self, template: str, **parts: Any) -> None: ... def references_table(self, table: str) -> bool: ... def references_column(self, table: str, column: str) -> bool: ... def rename_table_references(self, old_table: str, new_table: str) -> None: ... def rename_column_references(self, table: str, old_column: str, new_column: str) -> None: ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4023793 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/db/backends/dummy/0000775000175000017500000000000000000000000026136 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/db/backends/dummy/__init__.pyi0000664000175000017500000000000000000000000030406 0ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/db/backends/dummy/base.pyi0000664000175000017500000000200500000000000027570 0ustar00davedave00000000000000from typing import Any from django.db.backends.base.base import BaseDatabaseWrapper from django.db.backends.base.client import BaseDatabaseClient from django.db.backends.base.creation import BaseDatabaseCreation from django.db.backends.base.introspection import BaseDatabaseIntrospection from django.db.backends.base.operations import BaseDatabaseOperations def complain(*args: Any, **kwargs: Any) -> Any: ... def ignore(*args: Any, **kwargs: Any) -> None: ... class DatabaseOperations(BaseDatabaseOperations): quote_name: Any = ... class DatabaseClient(BaseDatabaseClient): runshell: Any = ... class DatabaseCreation(BaseDatabaseCreation): create_test_db: Any = ... destroy_test_db: Any = ... class DatabaseIntrospection(BaseDatabaseIntrospection): get_table_list: Any = ... get_table_description: Any = ... get_relations: Any = ... get_indexes: Any = ... get_key_columns: Any = ... class DatabaseWrapper(BaseDatabaseWrapper): operators: Any = ... ensure_connection: Any = ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4023793 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/db/backends/mysql/0000775000175000017500000000000000000000000026150 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/db/backends/mysql/__init__.pyi0000664000175000017500000000000000000000000030420 0ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/db/backends/mysql/client.pyi0000664000175000017500000000057700000000000030162 0ustar00davedave00000000000000from typing import Dict, List, Optional, Union from django.db.backends.base.client import BaseDatabaseClient class DatabaseClient(BaseDatabaseClient): executable_name: str = ... @classmethod def settings_to_cmd_args( cls, settings_dict: Dict[str, Optional[Union[Dict[str, Dict[str, str]], int, str]]] ) -> List[str]: ... def runshell(self) -> None: ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4023793 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/db/backends/postgresql/0000775000175000017500000000000000000000000027206 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/db/backends/postgresql/__init__.pyi0000664000175000017500000000000000000000000031456 0ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/db/backends/postgresql/base.pyi0000664000175000017500000000071300000000000030644 0ustar00davedave00000000000000from typing import Dict, Tuple from django.db.backends.base.base import BaseDatabaseWrapper def psycopg2_version() -> Tuple[int, ...]: ... PSYCOPG2_VERSION: Tuple[int, ...] = ... class DatabaseWrapper(BaseDatabaseWrapper): operators: Dict[str, str] = ... pattern_esc: str = ... pattern_ops: Dict[str, str] = ... # PostgreSQL backend-specific attributes. _named_cursor_idx: int = ... @property def pg_version(self) -> str: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/db/backends/postgresql/client.pyi0000664000175000017500000000043100000000000031205 0ustar00davedave00000000000000from typing import Dict from django.db.backends.base.client import BaseDatabaseClient class DatabaseClient(BaseDatabaseClient): executable_name: str = ... @classmethod def runshell_db(cls, conn_params: Dict[str, str]) -> None: ... def runshell(self) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/db/backends/postgresql/creation.pyi0000664000175000017500000000016500000000000031537 0ustar00davedave00000000000000from django.db.backends.base.creation import BaseDatabaseCreation class DatabaseCreation(BaseDatabaseCreation): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/db/backends/postgresql/operations.pyi0000664000175000017500000000017500000000000032117 0ustar00davedave00000000000000from django.db.backends.base.operations import BaseDatabaseOperations class DatabaseOperations(BaseDatabaseOperations): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/db/backends/signals.pyi0000664000175000017500000000010500000000000027162 0ustar00davedave00000000000000from django.dispatch import Signal connection_created: Signal = ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4023793 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/db/backends/sqlite3/0000775000175000017500000000000000000000000026367 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/db/backends/sqlite3/__init__.pyi0000664000175000017500000000000000000000000030637 0ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/db/backends/sqlite3/base.pyi0000664000175000017500000000053500000000000030027 0ustar00davedave00000000000000from sqlite3 import dbapi2 as Database from typing import Any, Callable from django.db.backends.base.base import BaseDatabaseWrapper def decoder(conv_func: Callable) -> Callable: ... class DatabaseWrapper(BaseDatabaseWrapper): ... FORMAT_QMARK_REGEX: Any class SQLiteCursorWrapper(Database.Cursor): ... def check_sqlite_version() -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/db/backends/sqlite3/creation.pyi0000664000175000017500000000016500000000000030720 0ustar00davedave00000000000000from django.db.backends.base.creation import BaseDatabaseCreation class DatabaseCreation(BaseDatabaseCreation): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/db/backends/sqlite3/features.pyi0000664000175000017500000000016500000000000030732 0ustar00davedave00000000000000from django.db.backends.base.features import BaseDatabaseFeatures class DatabaseFeatures(BaseDatabaseFeatures): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/db/backends/sqlite3/introspection.pyi0000664000175000017500000000055300000000000032015 0ustar00davedave00000000000000from typing import Any, Optional from django.db.backends.base.introspection import BaseDatabaseIntrospection field_size_re: Any def get_field_size(name: str) -> Optional[int]: ... class FlexibleFieldLookupDict: base_data_types_reverse: Any = ... def __getitem__(self, key: str) -> Any: ... class DatabaseIntrospection(BaseDatabaseIntrospection): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/db/backends/sqlite3/operations.pyi0000664000175000017500000000017500000000000031300 0ustar00davedave00000000000000from django.db.backends.base.operations import BaseDatabaseOperations class DatabaseOperations(BaseDatabaseOperations): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/db/backends/sqlite3/schema.pyi0000664000175000017500000000017700000000000030357 0ustar00davedave00000000000000from django.db.backends.base.schema import BaseDatabaseSchemaEditor class DatabaseSchemaEditor(BaseDatabaseSchemaEditor): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/db/backends/utils.pyi0000664000175000017500000000345300000000000026673 0ustar00davedave00000000000000import types from datetime import date, datetime, time from decimal import Decimal from typing import Any, Dict, List, Mapping, Optional, Sequence, Tuple, Type, Union from uuid import UUID logger: Any # Python types that can be adapted to SQL. _SQLType = Union[None, bool, int, float, Decimal, str, bytes, datetime, UUID] class CursorWrapper: cursor: Any = ... db: Any = ... def __init__(self, cursor: Any, db: Any) -> None: ... WRAP_ERROR_ATTRS: Any = ... def __getattr__(self, attr: str) -> Any: ... def __iter__(self) -> None: ... def __enter__(self) -> CursorWrapper: ... def __exit__( self, exc_type: Optional[Type[BaseException]], exc_value: Optional[BaseException], tb: Optional[types.TracebackType], ) -> None: ... def callproc(self, procname: str, params: List[Any] = ..., kparams: Dict[str, int] = ...) -> Any: ... def execute( self, sql: str, params: Optional[Union[Sequence[_SQLType], Mapping[str, _SQLType]]] = ... ) -> Optional[Any]: ... def executemany( self, sql: str, param_list: Sequence[Optional[Union[Sequence[_SQLType], Mapping[str, _SQLType]]]] ) -> Optional[Any]: ... class CursorDebugWrapper(CursorWrapper): cursor: Any db: Any def typecast_date(s: Optional[str]) -> Optional[date]: ... def typecast_time(s: Optional[str]) -> Optional[time]: ... def typecast_timestamp(s: Optional[str]) -> Optional[date]: ... def rev_typecast_decimal(d: Decimal) -> str: ... def split_identifier(identifier: str) -> Tuple[str, str]: ... def truncate_name(identifier: str, length: Optional[int] = ..., hash_len: int = ...) -> str: ... def format_number( value: Optional[Decimal], max_digits: Optional[int], decimal_places: Optional[int] ) -> Optional[str]: ... def strip_quotes(table_name: str) -> str: ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4023793 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/db/migrations/0000775000175000017500000000000000000000000025405 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/db/migrations/__init__.pyi0000664000175000017500000000036300000000000027671 0ustar00davedave00000000000000# Stubs for django.db.migrations (Python 3.6) # # NOTE: This dynamically typed stub was automatically generated by stubgen. from .migration import Migration as Migration, swappable_dependency as swappable_dependency from .operations import * ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/db/migrations/autodetector.pyi0000664000175000017500000000570300000000000030637 0ustar00davedave00000000000000from typing import Any, Callable, Dict, List, Optional, Set, Tuple, Union from django.db.migrations.graph import MigrationGraph from django.db.migrations.migration import Migration from django.db.migrations.operations.base import Operation from django.db.migrations.questioner import MigrationQuestioner from django.db.migrations.state import ProjectState from django.db.models.fields import Field class MigrationAutodetector: from_state: ProjectState = ... to_state: ProjectState = ... questioner: MigrationQuestioner = ... existing_apps: Set[Any] = ... def __init__( self, from_state: ProjectState, to_state: ProjectState, questioner: Optional[MigrationQuestioner] = ... ) -> None: ... def changes( self, graph: MigrationGraph, trim_to_apps: Optional[Set[str]] = ..., convert_apps: Optional[Set[str]] = ..., migration_name: Optional[str] = ..., ) -> Dict[str, List[Migration]]: ... def deep_deconstruct(self, obj: Any) -> Any: ... def only_relation_agnostic_fields( self, fields: List[Tuple[str, Field]] ) -> List[Tuple[str, List[Any], Dict[str, Union[Callable, int, str]]]]: ... def check_dependency( self, operation: Operation, dependency: Tuple[str, str, Optional[str], Union[bool, str]] ) -> bool: ... def add_operation( self, app_label: str, operation: Operation, dependencies: Optional[List[Tuple[str, str, Optional[str], Union[bool, str]]]] = ..., beginning: bool = ..., ) -> None: ... def swappable_first_key(self, item: Tuple[str, str]) -> Tuple[str, str]: ... renamed_models: Any = ... renamed_models_rel: Any = ... def generate_renamed_models(self) -> None: ... def generate_created_models(self) -> None: ... def generate_created_proxies(self) -> None: ... def generate_deleted_models(self) -> None: ... def generate_deleted_proxies(self) -> None: ... renamed_fields: Any = ... def generate_renamed_fields(self) -> None: ... def generate_added_fields(self) -> None: ... def generate_removed_fields(self) -> None: ... def generate_altered_fields(self) -> None: ... def create_altered_indexes(self) -> None: ... def generate_added_indexes(self) -> None: ... def generate_removed_indexes(self) -> None: ... def generate_altered_unique_together(self) -> None: ... def generate_altered_index_together(self) -> None: ... def generate_altered_db_table(self) -> None: ... def generate_altered_options(self) -> None: ... def generate_altered_order_with_respect_to(self) -> None: ... def generate_altered_managers(self) -> None: ... def arrange_for_graph( self, changes: Dict[str, List[Migration]], graph: MigrationGraph, migration_name: Optional[str] = ... ) -> Dict[str, List[Migration]]: ... @classmethod def suggest_name(cls, ops: List[Operation]) -> str: ... @classmethod def parse_number(cls, name: str) -> int: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/db/migrations/exceptions.pyi0000664000175000017500000000130500000000000030310 0ustar00davedave00000000000000from typing import Optional, Tuple from django.db.migrations.migration import Migration from django.db.utils import DatabaseError class AmbiguityError(Exception): ... class BadMigrationError(Exception): ... class CircularDependencyError(Exception): ... class InconsistentMigrationHistory(Exception): ... class InvalidBasesError(ValueError): ... class IrreversibleError(RuntimeError): ... class NodeNotFoundError(LookupError): message: str = ... origin: None = ... node: Tuple[str, str] = ... def __init__(self, message: str, node: Tuple[str, str], origin: Optional[Migration] = ...) -> None: ... class MigrationSchemaMissing(DatabaseError): ... class InvalidMigrationPlan(ValueError): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/db/migrations/executor.pyi0000664000175000017500000000321700000000000027771 0ustar00davedave00000000000000from typing import Any, Callable, List, Optional, Set, Tuple, Union from django.db import DefaultConnectionProxy from django.db.backends.base.base import BaseDatabaseWrapper from django.db.migrations.migration import Migration from .loader import MigrationLoader from .recorder import MigrationRecorder from .state import ProjectState class MigrationExecutor: connection: Any = ... loader: MigrationLoader = ... recorder: MigrationRecorder = ... progress_callback: Callable = ... def __init__( self, connection: Optional[Union[DefaultConnectionProxy, BaseDatabaseWrapper]], progress_callback: Optional[Callable] = ..., ) -> None: ... def migration_plan( self, targets: Union[List[Tuple[str, Optional[str]]], Set[Tuple[str, str]]], clean_start: bool = ... ) -> List[Tuple[Migration, bool]]: ... def migrate( self, targets: Optional[List[Tuple[str, Optional[str]]]], plan: Optional[List[Tuple[Migration, bool]]] = ..., state: Optional[ProjectState] = ..., fake: bool = ..., fake_initial: bool = ..., ) -> ProjectState: ... def collect_sql(self, plan: List[Tuple[Migration, bool]]) -> List[str]: ... def apply_migration( self, state: ProjectState, migration: Migration, fake: bool = ..., fake_initial: bool = ... ) -> ProjectState: ... def unapply_migration(self, state: ProjectState, migration: Migration, fake: bool = ...) -> ProjectState: ... def check_replacements(self) -> None: ... def detect_soft_applied( self, project_state: Optional[ProjectState], migration: Migration ) -> Tuple[bool, ProjectState]: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/db/migrations/graph.pyi0000664000175000017500000000474300000000000027241 0ustar00davedave00000000000000from typing import Any, Dict, List, Optional, Set, Tuple, Union from django.db.migrations.migration import Migration, SwappableTuple from django.db.migrations.state import ProjectState RECURSION_DEPTH_WARNING: str class Node: key: Tuple[str, str] = ... children: Set[Any] = ... parents: Set[Any] = ... def __init__(self, key: Tuple[str, str]) -> None: ... def __lt__(self, other: Union[Tuple[str, str], Node]) -> bool: ... def __getitem__(self, item: int) -> str: ... def add_child(self, child: Node) -> None: ... def add_parent(self, parent: Node) -> None: ... def ancestors(self) -> List[Tuple[str, str]]: ... def descendants(self) -> List[Tuple[str, str]]: ... class DummyNode(Node): origin: Any = ... error_message: Any = ... def __init__(self, key: Tuple[str, str], origin: Union[Migration, str], error_message: str) -> None: ... def promote(self) -> None: ... def raise_error(self) -> None: ... class MigrationGraph: node_map: Dict[Any, Any] = ... nodes: Dict[Any, Any] = ... cached: bool = ... def __init__(self) -> None: ... def add_node(self, key: Tuple[str, str], migration: Optional[Migration]) -> None: ... def add_dummy_node(self, key: Tuple[str, str], origin: Union[Migration, str], error_message: str) -> None: ... def add_dependency( self, migration: Optional[Union[Migration, str]], child: Tuple[str, str], parent: Tuple[str, str], skip_validation: bool = ..., ) -> None: ... def remove_replaced_nodes(self, replacement: Tuple[str, str], replaced: List[Tuple[str, str]]) -> None: ... def remove_replacement_node(self, replacement: Tuple[str, str], replaced: List[Tuple[str, str]]) -> None: ... def validate_consistency(self) -> None: ... def clear_cache(self) -> None: ... def forwards_plan(self, target: Tuple[str, str]) -> List[Tuple[str, str]]: ... def backwards_plan(self, target: Union[Tuple[str, str], Node]) -> List[Tuple[str, str]]: ... def iterative_dfs(self, start: Any, forwards: bool = ...): ... def root_nodes(self, app: Optional[str] = ...) -> List[Tuple[str, str]]: ... def leaf_nodes(self, app: Optional[str] = ...) -> List[Tuple[str, str]]: ... def ensure_not_cyclic(self) -> None: ... def make_state( self, nodes: Optional[Tuple[str, str]] = ..., at_end: bool = ..., real_apps: List[str] = ... ) -> ProjectState: ... def __contains__(self, node: Union[Tuple[str, str], SwappableTuple]) -> bool: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/db/migrations/loader.pyi0000664000175000017500000000301300000000000027373 0ustar00davedave00000000000000from typing import Any, Dict, Optional, Sequence, Set, Tuple, Union from django.db.migrations.migration import Migration from django.db.migrations.state import ProjectState MIGRATIONS_MODULE_NAME: str class MigrationLoader: connection: Any = ... disk_migrations: Dict[Tuple[str, str], Migration] = ... applied_migrations: Set[Tuple[str, str]] = ... ignore_no_migrations: bool = ... def __init__(self, connection: Any, load: bool = ..., ignore_no_migrations: bool = ...) -> None: ... @classmethod def migrations_module(cls, app_label: str) -> Tuple[Optional[str], bool]: ... unmigrated_apps: Set[str] = ... migrated_apps: Set[str] = ... def load_disk(self) -> None: ... def get_migration(self, app_label: str, name_prefix: str) -> Migration: ... def get_migration_by_prefix(self, app_label: str, name_prefix: str) -> Migration: ... def check_key(self, key: Tuple[str, str], current_app: str) -> Optional[Tuple[str, str]]: ... def add_internal_dependencies(self, key: Tuple[str, str], migration: Migration) -> None: ... def add_external_dependencies(self, key: Tuple[str, str], migration: Migration) -> None: ... graph: Any = ... replacements: Any = ... def build_graph(self) -> None: ... def check_consistent_history(self, connection: Any) -> None: ... def detect_conflicts(self) -> Dict[str, Set[str]]: ... def project_state( self, nodes: Optional[Union[Tuple[str, str], Sequence[Tuple[str, str]]]] = ..., at_end: bool = ... ) -> ProjectState: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/db/migrations/migration.pyi0000664000175000017500000000205000000000000030116 0ustar00davedave00000000000000from typing import Any, List, Tuple from django.db.backends.base.schema import BaseDatabaseSchemaEditor from django.db.migrations.state import ProjectState class Migration: operations: List[Any] = ... dependencies: List[Any] = ... run_before: List[Any] = ... replaces: List[Any] = ... initial: Any = ... atomic: bool = ... name: str = ... app_label: str = ... def __init__(self, name: str, app_label: str) -> None: ... def mutate_state(self, project_state: ProjectState, preserve: bool = ...) -> ProjectState: ... def apply( self, project_state: ProjectState, schema_editor: BaseDatabaseSchemaEditor, collect_sql: bool = ... ) -> ProjectState: ... def unapply( self, project_state: ProjectState, schema_editor: BaseDatabaseSchemaEditor, collect_sql: bool = ... ) -> ProjectState: ... class SwappableTuple(Tuple[str, str]): setting: str = ... def __new__(cls, value: Tuple[str, str], setting: str) -> SwappableTuple: ... def swappable_dependency(value: str) -> SwappableTuple: ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4023793 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/db/migrations/operations/0000775000175000017500000000000000000000000027570 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/db/migrations/operations/__init__.pyi0000664000175000017500000000143400000000000032054 0ustar00davedave00000000000000from .fields import ( AddField as AddField, AlterField as AlterField, RemoveField as RemoveField, RenameField as RenameField, ) from .models import ( AddIndex as AddIndex, AlterIndexTogether as AlterIndexTogether, AlterModelManagers as AlterModelManagers, AlterModelOptions as AlterModelOptions, AlterModelTable as AlterModelTable, AlterOrderWithRespectTo as AlterOrderWithRespectTo, AlterUniqueTogether as AlterUniqueTogether, CreateModel as CreateModel, DeleteModel as DeleteModel, RemoveIndex as RemoveIndex, RenameModel as RenameModel, AddConstraint as AddConstraint, RemoveConstraint as RemoveConstraint, ) from .special import RunPython as RunPython, RunSQL as RunSQL, SeparateDatabaseAndState as SeparateDatabaseAndState ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/db/migrations/operations/base.pyi0000664000175000017500000000160600000000000031230 0ustar00davedave00000000000000from typing import Any, List class Operation: reversible: bool = ... reduces_to_sql: bool = ... atomic: bool = ... elidable: bool = ... serialization_expand_args: Any = ... def deconstruct(self): ... def state_forwards(self, app_label: Any, state: Any) -> None: ... def database_forwards(self, app_label: Any, schema_editor: Any, from_state: Any, to_state: Any) -> None: ... def database_backwards(self, app_label: Any, schema_editor: Any, from_state: Any, to_state: Any) -> None: ... def describe(self): ... def references_model(self, name: str, app_label: str = ...) -> bool: ... def references_field(self, model_name: str, name: str, app_label: str = ...) -> bool: ... def allow_migrate_model(self, connection_alias: Any, model: Any): ... def reduce(self, operation: Operation, in_between: List[Operation], app_label: str = ...) -> bool: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/db/migrations/operations/fields.pyi0000664000175000017500000000221600000000000031562 0ustar00davedave00000000000000from typing import Any, Optional from django.db.models.fields import Field from .base import Operation class FieldOperation(Operation): model_name: str = ... model_name_lower: str name: str = ... def __init__(self, model_name: str, name: str, field: Optional[Field] = ...) -> None: ... def name_lower(self) -> str: ... def is_same_model_operation(self, operation: FieldOperation) -> bool: ... def is_same_field_operation(self, operation: AddField) -> bool: ... class AddField(FieldOperation): field: Field = ... preserve_default: bool = ... def __init__(self, model_name: str, name: str, field: Field, preserve_default: bool = ...) -> None: ... class RemoveField(FieldOperation): ... class AlterField(FieldOperation): field: Any = ... preserve_default: Any = ... def __init__(self, model_name: str, name: str, field: Field, preserve_default: bool = ...) -> None: ... class RenameField(FieldOperation): old_name: Any = ... new_name: Any = ... def __init__(self, model_name: str, old_name: str, new_name: str) -> None: ... def old_name_lower(self): ... def new_name_lower(self) -> str: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/db/migrations/operations/models.pyi0000664000175000017500000000612200000000000031577 0ustar00davedave00000000000000from typing import Any, Collection, Dict, List, Optional, Sequence, Tuple, Union from django.db.migrations.operations.base import Operation from django.db.models.indexes import Index from django.db.models.manager import Manager from django.db.models.constraints import BaseConstraint from django.db.models.fields import Field class ModelOperation(Operation): name: str = ... def __init__(self, name: str) -> None: ... def name_lower(self) -> str: ... class CreateModel(ModelOperation): fields: Sequence[Tuple[str, Field]] = ... options: Any = ... bases: Optional[Sequence[Union[type, str]]] = ... managers: Optional[Sequence[Tuple[str, Manager]]] = ... def __init__( self, name: str, fields: Sequence[Tuple[str, Field]], options: Optional[Dict[str, Any]] = ..., bases: Optional[Sequence[Union[type, str]]] = ..., managers: Optional[Sequence[Tuple[str, Manager]]] = ..., ) -> None: ... def model_to_key(self, model: str) -> List[str]: ... class DeleteModel(ModelOperation): ... class RenameModel(ModelOperation): old_name: Any = ... new_name: Any = ... def __init__(self, old_name: str, new_name: str) -> None: ... def old_name_lower(self) -> str: ... def new_name_lower(self) -> str: ... class AlterModelTable(ModelOperation): table: Optional[str] = ... def __init__(self, name: str, table: Optional[str]) -> None: ... class ModelOptionOperation(ModelOperation): ... class FieldRelatedOptionOperation(ModelOptionOperation): ... class AlterUniqueTogether(FieldRelatedOptionOperation): option_name: str = ... unique_together: Collection[Sequence[str]] = ... def __init__(self, name: str, unique_together: Optional[Collection[Sequence[str]]]) -> None: ... class AlterIndexTogether(FieldRelatedOptionOperation): option_name: str = ... index_together: Collection[Sequence[str]] = ... def __init__(self, name: str, index_together: Optional[Collection[Sequence[str]]]) -> None: ... class AlterOrderWithRespectTo(FieldRelatedOptionOperation): order_with_respect_to: str = ... def __init__(self, name: str, order_with_respect_to: str) -> None: ... class AlterModelOptions(ModelOptionOperation): ALTER_OPTION_KEYS: Any = ... options: Dict[str, str] = ... def __init__(self, name: str, options: Dict[str, Any]) -> None: ... class AlterModelManagers(ModelOptionOperation): managers: Any = ... def __init__(self, name: Any, managers: Any) -> None: ... class IndexOperation(Operation): option_name: str = ... def model_name_lower(self): ... class AddIndex(IndexOperation): model_name: str = ... index: Index = ... def __init__(self, model_name: str, index: Union[str, Index]) -> None: ... class RemoveIndex(IndexOperation): model_name: str = ... name: str = ... def __init__(self, model_name: str, name: Union[str, Index]) -> None: ... class AddConstraint(IndexOperation): def __init__(self, model_name: str, constraint: BaseConstraint): ... class RemoveConstraint(IndexOperation): def __init__(self, model_name: str, name: str) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/db/migrations/operations/special.pyi0000664000175000017500000000247400000000000031742 0ustar00davedave00000000000000from typing import Any, Callable, Dict, Optional, Sequence from django.db.backends.base.schema import BaseDatabaseSchemaEditor from django.db.migrations.state import StateApps from .base import Operation class SeparateDatabaseAndState(Operation): database_operations: Sequence[Operation] = ... state_operations: Sequence[Operation] = ... def __init__( self, database_operations: Sequence[Operation] = ..., state_operations: Sequence[Operation] = ... ) -> None: ... class RunSQL(Operation): noop: str = ... sql: Any = ... reverse_sql: Any = ... state_operations: Any = ... hints: Any = ... def __init__( self, sql: Any, reverse_sql: Optional[Any] = ..., state_operations: Optional[Any] = ..., hints: Optional[Any] = ..., elidable: bool = ..., ) -> None: ... class RunPython(Operation): code: Callable = ... reverse_code: Optional[Callable] = ... hints: Optional[Dict[str, Any]] = ... def __init__( self, code: Callable, reverse_code: Optional[Callable] = ..., atomic: Optional[bool] = ..., hints: Optional[Dict[str, Any]] = ..., elidable: bool = ..., ) -> None: ... @staticmethod def noop(apps: StateApps, schema_editor: BaseDatabaseSchemaEditor) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/db/migrations/operations/utils.pyi0000664000175000017500000000033100000000000031450 0ustar00davedave00000000000000from django.db.migrations.state import ProjectState from django.db.models.fields import Field def is_referenced_by_foreign_key(state: ProjectState, model_name_lower: str, field: Field, field_name: str) -> bool: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/db/migrations/optimizer.pyi0000664000175000017500000000052700000000000030156 0ustar00davedave00000000000000from typing import List, Optional from django.db.migrations.operations.base import Operation class MigrationOptimizer: def optimize(self, operations: List[Operation], app_label: Optional[str] = ...) -> List[Operation]: ... def optimize_inner(self, operations: List[Operation], app_label: Optional[str] = ...) -> List[Operation]: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/db/migrations/questioner.pyi0000664000175000017500000000220400000000000030324 0ustar00davedave00000000000000from typing import Any, Dict, Optional, Set from django.db.migrations.state import ModelState from django.db.models.fields import Field class MigrationQuestioner: defaults: Dict[str, Any] = ... specified_apps: Set[str] = ... dry_run: Optional[bool] = ... def __init__( self, defaults: Optional[Dict[str, bool]] = ..., specified_apps: Optional[Set[str]] = ..., dry_run: Optional[bool] = ..., ) -> None: ... def ask_initial(self, app_label: str) -> bool: ... def ask_not_null_addition(self, field_name: str, model_name: str) -> None: ... def ask_not_null_alteration(self, field_name: Any, model_name: Any): ... def ask_rename(self, model_name: str, old_name: str, new_name: str, field_instance: Field) -> bool: ... def ask_rename_model(self, old_model_state: ModelState, new_model_state: ModelState) -> bool: ... def ask_merge(self, app_label: str) -> bool: ... def ask_auto_now_add_addition(self, field_name: str, model_name: str) -> None: ... class InteractiveMigrationQuestioner(MigrationQuestioner): ... class NonInteractiveMigrationQuestioner(MigrationQuestioner): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/db/migrations/recorder.pyi0000664000175000017500000000144600000000000027742 0ustar00davedave00000000000000from typing import Any, Optional, Set, Tuple from django.db.backends.base.base import BaseDatabaseWrapper from django.db.models.query import QuerySet from django.db import models class MigrationRecorder: class Migration(models.Model): app: Any = ... name: Any = ... applied: Any = ... connection: Optional[BaseDatabaseWrapper] = ... def __init__(self, connection: Optional[BaseDatabaseWrapper]) -> None: ... @property def migration_qs(self) -> QuerySet: ... def has_table(self) -> bool: ... def ensure_schema(self) -> None: ... def applied_migrations(self) -> Set[Tuple[str, str]]: ... def record_applied(self, app: str, name: str) -> None: ... def record_unapplied(self, app: str, name: str) -> None: ... def flush(self) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/db/migrations/serializer.pyi0000664000175000017500000000344400000000000030306 0ustar00davedave00000000000000from typing import Any, Callable, Dict, List, Set, Tuple, Union, Type class BaseSerializer: value: Any = ... def __init__(self, value: Any) -> None: ... def serialize(self) -> Any: ... class BaseSequenceSerializer(BaseSerializer): ... class BaseSimpleSerializer(BaseSerializer): ... class DatetimeSerializer(BaseSerializer): ... class DateSerializer(BaseSerializer): ... class DecimalSerializer(BaseSerializer): ... class DeconstructableSerializer(BaseSerializer): @staticmethod def serialize_deconstructed( path: str, args: List[Any], kwargs: Dict[str, Union[Callable, int, str]] ) -> Tuple[str, Set[str]]: ... class DictionarySerializer(BaseSerializer): ... class EnumSerializer(BaseSerializer): ... class FloatSerializer(BaseSimpleSerializer): ... class FrozensetSerializer(BaseSequenceSerializer): ... class FunctionTypeSerializer(BaseSerializer): ... class FunctoolsPartialSerializer(BaseSerializer): ... class IterableSerializer(BaseSerializer): ... class ModelFieldSerializer(DeconstructableSerializer): ... class ModelManagerSerializer(DeconstructableSerializer): ... class OperationSerializer(BaseSerializer): ... class RegexSerializer(BaseSerializer): ... class SequenceSerializer(BaseSequenceSerializer): ... class SetSerializer(BaseSequenceSerializer): ... class SettingsReferenceSerializer(BaseSerializer): ... class TimedeltaSerializer(BaseSerializer): ... class TimeSerializer(BaseSerializer): ... class TupleSerializer(BaseSequenceSerializer): ... class TypeSerializer(BaseSerializer): ... class UUIDSerializer(BaseSerializer): ... def serializer_factory(value: Any) -> BaseSerializer: ... class Serializer: @classmethod def register(cls, type_: type, serializer: Type[BaseSerializer]) -> None: ... @classmethod def unregister(cls, type_: type) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/db/migrations/state.pyi0000664000175000017500000000512000000000000027246 0ustar00davedave00000000000000from typing import Any, Dict, Iterator, List, Optional, Sequence, Tuple, Type, Union, Set from django.apps import AppConfig from django.apps.registry import Apps from django.db.models.base import Model from django.db.models.manager import Manager from django.db.models.fields import Field class AppConfigStub(AppConfig): ... class ModelState: name: str app_label: str fields: List[Tuple[str, Field]] options: Dict[str, Any] = ... bases: Tuple[Type[Model]] = ... managers: List[Tuple[str, Manager]] = ... def __init__( self, app_label: str, name: str, fields: List[Tuple[str, Field]], options: Optional[Dict[str, Any]] = ..., bases: Optional[Sequence[Union[Type[Model], str]]] = ..., managers: Optional[List[Tuple[str, Manager]]] = ..., ) -> None: ... def clone(self) -> ModelState: ... def construct_managers(self) -> Iterator[Tuple[str, Manager]]: ... @classmethod def from_model(cls, model: Type[Model], exclude_rels: bool = ...) -> ModelState: ... def get_field_by_name(self, name: str) -> Field: ... @property def name_lower(self) -> str: ... def render(self, apps: Apps) -> Any: ... def get_related_models_tuples(model: Type[Model]) -> Set[Tuple[str, str]]: ... def get_related_models_recursive(model: Type[Model]) -> Set[Tuple[str, str]]: ... class ProjectState: is_delayed: bool models: Dict[Any, Any] real_apps: List[str] def __init__( self, models: Optional[Dict[Tuple[str, str], ModelState]] = ..., real_apps: Optional[List[str]] = ... ) -> None: ... def add_model(self, model_state: ModelState) -> None: ... @property def apps(self) -> StateApps: ... def clear_delayed_apps_cache(self) -> None: ... def clone(self) -> ProjectState: ... @property def concrete_apps(self) -> StateApps: ... @classmethod def from_apps(cls, apps: Apps) -> ProjectState: ... def reload_model(self, app_label: str, model_name: str, delay: bool = ...) -> None: ... def reload_models(self, models: List[Any], delay: bool = ...) -> None: ... def remove_model(self, app_label: str, model_name: str) -> None: ... class StateApps(Apps): real_models: List[ModelState] def __init__( self, real_apps: List[str], models: Dict[Tuple[str, str], ModelState], ignore_swappable: bool = ... ) -> None: ... def bulk_update(self) -> Iterator[None]: ... def clone(self) -> StateApps: ... def render_multiple(self, model_states: List[ModelState]) -> None: ... def unregister_model(self, app_label: str, model_name: str) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/db/migrations/topological_sort.pyi0000664000175000017500000000053400000000000031515 0ustar00davedave00000000000000from typing import Dict, Iterator, List, Set from django.db.migrations.operations.base import Operation def topological_sort_as_sets(dependency_graph: Dict[Operation, Set[Operation]]) -> Iterator[Set[Operation]]: ... def stable_topological_sort( l: List[Operation], dependency_graph: Dict[Operation, Set[Operation]] ) -> List[Operation]: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/db/migrations/utils.pyi0000664000175000017500000000031700000000000027271 0ustar00davedave00000000000000from typing import Any COMPILED_REGEX_TYPE: Any class RegexObject: pattern: str = ... flags: int = ... def __init__(self, obj: Any) -> None: ... def get_migration_name_timestamp() -> str: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/db/migrations/writer.pyi0000664000175000017500000000264100000000000027447 0ustar00davedave00000000000000from typing import Any, List, Set, Tuple, Union, Type from django.db.migrations.migration import Migration from django.db.migrations.operations.base import Operation from django.db.migrations.operations.models import CreateModel from django.db.migrations.serializer import BaseSerializer class SettingsReference(str): def __init__(self, value: str, setting_name: str) -> None: ... class OperationWriter: operation: CreateModel = ... buff: List[Any] = ... indentation: int = ... def __init__(self, operation: Operation, indentation: int = ...) -> None: ... def serialize(self) -> Tuple[str, Set[str]]: ... def indent(self) -> None: ... def unindent(self) -> None: ... def feed(self, line: str) -> None: ... def render(self) -> str: ... class MigrationWriter: migration: Migration = ... needs_manual_porting: bool = ... def __init__(self, migration: Union[type, Migration], include_header: bool = ...) -> None: ... def as_string(self) -> str: ... @property def basedir(self) -> str: ... @property def filename(self) -> str: ... @property def path(self) -> str: ... @classmethod def serialize(cls, value: Any) -> Tuple[str, Set[str]]: ... @classmethod def register_serializer(cls, type_: type, serializer: Type[BaseSerializer]) -> None: ... @classmethod def unregister_serializer(cls, type_: type) -> None: ... MIGRATION_TEMPLATE: str ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4023793 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/db/models/0000775000175000017500000000000000000000000024514 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/db/models/__init__.pyi0000664000175000017500000000677000000000000027010 0ustar00davedave00000000000000from .base import Model as Model from .aggregates import ( Aggregate as Aggregate, Avg as Avg, Count as Count, Max as Max, Min as Min, StdDev as StdDev, Sum as Sum, Variance as Variance, ) from .fields import ( FieldDoesNotExist as FieldDoesNotExist, AutoField as AutoField, IntegerField as IntegerField, PositiveIntegerField as PositiveIntegerField, PositiveSmallIntegerField as PositiveSmallIntegerField, SmallIntegerField as SmallIntegerField, BigIntegerField as BigIntegerField, FloatField as FloatField, CharField as CharField, EmailField as EmailField, URLField as URLField, Field as Field, SlugField as SlugField, TextField as TextField, BooleanField as BooleanField, NullBooleanField as NullBooleanField, DateField as DateField, TimeField as TimeField, DateTimeField as DateTimeField, IPAddressField as IPAddressField, GenericIPAddressField as GenericIPAddressField, UUIDField as UUIDField, DecimalField as DecimalField, FilePathField as FilePathField, BinaryField as BinaryField, DurationField as DurationField, BigAutoField as BigAutoField, CommaSeparatedIntegerField as CommaSeparatedIntegerField, NOT_PROVIDED as NOT_PROVIDED, ) from .fields.related import ( ForeignKey as ForeignKey, OneToOneField as OneToOneField, ManyToManyField as ManyToManyField, ForeignObject as ForeignObject, ManyToManyRel as ManyToManyRel, ManyToOneRel as ManyToOneRel, OneToOneRel as OneToOneRel, ForeignObjectRel as ForeignObjectRel, ) from .fields.files import ( ImageField as ImageField, FileField as FileField, FieldFile as FieldFile, FileDescriptor as FileDescriptor, ) from .fields.proxy import OrderWrt as OrderWrt from .deletion import ( CASCADE as CASCADE, SET_DEFAULT as SET_DEFAULT, SET_NULL as SET_NULL, DO_NOTHING as DO_NOTHING, PROTECT as PROTECT, SET as SET, RESTRICT as RESTRICT, ProtectedError as ProtectedError, RestrictedError as RestrictedError, ) from .query import ( Prefetch as Prefetch, QuerySet as QuerySet, RawQuerySet as RawQuerySet, prefetch_related_objects as prefetch_related_objects, ) from .query_utils import Q as Q, FilteredRelation as FilteredRelation from .lookups import Lookup as Lookup, Transform as Transform from .expressions import ( F as F, Expression as Expression, Subquery as Subquery, Exists as Exists, OrderBy as OrderBy, OuterRef as OuterRef, Case as Case, When as When, RawSQL as RawSQL, Value as Value, Func as Func, ExpressionWrapper as ExpressionWrapper, Combinable as Combinable, Col as Col, CombinedExpression as CombinedExpression, ExpressionList as ExpressionList, Random as Random, Ref as Ref, Window as Window, WindowFrame as WindowFrame, RowRange as RowRange, ValueRange as ValueRange, ) from .manager import BaseManager as BaseManager, Manager as Manager from . import lookups as lookups from .aggregates import ( Avg as Avg, Min as Min, Max as Max, Variance as Variance, StdDev as StdDev, Sum as Sum, Aggregate as Aggregate, ) from .indexes import Index as Index from . import signals as signals from .constraints import ( BaseConstraint as BaseConstraint, CheckConstraint as CheckConstraint, UniqueConstraint as UniqueConstraint, ) from .enums import Choices as Choices, IntegerChoices as IntegerChoices, TextChoices as TextChoices ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/db/models/aggregates.pyi0000664000175000017500000000076500000000000027360 0ustar00davedave00000000000000from typing import Any, Optional from django.db.models.expressions import Func class Aggregate(Func): filter_template: str = ... filter: Any = ... allow_distinct: bool = ... def __init__(self, *expressions: Any, distinct: bool = ..., filter: Optional[Any] = ..., **extra: Any) -> None: ... class Avg(Aggregate): ... class Count(Aggregate): ... class Max(Aggregate): ... class Min(Aggregate): ... class StdDev(Aggregate): ... class Sum(Aggregate): ... class Variance(Aggregate): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/db/models/base.pyi0000664000175000017500000000454000000000000026154 0ustar00davedave00000000000000from typing import Any, Callable, Dict, List, Optional, Sequence, Set, Tuple, Type, TypeVar, Union, Collection, ClassVar from django.core.checks.messages import CheckMessage from django.core.exceptions import ValidationError from django.db.models.manager import BaseManager from django.db.models.options import Options _Self = TypeVar("_Self", bound="Model") class ModelStateFieldsCacheDescriptor: ... class ModelState: db: Optional[str] = ... adding: bool = ... fields_cache: ModelStateFieldsCacheDescriptor = ... class ModelBase(type): ... class Model(metaclass=ModelBase): class DoesNotExist(Exception): ... class MultipleObjectsReturned(Exception): ... class Meta: ... _meta: Options[Any] _default_manager: BaseManager[Model] objects: ClassVar[BaseManager[Any]] pk: Any = ... _state: ModelState def __init__(self: _Self, *args, **kwargs) -> None: ... @classmethod def add_to_class(cls, name: str, value: Any): ... @classmethod def from_db(cls, db: Optional[str], field_names: Collection[str], values: Collection[Any]) -> _Self: ... def delete(self, using: Any = ..., keep_parents: bool = ...) -> Tuple[int, Dict[str, int]]: ... def full_clean(self, exclude: Optional[Collection[str]] = ..., validate_unique: bool = ...) -> None: ... def clean(self) -> None: ... def clean_fields(self, exclude: Optional[Collection[str]] = ...) -> None: ... def validate_unique(self, exclude: Optional[Collection[str]] = ...) -> None: ... def unique_error_message( self, model_class: Type[_Self], unique_check: Collection[Union[Callable, str]] ) -> ValidationError: ... def save( self, force_insert: bool = ..., force_update: bool = ..., using: Optional[str] = ..., update_fields: Optional[Union[Sequence[str], str]] = ..., ) -> None: ... def save_base( self, raw: bool = ..., force_insert: bool = ..., force_update: bool = ..., using: Optional[str] = ..., update_fields: Optional[Union[Sequence[str], str]] = ..., ): ... def refresh_from_db(self: _Self, using: Optional[str] = ..., fields: Optional[List[str]] = ...) -> None: ... def get_deferred_fields(self) -> Set[str]: ... @classmethod def check(cls, **kwargs: Any) -> List[CheckMessage]: ... def __getstate__(self) -> dict: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/db/models/constraints.pyi0000664000175000017500000000210100000000000027600 0ustar00davedave00000000000000from typing import Any, Optional, Sequence, Tuple, Type, TypeVar from django.db.backends.base.schema import BaseDatabaseSchemaEditor from django.db.models.base import Model from django.db.models.query_utils import Q _T = TypeVar("_T", bound="BaseConstraint") class BaseConstraint: name: str def __init__(self, name: str) -> None: ... def constraint_sql( self, model: Optional[Type[Model]], schema_editor: Optional[BaseDatabaseSchemaEditor] ) -> str: ... def create_sql(self, model: Optional[Type[Model]], schema_editor: Optional[BaseDatabaseSchemaEditor]) -> str: ... def remove_sql(self, model: Optional[Type[Model]], schema_editor: Optional[BaseDatabaseSchemaEditor]) -> str: ... def deconstruct(self) -> Any: ... def clone(self: _T) -> _T: ... class CheckConstraint(BaseConstraint): check: Q def __init__(self, *, check: Q, name: str) -> None: ... class UniqueConstraint(BaseConstraint): fields: Tuple[str] condition: Optional[Q] def __init__(self, *, fields: Sequence[str], name: str, condition: Optional[Q] = ...): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/db/models/deletion.pyi0000664000175000017500000000217500000000000027047 0ustar00davedave00000000000000from typing import Any, Callable, Iterable, Optional, Union, Collection, Type from django.db.models.base import Model from django.db import IntegrityError from django.db.models.fields import Field from django.db.models.options import Options def CASCADE(collector, field, sub_objs, using): ... def SET_NULL(collector, field, sub_objs, using): ... def SET_DEFAULT(collector, field, sub_objs, using): ... def DO_NOTHING(collector, field, sub_objs, using): ... def PROTECT(collector, field, sub_objs, using): ... def RESTRICT(collector, field, sub_objs, using): ... def SET(value: Any) -> Callable: ... def get_candidate_relations_to_delete(opts: Options) -> Iterable[Field]: ... class ProtectedError(IntegrityError): ... class RestrictedError(IntegrityError): ... class Collector: def __init__(self, using: str) -> None: ... def collect( self, objs: Collection[Optional[Model]], source: Optional[Type[Model]] = ..., source_attr: Optional[str] = ..., **kwargs: Any ) -> None: ... def can_fast_delete(self, objs: Union[Model, Iterable[Model]], from_field: Optional[Field] = ...) -> bool: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/db/models/enums.pyi0000664000175000017500000000145600000000000026374 0ustar00davedave00000000000000import enum from typing import Any, List, Tuple class ChoicesMeta(enum.EnumMeta): names: List[str] = ... choices: List[Tuple[Any, str]] = ... labels: List[str] = ... values: List[Any] = ... def __contains__(self, item: Any) -> bool: ... class Choices(enum.Enum, metaclass=ChoicesMeta): def __str__(self): ... # fake class _IntegerChoicesMeta(ChoicesMeta): names: List[str] = ... choices: List[Tuple[int, str]] = ... labels: List[str] = ... values: List[int] = ... class IntegerChoices(int, Choices, metaclass=_IntegerChoicesMeta): ... # fake class _TextChoicesMeta(ChoicesMeta): names: List[str] = ... choices: List[Tuple[str, str]] = ... labels: List[str] = ... values: List[str] = ... class TextChoices(str, Choices, metaclass=_TextChoicesMeta): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/db/models/expressions.pyi0000664000175000017500000002060700000000000027626 0ustar00davedave00000000000000from datetime import datetime, timedelta from typing import Any, Callable, Dict, Iterator, List, Optional, Sequence, Set, Tuple, Type, TypeVar, Union, Iterable from django.db.models.lookups import Lookup from django.db.models.sql.compiler import SQLCompiler from django.db.models import Q, QuerySet from django.db.models.fields import Field from django.db.models.query import _BaseQuerySet _OutputField = Union[Field, str] class SQLiteNumericMixin: def as_sqlite(self, compiler: SQLCompiler, connection: Any, **extra_context: Any) -> Tuple[str, List[float]]: ... _Self = TypeVar("_Self") class Combinable: ADD: str = ... SUB: str = ... MUL: str = ... DIV: str = ... POW: str = ... MOD: str = ... BITAND: str = ... BITOR: str = ... BITLEFTSHIFT: str = ... BITRIGHTSHIFT: str = ... def __neg__(self: _Self) -> _Self: ... def __add__(self: _Self, other: Optional[Union[timedelta, Combinable, float, str]]) -> _Self: ... def __sub__(self: _Self, other: Union[timedelta, Combinable, float]) -> _Self: ... def __mul__(self: _Self, other: Union[timedelta, Combinable, float]) -> _Self: ... def __truediv__(self: _Self, other: Union[Combinable, float]) -> _Self: ... def __itruediv__(self: _Self, other: Union[Combinable, float]) -> _Self: ... def __mod__(self: _Self, other: Union[int, Combinable]) -> _Self: ... def __pow__(self: _Self, other: Union[float, Combinable]) -> _Self: ... def __and__(self: _Self, other: Combinable) -> _Self: ... def bitand(self: _Self, other: int) -> _Self: ... def bitleftshift(self: _Self, other: int) -> _Self: ... def bitrightshift(self: _Self, other: int) -> _Self: ... def __or__(self: _Self, other: Combinable) -> _Self: ... def bitor(self: _Self, other: int) -> _Self: ... def __radd__(self, other: Optional[Union[datetime, float, Combinable]]) -> Combinable: ... def __rsub__(self, other: Union[float, Combinable]) -> Combinable: ... def __rmul__(self, other: Union[float, Combinable]) -> Combinable: ... def __rtruediv__(self, other: Union[float, Combinable]) -> Combinable: ... def __rmod__(self, other: Union[int, Combinable]) -> Combinable: ... def __rpow__(self, other: Union[float, Combinable]) -> Combinable: ... def __rand__(self, other: Any) -> Combinable: ... def __ror__(self, other: Any) -> Combinable: ... class BaseExpression: is_summary: bool = ... filterable: bool = ... window_compatible: bool = ... def __init__(self, output_field: Optional[_OutputField] = ...) -> None: ... def get_db_converters(self, connection: Any) -> List[Callable]: ... def get_source_expressions(self) -> List[Any]: ... def set_source_expressions(self, exprs: Sequence[Combinable]) -> None: ... @property def contains_aggregate(self) -> bool: ... @property def contains_over_clause(self) -> bool: ... @property def contains_column_references(self) -> bool: ... def resolve_expression( self: _Self, query: Any = ..., allow_joins: bool = ..., reuse: Optional[Set[str]] = ..., summarize: bool = ..., for_save: bool = ..., ) -> _Self: ... @property def field(self) -> Field: ... @property def output_field(self) -> Field: ... @property def convert_value(self) -> Callable: ... def get_lookup(self, lookup: str) -> Optional[Type[Lookup]]: ... def get_transform(self, name: str) -> Optional[Type[Expression]]: ... def relabeled_clone(self, change_map: Dict[Optional[str], str]) -> Expression: ... def copy(self) -> BaseExpression: ... def get_group_by_cols(self: _Self) -> List[_Self]: ... def get_source_fields(self) -> List[Optional[Field]]: ... def asc(self, **kwargs: Any) -> Expression: ... def desc(self, **kwargs: Any) -> Expression: ... def reverse_ordering(self): ... def flatten(self) -> Iterator[Expression]: ... def deconstruct(self) -> Any: ... def as_sqlite(self, compiler: SQLCompiler, connection: Any) -> Any: ... def as_sql(self, compiler: SQLCompiler, connection: Any, **extra_context: Any) -> Any: ... def as_mysql(self, compiler: Any, connection: Any) -> Any: ... def as_postgresql(self, compiler: Any, connection: Any) -> Any: ... def as_oracle(self, compiler: Any, connection: Any): ... class Expression(BaseExpression, Combinable): ... class CombinedExpression(SQLiteNumericMixin, Expression): connector: Any = ... lhs: Any = ... rhs: Any = ... def __init__( self, lhs: Combinable, connector: str, rhs: Combinable, output_field: Optional[_OutputField] = ... ) -> None: ... class F(Combinable): name: str def __init__(self, name: str): ... def resolve_expression( self: _Self, query: Any = ..., allow_joins: bool = ..., reuse: Optional[Set[str]] = ..., summarize: bool = ..., for_save: bool = ..., ) -> _Self: ... def asc(self, **kwargs) -> OrderBy: ... def desc(self, **kwargs) -> OrderBy: ... def deconstruct(self) -> Any: ... class OuterRef(F): def __init__(self, name: Union[str, OuterRef]): ... class Subquery(Expression): template: str = ... queryset: QuerySet = ... extra: Dict[Any, Any] = ... def __init__(self, queryset: _BaseQuerySet, output_field: Optional[_OutputField] = ..., **extra: Any) -> None: ... class Exists(Subquery): negated: bool = ... def __init__(self, *args: Any, negated: bool = ..., **kwargs: Any) -> None: ... def __invert__(self) -> Exists: ... class OrderBy(BaseExpression): template: str = ... nulls_first: bool = ... nulls_last: bool = ... descending: bool = ... expression: Expression = ... def __init__( self, expression: Combinable, descending: bool = ..., nulls_first: bool = ..., nulls_last: bool = ... ) -> None: ... class Value(Expression): value: Any = ... def __init__(self, value: Any, output_field: Optional[_OutputField] = ...) -> None: ... class RawSQL(Expression): params: List[Any] sql: str def __init__(self, sql: str, params: Sequence[Any], output_field: Optional[_OutputField] = ...) -> None: ... class Func(SQLiteNumericMixin, Expression): function: str = ... name: str = ... template: str = ... arg_joiner: str = ... arity: int = ... source_expressions: List[Combinable] = ... extra: Dict[Any, Any] = ... def __init__(self, *expressions: Any, output_field: Optional[_OutputField] = ..., **extra: Any) -> None: ... class When(Expression): template: str = ... condition: Any = ... result: Any = ... def __init__(self, condition: Any = ..., then: Any = ..., **lookups: Any) -> None: ... class Case(Expression): template: str = ... case_joiner: str = ... cases: Any = ... default: Any = ... extra: Any = ... def __init__( self, *cases: Any, default: Optional[Any] = ..., output_field: Optional[_OutputField] = ..., **extra: Any ) -> None: ... class ExpressionWrapper(Expression): def __init__(self, expression: Union[Q, Combinable], output_field: _OutputField): ... class Col(Expression): def __init__(self, alias: str, target: str, output_field: Optional[_OutputField] = ...): ... class SimpleCol(Expression): contains_column_references: bool = ... def __init__(self, target: Field, output_field: Optional[_OutputField] = ...): ... class Ref(Expression): def __init__(self, refs: str, source: Expression): ... class ExpressionList(Func): def __init__(self, *expressions: Union[BaseExpression, Combinable], **extra: Any) -> None: ... class Random(Expression): ... class Window(Expression): template: str = ... contains_aggregate: bool = ... contains_over_clause: bool = ... def __init__( self, expression: BaseExpression, partition_by: Optional[Union[str, Iterable[Union[BaseExpression, F]], F, BaseExpression]] = ..., order_by: Optional[Union[Sequence[Union[BaseExpression, F]], Union[BaseExpression, F]]] = ..., frame: Optional[WindowFrame] = ..., output_field: Optional[_OutputField] = ..., ) -> None: ... class WindowFrame(Expression): template: str = ... frame_type: str = ... def __init__(self, start: Optional[int] = ..., end: Optional[int] = ...) -> None: ... def window_frame_start_end(self, connection: Any, start: Optional[int], end: Optional[int]) -> Tuple[int, int]: ... class RowRange(WindowFrame): ... class ValueRange(WindowFrame): ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4063792 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/db/models/fields/0000775000175000017500000000000000000000000025762 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/db/models/fields/__init__.pyi0000664000175000017500000003273400000000000030255 0ustar00davedave00000000000000import decimal import uuid from datetime import date, datetime, time, timedelta from typing import ( Any, Callable, Dict, Generic, Iterable, Optional, Tuple, Type, TypeVar, Union, Sequence, List, overload, ) from django.core import checks from django.db.models import Model from django.core.exceptions import FieldDoesNotExist as FieldDoesNotExist from django.db.models.expressions import Combinable, Col from django.db.models.query_utils import RegisterLookupMixin from django.forms import Field as FormField, Widget class NOT_PROVIDED: ... BLANK_CHOICE_DASH: List[Tuple[str, str]] = ... _Choice = Tuple[Any, Any] _ChoiceNamedGroup = Tuple[str, Iterable[_Choice]] _FieldChoices = Iterable[Union[_Choice, _ChoiceNamedGroup]] _ValidatorCallable = Callable[..., None] _ErrorMessagesToOverride = Dict[str, Any] _T = TypeVar("_T", bound="Field") # __set__ value type _ST = TypeVar("_ST") # __get__ return type _GT = TypeVar("_GT") class Field(RegisterLookupMixin, Generic[_ST, _GT]): _pyi_private_set_type: Any _pyi_private_get_type: Any _pyi_lookup_exact_type: Any widget: Widget help_text: str db_table: str attname: str auto_created: bool primary_key: bool remote_field: Field is_relation: bool related_model: Optional[Type[Model]] max_length: int model: Type[Model] name: str verbose_name: str description: str blank: bool = ... null: bool = ... editable: bool = ... empty_strings_allowed: bool = ... choices: _FieldChoices = ... db_column: Optional[str] column: str default: Any error_messages: _ErrorMessagesToOverride def __init__( self, verbose_name: Optional[Union[str, bytes]] = ..., name: Optional[str] = ..., primary_key: bool = ..., max_length: Optional[int] = ..., unique: bool = ..., blank: bool = ..., null: bool = ..., db_index: bool = ..., default: Any = ..., editable: bool = ..., auto_created: bool = ..., serialize: bool = ..., unique_for_date: Optional[str] = ..., unique_for_month: Optional[str] = ..., unique_for_year: Optional[str] = ..., choices: Optional[_FieldChoices] = ..., help_text: str = ..., db_column: Optional[str] = ..., db_tablespace: Optional[str] = ..., validators: Iterable[_ValidatorCallable] = ..., error_messages: Optional[_ErrorMessagesToOverride] = ..., ): ... def __set__(self, instance, value: _ST) -> None: ... # class access @overload def __get__(self: _T, instance: None, owner) -> _T: ... # Model instance access @overload def __get__(self, instance: Model, owner) -> _GT: ... # non-Model instances @overload def __get__(self: _T, instance, owner) -> _T: ... def deconstruct(self) -> Any: ... def set_attributes_from_name(self, name: str) -> None: ... def db_type(self, connection: Any) -> str: ... def db_parameters(self, connection: Any) -> Dict[str, str]: ... def pre_save(self, model_instance: Model, add: bool) -> Any: ... def get_prep_value(self, value: Any) -> Any: ... def get_db_prep_value(self, value: Any, connection: Any, prepared: bool) -> Any: ... def get_db_prep_save(self, value: Any, connection: Any) -> Any: ... def get_internal_type(self) -> str: ... # TODO: plugin support def formfield(self, **kwargs) -> Any: ... def save_form_data(self, instance: Model, data: Any) -> None: ... def contribute_to_class(self, cls: Type[Model], name: str, private_only: bool = ...) -> None: ... def to_python(self, value: Any) -> Any: ... def clean(self, value: Any, model_instance: Optional[Model]) -> Any: ... def get_choices( self, include_blank: bool = ..., blank_choice: _Choice = ..., limit_choices_to: Optional[Any] = ..., ordering: Sequence[str] = ..., ) -> Sequence[Union[_Choice, _ChoiceNamedGroup]]: ... def has_default(self) -> bool: ... def get_default(self) -> Any: ... def check(self, **kwargs: Any) -> List[checks.Error]: ... @property def validators(self) -> List[_ValidatorCallable]: ... def validate(self, value: Any, model_instance: Model) -> None: ... def run_validators(self, value: Any) -> None: ... def get_col(self, alias: str, output_field: Optional[Field] = ...) -> Col: ... @property def cached_col(self) -> Col: ... def value_from_object(self, obj: Model) -> _GT: ... def get_attname(self) -> str: ... class IntegerField(Field[_ST, _GT]): _pyi_private_set_type: Union[float, int, str, Combinable] _pyi_private_get_type: int _pyi_lookup_exact_type: Union[str, int] class PositiveIntegerRelDbTypeMixin: def rel_db_type(self, connection: Any): ... class PositiveIntegerField(PositiveIntegerRelDbTypeMixin, IntegerField[_ST, _GT]): ... class PositiveSmallIntegerField(PositiveIntegerRelDbTypeMixin, IntegerField[_ST, _GT]): ... class SmallIntegerField(IntegerField[_ST, _GT]): ... class BigIntegerField(IntegerField[_ST, _GT]): ... class FloatField(Field[_ST, _GT]): _pyi_private_set_type: Union[float, int, str, Combinable] _pyi_private_get_type: float _pyi_lookup_exact_type: float class DecimalField(Field[_ST, _GT]): _pyi_private_set_type: Union[str, float, decimal.Decimal, Combinable] _pyi_private_get_type: decimal.Decimal _pyi_lookup_exact_type: Union[str, decimal.Decimal] # attributes max_digits: int = ... decimal_places: int = ... def __init__( self, verbose_name: Optional[Union[str, bytes]] = ..., name: Optional[str] = ..., max_digits: Optional[int] = ..., decimal_places: Optional[int] = ..., primary_key: bool = ..., unique: bool = ..., blank: bool = ..., null: bool = ..., db_index: bool = ..., default: Any = ..., editable: bool = ..., auto_created: bool = ..., serialize: bool = ..., choices: Optional[_FieldChoices] = ..., help_text: str = ..., db_column: Optional[str] = ..., db_tablespace: Optional[str] = ..., validators: Iterable[_ValidatorCallable] = ..., error_messages: Optional[_ErrorMessagesToOverride] = ..., ): ... class AutoField(Field[_ST, _GT]): _pyi_private_set_type: Union[Combinable, int, str] _pyi_private_get_type: int _pyi_lookup_exact_type: Union[str, int] class CharField(Field[_ST, _GT]): _pyi_private_set_type: Union[str, int, Combinable] _pyi_private_get_type: str # objects are converted to string before comparison _pyi_lookup_exact_type: Any def __init__( self, verbose_name: Optional[Union[str, bytes]] = ..., name: Optional[str] = ..., primary_key: bool = ..., max_length: Optional[int] = ..., unique: bool = ..., blank: bool = ..., null: bool = ..., db_index: bool = ..., default: Any = ..., editable: bool = ..., auto_created: bool = ..., serialize: bool = ..., unique_for_date: Optional[str] = ..., unique_for_month: Optional[str] = ..., unique_for_year: Optional[str] = ..., choices: Optional[_FieldChoices] = ..., help_text: str = ..., db_column: Optional[str] = ..., db_tablespace: Optional[str] = ..., validators: Iterable[_ValidatorCallable] = ..., error_messages: Optional[_ErrorMessagesToOverride] = ..., ): ... class SlugField(CharField[_ST, _GT]): def __init__( self, verbose_name: Optional[Union[str, bytes]] = ..., name: Optional[str] = ..., primary_key: bool = ..., max_length: Optional[int] = ..., allow_unicode: bool = ..., unique: bool = ..., blank: bool = ..., null: bool = ..., db_index: bool = ..., default: Any = ..., editable: bool = ..., auto_created: bool = ..., serialize: bool = ..., unique_for_date: Optional[str] = ..., unique_for_month: Optional[str] = ..., unique_for_year: Optional[str] = ..., choices: Optional[_FieldChoices] = ..., help_text: str = ..., db_column: Optional[str] = ..., db_tablespace: Optional[str] = ..., validators: Iterable[_ValidatorCallable] = ..., error_messages: Optional[_ErrorMessagesToOverride] = ..., ): ... class EmailField(CharField[_ST, _GT]): ... class URLField(CharField[_ST, _GT]): ... class TextField(Field[_ST, _GT]): _pyi_private_set_type: Union[str, Combinable] _pyi_private_get_type: str # objects are converted to string before comparison _pyi_lookup_exact_type: Any class BooleanField(Field[_ST, _GT]): _pyi_private_set_type: Union[bool, Combinable] _pyi_private_get_type: bool _pyi_lookup_exact_type: bool class NullBooleanField(Field[_ST, _GT]): _pyi_private_set_type: Optional[Union[bool, Combinable]] _pyi_private_get_type: Optional[bool] _pyi_lookup_exact_type: Optional[bool] class IPAddressField(Field[_ST, _GT]): _pyi_private_set_type: Union[str, Combinable] _pyi_private_get_type: str class GenericIPAddressField(Field[_ST, _GT]): _pyi_private_set_type: Union[str, int, Callable[..., Any], Combinable] _pyi_private_get_type: str default_error_messages: Any = ... unpack_ipv4: Any = ... protocol: Any = ... def __init__( self, verbose_name: Optional[Any] = ..., name: Optional[Any] = ..., protocol: str = ..., unpack_ipv4: bool = ..., primary_key: bool = ..., unique: bool = ..., blank: bool = ..., null: bool = ..., db_index: bool = ..., default: Any = ..., editable: bool = ..., auto_created: bool = ..., serialize: bool = ..., choices: Optional[_FieldChoices] = ..., help_text: str = ..., db_column: Optional[str] = ..., db_tablespace: Optional[str] = ..., validators: Iterable[_ValidatorCallable] = ..., error_messages: Optional[_ErrorMessagesToOverride] = ..., ) -> None: ... class DateTimeCheckMixin: ... class DateField(DateTimeCheckMixin, Field[_ST, _GT]): _pyi_private_set_type: Union[str, date, Combinable] _pyi_private_get_type: date _pyi_lookup_exact_type: Union[str, date] def __init__( self, verbose_name: Optional[Union[str, bytes]] = ..., name: Optional[str] = ..., auto_now: bool = ..., auto_now_add: bool = ..., primary_key: bool = ..., max_length: Optional[int] = ..., unique: bool = ..., blank: bool = ..., null: bool = ..., db_index: bool = ..., default: Any = ..., editable: bool = ..., auto_created: bool = ..., serialize: bool = ..., choices: Optional[_FieldChoices] = ..., help_text: str = ..., db_column: Optional[str] = ..., db_tablespace: Optional[str] = ..., validators: Iterable[_ValidatorCallable] = ..., error_messages: Optional[_ErrorMessagesToOverride] = ..., ): ... class TimeField(DateTimeCheckMixin, Field[_ST, _GT]): _pyi_private_set_type: Union[str, time, datetime, Combinable] _pyi_private_get_type: time def __init__( self, verbose_name: Optional[Union[str, bytes]] = ..., name: Optional[str] = ..., auto_now: bool = ..., auto_now_add: bool = ..., primary_key: bool = ..., unique: bool = ..., blank: bool = ..., null: bool = ..., db_index: bool = ..., default: Any = ..., editable: bool = ..., auto_created: bool = ..., serialize: bool = ..., choices: Optional[_FieldChoices] = ..., help_text: str = ..., db_column: Optional[str] = ..., db_tablespace: Optional[str] = ..., validators: Iterable[_ValidatorCallable] = ..., error_messages: Optional[_ErrorMessagesToOverride] = ..., ): ... class DateTimeField(DateField[_ST, _GT]): _pyi_private_get_type: datetime _pyi_lookup_exact_type: Union[str, datetime] class UUIDField(Field[_ST, _GT]): _pyi_private_set_type: Union[str, uuid.UUID] _pyi_private_get_type: uuid.UUID class FilePathField(Field[_ST, _GT]): path: Any = ... match: Optional[str] = ... recursive: bool = ... allow_files: bool = ... allow_folders: bool = ... def __init__( self, path: Union[str, Callable[..., str]] = ..., match: Optional[str] = ..., recursive: bool = ..., allow_files: bool = ..., allow_folders: bool = ..., verbose_name: Optional[str] = ..., name: Optional[str] = ..., primary_key: bool = ..., max_length: int = ..., unique: bool = ..., blank: bool = ..., null: bool = ..., db_index: bool = ..., default: Any = ..., editable: bool = ..., auto_created: bool = ..., serialize: bool = ..., choices: Optional[_FieldChoices] = ..., help_text: str = ..., db_column: Optional[str] = ..., db_tablespace: Optional[str] = ..., validators: Iterable[_ValidatorCallable] = ..., error_messages: Optional[_ErrorMessagesToOverride] = ..., ): ... class BinaryField(Field[_ST, _GT]): _pyi_private_get_type: bytes class DurationField(Field[_ST, _GT]): _pyi_private_get_type: timedelta class BigAutoField(AutoField[_ST, _GT]): ... class CommaSeparatedIntegerField(CharField[_ST, _GT]): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/db/models/fields/files.pyi0000664000175000017500000000707000000000000027613 0ustar00davedave00000000000000from pathlib import Path from typing import Any, Callable, Iterable, Optional, Type, TypeVar, Union, overload from django.core.files.base import File from django.core.files.images import ImageFile from django.core.files.storage import FileSystemStorage, Storage from django.db.models.base import Model from django.db.models.fields import Field, _FieldChoices, _ValidatorCallable, _ErrorMessagesToOverride class FieldFile(File): instance: Model = ... field: FileField = ... storage: FileSystemStorage = ... def __init__(self, instance: Model, field: FileField, name: Optional[str]) -> None: ... file: Any = ... @property def path(self) -> str: ... @property def url(self) -> str: ... @property def size(self) -> int: ... def save(self, name: str, content: File, save: bool = ...) -> None: ... def delete(self, save: bool = ...) -> None: ... @property def closed(self) -> bool: ... class FileDescriptor: field: FileField = ... def __init__(self, field: FileField) -> None: ... def __set__(self, instance: Model, value: Optional[Any]) -> None: ... def __get__(self, instance: Optional[Model], cls: Type[Model] = ...) -> Union[FieldFile, FileDescriptor]: ... _T = TypeVar("_T", bound="Field") class FileField(Field): storage: Any = ... upload_to: Union[str, Callable] = ... def __init__( self, upload_to: Union[str, Callable, Path] = ..., storage: Optional[Storage] = ..., verbose_name: Optional[Union[str, bytes]] = ..., name: Optional[str] = ..., max_length: Optional[int] = ..., unique: bool = ..., blank: bool = ..., null: bool = ..., db_index: bool = ..., default: Any = ..., editable: bool = ..., auto_created: bool = ..., serialize: bool = ..., unique_for_date: Optional[str] = ..., unique_for_month: Optional[str] = ..., unique_for_year: Optional[str] = ..., choices: Optional[_FieldChoices] = ..., help_text: str = ..., db_column: Optional[str] = ..., db_tablespace: Optional[str] = ..., validators: Iterable[_ValidatorCallable] = ..., error_messages: Optional[_ErrorMessagesToOverride] = ..., ): ... # class access @overload # type: ignore def __get__(self, instance: None, owner) -> FileDescriptor: ... # Model instance access @overload def __get__(self, instance: Model, owner) -> Any: ... # non-Model instances @overload def __get__(self: _T, instance, owner) -> _T: ... def generate_filename(self, instance: Optional[Model], filename: str) -> str: ... class ImageFileDescriptor(FileDescriptor): field: ImageField def __set__(self, instance: Model, value: Optional[str]) -> None: ... class ImageFieldFile(ImageFile, FieldFile): field: ImageField def delete(self, save: bool = ...) -> None: ... class ImageField(FileField): def __init__( self, verbose_name: Optional[str] = ..., name: Optional[str] = ..., width_field: Optional[str] = ..., height_field: Optional[str] = ..., **kwargs: Any ) -> None: ... # class access @overload # type: ignore def __get__(self, instance: None, owner) -> ImageFileDescriptor: ... # Model instance access @overload def __get__(self, instance: Model, owner) -> Any: ... # non-Model instances @overload def __get__(self: _T, instance, owner) -> _T: ... def update_dimension_fields(self, instance: Model, force: bool = ..., *args: Any, **kwargs: Any) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/db/models/fields/mixins.pyi0000664000175000017500000000070500000000000030016 0ustar00davedave00000000000000from typing import Any, Optional from django.db.models.base import Model NOT_PROVIDED: Any class FieldCacheMixin: def get_cache_name(self) -> str: ... def get_cached_value(self, instance: Model, default: Any = ...) -> Optional[Model]: ... def is_cached(self, instance: Model) -> bool: ... def set_cached_value(self, instance: Model, value: Optional[Model]) -> None: ... def delete_cached_value(self, instance: Model) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/db/models/fields/proxy.pyi0000664000175000017500000000024100000000000027663 0ustar00davedave00000000000000from typing import Any from django.db.models import fields class OrderWrt(fields.IntegerField): def __init__(self, *args: Any, **kwargs: Any) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/db/models/fields/related.pyi0000664000175000017500000002211100000000000030122 0ustar00davedave00000000000000from typing import Any, Callable, Dict, Iterable, List, Optional, Sequence, Tuple, Type, TypeVar, Union, overload from uuid import UUID from django.db import models from django.db.models.base import Model from django.db.models.fields import Field from django.db.models.query_utils import Q, PathInfo from django.db.models.manager import RelatedManager from django.db.models.expressions import Combinable from django.db.models.fields.mixins import FieldCacheMixin from django.db.models.fields.related_descriptors import ( # noqa: F401 ForwardOneToOneDescriptor as ForwardOneToOneDescriptor, ForwardManyToOneDescriptor as ForwardManyToOneDescriptor, ManyToManyDescriptor as ManyToManyDescriptor, ReverseOneToOneDescriptor as ReverseOneToOneDescriptor, ReverseManyToOneDescriptor as ReverseManyToOneDescriptor, ) from django.db.models.fields.reverse_related import ( # noqa: F401 ForeignObjectRel as ForeignObjectRel, OneToOneRel as OneToOneRel, ManyToOneRel as ManyToOneRel, ManyToManyRel as ManyToManyRel, ) _T = TypeVar("_T", bound=models.Model) _F = TypeVar("_F", bound=models.Field) _Choice = Tuple[Any, str] _ChoiceNamedGroup = Tuple[str, Iterable[_Choice]] _FieldChoices = Iterable[Union[_Choice, _ChoiceNamedGroup]] _ValidatorCallable = Callable[..., None] _ErrorMessagesToOverride = Dict[str, Any] RECURSIVE_RELATIONSHIP_CONSTANT: str = ... # __set__ value type _ST = TypeVar("_ST") # __get__ return type _GT = TypeVar("_GT") class RelatedField(FieldCacheMixin, Field[_ST, _GT]): one_to_many: bool = ... one_to_one: bool = ... many_to_many: bool = ... many_to_one: bool = ... related_model: Type[Model] opts: Any = ... def get_forward_related_filter(self, obj: Model) -> Dict[str, Union[int, UUID]]: ... def get_reverse_related_filter(self, obj: Model) -> Q: ... @property def swappable_setting(self) -> Optional[str]: ... def set_attributes_from_rel(self) -> None: ... def do_related_class(self, other: Type[Model], cls: Type[Model]) -> None: ... def get_limit_choices_to(self) -> Dict[str, int]: ... def related_query_name(self) -> str: ... @property def target_field(self) -> Field: ... class ForeignObject(RelatedField[_ST, _GT]): def __init__( self, to: Union[Type[Model], str], on_delete: Callable[..., None], from_fields: Sequence[str], to_fields: Sequence[str], rel: Optional[ForeignObjectRel] = ..., related_name: Optional[str] = ..., related_query_name: Optional[str] = ..., limit_choices_to: Optional[Union[Dict[str, Any], Callable[[], Any]]] = ..., parent_link: bool = ..., db_constraint: bool = ..., swappable: bool = ..., verbose_name: Optional[str] = ..., name: Optional[str] = ..., primary_key: bool = ..., unique: bool = ..., blank: bool = ..., null: bool = ..., db_index: bool = ..., default: Any = ..., editable: bool = ..., auto_created: bool = ..., serialize: bool = ..., choices: Optional[_FieldChoices] = ..., help_text: str = ..., db_column: Optional[str] = ..., db_tablespace: Optional[str] = ..., validators: Iterable[_ValidatorCallable] = ..., error_messages: Optional[_ErrorMessagesToOverride] = ..., ): ... class ForeignKey(ForeignObject[_ST, _GT]): _pyi_private_set_type: Union[Any, Combinable] _pyi_private_get_type: Any def __init__( self, to: Union[Type[Model], str], on_delete: Callable[..., None], to_field: Optional[str] = ..., related_name: Optional[str] = ..., related_query_name: Optional[str] = ..., limit_choices_to: Optional[Union[Dict[str, Any], Callable[[], Any], Q]] = ..., parent_link: bool = ..., db_constraint: bool = ..., verbose_name: Optional[Union[str, bytes]] = ..., name: Optional[str] = ..., primary_key: bool = ..., max_length: Optional[int] = ..., unique: bool = ..., blank: bool = ..., null: bool = ..., db_index: bool = ..., default: Any = ..., editable: bool = ..., auto_created: bool = ..., serialize: bool = ..., unique_for_date: Optional[str] = ..., unique_for_month: Optional[str] = ..., unique_for_year: Optional[str] = ..., choices: Optional[_FieldChoices] = ..., help_text: str = ..., db_column: Optional[str] = ..., db_tablespace: Optional[str] = ..., validators: Iterable[_ValidatorCallable] = ..., error_messages: Optional[_ErrorMessagesToOverride] = ..., ): ... # class access @overload # type: ignore def __get__(self, instance: None, owner) -> ForwardManyToOneDescriptor: ... # Model instance access @overload def __get__(self, instance: Model, owner) -> _GT: ... # non-Model instances @overload def __get__(self: _F, instance, owner) -> _F: ... class OneToOneField(RelatedField[_ST, _GT]): _pyi_private_set_type: Union[Any, Combinable] _pyi_private_get_type: Any def __init__( self, to: Union[Type[Model], str], on_delete: Any, to_field: Optional[str] = ..., related_name: Optional[str] = ..., related_query_name: Optional[str] = ..., limit_choices_to: Optional[Union[Dict[str, Any], Callable[[], Any], Q]] = ..., parent_link: bool = ..., db_constraint: bool = ..., verbose_name: Optional[Union[str, bytes]] = ..., name: Optional[str] = ..., primary_key: bool = ..., max_length: Optional[int] = ..., unique: bool = ..., blank: bool = ..., null: bool = ..., db_index: bool = ..., default: Any = ..., editable: bool = ..., auto_created: bool = ..., serialize: bool = ..., unique_for_date: Optional[str] = ..., unique_for_month: Optional[str] = ..., unique_for_year: Optional[str] = ..., choices: Optional[_FieldChoices] = ..., help_text: str = ..., db_column: Optional[str] = ..., db_tablespace: Optional[str] = ..., validators: Iterable[_ValidatorCallable] = ..., error_messages: Optional[_ErrorMessagesToOverride] = ..., ): ... # class access @overload # type: ignore def __get__(self, instance: None, owner) -> ForwardOneToOneDescriptor: ... # Model instance access @overload def __get__(self, instance: Model, owner) -> _GT: ... # non-Model instances @overload def __get__(self: _F, instance, owner) -> _F: ... class ManyToManyField(RelatedField[_ST, _GT]): _pyi_private_set_type: Sequence[Any] _pyi_private_get_type: RelatedManager[Any] rel_class: Any = ... description: Any = ... has_null_arg: Any = ... swappable: bool = ... def __init__( self, to: Union[Type[_T], str], related_name: Optional[str] = ..., related_query_name: Optional[str] = ..., limit_choices_to: Optional[Union[Dict[str, Any], Callable[[], Any], Q]] = ..., symmetrical: Optional[bool] = ..., through: Optional[Union[str, Type[Model]]] = ..., through_fields: Optional[Tuple[str, str]] = ..., db_constraint: bool = ..., db_table: Optional[str] = ..., swappable: bool = ..., verbose_name: Optional[Union[str, bytes]] = ..., name: Optional[str] = ..., primary_key: bool = ..., max_length: Optional[int] = ..., unique: bool = ..., blank: bool = ..., null: bool = ..., db_index: bool = ..., default: Any = ..., editable: bool = ..., auto_created: bool = ..., serialize: bool = ..., unique_for_date: Optional[str] = ..., unique_for_month: Optional[str] = ..., unique_for_year: Optional[str] = ..., choices: Optional[_FieldChoices] = ..., help_text: str = ..., db_column: Optional[str] = ..., db_tablespace: Optional[str] = ..., validators: Iterable[_ValidatorCallable] = ..., error_messages: Optional[_ErrorMessagesToOverride] = ..., ) -> None: ... # class access @overload # type: ignore def __get__(self, instance: None, owner) -> ManyToManyDescriptor: ... # Model instance access @overload def __get__(self, instance: Model, owner) -> _GT: ... # non-Model instances @overload def __get__(self: _F, instance, owner) -> _F: ... def get_path_info(self, filtered_relation: None = ...) -> List[PathInfo]: ... def get_reverse_path_info(self, filtered_relation: None = ...) -> List[PathInfo]: ... def contribute_to_related_class(self, cls: Type[Model], related: RelatedField) -> None: ... def m2m_db_table(self) -> str: ... def m2m_column_name(self) -> str: ... def m2m_reverse_name(self) -> str: ... def m2m_reverse_field_name(self) -> str: ... def m2m_target_field_name(self) -> str: ... def m2m_reverse_target_field_name(self) -> str: ... def create_many_to_many_intermediary_model(field: Type[Field], klass: Type[Model]) -> Type[Model]: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/db/models/fields/related_descriptors.pyi0000664000175000017500000000616000000000000032551 0ustar00davedave00000000000000from typing import Any, Callable, List, Optional, Tuple, Type, Union, Generic, TypeVar from django.core.exceptions import ObjectDoesNotExist from django.db.models.base import Model from django.db.models.fields.mixins import FieldCacheMixin from django.db.models.fields.related import RelatedField, OneToOneField from django.db.models.fields.reverse_related import ManyToManyRel, OneToOneRel from django.db.models.query import QuerySet from django.db.models.fields import Field _T = TypeVar("_T") class ForwardManyToOneDescriptor: RelatedObjectDoesNotExist: Type[ObjectDoesNotExist] field: Field = ... def __init__(self, field_with_rel: Field) -> None: ... def is_cached(self, instance: Model) -> bool: ... def get_queryset(self, **hints: Any) -> QuerySet: ... def get_prefetch_queryset( self, instances: List[Model], queryset: Optional[QuerySet] = ... ) -> Tuple[QuerySet, Callable, Callable, bool, str, bool]: ... def get_object(self, instance: Model) -> Model: ... def __get__( self, instance: Optional[Model], cls: Type[Model] = ... ) -> Optional[Union[Model, ForwardManyToOneDescriptor]]: ... def __set__(self, instance: Model, value: Optional[Model]) -> None: ... def __reduce__(self) -> Tuple[Callable, Tuple[Type[Model], str]]: ... class ForwardOneToOneDescriptor(ForwardManyToOneDescriptor): RelatedObjectDoesNotExist: Type[ObjectDoesNotExist] field: OneToOneField def get_object(self, instance: Model) -> Model: ... class ReverseOneToOneDescriptor: RelatedObjectDoesNotExist: Type[ObjectDoesNotExist] related: OneToOneRel = ... def __init__(self, related: OneToOneRel) -> None: ... def is_cached(self, instance: Model) -> bool: ... def get_queryset(self, **hints: Any) -> QuerySet: ... def get_prefetch_queryset( self, instances: List[Model], queryset: Optional[QuerySet] = ... ) -> Tuple[QuerySet, Callable, Callable, bool, str, bool]: ... def __get__(self, instance: Optional[Model], cls: Type[Model] = ...) -> Union[Model, ReverseOneToOneDescriptor]: ... def __set__(self, instance: Model, value: Optional[Model]) -> None: ... def __reduce__(self) -> Tuple[Callable, Tuple[Type[Model], str]]: ... class ReverseManyToOneDescriptor: rel: FieldCacheMixin = ... field: FieldCacheMixin = ... def __init__(self, rel: FieldCacheMixin) -> None: ... def related_manager_cls(self): ... def __get__(self, instance: Optional[Model], cls: Type[Model] = ...) -> ReverseManyToOneDescriptor: ... def __set__(self, instance: Model, value: List[Model]) -> Any: ... def create_reverse_many_to_one_manager(superclass: Any, rel: Any): ... class ManyToManyDescriptor(ReverseManyToOneDescriptor): field: RelatedField rel: ManyToManyRel reverse: bool = ... def __init__(self, rel: ManyToManyRel, reverse: bool = ...) -> None: ... @property def through(self) -> Type[Model]: ... def related_manager_cls(self): ... class _ForwardManyToManyManager(Generic[_T]): def all(self) -> QuerySet: ... def create_forward_many_to_many_manager(superclass: Any, rel: Any, reverse: Any) -> _ForwardManyToManyManager: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/db/models/fields/related_lookups.pyi0000664000175000017500000000273400000000000031707 0ustar00davedave00000000000000from collections import OrderedDict from typing import Any, List, Tuple, Type, Iterable from django.db.models.expressions import Expression from django.db.models.lookups import ( BuiltinLookup, Exact, GreaterThan, GreaterThanOrEqual, In, IsNull, LessThan, LessThanOrEqual, ) from django.db.models.fields import Field class MultiColSource: alias: str field: Field sources: Tuple[Field, Field] targets: Tuple[Field, Field] contains_aggregate: bool = ... output_field: Field = ... def __init__( self, alias: str, targets: Tuple[Field, Field], sources: Tuple[Field, Field], field: Field ) -> None: ... def relabeled_clone(self, relabels: OrderedDict) -> MultiColSource: ... def get_lookup(self, lookup: str) -> Type[BuiltinLookup]: ... def get_normalized_value(value: Any, lhs: Expression) -> Tuple[None]: ... class RelatedIn(In): bilateral_transforms: List[Any] lhs: Expression rhs: Any = ... def get_prep_lookup(self) -> Iterable[Any]: ... class RelatedLookupMixin: rhs: Any = ... def get_prep_lookup(self) -> Any: ... class RelatedExact(RelatedLookupMixin, Exact): ... class RelatedLessThan(RelatedLookupMixin, LessThan): ... class RelatedGreaterThan(RelatedLookupMixin, GreaterThan): ... class RelatedGreaterThanOrEqual(RelatedLookupMixin, GreaterThanOrEqual): ... class RelatedLessThanOrEqual(RelatedLookupMixin, LessThanOrEqual): ... class RelatedIsNull(RelatedLookupMixin, IsNull): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/db/models/fields/reverse_related.pyi0000664000175000017500000000771500000000000031672 0ustar00davedave00000000000000from typing import Any, Callable, Dict, List, Optional, Tuple, Type, Union from django.db.models.base import Model from django.db.models.fields.related import ForeignKey, OneToOneField, RelatedField from django.db.models.lookups import BuiltinLookup, StartsWith from django.db.models.query_utils import FilteredRelation, PathInfo from django.db.models.sql.where import WhereNode from django.db.models.fields import AutoField, Field from .mixins import FieldCacheMixin class ForeignObjectRel(FieldCacheMixin): many_to_many: bool many_to_one: bool one_to_many: bool one_to_one: bool auto_created: bool = ... concrete: bool = ... editable: bool = ... is_relation: bool = ... related_model: Type[Model] null: bool = ... field: RelatedField = ... model: Union[Type[Model], str] = ... related_name: Optional[str] = ... related_query_name: Optional[str] = ... limit_choices_to: Optional[Union[Dict[str, Any], Callable[[], Any]]] = ... parent_link: bool = ... on_delete: Callable = ... symmetrical: bool = ... multiple: bool = ... field_name: Optional[str] = ... def __init__( self, field: RelatedField, to: Union[Type[Model], str], related_name: Optional[str] = ..., related_query_name: Optional[str] = ..., limit_choices_to: Optional[Union[Dict[str, Any], Callable[[], Any]]] = ..., parent_link: bool = ..., on_delete: Optional[Callable] = ..., ) -> None: ... @property def hidden(self) -> bool: ... @property def name(self) -> str: ... @property def remote_field(self) -> RelatedField: ... @property def target_field(self) -> AutoField: ... def get_lookup(self, lookup_name: str) -> Type[BuiltinLookup]: ... def get_internal_type(self) -> str: ... @property def db_type(self) -> Callable: ... def get_choices( self, include_blank: bool = ..., blank_choice: List[Tuple[str, str]] = ... ) -> List[Tuple[int, str]]: ... def is_hidden(self) -> bool: ... def get_joining_columns(self) -> Tuple: ... def get_extra_restriction( self, where_class: Type[WhereNode], alias: str, related_alias: str ) -> Optional[Union[StartsWith, WhereNode]]: ... def set_field_name(self) -> None: ... def get_accessor_name(self, model: Optional[Type[Model]] = ...) -> Optional[str]: ... def get_path_info(self, filtered_relation: Optional[FilteredRelation] = ...) -> List[PathInfo]: ... class ManyToOneRel(ForeignObjectRel): def __init__( self, field: ForeignKey, to: Union[Type[Model], str], field_name: Optional[str], related_name: Optional[str] = ..., related_query_name: Optional[str] = ..., limit_choices_to: Optional[Union[Dict[str, Any], Callable[[], Any]]] = ..., parent_link: bool = ..., on_delete: Callable = ..., ) -> None: ... def get_related_field(self) -> Field: ... class OneToOneRel(ManyToOneRel): def __init__( self, field: OneToOneField, to: Union[Type[Model], str], field_name: Optional[str], related_name: Optional[str] = ..., related_query_name: Optional[str] = ..., limit_choices_to: Optional[Dict[str, str]] = ..., parent_link: bool = ..., on_delete: Callable = ..., ) -> None: ... class ManyToManyRel(ForeignObjectRel): through: Optional[Union[Type[Model], str]] = ... through_fields: Optional[Tuple[str, str]] = ... db_constraint: bool = ... def __init__( self, field: RelatedField, to: Union[Type[Model], str], related_name: Optional[str] = ..., related_query_name: Optional[str] = ..., limit_choices_to: Any = ..., symmetrical: bool = ..., through: Optional[Union[Type[Model], str]] = ..., through_fields: Optional[Tuple[str, str]] = ..., db_constraint: bool = ..., ) -> None: ... def get_related_field(self) -> Field: ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4063792 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/db/models/functions/0000775000175000017500000000000000000000000026524 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/db/models/functions/__init__.pyi0000664000175000017500000000403500000000000031010 0ustar00davedave00000000000000from .text import ( Lower as Lower, Upper as Upper, Length as Length, Chr as Chr, Concat as Concat, ConcatPair as ConcatPair, Left as Left, Right as Right, LPad as LPad, RPad as RPad, LTrim as LTrim, RTrim as RTrim, Trim as Trim, Ord as Ord, Repeat as Repeat, SHA1 as SHA1, SHA224 as SHA224, SHA256 as SHA256, SHA384 as SHA384, SHA512 as SHA512, StrIndex as StrIndex, Substr as Substr, Replace as Replace, Reverse as Reverse, ) from .window import ( CumeDist as CumeDist, DenseRank as DenseRank, FirstValue as FirstValue, Lag as Lag, LastValue as LastValue, Lead as Lead, NthValue as NthValue, Ntile as Ntile, PercentRank as PercentRank, Rank as Rank, RowNumber as RowNumber, ) from .datetime import ( Extract as Extract, ExtractDay as ExtractDay, ExtractHour as ExtractHour, ExtractMinute as ExtractMinute, ExtractSecond as ExtractSecond, ExtractMonth as ExtractMonth, ExtractQuarter as ExtractQuarter, ExtractWeek as ExtractWeek, ExtractWeekDay as ExtractWeekDay, ExtractYear as ExtractYear, ExtractIsoYear as ExtractIsoYear, Trunc as Trunc, TruncDate as TruncDate, TruncDay as TruncDay, TruncHour as TruncHour, TruncMinute as TruncMinute, TruncQuarter as TruncQuarter, TruncMonth as TruncMonth, TruncSecond as TruncSecond, TruncTime as TruncTime, TruncWeek as TruncWeek, TruncYear as TruncYear, Now as Now, ) from .comparison import Coalesce as Coalesce, Greatest as Greatest, Least as Least, Cast as Cast, NullIf as NullIf from .math import ( Abs as Abs, ACos as ACos, ASin as ASin, ATan as ATan, ATan2 as ATan2, Ceil as Ceil, Cos as Cos, Cot as Cot, Degrees as Degrees, Floor as Floor, Exp as Exp, Ln as Ln, Log as Log, Mod as Mod, Pi as Pi, Power as Power, Radians as Radians, Round as Round, Sign as Sign, Sin as Sin, Sqrt as Sqrt, Tan as Tan, ) ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/db/models/functions/comparison.pyi0000664000175000017500000000047000000000000031422 0ustar00davedave00000000000000from typing import Any, Union from django.db.models import Func from django.db.models.fields import Field class Cast(Func): def __init__(self, expression: Any, output_field: Union[str, Field]) -> None: ... class Coalesce(Func): ... class Greatest(Func): ... class Least(Func): ... class NullIf(Func): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/db/models/functions/datetime.pyi0000664000175000017500000000171400000000000031046 0ustar00davedave00000000000000from typing import Any, Optional from django.db.models import Func, Transform class TimezoneMixin: tzinfo: Any = ... def get_tzname(self) -> Optional[str]: ... class Extract(TimezoneMixin, Transform): ... class ExtractYear(Extract): ... class ExtractIsoYear(Extract): ... class ExtractMonth(Extract): ... class ExtractDay(Extract): ... class ExtractWeek(Extract): ... class ExtractWeekDay(Extract): ... class ExtractQuarter(Extract): ... class ExtractHour(Extract): ... class ExtractMinute(Extract): ... class ExtractSecond(Extract): ... class Now(Func): ... class TruncBase(TimezoneMixin, Transform): ... class Trunc(TruncBase): ... class TruncYear(TruncBase): ... class TruncQuarter(TruncBase): ... class TruncMonth(TruncBase): ... class TruncWeek(TruncBase): ... class TruncDay(TruncBase): ... class TruncDate(TruncBase): ... class TruncTime(TruncBase): ... class TruncHour(TruncBase): ... class TruncMinute(TruncBase): ... class TruncSecond(TruncBase): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/db/models/functions/math.pyi0000664000175000017500000000230600000000000030201 0ustar00davedave00000000000000from django.db.models.expressions import Func from django.db.models.functions.mixins import FixDecimalInputMixin, NumericOutputFieldMixin from django.db.models.lookups import Transform class Abs(Transform): ... class ACos(NumericOutputFieldMixin, Transform): ... class ASin(NumericOutputFieldMixin, Transform): ... class ATan(NumericOutputFieldMixin, Transform): ... class ATan2(NumericOutputFieldMixin, Func): ... class Ceil(Transform): ... class Cos(NumericOutputFieldMixin, Transform): ... class Cot(NumericOutputFieldMixin, Transform): ... class Degrees(NumericOutputFieldMixin, Transform): ... class Exp(NumericOutputFieldMixin, Transform): ... class Floor(Transform): ... class Ln(NumericOutputFieldMixin, Transform): ... class Log(FixDecimalInputMixin, NumericOutputFieldMixin, Func): ... class Mod(FixDecimalInputMixin, NumericOutputFieldMixin, Func): ... class Pi(NumericOutputFieldMixin, Func): ... class Power(NumericOutputFieldMixin, Func): ... class Radians(NumericOutputFieldMixin, Transform): ... class Round(Transform): ... class Sin(NumericOutputFieldMixin, Transform): ... class Sqrt(NumericOutputFieldMixin, Transform): ... class Tan(NumericOutputFieldMixin, Transform): ... class Sign(Transform): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/db/models/functions/mixins.pyi0000664000175000017500000000014400000000000030555 0ustar00davedave00000000000000class FixDecimalInputMixin: ... class FixDurationInputMixin: ... class NumericOutputFieldMixin: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/db/models/functions/text.pyi0000664000175000017500000000426400000000000030241 0ustar00davedave00000000000000from typing import Any, List, Optional, Tuple, Union from django.db.backends.sqlite3.base import DatabaseWrapper from django.db.models.expressions import Combinable, Expression, Value from django.db.models.sql.compiler import SQLCompiler from django.db.models import Func, Transform class BytesToCharFieldConversionMixin: ... class Chr(Transform): ... class ConcatPair(Func): def coalesce(self) -> ConcatPair: ... class Concat(Func): ... class Left(Func): def __init__(self, expression: str, length: Union[Value, int], **extra: Any) -> None: ... def get_substr(self) -> Substr: ... def use_substr( self, compiler: SQLCompiler, connection: DatabaseWrapper, **extra_context: Any ) -> Tuple[str, List[int]]: ... class Length(Transform): ... class Lower(Transform): ... class LPad(BytesToCharFieldConversionMixin, Func): def __init__( self, expression: str, length: Optional[Union[Length, int]], fill_text: Value = ..., **extra: Any ) -> None: ... class LTrim(Transform): ... class Ord(Transform): ... class Repeat(BytesToCharFieldConversionMixin, Func): def __init__(self, expression: Union[Value, str], number: Optional[Union[Length, int]], **extra: Any) -> None: ... class Replace(Func): def __init__(self, expression: Combinable, text: Value, replacement: Value = ..., **extra: Any) -> None: ... class Right(Left): ... class RPad(LPad): ... class RTrim(Transform): ... class StrIndex(Func): ... class Substr(Func): def __init__( self, expression: Union[Expression, str], pos: Union[Expression, int], length: Optional[Union[Value, int]] = ..., **extra: Any ) -> None: ... class Trim(Transform): ... class Upper(Transform): ... class Reverse(Transform): ... class MySQLSHA2Mixin: ... class OracleHashMixin: ... class PostgreSQLSHAMixin: ... class SHA1(OracleHashMixin, PostgreSQLSHAMixin, Transform): ... class SHA224(MySQLSHA2Mixin, PostgreSQLSHAMixin, Transform): ... class SHA256(MySQLSHA2Mixin, OracleHashMixin, PostgreSQLSHAMixin, Transform): ... class SHA384(MySQLSHA2Mixin, OracleHashMixin, PostgreSQLSHAMixin, Transform): ... class SHA512(MySQLSHA2Mixin, OracleHashMixin, PostgreSQLSHAMixin, Transform): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/db/models/functions/window.pyi0000664000175000017500000000127600000000000030564 0ustar00davedave00000000000000from typing import Any, Optional from django.db.models import Func class CumeDist(Func): ... class DenseRank(Func): ... class FirstValue(Func): ... class LagLeadFunction(Func): def __init__( self, expression: Optional[str], offset: int = ..., default: Optional[int] = ..., **extra: Any ) -> None: ... class Lag(LagLeadFunction): ... class LastValue(Func): ... class Lead(LagLeadFunction): ... class NthValue(Func): def __init__(self, expression: Optional[str], nth: int = ..., **extra: Any) -> None: ... class Ntile(Func): def __init__(self, num_buckets: int = ..., **extra: Any) -> None: ... class PercentRank(Func): ... class Rank(Func): ... class RowNumber(Func): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/db/models/indexes.pyi0000664000175000017500000000233100000000000026675 0ustar00davedave00000000000000from typing import Any, List, Optional, Sequence, Tuple, Type from django.db.backends.base.schema import BaseDatabaseSchemaEditor from django.db.backends.ddl_references import Statement from django.db.models.base import Model from django.db.models.query_utils import Q class Index: model: Type[Model] suffix: str = ... max_name_length: int = ... fields: Sequence[str] = ... fields_orders: Sequence[Tuple[str, str]] = ... name: str = ... db_tablespace: Optional[str] = ... opclasses: Sequence[str] = ... condition: Optional[Q] = ... def __init__( self, *, fields: Sequence[str] = ..., name: Optional[str] = ..., db_tablespace: Optional[str] = ..., opclasses: Sequence[str] = ..., condition: Optional[Q] = ... ) -> None: ... def check_name(self) -> List[str]: ... def create_sql( self, model: Type[Model], schema_editor: BaseDatabaseSchemaEditor, using: str = ... ) -> Statement: ... def remove_sql(self, model: Type[Model], schema_editor: BaseDatabaseSchemaEditor) -> str: ... def deconstruct(self) -> Any: ... def clone(self) -> Index: ... def set_name_with_model(self, model: Type[Model]) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/db/models/lookups.pyi0000664000175000017500000001057300000000000026741 0ustar00davedave00000000000000from datetime import datetime from typing import Any, Iterable, List, Optional, Tuple, Type, Union, Mapping, TypeVar, Generic from django.db.backends.sqlite3.base import DatabaseWrapper from django.db.models.expressions import Expression, Func from django.db.models.query_utils import RegisterLookupMixin from django.db.models.sql.compiler import SQLCompiler from django.utils.datastructures import OrderedSet from django.utils.safestring import SafeText from django.db.models.fields import TextField, related_lookups _T = TypeVar("_T") class Lookup(Generic[_T]): lookup_name: str = ... prepare_rhs: bool = ... can_use_none_as_rhs: bool = ... lhs: Any = ... rhs: Any = ... bilateral_transforms: List[Type[Transform]] = ... def __init__(self, lhs: Union[Expression, TextField, related_lookups.MultiColSource], rhs: Any) -> None: ... def apply_bilateral_transforms(self, value: Expression) -> Transform: ... def batch_process_rhs( self, compiler: SQLCompiler, connection: DatabaseWrapper, rhs: Optional[OrderedSet] = ... ) -> Tuple[List[str], List[str]]: ... def get_source_expressions(self) -> List[Expression]: ... def set_source_expressions(self, new_exprs: List[Expression]) -> None: ... def get_prep_lookup(self) -> Any: ... def get_db_prep_lookup(self, value: Union[int, str], connection: DatabaseWrapper) -> Tuple[str, List[SafeText]]: ... def process_lhs( self, compiler: SQLCompiler, connection: DatabaseWrapper, lhs: Optional[Expression] = ... ) -> Tuple[str, List[Union[int, str]]]: ... def process_rhs(self, compiler: SQLCompiler, connection: DatabaseWrapper) -> Tuple[str, List[Union[int, str]]]: ... def rhs_is_direct_value(self) -> bool: ... def relabeled_clone(self: _T, relabels: Mapping[str, str]) -> _T: ... def get_group_by_cols(self) -> List[Expression]: ... def as_sql(self, compiler: Any, connection: Any) -> Any: ... def contains_aggregate(self) -> bool: ... def contains_over_clause(self) -> bool: ... @property def is_summary(self) -> bool: ... class Transform(RegisterLookupMixin, Func): bilateral: bool = ... @property def lhs(self) -> Expression: ... def get_bilateral_transforms(self) -> List[Type[Transform]]: ... class BuiltinLookup(Lookup[_T]): def get_rhs_op(self, connection: DatabaseWrapper, rhs: str) -> str: ... class FieldGetDbPrepValueMixin: get_db_prep_lookup_value_is_iterable: bool = ... class FieldGetDbPrepValueIterableMixin(FieldGetDbPrepValueMixin): def get_prep_lookup(self) -> Iterable[Any]: ... def resolve_expression_parameter( self, compiler: SQLCompiler, connection: DatabaseWrapper, sql: str, param: Any ) -> Any: ... class Exact(FieldGetDbPrepValueMixin, BuiltinLookup): ... class IExact(BuiltinLookup): ... class GreaterThan(FieldGetDbPrepValueMixin, BuiltinLookup): ... class GreaterThanOrEqual(FieldGetDbPrepValueMixin, BuiltinLookup[_T]): ... class LessThan(FieldGetDbPrepValueMixin, BuiltinLookup[_T]): ... class LessThanOrEqual(FieldGetDbPrepValueMixin, BuiltinLookup): ... class IntegerFieldFloatRounding: rhs: Any = ... def get_prep_lookup(self) -> Any: ... class IntegerGreaterThanOrEqual(IntegerFieldFloatRounding, GreaterThanOrEqual[Union[int, float]]): ... class IntegerLessThan(IntegerFieldFloatRounding, LessThan[Union[int, float]]): ... class In(FieldGetDbPrepValueIterableMixin, BuiltinLookup): def split_parameter_list_as_sql(self, compiler: Any, connection: Any): ... class PatternLookup(BuiltinLookup[str]): param_pattern: str = ... class Contains(PatternLookup): ... class IContains(Contains): ... class StartsWith(PatternLookup): ... class IStartsWith(StartsWith): ... class EndsWith(PatternLookup): ... class IEndsWith(EndsWith): ... class Range(FieldGetDbPrepValueIterableMixin, BuiltinLookup): ... class IsNull(BuiltinLookup[bool]): ... class Regex(BuiltinLookup[str]): ... class IRegex(Regex): ... class YearLookup(Lookup): def year_lookup_bounds(self, connection: DatabaseWrapper, year: int) -> List[str]: ... class YearComparisonLookup(YearLookup): def get_rhs_op(self, connection: DatabaseWrapper, rhs: str) -> str: ... def get_bound(self, start: datetime, finish: datetime) -> Any: ... class YearExact(YearLookup, Exact): ... class YearGt(YearComparisonLookup): ... class YearGte(YearComparisonLookup): ... class YearLt(YearComparisonLookup): ... class YearLte(YearComparisonLookup): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/db/models/manager.pyi0000664000175000017500000000340400000000000026652 0ustar00davedave00000000000000from typing import Any, Dict, List, Optional, Tuple, Type, TypeVar, Iterable, Union from django.db.models.base import Model from django.db.models.query import QuerySet _T = TypeVar("_T", bound=Model, covariant=True) _M = TypeVar("_M", bound="BaseManager") class BaseManager(QuerySet[_T]): creation_counter: int = ... auto_created: bool = ... use_in_migrations: bool = ... name: str = ... model: Type[_T] = ... db: str _db: Optional[str] def __init__(self) -> None: ... def deconstruct(self) -> Tuple[bool, str, None, Tuple, Dict[str, int]]: ... def check(self, **kwargs: Any) -> List[Any]: ... @classmethod def from_queryset(cls, queryset_class: Type[QuerySet], class_name: Optional[str] = ...) -> Any: ... @classmethod def _get_queryset_methods(cls, queryset_class: type) -> Dict[str, Any]: ... def contribute_to_class(self, model: Type[Model], name: str) -> None: ... def db_manager(self: _M, using: Optional[str] = ..., hints: Optional[Dict[str, Model]] = ...) -> _M: ... def get_queryset(self) -> QuerySet[_T]: ... class Manager(BaseManager[_T]): ... class RelatedManager(Manager[_T]): related_val: Tuple[int, ...] def add(self, *objs: Union[_T, int], bulk: bool = ...) -> None: ... def remove(self, *objs: Union[_T, int], bulk: bool = ...) -> None: ... def set( self, objs: Union[QuerySet[_T], Iterable[Union[_T, int]]], *, bulk: bool = ..., clear: bool = ... ) -> None: ... def clear(self) -> None: ... class ManagerDescriptor: manager: Manager = ... def __init__(self, manager: Manager) -> None: ... def __get__(self, instance: Optional[Model], cls: Type[Model] = ...) -> Manager: ... class EmptyManager(Manager): def __init__(self, model: Type[Model]) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/db/models/options.pyi0000664000175000017500000001160100000000000026731 0ustar00davedave00000000000000import collections from typing import Any, Callable, Dict, Generic, Iterator, List, Optional, Sequence, Tuple, Type, TypeVar, Union from django.apps.config import AppConfig from django.apps.registry import Apps from django.contrib.contenttypes.fields import GenericForeignKey from django.contrib.postgres.fields.array import ArrayField from django.contrib.postgres.fields.citext import CIText from django.db.backends.sqlite3.base import DatabaseWrapper from django.db.models.base import Model from django.db.models.constraints import BaseConstraint from django.db.models.fields.mixins import FieldCacheMixin from django.db.models.fields.related import ManyToManyField, OneToOneField from django.db.models.fields.reverse_related import ForeignObjectRel from django.db.models.manager import Manager from django.db.models.query_utils import PathInfo from django.utils.datastructures import ImmutableList from django.db.models.fields import AutoField, Field PROXY_PARENTS: Any EMPTY_RELATION_TREE: Any IMMUTABLE_WARNING: str DEFAULT_NAMES: Tuple[str, ...] def normalize_together( option_together: Union[Sequence[Tuple[str, str]], Tuple[str, str]] ) -> Tuple[Tuple[str, str], ...]: ... def make_immutable_fields_list( name: str, data: Union[Iterator[Any], List[Union[ArrayField, CIText]], List[Union[Field, FieldCacheMixin]]] ) -> ImmutableList: ... _M = TypeVar("_M", bound=Model) class Options(Generic[_M]): base_manager: Manager concrete_fields: ImmutableList constraints: List[BaseConstraint] default_manager: Manager fields: ImmutableList local_concrete_fields: ImmutableList related_objects: ImmutableList FORWARD_PROPERTIES: Any = ... REVERSE_PROPERTIES: Any = ... default_apps: Any = ... local_fields: List[Field] = ... local_many_to_many: List[ManyToManyField] = ... private_fields: List[Any] = ... local_managers: List[Manager] = ... base_manager_name: Optional[str] = ... default_manager_name: Optional[str] = ... model_name: Optional[str] = ... verbose_name: Optional[str] = ... verbose_name_plural: Optional[str] = ... db_table: str = ... ordering: Optional[Sequence[str]] = ... indexes: List[Any] = ... unique_together: Union[List[Any], Tuple] = ... index_together: Union[List[Any], Tuple] = ... select_on_save: bool = ... default_permissions: Sequence[str] = ... permissions: List[Any] = ... object_name: Optional[str] = ... app_label: str = ... get_latest_by: Optional[Sequence[str]] = ... order_with_respect_to: None = ... db_tablespace: str = ... required_db_features: List[Any] = ... required_db_vendor: None = ... meta: Optional[type] = ... pk: Optional[Field] = ... auto_field: Optional[AutoField] = ... abstract: bool = ... managed: bool = ... proxy: bool = ... proxy_for_model: Optional[Type[Model]] = ... concrete_model: Optional[Type[Model]] = ... swappable: None = ... parents: collections.OrderedDict = ... auto_created: bool = ... related_fkey_lookups: List[Any] = ... apps: Apps = ... default_related_name: Optional[str] = ... model: Type[Model] = ... original_attrs: Dict[str, Any] = ... def __init__(self, meta: Optional[type], app_label: Optional[str] = ...) -> None: ... @property def label(self) -> str: ... @property def label_lower(self) -> str: ... @property def app_config(self) -> AppConfig: ... @property def installed(self): ... def contribute_to_class(self, cls: Type[Model], name: str) -> None: ... def add_manager(self, manager: Manager) -> None: ... def add_field(self, field: Union[GenericForeignKey, Field], private: bool = ...) -> None: ... def setup_pk(self, field: Field) -> None: ... def setup_proxy(self, target: Type[Model]) -> None: ... def can_migrate(self, connection: Union[DatabaseWrapper, str]) -> bool: ... @property def verbose_name_raw(self) -> str: ... @property def swapped(self) -> Optional[str]: ... @property def many_to_many(self) -> List[ManyToManyField]: ... @property def fields_map(self) -> Dict[str, Union[Field, ForeignObjectRel]]: ... @property def managers(self) -> List[Manager]: ... @property def managers_map(self) -> Dict[str, Manager]: ... @property def db_returning_fields(self) -> List[Field]: ... def get_field(self, field_name: Union[Callable, str]) -> Field: ... def get_base_chain(self, model: Type[Model]) -> List[Type[Model]]: ... def get_parent_list(self) -> List[Type[Model]]: ... def get_ancestor_link(self, ancestor: Type[Model]) -> Optional[OneToOneField]: ... def get_path_to_parent(self, parent: Type[Model]) -> List[PathInfo]: ... def get_path_from_parent(self, parent: Type[Model]) -> List[PathInfo]: ... def get_fields( self, include_parents: bool = ..., include_hidden: bool = ... ) -> List[Union[Field, ForeignObjectRel]]: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/db/models/query.pyi0000664000175000017500000002176200000000000026414 0ustar00davedave00000000000000import datetime from typing import ( Any, Collection, Dict, Generic, Iterable, Iterator, List, MutableMapping, Optional, Sequence, Sized, Tuple, Type, TypeVar, Union, overload, Reversible, ) from django.db.models.base import Model from django.db.models.expressions import Combinable as Combinable, F as F # noqa: F401 from django.db.models.sql.query import Query, RawQuery from django.db import models from django.db.models import Manager from django.db.models.query_utils import Q as Q # noqa: F401 _T = TypeVar("_T", bound=models.Model, covariant=True) _QS = TypeVar("_QS", bound="_BaseQuerySet") class _BaseQuerySet(Generic[_T], Sized): model: Type[_T] query: Query def __init__( self, model: Optional[Type[models.Model]] = ..., query: Optional[Query] = ..., using: Optional[str] = ..., hints: Optional[Dict[str, models.Model]] = ..., ) -> None: ... @classmethod def as_manager(cls) -> Manager[Any]: ... def __len__(self) -> int: ... def __bool__(self) -> bool: ... def __class_getitem__(cls, item: Type[_T]): ... def __getstate__(self) -> Dict[str, Any]: ... # Technically, the other QuerySet must be of the same type _T, but _T is covariant def __and__(self: _QS, other: _BaseQuerySet[_T]) -> _QS: ... def __or__(self: _QS, other: _BaseQuerySet[_T]) -> _QS: ... def iterator(self, chunk_size: int = ...) -> Iterator[_T]: ... def aggregate(self, *args: Any, **kwargs: Any) -> Dict[str, Any]: ... def get(self, *args: Any, **kwargs: Any) -> _T: ... def create(self, *args: Any, **kwargs: Any) -> _T: ... def bulk_create( self, objs: Iterable[_T], batch_size: Optional[int] = ..., ignore_conflicts: bool = ... ) -> List[_T]: ... def bulk_update(self, objs: Iterable[_T], fields: Sequence[str], batch_size: Optional[int] = ...) -> None: ... def get_or_create(self, defaults: Optional[MutableMapping[str, Any]] = ..., **kwargs: Any) -> Tuple[_T, bool]: ... def update_or_create( self, defaults: Optional[MutableMapping[str, Any]] = ..., **kwargs: Any ) -> Tuple[_T, bool]: ... def earliest(self, *fields: Any, field_name: Optional[Any] = ...) -> _T: ... def latest(self, *fields: Any, field_name: Optional[Any] = ...) -> _T: ... def first(self) -> Optional[_T]: ... def last(self) -> Optional[_T]: ... def in_bulk(self, id_list: Iterable[Any] = ..., *, field_name: str = ...) -> Dict[Any, _T]: ... def delete(self) -> Tuple[int, Dict[str, int]]: ... def update(self, **kwargs: Any) -> int: ... def exists(self) -> bool: ... def explain(self, *, format: Optional[Any] = ..., **options: Any) -> str: ... def raw( self, raw_query: str, params: Any = ..., translations: Optional[Dict[str, str]] = ..., using: Optional[str] = ..., ) -> RawQuerySet: ... # The type of values may be overridden to be more specific in the mypy plugin, depending on the fields param def values(self, *fields: Union[str, Combinable], **expressions: Any) -> ValuesQuerySet[_T, Dict[str, Any]]: ... # The type of values_list may be overridden to be more specific in the mypy plugin, depending on the fields param def values_list( self, *fields: Union[str, Combinable], flat: bool = ..., named: bool = ... ) -> ValuesQuerySet[_T, Any]: ... def dates(self, field_name: str, kind: str, order: str = ...) -> ValuesQuerySet[_T, datetime.date]: ... def datetimes( self, field_name: str, kind: str, order: str = ..., tzinfo: Optional[datetime.tzinfo] = ... ) -> ValuesQuerySet[_T, datetime.datetime]: ... def none(self: _QS) -> _QS: ... def all(self: _QS) -> _QS: ... def filter(self: _QS, *args: Any, **kwargs: Any) -> _QS: ... def exclude(self: _QS, *args: Any, **kwargs: Any) -> _QS: ... def complex_filter(self, filter_obj: Any) -> _QS: ... def count(self) -> int: ... def union(self: _QS, *other_qs: Any, all: bool = ...) -> _QS: ... def intersection(self: _QS, *other_qs: Any) -> _QS: ... def difference(self: _QS, *other_qs: Any) -> _QS: ... def select_for_update(self: _QS, nowait: bool = ..., skip_locked: bool = ..., of: Tuple = ...) -> _QS: ... def select_related(self: _QS, *fields: Any) -> _QS: ... def prefetch_related(self: _QS, *lookups: Any) -> _QS: ... # TODO: return type def annotate(self, *args: Any, **kwargs: Any) -> QuerySet[Any]: ... def order_by(self: _QS, *field_names: Any) -> _QS: ... def distinct(self: _QS, *field_names: Any) -> _QS: ... # extra() return type won't be supported any time soon def extra( self, select: Optional[Dict[str, Any]] = ..., where: Optional[List[str]] = ..., params: Optional[List[Any]] = ..., tables: Optional[List[str]] = ..., order_by: Optional[Sequence[str]] = ..., select_params: Optional[Sequence[Any]] = ..., ) -> QuerySet[Any]: ... def reverse(self: _QS) -> _QS: ... def defer(self: _QS, *fields: Any) -> _QS: ... def only(self: _QS, *fields: Any) -> _QS: ... def using(self: _QS, alias: Optional[str]) -> _QS: ... @property def ordered(self) -> bool: ... @property def db(self) -> str: ... def resolve_expression(self, *args: Any, **kwargs: Any) -> Any: ... class QuerySet(_BaseQuerySet[_T], Collection[_T], Reversible[_T], Sized): def __iter__(self) -> Iterator[_T]: ... def __contains__(self, x: object) -> bool: ... @overload def __getitem__(self, i: int) -> _T: ... @overload def __getitem__(self: _QS, s: slice) -> _QS: ... def __reversed__(self) -> Iterator[_T]: ... _Row = TypeVar("_Row", covariant=True) class BaseIterable(Sequence[_Row]): def __init__(self, queryset: _BaseQuerySet, chunked_fetch: bool = ..., chunk_size: int = ...): ... def __iter__(self) -> Iterator[_Row]: ... def __contains__(self, x: object) -> bool: ... def __len__(self) -> int: ... @overload def __getitem__(self, i: int) -> _Row: ... @overload def __getitem__(self, s: slice) -> Sequence[_Row]: ... class ModelIterable(BaseIterable[Model]): ... class ValuesIterable(BaseIterable[Dict[str, Any]]): ... class ValuesListIterable(BaseIterable[Tuple]): ... class NamedValuesListIterable(ValuesListIterable): ... class FlatValuesListIterable(BaseIterable): def __iter__(self) -> Iterator[Any]: ... class ValuesQuerySet(_BaseQuerySet[_T], Collection[_Row], Sized): def __contains__(self, x: object) -> bool: ... def __iter__(self) -> Iterator[_Row]: ... # type: ignore @overload # type: ignore def __getitem__(self, i: int) -> _Row: ... @overload def __getitem__(self: _QS, s: slice) -> _QS: ... def iterator(self, chunk_size: int = ...) -> Iterator[_Row]: ... # type: ignore def get(self, *args: Any, **kwargs: Any) -> _Row: ... # type: ignore def earliest(self, *fields: Any, field_name: Optional[Any] = ...) -> _Row: ... # type: ignore def latest(self, *fields: Any, field_name: Optional[Any] = ...) -> _Row: ... # type: ignore def first(self) -> Optional[_Row]: ... # type: ignore def last(self) -> Optional[_Row]: ... # type: ignore class RawQuerySet(Iterable[_T], Sized): query: RawQuery def __init__( self, raw_query: Union[RawQuery, str], model: Optional[Type[models.Model]] = ..., query: Optional[Query] = ..., params: Tuple[Any] = ..., translations: Optional[Dict[str, str]] = ..., using: str = ..., hints: Optional[Dict[str, models.Model]] = ..., ) -> None: ... def __len__(self) -> int: ... def __iter__(self) -> Iterator[_T]: ... def __bool__(self) -> bool: ... @overload def __getitem__(self, k: int) -> _T: ... @overload def __getitem__(self, k: str) -> Any: ... @overload def __getitem__(self, k: slice) -> RawQuerySet[_T]: ... @property def columns(self) -> List[str]: ... @property def db(self) -> str: ... def iterator(self) -> Iterator[_T]: ... @property def model_fields(self) -> Dict[str, str]: ... def prefetch_related(self, *lookups: Any) -> RawQuerySet[_T]: ... def resolve_model_init_order(self) -> Tuple[List[str], List[int], List[Tuple[str, int]]]: ... def using(self, alias: Optional[str]) -> RawQuerySet[_T]: ... class Prefetch(object): def __init__(self, lookup: str, queryset: Optional[QuerySet] = ..., to_attr: Optional[str] = ...) -> None: ... def __getstate__(self) -> Dict[str, Any]: ... def add_prefix(self, prefix: str) -> None: ... def get_current_prefetch_to(self, level: int) -> str: ... def get_current_to_attr(self, level: int) -> Tuple[str, str]: ... def get_current_queryset(self, level) -> Optional[QuerySet]: ... def prefetch_related_objects(model_instances: Iterable[_T], *related_lookups: Union[str, Prefetch]) -> None: ... def get_prefetcher(instance: Model, through_attr: str, to_attr: str) -> Tuple[Any, Any, bool, bool]: ... class InstanceCheckMeta(type): ... class EmptyQuerySet(metaclass=InstanceCheckMeta): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/db/models/query_utils.pyi0000664000175000017500000000570300000000000027631 0ustar00davedave00000000000000from collections import namedtuple from typing import Any, Collection, Dict, Iterator, List, Mapping, Optional, Sequence, Set, Tuple, Type from django.db.models.base import Model from django.db.models.fields.mixins import FieldCacheMixin from django.db.models.sql.compiler import SQLCompiler from django.db.models.sql.query import Query from django.db.models.sql.where import WhereNode from django.db.models.fields import Field from django.utils import tree PathInfo = namedtuple("PathInfo", "from_opts to_opts target_fields join_field m2m direct filtered_relation") class InvalidQuery(Exception): ... def subclasses(cls: Type[RegisterLookupMixin]) -> Iterator[Type[RegisterLookupMixin]]: ... class QueryWrapper: contains_aggregate: bool = ... data: Tuple[str, List[Any]] = ... def __init__(self, sql: str, params: List[Any]) -> None: ... def as_sql(self, compiler: SQLCompiler = ..., connection: Any = ...) -> Any: ... class Q(tree.Node): AND: str = ... OR: str = ... conditional: bool = ... def __init__(self, *args: Any, **kwargs: Any) -> None: ... def __or__(self, other: Any) -> Q: ... def __and__(self, other: Any) -> Q: ... def __invert__(self) -> Q: ... def resolve_expression( self, query: Query = ..., allow_joins: bool = ..., reuse: Optional[Set[str]] = ..., summarize: bool = ..., for_save: bool = ..., ) -> WhereNode: ... def deconstruct(self) -> Tuple[str, Tuple, Dict[str, str]]: ... class DeferredAttribute: field_name: str = ... field: Field def __init__(self, field_name: str) -> None: ... class RegisterLookupMixin: lookup_name: str @classmethod def get_lookups(cls) -> Dict[str, Any]: ... def get_lookup(self, lookup_name: str) -> Optional[Any]: ... def get_transform(self, lookup_name: str) -> Optional[Any]: ... @staticmethod def merge_dicts(dicts: List[Dict[str, Any]]) -> Dict[str, Any]: ... @classmethod def register_lookup(cls, lookup: Any, lookup_name: Optional[str] = ...) -> Type[Any]: ... @classmethod def _unregister_lookup(cls, lookup: Any, lookup_name: Optional[str] = ...): ... def select_related_descend( field: Field, restricted: bool, requested: Optional[Mapping[str, Any]], load_fields: Optional[Collection[str]], reverse: bool = ..., ) -> bool: ... def refs_expression(lookup_parts: Sequence[str], annotations: Mapping[str, bool]) -> Tuple[bool, Sequence[str]]: ... def check_rel_lookup_compatibility(model: Type[Model], target_opts: Any, field: FieldCacheMixin) -> bool: ... class FilteredRelation: relation_name: str = ... alias: Optional[str] = ... condition: Q = ... path: List[str] = ... def __init__(self, relation_name: str, *, condition: Any = ...) -> None: ... def clone(self) -> FilteredRelation: ... def resolve_expression(self, *args: Any, **kwargs: Any) -> None: ... def as_sql(self, compiler: SQLCompiler, connection: Any) -> Any: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/db/models/signals.pyi0000664000175000017500000000152200000000000026677 0ustar00davedave00000000000000from typing import Any, Callable, Optional, Type, Union from django.apps.registry import Apps from django.db.models.base import Model from django.dispatch import Signal class_prepared: Any class ModelSignal(Signal): def connect( # type: ignore self, receiver: Callable, sender: Optional[Union[Type[Model], str]] = ..., weak: bool = ..., dispatch_uid: None = ..., apps: Optional[Apps] = ..., ) -> None: ... def disconnect( # type: ignore self, receiver: Callable = ..., sender: Optional[Union[Type[Model], str]] = ..., dispatch_uid: None = ..., apps: Optional[Apps] = ..., ) -> Optional[bool]: ... pre_init: Any post_init: Any pre_save: Any post_save: Any pre_delete: Any post_delete: Any m2m_changed: Any pre_migrate: Any post_migrate: Any ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4063792 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/db/models/sql/0000775000175000017500000000000000000000000025313 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/db/models/sql/__init__.pyi0000664000175000017500000000033300000000000027574 0ustar00davedave00000000000000from .query import Query as Query, RawQuery as RawQuery from .subqueries import ( InsertQuery as InsertQuery, AggregateQuery as AggregateQuery, DeleteQuery as DeleteQuery, UpdateQuery as UpdateQuery, ) ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/db/models/sql/compiler.pyi0000664000175000017500000001115000000000000027646 0ustar00davedave00000000000000from datetime import date, datetime from decimal import Decimal from itertools import chain from typing import Any, Callable, Dict, Iterator, List, Optional, Set, Tuple, Type, Union from uuid import UUID from django.db.models.base import Model from django.db.models.expressions import BaseExpression, Expression from django.db.models.sql.query import Query, RawQuery FORCE: Any class SQLCompiler: query: Any = ... connection: Any = ... using: Any = ... quote_cache: Any = ... select: Any = ... annotation_col_map: Any = ... klass_info: Any = ... ordering_parts: Any = ... def __init__(self, query: Union[Query, RawQuery], connection: Any, using: Optional[str]) -> None: ... col_count: Any = ... def setup_query(self) -> None: ... has_extra_select: Any = ... def pre_sql_setup( self, ) -> Tuple[ List[Tuple[Expression, Tuple[str, Union[List[Any], Tuple[str, str]]], None]], List[Tuple[Expression, Tuple[str, List[Union[int, str]], bool]]], List[Tuple[str, List[float]]], ]: ... def get_group_by( self, select: List[Tuple[BaseExpression, Tuple[str, List[float]], Optional[str]]], order_by: List[Tuple[Expression, Tuple[str, List[Union[int, str]], bool]]], ) -> List[Tuple[str, List[float]]]: ... def collapse_group_by( self, expressions: List[Expression], having: Union[List[Expression], Tuple] ) -> List[Expression]: ... def get_select( self, ) -> Tuple[ List[Tuple[Expression, Tuple[str, List[Union[int, str]]], Optional[str]]], Optional[Dict[str, Any]], Dict[str, int], ]: ... def get_order_by(self) -> List[Tuple[Expression, Tuple[str, List[Any], bool]]]: ... def get_extra_select( self, order_by: List[Tuple[Expression, Tuple[str, List[Any], bool]]], select: List[Tuple[Expression, Tuple[str, List[float]], Optional[str]]], ) -> List[Tuple[Expression, Tuple[str, List[Any]], None]]: ... def quote_name_unless_alias(self, name: str) -> str: ... def compile( self, node: Any, select_format: Any = ... ) -> Tuple[str, Union[List[Optional[int]], Tuple[int, int]]]: ... def get_combinator_sql(self, combinator: str, all: bool) -> Tuple[List[str], Union[List[int], List[str]]]: ... def as_sql(self, with_limits: bool = ..., with_col_aliases: bool = ...) -> Any: ... def get_default_columns( self, start_alias: Optional[str] = ..., opts: Optional[Any] = ..., from_parent: Optional[Type[Model]] = ... ) -> List[Expression]: ... def get_distinct(self) -> Tuple[List[Any], List[Any]]: ... def find_ordering_name( self, name: str, opts: Any, alias: Optional[str] = ..., default_order: str = ..., already_seen: Optional[Set[Tuple[Optional[Tuple[Tuple[str, str]]], Tuple[Tuple[str, str]]]]] = ..., ) -> List[Tuple[Expression, bool]]: ... def get_from_clause(self) -> Tuple[List[str], List[Union[int, str]]]: ... def get_related_selections( self, select: List[Tuple[Expression, Optional[str]]], opts: Optional[Any] = ..., root_alias: Optional[str] = ..., cur_depth: int = ..., requested: Optional[Union[Dict[str, Dict[str, Dict[str, Dict[Any, Any]]]], bool]] = ..., restricted: Optional[bool] = ..., ) -> List[Dict[str, Any]]: ... def get_select_for_update_of_arguments(self): ... def deferred_to_columns(self) -> Dict[Type[Model], Set[str]]: ... def get_converters(self, expressions: List[Expression]) -> Dict[int, Tuple[List[Callable], Expression]]: ... def apply_converters( self, rows: chain, converters: Dict[int, Tuple[List[Callable], Expression]] ) -> Iterator[ Union[ List[Optional[Union[bytes, datetime, int, str]]], List[Optional[Union[date, Decimal, float, str]]], List[Optional[Union[datetime, float, str, UUID]]], ] ]: ... def results_iter( self, results: Optional[Union[Iterator[Any], List[List[Tuple[Union[int, str]]]]]] = ..., tuple_expected: bool = ..., chunked_fetch: bool = ..., chunk_size: int = ..., ) -> Iterator[Any]: ... def has_results(self) -> bool: ... def execute_sql( self, result_type: str = ..., chunked_fetch: bool = ..., chunk_size: int = ... ) -> Optional[Any]: ... def as_subquery_condition(self, alias: str, columns: List[str], compiler: SQLCompiler) -> Tuple[str, Tuple]: ... def explain_query(self) -> Iterator[str]: ... def cursor_iter(cursor: Any, sentinel: Any, col_count: Optional[int], itersize: int) -> Iterator[Any]: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/db/models/sql/constants.pyi0000664000175000017500000000040600000000000030052 0ustar00davedave00000000000000from typing import Dict, Pattern, Tuple GET_ITERATOR_CHUNK_SIZE: int = ... MULTI: str = ... SINGLE: str = ... CURSOR: str = ... NO_RESULTS: str = ... ORDER_PATTERN: Pattern = ... ORDER_DIR: Dict[str, Tuple[str, str]] = ... INNER: str = ... LOUTER: str = ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/db/models/sql/datastructures.pyi0000664000175000017500000000356500000000000031124 0ustar00davedave00000000000000from collections import OrderedDict from typing import Any, Dict, List, Optional, Tuple, Union from django.db.models.fields.mixins import FieldCacheMixin from django.db.models.query_utils import FilteredRelation, PathInfo from django.db.models.sql.compiler import SQLCompiler class MultiJoin(Exception): level: int = ... names_with_path: List[Tuple[str, List[PathInfo]]] = ... def __init__(self, names_pos: int, path_with_names: List[Tuple[str, List[PathInfo]]]) -> None: ... class Empty: ... class Join: table_name: str = ... parent_alias: str = ... table_alias: Optional[str] = ... join_type: str = ... join_cols: Tuple = ... join_field: FieldCacheMixin = ... nullable: bool = ... filtered_relation: Optional[FilteredRelation] = ... def __init__( self, table_name: str, parent_alias: str, table_alias: Optional[str], join_type: str, join_field: FieldCacheMixin, nullable: bool, filtered_relation: Optional[FilteredRelation] = ..., ) -> None: ... def as_sql(self, compiler: SQLCompiler, connection: Any) -> Tuple[str, List[Union[int, str]]]: ... def relabeled_clone(self, change_map: Union[Dict[str, str], OrderedDict]) -> Join: ... def equals(self, other: Union[BaseTable, Join], with_filtered_relation: bool) -> bool: ... def demote(self) -> Join: ... def promote(self) -> Join: ... class BaseTable: join_type: Any = ... parent_alias: Any = ... filtered_relation: Any = ... table_name: str = ... table_alias: Optional[str] = ... def __init__(self, table_name: str, alias: Optional[str]) -> None: ... def as_sql(self, compiler: SQLCompiler, connection: Any) -> Tuple[str, List[Any]]: ... def relabeled_clone(self, change_map: OrderedDict) -> BaseTable: ... def equals(self, other: Join, with_filtered_relation: bool) -> bool: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/db/models/sql/query.pyi0000664000175000017500000002156000000000000027207 0ustar00davedave00000000000000import collections from collections import OrderedDict, namedtuple from typing import Any, Callable, Dict, Iterator, List, Optional, Sequence, Set, Tuple, Type, Union, Iterable from django.db.models.lookups import Lookup, Transform from django.db.models.query_utils import PathInfo, RegisterLookupMixin from django.db.models.sql.compiler import SQLCompiler from django.db.models.sql.datastructures import BaseTable from django.db.models.sql.where import WhereNode from django.db.models import Expression, Field, FilteredRelation, Model, Q, QuerySet from django.db.models.expressions import Combinable JoinInfo = namedtuple("JoinInfo", ["final_field", "targets", "opts", "joins", "path", "transform_function"]) class RawQuery: high_mark: Optional[int] low_mark: Optional[int] params: Union[Any] = ... sql: str = ... using: str = ... extra_select: Dict[Any, Any] = ... annotation_select: Dict[Any, Any] = ... cursor: object = ... def __init__(self, sql: str, using: str, params: Any = ...) -> None: ... def chain(self, using: str) -> RawQuery: ... def clone(self, using: str) -> RawQuery: ... def get_columns(self) -> List[str]: ... def __iter__(self): ... class Query: base_table: str related_ids: Optional[List[int]] related_updates: Dict[Type[Model], List[Tuple[Field, None, Union[int, str]]]] values: List[Any] alias_prefix: str = ... subq_aliases: frozenset = ... compiler: str = ... model: Optional[Type[Model]] = ... alias_refcount: Dict[str, int] = ... alias_map: Dict[str, BaseTable] = ... external_aliases: Set[str] = ... table_map: Dict[str, List[str]] = ... default_cols: bool = ... default_ordering: bool = ... standard_ordering: bool = ... used_aliases: Set[str] = ... filter_is_sticky: bool = ... subquery: bool = ... group_by: Optional[Union[Sequence[Combinable], Sequence[str], bool]] = ... order_by: Tuple = ... distinct: bool = ... distinct_fields: Tuple = ... select_for_update: bool = ... select_for_update_nowait: bool = ... select_for_update_skip_locked: bool = ... select_for_update_of: Tuple = ... select_related: Union[Dict[str, Any], bool] = ... max_depth: int = ... values_select: Tuple = ... annotation_select_mask: Optional[Set[str]] = ... combinator: Optional[str] = ... combinator_all: bool = ... combined_queries: Tuple = ... extra_select_mask: Optional[Set[str]] = ... extra_tables: Tuple = ... extra_order_by: Union[List[str], Tuple] = ... deferred_loading: Tuple[Union[Set[str], frozenset], bool] = ... explain_query: bool = ... explain_format: Optional[str] = ... explain_options: Dict[str, int] = ... high_mark: Optional[int] = ... low_mark: int = ... def __init__(self, model: Optional[Type[Model]], where: Type[WhereNode] = ...) -> None: ... @property def extra(self) -> OrderedDict: ... @property def annotations(self) -> OrderedDict: ... @property def has_select_fields(self) -> bool: ... def sql_with_params(self) -> Tuple[str, Tuple]: ... def __deepcopy__(self, memo: Dict[str, Any]) -> Query: ... def get_compiler(self, using: Optional[str] = ..., connection: Any = ...) -> SQLCompiler: ... def clone(self) -> Query: ... def chain(self, klass: Optional[Type[Query]] = ...) -> Query: ... def relabeled_clone(self, change_map: Union[Dict[Any, Any], OrderedDict]) -> Query: ... def get_count(self, using: str) -> int: ... def has_filters(self) -> WhereNode: ... def has_results(self, using: str) -> bool: ... def explain(self, using: str, format: Optional[str] = ..., **options: Any) -> str: ... def combine(self, rhs: Query, connector: str) -> None: ... def deferred_to_data(self, target: Dict[Any, Any], callback: Callable) -> None: ... def ref_alias(self, alias: str) -> None: ... def unref_alias(self, alias: str, amount: int = ...) -> None: ... def promote_joins(self, aliases: Set[str]) -> None: ... def demote_joins(self, aliases: Set[str]) -> None: ... def reset_refcounts(self, to_counts: Dict[str, int]) -> None: ... def change_aliases(self, change_map: Union[Dict[Any, Any], OrderedDict]) -> None: ... def bump_prefix(self, outer_query: Query) -> None: ... def get_initial_alias(self) -> str: ... def count_active_tables(self) -> int: ... def resolve_expression(self, query: Query, *args: Any, **kwargs: Any) -> Query: ... def as_sql(self, compiler: SQLCompiler, connection: Any) -> Any: ... def resolve_lookup_value(self, value: Any, can_reuse: Optional[Set[str]], allow_joins: bool) -> Any: ... def solve_lookup_type(self, lookup: str) -> Tuple[Sequence[str], Sequence[str], bool]: ... def build_filter( self, filter_expr: Union[Dict[str, str], Tuple[str, Tuple[int, int]]], branch_negated: bool = ..., current_negated: bool = ..., can_reuse: Optional[Set[str]] = ..., allow_joins: bool = ..., split_subq: bool = ..., reuse_with_filtered_relation: bool = ..., ) -> Tuple[WhereNode, List[Any]]: ... def add_filter(self, filter_clause: Tuple[str, Union[List[int], List[str]]]) -> None: ... def add_q(self, q_object: Q) -> None: ... def build_where(self, q_object: Q) -> Any: ... def build_filtered_relation_q( self, q_object: Q, reuse: Set[str], branch_negated: bool = ..., current_negated: bool = ... ) -> WhereNode: ... def add_filtered_relation(self, filtered_relation: FilteredRelation, alias: str) -> None: ... def setup_joins( self, names: List[str], opts: Any, alias: str, can_reuse: Optional[Set[str]] = ..., allow_many: bool = ..., reuse_with_filtered_relation: bool = ..., ) -> JoinInfo: ... def trim_joins( self, targets: Tuple[Field], joins: List[str], path: List[PathInfo] ) -> Tuple[Tuple[Field], str, List[str]]: ... def resolve_ref( self, name: str, allow_joins: bool = ..., reuse: Optional[Set[str]] = ..., summarize: bool = ... ) -> Expression: ... def split_exclude( self, filter_expr: Tuple[str, Union[QuerySet, int]], can_reuse: Set[str], names_with_path: List[Tuple[str, List[PathInfo]]], ) -> Tuple[WhereNode, Tuple]: ... def set_empty(self) -> None: ... def is_empty(self) -> bool: ... def set_limits(self, low: Optional[int] = ..., high: Optional[int] = ...) -> None: ... def clear_limits(self) -> None: ... def has_limit_one(self) -> bool: ... def can_filter(self) -> bool: ... def clear_select_clause(self) -> None: ... def clear_select_fields(self) -> None: ... def set_select(self, cols: List[Expression]) -> None: ... def add_distinct_fields(self, *field_names: Any) -> None: ... def add_fields(self, field_names: Union[Iterator[Any], List[str]], allow_m2m: bool = ...) -> None: ... def add_ordering(self, *ordering: Any) -> None: ... def clear_ordering(self, force_empty: bool) -> None: ... def set_group_by(self) -> None: ... def add_select_related(self, fields: Iterable[str]) -> None: ... def add_extra( self, select: Optional[Dict[str, Any]], select_params: Optional[Iterable[Any]], where: Optional[Sequence[str]], params: Optional[Sequence[str]], tables: Optional[Sequence[str]], order_by: Optional[Sequence[str]], ) -> None: ... def clear_deferred_loading(self) -> None: ... def add_deferred_loading(self, field_names: Iterable[str]) -> None: ... def add_immediate_loading(self, field_names: Iterable[str]) -> None: ... def get_loaded_field_names(self) -> Dict[Type[Model], Set[str]]: ... def get_loaded_field_names_cb( self, target: Dict[Type[Model], Set[str]], model: Type[Model], fields: Set[Field] ) -> None: ... def set_annotation_mask(self, names: Optional[Union[List[str], Set[str], Tuple]]) -> None: ... def append_annotation_mask(self, names: List[str]) -> None: ... def set_extra_mask(self, names: Union[List[str], Tuple]) -> None: ... def set_values(self, fields: Union[List[str], Tuple]) -> None: ... def trim_start(self, names_with_path: List[Tuple[str, List[PathInfo]]]) -> Tuple[str, bool]: ... def is_nullable(self, field: Field) -> bool: ... def build_lookup( self, lookups: Sequence[str], lhs: Union[RegisterLookupMixin, Query], rhs: Optional[Query] ) -> Lookup: ... def try_transform(self, lhs: Union[RegisterLookupMixin, Query], name: str) -> Transform: ... class JoinPromoter: connector: str = ... negated: bool = ... effective_connector: str = ... num_children: int = ... votes: collections.Counter = ... def __init__(self, connector: str, num_children: int, negated: bool) -> None: ... def add_votes(self, votes: Union[Iterator[Any], List[Any], Set[str], Tuple]) -> None: ... def update_join_types(self, query: Query) -> Set[str]: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/db/models/sql/subqueries.pyi0000664000175000017500000000344400000000000030232 0ustar00davedave00000000000000from typing import Any, Dict, Iterable, List, Optional, Tuple, Type, Union from django.db.models.base import Model from django.db.models.expressions import Case from django.db.models.query import QuerySet from django.db.models.sql.query import Query from django.db.models.sql.where import WhereNode from django.db.models.fields import Field class DeleteQuery(Query): select: Tuple where_class: Type[WhereNode] where: WhereNode = ... def do_query(self, table: str, where: WhereNode, using: str) -> int: ... def delete_batch(self, pk_list: Union[List[int], List[str]], using: str) -> int: ... def delete_qs(self, query: QuerySet, using: str) -> int: ... class UpdateQuery(Query): select: Tuple where_class: Type[WhereNode] def __init__(self, *args: Any, **kwargs: Any) -> None: ... where: WhereNode = ... def update_batch(self, pk_list: List[int], values: Dict[str, Optional[int]], using: str) -> None: ... def add_update_values(self, values: Dict[str, Any]) -> None: ... def add_update_fields(self, values_seq: List[Tuple[Field, Optional[Type[Model]], Case]]) -> None: ... def add_related_update(self, model: Type[Model], field: Field, value: Union[int, str]) -> None: ... def get_related_updates(self) -> List[UpdateQuery]: ... class InsertQuery(Query): select: Tuple where: WhereNode where_class: Type[WhereNode] fields: Iterable[Field] = ... objs: List[Model] = ... raw: bool = ... def __init__(self, *args: Any, **kwargs: Any) -> None: ... def insert_values(self, fields: Iterable[Field], objs: List[Model], raw: bool = ...) -> None: ... class AggregateQuery(Query): select: Tuple sub_params: Tuple where: WhereNode where_class: Type[WhereNode] def add_subquery(self, query: Query, using: str) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/db/models/sql/where.pyi0000664000175000017500000000357600000000000027163 0ustar00davedave00000000000000from collections import OrderedDict from typing import Any, Dict, List, Optional, Tuple, Union from django.db.models.expressions import Expression from django.db.models.sql.compiler import SQLCompiler from django.db.models.sql.query import Query from django.utils import tree AND: str OR: str class WhereNode(tree.Node): connector: str contains_aggregate: bool contains_over_clause: bool negated: bool default: Any = ... resolved: bool = ... conditional: bool = ... def split_having(self, negated: bool = ...) -> Tuple[Optional[WhereNode], Optional[WhereNode]]: ... def as_sql(self, compiler: SQLCompiler, connection: Any) -> Any: ... def get_group_by_cols(self) -> List[Expression]: ... def relabel_aliases(self, change_map: Union[Dict[Optional[str], str], OrderedDict]) -> None: ... def clone(self) -> WhereNode: ... def relabeled_clone(self, change_map: Union[Dict[Optional[str], str], OrderedDict]) -> WhereNode: ... def resolve_expression(self, *args: Any, **kwargs: Any) -> WhereNode: ... class NothingNode: contains_aggregate: bool = ... def as_sql(self, compiler: SQLCompiler = ..., connection: Any = ...) -> Any: ... class ExtraWhere: contains_aggregate: bool = ... sqls: List[str] = ... params: Optional[Union[List[int], List[str]]] = ... def __init__(self, sqls: List[str], params: Optional[Union[List[int], List[str]]]) -> None: ... def as_sql(self, compiler: SQLCompiler = ..., connection: Any = ...) -> Tuple[str, Union[List[int], List[str]]]: ... class SubqueryConstraint: contains_aggregate: bool = ... alias: str = ... columns: List[str] = ... targets: List[str] = ... query_object: Query = ... def __init__(self, alias: str, columns: List[str], targets: List[str], query_object: Query) -> None: ... def as_sql(self, compiler: SQLCompiler, connection: Any) -> Tuple[str, Tuple]: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/db/models/utils.pyi0000664000175000017500000000023500000000000026377 0ustar00davedave00000000000000from typing import Tuple, Type, Union from django.db.models.base import Model def make_model_tuple(model: Union[Type[Model], str]) -> Tuple[str, str]: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/db/transaction.pyi0000664000175000017500000000376000000000000026307 0ustar00davedave00000000000000from contextlib import contextmanager from typing import Any, Callable, Optional, overload, TypeVar, Iterator from django.db import ProgrammingError class TransactionManagementError(ProgrammingError): ... def get_connection(using: Optional[str] = ...) -> Any: ... def get_autocommit(using: Optional[str] = ...) -> bool: ... def set_autocommit(autocommit: bool, using: Optional[str] = ...) -> Any: ... def commit(using: Optional[str] = ...) -> Any: ... def rollback(using: Optional[str] = ...) -> Any: ... def savepoint(using: Optional[str] = ...) -> str: ... def savepoint_rollback(sid: str, using: Optional[str] = ...) -> None: ... def savepoint_commit(sid: Any, using: Optional[Any] = ...) -> None: ... def clean_savepoints(using: Optional[Any] = ...) -> None: ... def get_rollback(using: Optional[str] = ...) -> bool: ... def set_rollback(rollback: bool, using: Optional[str] = ...) -> None: ... @contextmanager def mark_for_rollback_on_error(using: Optional[str] = ...) -> Iterator[None]: ... def on_commit(func: Callable, using: Optional[str] = ...) -> None: ... _C = TypeVar("_C", bound=Callable) # Any callable # Don't inherit from ContextDecorator, so we can provide a more specific signature for __call__ class Atomic: using: Optional[str] = ... savepoint: bool = ... def __init__(self, using: Optional[str], savepoint: bool) -> None: ... # When decorating, return the decorated function as-is, rather than clobbering it as ContextDecorator does. def __call__(self, func: _C) -> _C: ... def __enter__(self) -> None: ... def __exit__(self, exc_type: None, exc_value: None, traceback: None) -> None: ... # Bare decorator @overload def atomic(using: _C) -> _C: ... # Decorator or context-manager with parameters @overload def atomic(using: Optional[str] = ..., savepoint: bool = ...) -> Atomic: ... # Bare decorator @overload def non_atomic_requests(using: _C) -> _C: ... # Decorator with arguments @overload def non_atomic_requests(using: Optional[str] = ...) -> Callable[[_C], _C]: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/db/utils.pyi0000664000175000017500000000233400000000000025116 0ustar00davedave00000000000000from typing import Any, Dict, Iterable, List, Optional DEFAULT_DB_ALIAS: str DJANGO_VERSION_PICKLE_KEY: str class Error(Exception): ... class InterfaceError(Error): ... class DatabaseError(Error): ... class DataError(DatabaseError): ... class OperationalError(DatabaseError): ... class IntegrityError(DatabaseError): ... class InternalError(DatabaseError): ... class ProgrammingError(DatabaseError): ... class NotSupportedError(DatabaseError): ... def load_backend(backend_name: str) -> Any: ... class ConnectionDoesNotExist(Exception): ... class ConnectionHandler: databases: Dict[str, Dict[str, Optional[Any]]] def __init__(self, databases: Dict[str, Dict[str, Optional[Any]]] = ...) -> None: ... def ensure_defaults(self, alias: str) -> None: ... def prepare_test_settings(self, alias: str) -> None: ... def __getitem__(self, alias: str) -> Any: ... def __setitem__(self, key: Any, value: Any) -> None: ... def __delitem__(self, key: Any) -> None: ... def __iter__(self): ... def all(self) -> List[Any]: ... def close_all(self) -> None: ... class ConnectionRouter: def __init__(self, routers: Optional[Iterable[Any]] = ...) -> None: ... @property def routers(self) -> List[Any]: ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4063792 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/dispatch/0000775000175000017500000000000000000000000024443 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/dispatch/__init__.pyi0000664000175000017500000000011600000000000026723 0ustar00davedave00000000000000from django.dispatch.dispatcher import Signal as Signal, receiver as receiver ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/dispatch/dispatcher.pyi0000664000175000017500000000174200000000000027320 0ustar00davedave00000000000000from typing import Any, Callable, List, Optional, Tuple, Union NONE_ID: Any NO_RECEIVERS: Any class Signal: receivers: Any = ... providing_args: Any = ... lock: Any = ... use_caching: Any = ... sender_receivers_cache: Any = ... def __init__(self, providing_args: List[str] = ..., use_caching: bool = ...) -> None: ... def connect( self, receiver: Callable, sender: Optional[object] = ..., weak: bool = ..., dispatch_uid: Optional[str] = ... ) -> None: ... def disconnect( self, receiver: Optional[Callable] = ..., sender: Optional[object] = ..., dispatch_uid: Optional[str] = ... ) -> bool: ... def has_listeners(self, sender: Any = ...) -> bool: ... def send(self, sender: Any, **named: Any) -> List[Tuple[Callable, Optional[str]]]: ... def send_robust(self, sender: Any, **named: Any) -> List[Tuple[Callable, Union[ValueError, str]]]: ... def receiver(signal: Union[List[Signal], Signal], **kwargs: Any) -> Callable: ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4063792 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/forms/0000775000175000017500000000000000000000000023772 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/forms/__init__.pyi0000664000175000017500000000561500000000000026263 0ustar00davedave00000000000000from django.core.exceptions import ValidationError as ValidationError from .forms import Form as Form, BaseForm as BaseForm from .formsets import BaseFormSet as BaseFormSet, all_valid as all_valid, formset_factory as formset_factory from .models import ( ModelForm as ModelForm, ModelChoiceField as ModelChoiceField, ModelMultipleChoiceField as ModelMultipleChoiceField, model_to_dict as model_to_dict, BaseModelForm as BaseModelForm, BaseInlineFormSet as BaseInlineFormSet, BaseModelFormSet as BaseModelFormSet, fields_for_model as fields_for_model, inlineformset_factory as inlineformset_factory, modelform_factory as modelform_factory, InlineForeignKeyField as InlineForeignKeyField, ModelChoiceIterator as ModelChoiceIterator, ModelFormMetaclass as ModelFormMetaclass, ModelFormOptions as ModelFormOptions, modelformset_factory as modelformset_factory, ) from .widgets import ( Widget as Widget, ChoiceWidget as ChoiceWidget, NumberInput as NumberInput, Select as Select, CheckboxInput as CheckboxInput, CheckboxSelectMultiple as CheckboxSelectMultiple, Media as Media, MultiWidget as MultiWidget, TextInput as TextInput, Textarea as Textarea, Input as Input, ClearableFileInput as ClearableFileInput, DateInput as DateInput, DateTimeBaseInput as DateTimeBaseInput, DateTimeInput as DateTimeInput, EmailInput as EmailInput, FileInput as FileInput, HiddenInput as HiddenInput, MultipleHiddenInput as MultipleHiddenInput, NullBooleanSelect as NullBooleanSelect, PasswordInput as PasswordInput, RadioSelect as RadioSelect, SelectMultiple as SelectMultiple, TimeInput as TimeInput, URLInput as URLInput, SelectDateWidget as SelectDateWidget, SplitHiddenDateTimeWidget as SplitHiddenDateTimeWidget, SplitDateTimeWidget as SplitDateTimeWidget, ) from .fields import ( Field as Field, CharField as CharField, ChoiceField as ChoiceField, DurationField as DurationField, FileField as FileField, ImageField as ImageField, DateTimeField as DateTimeField, DateField as DateField, BooleanField as BooleanField, EmailField as EmailField, FloatField as FloatField, MultiValueField as MultiValueField, MultipleChoiceField as MultipleChoiceField, NullBooleanField as NullBooleanField, SplitDateTimeField as SplitDateTimeField, TimeField as TimeField, IntegerField as IntegerField, FilePathField as FilePathField, DecimalField as DecimalField, UUIDField as UUIDField, URLField as URLField, ComboField as ComboField, GenericIPAddressField as GenericIPAddressField, RegexField as RegexField, SlugField as SlugField, TypedChoiceField as TypedChoiceField, TypedMultipleChoiceField as TypedMultipleChoiceField, ) from .boundfield import BoundField as BoundField, BoundWidget as BoundWidget ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/forms/boundfield.pyi0000664000175000017500000000440400000000000026632 0ustar00davedave00000000000000from typing import Any, Dict, List, Optional, Union from django.forms.fields import Field from django.forms.forms import BaseForm from django.forms.renderers import DjangoTemplates from django.forms.utils import ErrorList from django.forms.widgets import Widget from django.utils.safestring import SafeText class BoundField: initial: Any form: BaseForm = ... field: Field = ... name: str = ... html_name: str = ... html_initial_name: str = ... html_initial_id: str = ... label: str = ... help_text: str = ... def __init__(self, form: BaseForm, field: Field, name: str) -> None: ... def subwidgets(self) -> List[BoundWidget]: ... def __bool__(self) -> bool: ... def __iter__(self): ... def __len__(self) -> int: ... def __getitem__(self, idx: Union[int, slice, str]) -> Union[List[BoundWidget], BoundWidget]: ... @property def errors(self) -> ErrorList: ... def as_widget(self, widget: Optional[Widget] = ..., attrs: None = ..., only_initial: bool = ...) -> SafeText: ... def as_text(self, attrs: None = ..., **kwargs: Any) -> SafeText: ... def as_textarea(self, attrs: None = ..., **kwargs: Any) -> SafeText: ... def as_hidden(self, attrs: None = ..., **kwargs: Any) -> SafeText: ... @property def data(self) -> Any: ... def value(self) -> Any: ... def label_tag( self, contents: Optional[str] = ..., attrs: Optional[Dict[str, str]] = ..., label_suffix: Optional[str] = ... ) -> SafeText: ... def css_classes(self, extra_classes: None = ...) -> str: ... @property def is_hidden(self) -> bool: ... @property def auto_id(self) -> str: ... @property def id_for_label(self) -> str: ... def build_widget_attrs( self, attrs: Dict[str, str], widget: Optional[Widget] = ... ) -> Dict[str, Union[bool, str]]: ... class BoundWidget: parent_widget: Widget = ... data: Dict[str, Any] = ... renderer: DjangoTemplates = ... def __init__(self, parent_widget: Widget, data: Dict[str, Any], renderer: DjangoTemplates) -> None: ... def tag(self, wrap_label: bool = ...) -> SafeText: ... @property def template_name(self) -> str: ... @property def id_for_label(self) -> str: ... @property def choice_label(self) -> str: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/forms/fields.pyi0000664000175000017500000003135500000000000025772 0ustar00davedave00000000000000from datetime import datetime, timedelta from typing import Any, Callable, Iterable, List, Optional, Pattern, Sequence, Tuple, Type, Union from django.core.validators import BaseValidator from django.forms.boundfield import BoundField from django.forms.forms import BaseForm from django.forms.widgets import Widget _Choice = Tuple[Any, str] _ChoiceNamedGroup = Tuple[str, Iterable[_Choice]] _FieldChoices = Iterable[Union[_Choice, _ChoiceNamedGroup]] class Field: initial: Any label: Optional[str] required: bool widget: Type[Widget] = ... hidden_widget: Any = ... default_validators: Any = ... default_error_messages: Any = ... empty_values: Any = ... show_hidden_initial: bool = ... help_text: str = ... disabled: bool = ... label_suffix: Optional[Any] = ... localize: bool = ... error_messages: Any = ... validators: List[BaseValidator] = ... max_length: Optional[Union[int, str]] = ... choices: _FieldChoices = ... base_field: Field def __init__( self, *, required: bool = ..., widget: Optional[Union[Widget, Type[Widget]]] = ..., label: Optional[Any] = ..., initial: Optional[Any] = ..., help_text: str = ..., error_messages: Optional[Any] = ..., show_hidden_initial: bool = ..., validators: Sequence[Any] = ..., localize: bool = ..., disabled: bool = ..., label_suffix: Optional[Any] = ..., ) -> None: ... def prepare_value(self, value: Any) -> Any: ... def to_python(self, value: Optional[Any]) -> Optional[Any]: ... def validate(self, value: Any) -> None: ... def run_validators(self, value: Any) -> None: ... def clean(self, value: Any) -> Any: ... def bound_data(self, data: Any, initial: Any) -> Any: ... def widget_attrs(self, widget: Widget) -> Any: ... def has_changed(self, initial: Any, data: Any) -> bool: ... def get_bound_field(self, form: BaseForm, field_name: str) -> BoundField: ... def deconstruct(self) -> Any: ... class CharField(Field): min_length: Optional[Union[int, str]] = ... strip: bool = ... empty_value: Optional[str] = ... def __init__( self, max_length: Optional[Any] = ..., min_length: Optional[Any] = ..., strip: bool = ..., empty_value: Optional[str] = ..., required: bool = ..., widget: Optional[Union[Widget, Type[Widget]]] = ..., label: Optional[Any] = ..., initial: Optional[Any] = ..., help_text: str = ..., error_messages: Optional[Any] = ..., show_hidden_initial: bool = ..., validators: Sequence[Any] = ..., localize: bool = ..., disabled: bool = ..., label_suffix: Optional[Any] = ..., ) -> None: ... class IntegerField(Field): max_value: Optional[Any] min_value: Optional[Any] re_decimal: Any = ... def __init__( self, max_value: Optional[Any] = ..., min_value: Optional[Any] = ..., required: bool = ..., widget: Optional[Union[Widget, Type[Widget]]] = ..., label: Optional[Any] = ..., initial: Optional[Any] = ..., help_text: str = ..., error_messages: Optional[Any] = ..., show_hidden_initial: bool = ..., validators: Sequence[Any] = ..., localize: bool = ..., disabled: bool = ..., label_suffix: Optional[Any] = ..., ) -> None: ... class FloatField(IntegerField): ... class DecimalField(IntegerField): decimal_places: Optional[int] max_digits: Optional[int] def __init__( self, *, max_value: Optional[Any] = ..., min_value: Optional[Any] = ..., max_digits: Optional[Any] = ..., decimal_places: Optional[Any] = ..., required: bool = ..., widget: Optional[Union[Widget, Type[Widget]]] = ..., label: Optional[Any] = ..., initial: Optional[Any] = ..., help_text: str = ..., error_messages: Optional[Any] = ..., show_hidden_initial: bool = ..., validators: Sequence[Any] = ..., localize: bool = ..., disabled: bool = ..., label_suffix: Optional[Any] = ..., ) -> None: ... class BaseTemporalField(Field): input_formats: Any = ... def __init__( self, input_formats: Optional[Any] = ..., required: bool = ..., widget: Optional[Union[Widget, Type[Widget]]] = ..., label: Optional[Any] = ..., initial: Optional[Any] = ..., help_text: str = ..., error_messages: Optional[Any] = ..., show_hidden_initial: bool = ..., validators: Sequence[Any] = ..., localize: bool = ..., disabled: bool = ..., label_suffix: Optional[Any] = ..., ) -> None: ... def strptime(self, value: Any, format: str) -> Any: ... class DateField(BaseTemporalField): ... class TimeField(BaseTemporalField): ... class DateTimeField(BaseTemporalField): ... class DurationField(Field): def prepare_value(self, value: Optional[Union[timedelta, str]]) -> Optional[str]: ... class RegexField(CharField): regex: str = ... def __init__( self, regex: Union[str, Pattern], max_length: Optional[Any] = ..., min_length: Optional[Any] = ..., strip: bool = ..., empty_value: Optional[str] = ..., required: bool = ..., widget: Optional[Union[Widget, Type[Widget]]] = ..., label: Optional[Any] = ..., initial: Optional[Any] = ..., help_text: str = ..., error_messages: Optional[Any] = ..., show_hidden_initial: bool = ..., validators: Sequence[Any] = ..., localize: bool = ..., disabled: bool = ..., label_suffix: Optional[Any] = ..., ) -> None: ... class EmailField(CharField): ... class FileField(Field): allow_empty_file: bool = ... def __init__( self, max_length: Optional[Any] = ..., allow_empty_file: bool = ..., required: bool = ..., widget: Optional[Union[Widget, Type[Widget]]] = ..., label: Optional[Any] = ..., initial: Optional[Any] = ..., help_text: str = ..., error_messages: Optional[Any] = ..., show_hidden_initial: bool = ..., validators: Sequence[Any] = ..., localize: bool = ..., disabled: bool = ..., label_suffix: Optional[Any] = ..., ) -> None: ... def clean(self, data: Any, initial: Optional[Any] = ...): ... class ImageField(FileField): ... class URLField(CharField): ... class BooleanField(Field): ... class NullBooleanField(BooleanField): ... class CallableChoiceIterator: choices_func: Callable = ... def __init__(self, choices_func: Callable) -> None: ... def __iter__(self) -> None: ... class ChoiceField(Field): def __init__( self, choices: Union[_FieldChoices, Callable[[], _FieldChoices]] = ..., required: bool = ..., widget: Optional[Union[Widget, Type[Widget]]] = ..., label: Optional[Any] = ..., initial: Optional[Any] = ..., help_text: str = ..., error_messages: Optional[Any] = ..., show_hidden_initial: bool = ..., validators: Sequence[Any] = ..., localize: bool = ..., disabled: bool = ..., label_suffix: Optional[Any] = ..., ) -> None: ... def valid_value(self, value: str) -> bool: ... class TypedChoiceField(ChoiceField): coerce: Union[Callable, Type[Any]] = ... empty_value: Optional[str] = ... def __init__( self, coerce: Any = ..., empty_value: Optional[str] = ..., choices: Any = ..., required: bool = ..., widget: Optional[Union[Widget, Type[Widget]]] = ..., label: Optional[Any] = ..., initial: Optional[Any] = ..., help_text: str = ..., error_messages: Optional[Any] = ..., show_hidden_initial: bool = ..., validators: Sequence[Any] = ..., localize: bool = ..., disabled: bool = ..., label_suffix: Optional[Any] = ..., ) -> None: ... class MultipleChoiceField(ChoiceField): ... class TypedMultipleChoiceField(MultipleChoiceField): coerce: Union[Callable, Type[float]] = ... empty_value: Optional[List[Any]] = ... def __init__( self, coerce: Any = ..., empty_value: Optional[str] = ..., choices: Any = ..., required: bool = ..., widget: Optional[Union[Widget, Type[Widget]]] = ..., label: Optional[Any] = ..., initial: Optional[Any] = ..., help_text: str = ..., error_messages: Optional[Any] = ..., show_hidden_initial: bool = ..., validators: Sequence[Any] = ..., localize: bool = ..., disabled: bool = ..., label_suffix: Optional[Any] = ..., ) -> None: ... class ComboField(Field): fields: Any = ... def __init__( self, fields: Sequence[Field], required: bool = ..., widget: Optional[Union[Widget, Type[Widget]]] = ..., label: Optional[Any] = ..., initial: Optional[Any] = ..., help_text: str = ..., error_messages: Optional[Any] = ..., show_hidden_initial: bool = ..., validators: Sequence[Any] = ..., localize: bool = ..., disabled: bool = ..., label_suffix: Optional[Any] = ..., ) -> None: ... class MultiValueField(Field): require_all_fields: bool = ... fields: Any = ... def __init__( self, fields: Sequence[Field], require_all_fields: bool = ..., required: bool = ..., widget: Optional[Union[Widget, Type[Widget]]] = ..., label: Optional[Any] = ..., initial: Optional[Any] = ..., help_text: str = ..., error_messages: Optional[Any] = ..., show_hidden_initial: bool = ..., validators: Sequence[Any] = ..., localize: bool = ..., disabled: bool = ..., label_suffix: Optional[Any] = ..., ) -> None: ... def compress(self, data_list: Any) -> Any: ... class FilePathField(ChoiceField): allow_files: bool allow_folders: bool match: Optional[str] path: str recursive: bool match_re: Any = ... def __init__( self, path: str, match: Optional[Any] = ..., recursive: bool = ..., allow_files: bool = ..., allow_folders: bool = ..., choices: Any = ..., required: bool = ..., widget: Optional[Union[Widget, Type[Widget]]] = ..., label: Optional[Any] = ..., initial: Optional[Any] = ..., help_text: str = ..., error_messages: Optional[Any] = ..., show_hidden_initial: bool = ..., validators: Sequence[Any] = ..., localize: bool = ..., disabled: bool = ..., label_suffix: Optional[Any] = ..., ) -> None: ... class SplitDateTimeField(MultiValueField): def __init__( self, input_date_formats: Optional[Any] = ..., input_time_formats: Optional[Any] = ..., fields: Sequence[Field] = ..., require_all_fields: bool = ..., required: bool = ..., widget: Optional[Union[Widget, Type[Widget]]] = ..., label: Optional[Any] = ..., initial: Optional[Any] = ..., help_text: str = ..., error_messages: Optional[Any] = ..., show_hidden_initial: bool = ..., validators: Sequence[Any] = ..., localize: bool = ..., disabled: bool = ..., label_suffix: Optional[Any] = ..., ) -> None: ... def compress(self, data_list: List[Optional[datetime]]) -> Optional[datetime]: ... class GenericIPAddressField(CharField): unpack_ipv4: bool = ... def __init__( self, protocol: str = ..., unpack_ipv4: bool = ..., required: bool = ..., widget: Optional[Union[Widget, Type[Widget]]] = ..., label: Optional[Any] = ..., initial: Optional[Any] = ..., help_text: str = ..., error_messages: Optional[Any] = ..., show_hidden_initial: bool = ..., validators: Sequence[Any] = ..., localize: bool = ..., disabled: bool = ..., label_suffix: Optional[Any] = ..., ) -> None: ... class SlugField(CharField): allow_unicode: bool = ... def __init__( self, allow_unicode: bool = ..., required: bool = ..., widget: Optional[Union[Widget, Type[Widget]]] = ..., label: Optional[Any] = ..., initial: Optional[Any] = ..., help_text: str = ..., error_messages: Optional[Any] = ..., show_hidden_initial: bool = ..., validators: Sequence[Any] = ..., localize: bool = ..., disabled: bool = ..., label_suffix: Optional[Any] = ..., ) -> None: ... class UUIDField(CharField): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/forms/forms.pyi0000664000175000017500000000603000000000000025642 0ustar00davedave00000000000000from typing import Any, Dict, Iterator, List, Mapping, Optional, Sequence, Type, Union from django.core.exceptions import ValidationError as ValidationError from django.core.files import uploadedfile from django.forms.boundfield import BoundField from django.forms.fields import Field from django.forms.renderers import BaseRenderer from django.forms.utils import ErrorDict, ErrorList from django.forms.widgets import Media, MediaDefiningClass from django.utils.datastructures import MultiValueDict from django.utils.safestring import SafeText class DeclarativeFieldsMetaclass(MediaDefiningClass): ... class BaseForm: class Meta: fields: Sequence[str] = ... default_renderer: Any = ... field_order: Any = ... use_required_attribute: bool = ... is_bound: bool = ... data: Dict[str, Any] = ... files: MultiValueDict[str, uploadedfile.UploadedFile] = ... auto_id: Union[bool, str] = ... initial: Dict[str, Any] = ... error_class: Type[ErrorList] = ... prefix: Optional[str] = ... label_suffix: str = ... empty_permitted: bool = ... fields: Dict[str, Any] = ... renderer: BaseRenderer = ... cleaned_data: Any = ... def __init__( self, data: Optional[Mapping[str, Any]] = ..., files: Optional[Mapping[str, Any]] = ..., auto_id: Optional[Union[bool, str]] = ..., prefix: Optional[str] = ..., initial: Optional[Mapping[str, Any]] = ..., error_class: Type[ErrorList] = ..., label_suffix: Optional[str] = ..., empty_permitted: bool = ..., field_order: Optional[Any] = ..., use_required_attribute: Optional[bool] = ..., renderer: Any = ..., ) -> None: ... def order_fields(self, field_order: Optional[List[str]]) -> None: ... def __iter__(self) -> Iterator[BoundField]: ... def __getitem__(self, name: str) -> BoundField: ... @property def errors(self) -> ErrorDict: ... def is_valid(self) -> bool: ... def add_prefix(self, field_name: str) -> str: ... def add_initial_prefix(self, field_name: str) -> str: ... def as_table(self) -> SafeText: ... def as_ul(self) -> SafeText: ... def as_p(self) -> SafeText: ... def non_field_errors(self) -> ErrorList: ... def add_error(self, field: Optional[str], error: Union[ValidationError, str]) -> None: ... def has_error(self, field: Any, code: Optional[Any] = ...): ... def full_clean(self) -> None: ... def clean(self) -> Dict[str, Any]: ... def has_changed(self) -> bool: ... @property def changed_data(self) -> List[str]: ... @property def media(self) -> Media: ... def is_multipart(self): ... def hidden_fields(self): ... def visible_fields(self): ... def get_initial_for_field(self, field: Field, field_name: str) -> Any: ... def _html_output( self, normal_row: str, error_row: str, row_ender: str, help_text_html: str, errors_on_separate_row: bool, ) -> SafeText: ... class Form(BaseForm): base_fields: Dict[str, Field] declared_fields: Dict[str, Field] ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/forms/formsets.pyi0000664000175000017500000000453500000000000026366 0ustar00davedave00000000000000from typing import Any, Dict, Mapping, Optional, Sequence, Sized from django.forms import Form TOTAL_FORM_COUNT: str = ... INITIAL_FORM_COUNT: str = ... MIN_NUM_FORM_COUNT: str = ... MAX_NUM_FORM_COUNT: str = ... ORDERING_FIELD_NAME: str = ... DELETION_FIELD_NAME: str = ... DEFAULT_MIN_NUM: int = ... DEFAULT_MAX_NUM: int = ... class ManagementForm(Form): cleaned_data: Dict[str, Optional[int]] class BaseFormSet(Sized, Mapping[str, Any]): is_bound: Any = ... prefix: Any = ... auto_id: Any = ... data: Any = ... files: Any = ... initial: Any = ... form_kwargs: Any = ... error_class: Any = ... def __init__( self, data: Optional[Any] = ..., files: Optional[Any] = ..., auto_id: str = ..., prefix: Optional[Any] = ..., initial: Optional[Any] = ..., error_class: Any = ..., form_kwargs: Optional[Any] = ..., ) -> None: ... def __iter__(self): ... def __getitem__(self, index: Any): ... def __len__(self): ... def __bool__(self): ... def management_form(self): ... def total_form_count(self): ... def initial_form_count(self): ... @property def forms(self): ... def get_form_kwargs(self, index: Any): ... @property def initial_forms(self): ... @property def extra_forms(self): ... @property def empty_form(self): ... @property def cleaned_data(self): ... @property def deleted_forms(self): ... @property def ordered_forms(self): ... @classmethod def get_default_prefix(cls): ... def non_form_errors(self): ... @property def errors(self): ... def total_error_count(self): ... def is_valid(self): ... def full_clean(self): ... def clean(self) -> None: ... def has_changed(self): ... def add_fields(self, form: Any, index: Any) -> None: ... def add_prefix(self, index: Any): ... def is_multipart(self): ... @property def media(self): ... def as_table(self): ... def as_p(self): ... def as_ul(self): ... def formset_factory( form: Any, formset: Any = ..., extra: int = ..., can_order: bool = ..., can_delete: bool = ..., max_num: Optional[Any] = ..., validate_max: bool = ..., min_num: Optional[Any] = ..., validate_min: bool = ..., ): ... def all_valid(formsets: Sequence[Any]) -> bool: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/forms/models.pyi0000664000175000017500000002367500000000000026015 0ustar00davedave00000000000000from datetime import datetime from typing import ( Any, Callable, Dict, Iterator, List, Mapping, MutableMapping, Optional, Sequence, Tuple, Type, Union, ClassVar, Container, TypeVar, ) from unittest.mock import MagicMock from uuid import UUID from django.core.files.base import File from django.db.models.base import Model from django.db.models.manager import Manager from django.db.models.query import QuerySet, _BaseQuerySet from django.db.models.query_utils import Q from django.forms.fields import CharField, ChoiceField, Field from django.forms.forms import BaseForm, DeclarativeFieldsMetaclass from django.forms.formsets import BaseFormSet from django.forms.utils import ErrorList from django.forms.widgets import Input, Widget from typing_extensions import Literal from django.db import models from django.db.models import ForeignKey ALL_FIELDS: str _Fields = Union[List[Union[Callable, str]], Sequence[str], Literal["__all__"]] _Labels = Dict[str, str] _ErrorMessages = Dict[str, Dict[str, str]] _M = TypeVar("_M", bound=Model) def construct_instance( form: BaseForm, instance: _M, fields: Optional[Container[str]] = ..., exclude: Optional[Container[str]] = ... ) -> _M: ... def model_to_dict( instance: Model, fields: Optional[_Fields] = ..., exclude: Optional[_Fields] = ... ) -> Dict[str, Any]: ... def fields_for_model( model: Type[Model], fields: Optional[_Fields] = ..., exclude: Optional[_Fields] = ..., widgets: Optional[Union[Dict[str, Type[Input]], Dict[str, Widget]]] = ..., formfield_callback: Optional[Union[Callable, str]] = ..., localized_fields: Optional[Union[Tuple[str], str]] = ..., labels: Optional[_Labels] = ..., help_texts: Optional[Dict[str, str]] = ..., error_messages: Optional[_ErrorMessages] = ..., field_classes: Optional[Dict[str, Type[CharField]]] = ..., *, apply_limit_choices_to: bool = ... ) -> Dict[str, Any]: ... class ModelFormOptions: model: Optional[Type[Model]] = ... fields: Optional[_Fields] = ... exclude: Optional[_Fields] = ... widgets: Optional[Dict[str, Union[Widget, Input]]] = ... localized_fields: Optional[Union[Tuple[str], str]] = ... labels: Optional[_Labels] = ... help_texts: Optional[Dict[str, str]] = ... error_messages: Optional[_ErrorMessages] = ... field_classes: Optional[Dict[str, Type[Field]]] = ... def __init__(self, options: Optional[type] = ...) -> None: ... class ModelFormMetaclass(DeclarativeFieldsMetaclass): ... class BaseModelForm(BaseForm): instance: Any = ... def __init__( self, data: Optional[Mapping[str, Any]] = ..., files: Optional[Mapping[str, File]] = ..., auto_id: Union[bool, str] = ..., prefix: Optional[str] = ..., initial: Optional[Dict[str, Any]] = ..., error_class: Type[ErrorList] = ..., label_suffix: Optional[str] = ..., empty_permitted: bool = ..., instance: Optional[Model] = ..., use_required_attribute: Optional[bool] = ..., renderer: Any = ..., ) -> None: ... def validate_unique(self) -> None: ... save_m2m: Any = ... def save(self, commit: bool = ...) -> Any: ... class ModelForm(BaseModelForm, metaclass=ModelFormMetaclass): base_fields: ClassVar[Dict[str, Field]] = ... def modelform_factory( model: Type[Model], form: Type[ModelForm] = ..., fields: Optional[_Fields] = ..., exclude: Optional[_Fields] = ..., formfield_callback: Optional[Union[str, Callable[[models.Field], Field]]] = ..., widgets: Optional[MutableMapping[str, Widget]] = ..., localized_fields: Optional[Sequence[str]] = ..., labels: Optional[MutableMapping[str, str]] = ..., help_texts: Optional[MutableMapping[str, str]] = ..., error_messages: Optional[MutableMapping[str, Dict[str, Any]]] = ..., field_classes: Optional[MutableMapping[str, Type[Field]]] = ..., ) -> Type[ModelForm]: ... class BaseModelFormSet(BaseFormSet): model: Any = ... unique_fields: Any = ... queryset: Any = ... initial_extra: Any = ... def __init__( self, data: Optional[Any] = ..., files: Optional[Any] = ..., auto_id: str = ..., prefix: Optional[Any] = ..., queryset: Optional[Any] = ..., *, initial: Optional[Any] = ..., **kwargs: Any ) -> None: ... def initial_form_count(self): ... def get_queryset(self): ... def save_new(self, form: Any, commit: bool = ...): ... def save_existing(self, form: Any, instance: Any, commit: bool = ...): ... def delete_existing(self, obj: Any, commit: bool = ...) -> None: ... saved_forms: Any = ... save_m2m: Any = ... def save(self, commit: bool = ...): ... def clean(self) -> None: ... def validate_unique(self) -> None: ... def get_unique_error_message(self, unique_check: Any): ... def get_date_error_message(self, date_check: Any): ... def get_form_error(self): ... changed_objects: Any = ... deleted_objects: Any = ... def save_existing_objects(self, commit: bool = ...): ... new_objects: Any = ... def save_new_objects(self, commit: bool = ...): ... def add_fields(self, form: Any, index: Any): ... def modelformset_factory( model: Type[Model], form: Type[ModelForm] = ..., formfield_callback: Optional[Callable] = ..., formset: Type[BaseModelFormSet] = ..., extra: int = ..., can_delete: bool = ..., can_order: bool = ..., min_num: Optional[int] = ..., max_num: Optional[int] = ..., fields: Optional[_Fields] = ..., exclude: Optional[_Fields] = ..., widgets: Optional[Dict[str, Any]] = ..., validate_max: bool = ..., localized_fields: Optional[Sequence[str]] = ..., labels: Optional[Dict[str, str]] = ..., help_texts: Optional[Dict[str, str]] = ..., error_messages: Optional[Dict[str, Dict[str, str]]] = ..., validate_min: bool = ..., field_classes: Optional[Dict[str, Type[Field]]] = ..., ) -> Type[BaseModelFormSet]: ... class BaseInlineFormSet(BaseModelFormSet): instance: Any = ... save_as_new: Any = ... unique_fields: Any = ... def __init__( self, data: Optional[Any] = ..., files: Optional[Any] = ..., instance: Optional[Any] = ..., save_as_new: bool = ..., prefix: Optional[Any] = ..., queryset: Optional[Any] = ..., **kwargs: Any ) -> None: ... def initial_form_count(self): ... @classmethod def get_default_prefix(cls): ... def save_new(self, form: Any, commit: bool = ...): ... def add_fields(self, form: Any, index: Any) -> None: ... def get_unique_error_message(self, unique_check: Any): ... def inlineformset_factory( parent_model: Type[Model], model: Type[Model], form: Type[ModelForm] = ..., formset: Type[BaseInlineFormSet] = ..., fk_name: Optional[str] = ..., fields: Optional[_Fields] = ..., exclude: Optional[_Fields] = ..., extra: int = ..., can_order: bool = ..., can_delete: bool = ..., max_num: Optional[int] = ..., formfield_callback: Optional[Callable] = ..., widgets: Optional[Dict[str, Any]] = ..., validate_max: bool = ..., localized_fields: Optional[Sequence[str]] = ..., labels: Optional[Dict[str, str]] = ..., help_texts: Optional[Dict[str, str]] = ..., error_messages: Optional[Dict[str, Dict[str, str]]] = ..., min_num: Optional[int] = ..., validate_min: bool = ..., field_classes: Optional[Dict[str, Any]] = ..., ) -> Type[BaseInlineFormSet]: ... class InlineForeignKeyField(Field): disabled: bool help_text: str required: bool show_hidden_initial: bool widget: Any = ... default_error_messages: Any = ... parent_instance: Model = ... pk_field: bool = ... to_field: Optional[str] = ... def __init__( self, parent_instance: Model, *args: Any, pk_field: bool = ..., to_field: Optional[Any] = ..., **kwargs: Any ) -> None: ... class ModelChoiceIterator: field: ModelChoiceField = ... queryset: Optional[QuerySet] = ... def __init__(self, field: ModelChoiceField) -> None: ... def __iter__(self) -> Iterator[Tuple[Union[int, str], str]]: ... def __len__(self) -> int: ... def __bool__(self) -> bool: ... def choice(self, obj: Model) -> Tuple[int, str]: ... class ModelChoiceField(ChoiceField): disabled: bool error_messages: Dict[str, str] help_text: str required: bool show_hidden_initial: bool validators: List[Any] default_error_messages: Any = ... iterator: Any = ... empty_label: Optional[str] = ... queryset: Any = ... limit_choices_to: Optional[Union[Dict[str, Any], Callable[[], Any]]] = ... to_field_name: None = ... def __init__( self, queryset: Optional[Union[Manager, QuerySet]], *, empty_label: Optional[str] = ..., required: bool = ..., widget: Optional[Any] = ..., label: Optional[Any] = ..., initial: Optional[Any] = ..., help_text: str = ..., to_field_name: Optional[Any] = ..., limit_choices_to: Optional[Union[Dict[str, Any], Callable[[], Any]]] = ..., **kwargs: Any ) -> None: ... def get_limit_choices_to(self) -> Optional[Union[Dict[str, datetime], Q, MagicMock]]: ... def label_from_instance(self, obj: Model) -> str: ... choices: Any = ... def validate(self, value: Optional[Model]) -> None: ... def has_changed(self, initial: Optional[Union[Model, int, str, UUID]], data: Optional[Union[int, str]]) -> bool: ... class ModelMultipleChoiceField(ModelChoiceField): disabled: bool empty_label: None help_text: str required: bool show_hidden_initial: bool widget: Any = ... hidden_widget: Any = ... default_error_messages: Any = ... def __init__(self, queryset: _BaseQuerySet, **kwargs: Any) -> None: ... def _get_foreign_key( parent_model: Type[Model], model: Type[Model], fk_name: Optional[str] = ..., can_fail: bool = ... ) -> ForeignKey: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/forms/renderers.pyi0000664000175000017500000000132400000000000026506 0ustar00davedave00000000000000from typing import Any, Dict from django.template.backends.base import BaseEngine from django.template import Template ROOT: Any def get_default_renderer() -> DjangoTemplates: ... class BaseRenderer: def get_template(self, template_name: str) -> Any: ... def render(self, template_name: str, context: Dict[str, Any], request: None = ...) -> str: ... class EngineMixin: def get_template(self, template_name: str) -> Any: ... def engine(self) -> BaseEngine: ... class DjangoTemplates(EngineMixin, BaseRenderer): backend: Any = ... class Jinja2(EngineMixin, BaseRenderer): backend: Any = ... class TemplatesSetting(BaseRenderer): def get_template(self, template_name: str) -> Template: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/forms/utils.pyi0000664000175000017500000000235100000000000025656 0ustar00davedave00000000000000from collections import UserList from datetime import datetime from typing import Any, Dict, List, Optional, Sequence, Union from django.core.exceptions import ValidationError from django.utils.safestring import SafeText def pretty_name(name: str) -> str: ... def flatatt(attrs: Dict[str, Any]) -> SafeText: ... class ErrorDict(dict): def as_data(self) -> Dict[str, List[ValidationError]]: ... def get_json_data(self, escape_html: bool = ...) -> Dict[str, Any]: ... def as_json(self, escape_html: bool = ...) -> str: ... def as_ul(self) -> str: ... def as_text(self) -> str: ... class ErrorList(UserList): data: List[Union[ValidationError, str]] error_class: str = ... def __init__( self, initlist: Optional[Union[ErrorList, Sequence[Union[str, Exception]]]] = ..., error_class: Optional[str] = ..., ) -> None: ... def as_data(self) -> List[ValidationError]: ... def get_json_data(self, escape_html: bool = ...) -> List[Dict[str, str]]: ... def as_json(self, escape_html: bool = ...) -> str: ... def as_ul(self) -> str: ... def as_text(self) -> str: ... def from_current_timezone(value: datetime) -> datetime: ... def to_current_timezone(value: datetime) -> datetime: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/forms/widgets.pyi0000664000175000017500000001371600000000000026173 0ustar00davedave00000000000000from decimal import Decimal from itertools import chain from typing import Any, Callable, Dict, Iterable, Iterator, List, Mapping, Optional, Sequence, Set, Tuple, Type, Union from django.core.files.base import File from django.forms.renderers import EngineMixin from django.utils.safestring import SafeText _OptAttrs = Dict[str, Any] class MediaOrderConflictWarning(RuntimeWarning): ... class Media: _js: str def __init__( self, media: Optional[type] = ..., css: Optional[Dict[str, Iterable[str]]] = ..., js: Optional[Iterable[str]] = ..., ) -> None: ... def render(self) -> str: ... def render_js(self) -> List[str]: ... def render_css(self) -> chain: ... def absolute_path(self, path: str) -> str: ... def __getitem__(self, name: str) -> Media: ... @staticmethod def merge(list_1: Iterable[Any], list_2: Iterable[Any]) -> Iterable[Any]: ... def __add__(self, other: Media) -> Media: ... class MediaDefiningClass(type): ... class Widget: needs_multipart_form: bool = ... is_localized: bool = ... is_required: bool = ... supports_microseconds: bool = ... attrs: _OptAttrs = ... def __init__(self, attrs: Optional[_OptAttrs] = ...) -> None: ... @property def is_hidden(self) -> bool: ... def subwidgets(self, name: str, value: Optional[List[str]], attrs: _OptAttrs = ...) -> Iterator[Dict[str, Any]]: ... def format_value(self, value: Any) -> Optional[str]: ... def get_context(self, name: str, value: Any, attrs: Optional[_OptAttrs]) -> Dict[str, Any]: ... def render( self, name: str, value: Any, attrs: Optional[_OptAttrs] = ..., renderer: Optional[EngineMixin] = ... ) -> SafeText: ... def build_attrs( self, base_attrs: _OptAttrs, extra_attrs: Optional[_OptAttrs] = ... ) -> Dict[str, Union[Decimal, float, str]]: ... def value_from_datadict(self, data: Dict[str, Any], files: Mapping[str, Iterable[Any]], name: str) -> Any: ... def value_omitted_from_data(self, data: Dict[str, Any], files: Mapping[str, Iterable[Any]], name: str) -> bool: ... def id_for_label(self, id_: str) -> str: ... def use_required_attribute(self, initial: Any) -> bool: ... class Input(Widget): input_type: str = ... template_name: str = ... class TextInput(Input): ... class NumberInput(Input): ... class EmailInput(Input): ... class URLInput(Input): ... class PasswordInput(Input): render_value: bool = ... def __init__(self, attrs: Optional[_OptAttrs] = ..., render_value: bool = ...): ... class HiddenInput(Input): choices: Iterable[Tuple[str, str]] class MultipleHiddenInput(HiddenInput): ... class FileInput(Input): ... class ClearableFileInput(FileInput): clear_checkbox_label: Any = ... initial_text: Any = ... input_text: Any = ... def clear_checkbox_name(self, name: str) -> str: ... def clear_checkbox_id(self, name: str) -> str: ... def is_initial(self, value: Optional[Union[File, str]]) -> bool: ... class Textarea(Widget): template_name: str = ... class DateTimeBaseInput(TextInput): format_key: str = ... format: Optional[str] = ... def __init__(self, attrs: Optional[_OptAttrs] = ..., format: Optional[str] = ...): ... class DateInput(DateTimeBaseInput): ... class DateTimeInput(DateTimeBaseInput): ... class TimeInput(DateTimeBaseInput): ... class CheckboxInput(Input): check_test: Callable = ... def __init__(self, attrs: Optional[_OptAttrs] = ..., check_test: Optional[Callable] = ...) -> None: ... class ChoiceWidget(Widget): allow_multiple_selected: bool = ... input_type: Optional[str] = ... template_name: Optional[str] = ... option_template_name: str = ... add_id_index: bool = ... checked_attribute: Any = ... option_inherits_attrs: bool = ... choices: List[List[Union[int, str]]] = ... def __init__(self, attrs: Optional[_OptAttrs] = ..., choices: Sequence[Tuple[Any, Any]] = ...) -> None: ... def options(self, name: str, value: List[str], attrs: Optional[_OptAttrs] = ...) -> None: ... def optgroups(self, name: str, value: List[str], attrs: Optional[_OptAttrs] = ...) -> Any: ... def create_option( self, name: str, value: Any, label: Union[int, str], selected: Union[Set[str], bool], index: int, subindex: Optional[int] = ..., attrs: Optional[_OptAttrs] = ..., ) -> Dict[str, Any]: ... def id_for_label(self, id_: str, index: str = ...) -> str: ... class Select(ChoiceWidget): ... class NullBooleanSelect(Select): ... class SelectMultiple(Select): allow_multiple_selected: bool = ... class RadioSelect(ChoiceWidget): can_add_related: bool class CheckboxSelectMultiple(ChoiceWidget): ... class MultiWidget(Widget): template_name: str = ... widgets: List[Widget] = ... def __init__(self, widgets: Sequence[Union[Widget, Type[Widget]]], attrs: Optional[_OptAttrs] = ...) -> None: ... def decompress(self, value: Any) -> Optional[Any]: ... media: Any = ... class SplitDateTimeWidget(MultiWidget): def __init__( self, attrs: Optional[_OptAttrs] = ..., date_format: Optional[str] = ..., time_format: Optional[str] = ..., date_attrs: Optional[Dict[str, str]] = ..., time_attrs: Optional[Dict[str, str]] = ..., ) -> None: ... class SplitHiddenDateTimeWidget(SplitDateTimeWidget): ... class SelectDateWidget(Widget): none_value: Any = ... month_field: str = ... day_field: str = ... year_field: str = ... template_name: str = ... input_type: str = ... select_widget: Any = ... date_re: Any = ... years: Any = ... months: Any = ... year_none_value: Any = ... month_none_value: Any = ... day_none_value: Any = ... def __init__( self, attrs: Optional[_OptAttrs] = ..., years: Optional[Iterable[Union[int, str]]] = ..., months: Optional[Dict[int, str]] = ..., empty_label: Optional[Union[str, Sequence[str]]] = ..., ) -> None: ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4063792 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/http/0000775000175000017500000000000000000000000023623 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/http/__init__.pyi0000664000175000017500000000173400000000000026112 0ustar00davedave00000000000000from .request import ( HttpRequest as HttpRequest, QueryDict as QueryDict, RawPostDataException as RawPostDataException, UnreadablePostError as UnreadablePostError, ) from .response import ( BadHeaderError as BadHeaderError, FileResponse as FileResponse, Http404 as Http404, HttpResponse as HttpResponse, HttpResponseBadRequest as HttpResponseBadRequest, HttpResponseForbidden as HttpResponseForbidden, HttpResponseGone as HttpResponseGone, HttpResponseNotAllowed as HttpResponseNotAllowed, HttpResponseNotFound as HttpResponseNotFound, HttpResponseNotModified as HttpResponseNotModified, HttpResponsePermanentRedirect as HttpResponsePermanentRedirect, HttpResponseRedirect as HttpResponseRedirect, HttpResponseServerError as HttpResponseServerError, JsonResponse as JsonResponse, StreamingHttpResponse as StreamingHttpResponse, ) from .cookie import SimpleCookie as SimpleCookie, parse_cookie as parse_cookie ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/http/cookie.pyi0000664000175000017500000000014600000000000025620 0ustar00davedave00000000000000from typing import Any, Dict SimpleCookie: Any def parse_cookie(cookie: str) -> Dict[str, str]: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/http/multipartparser.pyi0000664000175000017500000000370200000000000027606 0ustar00davedave00000000000000from io import BytesIO, StringIO from typing import Any, Dict, Iterator, List, Optional, Tuple, Union from django.http.request import QueryDict from django.utils.datastructures import ImmutableList, MultiValueDict class MultiPartParserError(Exception): ... class InputStreamExhausted(Exception): ... class MultiPartParser: def __init__( self, META: Dict[str, Any], input_data: Union[StringIO, BytesIO], upload_handlers: Union[List[Any], ImmutableList], encoding: Optional[str] = ..., ) -> None: ... def parse(self) -> Tuple[QueryDict, MultiValueDict]: ... def handle_file_complete(self, old_field_name: str, counters: List[int]) -> None: ... def IE_sanitize(self, filename: str) -> str: ... class LazyStream: length: None = ... position: int = ... def __init__(self, producer: Union[BoundaryIter, ChunkIter], length: None = ...) -> None: ... def tell(self): ... def read(self, size: Optional[int] = ...) -> bytes: ... def __next__(self) -> bytes: ... def close(self) -> None: ... def __iter__(self) -> LazyStream: ... def unget(self, bytes: bytes) -> None: ... class ChunkIter: flo: BytesIO = ... chunk_size: int = ... def __init__(self, flo: BytesIO, chunk_size: int = ...) -> None: ... def __next__(self) -> bytes: ... def __iter__(self): ... class InterBoundaryIter: def __init__(self, stream: LazyStream, boundary: bytes) -> None: ... def __iter__(self) -> InterBoundaryIter: ... def __next__(self) -> LazyStream: ... class BoundaryIter: def __init__(self, stream: LazyStream, boundary: bytes) -> None: ... def __iter__(self): ... def __next__(self) -> bytes: ... class Parser: def __init__(self, stream: LazyStream, boundary: bytes) -> None: ... def __iter__(self) -> Iterator[Tuple[str, Dict[str, Tuple[str, Dict[str, Union[bytes, str]]]], LazyStream]]: ... def parse_header(line: bytes) -> Tuple[str, Dict[str, Any]]: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/http/request.pyi0000664000175000017500000000731200000000000026041 0ustar00davedave00000000000000from io import BytesIO from typing import ( Any, BinaryIO, Dict, Iterable, List, Mapping, Optional, Pattern, Set, Tuple, Type, TypeVar, Union, overload, ) from django.contrib.auth.base_user import AbstractBaseUser from django.contrib.auth.models import AnonymousUser from django.contrib.sessions.backends.base import SessionBase from django.contrib.sites.models import Site from django.utils.datastructures import CaseInsensitiveMapping, ImmutableList, MultiValueDict from django.core.files import uploadedfile, uploadhandler from django.urls import ResolverMatch RAISE_ERROR: object = ... host_validation_re: Pattern = ... class UnreadablePostError(IOError): ... class RawPostDataException(Exception): ... UploadHandlerList = Union[List[uploadhandler.FileUploadHandler], ImmutableList[uploadhandler.FileUploadHandler]] class HttpHeaders(CaseInsensitiveMapping): HTTP_PREFIX: str = ... UNPREFIXED_HEADERS: Set[str] = ... def __init__(self, environ: Mapping[str, Any]) -> None: ... @classmethod def parse_header_name(cls, header: str) -> Optional[str]: ... class HttpRequest(BytesIO): GET: QueryDict = ... POST: QueryDict = ... COOKIES: Dict[str, str] = ... META: Dict[str, Any] = ... FILES: MultiValueDict[str, uploadedfile.UploadedFile] = ... path: str = ... path_info: str = ... method: Optional[str] = ... resolver_match: ResolverMatch = ... content_type: Optional[str] = ... content_params: Optional[Dict[str, str]] = ... user: Union[AbstractBaseUser, AnonymousUser] site: Site session: SessionBase encoding: Optional[str] = ... upload_handlers: UploadHandlerList = ... def __init__(self) -> None: ... def get_host(self) -> str: ... def get_port(self) -> str: ... def get_full_path(self, force_append_slash: bool = ...) -> str: ... def get_full_path_info(self, force_append_slash: bool = ...) -> str: ... def get_signed_cookie( self, key: str, default: Any = ..., salt: str = ..., max_age: Optional[int] = ... ) -> Optional[str]: ... def get_raw_uri(self) -> str: ... def build_absolute_uri(self, location: Optional[str] = ...) -> str: ... @property def scheme(self) -> Optional[str]: ... def is_secure(self) -> bool: ... def is_ajax(self) -> bool: ... def parse_file_upload( self, META: Mapping[str, Any], post_data: BinaryIO ) -> Tuple[QueryDict, MultiValueDict[str, uploadedfile.UploadedFile]]: ... @property def headers(self) -> HttpHeaders: ... @property def body(self) -> bytes: ... def _load_post_and_files(self) -> None: ... _Q = TypeVar("_Q", bound="QueryDict") class QueryDict(MultiValueDict[str, str]): encoding: str = ... _mutable: bool = ... def __init__( self, query_string: Optional[Union[str, bytes]] = ..., mutable: bool = ..., encoding: Optional[str] = ... ) -> None: ... def setlist(self, key: str, list_: List[str]) -> None: ... def setlistdefault(self, key: str, default_list: Optional[List[str]] = ...) -> List[str]: ... def appendlist(self, key: str, value: str) -> None: ... def urlencode(self, safe: Optional[str] = ...) -> str: ... @classmethod def fromkeys( cls: Type[_Q], iterable: Iterable[Union[bytes, str]], value: Any = ..., mutable: bool = ..., encoding: Optional[str] = ..., ) -> _Q: ... @overload def bytes_to_text(s: bytes, encoding: str) -> str: ... @overload def bytes_to_text(s: str, encoding: str) -> str: ... @overload def bytes_to_text(s: None, encoding: str) -> None: ... def split_domain_port(host: str) -> Tuple[str, str]: ... def validate_host(host: str, allowed_hosts: Iterable[str]) -> bool: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/http/response.pyi0000664000175000017500000001160200000000000026204 0ustar00davedave00000000000000import datetime from io import BytesIO from json import JSONEncoder from typing import Any, Dict, Iterable, Iterator, List, Optional, Tuple, Type, Union, overload from django.core.handlers.wsgi import WSGIRequest from django.http.cookie import SimpleCookie from django.test.client import Client from django.template import Context, Template from django.urls import ResolverMatch class BadHeaderError(ValueError): ... class HttpResponseBase(Iterable[Any]): status_code: int = ... cookies: SimpleCookie = ... reason_phrase: str = ... charset: str = ... closed: bool = ... def __init__( self, content_type: Optional[str] = ..., status: Optional[int] = ..., reason: Optional[str] = ..., charset: Optional[str] = ..., ) -> None: ... def serialize_headers(self) -> bytes: ... def __setitem__(self, header: Union[str, bytes], value: Union[str, bytes, int]) -> None: ... def __delitem__(self, header: Union[str, bytes]) -> None: ... def __getitem__(self, header: Union[str, bytes]) -> str: ... def has_header(self, header: str) -> bool: ... def items(self) -> Iterable[Tuple[str, str]]: ... @overload def get(self, header: Union[str, bytes], alternate: Optional[str]) -> str: ... @overload def get(self, header: Union[str, bytes]) -> Optional[str]: ... def set_cookie( self, key: str, value: str = ..., max_age: Optional[int] = ..., expires: Optional[Union[str, datetime.datetime]] = ..., path: str = ..., domain: Optional[str] = ..., secure: bool = ..., httponly: bool = ..., samesite: str = ..., ) -> None: ... def setdefault(self, key: str, value: str) -> None: ... def set_signed_cookie(self, key: str, value: str, salt: str = ..., **kwargs: Any) -> None: ... def delete_cookie(self, key: str, path: str = ..., domain: Optional[str] = ...) -> None: ... def make_bytes(self, value: object) -> bytes: ... def close(self) -> None: ... def write(self, content: Union[str, bytes]) -> None: ... def flush(self) -> None: ... def tell(self) -> int: ... def readable(self) -> bool: ... def seekable(self) -> bool: ... def writable(self) -> bool: ... def writelines(self, lines: Iterable[object]): ... def __iter__(self) -> Iterator[Any]: ... class HttpResponse(HttpResponseBase): content: Any csrf_cookie_set: bool redirect_chain: List[Tuple[str, int]] sameorigin: bool test_server_port: str test_was_secure_request: bool xframe_options_exempt: bool streaming: bool = ... def __init__(self, content: object = ..., *args: Any, **kwargs: Any) -> None: ... def serialize(self) -> bytes: ... @property def url(self) -> str: ... # Attributes assigned by monkey-patching in test client ClientHandler.__call__() wsgi_request: WSGIRequest # Attributes assigned by monkey-patching in test client Client.request() client: Client request: Dict[str, Any] templates: List[Template] context: Context resolver_match: ResolverMatch def json(self) -> Any: ... class StreamingHttpResponse(HttpResponseBase): content: Any streaming_content: Iterator[Any] def __init__(self, streaming_content: Iterable[Any] = ..., *args: Any, **kwargs: Any) -> None: ... def getvalue(self) -> Any: ... class FileResponse(StreamingHttpResponse): client: Client context: None file_to_stream: Optional[BytesIO] request: Dict[str, str] resolver_match: ResolverMatch templates: List[Any] wsgi_request: WSGIRequest block_size: int = ... as_attachment: bool = ... filename: str = ... def __init__(self, *args: Any, as_attachment: bool = ..., filename: str = ..., **kwargs: Any) -> None: ... def set_headers(self, filelike: BytesIO) -> None: ... def json(self) -> Dict[str, Any]: ... class HttpResponseRedirectBase(HttpResponse): allowed_schemes: List[str] = ... def __init__(self, redirect_to: str, *args: Any, **kwargs: Any) -> None: ... class HttpResponseRedirect(HttpResponseRedirectBase): ... class HttpResponsePermanentRedirect(HttpResponseRedirectBase): ... class HttpResponseNotModified(HttpResponse): def __init__(self, *args: Any, **kwargs: Any) -> None: ... class HttpResponseBadRequest(HttpResponse): ... class HttpResponseNotFound(HttpResponse): ... class HttpResponseForbidden(HttpResponse): ... class HttpResponseNotAllowed(HttpResponse): def __init__(self, permitted_methods: Iterable[str], *args: Any, **kwargs: Any) -> None: ... class HttpResponseGone(HttpResponse): ... class HttpResponseServerError(HttpResponse): ... class Http404(Exception): ... class JsonResponse(HttpResponse): def __init__( self, data: Any, encoder: Type[JSONEncoder] = ..., safe: bool = ..., json_dumps_params: Optional[Dict[str, Any]] = ..., **kwargs: Any ) -> None: ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4063792 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/middleware/0000775000175000017500000000000000000000000024761 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/middleware/__init__.pyi0000664000175000017500000000000000000000000027231 0ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/middleware/cache.pyi0000664000175000017500000000210700000000000026547 0ustar00davedave00000000000000from typing import Any, Optional, Union, Callable from django.http.request import HttpRequest from django.http.response import HttpResponse, HttpResponseBase from django.utils.deprecation import MiddlewareMixin from django.core.cache import BaseCache class UpdateCacheMiddleware(MiddlewareMixin): cache_timeout: float = ... key_prefix: str = ... cache_alias: str = ... cache: BaseCache = ... def process_response( self, request: HttpRequest, response: Union[HttpResponseBase, str] ) -> Union[HttpResponseBase, str]: ... class FetchFromCacheMiddleware(MiddlewareMixin): key_prefix: str = ... cache_alias: str = ... cache: BaseCache = ... def process_request(self, request: HttpRequest) -> Optional[HttpResponse]: ... class CacheMiddleware(UpdateCacheMiddleware, FetchFromCacheMiddleware): key_prefix: str = ... cache_alias: str = ... cache_timeout: float = ... cache: BaseCache = ... def __init__( self, get_response: Optional[Callable] = ..., cache_timeout: Optional[float] = ..., **kwargs: Any ) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/middleware/clickjacking.pyi0000664000175000017500000000060300000000000030117 0ustar00davedave00000000000000from django.http.request import HttpRequest from django.http.response import HttpResponse from django.utils.deprecation import MiddlewareMixin class XFrameOptionsMiddleware(MiddlewareMixin): def process_response(self, request: HttpRequest, response: HttpResponse) -> HttpResponse: ... def get_xframe_options_value(self, request: HttpRequest, response: HttpResponse) -> str: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/middleware/common.pyi0000664000175000017500000000173300000000000027000 0ustar00davedave00000000000000from typing import Any, Optional from django.http.request import HttpRequest from django.http.response import HttpResponseBase, HttpResponsePermanentRedirect from django.utils.deprecation import MiddlewareMixin class CommonMiddleware(MiddlewareMixin): response_redirect_class: Any = ... def process_request(self, request: HttpRequest) -> Optional[HttpResponsePermanentRedirect]: ... def should_redirect_with_slash(self, request: HttpRequest) -> bool: ... def get_full_path_with_slash(self, request: HttpRequest) -> str: ... def process_response(self, request: HttpRequest, response: HttpResponseBase) -> HttpResponseBase: ... class BrokenLinkEmailsMiddleware(MiddlewareMixin): def process_response(self, request: HttpRequest, response: HttpResponseBase) -> HttpResponseBase: ... def is_internal_request(self, domain: str, referer: str) -> bool: ... def is_ignorable_request(self, request: HttpRequest, uri: str, domain: str, referer: str) -> bool: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/middleware/csrf.pyi0000664000175000017500000000234200000000000026442 0ustar00davedave00000000000000from typing import Any, Callable, Dict, Optional, Tuple from django.http.request import HttpRequest from django.http.response import HttpResponseBase, HttpResponseForbidden from django.utils.deprecation import MiddlewareMixin logger: Any REASON_NO_REFERER: str REASON_BAD_REFERER: str REASON_NO_CSRF_COOKIE: str REASON_BAD_TOKEN: str REASON_MALFORMED_REFERER: str REASON_INSECURE_REFERER: str CSRF_SECRET_LENGTH: int CSRF_TOKEN_LENGTH: Any CSRF_ALLOWED_CHARS: Any CSRF_SESSION_KEY: str def get_token(request: HttpRequest) -> str: ... def rotate_token(request: HttpRequest) -> None: ... class CsrfViewMiddleware(MiddlewareMixin): def process_request(self, request: HttpRequest) -> None: ... def process_view( self, request: HttpRequest, callback: Optional[Callable], callback_args: Tuple, callback_kwargs: Dict[str, Any] ) -> Optional[HttpResponseForbidden]: ... def process_response(self, request: HttpRequest, response: HttpResponseBase) -> HttpResponseBase: ... def _compare_salted_tokens(request_csrf_token: str, csrf_token: str) -> bool: ... def _get_new_csrf_string() -> str: ... def _salt_cipher_secret(secret: str) -> str: ... def _unsalt_cipher_token(token: str) -> str: ... def _get_new_csrf_token() -> str: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/middleware/gzip.pyi0000664000175000017500000000052300000000000026455 0ustar00davedave00000000000000from typing import Any from django.http.request import HttpRequest from django.http.response import HttpResponseBase from django.utils.deprecation import MiddlewareMixin re_accepts_gzip: Any class GZipMiddleware(MiddlewareMixin): def process_response(self, request: HttpRequest, response: HttpResponseBase) -> HttpResponseBase: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/middleware/http.pyi0000664000175000017500000000056100000000000026465 0ustar00davedave00000000000000from django.http.request import HttpRequest from django.http.response import HttpResponseBase from django.utils.deprecation import MiddlewareMixin class ConditionalGetMiddleware(MiddlewareMixin): def process_response(self, request: HttpRequest, response: HttpResponseBase) -> HttpResponseBase: ... def needs_etag(self, response: HttpResponseBase) -> bool: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/middleware/locale.pyi0000664000175000017500000000064700000000000026752 0ustar00davedave00000000000000from typing import Any from django.http.request import HttpRequest from django.http.response import HttpResponseBase from django.utils.deprecation import MiddlewareMixin class LocaleMiddleware(MiddlewareMixin): response_redirect_class: Any = ... def process_request(self, request: HttpRequest) -> None: ... def process_response(self, request: HttpRequest, response: HttpResponseBase) -> HttpResponseBase: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/middleware/security.pyi0000664000175000017500000000131300000000000027351 0ustar00davedave00000000000000from typing import Any, List, Optional from django.http.request import HttpRequest from django.http.response import HttpResponse, HttpResponsePermanentRedirect from django.utils.deprecation import MiddlewareMixin class SecurityMiddleware(MiddlewareMixin): sts_seconds: int = ... sts_include_subdomains: bool = ... sts_preload: bool = ... content_type_nosniff: bool = ... xss_filter: bool = ... redirect: bool = ... redirect_host: Optional[str] = ... redirect_exempt: List[Any] = ... def process_request(self, request: HttpRequest) -> Optional[HttpResponsePermanentRedirect]: ... def process_response(self, request: HttpRequest, response: HttpResponse) -> HttpResponse: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/shortcuts.pyi0000664000175000017500000000366400000000000025436 0ustar00davedave00000000000000import sys from typing import Any, Callable, List, Mapping, Optional, overload, Protocol, Sequence, Type, TypeVar, Union from django.db.models.base import Model from django.http.response import ( HttpResponse as HttpResponse, HttpResponseRedirect as HttpResponseRedirect, HttpResponsePermanentRedirect as HttpResponsePermanentRedirect, ) from django.db.models import Manager, QuerySet from django.http import HttpRequest if sys.version_info < (3, 8): from typing_extensions import Literal else: from typing import Literal def render_to_response( template_name: Union[str, Sequence[str]], context: Optional[Mapping[str, Any]] = ..., content_type: Optional[str] = ..., status: Optional[int] = ..., using: Optional[str] = ..., ) -> HttpResponse: ... def render( request: HttpRequest, template_name: Union[str, Sequence[str]], context: Optional[Mapping[str, Any]] = ..., content_type: Optional[str] = ..., status: Optional[int] = ..., using: Optional[str] = ..., ) -> HttpResponse: ... class SupportsGetAbsoluteUrl(Protocol): ... @overload def redirect( to: Union[Callable, str, SupportsGetAbsoluteUrl], *args: Any, permanent: Literal[True], **kwargs: Any ) -> HttpResponsePermanentRedirect: ... @overload def redirect( to: Union[Callable, str, SupportsGetAbsoluteUrl], *args: Any, permanent: Literal[False], **kwargs: Any ) -> HttpResponseRedirect: ... @overload def redirect( to: Union[Callable, str, SupportsGetAbsoluteUrl], *args: Any, permanent: bool = ..., **kwargs: Any ) -> Union[HttpResponseRedirect, HttpResponsePermanentRedirect]: ... _T = TypeVar("_T", bound=Model) def get_object_or_404(klass: Union[Type[_T], Manager[_T], QuerySet[_T]], *args: Any, **kwargs: Any) -> _T: ... def get_list_or_404(klass: Union[Type[_T], Manager[_T], QuerySet[_T]], *args: Any, **kwargs: Any) -> List[_T]: ... def resolve_url(to: Union[Callable, Model, str], *args: Any, **kwargs: Any) -> str: ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4063792 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/template/0000775000175000017500000000000000000000000024457 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/template/__init__.pyi0000664000175000017500000000121000000000000026733 0ustar00davedave00000000000000from .engine import Engine as Engine from .utils import EngineHandler as EngineHandler engines: EngineHandler from .base import VariableDoesNotExist as VariableDoesNotExist from .context import ContextPopException as ContextPopException from .exceptions import TemplateDoesNotExist as TemplateDoesNotExist, TemplateSyntaxError as TemplateSyntaxError # Template parts from .base import Node as Node, NodeList as NodeList, Origin as Origin, Template as Template, Variable as Variable from .context import Context as Context, RequestContext as RequestContext from .library import Library as Library from . import defaultfilters as defaultfilters ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4063792 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/template/backends/0000775000175000017500000000000000000000000026231 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/template/backends/__init__.pyi0000664000175000017500000000000000000000000030501 0ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/template/backends/base.pyi0000664000175000017500000000113100000000000027662 0ustar00davedave00000000000000from typing import Any, Iterator, List, Mapping, Optional, Tuple from django.template.base import Template class BaseEngine: name: str = ... dirs: List[str] = ... app_dirs: bool = ... def __init__(self, params: Mapping[str, Any]) -> None: ... @property def app_dirname(self) -> Optional[str]: ... def from_string(self, template_code: str) -> Template: ... def get_template(self, template_name: str) -> Optional[Template]: ... @property def template_dirs(self) -> Tuple[str]: ... def iter_template_filenames(self, template_name: str) -> Iterator[str]: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/template/backends/django.pyi0000664000175000017500000000130200000000000030212 0ustar00davedave00000000000000from typing import Any, Dict, Iterator, Optional from django.template.engine import Engine from django.template.exceptions import TemplateDoesNotExist from .base import BaseEngine class DjangoTemplates(BaseEngine): engine: Engine = ... def __init__(self, params: Dict[str, Any]) -> None: ... def get_templatetag_libraries(self, custom_libraries: Dict[str, str]) -> Dict[str, str]: ... def copy_exception(exc: TemplateDoesNotExist, backend: Optional[DjangoTemplates] = ...) -> TemplateDoesNotExist: ... def reraise(exc: TemplateDoesNotExist, backend: DjangoTemplates) -> Any: ... def get_installed_libraries() -> Dict[str, str]: ... def get_package_libraries(pkg: Any) -> Iterator[str]: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/template/backends/dummy.pyi0000664000175000017500000000073600000000000030115 0ustar00davedave00000000000000import string from typing import Any, Dict, List, Optional, Tuple, Union from django.http.request import HttpRequest from .base import BaseEngine class TemplateStrings(BaseEngine): template_dirs: Tuple[str] def __init__(self, params: Dict[str, Union[Dict[Any, Any], List[Any], bool, str]]) -> None: ... class Template(string.Template): template: str def render(self, context: Optional[Dict[str, str]] = ..., request: Optional[HttpRequest] = ...) -> str: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/template/backends/jinja2.pyi0000664000175000017500000000110500000000000030126 0ustar00davedave00000000000000from typing import Any, Callable, Dict, List, Optional from django.template.exceptions import TemplateSyntaxError from .base import BaseEngine class Jinja2(BaseEngine): context_processors: List[str] = ... def __init__(self, params: Dict[str, Any]) -> None: ... @property def template_context_processors(self) -> List[Callable]: ... class Origin: name: str = ... template_name: Optional[str] = ... def __init__(self, name: str, template_name: Optional[str]) -> None: ... def get_exception_info(exception: TemplateSyntaxError) -> Dict[str, Any]: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/template/backends/utils.pyi0000664000175000017500000000032300000000000030112 0ustar00davedave00000000000000from typing import Any from django.http.request import HttpRequest from django.utils.safestring import SafeText def csrf_input(request: HttpRequest) -> SafeText: ... csrf_input_lazy: Any csrf_token_lazy: Any ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/template/base.pyi0000664000175000017500000001361600000000000026123 0ustar00davedave00000000000000from enum import Enum from typing import Any, Callable, Dict, Iterator, List, Mapping, Optional, Sequence, Tuple, Type, Union from django.http.request import HttpRequest from django.template.context import Context as Context from django.template.engine import Engine from django.template.library import Library from django.template.loaders.base import Loader from django.utils.safestring import SafeText FILTER_SEPARATOR: str FILTER_ARGUMENT_SEPARATOR: str VARIABLE_ATTRIBUTE_SEPARATOR: str BLOCK_TAG_START: str BLOCK_TAG_END: str VARIABLE_TAG_START: str VARIABLE_TAG_END: str COMMENT_TAG_START: str COMMENT_TAG_END: str TRANSLATOR_COMMENT_MARK: str SINGLE_BRACE_START: str SINGLE_BRACE_END: str UNKNOWN_SOURCE: str tag_re: Any logger: Any class TokenType(Enum): TEXT: int = ... VAR: int = ... BLOCK: int = ... COMMENT: int = ... class VariableDoesNotExist(Exception): msg: str = ... params: Tuple[Union[Dict[str, str], str]] = ... def __init__(self, msg: str, params: Tuple[Union[Dict[str, str], str]] = ...) -> None: ... class Origin: name: str = ... template_name: Optional[Union[bytes, str]] = ... loader: Optional[Loader] = ... def __init__( self, name: str, template_name: Optional[Union[bytes, str]] = ..., loader: Optional[Loader] = ... ) -> None: ... @property def loader_name(self) -> Optional[str]: ... class Template: name: Optional[str] = ... origin: Origin = ... engine: Engine = ... source: str = ... nodelist: NodeList = ... def __init__( self, template_string: Union[Template, str], origin: Optional[Origin] = ..., name: Optional[str] = ..., engine: Optional[Engine] = ..., ) -> None: ... def __iter__(self) -> None: ... def render( self, context: Optional[Union[Context, Dict[str, Any]]] = ..., request: Optional[HttpRequest] = ... ) -> Any: ... def compile_nodelist(self) -> NodeList: ... def get_exception_info(self, exception: Exception, token: Token) -> Dict[str, Any]: ... def linebreak_iter(template_source: str) -> Iterator[int]: ... class Token: contents: str token_type: TokenType lineno: Optional[int] = ... position: Optional[Tuple[int, int]] = ... def __init__( self, token_type: TokenType, contents: str, position: Optional[Tuple[int, int]] = ..., lineno: Optional[int] = ..., ) -> None: ... def split_contents(self) -> List[str]: ... class Lexer: template_string: str = ... verbatim: Union[bool, str] = ... def __init__(self, template_string: str) -> None: ... def tokenize(self) -> List[Token]: ... def create_token( self, token_string: str, position: Optional[Tuple[int, int]], lineno: int, in_tag: bool ) -> Token: ... class DebugLexer(Lexer): template_string: str verbatim: Union[bool, str] def tokenize(self) -> List[Token]: ... class Parser: tokens: Union[List[Token], str] = ... tags: Dict[str, Callable] = ... filters: Dict[str, Callable] = ... command_stack: List[Tuple[str, Token]] = ... libraries: Dict[str, Library] = ... origin: Optional[Origin] = ... def __init__( self, tokens: Union[List[Token], str], libraries: Optional[Dict[str, Library]] = ..., builtins: Optional[List[Library]] = ..., origin: Optional[Origin] = ..., ) -> None: ... def parse(self, parse_until: Optional[Tuple[str]] = ...) -> NodeList: ... def skip_past(self, endtag: str) -> None: ... def extend_nodelist(self, nodelist: NodeList, node: Node, token: Token) -> None: ... def error(self, token: Token, e: Union[Exception, str]) -> Exception: ... def invalid_block_tag(self, token: Token, command: str, parse_until: Union[List[Any], Tuple[str]] = ...) -> Any: ... def unclosed_block_tag(self, parse_until: Tuple[str]) -> Any: ... def next_token(self) -> Token: ... def prepend_token(self, token: Token) -> None: ... def delete_first_token(self) -> None: ... def add_library(self, lib: Library) -> None: ... def compile_filter(self, token: str) -> FilterExpression: ... def find_filter(self, filter_name: str) -> Callable: ... constant_string: Any filter_raw_string: Any filter_re: Any class FilterExpression: token: str = ... filters: List[Any] = ... var: Any = ... def __init__(self, token: str, parser: Parser) -> None: ... def resolve(self, context: Mapping[str, Any], ignore_failures: bool = ...) -> Any: ... @staticmethod def args_check(name: str, func: Callable, provided: List[Tuple[bool, Any]]) -> bool: ... class Variable: var: Union[Dict[Any, Any], str] = ... literal: Optional[Union[SafeText, float]] = ... lookups: Optional[Tuple[str]] = ... translate: bool = ... message_context: Optional[str] = ... def __init__(self, var: Union[Dict[Any, Any], str]) -> None: ... def resolve(self, context: Union[Mapping[str, Mapping[str, Any]], Context, int, str]) -> Any: ... class Node: must_be_first: bool = ... child_nodelists: Any = ... origin: Origin token: Token = ... def render(self, context: Context) -> str: ... def render_annotated(self, context: Context) -> Union[int, str]: ... def __iter__(self) -> None: ... def get_nodes_by_type(self, nodetype: Type[Node]) -> List[Node]: ... class NodeList(List[Node]): contains_nontext: bool = ... def render(self, context: Context) -> SafeText: ... def get_nodes_by_type(self, nodetype: Type[Node]) -> List[Node]: ... class TextNode(Node): s: str = ... def __init__(self, s: str) -> None: ... def render_value_in_context(value: Any, context: Context) -> str: ... class VariableNode(Node): filter_expression: FilterExpression = ... def __init__(self, filter_expression: FilterExpression) -> None: ... kwarg_re: Any def token_kwargs(bits: Sequence[str], parser: Parser, support_legacy: bool = ...) -> Dict[str, FilterExpression]: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/template/context.pyi0000664000175000017500000000621000000000000026665 0ustar00davedave00000000000000from typing import Any, Callable, Dict, Iterator, List, Optional, Type, Union, Iterable from django.http.request import HttpRequest from django.template.base import Node, Origin, Template from django.template.defaulttags import IfChangedNode from django.template.loader_tags import IncludeNode _ContextValues = Union[Dict[str, Any], "Context"] class ContextPopException(Exception): ... class ContextDict(dict): context: BaseContext = ... def __init__(self, context: BaseContext, *args: Any, **kwargs: Any) -> None: ... def __enter__(self) -> ContextDict: ... def __exit__(self, *args: Any, **kwargs: Any) -> None: ... class BaseContext(Iterable[Any]): def __init__(self, dict_: Any = ...) -> None: ... def __copy__(self) -> BaseContext: ... def __iter__(self) -> Iterator[Any]: ... def push(self, *args: Any, **kwargs: Any) -> ContextDict: ... def pop(self) -> ContextDict: ... def __setitem__(self, key: Union[Node, str], value: Any) -> None: ... def set_upward(self, key: str, value: Union[int, str]) -> None: ... def __getitem__(self, key: Union[int, str]) -> Any: ... def __delitem__(self, key: Any) -> None: ... def __contains__(self, key: str) -> bool: ... def get(self, key: str, otherwise: Optional[Any] = ...) -> Optional[Any]: ... def setdefault( self, key: Union[IfChangedNode, str], default: Optional[Union[List[Origin], int]] = ... ) -> Optional[Union[List[Origin], int]]: ... def new(self, values: Optional[_ContextValues] = ...) -> Context: ... def flatten(self) -> Dict[str, Optional[Union[Dict[str, Union[Type[Any], str]], int, str]]]: ... class Context(BaseContext): dicts: Any autoescape: bool = ... use_l10n: Optional[bool] = ... use_tz: Optional[bool] = ... template_name: Optional[str] = ... render_context: RenderContext = ... template: Optional[Template] = ... def __init__( self, dict_: Any = ..., autoescape: bool = ..., use_l10n: Optional[bool] = ..., use_tz: None = ... ) -> None: ... def bind_template(self, template: Template) -> Iterator[None]: ... def update(self, other_dict: Union[Dict[str, Any], Context]) -> ContextDict: ... class RenderContext(BaseContext): dicts: List[Dict[Union[IncludeNode, str], str]] template: Optional[Template] = ... def push_state(self, template: Template, isolated_context: bool = ...) -> Iterator[None]: ... class RequestContext(Context): autoescape: bool dicts: List[Dict[str, str]] render_context: RenderContext template_name: Optional[str] use_l10n: None use_tz: None request: HttpRequest = ... def __init__( self, request: HttpRequest, dict_: Optional[Dict[str, Any]] = ..., processors: Optional[List[Callable]] = ..., use_l10n: None = ..., use_tz: None = ..., autoescape: bool = ..., ) -> None: ... template: Optional[Template] = ... def bind_template(self, template: Template) -> Iterator[None]: ... def new(self, values: Optional[_ContextValues] = ...) -> RequestContext: ... def make_context(context: Any, request: Optional[HttpRequest] = ..., **kwargs: Any) -> Context: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/template/context_processors.pyi0000664000175000017500000000120000000000000031141 0ustar00davedave00000000000000from typing import Any, Callable, Dict, List, Tuple, Union from django.core.handlers.wsgi import WSGIRequest from django.http.request import HttpRequest from django.utils.functional import SimpleLazyObject def csrf(request: HttpRequest) -> Dict[str, SimpleLazyObject]: ... def debug(request: HttpRequest) -> Dict[str, Union[Callable, bool]]: ... def i18n(request: WSGIRequest) -> Dict[str, Union[List[Tuple[str, str]], bool, str]]: ... def tz(request: HttpRequest) -> Dict[str, str]: ... def static(request: HttpRequest) -> Dict[str, str]: ... def media(request: Any): ... def request(request: HttpRequest) -> Dict[str, HttpRequest]: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/template/defaultfilters.pyi0000664000175000017500000000710300000000000030220 0ustar00davedave00000000000000from datetime import date as _date, datetime, time as _time from typing import Any, Callable, Dict, List, Optional, Union from django.utils.safestring import SafeText from django.utils.html import escape as escape # noqa: F401 register: Any def stringfilter(func: Callable) -> Callable: ... def addslashes(value: str) -> str: ... def capfirst(value: str) -> str: ... def escapejs_filter(value: str) -> SafeText: ... def json_script(value: Dict[str, str], element_id: SafeText) -> SafeText: ... def floatformat(text: Optional[Any], arg: Union[int, str] = ...) -> str: ... def iriencode(value: str) -> str: ... def linenumbers(value: str, autoescape: bool = ...) -> SafeText: ... def lower(value: str) -> str: ... def make_list(value: str) -> List[str]: ... def slugify(value: str) -> SafeText: ... def stringformat(value: Any, arg: str) -> str: ... def title(value: str) -> str: ... def truncatechars(value: str, arg: Union[SafeText, int]) -> str: ... def truncatechars_html(value: str, arg: Union[int, str]) -> str: ... def truncatewords(value: str, arg: Union[int, str]) -> str: ... def truncatewords_html(value: str, arg: Union[int, str]) -> str: ... def upper(value: str) -> str: ... def urlencode(value: str, safe: Optional[SafeText] = ...) -> str: ... def urlize(value: str, autoescape: bool = ...) -> SafeText: ... def urlizetrunc(value: str, limit: Union[SafeText, int], autoescape: bool = ...) -> SafeText: ... def wordcount(value: str) -> int: ... def wordwrap(value: str, arg: Union[SafeText, int]) -> str: ... def ljust(value: str, arg: Union[SafeText, int]) -> str: ... def rjust(value: str, arg: Union[SafeText, int]) -> str: ... def center(value: str, arg: Union[SafeText, int]) -> str: ... def cut(value: str, arg: str) -> str: ... def escape_filter(value: str) -> SafeText: ... def force_escape(value: str) -> SafeText: ... def linebreaks_filter(value: str, autoescape: bool = ...) -> SafeText: ... def linebreaksbr(value: str, autoescape: bool = ...) -> SafeText: ... def safe(value: str) -> SafeText: ... def safeseq(value: List[str]) -> List[SafeText]: ... def striptags(value: str) -> str: ... def dictsort(value: Any, arg: Union[int, str]) -> Any: ... def dictsortreversed(value: Any, arg: Union[int, str]) -> Any: ... def first(value: Any) -> Any: ... def join(value: Any, arg: str, autoescape: bool = ...) -> Any: ... def last(value: List[str]) -> str: ... def length(value: Any) -> int: ... def length_is(value: Optional[Any], arg: Union[SafeText, int]) -> Union[bool, str]: ... def random(value: List[str]) -> str: ... def slice_filter(value: Any, arg: Union[str, int]) -> Any: ... def unordered_list(value: Any, autoescape: bool = ...) -> Any: ... def add(value: Any, arg: Any) -> Any: ... def get_digit(value: Any, arg: int) -> Any: ... def date(value: Optional[Union[_date, datetime, str]], arg: Optional[str] = ...) -> str: ... def time(value: Optional[Union[datetime, _time, str]], arg: Optional[str] = ...) -> str: ... def timesince_filter(value: Optional[_date], arg: Optional[_date] = ...) -> str: ... def timeuntil_filter(value: Optional[_date], arg: Optional[_date] = ...) -> str: ... def default(value: Optional[Union[int, str]], arg: Union[int, str]) -> Union[int, str]: ... def default_if_none(value: Optional[str], arg: Union[int, str]) -> Union[int, str]: ... def divisibleby(value: int, arg: int) -> bool: ... def yesno(value: Optional[int], arg: Optional[str] = ...) -> Optional[Union[bool, str]]: ... def filesizeformat(bytes_: Union[complex, int, str]) -> str: ... def pluralize(value: Any, arg: str = ...) -> str: ... def phone2numeric_filter(value: str) -> str: ... def pprint(value: Any) -> str: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/template/defaulttags.pyi0000664000175000017500000001610500000000000027510 0ustar00davedave00000000000000from collections import namedtuple from datetime import date from typing import Any, Dict, List, Optional, Sequence, Tuple, Union from django.template.base import FilterExpression, Parser, Token from django.template.context import Context from django.utils.safestring import SafeText from .base import Node, NodeList from .library import Library from .smartif import IfParser, Literal register: Any class AutoEscapeControlNode(Node): nodelist: NodeList setting: bool def __init__(self, setting: bool, nodelist: NodeList) -> None: ... class CommentNode(Node): ... class CsrfTokenNode(Node): ... class CycleNode(Node): cyclevars: List[FilterExpression] = ... variable_name: Optional[str] = ... silent: bool = ... def __init__( self, cyclevars: List[FilterExpression], variable_name: Optional[str] = ..., silent: bool = ... ) -> None: ... def reset(self, context: Context) -> None: ... class DebugNode(Node): ... class FilterNode(Node): filter_expr: FilterExpression nodelist: NodeList def __init__(self, filter_expr: FilterExpression, nodelist: NodeList) -> None: ... class FirstOfNode(Node): vars: List[FilterExpression] = ... asvar: Optional[str] = ... def __init__(self, variables: List[FilterExpression], asvar: Optional[str] = ...) -> None: ... class ForNode(Node): loopvars: Union[List[str], str] sequence: Union[FilterExpression, str] child_nodelists: Any = ... is_reversed: bool = ... nodelist_loop: Union[List[str], NodeList] = ... nodelist_empty: Union[List[str], NodeList] = ... def __init__( self, loopvars: Union[List[str], str], sequence: Union[FilterExpression, str], is_reversed: bool, nodelist_loop: Union[List[str], NodeList], nodelist_empty: Optional[Union[List[str], NodeList]] = ..., ) -> None: ... class IfChangedNode(Node): nodelist_false: NodeList nodelist_true: NodeList child_nodelists: Any = ... def __init__(self, nodelist_true: NodeList, nodelist_false: NodeList, *varlist: Any) -> None: ... class IfEqualNode(Node): nodelist_false: Union[List[Any], NodeList] nodelist_true: Union[List[Any], NodeList] var1: Union[FilterExpression, str] var2: Union[FilterExpression, str] child_nodelists: Any = ... negate: bool = ... def __init__( self, var1: Union[FilterExpression, str], var2: Union[FilterExpression, str], nodelist_true: Union[List[Any], NodeList], nodelist_false: Union[List[Any], NodeList], negate: bool, ) -> None: ... class IfNode(Node): conditions_nodelists: List[Tuple[Optional[TemplateLiteral], NodeList]] = ... def __init__(self, conditions_nodelists: List[Tuple[Optional[TemplateLiteral], NodeList]]) -> None: ... def __iter__(self) -> None: ... @property def nodelist(self) -> NodeList: ... class LoremNode(Node): common: bool count: FilterExpression method: str def __init__(self, count: FilterExpression, method: str, common: bool) -> None: ... GroupedResult = namedtuple("GroupedResult", ["grouper", "list"]) class RegroupNode(Node): expression: FilterExpression target: FilterExpression var_name: str = ... def __init__(self, target: FilterExpression, expression: FilterExpression, var_name: str) -> None: ... def resolve_expression(self, obj: Dict[str, date], context: Context) -> Union[int, str]: ... class LoadNode(Node): ... class NowNode(Node): format_string: str = ... asvar: Optional[str] = ... def __init__(self, format_string: str, asvar: Optional[str] = ...) -> None: ... class ResetCycleNode(Node): node: CycleNode = ... def __init__(self, node: CycleNode) -> None: ... class SpacelessNode(Node): nodelist: NodeList = ... def __init__(self, nodelist: NodeList) -> None: ... class TemplateTagNode(Node): mapping: Any = ... tagtype: str = ... def __init__(self, tagtype: str) -> None: ... class URLNode(Node): view_name: FilterExpression = ... args: List[FilterExpression] = ... kwargs: Dict[str, FilterExpression] = ... asvar: Optional[str] = ... def __init__( self, view_name: FilterExpression, args: List[FilterExpression], kwargs: Dict[str, FilterExpression], asvar: Optional[str], ) -> None: ... class VerbatimNode(Node): content: SafeText = ... def __init__(self, content: SafeText) -> None: ... class WidthRatioNode(Node): val_expr: FilterExpression = ... max_expr: FilterExpression = ... max_width: FilterExpression = ... asvar: Optional[str] = ... def __init__( self, val_expr: FilterExpression, max_expr: FilterExpression, max_width: FilterExpression, asvar: Optional[str] = ..., ) -> None: ... class WithNode(Node): nodelist: NodeList = ... extra_context: Dict[str, Any] = ... def __init__( self, var: Optional[str], name: Optional[str], nodelist: Union[NodeList, Sequence[Node]], extra_context: Optional[Dict[str, Any]] = ..., ) -> None: ... def autoescape(parser: Parser, token: Token) -> AutoEscapeControlNode: ... def comment(parser: Parser, token: Token) -> CommentNode: ... def cycle(parser: Parser, token: Token) -> CycleNode: ... def csrf_token(parser: Parser, token: Token) -> CsrfTokenNode: ... def debug(parser: Parser, token: Token) -> DebugNode: ... def do_filter(parser: Parser, token: Token) -> FilterNode: ... def firstof(parser: Parser, token: Token) -> FirstOfNode: ... def do_for(parser: Parser, token: Token) -> ForNode: ... def do_ifequal(parser: Parser, token: Token, negate: bool) -> IfEqualNode: ... def ifequal(parser: Parser, token: Token) -> IfEqualNode: ... def ifnotequal(parser: Parser, token: Token) -> IfEqualNode: ... class TemplateLiteral(Literal): text: str = ... def __init__(self, value: FilterExpression, text: str) -> None: ... def display(self) -> str: ... class TemplateIfParser(IfParser): current_token: TemplateLiteral pos: int tokens: List[TemplateLiteral] error_class: Any = ... template_parser: Parser = ... def __init__(self, parser: Parser, *args: Any, **kwargs: Any) -> None: ... def do_if(parser: Parser, token: Token) -> IfNode: ... def ifchanged(parser: Parser, token: Token) -> IfChangedNode: ... def find_library(parser: Parser, name: str) -> Library: ... def load_from_library(library: Library, label: str, names: List[str]) -> Library: ... def load(parser: Parser, token: Token) -> LoadNode: ... def lorem(parser: Parser, token: Token) -> LoremNode: ... def now(parser: Parser, token: Token) -> NowNode: ... def regroup(parser: Parser, token: Token) -> RegroupNode: ... def resetcycle(parser: Parser, token: Token) -> ResetCycleNode: ... def spaceless(parser: Parser, token: Token) -> SpacelessNode: ... def templatetag(parser: Parser, token: Token) -> TemplateTagNode: ... def url(parser: Parser, token: Token) -> URLNode: ... def verbatim(parser: Parser, token: Token) -> VerbatimNode: ... def widthratio(parser: Parser, token: Token) -> WidthRatioNode: ... def do_with(parser: Parser, token: Token) -> WithNode: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/template/engine.pyi0000664000175000017500000000415600000000000026455 0ustar00davedave00000000000000from typing import Any, Callable, Dict, List, Optional, Tuple, Union, Sequence from django.template.base import Origin from django.template.library import Library from django.template.loaders.base import Loader from django.utils.safestring import SafeText from .base import Template _Loader = Any class Engine: template_context_processors: Tuple[Callable] template_loaders: List[Loader] default_builtins: Any = ... dirs: List[str] = ... app_dirs: bool = ... autoescape: bool = ... context_processors: Union[List[str], Tuple[str]] = ... debug: bool = ... loaders: Sequence[_Loader] = ... string_if_invalid: str = ... file_charset: str = ... libraries: Dict[str, str] = ... template_libraries: Dict[str, Library] = ... builtins: List[str] = ... template_builtins: List[Library] = ... def __init__( self, dirs: Optional[List[str]] = ..., app_dirs: bool = ..., context_processors: Optional[Union[List[str], Tuple[str]]] = ..., debug: bool = ..., loaders: Optional[Sequence[_Loader]] = ..., string_if_invalid: str = ..., file_charset: str = ..., libraries: Optional[Dict[str, str]] = ..., builtins: Optional[List[str]] = ..., autoescape: bool = ..., ) -> None: ... @staticmethod def get_default() -> Engine: ... def get_template_builtins(self, builtins: List[str]) -> List[Library]: ... def get_template_libraries(self, libraries: Dict[str, str]) -> Dict[str, Library]: ... def get_template_loaders(self, template_loaders: Sequence[_Loader]) -> List[Loader]: ... def find_template_loader(self, loader: _Loader) -> Loader: ... def find_template( self, name: str, dirs: None = ..., skip: Optional[List[Origin]] = ... ) -> Tuple[Template, Origin]: ... def from_string(self, template_code: str) -> Template: ... def get_template(self, template_name: str) -> Template: ... def render_to_string(self, template_name: str, context: Optional[Dict[str, Any]] = ...) -> SafeText: ... def select_template(self, template_name_list: List[str]) -> Template: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/template/exceptions.pyi0000664000175000017500000000112400000000000027361 0ustar00davedave00000000000000from typing import List, Optional, Tuple, Union from django.template.backends.base import BaseEngine from django.template.base import Origin class TemplateDoesNotExist(Exception): backend: Optional[BaseEngine] = ... tried: List[Tuple[Origin, str]] = ... chain: List[TemplateDoesNotExist] = ... def __init__( self, msg: Union[Origin, str], tried: Optional[List[Tuple[Origin, str]]] = ..., backend: Optional[BaseEngine] = ..., chain: Optional[List[TemplateDoesNotExist]] = ..., ) -> None: ... class TemplateSyntaxError(Exception): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/template/library.pyi0000664000175000017500000000600700000000000026651 0ustar00davedave00000000000000from typing import Any, Callable, Dict, List, Optional, Tuple, Union from django.template.base import FilterExpression, Parser, Origin, Token from django.template.context import Context from django.utils.safestring import SafeText from .base import Node, Template class InvalidTemplateLibrary(Exception): ... class Library: filters: Dict[str, Callable] = ... tags: Dict[str, Callable] = ... def __init__(self) -> None: ... def tag( self, name: Optional[Union[Callable, str]] = ..., compile_function: Optional[Union[Callable, str]] = ... ) -> Callable: ... def tag_function(self, func: Callable) -> Callable: ... def filter( self, name: Optional[Union[Callable, str]] = ..., filter_func: Optional[Union[Callable, str]] = ..., **flags: Any ) -> Callable: ... def filter_function(self, func: Callable, **flags: Any) -> Callable: ... def simple_tag( self, func: Optional[Union[Callable, str]] = ..., takes_context: Optional[bool] = ..., name: Optional[str] = ... ) -> Callable: ... def inclusion_tag( self, filename: Union[Template, str], func: None = ..., takes_context: Optional[bool] = ..., name: Optional[str] = ..., ) -> Callable: ... class TagHelperNode(Node): func: Any = ... takes_context: Any = ... args: Any = ... kwargs: Any = ... def __init__( self, func: Callable, takes_context: Optional[bool], args: List[FilterExpression], kwargs: Dict[str, FilterExpression], ) -> None: ... def get_resolved_arguments(self, context: Context) -> Tuple[List[int], Dict[str, Union[SafeText, int]]]: ... class SimpleNode(TagHelperNode): args: List[FilterExpression] func: Callable kwargs: Dict[str, FilterExpression] origin: Origin takes_context: Optional[bool] token: Token target_var: Optional[str] = ... def __init__( self, func: Callable, takes_context: Optional[bool], args: List[FilterExpression], kwargs: Dict[str, FilterExpression], target_var: Optional[str], ) -> None: ... class InclusionNode(TagHelperNode): args: List[FilterExpression] func: Callable kwargs: Dict[str, FilterExpression] origin: Origin takes_context: Optional[bool] token: Token filename: Union[Template, str] = ... def __init__( self, func: Callable, takes_context: Optional[bool], args: List[FilterExpression], kwargs: Dict[str, FilterExpression], filename: Optional[Union[Template, str]], ) -> None: ... def parse_bits( parser: Parser, bits: List[str], params: List[str], varargs: Optional[str], varkw: Optional[str], defaults: Optional[Tuple[Union[bool, str]]], kwonly: List[str], kwonly_defaults: Optional[Dict[str, int]], takes_context: Optional[bool], name: str, ) -> Tuple[List[FilterExpression], Dict[str, FilterExpression]]: ... def import_library(name: str) -> Library: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/template/loader.pyi0000664000175000017500000000115400000000000026451 0ustar00davedave00000000000000from typing import Any, Dict, List, Optional, Union from . import engines as engines # noqa: F401 from django.http.request import HttpRequest from django.template.exceptions import TemplateDoesNotExist as TemplateDoesNotExist # noqa: F401 def get_template(template_name: str, using: Optional[str] = ...) -> Any: ... def select_template(template_name_list: Union[List[str], str], using: Optional[str] = ...) -> Any: ... def render_to_string( template_name: Union[List[str], str], context: Optional[Dict[str, Any]] = ..., request: Optional[HttpRequest] = ..., using: Optional[str] = ..., ) -> str: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/template/loader_tags.pyi0000664000175000017500000000447300000000000027476 0ustar00davedave00000000000000import collections from typing import Any, Dict, List, Optional, Union from django.template.base import FilterExpression, NodeList, Parser, Token, Origin from django.template.context import Context from django.utils.safestring import SafeText from .base import Node, Template register: Any BLOCK_CONTEXT_KEY: str class BlockContext: blocks: collections.defaultdict = ... def __init__(self) -> None: ... def add_blocks(self, blocks: Dict[str, BlockNode]) -> None: ... def pop(self, name: str) -> BlockNode: ... def push(self, name: str, block: BlockNode) -> None: ... def get_block(self, name: str) -> BlockNode: ... class BlockNode(Node): context: Context name: str nodelist: NodeList origin: Origin parent: None token: Token def __init__(self, name: str, nodelist: NodeList, parent: None = ...) -> None: ... def render(self, context: Context) -> SafeText: ... def super(self) -> SafeText: ... class ExtendsNode(Node): origin: Origin token: Token must_be_first: bool = ... context_key: str = ... nodelist: NodeList = ... parent_name: Union[FilterExpression, Node] = ... template_dirs: Optional[List[Any]] = ... blocks: Dict[str, BlockNode] = ... def __init__( self, nodelist: NodeList, parent_name: Union[FilterExpression, Node], template_dirs: Optional[List[Any]] = ... ) -> None: ... def find_template(self, template_name: str, context: Context) -> Template: ... def get_parent(self, context: Context) -> Template: ... def render(self, context: Context) -> Any: ... class IncludeNode(Node): origin: Origin token: Token context_key: str = ... template: FilterExpression = ... extra_context: Dict[str, FilterExpression] = ... isolated_context: bool = ... def __init__( self, template: FilterExpression, *args: Any, extra_context: Optional[Any] = ..., isolated_context: bool = ..., **kwargs: Any ) -> None: ... def render(self, context: Context) -> SafeText: ... def do_block(parser: Parser, token: Token) -> BlockNode: ... def construct_relative_path(current_template_name: Optional[str], relative_name: str) -> str: ... def do_extends(parser: Parser, token: Token) -> ExtendsNode: ... def do_include(parser: Parser, token: Token) -> IncludeNode: ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4063792 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/template/loaders/0000775000175000017500000000000000000000000026110 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/template/loaders/__init__.pyi0000664000175000017500000000000000000000000030360 0ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/template/loaders/app_directories.pyi0000664000175000017500000000013000000000000032001 0ustar00davedave00000000000000from .filesystem import Loader as FilesystemLoader class Loader(FilesystemLoader): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/template/loaders/base.pyi0000664000175000017500000000073400000000000027551 0ustar00davedave00000000000000from typing import Any, List, Optional, Dict from django.template.base import Origin, Template from django.template.engine import Engine class Loader: engine: Engine = ... get_template_cache: Dict[str, Any] = ... def __init__(self, engine: Engine) -> None: ... def get_template(self, template_name: str, skip: Optional[List[Origin]] = ...) -> Template: ... def get_template_sources(self, template_name: str) -> None: ... def reset(self) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/template/loaders/cached.pyi0000664000175000017500000000106400000000000030043 0ustar00davedave00000000000000from typing import Any, Dict, List, Optional, Sequence from django.template.base import Origin from django.template.engine import Engine from .base import Loader as BaseLoader class Loader(BaseLoader): template_cache: Dict[str, Any] = ... loaders: List[BaseLoader] = ... def __init__(self, engine: Engine, loaders: Sequence[Any]) -> None: ... def get_contents(self, origin: Origin) -> str: ... def cache_key(self, template_name: str, skip: Optional[List[Origin]] = ...) -> str: ... def generate_hash(self, values: List[str]) -> str: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/template/loaders/filesystem.pyi0000664000175000017500000000066100000000000031022 0ustar00davedave00000000000000from typing import Any, List, Optional, Union from django.template.base import Origin from django.template.engine import Engine from .base import Loader as BaseLoader class Loader(BaseLoader): dirs: Optional[List[str]] = ... def __init__(self, engine: Engine, dirs: Optional[List[str]] = ...) -> None: ... def get_dirs(self) -> Union[List[bytes], List[str]]: ... def get_contents(self, origin: Origin) -> Any: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/template/loaders/locmem.pyi0000664000175000017500000000054200000000000030110 0ustar00davedave00000000000000from typing import Dict from django.template.base import Origin from django.template.engine import Engine from .base import Loader as BaseLoader class Loader(BaseLoader): templates_dict: Dict[str, str] = ... def __init__(self, engine: Engine, templates_dict: Dict[str, str]) -> None: ... def get_contents(self, origin: Origin) -> str: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/template/response.pyi0000664000175000017500000000445000000000000027043 0ustar00davedave00000000000000import functools from http.cookies import SimpleCookie from typing import Any, Callable, Dict, List, Optional, Sequence, Tuple, Union from django.core.handlers.wsgi import WSGIRequest from django.http.request import HttpRequest from django.template.base import Template from django.template.context import RequestContext from django.test.client import Client from django.http import HttpResponse class ContentNotRenderedError(Exception): ... class SimpleTemplateResponse(HttpResponse): content: Any = ... closed: bool cookies: SimpleCookie status_code: int rendering_attrs: Any = ... template_name: Union[List[str], Template, str] = ... context_data: Optional[Dict[str, Any]] = ... using: Optional[str] = ... def __init__( self, template: Union[List[str], Template, str], context: Optional[Dict[str, Any]] = ..., content_type: Optional[str] = ..., status: Optional[int] = ..., charset: Optional[str] = ..., using: Optional[str] = ..., ) -> None: ... def resolve_template(self, template: Union[Sequence[str], Template, str]) -> Template: ... def resolve_context(self, context: Optional[Dict[str, Any]]) -> Optional[Dict[str, Any]]: ... @property def rendered_content(self) -> str: ... def add_post_render_callback(self, callback: Callable) -> None: ... def render(self) -> SimpleTemplateResponse: ... @property def is_rendered(self) -> bool: ... def __iter__(self) -> Any: ... class TemplateResponse(SimpleTemplateResponse): client: Client closed: bool context: RequestContext context_data: Optional[Dict[str, Any]] cookies: SimpleCookie csrf_cookie_set: bool json: functools.partial redirect_chain: List[Tuple[str, int]] request: Dict[str, Union[int, str]] status_code: int template_name: Union[List[str], Template, str] templates: List[Template] using: Optional[str] wsgi_request: WSGIRequest rendering_attrs: Any = ... def __init__( self, request: HttpRequest, template: Union[List[str], Template, str], context: Optional[Dict[str, Any]] = ..., content_type: Optional[str] = ..., status: Optional[int] = ..., charset: None = ..., using: Optional[str] = ..., ) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/template/smartif.pyi0000664000175000017500000000236300000000000026653 0ustar00davedave00000000000000from typing import Any, Dict, List, Optional, Union from django.template.defaulttags import TemplateLiteral _Token = Union[List[int], int, str] class TokenBase: id: Any = ... value: Any = ... first: Any = ... second: Any = ... def nud(self, parser: Any) -> None: ... def led(self, left: Any, parser: Any) -> None: ... def display(self): ... def infix(bp: Any, func: Any): ... def prefix(bp: Any, func: Any): ... OPERATORS: Any class Literal(TokenBase): id: str = ... lbp: int = ... value: Optional[_Token] = ... def __init__(self, value: Optional[_Token]) -> None: ... def display(self): ... def eval(self, context: Dict[Any, Any]) -> Optional[_Token]: ... class EndToken(TokenBase): lbp: int = ... def nud(self, parser: Any) -> None: ... class IfParser: error_class: Any = ... tokens: Any = ... pos: int = ... current_token: Any = ... def __init__(self, tokens: List[Optional[_Token]]) -> None: ... def translate_token(self, token: Optional[_Token]) -> Literal: ... def next_token(self) -> Literal: ... def parse(self) -> TemplateLiteral: ... def expression(self, rbp: int = ...) -> Literal: ... def create_var(self, value: Optional[_Token]) -> Literal: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/template/utils.pyi0000664000175000017500000000105600000000000026344 0ustar00davedave00000000000000import collections from typing import Any, Dict, List, Tuple from django.core.exceptions import ImproperlyConfigured from django.template.backends.base import BaseEngine class InvalidTemplateEngineError(ImproperlyConfigured): ... class EngineHandler: templates: collections.OrderedDict def __init__(self, templates: List[Dict[str, Any]] = ...) -> None: ... def __getitem__(self, alias: str) -> BaseEngine: ... def __iter__(self) -> Any: ... def all(self) -> List[BaseEngine]: ... def get_app_template_dirs(dirname: str) -> Tuple: ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4063792 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/templatetags/0000775000175000017500000000000000000000000025336 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/templatetags/__init__.pyi0000664000175000017500000000000000000000000027606 0ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/templatetags/cache.pyi0000664000175000017500000000125200000000000027124 0ustar00davedave00000000000000from typing import Any, List, Optional from django.template.base import FilterExpression, NodeList, Parser, Token from django.template import Node register: Any class CacheNode(Node): nodelist: NodeList = ... expire_time_var: FilterExpression = ... fragment_name: str = ... vary_on: List[FilterExpression] = ... cache_name: Optional[FilterExpression] = ... def __init__( self, nodelist: NodeList, expire_time_var: FilterExpression, fragment_name: str, vary_on: List[FilterExpression], cache_name: Optional[FilterExpression], ) -> None: ... def do_cache(parser: Parser, token: Token) -> CacheNode: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/templatetags/i18n.pyi0000664000175000017500000000615000000000000026642 0ustar00davedave00000000000000from typing import Any, Dict, List, Optional, Tuple from django.template.base import FilterExpression, NodeList, Parser, Token from django.template import Node register: Any class GetAvailableLanguagesNode(Node): variable: str = ... def __init__(self, variable: str) -> None: ... class GetLanguageInfoNode(Node): lang_code: FilterExpression = ... variable: str = ... def __init__(self, lang_code: FilterExpression, variable: str) -> None: ... class GetLanguageInfoListNode(Node): languages: FilterExpression = ... variable: str = ... def __init__(self, languages: FilterExpression, variable: str) -> None: ... def get_language_info(self, language: Any): ... class GetCurrentLanguageNode(Node): variable: str = ... def __init__(self, variable: str) -> None: ... class GetCurrentLanguageBidiNode(Node): variable: str = ... def __init__(self, variable: str) -> None: ... class TranslateNode(Node): noop: bool = ... asvar: Optional[str] = ... message_context: Optional[FilterExpression] = ... filter_expression: FilterExpression = ... def __init__( self, filter_expression: FilterExpression, noop: bool, asvar: Optional[str] = ..., message_context: Optional[FilterExpression] = ..., ) -> None: ... class BlockTranslateNode(Node): extra_context: Dict[str, FilterExpression] = ... singular: List[Token] = ... plural: List[Token] = ... countervar: Optional[str] = ... counter: Optional[FilterExpression] = ... message_context: Optional[FilterExpression] = ... trimmed: bool = ... asvar: Optional[str] = ... def __init__( self, extra_context: Dict[str, FilterExpression], singular: List[Token], plural: List[Token] = ..., countervar: Optional[str] = ..., counter: Optional[FilterExpression] = ..., message_context: Optional[FilterExpression] = ..., trimmed: bool = ..., asvar: Optional[str] = ..., ) -> None: ... def render_token_list(self, tokens: List[Token]) -> Tuple[str, List[str]]: ... class LanguageNode(Node): nodelist: NodeList = ... language: FilterExpression = ... def __init__(self, nodelist: NodeList, language: FilterExpression) -> None: ... def do_get_available_languages(parser: Parser, token: Token) -> GetAvailableLanguagesNode: ... def do_get_language_info(parser: Parser, token: Token) -> GetLanguageInfoNode: ... def do_get_language_info_list(parser: Parser, token: Token) -> GetLanguageInfoListNode: ... def language_name(lang_code: str) -> str: ... def language_name_translated(lang_code: str) -> str: ... def language_name_local(lang_code: str) -> str: ... def language_bidi(lang_code: str) -> bool: ... def do_get_current_language(parser: Parser, token: Token) -> GetCurrentLanguageNode: ... def do_get_current_language_bidi(parser: Parser, token: Token) -> GetCurrentLanguageBidiNode: ... def do_translate(parser: Parser, token: Token) -> TranslateNode: ... def do_block_translate(parser: Parser, token: Token) -> BlockTranslateNode: ... def language(parser: Parser, token: Token) -> LanguageNode: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/templatetags/l10n.pyi0000664000175000017500000000065500000000000026641 0ustar00davedave00000000000000from typing import Any, List from django.template.base import Parser, Token from django.template import Node register: Any def localize(value: Any) -> str: ... def unlocalize(value: Any) -> str: ... class LocalizeNode(Node): nodelist: List[Node] = ... use_l10n: bool = ... def __init__(self, nodelist: List[Node], use_l10n: bool) -> None: ... def localize_tag(parser: Parser, token: Token) -> LocalizeNode: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/templatetags/static.pyi0000664000175000017500000000222200000000000027346 0ustar00davedave00000000000000from typing import Any, Optional from django.template.base import FilterExpression, Parser, Token from django.template.context import Context from django import template register: Any class PrefixNode(template.Node): varname: Optional[str] = ... name: str = ... def __init__(self, varname: Optional[str] = ..., name: str = ...) -> None: ... @classmethod def handle_token(cls, parser: Parser, token: Token, name: str) -> PrefixNode: ... @classmethod def handle_simple(cls, name: str) -> str: ... def get_static_prefix(parser: Parser, token: Token) -> PrefixNode: ... def get_media_prefix(parser: Parser, token: Token) -> PrefixNode: ... class StaticNode(template.Node): path: FilterExpression = ... varname: Optional[str] = ... def __init__(self, varname: Optional[str] = ..., path: FilterExpression = ...) -> None: ... def url(self, context: Context) -> str: ... @classmethod def handle_simple(cls, path: str) -> str: ... @classmethod def handle_token(cls, parser: Parser, token: Token) -> StaticNode: ... def do_static(parser: Parser, token: Token) -> StaticNode: ... def static(path: str) -> str: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/templatetags/tz.pyi0000664000175000017500000000221600000000000026517 0ustar00davedave00000000000000from datetime import datetime from typing import Any, Optional, Union from django.template.base import FilterExpression, NodeList, Parser, Token from django.utils.timezone import FixedOffset from django.template import Node register: Any class datetimeobject(datetime): ... def localtime(value: Optional[Union[datetime, str]]) -> Any: ... def utc(value: Optional[Union[datetime, str]]) -> Any: ... def do_timezone(value: Optional[Union[datetime, str]], arg: Optional[Union[FixedOffset, str]]) -> Any: ... class LocalTimeNode(Node): nodelist: NodeList = ... use_tz: bool = ... def __init__(self, nodelist: NodeList, use_tz: bool) -> None: ... class TimezoneNode(Node): nodelist: NodeList = ... tz: FilterExpression = ... def __init__(self, nodelist: NodeList, tz: FilterExpression) -> None: ... class GetCurrentTimezoneNode(Node): variable: str = ... def __init__(self, variable: str) -> None: ... def localtime_tag(parser: Parser, token: Token) -> LocalTimeNode: ... def timezone_tag(parser: Parser, token: Token) -> TimezoneNode: ... def get_current_timezone_tag(parser: Parser, token: Token) -> GetCurrentTimezoneNode: ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4063792 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/test/0000775000175000017500000000000000000000000023623 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/test/__init__.pyi0000664000175000017500000000123700000000000026110 0ustar00davedave00000000000000from .testcases import ( TestCase as TestCase, TransactionTestCase as TransactionTestCase, SimpleTestCase as SimpleTestCase, LiveServerTestCase as LiveServerTestCase, skipIfDBFeature as skipIfDBFeature, skipUnlessDBFeature as skipUnlessDBFeature, skipUnlessAnyDBFeature as skipUnlessAnyDBFeature, ) from .utils import ( override_settings as override_settings, modify_settings as modify_settings, override_script_prefix as override_script_prefix, override_system_checks as override_system_checks, ignore_warnings as ignore_warnings, tag as tag, ) from .client import Client as Client, RequestFactory as RequestFactory ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/test/client.pyi0000664000175000017500000001273100000000000025630 0ustar00davedave00000000000000from io import BytesIO from types import TracebackType from typing import Any, Dict, List, Optional, Pattern, Tuple, Type, Union from django.contrib.auth.models import AbstractUser from django.contrib.sessions.backends.base import SessionBase from django.core.handlers.base import BaseHandler from django.http.cookie import SimpleCookie from django.http.request import HttpRequest from django.http.response import HttpResponse, HttpResponseBase from django.core.handlers.wsgi import WSGIRequest from json import JSONEncoder BOUNDARY: str = ... MULTIPART_CONTENT: str = ... CONTENT_TYPE_RE: Pattern = ... JSON_CONTENT_TYPE_RE: Pattern = ... class RedirectCycleError(Exception): last_response: HttpResponseBase = ... redirect_chain: List[Tuple[str, int]] = ... def __init__(self, message: str, last_response: HttpResponseBase) -> None: ... class FakePayload: read_started: bool = ... def __init__(self, content: Optional[Union[bytes, str]] = ...) -> None: ... def __len__(self) -> int: ... def read(self, num_bytes: int = ...) -> bytes: ... def write(self, content: Union[bytes, str]) -> None: ... class ClientHandler(BaseHandler): enforce_csrf_checks: bool = ... def __init__(self, enforce_csrf_checks: bool = ..., *args: Any, **kwargs: Any) -> None: ... def __call__(self, environ: Dict[str, Any]) -> HttpResponseBase: ... def encode_multipart(boundary: str, data: Dict[str, Any]) -> bytes: ... def encode_file(boundary: str, key: str, file: Any) -> List[bytes]: ... class RequestFactory: json_encoder: Type[JSONEncoder] defaults: Dict[str, str] cookies: SimpleCookie errors: BytesIO def __init__(self, *, json_encoder: Type[JSONEncoder] = ..., **defaults: Any) -> None: ... def request(self, **request: Any) -> WSGIRequest: ... def get(self, path: str, data: Any = ..., secure: bool = ..., **extra: Any) -> WSGIRequest: ... def post( self, path: str, data: Any = ..., content_type: str = ..., secure: bool = ..., **extra: Any ) -> WSGIRequest: ... def head(self, path: str, data: Any = ..., secure: bool = ..., **extra: Any) -> WSGIRequest: ... def trace(self, path: str, secure: bool = ..., **extra: Any) -> WSGIRequest: ... def options( self, path: str, data: Union[Dict[str, str], str] = ..., content_type: str = ..., follow: bool = ..., secure: bool = ..., **extra: Any ) -> WSGIRequest: ... def put( self, path: str, data: Any = ..., content_type: str = ..., secure: bool = ..., **extra: Any ) -> WSGIRequest: ... def patch( self, path: str, data: Any = ..., content_type: str = ..., secure: bool = ..., **extra: Any ) -> WSGIRequest: ... def delete( self, path: str, data: Any = ..., content_type: str = ..., secure: bool = ..., **extra: Any ) -> WSGIRequest: ... def generic( self, method: str, path: str, data: Any = ..., content_type: Optional[str] = ..., secure: bool = ..., **extra: Any ) -> WSGIRequest: ... class Client(RequestFactory): handler: ClientHandler raise_request_exception: bool exc_info: Optional[Tuple[Type[BaseException], BaseException, TracebackType]] def __init__( self, enforce_csrf_checks: bool = ..., raise_request_exception: bool = ..., *, json_encoder: Type[JSONEncoder] = ..., **defaults: Any ) -> None: ... # Silence type warnings, since this class overrides arguments and return types in an unsafe manner. def request(self, **request: Any) -> HttpResponse: ... # type: ignore def get( # type: ignore self, path: str, data: Any = ..., follow: bool = ..., secure: bool = ..., **extra: Any ) -> HttpResponse: ... # type: ignore def post( # type: ignore self, path: str, data: Any = ..., content_type: str = ..., follow: bool = ..., secure: bool = ..., **extra: Any ) -> HttpResponse: ... # type: ignore def head( # type: ignore self, path: str, data: Any = ..., follow: bool = ..., secure: bool = ..., **extra: Any ) -> HttpResponse: ... # type: ignore def trace( # type: ignore self, path: str, follow: bool = ..., secure: bool = ..., **extra: Any ) -> HttpResponse: ... # type: ignore def options( # type: ignore self, path: str, data: Union[Dict[str, str], str] = ..., content_type: str = ..., follow: bool = ..., secure: bool = ..., **extra: Any ) -> HttpResponse: ... # type: ignore def put( # type: ignore self, path: str, data: Any = ..., content_type: str = ..., follow: bool = ..., secure: bool = ..., **extra: Any ) -> HttpResponse: ... # type: ignore def patch( # type: ignore self, path: str, data: Any = ..., content_type: str = ..., follow: bool = ..., secure: bool = ..., **extra: Any ) -> HttpResponse: ... # type: ignore def delete( # type: ignore self, path: str, data: Any = ..., content_type: str = ..., follow: bool = ..., secure: bool = ..., **extra: Any ) -> HttpResponse: ... # type: ignore def store_exc_info(self, **kwargs: Any) -> None: ... @property def session(self) -> SessionBase: ... def login(self, **credentials: Any) -> bool: ... def force_login(self, user: AbstractUser, backend: Optional[str] = ...) -> None: ... def logout(self) -> None: ... def conditional_content_removal(request: HttpRequest, response: HttpResponseBase) -> HttpResponse: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/test/html.pyi0000664000175000017500000000226300000000000025315 0ustar00davedave00000000000000from html.parser import HTMLParser from typing import Any, List, Optional, Sequence, Tuple, TypeVar, Union _Self = TypeVar("_Self") WHITESPACE: Any def normalize_whitespace(string: str) -> str: ... _ElementAttribute = Tuple[str, Optional[str]] class Element: name: Optional[str] = ... attributes: List[_ElementAttribute] = ... children: List[Any] = ... def __init__(self, name: Optional[str], attributes: Sequence[_ElementAttribute]) -> None: ... def append(self, element: Union[Element, str]) -> None: ... def finalize(self) -> None: ... def __contains__(self, element: Union[Element, str]) -> bool: ... def count(self, element: Union[Element, str]) -> int: ... def __getitem__(self, key: int) -> Any: ... class RootElement(Element): def __init__(self) -> None: ... class HTMLParseError(Exception): ... class Parser(HTMLParser): SELF_CLOSING_TAGS: Any = ... root: Any = ... open_tags: Any = ... element_positions: Any = ... def __init__(self) -> None: ... def format_position(self, position: Any = ..., element: Any = ...) -> str: ... @property def current(self) -> Element: ... def parse_html(html: str) -> Element: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/test/runner.pyi0000664000175000017500000001213200000000000025656 0ustar00davedave00000000000000import logging from argparse import ArgumentParser from io import StringIO from typing import Any, Dict, List, Optional, Sequence, Set, Tuple, Type from unittest import TestCase, TestSuite, TextTestResult from django.db.backends.base.base import BaseDatabaseWrapper from django.test.testcases import SimpleTestCase, TestCase from django.utils.datastructures import OrderedSet class DebugSQLTextTestResult(TextTestResult): buffer: bool descriptions: bool dots: bool expectedFailures: List[Any] failfast: bool shouldStop: bool showAll: bool skipped: List[Any] tb_locals: bool testsRun: int unexpectedSuccesses: List[Any] logger: logging.Logger = ... def __init__(self, stream: Any, descriptions: bool, verbosity: int) -> None: ... debug_sql_stream: StringIO = ... handler: logging.StreamHandler = ... def startTest(self, test: TestCase) -> None: ... def stopTest(self, test: TestCase) -> None: ... def addError(self, test: Any, err: Any) -> None: ... def addFailure(self, test: Any, err: Any) -> None: ... class RemoteTestResult: events: List[Any] = ... failfast: bool = ... shouldStop: bool = ... testsRun: int = ... def __init__(self) -> None: ... @property def test_index(self): ... def check_picklable(self, test: Any, err: Any) -> None: ... def _confirm_picklable(self, obj: Any) -> None: ... def check_subtest_picklable(self, test: Any, subtest: Any) -> None: ... def stop_if_failfast(self) -> None: ... def stop(self) -> None: ... def startTestRun(self) -> None: ... def stopTestRun(self) -> None: ... def startTest(self, test: Any) -> None: ... def stopTest(self, test: Any) -> None: ... def addError(self, test: Any, err: Any) -> None: ... def addFailure(self, test: Any, err: Any) -> None: ... def addSubTest(self, test: Any, subtest: Any, err: Any) -> None: ... def addSuccess(self, test: Any) -> None: ... def addSkip(self, test: Any, reason: Any) -> None: ... def addExpectedFailure(self, test: Any, err: Any) -> None: ... def addUnexpectedSuccess(self, test: Any) -> None: ... class RemoteTestRunner: resultclass: Any = ... failfast: Any = ... def __init__(self, failfast: bool = ..., resultclass: Optional[Any] = ...) -> None: ... def run(self, test: Any): ... def default_test_processes() -> int: ... class ParallelTestSuite(TestSuite): init_worker: Any = ... run_subsuite: Any = ... runner_class: Any = ... subsuites: Any = ... processes: Any = ... failfast: Any = ... def __init__(self, suite: Any, processes: Any, failfast: bool = ...) -> None: ... def run(self, result: Any): ... class DiscoverRunner: test_suite: Any = ... parallel_test_suite: Any = ... test_runner: Any = ... test_loader: Any = ... reorder_by: Any = ... pattern: Optional[str] = ... top_level: None = ... verbosity: int = ... interactive: bool = ... failfast: bool = ... keepdb: bool = ... reverse: bool = ... debug_mode: bool = ... debug_sql: bool = ... parallel: int = ... tags: Set[str] = ... exclude_tags: Set[str] = ... def __init__( self, pattern: Optional[str] = ..., top_level: None = ..., verbosity: int = ..., interactive: bool = ..., failfast: bool = ..., keepdb: bool = ..., reverse: bool = ..., debug_mode: bool = ..., debug_sql: bool = ..., parallel: int = ..., tags: Optional[List[str]] = ..., exclude_tags: Optional[List[str]] = ..., **kwargs: Any ) -> None: ... @classmethod def add_arguments(cls, parser: ArgumentParser) -> None: ... def setup_test_environment(self, **kwargs: Any) -> None: ... def build_suite( self, test_labels: Sequence[str] = ..., extra_tests: Optional[List[Any]] = ..., **kwargs: Any ) -> TestSuite: ... def setup_databases(self, **kwargs: Any) -> List[Tuple[BaseDatabaseWrapper, str, bool]]: ... def get_resultclass(self) -> Optional[Type[DebugSQLTextTestResult]]: ... def get_test_runner_kwargs(self) -> Dict[str, Optional[int]]: ... def run_checks(self) -> None: ... def run_suite(self, suite: TestSuite, **kwargs: Any) -> TextTestResult: ... def teardown_databases(self, old_config: List[Tuple[BaseDatabaseWrapper, str, bool]], **kwargs: Any) -> None: ... def teardown_test_environment(self, **kwargs: Any) -> None: ... def suite_result(self, suite: TestSuite, result: TextTestResult, **kwargs: Any) -> int: ... def run_tests(self, test_labels: List[str], extra_tests: List[Any] = ..., **kwargs: Any) -> int: ... def is_discoverable(label: str) -> bool: ... def reorder_suite( suite: TestSuite, classes: Tuple[Type[TestCase], Type[SimpleTestCase]], reverse: bool = ... ) -> TestSuite: ... def partition_suite_by_type( suite: TestSuite, classes: Tuple[Type[TestCase], Type[SimpleTestCase]], bins: List[OrderedSet], reverse: bool = ... ) -> None: ... def partition_suite_by_case(suite: Any): ... def filter_tests_by_tags(suite: TestSuite, tags: Set[str], exclude_tags: Set[str]) -> TestSuite: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/test/selenium.pyi0000664000175000017500000000056000000000000026170 0ustar00davedave00000000000000from typing import Any from django.test import LiveServerTestCase class SeleniumTestCaseBase: browsers: Any = ... browser: Any = ... @classmethod def import_webdriver(cls, browser: Any): ... def create_webdriver(self): ... class SeleniumTestCase(LiveServerTestCase): implicit_wait: int = ... def disable_implicit_wait(self) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/test/signals.pyi0000664000175000017500000000173200000000000026011 0ustar00davedave00000000000000from typing import Any from django.core.signals import setting_changed as setting_changed # noqa: F401 template_rendered: Any COMPLEX_OVERRIDE_SETTINGS: Any def clear_cache_handlers(**kwargs: Any) -> None: ... def update_installed_apps(**kwargs: Any) -> None: ... def update_connections_time_zone(**kwargs: Any) -> None: ... def clear_routers_cache(**kwargs: Any) -> None: ... def reset_template_engines(**kwargs: Any) -> None: ... def clear_serializers_cache(**kwargs: Any) -> None: ... def language_changed(**kwargs: Any) -> None: ... def localize_settings_changed(**kwargs: Any) -> None: ... def file_storage_changed(**kwargs: Any) -> None: ... def complex_setting_changed(**kwargs: Any) -> None: ... def root_urlconf_changed(**kwargs: Any) -> None: ... def static_storage_changed(**kwargs: Any) -> None: ... def static_finders_changed(**kwargs: Any) -> None: ... def auth_password_validators_changed(**kwargs: Any) -> None: ... def user_model_swapped(**kwargs: Any) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/test/testcases.pyi0000664000175000017500000002012100000000000026340 0ustar00davedave00000000000000import threading import unittest from datetime import date from typing import Any, Callable, Dict, Iterator, List, Optional, Set, Tuple, Type, Union, ClassVar, overload from django.core.exceptions import ImproperlyConfigured from django.core.handlers.wsgi import WSGIHandler from django.core.servers.basehttp import ThreadedWSGIServer, WSGIRequestHandler from django.db.backends.sqlite3.base import DatabaseWrapper from django.db.models.base import Model from django.db.models.query import QuerySet, RawQuerySet from django.forms.fields import EmailField from django.http.response import HttpResponse, HttpResponseBase from django.template.base import Template from django.test.client import Client from django.test.utils import CaptureQueriesContext, ContextList from django.utils.safestring import SafeText from django.db import connections as connections # noqa: F401 class _AssertNumQueriesContext(CaptureQueriesContext): test_case: SimpleTestCase = ... num: int = ... def __init__(self, test_case: Any, num: Any, connection: Any) -> None: ... class _AssertTemplateUsedContext: test_case: SimpleTestCase = ... template_name: str = ... rendered_templates: List[Template] = ... rendered_template_names: List[str] = ... context: ContextList = ... def __init__(self, test_case: Any, template_name: Any) -> None: ... def on_template_render(self, sender: Any, signal: Any, template: Any, context: Any, **kwargs: Any) -> None: ... def test(self): ... def message(self): ... def __enter__(self): ... def __exit__(self, exc_type: Any, exc_value: Any, traceback: Any): ... class _AssertTemplateNotUsedContext(_AssertTemplateUsedContext): ... class _CursorFailure: cls_name: str = ... wrapped: Callable = ... def __init__(self, cls_name: Any, wrapped: Any) -> None: ... def __call__(self) -> None: ... class SimpleTestCase(unittest.TestCase): client_class: Any = ... client: Client allow_database_queries: bool = ... # TODO: str -> Literal['__all__'] databases: Union[Set[str], str] = ... def __call__(self, result: Optional[unittest.TestResult] = ...) -> None: ... def settings(self, **kwargs: Any) -> Any: ... def modify_settings(self, **kwargs: Any) -> Any: ... def assertRedirects( self, response: HttpResponse, expected_url: str, status_code: int = ..., target_status_code: int = ..., msg_prefix: str = ..., fetch_redirect_response: bool = ..., ) -> None: ... def assertContains( self, response: HttpResponseBase, text: Union[bytes, int, str], count: Optional[int] = ..., status_code: int = ..., msg_prefix: str = ..., html: bool = ..., ) -> None: ... def assertNotContains( self, response: HttpResponse, text: Union[bytes, str], status_code: int = ..., msg_prefix: str = ..., html: bool = ..., ) -> None: ... def assertFormError( self, response: HttpResponse, form: str, field: Optional[str], errors: Union[List[str], str], msg_prefix: str = ..., ) -> None: ... def assertFormsetError( self, response: HttpResponse, formset: str, form_index: Optional[int], field: Optional[str], errors: Union[List[str], str], msg_prefix: str = ..., ) -> None: ... def assertTemplateUsed( self, response: Optional[Union[HttpResponse, str]] = ..., template_name: Optional[str] = ..., msg_prefix: str = ..., count: Optional[int] = ..., ) -> Optional[_AssertTemplateUsedContext]: ... def assertTemplateNotUsed( self, response: Union[HttpResponse, str] = ..., template_name: Optional[str] = ..., msg_prefix: str = ... ) -> Optional[_AssertTemplateNotUsedContext]: ... def assertRaisesMessage( self, expected_exception: Type[Exception], expected_message: str, *args: Any, **kwargs: Any ) -> Any: ... def assertWarnsMessage( self, expected_warning: Type[Exception], expected_message: str, *args: Any, **kwargs: Any ) -> Any: ... def assertFieldOutput( self, fieldclass: Type[EmailField], valid: Dict[str, str], invalid: Dict[str, List[str]], field_args: None = ..., field_kwargs: None = ..., empty_value: str = ..., ) -> Any: ... def assertHTMLEqual(self, html1: str, html2: str, msg: Optional[str] = ...) -> None: ... def assertHTMLNotEqual(self, html1: str, html2: str, msg: Optional[str] = ...) -> None: ... def assertInHTML( self, needle: str, haystack: SafeText, count: Optional[int] = ..., msg_prefix: str = ... ) -> None: ... def assertJSONEqual( self, raw: str, expected_data: Union[Dict[str, Any], List[Any], str, int, float, bool, None], msg: Optional[str] = ..., ) -> None: ... def assertJSONNotEqual( self, raw: str, expected_data: Union[Dict[str, Any], List[Any], str, int, float, bool, None], msg: Optional[str] = ..., ) -> None: ... def assertXMLEqual(self, xml1: str, xml2: str, msg: Optional[str] = ...) -> None: ... def assertXMLNotEqual(self, xml1: str, xml2: str, msg: Optional[str] = ...) -> None: ... class TransactionTestCase(SimpleTestCase): reset_sequences: bool = ... available_apps: Any = ... fixtures: Any = ... multi_db: bool = ... serialized_rollback: bool = ... def assertQuerysetEqual( self, qs: Union[Iterator[Any], List[Model], QuerySet, RawQuerySet], values: Union[List[None], List[Tuple[str, str]], List[date], List[int], List[str], Set[str], QuerySet], transform: Union[Callable, Type[str]] = ..., ordered: bool = ..., msg: Optional[str] = ..., ) -> None: ... @overload def assertNumQueries( self, num: int, func: Callable[..., Any], *args: Any, using: str = ..., **kwargs: Any ) -> None: ... @overload def assertNumQueries( self, num: int, func: None = ..., *args: Any, using: str = ..., **kwargs: Any ) -> _AssertNumQueriesContext: ... class TestCase(TransactionTestCase): @classmethod def setUpTestData(cls) -> None: ... class CheckCondition: conditions: Tuple[Tuple[Callable, str]] = ... def __init__(self, *conditions: Any) -> None: ... def add_condition(self, condition: Callable, reason: str) -> CheckCondition: ... def __get__(self, instance: None, cls: Type[TransactionTestCase] = ...) -> bool: ... def skipIfDBFeature(*features: Any) -> Callable: ... def skipUnlessDBFeature(*features: Any) -> Callable: ... def skipUnlessAnyDBFeature(*features: Any) -> Callable: ... class QuietWSGIRequestHandler(WSGIRequestHandler): ... class FSFilesHandler(WSGIHandler): application: Any = ... base_url: Any = ... def __init__(self, application: Any) -> None: ... def file_path(self, url: Any): ... def serve(self, request: Any): ... class _StaticFilesHandler(FSFilesHandler): def get_base_dir(self): ... def get_base_url(self): ... class _MediaFilesHandler(FSFilesHandler): def get_base_dir(self): ... def get_base_url(self): ... class LiveServerThread(threading.Thread): host: str = ... port: int = ... is_ready: threading.Event = ... error: Optional[ImproperlyConfigured] = ... static_handler: Type[WSGIHandler] = ... connections_override: Dict[str, Any] = ... def __init__( self, host: str, static_handler: Type[WSGIHandler], connections_override: Dict[str, DatabaseWrapper] = ..., port: int = ..., ) -> None: ... httpd: ThreadedWSGIServer = ... def terminate(self) -> None: ... class LiveServerTestCase(TransactionTestCase): live_server_url: ClassVar[str] host: str = ... port: int = ... server_thread_class: Type[Any] = ... server_thread: Any static_handler: Any = ... class SerializeMixin: lockfile: Any = ... @classmethod def setUpClass(cls) -> None: ... @classmethod def tearDownClass(cls) -> None: ... def connections_support_transactions() -> bool: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/test/utils.pyi0000664000175000017500000001247400000000000025516 0ustar00davedave00000000000000import decimal from contextlib import contextmanager from decimal import Decimal from io import StringIO from typing import ( Any, Callable, Dict, Iterable, Iterator, List, Mapping, Optional, Set, Tuple, Type, Union, ContextManager, TypeVar, ) from django.apps.registry import Apps from django.core.checks.registry import CheckRegistry from django.db.models.lookups import Lookup, Transform from django.db.models.query_utils import RegisterLookupMixin from django.test.runner import DiscoverRunner from django.test.testcases import SimpleTestCase from django.conf import LazySettings, Settings _TestClass = Type[SimpleTestCase] _DecoratedTest = Union[Callable, _TestClass] _C = TypeVar("_C", bound=Callable) # Any callable TZ_SUPPORT: bool = ... class Approximate: val: Union[decimal.Decimal, float] = ... places: int = ... def __init__(self, val: Union[Decimal, float], places: int = ...) -> None: ... class ContextList(list): def get(self, key: str, default: Optional[str] = ...) -> str: ... def keys(self) -> Set[str]: ... class _TestState: ... def setup_test_environment(debug: Optional[bool] = ...) -> None: ... def teardown_test_environment() -> None: ... def get_runner(settings: LazySettings, test_runner_class: Optional[str] = ...) -> Type[DiscoverRunner]: ... class TestContextDecorator: attr_name: Optional[str] = ... kwarg_name: Optional[str] = ... def __init__(self, attr_name: Optional[str] = ..., kwarg_name: Optional[str] = ...) -> None: ... def enable(self) -> Any: ... def disable(self) -> None: ... def __enter__(self) -> Optional[Apps]: ... def __exit__(self, exc_type: None, exc_value: None, traceback: None) -> None: ... def decorate_class(self, cls: _TestClass) -> _TestClass: ... def decorate_callable(self, func: _C) -> _C: ... def __call__(self, decorated: _DecoratedTest) -> Any: ... class override_settings(TestContextDecorator): options: Dict[str, Any] = ... def __init__(self, **kwargs: Any) -> None: ... wrapped: Settings = ... def save_options(self, test_func: _DecoratedTest) -> None: ... def decorate_class(self, cls: type) -> type: ... class modify_settings(override_settings): wrapped: Settings operations: List[Tuple[str, Dict[str, Union[List[str], str]]]] = ... def __init__(self, *args: Any, **kwargs: Any) -> None: ... def save_options(self, test_func: _DecoratedTest) -> None: ... options: Dict[str, List[Union[Tuple[str, str], str]]] = ... class override_system_checks(TestContextDecorator): registry: CheckRegistry = ... new_checks: List[Callable] = ... deployment_checks: Optional[List[Callable]] = ... def __init__(self, new_checks: List[Callable], deployment_checks: Optional[List[Callable]] = ...) -> None: ... old_checks: Set[Callable] = ... old_deployment_checks: Set[Callable] = ... class CaptureQueriesContext: connection: Any = ... force_debug_cursor: bool = ... initial_queries: int = ... final_queries: Optional[int] = ... def __init__(self, connection: Any) -> None: ... def __iter__(self): ... def __getitem__(self, index: int) -> Dict[str, str]: ... def __len__(self) -> int: ... @property def captured_queries(self) -> List[Dict[str, str]]: ... def __enter__(self) -> CaptureQueriesContext: ... def __exit__(self, exc_type: None, exc_value: None, traceback: None) -> None: ... class ignore_warnings(TestContextDecorator): ignore_kwargs: Dict[str, Any] = ... filter_func: Callable = ... def __init__(self, **kwargs: Any) -> None: ... catch_warnings: ContextManager[Optional[list]] = ... requires_tz_support: Any def isolate_lru_cache(lru_cache_object: Callable) -> Iterator[None]: ... class override_script_prefix(TestContextDecorator): prefix: str = ... def __init__(self, prefix: str) -> None: ... old_prefix: str = ... class LoggingCaptureMixin: logger: Any = ... old_stream: Any = ... logger_output: Any = ... def setUp(self) -> None: ... def tearDown(self) -> None: ... class isolate_apps(TestContextDecorator): installed_apps: Tuple[str] = ... def __init__(self, *installed_apps: Any, **kwargs: Any) -> None: ... old_apps: Apps = ... @contextmanager def extend_sys_path(*paths: str) -> Iterator[None]: ... @contextmanager def captured_output(stream_name) -> Iterator[StringIO]: ... @contextmanager def captured_stdin() -> Iterator[StringIO]: ... @contextmanager def captured_stdout() -> Iterator[StringIO]: ... @contextmanager def captured_stderr() -> Iterator[StringIO]: ... @contextmanager def freeze_time(t: float) -> Iterator[None]: ... def tag(*tags: str): ... _Signature = str _TestDatabase = Tuple[str, List[str]] def dependency_ordered( test_databases: Iterable[Tuple[_Signature, _TestDatabase]], dependencies: Mapping[str, List[str]] ) -> List[Tuple[_Signature, _TestDatabase]]: ... def get_unique_databases_and_mirrors() -> Tuple[Dict[_Signature, _TestDatabase], Dict[str, Any]]: ... def teardown_databases( old_config: Iterable[Tuple[Any, str, bool]], verbosity: int, parallel: int = ..., keepdb: bool = ... ) -> None: ... def require_jinja2(test_func: _C) -> _C: ... @contextmanager def register_lookup( field: Type[RegisterLookupMixin], *lookups: Type[Union[Lookup, Transform]], lookup_name: Optional[str] = ... ) -> Iterator[None]: ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4063792 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/urls/0000775000175000017500000000000000000000000023631 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/urls/__init__.pyi0000664000175000017500000000225500000000000026117 0ustar00davedave00000000000000# noinspection PyUnresolvedReferences from .base import ( clear_script_prefix as clear_script_prefix, clear_url_caches as clear_url_caches, get_script_prefix as get_script_prefix, get_urlconf as get_urlconf, is_valid_path as is_valid_path, resolve as resolve, reverse as reverse, reverse_lazy as reverse_lazy, set_script_prefix as set_script_prefix, set_urlconf as set_urlconf, translate_url as translate_url, ) # noinspection PyUnresolvedReferences from .conf import include as include, path as path, re_path as re_path # noinspection PyUnresolvedReferences from .converters import register_converter as register_converter # noinspection PyUnresolvedReferences from .exceptions import NoReverseMatch as NoReverseMatch, Resolver404 as Resolver404 # noinspection PyUnresolvedReferences from .resolvers import ( LocalePrefixPattern as LocalePrefixPattern, ResolverMatch as ResolverMatch, URLPattern as URLPattern, URLResolver as URLResolver, get_ns_resolver as get_ns_resolver, get_resolver as get_resolver, ) # noinspection PyUnresolvedReferences from .utils import get_callable as get_callable, get_mod_func as get_mod_func ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/urls/base.pyi0000664000175000017500000000156700000000000025277 0ustar00davedave00000000000000from typing import Any, Callable, Dict, Optional, Type, Union, Sequence from django.urls.resolvers import ResolverMatch def resolve(path: str, urlconf: Optional[str] = ...) -> ResolverMatch: ... def reverse( viewname: Optional[Union[Callable, str]], urlconf: Optional[str] = ..., args: Optional[Sequence[Any]] = ..., kwargs: Optional[Dict[str, Any]] = ..., current_app: Optional[str] = ..., ) -> str: ... reverse_lazy: Any def clear_url_caches() -> None: ... def set_script_prefix(prefix: str) -> None: ... def get_script_prefix() -> str: ... def clear_script_prefix() -> None: ... def set_urlconf(urlconf_name: Optional[Union[Type[Any], str]]) -> None: ... def get_urlconf(default: None = ...) -> Optional[Union[Type[Any], str]]: ... def is_valid_path(path: str, urlconf: Optional[str] = ...) -> bool: ... def translate_url(url: str, lang_code: str) -> str: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/urls/conf.pyi0000664000175000017500000000034000000000000025276 0ustar00davedave00000000000000from typing import Any, List, Optional, Tuple from .resolvers import URLResolver def include(arg: Any, namespace: Optional[str] = ...) -> Tuple[List[URLResolver], Optional[str], Optional[str]]: ... path: Any re_path: Any ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/urls/converters.pyi0000664000175000017500000000147300000000000026553 0ustar00davedave00000000000000from typing import Any, Dict, Type, Union from uuid import UUID class IntConverter: regex: str = ... def to_python(self, value: str) -> int: ... def to_url(self, value: Union[str, int]) -> str: ... class StringConverter: regex: str = ... def to_python(self, value: str) -> str: ... def to_url(self, value: str) -> str: ... class UUIDConverter: regex: str = ... def to_python(self, value: str) -> UUID: ... def to_url(self, value: Union[str, UUID]) -> str: ... class SlugConverter(StringConverter): ... class PathConverter(StringConverter): ... DEFAULT_CONVERTERS: Dict[str, Any] REGISTERED_CONVERTERS: Dict[str, Any] def register_converter(converter: Type[Any], type_name: str) -> None: ... def get_converters() -> Dict[str, Any]: ... def get_converter(raw_converter: str) -> Any: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/urls/exceptions.pyi0000664000175000017500000000014600000000000026536 0ustar00davedave00000000000000from django.http import Http404 class Resolver404(Http404): ... class NoReverseMatch(Exception): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/urls/resolvers.pyi0000664000175000017500000000767500000000000026417 0ustar00davedave00000000000000from typing import Any, Callable, Dict, List, Optional, Tuple, Type, Union from django.urls.converters import UUIDConverter from django.utils.datastructures import MultiValueDict class ResolverMatch: func: Callable = ... args: Tuple = ... kwargs: Dict[str, Any] = ... url_name: Optional[str] = ... app_names: List[str] = ... app_name: str = ... namespaces: List[str] = ... namespace: str = ... view_name: str = ... route: str = ... def __init__( self, func: Callable, args: Tuple, kwargs: Dict[str, Any], url_name: Optional[str] = ..., app_names: Optional[List[Optional[str]]] = ..., namespaces: Optional[List[Optional[str]]] = ..., ) -> None: ... def __getitem__(self, index: int) -> Any: ... # for tuple unpacking def __iter__(self) -> Any: ... def get_resolver(urlconf: Optional[str] = ...) -> URLResolver: ... def get_ns_resolver(ns_pattern: str, resolver: URLResolver, converters: Tuple) -> URLResolver: ... class LocaleRegexDescriptor: attr: str = ... def __init__(self, attr: Any) -> None: ... def __get__(self, instance: Optional[RegexPattern], cls: Type[RegexPattern] = ...) -> LocaleRegexDescriptor: ... class CheckURLMixin: def describe(self) -> str: ... class RegexPattern(CheckURLMixin): regex: Any = ... name: Optional[str] = ... converters: Dict[Any, Any] = ... def __init__(self, regex: str, name: Optional[str] = ..., is_endpoint: bool = ...) -> None: ... def match(self, path: str) -> Optional[Tuple[str, Tuple, Dict[str, str]]]: ... def check(self) -> List[Warning]: ... class RoutePattern(CheckURLMixin): regex: Any = ... name: Optional[str] = ... converters: Dict[str, UUIDConverter] = ... def __init__(self, route: str, name: Optional[str] = ..., is_endpoint: bool = ...) -> None: ... def match(self, path: str) -> Optional[Tuple[str, Tuple, Dict[str, Union[int, str]]]]: ... def check(self) -> List[Warning]: ... class LocalePrefixPattern: prefix_default_language: bool = ... converters: Dict[Any, Any] = ... def __init__(self, prefix_default_language: bool = ...) -> None: ... @property def regex(self): ... @property def language_prefix(self) -> str: ... def match(self, path: str) -> Optional[Tuple[str, Tuple, Dict[str, Any]]]: ... def check(self) -> List[Any]: ... def describe(self) -> str: ... class URLPattern: lookup_str: str pattern: Any = ... callback: Callable = ... default_args: Optional[Dict[str, str]] = ... name: Optional[str] = ... def __init__( self, pattern: Any, callback: Callable, default_args: Optional[Dict[str, str]] = ..., name: Optional[str] = ... ) -> None: ... def check(self) -> List[Warning]: ... def resolve(self, path: str) -> Optional[ResolverMatch]: ... class URLResolver: url_patterns: List[Tuple[str, Callable]] urlconf_module: Optional[List[Tuple[str, Callable]]] pattern: Any = ... urlconf_name: Optional[str] = ... callback: None = ... default_kwargs: Dict[str, Any] = ... namespace: Optional[str] = ... app_name: Optional[str] = ... _local: Any _reverse_dict: MultiValueDict def __init__( self, pattern: Any, urlconf_name: Optional[str], default_kwargs: Optional[Dict[str, Any]] = ..., app_name: Optional[str] = ..., namespace: Optional[str] = ..., ) -> None: ... @property def reverse_dict(self) -> MultiValueDict: ... @property def namespace_dict(self) -> Dict[str, Tuple[str, URLResolver]]: ... @property def app_dict(self) -> Dict[str, List[str]]: ... def resolve(self, path: str) -> ResolverMatch: ... def resolve_error_handler(self, view_type: int) -> Tuple[Callable, Dict[str, Any]]: ... def reverse(self, lookup_view: str, *args: Any, **kwargs: Any) -> str: ... def _is_callback(self, name: str) -> bool: ... def _populate(self) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/urls/utils.pyi0000664000175000017500000000025000000000000025511 0ustar00davedave00000000000000from typing import Callable, Tuple, Union def get_callable(lookup_view: Union[Callable, str]) -> Callable: ... def get_mod_func(callback: str) -> Tuple[str, str]: ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4103792 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/utils/0000775000175000017500000000000000000000000024004 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/utils/__init__.pyi0000664000175000017500000000000000000000000026254 0ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/utils/_os.pyi0000664000175000017500000000046300000000000025312 0ustar00davedave00000000000000from os.path import abspath from pathlib import Path from typing import Any, Union abspathu = abspath def upath(path: Any): ... def npath(path: Any): ... def safe_join(base: Union[bytes, str], *paths: Any) -> str: ... def symlinks_supported() -> Any: ... def to_path(value: Union[Path, str]) -> Path: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/utils/archive.pyi0000664000175000017500000000202300000000000026145 0ustar00davedave00000000000000from typing import Any, Dict, Iterable, Sequence, Type class ArchiveException(Exception): ... class UnrecognizedArchiveFormat(ArchiveException): ... def extract(path: str, to_path: str = ...) -> None: ... class Archive: def __init__(self, file: str) -> None: ... def __enter__(self) -> Archive: ... def __exit__(self, exc_type: None, exc_value: None, traceback: None) -> None: ... def extract(self, to_path: str = ...) -> None: ... def list(self) -> None: ... def close(self) -> None: ... class BaseArchive: def split_leading_dir(self, path: str) -> Sequence[str]: ... def has_leading_dir(self, paths: Iterable[str]) -> bool: ... def extract(self, to_path: str) -> None: ... def list(self, *args: Any, **kwargs: Any) -> None: ... class TarArchive(BaseArchive): def __init__(self, file: str) -> None: ... def close(self) -> None: ... class ZipArchive(BaseArchive): def __init__(self, file: str) -> None: ... def close(self) -> None: ... extension_map: Dict[str, Type[BaseArchive]] ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/utils/autoreload.pyi0000664000175000017500000000521600000000000026672 0ustar00davedave00000000000000import threading import types from pathlib import Path from typing import Any, Callable, List, Optional, Set, Dict, Union, Iterator, Tuple, Iterable from django.apps.registry import Apps USE_INOTIFY: bool fd: Any RUN_RELOADER: bool FILE_MODIFIED: int I18N_MODIFIED: int def gen_filenames(only_new: bool = ...) -> List[str]: ... def clean_files(filelist: List[Optional[str]]) -> List[str]: ... def reset_translations() -> None: ... def inotify_code_changed(): ... def code_changed(): ... def check_errors(fn: Callable) -> Callable: ... def raise_last_exception() -> None: ... def ensure_echo_on() -> None: ... def reloader_thread() -> None: ... def restart_with_reloader() -> int: ... def python_reloader(main_func: Any, args: Any, kwargs: Any) -> None: ... def main(main_func: Any, args: Optional[Any] = ..., kwargs: Optional[Any] = ...) -> None: ... def iter_all_python_module_files() -> Set[Path]: ... def iter_modules_and_files( modules: Iterable[types.ModuleType], extra_files: Iterable[Union[str, Path]] ) -> Set[Path]: ... def common_roots(paths: Iterable[Path]) -> Iterator[Path]: ... def sys_path_directories() -> Iterator[Path]: ... class BaseReloader: extra_files: Set[Path] directory_globs: Dict[Path, Set[str]] def __init__(self) -> None: ... def watch_dir(self, path: Union[str, Path], glob: str) -> None: ... def watch_file(self, path: Union[str, Path]) -> None: ... def watched_files(self, include_globs: bool = ...) -> Iterator[Path]: ... def wait_for_apps_ready(self, app_reg: Apps, django_main_thread: threading.Thread) -> bool: ... def run(self, django_main_thread: threading.Thread) -> None: ... def run_loop(self) -> None: ... def tick(self) -> Iterator[None]: ... @classmethod def check_availability(cls) -> bool: ... def notify_file_changed(self, path: Union[str, Path]) -> None: ... @property def should_stop(self) -> bool: ... def stop(self) -> None: ... class StatReloader(BaseReloader): SLEEP_TIME: int = ... def snapshot_files(self) -> Iterator[Tuple[Path, int]]: ... class WatchmanUnavailable(RuntimeError): ... class WatchmanReloader(BaseReloader): @property def client(self) -> Any: ... def watched_roots(self, watched_files: Iterable[Path]) -> Set[Path]: ... def update_watches(self) -> None: ... def request_processed(self, **kwargs: Any) -> None: ... def check_server_status(self, inner_ex: Optional[BaseException] = ...) -> bool: ... def get_reloader() -> BaseReloader: ... def start_django(reloader: BaseReloader, main_func: Callable, *args: Any, **kwargs: Any) -> None: ... def run_with_reloader(main_func: Callable, *args: Any, **kwargs: Any) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/utils/baseconv.pyi0000664000175000017500000000112100000000000026322 0ustar00davedave00000000000000from typing import Any, Tuple, Union BASE2_ALPHABET: str BASE16_ALPHABET: str BASE56_ALPHABET: str BASE36_ALPHABET: str BASE62_ALPHABET: str BASE64_ALPHABET: Any class BaseConverter: decimal_digits: str = ... sign: str = ... digits: str = ... def __init__(self, digits: str, sign: str = ...) -> None: ... def encode(self, i: int) -> str: ... def decode(self, s: str) -> int: ... def convert(self, number: Union[int, str], from_digits: str, to_digits: str, sign: str) -> Tuple[int, str]: ... base2: Any base16: Any base36: Any base56: Any base62: Any base64: Any ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/utils/cache.pyi0000664000175000017500000000247200000000000025577 0ustar00davedave00000000000000from typing import Any, Optional, Tuple from django.core.cache.backends.base import BaseCache from django.core.handlers.wsgi import WSGIRequest from django.http.response import HttpResponse, HttpResponseBase cc_delim_re: Any def patch_cache_control(response: HttpResponseBase, **kwargs: Any) -> None: ... def get_max_age(response: HttpResponse) -> Optional[int]: ... def set_response_etag(response: HttpResponseBase) -> HttpResponseBase: ... def get_conditional_response( request: WSGIRequest, etag: Optional[str] = ..., last_modified: Optional[int] = ..., response: Optional[HttpResponse] = ..., ) -> Optional[HttpResponse]: ... def patch_response_headers(response: HttpResponseBase, cache_timeout: float = ...) -> None: ... def add_never_cache_headers(response: HttpResponseBase) -> None: ... def patch_vary_headers(response: HttpResponseBase, newheaders: Tuple[str]) -> None: ... def has_vary_header(response: HttpResponse, header_query: str) -> bool: ... def get_cache_key( request: WSGIRequest, key_prefix: Optional[str] = ..., method: str = ..., cache: Optional[BaseCache] = ... ) -> Optional[str]: ... def learn_cache_key( request: WSGIRequest, response: HttpResponse, cache_timeout: Optional[float] = ..., key_prefix: Optional[str] = ..., cache: Optional[BaseCache] = ..., ) -> str: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/utils/crypto.pyi0000664000175000017500000000103700000000000026050 0ustar00davedave00000000000000from hmac import HMAC from typing import Callable, Optional, Union using_sysrandom: bool def salted_hmac(key_salt: str, value: Union[bytes, str], secret: Optional[Union[bytes, str]] = ...) -> HMAC: ... def get_random_string(length: int = ..., allowed_chars: str = ...) -> str: ... def constant_time_compare(val1: Union[bytes, str], val2: Union[bytes, str]) -> bool: ... def pbkdf2( password: Union[bytes, str], salt: Union[bytes, str], iterations: int, dklen: int = ..., digest: Optional[Callable] = ..., ) -> bytes: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/utils/datastructures.pyi0000664000175000017500000000510000000000000027600 0ustar00davedave00000000000000from typing import ( Any, Callable, Dict, Iterable, List, Mapping, MutableMapping, MutableSet, Tuple, TypeVar, Union, overload, Iterator, Optional, ) from typing_extensions import Literal _K = TypeVar("_K") _V = TypeVar("_V") class OrderedSet(MutableSet[_K]): dict: Dict[_K, None] = ... def __init__(self, iterable: Optional[Iterable[_K]] = ...) -> None: ... def __contains__(self, item: object) -> bool: ... def __iter__(self) -> Iterator[_K]: ... def __len__(self) -> int: ... def add(self, x: _K) -> None: ... def discard(self, item: _K) -> None: ... class MultiValueDictKeyError(KeyError): ... _D = TypeVar("_D", bound="MultiValueDict") class MultiValueDict(MutableMapping[_K, _V]): @overload def __init__(self, key_to_list_mapping: Mapping[_K, Optional[List[_V]]] = ...) -> None: ... @overload def __init__(self, key_to_list_mapping: Iterable[Tuple[_K, List[_V]]] = ...) -> None: ... def getlist(self, key: _K, default: Any = ...) -> List[_V]: ... def setlist(self, key: _K, list_: List[_V]) -> None: ... def setlistdefault(self, key: _K, default_list: Optional[List[_V]] = ...) -> List[_V]: ... def appendlist(self, key: _K, value: _V) -> None: ... def lists(self) -> Iterable[Tuple[_K, List[_V]]]: ... def dict(self) -> Dict[_K, Union[_V, List[_V]]]: ... def copy(self: _D) -> _D: ... # These overrides are needed to convince mypy that this isn't an abstract class def __delitem__(self, item: _K) -> None: ... def __getitem__(self, item: _K) -> Union[_V, Literal[[]]]: ... # type: ignore def __setitem__(self, k: _K, v: Union[_V, List[_V]]) -> None: ... def __len__(self) -> int: ... def __iter__(self) -> Iterator[_K]: ... class ImmutableList(Tuple[_V, ...]): warning: str = ... def __init__(self, *args: Any, warning: str = ..., **kwargs: Any) -> None: ... def complain(self, *wargs: Any, **kwargs: Any) -> None: ... class DictWrapper(Dict[str, _V]): func: Callable[[_V], _V] = ... prefix: str = ... @overload def __init__(self, data: Mapping[str, _V], func: Callable[[_V], _V], prefix: str) -> None: ... @overload def __init__(self, data: Iterable[Tuple[str, _V]], func: Callable[[_V], _V], prefix: str) -> None: ... _T = TypeVar("_T", bound="CaseInsensitiveMapping") class CaseInsensitiveMapping(Mapping): def __init__(self, data: Any) -> None: ... def __getitem__(self, key: str) -> Any: ... def __len__(self) -> int: ... def __iter__(self) -> Iterator[str]: ... def copy(self: _T) -> _T: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/utils/dateformat.pyi0000664000175000017500000000336600000000000026665 0ustar00davedave00000000000000from datetime import datetime, date from typing import Any, Optional, Union from django.utils.timezone import FixedOffset re_formatchars: Any re_escaped: Any class Formatter: def format(self, formatstr: str) -> str: ... class TimeFormat(Formatter): data: Union[datetime, str] = ... timezone: Optional[FixedOffset] = ... def __init__(self, obj: Union[datetime, str]) -> None: ... def a(self) -> str: ... def A(self) -> str: ... def B(self) -> None: ... def e(self) -> str: ... def f(self) -> Union[int, str]: ... def g(self) -> int: ... def G(self) -> int: ... def h(self) -> str: ... def H(self) -> str: ... def i(self) -> str: ... def O(self) -> str: ... def P(self) -> str: ... def s(self) -> str: ... def T(self) -> str: ... def u(self) -> str: ... def Z(self) -> Union[int, str]: ... class DateFormat(TimeFormat): data: Union[datetime, str] timezone: Optional[FixedOffset] year_days: Any = ... def b(self): ... def c(self) -> str: ... def d(self) -> str: ... def D(self): ... def E(self): ... def F(self): ... def I(self) -> str: ... def j(self) -> int: ... def l(self): ... def L(self) -> bool: ... def m(self) -> str: ... def M(self) -> str: ... def n(self) -> int: ... def N(self): ... def o(self) -> int: ... def r(self) -> str: ... def S(self) -> str: ... def t(self) -> str: ... def U(self) -> int: ... def w(self) -> int: ... def W(self) -> int: ... def y(self) -> str: ... def Y(self) -> int: ... def z(self) -> int: ... def format(value: Union[datetime, str, date], format_string: str) -> str: ... def time_format(value: Union[datetime, str], format_string: str) -> str: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/utils/dateparse.pyi0000664000175000017500000000065100000000000026501 0ustar00davedave00000000000000from datetime import date, datetime, time, timedelta from typing import Any, Optional date_re: Any time_re: Any datetime_re: Any standard_duration_re: Any iso8601_duration_re: Any postgres_interval_re: Any def parse_date(value: str) -> Optional[date]: ... def parse_time(value: str) -> Optional[time]: ... def parse_datetime(value: str) -> Optional[datetime]: ... def parse_duration(value: str) -> Optional[timedelta]: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/utils/dates.pyi0000664000175000017500000000026500000000000025632 0ustar00davedave00000000000000from typing import Dict WEEKDAYS: Dict[int, str] WEEKDAYS_ABBR: Dict[int, str] MONTHS: Dict[int, str] MONTHS_3: Dict[int, str] MONTHS_AP: Dict[int, str] MONTHS_ALT: Dict[int, str] ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/utils/datetime_safe.pyi0000664000175000017500000000052500000000000027323 0ustar00davedave00000000000000from datetime import date as real_date, datetime as real_datetime, time as real_time from typing import Union class date(real_date): ... class datetime(real_datetime): ... class time(real_time): ... def new_date(d: date) -> date: ... def new_datetime(d: date) -> datetime: ... def strftime(dt: Union[date, datetime], fmt: str) -> str: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/utils/deconstruct.pyi0000664000175000017500000000015100000000000027061 0ustar00davedave00000000000000from typing import Any, Optional def deconstructible(*args: Any, path: Optional[Any] = ...) -> Any: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/utils/decorators.pyi0000664000175000017500000000164700000000000026704 0ustar00davedave00000000000000from typing import Any, Callable, Iterable, Optional, Type, Union, TypeVar from django.utils.deprecation import MiddlewareMixin from django.views.generic.base import View _T = TypeVar("_T", bound=Union[View, Callable]) # Any callable class classonlymethod(classmethod): ... def method_decorator(decorator: Union[Callable, Iterable[Callable]], name: str = ...) -> Callable[[_T], _T]: ... def decorator_from_middleware_with_args(middleware_class: type) -> Callable: ... def decorator_from_middleware(middleware_class: type) -> Callable: ... def available_attrs(fn: Callable): ... def make_middleware_decorator(middleware_class: Type[MiddlewareMixin]) -> Callable: ... class classproperty: fget: Optional[Callable] = ... def __init__(self, method: Optional[Callable] = ...) -> None: ... def __get__(self, instance: Any, cls: Optional[type] = ...) -> Any: ... def getter(self, method: Callable) -> classproperty: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/utils/deprecation.pyi0000664000175000017500000000250100000000000027022 0ustar00davedave00000000000000from typing import Any, Callable, Optional, Type from django.http.request import HttpRequest from django.http.response import HttpResponse class RemovedInDjango30Warning(PendingDeprecationWarning): ... class RemovedInDjango31Warning(PendingDeprecationWarning): ... class RemovedInDjango40Warning(PendingDeprecationWarning): ... class RemovedInNextVersionWarning(DeprecationWarning): ... class warn_about_renamed_method: class_name: str = ... old_method_name: str = ... new_method_name: str = ... deprecation_warning: Type[DeprecationWarning] = ... def __init__( self, class_name: str, old_method_name: str, new_method_name: str, deprecation_warning: Type[DeprecationWarning] ) -> None: ... def __call__(self, f: Callable) -> Callable: ... class RenameMethodsBase(type): renamed_methods: Any = ... def __new__(cls, name: Any, bases: Any, attrs: Any): ... class DeprecationInstanceCheck(type): alternative: str deprecation_warning: Type[Warning] def __instancecheck__(self, instance: Any): ... GetResponseCallable = Callable[[HttpRequest], HttpResponse] class MiddlewareMixin: get_response: Optional[GetResponseCallable] = ... def __init__(self, get_response: Optional[GetResponseCallable] = ...) -> None: ... def __call__(self, request: HttpRequest) -> HttpResponse: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/utils/duration.pyi0000664000175000017500000000030600000000000026353 0ustar00davedave00000000000000from datetime import timedelta def duration_string(duration: timedelta) -> str: ... def duration_iso_string(duration: timedelta) -> str: ... def duration_microseconds(delta: timedelta) -> int: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/utils/encoding.pyi0000664000175000017500000000456000000000000026322 0ustar00davedave00000000000000import datetime from decimal import Decimal from typing import Any, TypeVar, overload, Union from django.utils.functional import Promise from typing_extensions import Literal class DjangoUnicodeDecodeError(UnicodeDecodeError): obj: bytes = ... def __init__(self, obj: bytes, *args: Any) -> None: ... _P = TypeVar("_P", bound=Promise) _S = TypeVar("_S", bound=str) _PT = TypeVar("_PT", None, int, float, Decimal, datetime.datetime, datetime.date, datetime.time) @overload def smart_text(s: _P, encoding: str = ..., strings_only: bool = ..., errors: str = ...) -> _P: ... @overload def smart_text(s: _PT, encoding: str = ..., strings_only: Literal[True] = ..., errors: str = ...) -> _PT: ... @overload def smart_text(s: _S, encoding: str = ..., strings_only: bool = ..., errors: str = ...) -> _S: ... @overload def smart_text(s: Any, encoding: str = ..., strings_only: bool = ..., errors: str = ...) -> str: ... def is_protected_type(obj: Any) -> bool: ... @overload def force_text(s: _PT, encoding: str = ..., strings_only: Literal[True] = ..., errors: str = ...) -> _PT: ... @overload def force_text(s: _S, encoding: str = ..., strings_only: bool = ..., errors: str = ...) -> _S: ... @overload def force_text(s: Any, encoding: str = ..., strings_only: bool = ..., errors: str = ...) -> str: ... @overload def smart_bytes(s: _P, encoding: str = ..., strings_only: bool = ..., errors: str = ...) -> _P: ... @overload def smart_bytes(s: _PT, encoding: str = ..., strings_only: Literal[True] = ..., errors: str = ...) -> _PT: ... @overload def smart_bytes(s: Any, encoding: str = ..., strings_only: bool = ..., errors: str = ...) -> bytes: ... @overload def force_bytes(s: _PT, encoding: str = ..., strings_only: Literal[True] = ..., errors: str = ...) -> _PT: ... @overload def force_bytes(s: Any, encoding: str = ..., strings_only: bool = ..., errors: str = ...) -> bytes: ... smart_str = smart_text force_str = force_text @overload def iri_to_uri(iri: None) -> None: ... @overload def iri_to_uri(iri: Union[str, Promise]) -> str: ... @overload def uri_to_iri(iri: None) -> None: ... @overload def uri_to_iri(iri: str) -> str: ... def escape_uri_path(path: str) -> str: ... def repercent_broken_unicode(path: bytes) -> bytes: ... @overload def filepath_to_uri(path: None) -> None: ... @overload def filepath_to_uri(path: str) -> str: ... def get_system_encoding() -> str: ... DEFAULT_LOCALE_ENCODING: Any ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/utils/feedgenerator.pyi0000664000175000017500000000516500000000000027350 0ustar00davedave00000000000000from datetime import date, datetime from typing import Any, Dict, List, Optional, Tuple, Union from xml.sax import ContentHandler # type: ignore def rfc2822_date(date: date) -> str: ... def rfc3339_date(date: date) -> str: ... def get_tag_uri(url: str, date: Optional[date]) -> str: ... class SyndicationFeed: feed: Dict[str, Any] = ... items: List[Dict[str, Any]] = ... def __init__( self, title: str, link: str, description: Optional[str], language: Optional[str] = ..., author_email: Optional[str] = ..., author_name: Optional[str] = ..., author_link: Optional[str] = ..., subtitle: Optional[str] = ..., categories: Optional[Tuple[str, str]] = ..., feed_url: Optional[str] = ..., feed_copyright: Optional[str] = ..., feed_guid: Optional[str] = ..., ttl: Optional[int] = ..., **kwargs: Any ) -> None: ... def add_item( self, title: str, link: str, description: str, author_email: Optional[str] = ..., author_name: Optional[str] = ..., author_link: Optional[str] = ..., pubdate: Optional[datetime] = ..., comments: None = ..., unique_id: Optional[str] = ..., unique_id_is_permalink: Optional[bool] = ..., categories: Optional[Tuple] = ..., item_copyright: Optional[str] = ..., ttl: None = ..., updateddate: Optional[datetime] = ..., enclosures: Optional[List[Enclosure]] = ..., **kwargs: Any ) -> None: ... def num_items(self): ... def root_attributes(self) -> Dict[Any, Any]: ... def add_root_elements(self, handler: ContentHandler) -> None: ... def item_attributes(self, item: Dict[str, Any]) -> Dict[Any, Any]: ... def add_item_elements(self, handler: ContentHandler, item: Dict[str, Any]) -> None: ... def write(self, outfile: Any, encoding: Any) -> None: ... def writeString(self, encoding: str) -> str: ... def latest_post_date(self) -> datetime: ... class Enclosure: length: Any mime_type: str url: str = ... def __init__(self, url: str, length: Union[int, str], mime_type: str) -> None: ... class RssFeed(SyndicationFeed): content_type: str = ... def write_items(self, handler: ContentHandler) -> None: ... def endChannelElement(self, handler: ContentHandler) -> None: ... class RssUserland091Feed(RssFeed): ... class Rss201rev2Feed(RssFeed): ... class Atom1Feed(SyndicationFeed): content_type: str = ... ns: str = ... def write_items(self, handler: ContentHandler) -> None: ... DefaultFeed = Rss201rev2Feed ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/utils/formats.pyi0000664000175000017500000000236700000000000026212 0ustar00davedave00000000000000from datetime import datetime, date, time from decimal import Decimal from typing import Any, Iterator, List, Optional, Union ISO_INPUT_FORMATS: Any FORMAT_SETTINGS: Any def reset_format_cache() -> None: ... def iter_format_modules(lang: str, format_module_path: Optional[Union[List[str], str]] = ...) -> Iterator[Any]: ... def get_format_modules(lang: Optional[str] = ..., reverse: bool = ...) -> List[Any]: ... def get_format(format_type: str, lang: Optional[str] = ..., use_l10n: Optional[bool] = ...) -> str: ... get_format_lazy: Any def date_format( value: Union[date, datetime, str], format: Optional[str] = ..., use_l10n: Optional[bool] = ... ) -> str: ... def time_format( value: Union[time, datetime, str], format: Optional[str] = ..., use_l10n: Optional[bool] = ... ) -> str: ... def number_format( value: Union[Decimal, float, str], decimal_pos: Optional[int] = ..., use_l10n: Optional[bool] = ..., force_grouping: bool = ..., ) -> str: ... def localize(value: Any, use_l10n: Optional[bool] = ...) -> Any: ... def localize_input( value: Optional[Union[datetime, Decimal, float, str]], default: Optional[str] = ... ) -> Optional[str]: ... def sanitize_separators(value: Union[Decimal, int, str]) -> Union[Decimal, int, str]: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/utils/functional.pyi0000664000175000017500000000360300000000000026673 0ustar00davedave00000000000000from typing import Any, Callable, Dict, List, Optional, Tuple, Type, Union, TypeVar, Generic, overload from functools import wraps as wraps # noqa: F401 from django.db.models.base import Model def curry(_curried_func: Any, *args: Any, **kwargs: Any): ... _T = TypeVar("_T") class cached_property(Generic[_T]): func: Callable[..., _T] = ... __doc__: Any = ... name: str = ... def __init__(self, func: Callable[..., _T], name: Optional[str] = ...): ... @overload def __get__(self, instance: None, cls: Type[Any] = ...) -> "cached_property[_T]": ... @overload def __get__(self, instance: object, cls: Type[Any] = ...) -> _T: ... class Promise: ... def lazy(func: Union[Callable, Type[str]], *resultclasses: Any) -> Callable: ... def lazystr(text: Any): ... def keep_lazy(*resultclasses: Any) -> Callable: ... def keep_lazy_text(func: Callable) -> Callable: ... empty: Any def new_method_proxy(func: Any): ... class LazyObject: def __init__(self) -> None: ... __getattr__: Any = ... def __setattr__(self, name: str, value: Any) -> None: ... def __delattr__(self, name: str) -> None: ... def __reduce__(self) -> Tuple[Callable, Tuple[Model]]: ... def __copy__(self): ... def __deepcopy__(self, memo: Any): ... __bytes__: Any = ... __bool__: Any = ... __dir__: Any = ... __class__: Any = ... __ne__: Any = ... __hash__: Any = ... __getitem__: Any = ... __setitem__: Any = ... __delitem__: Any = ... __iter__: Any = ... __len__: Any = ... __contains__: Any = ... def unpickle_lazyobject(wrapped: Model) -> Model: ... class SimpleLazyObject(LazyObject): def __init__(self, func: Callable) -> None: ... def __copy__(self) -> List[int]: ... def __deepcopy__(self, memo: Dict[Any, Any]) -> List[int]: ... def partition(predicate: Callable, values: List[Model]) -> Tuple[List[Model], List[Model]]: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/utils/hashable.pyi0000664000175000017500000000010200000000000026267 0ustar00davedave00000000000000from typing import Any def make_hashable(value: Any) -> Any: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/utils/html.pyi0000664000175000017500000000252600000000000025500 0ustar00davedave00000000000000from html.parser import HTMLParser from typing import Any, Iterator, List, Optional, Tuple, Union from django.utils.safestring import SafeText TRAILING_PUNCTUATION_CHARS: str WRAPPING_PUNCTUATION: Any DOTS: Any unencoded_ampersands_re: Any word_split_re: Any simple_url_re: Any simple_url_2_re: Any def escape(text: Any) -> SafeText: ... def escapejs(value: Any) -> SafeText: ... def json_script(value: Any, element_id: str) -> SafeText: ... def conditional_escape(text: Any) -> str: ... def format_html(format_string: str, *args: Any, **kwargs: Any) -> SafeText: ... def format_html_join( sep: str, format_string: str, args_generator: Union[Iterator[Any], List[Tuple[str]]] ) -> SafeText: ... def linebreaks(value: Any, autoescape: bool = ...) -> str: ... class MLStripper(HTMLParser): fed: Any = ... def __init__(self) -> None: ... def handle_data(self, d: str) -> None: ... def handle_entityref(self, name: str) -> None: ... def handle_charref(self, name: str) -> None: ... def get_data(self) -> str: ... def strip_tags(value: str) -> str: ... def strip_spaces_between_tags(value: str) -> str: ... def smart_urlquote(url: str) -> str: ... def urlize(text: str, trim_url_limit: Optional[int] = ..., nofollow: bool = ..., autoescape: bool = ...) -> str: ... def avoid_wrapping(value: str) -> str: ... def html_safe(klass: Any): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/utils/http.pyi0000664000175000017500000000301000000000000025500 0ustar00davedave00000000000000from typing import Any, Iterable, List, Optional, Tuple, Union ETAG_MATCH: Any MONTHS: Any RFC1123_DATE: Any RFC850_DATE: Any ASCTIME_DATE: Any RFC3986_GENDELIMS: str RFC3986_SUBDELIMS: str FIELDS_MATCH: Any def urlquote(url: str, safe: str = ...) -> str: ... def urlquote_plus(url: str, safe: str = ...) -> str: ... def urlunquote(quoted_url: str) -> str: ... def urlunquote_plus(quoted_url: str) -> str: ... def urlencode(query: Any, doseq: bool = ...) -> str: ... def cookie_date(epoch_seconds: Optional[float] = ...) -> str: ... def http_date(epoch_seconds: Optional[float] = ...) -> str: ... def parse_http_date(date: str) -> int: ... def parse_http_date_safe(date: str) -> Optional[int]: ... def base36_to_int(s: str) -> int: ... def int_to_base36(i: int) -> str: ... def urlsafe_base64_encode(s: bytes) -> str: ... def urlsafe_base64_decode(s: Union[bytes, str]) -> bytes: ... def parse_etags(etag_str: str) -> List[str]: ... def quote_etag(etag_str: str) -> str: ... def is_same_domain(host: str, pattern: str) -> bool: ... def url_has_allowed_host_and_scheme( url: Optional[str], allowed_hosts: Optional[Union[str, Iterable[str]]], require_https: bool = ... ) -> bool: ... def is_safe_url( url: Optional[str], allowed_hosts: Optional[Union[str, Iterable[str]]], require_https: bool = ... ) -> bool: ... def limited_parse_qsl( qs: str, keep_blank_values: bool = ..., encoding: str = ..., errors: str = ..., fields_limit: Optional[int] = ... ) -> List[Tuple[str, str]]: ... def escape_leading_slashes(url: str) -> str: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/utils/inspect.pyi0000664000175000017500000000060700000000000026177 0ustar00davedave00000000000000from typing import Callable, List, Tuple def get_func_args(func: Callable) -> List[str]: ... def get_func_full_args(func: Callable) -> List[Tuple[str]]: ... def func_accepts_kwargs(func: Callable) -> bool: ... def func_accepts_var_args(func: Callable) -> bool: ... def method_has_no_args(meth: Callable) -> bool: ... def func_supports_parameter(func: Callable, parameter: str) -> bool: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/utils/ipv6.pyi0000664000175000017500000000025000000000000025410 0ustar00davedave00000000000000from typing import Any def clean_ipv6_address(ip_str: Any, unpack_ipv4: bool = ..., error_message: Any = ...): ... def is_valid_ipv6_address(ip_str: str) -> bool: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/utils/itercompat.pyi0000664000175000017500000000007500000000000026700 0ustar00davedave00000000000000from typing import Any def is_iterable(x: Any) -> bool: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/utils/jslex.pyi0000664000175000017500000000135400000000000025657 0ustar00davedave00000000000000from typing import Any, Dict, Iterator, List, Optional, Tuple class Tok: num: int = ... id: int = ... name: str = ... regex: str = ... next: Optional[str] = ... def __init__(self, name: str, regex: str, next: Optional[str] = ...) -> None: ... def literals(choices: str, prefix: str = ..., suffix: str = ...) -> str: ... class Lexer: regexes: Any = ... toks: Any = ... state: Any = ... def __init__(self, states: Dict[str, List[Tok]], first: str) -> None: ... def lex(self, text: str) -> Iterator[Tuple[str, str]]: ... class JsLexer(Lexer): both_before: Any = ... both_after: Any = ... states: Any = ... def __init__(self) -> None: ... def prepare_js_for_gettext(js: str) -> str: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/utils/log.pyi0000664000175000017500000000273500000000000025317 0ustar00davedave00000000000000import logging.config from logging import LogRecord from typing import Any, Callable, Dict, Optional, Union from django.core.management.color import Style request_logger: Any DEFAULT_LOGGING: Any def configure_logging(logging_config: str, logging_settings: Dict[str, Any]) -> None: ... class AdminEmailHandler(logging.Handler): include_html: bool = ... email_backend: Optional[str] = ... def __init__(self, include_html: bool = ..., email_backend: Optional[str] = ...) -> None: ... def send_mail(self, subject: str, message: str, *args: Any, **kwargs: Any) -> None: ... def connection(self) -> Any: ... def format_subject(self, subject: str) -> str: ... class CallbackFilter(logging.Filter): callback: Callable = ... def __init__(self, callback: Callable) -> None: ... def filter(self, record: Union[str, LogRecord]) -> bool: ... class RequireDebugFalse(logging.Filter): def filter(self, record: Union[str, LogRecord]) -> bool: ... class RequireDebugTrue(logging.Filter): def filter(self, record: Union[str, LogRecord]) -> bool: ... class ServerFormatter(logging.Formatter): datefmt: None style: Style = ... def __init__(self, *args: Any, **kwargs: Any) -> None: ... def uses_server_time(self) -> bool: ... def log_response( message: str, *args: Any, response: Optional[Any] = ..., request: Optional[Any] = ..., logger: Any = ..., level: Optional[Any] = ..., exc_info: Optional[Any] = ... ) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/utils/lorem_ipsum.pyi0000664000175000017500000000037000000000000027062 0ustar00davedave00000000000000from typing import Any, List COMMON_P: str WORDS: Any COMMON_WORDS: Any def sentence() -> str: ... def paragraph() -> str: ... def paragraphs(count: int, common: bool = ...) -> List[str]: ... def words(count: int, common: bool = ...) -> str: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/utils/module_loading.pyi0000664000175000017500000000036700000000000027517 0ustar00davedave00000000000000from typing import Any def import_string(dotted_path: str) -> Any: ... def autodiscover_modules(*args: Any, **kwargs: Any) -> None: ... def module_has_submodule(package: Any, module_name: str) -> bool: ... def module_dir(module: Any) -> str: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/utils/numberformat.pyi0000664000175000017500000000053000000000000027226 0ustar00davedave00000000000000from decimal import Decimal from typing import Optional, Sequence, Union def format( number: Union[Decimal, float, str], decimal_sep: str, decimal_pos: Optional[int] = ..., grouping: Union[int, Sequence[int]] = ..., thousand_sep: str = ..., force_grouping: bool = ..., use_l10n: Optional[bool] = ..., ) -> str: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/utils/regex_helper.pyi0000664000175000017500000000122200000000000027175 0ustar00davedave00000000000000from typing import Any, Iterator, List, Optional, Tuple, Type, Union ESCAPE_MAPPINGS: Any class Choice(list): ... class Group(list): ... class NonCapture(list): ... def normalize(pattern: str) -> List[Tuple[str, List[str]]]: ... def next_char(input_iter: Any) -> None: ... def walk_to_end(ch: str, input_iter: Iterator[Any]) -> None: ... def get_quantifier(ch: str, input_iter: Iterator[Any]) -> Tuple[int, Optional[str]]: ... def contains(source: Union[Group, NonCapture, str], inst: Type[Group]) -> bool: ... def flatten_result( source: Optional[Union[List[Union[Choice, Group, str]], Group, NonCapture]] ) -> Tuple[List[str], List[List[str]]]: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/utils/safestring.pyi0000664000175000017500000000116500000000000026677 0ustar00davedave00000000000000from typing import TypeVar, overload, Callable, Any _SD = TypeVar("_SD", bound="SafeData") class SafeData: def __html__(self: _SD) -> _SD: ... class SafeText(str, SafeData): @overload def __add__(self, rhs: SafeText) -> SafeText: ... @overload def __add__(self, rhs: str) -> str: ... @overload def __iadd__(self, rhs: SafeText) -> SafeText: ... @overload def __iadd__(self, rhs: str) -> str: ... SafeString = SafeText _C = TypeVar("_C", bound=Callable) @overload def mark_safe(s: _SD) -> _SD: ... @overload def mark_safe(s: _C) -> _C: ... @overload def mark_safe(s: Any) -> SafeText: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/utils/six.pyi0000664000175000017500000000652000000000000025335 0ustar00davedave00000000000000from __future__ import print_function import types import typing import unittest from typing import ( Any, AnyStr, Callable, Dict, ItemsView, Iterable, KeysView, Mapping, NoReturn, Optional, Pattern, Text, Tuple, Type, TypeVar, Union, ValuesView, overload, ) # Exports _T = TypeVar("_T") _K = TypeVar("_K") _V = TypeVar("_V") # TODO make constant, then move this stub to 2and3 # https://github.com/python/typeshed/issues/17 PY2 = False PY3 = True PY34 = ... # type: bool string_types = (str,) integer_types = (int,) class_types = (type,) text_type = str binary_type = bytes MAXSIZE = ... # type: int # def add_move # def remove_move def callable(obj: object) -> bool: ... def get_unbound_function(unbound: types.FunctionType) -> types.FunctionType: ... def create_bound_method(func: types.FunctionType, obj: object) -> types.MethodType: ... def create_unbound_method(func: types.FunctionType, cls: type) -> types.FunctionType: ... Iterator = object def get_method_function(meth: types.MethodType) -> types.FunctionType: ... def get_method_self(meth: types.MethodType) -> Optional[object]: ... def get_function_closure(fun: types.FunctionType) -> Optional[Tuple[types._Cell, ...]]: ... def get_function_code(fun: types.FunctionType) -> types.CodeType: ... def get_function_defaults(fun: types.FunctionType) -> Optional[Tuple[Any, ...]]: ... def get_function_globals(fun: types.FunctionType) -> Dict[str, Any]: ... def iterkeys(d: Mapping[_K, _V]) -> typing.Iterator[_K]: ... def itervalues(d: Mapping[_K, _V]) -> typing.Iterator[_V]: ... def iteritems(d: Mapping[_K, _V]) -> typing.Iterator[Tuple[_K, _V]]: ... # def iterlists def viewkeys(d: Mapping[_K, _V]) -> KeysView[_K]: ... def viewvalues(d: Mapping[_K, _V]) -> ValuesView[_V]: ... def viewitems(d: Mapping[_K, _V]) -> ItemsView[_K, _V]: ... def b(s: str) -> binary_type: ... def u(s: str) -> text_type: ... unichr = chr def int2byte(i: int) -> bytes: ... def byte2int(bs: binary_type) -> int: ... def indexbytes(buf: binary_type, i: int) -> int: ... def iterbytes(buf: binary_type) -> typing.Iterator[int]: ... def assertCountEqual( self: unittest.TestCase, first: Iterable[_T], second: Iterable[_T], msg: Optional[str] = ... ) -> None: ... @overload def assertRaisesRegex(self: unittest.TestCase, msg: Optional[str] = ...) -> Any: ... @overload def assertRaisesRegex(self: unittest.TestCase, callable_obj: Callable[..., Any], *args: Any, **kwargs: Any) -> Any: ... def assertRegex( self: unittest.TestCase, text: AnyStr, expected_regex: Union[AnyStr, Pattern[AnyStr]], msg: Optional[str] = ... ) -> None: ... exec_ = exec def reraise( tp: Optional[Type[BaseException]], value: Optional[BaseException], tb: Optional[types.TracebackType] = ... ) -> NoReturn: ... def raise_from(value: Union[BaseException, Type[BaseException]], from_value: Optional[BaseException]) -> NoReturn: ... print_ = print def with_metaclass(meta: type, *bases: type) -> type: ... def add_metaclass(metaclass: type) -> Callable[[_T], _T]: ... def ensure_binary(s: Union[bytes, Text], encoding: str = ..., errors: str = ...) -> bytes: ... def ensure_str(s: Union[bytes, Text], encoding: str = ..., errors: str = ...) -> str: ... def ensure_text(s: Union[bytes, Text], encoding: str = ..., errors: str = ...) -> Text: ... def python_2_unicode_compatible(klass: _T) -> _T: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/utils/termcolors.pyi0000664000175000017500000000100500000000000026714 0ustar00davedave00000000000000from typing import Any, Callable, Dict, Optional, Tuple, Union, Sequence color_names: Any foreground: Any background: Any RESET: str opt_dict: Any def colorize(text: Optional[str] = ..., opts: Sequence[str] = ..., **kwargs: Any) -> str: ... def make_style(opts: Tuple = ..., **kwargs: Any) -> Callable: ... NOCOLOR_PALETTE: str DARK_PALETTE: str LIGHT_PALETTE: str PALETTES: Any DEFAULT_PALETTE: str = ... def parse_color_setting(config_string: str) -> Optional[Dict[str, Dict[str, Union[Tuple[str], str]]]]: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/utils/text.pyi0000664000175000017500000000305700000000000025520 0ustar00davedave00000000000000from typing import Any, Iterable, Iterator, List, Optional, Union from django.db.models.base import Model from django.utils.functional import SimpleLazyObject from django.utils.safestring import SafeText def capfirst(x: Optional[str]) -> Optional[str]: ... re_words: Any re_chars: Any re_tag: Any re_newlines: Any re_camel_case: Any def wrap(text: str, width: int) -> str: ... class Truncator(SimpleLazyObject): def __init__(self, text: Union[Model, str]) -> None: ... def add_truncation_text(self, text: str, truncate: Optional[str] = ...) -> str: ... def chars(self, num: int, truncate: Optional[str] = ..., html: bool = ...) -> str: ... def words(self, num: int, truncate: Optional[str] = ..., html: bool = ...) -> str: ... def get_valid_filename(s: str) -> str: ... def get_text_list(list_: List[str], last_word: str = ...) -> str: ... def normalize_newlines(text: str) -> str: ... def phone2numeric(phone: str) -> str: ... def compress_string(s: bytes) -> bytes: ... class StreamingBuffer: vals: List[bytes] = ... def __init__(self) -> None: ... def write(self, val: bytes) -> None: ... def read(self) -> bytes: ... def flush(self): ... def close(self): ... def compress_sequence(sequence: Iterable[bytes]) -> Iterator[bytes]: ... smart_split_re: Any def smart_split(text: str) -> Iterator[str]: ... def unescape_entities(text: str) -> str: ... def unescape_string_literal(s: str) -> str: ... def slugify(value: str, allow_unicode: bool = ...) -> SafeText: ... def camel_case_to_spaces(value: str) -> str: ... format_lazy: Any ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/utils/timesince.pyi0000664000175000017500000000055200000000000026511 0ustar00davedave00000000000000from datetime import date from typing import Any, Optional, Dict TIME_STRINGS: Dict[str, str] TIMESINCE_CHUNKS: Any def timesince( d: date, now: Optional[date] = ..., reversed: bool = ..., time_strings: Optional[Dict[str, str]] = ... ) -> str: ... def timeuntil(d: date, now: Optional[date] = ..., time_strings: Optional[Dict[str, str]] = ...) -> str: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/utils/timezone.pyi0000664000175000017500000000523200000000000026363 0ustar00davedave00000000000000import types from contextlib import ContextDecorator from datetime import date, datetime as datetime, time, timedelta as timedelta, tzinfo as tzinfo, timezone from typing import Optional, Union, Type from pytz import BaseTzInfo _AnyTime = Union[time, datetime] class UTC(tzinfo): def utcoffset(self, dt: Optional[datetime]) -> Optional[timedelta]: ... def tzname(self, dt: Optional[datetime]) -> str: ... def dst(self, dt: Optional[datetime]) -> Optional[timedelta]: ... class FixedOffset(tzinfo): def __init__(self, offset: Optional[int] = ..., name: Optional[str] = ...) -> None: ... def utcoffset(self, dt: Optional[datetime]) -> Optional[timedelta]: ... def tzname(self, dt: Optional[datetime]) -> str: ... def dst(self, dt: Optional[Union[datetime, timedelta]]) -> Optional[timedelta]: ... class ReferenceLocalTimezone(tzinfo): STDOFFSET: timedelta = ... DSTOFFSET: timedelta = ... DSTDIFF: timedelta = ... def __init__(self) -> None: ... def utcoffset(self, dt: Optional[datetime]) -> Optional[timedelta]: ... def dst(self, dt: Optional[datetime]) -> Optional[timedelta]: ... def tzname(self, dt: Optional[datetime]) -> str: ... class LocalTimezone(ReferenceLocalTimezone): def tzname(self, dt: Optional[datetime]) -> str: ... utc: UTC = ... def get_fixed_timezone(offset: Union[timedelta, int]) -> timezone: ... def get_default_timezone() -> BaseTzInfo: ... def get_default_timezone_name() -> str: ... # Strictly speaking, it is possible to activate() a non-pytz timezone, # in which case BaseTzInfo is incorrect. However, this is unlikely, # so we use it anyway, to keep things ergonomic for most users. def get_current_timezone() -> BaseTzInfo: ... def get_current_timezone_name() -> str: ... def activate(timezone: Union[tzinfo, str]) -> None: ... def deactivate() -> None: ... class override(ContextDecorator): timezone: tzinfo = ... old_timezone: Optional[tzinfo] = ... def __init__(self, timezone: Optional[Union[str, tzinfo]]) -> None: ... def __enter__(self) -> None: ... def __exit__( self, exc_type: Type[BaseException], exc_value: BaseException, traceback: types.TracebackType ) -> None: ... def localtime(value: Optional[_AnyTime] = ..., timezone: Optional[tzinfo] = ...) -> datetime: ... def localdate(value: Optional[_AnyTime] = ..., timezone: Optional[tzinfo] = ...) -> date: ... def now() -> datetime: ... def is_aware(value: _AnyTime) -> bool: ... def is_naive(value: _AnyTime) -> bool: ... def make_aware(value: _AnyTime, timezone: Optional[tzinfo] = ..., is_dst: Optional[bool] = ...) -> datetime: ... def make_naive(value: _AnyTime, timezone: Optional[tzinfo] = ...) -> datetime: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/utils/topological_sort.pyi0000664000175000017500000000045100000000000030112 0ustar00davedave00000000000000from typing import Any, Dict, Iterator, Set, Container, List class CyclicDependencyError(ValueError): ... def topological_sort_as_sets(dependency_graph: Dict[Any, Any]) -> Iterator[Set[Any]]: ... def stable_topological_sort(l: Container[Any], dependency_graph: Dict[Any, Any]) -> List[Any]: ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4103792 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/utils/translation/0000775000175000017500000000000000000000000026342 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/utils/translation/__init__.pyi0000664000175000017500000000427000000000000030627 0ustar00davedave00000000000000import functools from contextlib import ContextDecorator from typing import Any, Optional, Callable from django.core.handlers.wsgi import WSGIRequest LANGUAGE_SESSION_KEY: str class TranslatorCommentWarning(SyntaxWarning): ... class Trans: activate: Callable check_for_language: functools._lru_cache_wrapper deactivate: Callable deactivate_all: Callable get_language: Callable get_language_bidi: Callable get_language_from_path: Callable get_language_from_request: Callable gettext: Callable gettext_noop: Callable ngettext: Callable npgettext: Callable pgettext: Callable def __getattr__(self, real_name: Any): ... def gettext_noop(message: str) -> str: ... ugettext_noop = gettext_noop def gettext(message: str) -> str: ... ugettext = gettext def ngettext(singular: str, plural: str, number: float) -> str: ... ungettext = ngettext def pgettext(context: str, message: str) -> str: ... def npgettext(context: str, singular: str, plural: str, number: int) -> str: ... gettext_lazy = gettext ugettext_lazy = ugettext pgettext_lazy = pgettext ngettext_lazy = ngettext ungettext_lazy = ungettext npgettext_lazy = npgettext def activate(language: str) -> None: ... def deactivate() -> None: ... class override(ContextDecorator): language: Optional[str] = ... deactivate: bool = ... def __init__(self, language: Optional[str], deactivate: bool = ...) -> None: ... old_language: Optional[str] = ... def __enter__(self) -> None: ... def __exit__(self, exc_type: None, exc_value: None, traceback: None) -> None: ... def get_language() -> Optional[str]: ... def get_language_from_path(path: str) -> Optional[str]: ... def get_language_bidi() -> bool: ... def check_for_language(lang_code: Optional[str]) -> bool: ... def to_language(locale: str) -> str: ... def to_locale(language: str) -> str: ... def get_language_from_request(request: WSGIRequest, check_path: bool = ...) -> str: ... def templatize(src: str, **kwargs: Any) -> str: ... def deactivate_all() -> None: ... def get_supported_language_variant(lang_code: str, strict: bool = ...) -> str: ... def get_language_info(lang_code: str) -> Any: ... from . import trans_real as trans_real ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/utils/translation/reloader.pyi0000664000175000017500000000045300000000000030664 0ustar00davedave00000000000000from pathlib import Path from typing import Any, Optional from django.utils.autoreload import BaseReloader def watch_for_translation_changes(sender: BaseReloader, **kwargs: Any) -> None: ... def translation_file_changed(sender: Optional[BaseReloader], file_path: Path, **kwargs: Any) -> bool: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/utils/translation/template.pyi0000664000175000017500000000035300000000000030701 0ustar00davedave00000000000000from typing import Any dot_re: Any def blankout(src: str, char: str) -> str: ... context_re: Any inline_re: Any block_re: Any endblock_re: Any plural_re: Any constant_re: Any def templatize(src: str, origin: str = ...) -> str: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/utils/translation/trans_null.pyi0000664000175000017500000000133100000000000031244 0ustar00davedave00000000000000from typing import Any def gettext(message: Any): ... gettext_noop = gettext gettext_lazy = gettext _ = gettext def ngettext(singular: str, plural: str, number: int) -> str: ... ngettext_lazy = ngettext def pgettext(context: Any, message: Any): ... def npgettext(context: Any, singular: Any, plural: Any, number: Any): ... def activate(x: Any): ... def deactivate(): ... deactivate_all = deactivate def get_language(): ... def get_language_bidi() -> bool: ... def check_for_language(x: str) -> bool: ... def get_language_from_request(request: None, check_path: bool = ...) -> str: ... def get_language_from_path(request: str) -> None: ... def get_supported_language_variant(lang_code: str, strict: bool = ...) -> str: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/utils/translation/trans_real.pyi0000664000175000017500000000342700000000000031225 0ustar00davedave00000000000000import gettext as gettext_module from collections import OrderedDict from gettext import NullTranslations from typing import Any, List, Optional, Tuple, Callable from django.core.handlers.wsgi import WSGIRequest CONTEXT_SEPARATOR: str accept_language_re: Any language_code_re: Any language_code_prefix_re: Any def reset_cache(**kwargs: Any) -> None: ... class DjangoTranslation(gettext_module.GNUTranslations): domain: str = ... plural: Callable = ... def __init__(self, language: str, domain: Optional[str] = ..., localedirs: Optional[List[str]] = ...) -> None: ... def merge(self, other: NullTranslations) -> None: ... def language(self): ... def to_language(self) -> str: ... def translation(language: str) -> DjangoTranslation: ... def activate(language: str) -> None: ... def deactivate() -> None: ... def deactivate_all() -> None: ... def get_language() -> Optional[str]: ... def get_language_bidi() -> bool: ... def catalog(): ... def gettext(message: str) -> str: ... def pgettext(context: str, message: str) -> str: ... def gettext_noop(message: str) -> str: ... def do_ntranslate(singular: str, plural: str, number: float, translation_function: str) -> str: ... def ngettext(singular: str, plural: str, number: float) -> str: ... def npgettext(context: str, singular: str, plural: str, number: int) -> str: ... def all_locale_paths() -> List[str]: ... def check_for_language(lang_code: Optional[str]) -> bool: ... def get_languages() -> OrderedDict: ... def get_supported_language_variant(lang_code: Optional[str], strict: bool = ...) -> str: ... def get_language_from_path(path: str, strict: bool = ...) -> Optional[str]: ... def get_language_from_request(request: WSGIRequest, check_path: bool = ...) -> str: ... def parse_accept_lang_header(lang_string: str) -> Tuple: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/utils/tree.pyi0000664000175000017500000000143700000000000025473 0ustar00davedave00000000000000from typing import Any, Dict, Iterable, Optional, Tuple, Union, Sequence, List from django.db.models.sql.where import NothingNode _NodeChildren = Iterable[Union["Node", NothingNode, Sequence[Any]]] class Node: children: List[Any] default: Any = ... connector: str = ... negated: bool = ... def __init__( self, children: Optional[_NodeChildren] = ..., connector: Optional[str] = ..., negated: bool = ... ) -> None: ... def __deepcopy__(self, memodict: Dict[Any, Any]) -> Node: ... def __len__(self) -> int: ... def __bool__(self) -> bool: ... def __contains__(self, other: Tuple[str, int]) -> bool: ... def __hash__(self) -> int: ... def add(self, data: Any, conn_type: str, squash: bool = ...) -> Any: ... def negate(self) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/utils/version.pyi0000664000175000017500000000100400000000000026207 0ustar00davedave00000000000000from typing import Any, Optional, Tuple PY36: Any PY37: Any PY38: Any PY39: Any def get_version(version: Optional[Tuple[int, int, int, str, int]] = ...) -> str: ... def get_main_version(version: Tuple[int, int, int, str, int] = ...) -> str: ... def get_complete_version(version: Optional[Tuple[int, int, int, str, int]] = ...) -> Tuple[int, int, int, str, int]: ... def get_docs_version(version: None = ...) -> str: ... def get_git_changeset(): ... def get_version_tuple(version: str) -> Tuple[int, int, int]: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/utils/xmlutils.pyi0000664000175000017500000000066100000000000026413 0ustar00davedave00000000000000from typing import Dict, Optional from xml.sax.saxutils import XMLGenerator class UnserializableContentError(ValueError): ... class SimplerXMLGenerator(XMLGenerator): def addQuickElement( self, name: str, contents: Optional[str] = ..., attrs: Optional[Dict[str, str]] = ... ) -> None: ... def characters(self, content: str) -> None: ... def startElement(self, name: str, attrs: Dict[str, str]) -> None: ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4103792 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/views/0000775000175000017500000000000000000000000024001 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/views/__init__.pyi0000664000175000017500000000004700000000000026264 0ustar00davedave00000000000000from .generic.base import View as View ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/views/csrf.pyi0000664000175000017500000000042200000000000025457 0ustar00davedave00000000000000from django.http.request import HttpRequest from django.http.response import HttpResponseForbidden CSRF_FAILURE_TEMPLATE: str CSRF_FAILURE_TEMPLATE_NAME: str def csrf_failure(request: HttpRequest, reason: str = ..., template_name: str = ...) -> HttpResponseForbidden: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/views/debug.pyi0000664000175000017500000000533500000000000025620 0ustar00davedave00000000000000from importlib.abc import SourceLoader from types import TracebackType from typing import Any, Callable, Dict, List, MutableMapping, Optional, Type, Union from django.http.request import HttpRequest, QueryDict from django.http.response import Http404, HttpResponse from django.utils.safestring import SafeText DEBUG_ENGINE: Any HIDDEN_SETTINGS: Any CLEANSED_SUBSTITUTE: str CURRENT_DIR: Any class CallableSettingWrapper: def __init__(self, callable_setting: Union[Callable, Type[Any]]) -> None: ... def cleanse_setting(key: Union[int, str], value: Any) -> Any: ... def get_safe_settings() -> Dict[str, Any]: ... def technical_500_response(request: Any, exc_type: Any, exc_value: Any, tb: Any, status_code: int = ...): ... def get_default_exception_reporter_filter() -> ExceptionReporterFilter: ... def get_exception_reporter_filter(request: Optional[HttpRequest]) -> ExceptionReporterFilter: ... class ExceptionReporterFilter: def get_post_parameters(self, request: Any): ... def get_traceback_frame_variables(self, request: Any, tb_frame: Any): ... class SafeExceptionReporterFilter(ExceptionReporterFilter): def is_active(self, request: Optional[HttpRequest]) -> bool: ... def get_cleansed_multivaluedict(self, request: HttpRequest, multivaluedict: QueryDict) -> QueryDict: ... def get_post_parameters(self, request: Optional[HttpRequest]) -> MutableMapping[str, Any]: ... def cleanse_special_types(self, request: Optional[HttpRequest], value: Any) -> Any: ... def get_traceback_frame_variables(self, request: Any, tb_frame: Any): ... class ExceptionReporter: request: Optional[HttpRequest] = ... filter: ExceptionReporterFilter = ... exc_type: Optional[Type[BaseException]] = ... exc_value: Optional[str] = ... tb: Optional[TracebackType] = ... is_email: bool = ... template_info: None = ... template_does_not_exist: bool = ... postmortem: None = ... def __init__( self, request: Optional[HttpRequest], exc_type: Optional[Type[BaseException]], exc_value: Optional[Union[str, BaseException]], tb: Optional[TracebackType], is_email: bool = ..., ) -> None: ... def get_traceback_data(self) -> Dict[str, Any]: ... def get_traceback_html(self) -> SafeText: ... def get_traceback_text(self) -> SafeText: ... def get_traceback_frames(self) -> List[Any]: ... def _get_lines_from_file( self, filename: str, lineno: int, context_lines: int, loader: Optional[SourceLoader] = ..., module_name: Optional[str] = ..., ): ... def technical_404_response(request: HttpRequest, exception: Http404) -> HttpResponse: ... def default_urlconf(request: Optional[HttpResponse]) -> HttpResponse: ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4103792 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/views/decorators/0000775000175000017500000000000000000000000026146 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/views/decorators/__init__.pyi0000664000175000017500000000000000000000000030416 0ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/views/decorators/cache.pyi0000664000175000017500000000045700000000000027742 0ustar00davedave00000000000000from typing import Any, Callable, Optional, TypeVar _F = TypeVar("_F", bound=Callable[..., Any]) def cache_page(timeout: float, *, cache: Optional[Any] = ..., key_prefix: Optional[Any] = ...) -> Callable: ... def cache_control(**kwargs: Any) -> Callable: ... def never_cache(view_func: _F) -> _F: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/views/decorators/clickjacking.pyi0000664000175000017500000000036700000000000031313 0ustar00davedave00000000000000from typing import Callable, TypeVar, Any _F = TypeVar("_F", bound=Callable[..., Any]) def xframe_options_deny(view_func: _F) -> _F: ... def xframe_options_sameorigin(view_func: _F) -> _F: ... def xframe_options_exempt(view_func: _F) -> _F: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/views/decorators/csrf.pyi0000664000175000017500000000073500000000000027633 0ustar00davedave00000000000000from typing import Any, Callable, TypeVar from django.middleware.csrf import CsrfViewMiddleware csrf_protect: Any class _EnsureCsrfToken(CsrfViewMiddleware): ... requires_csrf_token: Any class _EnsureCsrfCookie(CsrfViewMiddleware): get_response: None def process_view(self, request: Any, callback: Any, callback_args: Any, callback_kwargs: Any): ... ensure_csrf_cookie: Any _F = TypeVar("_F", bound=Callable[..., Any]) def csrf_exempt(view_func: _F) -> _F: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/views/decorators/debug.pyi0000664000175000017500000000023500000000000027757 0ustar00davedave00000000000000from typing import Any, Callable def sensitive_variables(*variables: Any) -> Callable: ... def sensitive_post_parameters(*parameters: Any) -> Callable: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/views/decorators/gzip.pyi0000664000175000017500000000020100000000000027633 0ustar00davedave00000000000000from typing import Callable, TypeVar, Any _C = TypeVar("_C", bound=Callable[..., Any]) def gzip_page(view_func: _C) -> _C: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/views/decorators/http.pyi0000664000175000017500000000110000000000000027640 0ustar00davedave00000000000000from typing import Any, Callable, List, Optional, TypeVar _F = TypeVar("_F", bound=Callable[..., Any]) def conditional_page(_F) -> _F: ... def require_http_methods(request_method_list: List[str]) -> Callable: ... def require_GET(_F) -> _F: ... def require_POST(_F) -> _F: ... def require_safe(_F) -> _F: ... def condition(etag_func: Optional[Callable] = ..., last_modified_func: Optional[Callable] = ...) -> Callable: ... def etag(etag_func: Callable[..., Any]) -> Callable[[_F], _F]: ... def last_modified(last_modified_func: Callable[..., Any]) -> Callable[[_F], _F]: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/views/decorators/vary.pyi0000664000175000017500000000026500000000000027655 0ustar00davedave00000000000000from typing import Any, Callable, TypeVar _F = TypeVar("_F", bound=Callable[..., Any]) def vary_on_headers(*headers: Any) -> Callable: ... def vary_on_cookie(func: _F) -> _F: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/views/defaults.pyi0000664000175000017500000000145600000000000026341 0ustar00davedave00000000000000from typing import Optional from django.http.request import HttpRequest from django.http.response import ( HttpResponseBadRequest, HttpResponseForbidden, HttpResponseNotFound, HttpResponseServerError, ) ERROR_404_TEMPLATE_NAME: str ERROR_403_TEMPLATE_NAME: str ERROR_400_TEMPLATE_NAME: str ERROR_500_TEMPLATE_NAME: str def page_not_found( request: HttpRequest, exception: Optional[Exception], template_name: str = ... ) -> HttpResponseNotFound: ... def server_error(request: HttpRequest, template_name: str = ...) -> HttpResponseServerError: ... def bad_request(request: HttpRequest, exception: Exception, template_name: str = ...) -> HttpResponseBadRequest: ... def permission_denied( request: HttpRequest, exception: Exception, template_name: str = ... ) -> HttpResponseForbidden: ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4103792 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/views/generic/0000775000175000017500000000000000000000000025415 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/views/generic/__init__.pyi0000664000175000017500000000117500000000000027703 0ustar00davedave00000000000000from .base import RedirectView as RedirectView, TemplateView as TemplateView, View as View from .dates import ( ArchiveIndexView as ArchiveIndexView, DateDetailView as DateDetailView, DayArchiveView as DayArchiveView, MonthArchiveView as MonthArchiveView, TodayArchiveView as TodayArchiveView, WeekArchiveView as WeekArchiveView, YearArchiveView as YearArchiveView, ) from .detail import DetailView as DetailView from .edit import CreateView as CreateView, DeleteView as DeleteView, FormView as FormView, UpdateView as UpdateView from .list import ListView as ListView class GenericViewError(Exception): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/views/generic/base.pyi0000664000175000017500000000427700000000000027064 0ustar00davedave00000000000000from typing import Any, Callable, Dict, List, Optional, Type from django import http class ContextMixin: def get_context_data(self, **kwargs: Any) -> Dict[str, Any]: ... class View: http_method_names: List[str] = ... request: http.HttpRequest = ... args: Any = ... kwargs: Any = ... def __init__(self, **kwargs: Any) -> None: ... @classmethod def as_view(cls: Any, **initkwargs: Any) -> Callable[..., http.HttpResponse]: ... def setup(self, request: http.HttpRequest, *args: Any, **kwargs: Any) -> None: ... def dispatch(self, request: http.HttpRequest, *args: Any, **kwargs: Any) -> http.HttpResponse: ... def http_method_not_allowed(self, request: http.HttpRequest, *args: Any, **kwargs: Any) -> http.HttpResponse: ... def options(self, request: http.HttpRequest, *args: Any, **kwargs: Any) -> http.HttpResponse: ... class TemplateResponseMixin: template_name: str = ... template_engine: Optional[str] = ... response_class: Type[http.HttpResponse] = ... content_type: Optional[str] = ... request: http.HttpRequest = ... def render_to_response(self, context: Dict[str, Any], **response_kwargs: Any) -> http.HttpResponse: ... def get_template_names(self) -> List[str]: ... class TemplateView(TemplateResponseMixin, ContextMixin, View): def get(self, request: http.HttpRequest, *args: Any, **kwargs: Any) -> http.HttpResponse: ... class RedirectView(View): permanent: bool = ... url: Optional[str] = ... pattern_name: Optional[str] = ... query_string: bool = ... def get_redirect_url(self, *args: Any, **kwargs: Any) -> Optional[str]: ... def get(self, request: http.HttpRequest, *args: Any, **kwargs: Any) -> http.HttpResponse: ... def head(self, request: http.HttpRequest, *args: Any, **kwargs: Any) -> http.HttpResponse: ... def post(self, request: http.HttpRequest, *args: Any, **kwargs: Any) -> http.HttpResponse: ... def delete(self, request: http.HttpRequest, *args: Any, **kwargs: Any) -> http.HttpResponse: ... def put(self, request: http.HttpRequest, *args: Any, **kwargs: Any) -> http.HttpResponse: ... def patch(self, request: http.HttpRequest, *args: Any, **kwargs: Any) -> http.HttpResponse: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/views/generic/dates.pyi0000664000175000017500000000727300000000000027251 0ustar00davedave00000000000000import datetime from typing import Any, Dict, Optional, Sequence, Tuple from django.views.generic.base import View from django.views.generic.detail import BaseDetailView, SingleObjectTemplateResponseMixin from django.views.generic.list import MultipleObjectMixin, MultipleObjectTemplateResponseMixin from django.db import models from django.http import HttpRequest, HttpResponse class YearMixin: year_format: str = ... year: Optional[str] = ... def get_year_format(self) -> str: ... def get_year(self) -> str: ... def get_next_year(self, date: datetime.date) -> Optional[datetime.date]: ... def get_previous_year(self, date: datetime.date) -> Optional[datetime.date]: ... class MonthMixin: month_format: str = ... month: Optional[str] = ... def get_month_format(self) -> str: ... def get_month(self) -> str: ... def get_next_month(self, date: datetime.date) -> Optional[datetime.date]: ... def get_previous_month(self, date: datetime.date) -> Optional[datetime.date]: ... class DayMixin: day_format: str = ... day: Optional[str] = ... def get_day_format(self) -> str: ... def get_day(self) -> str: ... def get_next_day(self, date: datetime.date) -> Optional[datetime.date]: ... def get_previous_day(self, date: datetime.date) -> Optional[datetime.date]: ... class WeekMixin: week_format: str = ... week: Optional[str] = ... def get_week_format(self) -> str: ... def get_week(self) -> str: ... def get_next_week(self, date: datetime.date) -> Optional[datetime.date]: ... def get_previous_week(self, date: datetime.date) -> Optional[datetime.date]: ... class DateMixin: date_field: Optional[str] = ... allow_future: bool = ... def get_date_field(self) -> str: ... def get_allow_future(self) -> bool: ... def uses_datetime_field(self) -> bool: ... DatedItems = Tuple[Optional[Sequence[datetime.date]], Sequence[object], Dict[str, Any]] class BaseDateListView(MultipleObjectMixin, DateMixin, View): date_list_period: str = ... def render_to_response(self, context: Dict[str, Any], **response_kwargs: Any) -> HttpResponse: ... def get(self, request: HttpRequest, *args: Any, **kwargs: Any) -> HttpResponse: ... def get_dated_items(self) -> DatedItems: ... def get_dated_queryset(self, **lookup: Any) -> models.query.QuerySet: ... def get_date_list_period(self) -> str: ... def get_date_list( self, queryset: models.query.QuerySet, date_type: Optional[str] = ..., ordering: str = ... ) -> models.query.QuerySet: ... class BaseArchiveIndexView(BaseDateListView): ... class ArchiveIndexView(MultipleObjectTemplateResponseMixin, BaseArchiveIndexView): ... class BaseYearArchiveView(YearMixin, BaseDateListView): make_object_list: bool = ... def get_make_object_list(self) -> bool: ... class YearArchiveView(MultipleObjectTemplateResponseMixin, BaseYearArchiveView): ... class BaseMonthArchiveView(YearMixin, MonthMixin, BaseDateListView): ... class MonthArchiveView(MultipleObjectTemplateResponseMixin, BaseMonthArchiveView): ... class BaseWeekArchiveView(YearMixin, WeekMixin, BaseDateListView): ... class WeekArchiveView(MultipleObjectTemplateResponseMixin, BaseWeekArchiveView): ... class BaseDayArchiveView(YearMixin, MonthMixin, DayMixin, BaseDateListView): ... class DayArchiveView(MultipleObjectTemplateResponseMixin, BaseDayArchiveView): ... class BaseTodayArchiveView(BaseDayArchiveView): ... class TodayArchiveView(MultipleObjectTemplateResponseMixin, BaseTodayArchiveView): ... class BaseDateDetailView(YearMixin, MonthMixin, DayMixin, DateMixin, BaseDetailView): ... class DateDetailView(SingleObjectTemplateResponseMixin, BaseDateDetailView): ... def timezone_today() -> datetime.date: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/views/generic/detail.pyi0000664000175000017500000000210200000000000027375 0ustar00davedave00000000000000from typing import Any, Optional, Type from django.views.generic.base import ContextMixin, TemplateResponseMixin, View from django.db import models from django.http import HttpRequest, HttpResponse class SingleObjectMixin(ContextMixin): model: Type[models.Model] = ... queryset: models.query.QuerySet = ... slug_field: str = ... context_object_name: str = ... slug_url_kwarg: str = ... pk_url_kwarg: str = ... query_pk_and_slug: bool = ... def get_object(self, queryset: Optional[models.query.QuerySet] = ...) -> models.Model: ... def get_queryset(self) -> models.query.QuerySet: ... def get_slug_field(self) -> str: ... def get_context_object_name(self, obj: Any) -> Optional[str]: ... class BaseDetailView(SingleObjectMixin, View): def get(self, request: HttpRequest, *args: Any, **kwargs: Any) -> HttpResponse: ... class SingleObjectTemplateResponseMixin(TemplateResponseMixin): template_name_field: Optional[str] = ... template_name_suffix: str = ... class DetailView(SingleObjectTemplateResponseMixin, BaseDetailView): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/views/generic/edit.pyi0000664000175000017500000000427200000000000027072 0ustar00davedave00000000000000from typing import Any, Callable, Dict, Optional, Sequence, Type, Union from django.forms.forms import BaseForm from django.views.generic.base import ContextMixin, TemplateResponseMixin, View from django.views.generic.detail import BaseDetailView, SingleObjectMixin, SingleObjectTemplateResponseMixin from typing_extensions import Literal from django.http import HttpRequest, HttpResponse class FormMixin(ContextMixin): initial: Dict[str, Any] = ... form_class: Optional[Type[BaseForm]] = ... success_url: Optional[Union[str, Callable[..., Any]]] = ... prefix: Optional[str] = ... def get_initial(self) -> Dict[str, Any]: ... def get_prefix(self) -> Optional[str]: ... def get_form_class(self) -> Type[BaseForm]: ... def get_form(self, form_class: Optional[Type[BaseForm]] = ...) -> BaseForm: ... def get_form_kwargs(self) -> Dict[str, Any]: ... def get_success_url(self) -> str: ... def form_valid(self, form: BaseForm) -> HttpResponse: ... def form_invalid(self, form: BaseForm) -> HttpResponse: ... class ModelFormMixin(FormMixin, SingleObjectMixin): fields: Optional[Union[Sequence[str], Literal["__all__"]]] = ... class ProcessFormView(View): def get(self, request: HttpRequest, *args: str, **kwargs: Any) -> HttpResponse: ... def post(self, request: HttpRequest, *args: str, **kwargs: Any) -> HttpResponse: ... def put(self, *args: str, **kwargs: Any) -> HttpResponse: ... class BaseFormView(FormMixin, ProcessFormView): ... class FormView(TemplateResponseMixin, BaseFormView): ... class BaseCreateView(ModelFormMixin, ProcessFormView): ... class CreateView(SingleObjectTemplateResponseMixin, BaseCreateView): ... class BaseUpdateView(ModelFormMixin, ProcessFormView): ... class UpdateView(SingleObjectTemplateResponseMixin, BaseUpdateView): ... class DeletionMixin: success_url: Optional[str] = ... def post(self, request: HttpRequest, *args: str, **kwargs: Any) -> HttpResponse: ... def delete(self, request: HttpRequest, *args: str, **kwargs: Any) -> HttpResponse: ... def get_success_url(self) -> str: ... class BaseDeleteView(DeletionMixin, BaseDetailView): ... class DeleteView(SingleObjectTemplateResponseMixin, BaseDeleteView): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/views/generic/list.pyi0000664000175000017500000000313100000000000027111 0ustar00davedave00000000000000from typing import Any, Optional, Sequence, Tuple, Type from django.core.paginator import Paginator from django.db.models.query import QuerySet, _BaseQuerySet from django.views.generic.base import ContextMixin, TemplateResponseMixin, View from django.db.models import Model from django.http import HttpRequest, HttpResponse class MultipleObjectMixin(ContextMixin): allow_empty: bool = ... queryset: Optional[QuerySet] = ... model: Optional[Type[Model]] = ... paginate_by: int = ... paginate_orphans: int = ... context_object_name: Optional[str] = ... paginator_class: Type[Paginator] = ... page_kwarg: str = ... ordering: Sequence[str] = ... def get_queryset(self) -> QuerySet: ... def get_ordering(self) -> Sequence[str]: ... def paginate_queryset(self, queryset: _BaseQuerySet, page_size: int) -> Tuple[Paginator, int, QuerySet, bool]: ... def get_paginate_by(self, queryset: _BaseQuerySet) -> Optional[int]: ... def get_paginator( self, queryset: QuerySet, per_page: int, orphans: int = ..., allow_empty_first_page: bool = ..., **kwargs: Any ) -> Paginator: ... def get_paginate_orphans(self) -> int: ... def get_allow_empty(self) -> bool: ... def get_context_object_name(self, object_list: _BaseQuerySet) -> Optional[str]: ... class BaseListView(MultipleObjectMixin, View): def get(self, request: HttpRequest, *args: Any, **kwargs: Any) -> HttpResponse: ... class MultipleObjectTemplateResponseMixin(TemplateResponseMixin): template_name_suffix: str = ... class ListView(MultipleObjectTemplateResponseMixin, BaseListView): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/views/i18n.pyi0000664000175000017500000000235100000000000025304 0ustar00davedave00000000000000from typing import Any, Callable, Dict, List, Optional, Union from django.http.request import HttpRequest from django.http.response import HttpResponse from django.utils.translation.trans_real import DjangoTranslation from django.views.generic import View LANGUAGE_QUERY_PARAMETER: str def set_language(request: HttpRequest) -> HttpResponse: ... def get_formats() -> Dict[str, Union[List[str], int, str]]: ... js_catalog_template: str def render_javascript_catalog(catalog: Optional[Any] = ..., plural: Optional[Any] = ...): ... def null_javascript_catalog(request: Any, domain: Optional[Any] = ..., packages: Optional[Any] = ...): ... class JavaScriptCatalog(View): head: Callable domain: str = ... packages: List[str] = ... translation: DjangoTranslation = ... def get(self, request: HttpRequest, *args: Any, **kwargs: Any) -> HttpResponse: ... def get_paths(self, packages: List[str]) -> List[str]: ... def get_plural(self) -> None: ... def get_catalog(self) -> Dict[str, Union[List[str], str]]: ... def get_context_data(self, **kwargs: Any) -> Dict[str, Any]: ... def render_to_response(self, context: Dict[str, Any], **response_kwargs: Any) -> HttpResponse: ... class JSONCatalog(JavaScriptCatalog): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/django-stubs/django-stubs/views/static.pyi0000664000175000017500000000071500000000000026016 0ustar00davedave00000000000000from typing import Any, Optional from django.http.request import HttpRequest from django.http.response import FileResponse def serve(request: HttpRequest, path: str, document_root: str = ..., show_indexes: bool = ...) -> FileResponse: ... DEFAULT_DIRECTORY_INDEX_TEMPLATE: str template_translatable: Any def directory_index(path: Any, fullpath: Any): ... def was_modified_since(header: Optional[str] = ..., mtime: float = ..., size: int = ...) -> bool: ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4103792 jedi-0.19.1/jedi/third_party/typeshed/0000775000175000017500000000000000000000000017471 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/LICENSE0000664000175000017500000003056200000000000020504 0ustar00davedave00000000000000The "typeshed" project is licensed under the terms of the Apache license, as reproduced below. = = = = = Apache License Version 2.0, January 2004 http://www.apache.org/licenses/ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION 1. Definitions. "License" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document. "Licensor" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License. "Legal Entity" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, "control" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity. "You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by this License. "Source" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files. "Object" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types. "Work" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below). "Derivative Works" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof. "Contribution" shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, "submitted" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as "Not a Contribution." "Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work. 2. Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form. 3. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed. 4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions: (a) You must give any other recipients of the Work or Derivative Works a copy of this License; and (b) You must cause any modified files to carry prominent notices stating that You changed the files; and (c) You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and (d) If the Work includes a "NOTICE" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License. You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License. 5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions. 6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file. 7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License. 8. Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages. 9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability. END OF TERMS AND CONDITIONS APPENDIX: How to apply the Apache License to your work. To apply the Apache License to your work, attach the following boilerplate notice, with the fields enclosed by brackets "{}" replaced with your own identifying information. (Don't include the brackets!) The text should be enclosed in the appropriate comment syntax for the file format. We also recommend that a file or class name and description of purpose be included on the same "printed page" as the copyright notice for easier identification within third-party archives. Copyright {yyyy} {name of copyright owner} Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. = = = = = Parts of typeshed are licensed under different licenses (like the MIT license), reproduced below. = = = = = The MIT License Copyright (c) 2015 Jukka Lehtosalo and contributors Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. = = = = = ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.3823793 jedi-0.19.1/jedi/third_party/typeshed/stdlib/0000775000175000017500000000000000000000000020752 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4143794 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/0000775000175000017500000000000000000000000021113 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/BaseHTTPServer.pyi0000664000175000017500000000332300000000000024400 0ustar00davedave00000000000000import mimetools import SocketServer from typing import Any, BinaryIO, Callable, Mapping, Optional, Tuple, Union class HTTPServer(SocketServer.TCPServer): server_name: str server_port: int def __init__(self, server_address: Tuple[str, int], RequestHandlerClass: Callable[..., BaseHTTPRequestHandler]) -> None: ... class BaseHTTPRequestHandler(SocketServer.StreamRequestHandler): client_address: Tuple[str, int] server: SocketServer.BaseServer close_connection: bool command: str path: str request_version: str headers: mimetools.Message rfile: BinaryIO wfile: BinaryIO server_version: str sys_version: str error_message_format: str error_content_type: str protocol_version: str MessageClass: type responses: Mapping[int, Tuple[str, str]] def __init__(self, request: bytes, client_address: Tuple[str, int], server: SocketServer.BaseServer) -> None: ... def handle(self) -> None: ... def handle_one_request(self) -> None: ... def send_error(self, code: int, message: Optional[str] = ...) -> None: ... def send_response(self, code: int, message: Optional[str] = ...) -> None: ... def send_header(self, keyword: str, value: str) -> None: ... def end_headers(self) -> None: ... def flush_headers(self) -> None: ... def log_request(self, code: Union[int, str] = ..., size: Union[int, str] = ...) -> None: ... def log_error(self, format: str, *args: Any) -> None: ... def log_message(self, format: str, *args: Any) -> None: ... def version_string(self) -> str: ... def date_time_string(self, timestamp: Optional[int] = ...) -> str: ... def log_date_time_string(self) -> str: ... def address_string(self) -> str: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/CGIHTTPServer.pyi0000664000175000017500000000027300000000000024131 0ustar00davedave00000000000000import SimpleHTTPServer from typing import List class CGIHTTPRequestHandler(SimpleHTTPServer.SimpleHTTPRequestHandler): cgi_directories: List[str] def do_POST(self) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/ConfigParser.pyi0000664000175000017500000000743500000000000024231 0ustar00davedave00000000000000from _typeshed import SupportsNoArgReadline from typing import IO, Any, Dict, List, Optional, Sequence, Tuple, Union DEFAULTSECT: str MAX_INTERPOLATION_DEPTH: int class Error(Exception): message: Any def __init__(self, msg: str = ...) -> None: ... def _get_message(self) -> None: ... def _set_message(self, value: str) -> None: ... def __repr__(self) -> str: ... def __str__(self) -> str: ... class NoSectionError(Error): section: str def __init__(self, section: str) -> None: ... class DuplicateSectionError(Error): section: str def __init__(self, section: str) -> None: ... class NoOptionError(Error): section: str option: str def __init__(self, option: str, section: str) -> None: ... class InterpolationError(Error): section: str option: str msg: str def __init__(self, option: str, section: str, msg: str) -> None: ... class InterpolationMissingOptionError(InterpolationError): reference: str def __init__(self, option: str, section: str, rawval: str, reference: str) -> None: ... class InterpolationSyntaxError(InterpolationError): ... class InterpolationDepthError(InterpolationError): def __init__(self, option: str, section: str, rawval: str) -> None: ... class ParsingError(Error): filename: str errors: List[Tuple[Any, Any]] def __init__(self, filename: str) -> None: ... def append(self, lineno: Any, line: Any) -> None: ... class MissingSectionHeaderError(ParsingError): lineno: Any line: Any def __init__(self, filename: str, lineno: Any, line: Any) -> None: ... class RawConfigParser: _dict: Any _sections: Dict[Any, Any] _defaults: Dict[Any, Any] _optcre: Any SECTCRE: Any OPTCRE: Any OPTCRE_NV: Any def __init__(self, defaults: Dict[Any, Any] = ..., dict_type: Any = ..., allow_no_value: bool = ...) -> None: ... def defaults(self) -> Dict[Any, Any]: ... def sections(self) -> List[str]: ... def add_section(self, section: str) -> None: ... def has_section(self, section: str) -> bool: ... def options(self, section: str) -> List[str]: ... def read(self, filenames: Union[str, Sequence[str]]) -> List[str]: ... def readfp(self, fp: SupportsNoArgReadline[str], filename: str = ...) -> None: ... def get(self, section: str, option: str) -> str: ... def items(self, section: str) -> List[Tuple[Any, Any]]: ... def _get(self, section: str, conv: type, option: str) -> Any: ... def getint(self, section: str, option: str) -> int: ... def getfloat(self, section: str, option: str) -> float: ... _boolean_states: Dict[str, bool] def getboolean(self, section: str, option: str) -> bool: ... def optionxform(self, optionstr: str) -> str: ... def has_option(self, section: str, option: str) -> bool: ... def set(self, section: str, option: str, value: Any = ...) -> None: ... def write(self, fp: IO[str]) -> None: ... def remove_option(self, section: str, option: Any) -> bool: ... def remove_section(self, section: str) -> bool: ... def _read(self, fp: IO[str], fpname: str) -> None: ... class ConfigParser(RawConfigParser): _KEYCRE: Any def get(self, section: str, option: str, raw: bool = ..., vars: Optional[Dict[Any, Any]] = ...) -> Any: ... def items(self, section: str, raw: bool = ..., vars: Optional[Dict[Any, Any]] = ...) -> List[Tuple[str, Any]]: ... def _interpolate(self, section: str, option: str, rawval: Any, vars: Any) -> str: ... def _interpolation_replace(self, match: Any) -> str: ... class SafeConfigParser(ConfigParser): _interpvar_re: Any def _interpolate(self, section: str, option: str, rawval: Any, vars: Any) -> str: ... def _interpolate_some( self, option: str, accum: List[Any], rest: str, section: str, map: Dict[Any, Any], depth: int ) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/Cookie.pyi0000664000175000017500000000247600000000000023060 0ustar00davedave00000000000000from typing import Any, Dict, Optional class CookieError(Exception): ... class Morsel(Dict[Any, Any]): key: Any def __init__(self): ... def __setitem__(self, K, V): ... def isReservedKey(self, K): ... value: Any coded_value: Any def set(self, key, val, coded_val, LegalChars=..., idmap=..., translate=...): ... def output(self, attrs: Optional[Any] = ..., header=...): ... def js_output(self, attrs: Optional[Any] = ...): ... def OutputString(self, attrs: Optional[Any] = ...): ... class BaseCookie(Dict[Any, Any]): def value_decode(self, val): ... def value_encode(self, val): ... def __init__(self, input: Optional[Any] = ...): ... def __setitem__(self, key, value): ... def output(self, attrs: Optional[Any] = ..., header=..., sep=...): ... def js_output(self, attrs: Optional[Any] = ...): ... def load(self, rawdata): ... class SimpleCookie(BaseCookie): def value_decode(self, val): ... def value_encode(self, val): ... class SerialCookie(BaseCookie): def __init__(self, input: Optional[Any] = ...): ... def value_decode(self, val): ... def value_encode(self, val): ... class SmartCookie(BaseCookie): def __init__(self, input: Optional[Any] = ...): ... def value_decode(self, val): ... def value_encode(self, val): ... Cookie: Any ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/HTMLParser.pyi0000664000175000017500000000205000000000000023554 0ustar00davedave00000000000000from typing import AnyStr, List, Tuple from markupbase import ParserBase class HTMLParser(ParserBase): def __init__(self) -> None: ... def feed(self, feed: AnyStr) -> None: ... def close(self) -> None: ... def reset(self) -> None: ... def get_starttag_text(self) -> AnyStr: ... def set_cdata_mode(self, AnyStr) -> None: ... def clear_cdata_mode(self) -> None: ... def handle_startendtag(self, tag: AnyStr, attrs: List[Tuple[AnyStr, AnyStr]]): ... def handle_starttag(self, tag: AnyStr, attrs: List[Tuple[AnyStr, AnyStr]]): ... def handle_endtag(self, tag: AnyStr): ... def handle_charref(self, name: AnyStr): ... def handle_entityref(self, name: AnyStr): ... def handle_data(self, data: AnyStr): ... def handle_comment(self, data: AnyStr): ... def handle_decl(self, decl: AnyStr): ... def handle_pi(self, data: AnyStr): ... def unknown_decl(self, data: AnyStr): ... def unescape(self, s: AnyStr) -> AnyStr: ... class HTMLParseError(Exception): msg: str lineno: int offset: int ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/Queue.pyi0000664000175000017500000000157700000000000022734 0ustar00davedave00000000000000from collections import deque from typing import Any, Deque, Generic, Optional, TypeVar _T = TypeVar("_T") class Empty(Exception): ... class Full(Exception): ... class Queue(Generic[_T]): maxsize: Any mutex: Any not_empty: Any not_full: Any all_tasks_done: Any unfinished_tasks: Any queue: Deque[Any] # undocumented def __init__(self, maxsize: int = ...) -> None: ... def task_done(self) -> None: ... def join(self) -> None: ... def qsize(self) -> int: ... def empty(self) -> bool: ... def full(self) -> bool: ... def put(self, item: _T, block: bool = ..., timeout: Optional[float] = ...) -> None: ... def put_nowait(self, item: _T) -> None: ... def get(self, block: bool = ..., timeout: Optional[float] = ...) -> _T: ... def get_nowait(self) -> _T: ... class PriorityQueue(Queue[_T]): ... class LifoQueue(Queue[_T]): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/SimpleHTTPServer.pyi0000664000175000017500000000121000000000000024750 0ustar00davedave00000000000000import BaseHTTPServer from StringIO import StringIO from typing import IO, Any, AnyStr, Mapping, Optional, Union class SimpleHTTPRequestHandler(BaseHTTPServer.BaseHTTPRequestHandler): server_version: str def do_GET(self) -> None: ... def do_HEAD(self) -> None: ... def send_head(self) -> Optional[IO[str]]: ... def list_directory(self, path: Union[str, unicode]) -> Optional[StringIO[Any]]: ... def translate_path(self, path: AnyStr) -> AnyStr: ... def copyfile(self, source: IO[AnyStr], outputfile: IO[AnyStr]): ... def guess_type(self, path: Union[str, unicode]) -> str: ... extensions_map: Mapping[str, str] ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/SocketServer.pyi0000664000175000017500000001071700000000000024263 0ustar00davedave00000000000000import sys import types from socket import SocketType from typing import Any, BinaryIO, Callable, ClassVar, List, Optional, Text, Tuple, Type, Union class BaseServer: address_family: int RequestHandlerClass: Callable[..., BaseRequestHandler] server_address: Tuple[str, int] socket: SocketType allow_reuse_address: bool request_queue_size: int socket_type: int timeout: Optional[float] def __init__(self, server_address: Any, RequestHandlerClass: Callable[..., BaseRequestHandler]) -> None: ... def fileno(self) -> int: ... def handle_request(self) -> None: ... def serve_forever(self, poll_interval: float = ...) -> None: ... def shutdown(self) -> None: ... def server_close(self) -> None: ... def finish_request(self, request: bytes, client_address: Tuple[str, int]) -> None: ... def get_request(self) -> Tuple[SocketType, Tuple[str, int]]: ... def handle_error(self, request: bytes, client_address: Tuple[str, int]) -> None: ... def handle_timeout(self) -> None: ... def process_request(self, request: bytes, client_address: Tuple[str, int]) -> None: ... def server_activate(self) -> None: ... def server_bind(self) -> None: ... def verify_request(self, request: bytes, client_address: Tuple[str, int]) -> bool: ... class TCPServer(BaseServer): def __init__( self, server_address: Tuple[str, int], RequestHandlerClass: Callable[..., BaseRequestHandler], bind_and_activate: bool = ..., ) -> None: ... class UDPServer(BaseServer): def __init__( self, server_address: Tuple[str, int], RequestHandlerClass: Callable[..., BaseRequestHandler], bind_and_activate: bool = ..., ) -> None: ... if sys.platform != "win32": class UnixStreamServer(BaseServer): def __init__( self, server_address: Union[Text, bytes], RequestHandlerClass: Callable[..., BaseRequestHandler], bind_and_activate: bool = ..., ) -> None: ... class UnixDatagramServer(BaseServer): def __init__( self, server_address: Union[Text, bytes], RequestHandlerClass: Callable[..., BaseRequestHandler], bind_and_activate: bool = ..., ) -> None: ... if sys.platform != "win32": class ForkingMixIn: timeout: Optional[float] # undocumented active_children: Optional[List[int]] # undocumented max_children: int # undocumented def collect_children(self) -> None: ... # undocumented def handle_timeout(self) -> None: ... # undocumented def process_request(self, request: bytes, client_address: Tuple[str, int]) -> None: ... class ThreadingMixIn: daemon_threads: bool def process_request_thread(self, request: bytes, client_address: Tuple[str, int]) -> None: ... # undocumented def process_request(self, request: bytes, client_address: Tuple[str, int]) -> None: ... if sys.platform != "win32": class ForkingTCPServer(ForkingMixIn, TCPServer): ... class ForkingUDPServer(ForkingMixIn, UDPServer): ... class ThreadingTCPServer(ThreadingMixIn, TCPServer): ... class ThreadingUDPServer(ThreadingMixIn, UDPServer): ... if sys.platform != "win32": class ThreadingUnixStreamServer(ThreadingMixIn, UnixStreamServer): ... class ThreadingUnixDatagramServer(ThreadingMixIn, UnixDatagramServer): ... class BaseRequestHandler: # Those are technically of types, respectively: # * Union[SocketType, Tuple[bytes, SocketType]] # * Union[Tuple[str, int], str] # But there are some concerns that having unions here would cause # too much inconvenience to people using it (see # https://github.com/python/typeshed/pull/384#issuecomment-234649696) request: Any client_address: Any server: BaseServer def __init__(self, request: Any, client_address: Any, server: BaseServer) -> None: ... def setup(self) -> None: ... def handle(self) -> None: ... def finish(self) -> None: ... class StreamRequestHandler(BaseRequestHandler): rbufsize: ClassVar[int] # Undocumented wbufsize: ClassVar[int] # Undocumented timeout: ClassVar[Optional[float]] # Undocumented disable_nagle_algorithm: ClassVar[bool] # Undocumented connection: SocketType # Undocumented rfile: BinaryIO wfile: BinaryIO class DatagramRequestHandler(BaseRequestHandler): packet: SocketType # Undocumented socket: SocketType # Undocumented rfile: BinaryIO wfile: BinaryIO ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/StringIO.pyi0000664000175000017500000000217200000000000023336 0ustar00davedave00000000000000from typing import IO, Any, AnyStr, Generic, Iterable, Iterator, List, Optional class StringIO(IO[AnyStr], Generic[AnyStr]): closed: bool softspace: int len: int name: str def __init__(self, buf: AnyStr = ...) -> None: ... def __iter__(self) -> Iterator[AnyStr]: ... def next(self) -> AnyStr: ... def close(self) -> None: ... def isatty(self) -> bool: ... def seek(self, pos: int, mode: int = ...) -> int: ... def tell(self) -> int: ... def read(self, n: int = ...) -> AnyStr: ... def readline(self, length: int = ...) -> AnyStr: ... def readlines(self, sizehint: int = ...) -> List[AnyStr]: ... def truncate(self, size: Optional[int] = ...) -> int: ... def write(self, s: AnyStr) -> int: ... def writelines(self, iterable: Iterable[AnyStr]) -> None: ... def flush(self) -> None: ... def getvalue(self) -> AnyStr: ... def __enter__(self) -> Any: ... def __exit__(self, type: Any, value: Any, traceback: Any) -> Any: ... def fileno(self) -> int: ... def readable(self) -> bool: ... def seekable(self) -> bool: ... def writable(self) -> bool: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/UserDict.pyi0000664000175000017500000000317700000000000023370 0ustar00davedave00000000000000from typing import ( Any, Container, Dict, Generic, Iterable, Iterator, List, Mapping, Optional, Sized, Tuple, TypeVar, Union, overload, ) _KT = TypeVar("_KT") _VT = TypeVar("_VT") _T = TypeVar("_T") class UserDict(Dict[_KT, _VT], Generic[_KT, _VT]): data: Dict[_KT, _VT] def __init__(self, initialdata: Mapping[_KT, _VT] = ...) -> None: ... # TODO: __iter__ is not available for UserDict class IterableUserDict(UserDict[_KT, _VT], Generic[_KT, _VT]): ... class DictMixin(Iterable[_KT], Container[_KT], Sized, Generic[_KT, _VT]): def has_key(self, key: _KT) -> bool: ... def __len__(self) -> int: ... def __iter__(self) -> Iterator[_KT]: ... # From typing.Mapping[_KT, _VT] # (can't inherit because of keys()) @overload def get(self, k: _KT) -> Optional[_VT]: ... @overload def get(self, k: _KT, default: Union[_VT, _T]) -> Union[_VT, _T]: ... def values(self) -> List[_VT]: ... def items(self) -> List[Tuple[_KT, _VT]]: ... def iterkeys(self) -> Iterator[_KT]: ... def itervalues(self) -> Iterator[_VT]: ... def iteritems(self) -> Iterator[Tuple[_KT, _VT]]: ... def __contains__(self, o: Any) -> bool: ... # From typing.MutableMapping[_KT, _VT] def clear(self) -> None: ... def pop(self, k: _KT, default: _VT = ...) -> _VT: ... def popitem(self) -> Tuple[_KT, _VT]: ... def setdefault(self, k: _KT, default: _VT = ...) -> _VT: ... @overload def update(self, m: Mapping[_KT, _VT], **kwargs: _VT) -> None: ... @overload def update(self, m: Iterable[Tuple[_KT, _VT]], **kwargs: _VT) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/UserList.pyi0000664000175000017500000000116600000000000023414 0ustar00davedave00000000000000from typing import Iterable, List, MutableSequence, TypeVar, Union, overload _T = TypeVar("_T") _S = TypeVar("_S") class UserList(MutableSequence[_T]): data: List[_T] def insert(self, index: int, object: _T) -> None: ... @overload def __setitem__(self, i: int, o: _T) -> None: ... @overload def __setitem__(self, s: slice, o: Iterable[_T]) -> None: ... def __delitem__(self, i: Union[int, slice]) -> None: ... def __len__(self) -> int: ... @overload def __getitem__(self, i: int) -> _T: ... @overload def __getitem__(self: _S, s: slice) -> _S: ... def sort(self) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/UserString.pyi0000664000175000017500000000740400000000000023750 0ustar00davedave00000000000000import collections from typing import Any, Iterable, List, MutableSequence, Optional, Sequence, Text, Tuple, TypeVar, Union, overload _UST = TypeVar("_UST", bound=UserString) _MST = TypeVar("_MST", bound=MutableString) class UserString(Sequence[UserString]): data: unicode def __init__(self, seq: object) -> None: ... def __int__(self) -> int: ... def __long__(self) -> long: ... def __float__(self) -> float: ... def __complex__(self) -> complex: ... def __hash__(self) -> int: ... def __len__(self) -> int: ... @overload def __getitem__(self: _UST, i: int) -> _UST: ... @overload def __getitem__(self: _UST, s: slice) -> _UST: ... def __add__(self: _UST, other: Any) -> _UST: ... def __radd__(self: _UST, other: Any) -> _UST: ... def __mul__(self: _UST, other: int) -> _UST: ... def __rmul__(self: _UST, other: int) -> _UST: ... def __mod__(self: _UST, args: Any) -> _UST: ... def capitalize(self: _UST) -> _UST: ... def center(self: _UST, width: int, *args: Any) -> _UST: ... def count(self, sub: int, start: int = ..., end: int = ...) -> int: ... def decode(self: _UST, encoding: Optional[str] = ..., errors: Optional[str] = ...) -> _UST: ... def encode(self: _UST, encoding: Optional[str] = ..., errors: Optional[str] = ...) -> _UST: ... def endswith(self, suffix: Text, start: int = ..., end: int = ...) -> bool: ... def expandtabs(self: _UST, tabsize: int = ...) -> _UST: ... def find(self, sub: Text, start: int = ..., end: int = ...) -> int: ... def index(self, sub: Text, start: int = ..., end: int = ...) -> int: ... def isalpha(self) -> bool: ... def isalnum(self) -> bool: ... def isdecimal(self) -> bool: ... def isdigit(self) -> bool: ... def islower(self) -> bool: ... def isnumeric(self) -> bool: ... def isspace(self) -> bool: ... def istitle(self) -> bool: ... def isupper(self) -> bool: ... def join(self, seq: Iterable[Text]) -> Text: ... def ljust(self: _UST, width: int, *args: Any) -> _UST: ... def lower(self: _UST) -> _UST: ... def lstrip(self: _UST, chars: Optional[Text] = ...) -> _UST: ... def partition(self, sep: Text) -> Tuple[Text, Text, Text]: ... def replace(self: _UST, old: Text, new: Text, maxsplit: int = ...) -> _UST: ... def rfind(self, sub: Text, start: int = ..., end: int = ...) -> int: ... def rindex(self, sub: Text, start: int = ..., end: int = ...) -> int: ... def rjust(self: _UST, width: int, *args: Any) -> _UST: ... def rpartition(self, sep: Text) -> Tuple[Text, Text, Text]: ... def rstrip(self: _UST, chars: Optional[Text] = ...) -> _UST: ... def split(self, sep: Optional[Text] = ..., maxsplit: int = ...) -> List[Text]: ... def rsplit(self, sep: Optional[Text] = ..., maxsplit: int = ...) -> List[Text]: ... def splitlines(self, keepends: int = ...) -> List[Text]: ... def startswith(self, suffix: Text, start: int = ..., end: int = ...) -> bool: ... def strip(self: _UST, chars: Optional[Text] = ...) -> _UST: ... def swapcase(self: _UST) -> _UST: ... def title(self: _UST) -> _UST: ... def translate(self: _UST, *args: Any) -> _UST: ... def upper(self: _UST) -> _UST: ... def zfill(self: _UST, width: int) -> _UST: ... class MutableString(UserString, MutableSequence[MutableString]): @overload def __getitem__(self: _MST, i: int) -> _MST: ... @overload def __getitem__(self: _MST, s: slice) -> _MST: ... def __setitem__(self, index: Union[int, slice], sub: Any) -> None: ... def __delitem__(self, index: Union[int, slice]) -> None: ... def immutable(self) -> UserString: ... def __iadd__(self: _MST, other: Any) -> _MST: ... def __imul__(self, n: int) -> _MST: ... def insert(self, index: int, value: Any) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/__builtin__.pyi0000664000175000017500000013732500000000000024113 0ustar00davedave00000000000000# True and False are deliberately omitted because they are keywords in # Python 3, and stub files conform to Python 3 syntax. from _typeshed import ReadableBuffer, SupportsKeysAndGetItem, SupportsWrite from abc import ABCMeta from ast import mod from types import CodeType from typing import ( AbstractSet, Any, AnyStr, BinaryIO, ByteString, Callable, Container, Dict, FrozenSet, Generic, ItemsView, Iterable, Iterator, KeysView, List, Mapping, MutableMapping, MutableSequence, MutableSet, NoReturn, Optional, Protocol, Reversible, Sequence, Set, Sized, SupportsAbs, SupportsComplex, SupportsFloat, SupportsInt, Text, Tuple, Type, TypeVar, Union, ValuesView, overload, runtime_checkable, ) from typing_extensions import Literal class _SupportsIndex(Protocol): def __index__(self) -> int: ... class _SupportsTrunc(Protocol): def __trunc__(self) -> int: ... _T = TypeVar("_T") _T_co = TypeVar("_T_co", covariant=True) _KT = TypeVar("_KT") _VT = TypeVar("_VT") _S = TypeVar("_S") _T1 = TypeVar("_T1") _T2 = TypeVar("_T2") _T3 = TypeVar("_T3") _T4 = TypeVar("_T4") _T5 = TypeVar("_T5") _TT = TypeVar("_TT", bound="type") _TBE = TypeVar("_TBE", bound="BaseException") class object: __doc__: Optional[str] __dict__: Dict[str, Any] __slots__: Union[Text, Iterable[Text]] __module__: str @property def __class__(self: _T) -> Type[_T]: ... @__class__.setter def __class__(self, __type: Type[object]) -> None: ... # noqa: F811 def __init__(self) -> None: ... def __new__(cls) -> Any: ... def __setattr__(self, name: str, value: Any) -> None: ... def __eq__(self, o: object) -> bool: ... def __ne__(self, o: object) -> bool: ... def __str__(self) -> str: ... def __repr__(self) -> str: ... def __hash__(self) -> int: ... def __format__(self, format_spec: str) -> str: ... def __getattribute__(self, name: str) -> Any: ... def __delattr__(self, name: str) -> None: ... def __sizeof__(self) -> int: ... def __reduce__(self) -> Union[str, Tuple[Any, ...]]: ... def __reduce_ex__(self, protocol: int) -> Union[str, Tuple[Any, ...]]: ... class staticmethod(object): # Special, only valid as a decorator. __func__: Callable[..., Any] def __init__(self, f: Callable[..., Any]) -> None: ... def __new__(cls: Type[_T], *args: Any, **kwargs: Any) -> _T: ... def __get__(self, obj: _T, type: Optional[Type[_T]] = ...) -> Callable[..., Any]: ... class classmethod(object): # Special, only valid as a decorator. __func__: Callable[..., Any] def __init__(self, f: Callable[..., Any]) -> None: ... def __new__(cls: Type[_T], *args: Any, **kwargs: Any) -> _T: ... def __get__(self, obj: _T, type: Optional[Type[_T]] = ...) -> Callable[..., Any]: ... class type(object): __base__: type __bases__: Tuple[type, ...] __basicsize__: int __dict__: Dict[str, Any] __dictoffset__: int __flags__: int __itemsize__: int __module__: str __mro__: Tuple[type, ...] __name__: str __weakrefoffset__: int @overload def __init__(self, o: object) -> None: ... @overload def __init__(self, name: str, bases: Tuple[type, ...], dict: Dict[str, Any]) -> None: ... @overload def __new__(cls, o: object) -> type: ... @overload def __new__(cls, name: str, bases: Tuple[type, ...], namespace: Dict[str, Any]) -> type: ... def __call__(self, *args: Any, **kwds: Any) -> Any: ... def __subclasses__(self: _TT) -> List[_TT]: ... # Note: the documentation doesnt specify what the return type is, the standard # implementation seems to be returning a list. def mro(self) -> List[type]: ... def __instancecheck__(self, instance: Any) -> bool: ... def __subclasscheck__(self, subclass: type) -> bool: ... class super(object): @overload def __init__(self, t: Any, obj: Any) -> None: ... @overload def __init__(self, t: Any) -> None: ... class int: @overload def __new__(cls: Type[_T], x: Union[Text, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc] = ...) -> _T: ... @overload def __new__(cls: Type[_T], x: Union[Text, bytes, bytearray], base: int) -> _T: ... @property def real(self) -> int: ... @property def imag(self) -> int: ... @property def numerator(self) -> int: ... @property def denominator(self) -> int: ... def conjugate(self) -> int: ... def bit_length(self) -> int: ... def __add__(self, x: int) -> int: ... def __sub__(self, x: int) -> int: ... def __mul__(self, x: int) -> int: ... def __floordiv__(self, x: int) -> int: ... def __div__(self, x: int) -> int: ... def __truediv__(self, x: int) -> float: ... def __mod__(self, x: int) -> int: ... def __divmod__(self, x: int) -> Tuple[int, int]: ... def __radd__(self, x: int) -> int: ... def __rsub__(self, x: int) -> int: ... def __rmul__(self, x: int) -> int: ... def __rfloordiv__(self, x: int) -> int: ... def __rdiv__(self, x: int) -> int: ... def __rtruediv__(self, x: int) -> float: ... def __rmod__(self, x: int) -> int: ... def __rdivmod__(self, x: int) -> Tuple[int, int]: ... @overload def __pow__(self, __x: Literal[2], __modulo: Optional[int] = ...) -> int: ... @overload def __pow__(self, __x: int, __modulo: Optional[int] = ...) -> Any: ... # Return type can be int or float, depending on x. def __rpow__(self, x: int, mod: Optional[int] = ...) -> Any: ... def __and__(self, n: int) -> int: ... def __or__(self, n: int) -> int: ... def __xor__(self, n: int) -> int: ... def __lshift__(self, n: int) -> int: ... def __rshift__(self, n: int) -> int: ... def __rand__(self, n: int) -> int: ... def __ror__(self, n: int) -> int: ... def __rxor__(self, n: int) -> int: ... def __rlshift__(self, n: int) -> int: ... def __rrshift__(self, n: int) -> int: ... def __neg__(self) -> int: ... def __pos__(self) -> int: ... def __invert__(self) -> int: ... def __trunc__(self) -> int: ... def __getnewargs__(self) -> Tuple[int]: ... def __eq__(self, x: object) -> bool: ... def __ne__(self, x: object) -> bool: ... def __lt__(self, x: int) -> bool: ... def __le__(self, x: int) -> bool: ... def __gt__(self, x: int) -> bool: ... def __ge__(self, x: int) -> bool: ... def __str__(self) -> str: ... def __float__(self) -> float: ... def __int__(self) -> int: ... def __abs__(self) -> int: ... def __hash__(self) -> int: ... def __nonzero__(self) -> bool: ... def __index__(self) -> int: ... class float: def __new__(cls: Type[_T], x: Union[SupportsFloat, _SupportsIndex, Text, bytes, bytearray] = ...) -> _T: ... def as_integer_ratio(self) -> Tuple[int, int]: ... def hex(self) -> str: ... def is_integer(self) -> bool: ... @classmethod def fromhex(cls, __s: str) -> float: ... @property def real(self) -> float: ... @property def imag(self) -> float: ... def conjugate(self) -> float: ... def __add__(self, x: float) -> float: ... def __sub__(self, x: float) -> float: ... def __mul__(self, x: float) -> float: ... def __floordiv__(self, x: float) -> float: ... def __div__(self, x: float) -> float: ... def __truediv__(self, x: float) -> float: ... def __mod__(self, x: float) -> float: ... def __divmod__(self, x: float) -> Tuple[float, float]: ... def __pow__( self, x: float, mod: None = ... ) -> float: ... # In Python 3, returns complex if self is negative and x is not whole def __radd__(self, x: float) -> float: ... def __rsub__(self, x: float) -> float: ... def __rmul__(self, x: float) -> float: ... def __rfloordiv__(self, x: float) -> float: ... def __rdiv__(self, x: float) -> float: ... def __rtruediv__(self, x: float) -> float: ... def __rmod__(self, x: float) -> float: ... def __rdivmod__(self, x: float) -> Tuple[float, float]: ... def __rpow__(self, x: float, mod: None = ...) -> float: ... def __getnewargs__(self) -> Tuple[float]: ... def __trunc__(self) -> int: ... def __eq__(self, x: object) -> bool: ... def __ne__(self, x: object) -> bool: ... def __lt__(self, x: float) -> bool: ... def __le__(self, x: float) -> bool: ... def __gt__(self, x: float) -> bool: ... def __ge__(self, x: float) -> bool: ... def __neg__(self) -> float: ... def __pos__(self) -> float: ... def __str__(self) -> str: ... def __int__(self) -> int: ... def __float__(self) -> float: ... def __abs__(self) -> float: ... def __hash__(self) -> int: ... def __nonzero__(self) -> bool: ... class complex: @overload def __new__(cls: Type[_T], real: float = ..., imag: float = ...) -> _T: ... @overload def __new__(cls: Type[_T], real: Union[str, SupportsComplex, _SupportsIndex]) -> _T: ... @property def real(self) -> float: ... @property def imag(self) -> float: ... def conjugate(self) -> complex: ... def __add__(self, x: complex) -> complex: ... def __sub__(self, x: complex) -> complex: ... def __mul__(self, x: complex) -> complex: ... def __pow__(self, x: complex, mod: None = ...) -> complex: ... def __div__(self, x: complex) -> complex: ... def __truediv__(self, x: complex) -> complex: ... def __radd__(self, x: complex) -> complex: ... def __rsub__(self, x: complex) -> complex: ... def __rmul__(self, x: complex) -> complex: ... def __rpow__(self, x: complex, mod: None = ...) -> complex: ... def __rdiv__(self, x: complex) -> complex: ... def __rtruediv__(self, x: complex) -> complex: ... def __eq__(self, x: object) -> bool: ... def __ne__(self, x: object) -> bool: ... def __neg__(self) -> complex: ... def __pos__(self) -> complex: ... def __str__(self) -> str: ... def __complex__(self) -> complex: ... def __abs__(self) -> float: ... def __hash__(self) -> int: ... def __nonzero__(self) -> bool: ... class basestring(metaclass=ABCMeta): ... class unicode(basestring, Sequence[unicode]): @overload def __init__(self) -> None: ... @overload def __init__(self, o: object) -> None: ... @overload def __init__(self, o: str, encoding: unicode = ..., errors: unicode = ...) -> None: ... def capitalize(self) -> unicode: ... def center(self, width: int, fillchar: unicode = ...) -> unicode: ... def count(self, x: unicode) -> int: ... def decode(self, encoding: unicode = ..., errors: unicode = ...) -> unicode: ... def encode(self, encoding: unicode = ..., errors: unicode = ...) -> str: ... def endswith(self, suffix: Union[unicode, Tuple[unicode, ...]], start: int = ..., end: int = ...) -> bool: ... def expandtabs(self, tabsize: int = ...) -> unicode: ... def find(self, sub: unicode, start: int = ..., end: int = ...) -> int: ... def format(self, *args: object, **kwargs: object) -> unicode: ... def index(self, sub: unicode, start: int = ..., end: int = ...) -> int: ... def isalnum(self) -> bool: ... def isalpha(self) -> bool: ... def isdecimal(self) -> bool: ... def isdigit(self) -> bool: ... def isidentifier(self) -> bool: ... def islower(self) -> bool: ... def isnumeric(self) -> bool: ... def isprintable(self) -> bool: ... def isspace(self) -> bool: ... def istitle(self) -> bool: ... def isupper(self) -> bool: ... def join(self, iterable: Iterable[unicode]) -> unicode: ... def ljust(self, width: int, fillchar: unicode = ...) -> unicode: ... def lower(self) -> unicode: ... def lstrip(self, chars: unicode = ...) -> unicode: ... def partition(self, sep: unicode) -> Tuple[unicode, unicode, unicode]: ... def replace(self, old: unicode, new: unicode, count: int = ...) -> unicode: ... def rfind(self, sub: unicode, start: int = ..., end: int = ...) -> int: ... def rindex(self, sub: unicode, start: int = ..., end: int = ...) -> int: ... def rjust(self, width: int, fillchar: unicode = ...) -> unicode: ... def rpartition(self, sep: unicode) -> Tuple[unicode, unicode, unicode]: ... def rsplit(self, sep: Optional[unicode] = ..., maxsplit: int = ...) -> List[unicode]: ... def rstrip(self, chars: unicode = ...) -> unicode: ... def split(self, sep: Optional[unicode] = ..., maxsplit: int = ...) -> List[unicode]: ... def splitlines(self, keepends: bool = ...) -> List[unicode]: ... def startswith(self, prefix: Union[unicode, Tuple[unicode, ...]], start: int = ..., end: int = ...) -> bool: ... def strip(self, chars: unicode = ...) -> unicode: ... def swapcase(self) -> unicode: ... def title(self) -> unicode: ... def translate(self, table: Union[Dict[int, Any], unicode]) -> unicode: ... def upper(self) -> unicode: ... def zfill(self, width: int) -> unicode: ... @overload def __getitem__(self, i: int) -> unicode: ... @overload def __getitem__(self, s: slice) -> unicode: ... def __getslice__(self, start: int, stop: int) -> unicode: ... def __add__(self, s: unicode) -> unicode: ... def __mul__(self, n: int) -> unicode: ... def __rmul__(self, n: int) -> unicode: ... def __mod__(self, x: Any) -> unicode: ... def __eq__(self, x: object) -> bool: ... def __ne__(self, x: object) -> bool: ... def __lt__(self, x: unicode) -> bool: ... def __le__(self, x: unicode) -> bool: ... def __gt__(self, x: unicode) -> bool: ... def __ge__(self, x: unicode) -> bool: ... def __len__(self) -> int: ... # The argument type is incompatible with Sequence def __contains__(self, s: Union[unicode, bytes]) -> bool: ... # type: ignore def __iter__(self) -> Iterator[unicode]: ... def __str__(self) -> str: ... def __repr__(self) -> str: ... def __int__(self) -> int: ... def __float__(self) -> float: ... def __hash__(self) -> int: ... def __getnewargs__(self) -> Tuple[unicode]: ... class _FormatMapMapping(Protocol): def __getitem__(self, __key: str) -> Any: ... class str(Sequence[str], basestring): def __init__(self, o: object = ...) -> None: ... def capitalize(self) -> str: ... def center(self, __width: int, __fillchar: str = ...) -> str: ... def count(self, x: Text, __start: Optional[int] = ..., __end: Optional[int] = ...) -> int: ... def decode(self, encoding: Text = ..., errors: Text = ...) -> unicode: ... def encode(self, encoding: Text = ..., errors: Text = ...) -> bytes: ... def endswith(self, suffix: Union[Text, Tuple[Text, ...]]) -> bool: ... def expandtabs(self, tabsize: int = ...) -> str: ... def find(self, sub: Text, __start: Optional[int] = ..., __end: Optional[int] = ...) -> int: ... def format(self, *args: object, **kwargs: object) -> str: ... def format_map(self, map: _FormatMapMapping) -> str: ... def index(self, sub: Text, __start: Optional[int] = ..., __end: Optional[int] = ...) -> int: ... def isalnum(self) -> bool: ... def isalpha(self) -> bool: ... def isdigit(self) -> bool: ... def islower(self) -> bool: ... def isspace(self) -> bool: ... def istitle(self) -> bool: ... def isupper(self) -> bool: ... def join(self, __iterable: Iterable[AnyStr]) -> AnyStr: ... def ljust(self, __width: int, __fillchar: str = ...) -> str: ... def lower(self) -> str: ... @overload def lstrip(self, __chars: str = ...) -> str: ... @overload def lstrip(self, __chars: unicode) -> unicode: ... @overload def partition(self, __sep: bytearray) -> Tuple[str, bytearray, str]: ... @overload def partition(self, __sep: str) -> Tuple[str, str, str]: ... @overload def partition(self, __sep: unicode) -> Tuple[unicode, unicode, unicode]: ... def replace(self, __old: AnyStr, __new: AnyStr, __count: int = ...) -> AnyStr: ... def rfind(self, sub: Text, __start: Optional[int] = ..., __end: Optional[int] = ...) -> int: ... def rindex(self, sub: Text, __start: Optional[int] = ..., __end: Optional[int] = ...) -> int: ... def rjust(self, __width: int, __fillchar: str = ...) -> str: ... @overload def rpartition(self, __sep: bytearray) -> Tuple[str, bytearray, str]: ... @overload def rpartition(self, __sep: str) -> Tuple[str, str, str]: ... @overload def rpartition(self, __sep: unicode) -> Tuple[unicode, unicode, unicode]: ... @overload def rsplit(self, sep: Optional[str] = ..., maxsplit: int = ...) -> List[str]: ... @overload def rsplit(self, sep: unicode, maxsplit: int = ...) -> List[unicode]: ... @overload def rstrip(self, __chars: str = ...) -> str: ... @overload def rstrip(self, __chars: unicode) -> unicode: ... @overload def split(self, sep: Optional[str] = ..., maxsplit: int = ...) -> List[str]: ... @overload def split(self, sep: unicode, maxsplit: int = ...) -> List[unicode]: ... def splitlines(self, keepends: bool = ...) -> List[str]: ... def startswith(self, prefix: Union[Text, Tuple[Text, ...]]) -> bool: ... @overload def strip(self, __chars: str = ...) -> str: ... @overload def strip(self, chars: unicode) -> unicode: ... def swapcase(self) -> str: ... def title(self) -> str: ... def translate(self, __table: Optional[AnyStr], deletechars: AnyStr = ...) -> AnyStr: ... def upper(self) -> str: ... def zfill(self, __width: int) -> str: ... def __add__(self, s: AnyStr) -> AnyStr: ... # Incompatible with Sequence.__contains__ def __contains__(self, o: Union[str, Text]) -> bool: ... # type: ignore def __eq__(self, x: object) -> bool: ... def __ge__(self, x: Text) -> bool: ... def __getitem__(self, i: Union[int, slice]) -> str: ... def __gt__(self, x: Text) -> bool: ... def __hash__(self) -> int: ... def __iter__(self) -> Iterator[str]: ... def __le__(self, x: Text) -> bool: ... def __len__(self) -> int: ... def __lt__(self, x: Text) -> bool: ... def __mod__(self, x: Any) -> str: ... def __mul__(self, n: int) -> str: ... def __ne__(self, x: object) -> bool: ... def __repr__(self) -> str: ... def __rmul__(self, n: int) -> str: ... def __str__(self) -> str: ... def __getnewargs__(self) -> Tuple[str]: ... def __getslice__(self, start: int, stop: int) -> str: ... def __float__(self) -> float: ... def __int__(self) -> int: ... bytes = str class bytearray(MutableSequence[int], ByteString): @overload def __init__(self) -> None: ... @overload def __init__(self, ints: Iterable[int]) -> None: ... @overload def __init__(self, string: str) -> None: ... @overload def __init__(self, string: Text, encoding: Text, errors: Text = ...) -> None: ... @overload def __init__(self, length: int) -> None: ... def capitalize(self) -> bytearray: ... def center(self, __width: int, __fillchar: bytes = ...) -> bytearray: ... def count(self, __sub: str) -> int: ... def decode(self, encoding: Text = ..., errors: Text = ...) -> str: ... def endswith(self, __suffix: Union[bytes, Tuple[bytes, ...]]) -> bool: ... def expandtabs(self, tabsize: int = ...) -> bytearray: ... def extend(self, iterable: Union[str, Iterable[int]]) -> None: ... def find(self, __sub: str, __start: int = ..., __end: int = ...) -> int: ... def index(self, __sub: str, __start: int = ..., __end: int = ...) -> int: ... def insert(self, __index: int, __item: int) -> None: ... def isalnum(self) -> bool: ... def isalpha(self) -> bool: ... def isdigit(self) -> bool: ... def islower(self) -> bool: ... def isspace(self) -> bool: ... def istitle(self) -> bool: ... def isupper(self) -> bool: ... def join(self, __iterable: Iterable[str]) -> bytearray: ... def ljust(self, __width: int, __fillchar: str = ...) -> bytearray: ... def lower(self) -> bytearray: ... def lstrip(self, __bytes: Optional[bytes] = ...) -> bytearray: ... def partition(self, __sep: bytes) -> Tuple[bytearray, bytearray, bytearray]: ... def replace(self, __old: bytes, __new: bytes, __count: int = ...) -> bytearray: ... def rfind(self, __sub: bytes, __start: int = ..., __end: int = ...) -> int: ... def rindex(self, __sub: bytes, __start: int = ..., __end: int = ...) -> int: ... def rjust(self, __width: int, __fillchar: bytes = ...) -> bytearray: ... def rpartition(self, __sep: bytes) -> Tuple[bytearray, bytearray, bytearray]: ... def rsplit(self, sep: Optional[bytes] = ..., maxsplit: int = ...) -> List[bytearray]: ... def rstrip(self, __bytes: Optional[bytes] = ...) -> bytearray: ... def split(self, sep: Optional[bytes] = ..., maxsplit: int = ...) -> List[bytearray]: ... def splitlines(self, keepends: bool = ...) -> List[bytearray]: ... def startswith( self, __prefix: Union[bytes, Tuple[bytes, ...]], __start: Optional[int] = ..., __end: Optional[int] = ... ) -> bool: ... def strip(self, __bytes: Optional[bytes] = ...) -> bytearray: ... def swapcase(self) -> bytearray: ... def title(self) -> bytearray: ... def translate(self, __table: str) -> bytearray: ... def upper(self) -> bytearray: ... def zfill(self, __width: int) -> bytearray: ... @classmethod def fromhex(cls, __string: str) -> bytearray: ... def __len__(self) -> int: ... def __iter__(self) -> Iterator[int]: ... def __str__(self) -> str: ... def __repr__(self) -> str: ... def __int__(self) -> int: ... def __float__(self) -> float: ... __hash__: None # type: ignore @overload def __getitem__(self, i: int) -> int: ... @overload def __getitem__(self, s: slice) -> bytearray: ... @overload def __setitem__(self, i: int, x: int) -> None: ... @overload def __setitem__(self, s: slice, x: Union[Iterable[int], bytes]) -> None: ... def __delitem__(self, i: Union[int, slice]) -> None: ... def __getslice__(self, start: int, stop: int) -> bytearray: ... def __setslice__(self, start: int, stop: int, x: Union[Sequence[int], str]) -> None: ... def __delslice__(self, start: int, stop: int) -> None: ... def __add__(self, s: bytes) -> bytearray: ... def __mul__(self, n: int) -> bytearray: ... # Incompatible with Sequence.__contains__ def __contains__(self, o: Union[int, bytes]) -> bool: ... # type: ignore def __eq__(self, x: object) -> bool: ... def __ne__(self, x: object) -> bool: ... def __lt__(self, x: bytes) -> bool: ... def __le__(self, x: bytes) -> bool: ... def __gt__(self, x: bytes) -> bool: ... def __ge__(self, x: bytes) -> bool: ... class memoryview(Sized, Container[str]): format: str itemsize: int shape: Optional[Tuple[int, ...]] strides: Optional[Tuple[int, ...]] suboffsets: Optional[Tuple[int, ...]] readonly: bool ndim: int def __init__(self, obj: ReadableBuffer) -> None: ... @overload def __getitem__(self, i: int) -> str: ... @overload def __getitem__(self, s: slice) -> memoryview: ... def __contains__(self, x: object) -> bool: ... def __iter__(self) -> Iterator[str]: ... def __len__(self) -> int: ... @overload def __setitem__(self, s: slice, o: memoryview) -> None: ... @overload def __setitem__(self, i: int, o: bytes) -> None: ... @overload def __setitem__(self, s: slice, o: Sequence[bytes]) -> None: ... def tobytes(self) -> bytes: ... def tolist(self) -> List[int]: ... class bool(int): def __new__(cls: Type[_T], __o: object = ...) -> _T: ... @overload def __and__(self, x: bool) -> bool: ... @overload def __and__(self, x: int) -> int: ... @overload def __or__(self, x: bool) -> bool: ... @overload def __or__(self, x: int) -> int: ... @overload def __xor__(self, x: bool) -> bool: ... @overload def __xor__(self, x: int) -> int: ... @overload def __rand__(self, x: bool) -> bool: ... @overload def __rand__(self, x: int) -> int: ... @overload def __ror__(self, x: bool) -> bool: ... @overload def __ror__(self, x: int) -> int: ... @overload def __rxor__(self, x: bool) -> bool: ... @overload def __rxor__(self, x: int) -> int: ... def __getnewargs__(self) -> Tuple[int]: ... class slice(object): start: Any step: Any stop: Any @overload def __init__(self, stop: Any) -> None: ... @overload def __init__(self, start: Any, stop: Any, step: Any = ...) -> None: ... __hash__: None # type: ignore def indices(self, len: int) -> Tuple[int, int, int]: ... class tuple(Sequence[_T_co], Generic[_T_co]): def __new__(cls: Type[_T], iterable: Iterable[_T_co] = ...) -> _T: ... def __len__(self) -> int: ... def __contains__(self, x: object) -> bool: ... @overload def __getitem__(self, x: int) -> _T_co: ... @overload def __getitem__(self, x: slice) -> Tuple[_T_co, ...]: ... def __iter__(self) -> Iterator[_T_co]: ... def __lt__(self, x: Tuple[_T_co, ...]) -> bool: ... def __le__(self, x: Tuple[_T_co, ...]) -> bool: ... def __gt__(self, x: Tuple[_T_co, ...]) -> bool: ... def __ge__(self, x: Tuple[_T_co, ...]) -> bool: ... @overload def __add__(self, x: Tuple[_T_co, ...]) -> Tuple[_T_co, ...]: ... @overload def __add__(self, x: Tuple[Any, ...]) -> Tuple[Any, ...]: ... def __mul__(self, n: int) -> Tuple[_T_co, ...]: ... def __rmul__(self, n: int) -> Tuple[_T_co, ...]: ... def count(self, __value: Any) -> int: ... def index(self, __value: Any) -> int: ... class function: # TODO not defined in builtins! __name__: str __module__: str __code__: CodeType class list(MutableSequence[_T], Generic[_T]): @overload def __init__(self) -> None: ... @overload def __init__(self, iterable: Iterable[_T]) -> None: ... def append(self, __object: _T) -> None: ... def extend(self, __iterable: Iterable[_T]) -> None: ... def pop(self, __index: int = ...) -> _T: ... def index(self, __value: _T, __start: int = ..., __stop: int = ...) -> int: ... def count(self, __value: _T) -> int: ... def insert(self, __index: int, __object: _T) -> None: ... def remove(self, __value: _T) -> None: ... def reverse(self) -> None: ... def sort(self, cmp: Callable[[_T, _T], Any] = ..., key: Callable[[_T], Any] = ..., reverse: bool = ...) -> None: ... def __len__(self) -> int: ... def __iter__(self) -> Iterator[_T]: ... def __str__(self) -> str: ... __hash__: None # type: ignore @overload def __getitem__(self, i: int) -> _T: ... @overload def __getitem__(self, s: slice) -> List[_T]: ... @overload def __setitem__(self, i: int, o: _T) -> None: ... @overload def __setitem__(self, s: slice, o: Iterable[_T]) -> None: ... def __delitem__(self, i: Union[int, slice]) -> None: ... def __getslice__(self, start: int, stop: int) -> List[_T]: ... def __setslice__(self, start: int, stop: int, o: Sequence[_T]) -> None: ... def __delslice__(self, start: int, stop: int) -> None: ... def __add__(self, x: List[_T]) -> List[_T]: ... def __iadd__(self: _S, x: Iterable[_T]) -> _S: ... def __mul__(self, n: int) -> List[_T]: ... def __rmul__(self, n: int) -> List[_T]: ... def __contains__(self, o: object) -> bool: ... def __reversed__(self) -> Iterator[_T]: ... def __gt__(self, x: List[_T]) -> bool: ... def __ge__(self, x: List[_T]) -> bool: ... def __lt__(self, x: List[_T]) -> bool: ... def __le__(self, x: List[_T]) -> bool: ... class dict(MutableMapping[_KT, _VT], Generic[_KT, _VT]): # NOTE: Keyword arguments are special. If they are used, _KT must include # str, but we have no way of enforcing it here. @overload def __init__(self, **kwargs: _VT) -> None: ... @overload def __init__(self, map: SupportsKeysAndGetItem[_KT, _VT], **kwargs: _VT) -> None: ... @overload def __init__(self, iterable: Iterable[Tuple[_KT, _VT]], **kwargs: _VT) -> None: ... def __new__(cls: Type[_T1], *args: Any, **kwargs: Any) -> _T1: ... def has_key(self, k: _KT) -> bool: ... def clear(self) -> None: ... def copy(self) -> Dict[_KT, _VT]: ... def popitem(self) -> Tuple[_KT, _VT]: ... def setdefault(self, __key: _KT, __default: _VT = ...) -> _VT: ... @overload def update(self, __m: Mapping[_KT, _VT], **kwargs: _VT) -> None: ... @overload def update(self, __m: Iterable[Tuple[_KT, _VT]], **kwargs: _VT) -> None: ... @overload def update(self, **kwargs: _VT) -> None: ... def iterkeys(self) -> Iterator[_KT]: ... def itervalues(self) -> Iterator[_VT]: ... def iteritems(self) -> Iterator[Tuple[_KT, _VT]]: ... def viewkeys(self) -> KeysView[_KT]: ... def viewvalues(self) -> ValuesView[_VT]: ... def viewitems(self) -> ItemsView[_KT, _VT]: ... @classmethod @overload def fromkeys(cls, __iterable: Iterable[_T]) -> Dict[_T, Any]: ... @classmethod @overload def fromkeys(cls, __iterable: Iterable[_T], __value: _S) -> Dict[_T, _S]: ... def __len__(self) -> int: ... def __getitem__(self, k: _KT) -> _VT: ... def __setitem__(self, k: _KT, v: _VT) -> None: ... def __delitem__(self, v: _KT) -> None: ... def __iter__(self) -> Iterator[_KT]: ... def __str__(self) -> str: ... __hash__: None # type: ignore class set(MutableSet[_T], Generic[_T]): def __init__(self, iterable: Iterable[_T] = ...) -> None: ... def add(self, element: _T) -> None: ... def clear(self) -> None: ... def copy(self) -> Set[_T]: ... def difference(self, *s: Iterable[Any]) -> Set[_T]: ... def difference_update(self, *s: Iterable[Any]) -> None: ... def discard(self, element: _T) -> None: ... def intersection(self, *s: Iterable[Any]) -> Set[_T]: ... def intersection_update(self, *s: Iterable[Any]) -> None: ... def isdisjoint(self, s: Iterable[Any]) -> bool: ... def issubset(self, s: Iterable[Any]) -> bool: ... def issuperset(self, s: Iterable[Any]) -> bool: ... def pop(self) -> _T: ... def remove(self, element: _T) -> None: ... def symmetric_difference(self, s: Iterable[_T]) -> Set[_T]: ... def symmetric_difference_update(self, s: Iterable[_T]) -> None: ... def union(self, *s: Iterable[_T]) -> Set[_T]: ... def update(self, *s: Iterable[_T]) -> None: ... def __len__(self) -> int: ... def __contains__(self, o: object) -> bool: ... def __iter__(self) -> Iterator[_T]: ... def __str__(self) -> str: ... def __and__(self, s: AbstractSet[object]) -> Set[_T]: ... def __iand__(self, s: AbstractSet[object]) -> Set[_T]: ... def __or__(self, s: AbstractSet[_S]) -> Set[Union[_T, _S]]: ... def __ior__(self, s: AbstractSet[_S]) -> Set[Union[_T, _S]]: ... @overload def __sub__(self: Set[str], s: AbstractSet[Optional[Text]]) -> Set[_T]: ... @overload def __sub__(self, s: AbstractSet[Optional[_T]]) -> Set[_T]: ... @overload # type: ignore def __isub__(self: Set[str], s: AbstractSet[Optional[Text]]) -> Set[_T]: ... @overload def __isub__(self, s: AbstractSet[Optional[_T]]) -> Set[_T]: ... def __xor__(self, s: AbstractSet[_S]) -> Set[Union[_T, _S]]: ... def __ixor__(self, s: AbstractSet[_S]) -> Set[Union[_T, _S]]: ... def __le__(self, s: AbstractSet[object]) -> bool: ... def __lt__(self, s: AbstractSet[object]) -> bool: ... def __ge__(self, s: AbstractSet[object]) -> bool: ... def __gt__(self, s: AbstractSet[object]) -> bool: ... __hash__: None # type: ignore class frozenset(AbstractSet[_T_co], Generic[_T_co]): def __init__(self, iterable: Iterable[_T_co] = ...) -> None: ... def copy(self) -> FrozenSet[_T_co]: ... def difference(self, *s: Iterable[object]) -> FrozenSet[_T_co]: ... def intersection(self, *s: Iterable[object]) -> FrozenSet[_T_co]: ... def isdisjoint(self, s: Iterable[_T_co]) -> bool: ... def issubset(self, s: Iterable[object]) -> bool: ... def issuperset(self, s: Iterable[object]) -> bool: ... def symmetric_difference(self, s: Iterable[_T_co]) -> FrozenSet[_T_co]: ... def union(self, *s: Iterable[_T_co]) -> FrozenSet[_T_co]: ... def __len__(self) -> int: ... def __contains__(self, o: object) -> bool: ... def __iter__(self) -> Iterator[_T_co]: ... def __str__(self) -> str: ... def __and__(self, s: AbstractSet[_T_co]) -> FrozenSet[_T_co]: ... def __or__(self, s: AbstractSet[_S]) -> FrozenSet[Union[_T_co, _S]]: ... def __sub__(self, s: AbstractSet[_T_co]) -> FrozenSet[_T_co]: ... def __xor__(self, s: AbstractSet[_S]) -> FrozenSet[Union[_T_co, _S]]: ... def __le__(self, s: AbstractSet[object]) -> bool: ... def __lt__(self, s: AbstractSet[object]) -> bool: ... def __ge__(self, s: AbstractSet[object]) -> bool: ... def __gt__(self, s: AbstractSet[object]) -> bool: ... class enumerate(Iterator[Tuple[int, _T]], Generic[_T]): def __init__(self, iterable: Iterable[_T], start: int = ...) -> None: ... def __iter__(self) -> Iterator[Tuple[int, _T]]: ... def next(self) -> Tuple[int, _T]: ... class xrange(Sized, Iterable[int], Reversible[int]): @overload def __init__(self, stop: int) -> None: ... @overload def __init__(self, start: int, stop: int, step: int = ...) -> None: ... def __len__(self) -> int: ... def __iter__(self) -> Iterator[int]: ... def __getitem__(self, i: int) -> int: ... def __reversed__(self) -> Iterator[int]: ... class property(object): def __init__( self, fget: Optional[Callable[[Any], Any]] = ..., fset: Optional[Callable[[Any, Any], None]] = ..., fdel: Optional[Callable[[Any], None]] = ..., doc: Optional[str] = ..., ) -> None: ... def getter(self, fget: Callable[[Any], Any]) -> property: ... def setter(self, fset: Callable[[Any, Any], None]) -> property: ... def deleter(self, fdel: Callable[[Any], None]) -> property: ... def __get__(self, obj: Any, type: Optional[type] = ...) -> Any: ... def __set__(self, obj: Any, value: Any) -> None: ... def __delete__(self, obj: Any) -> None: ... def fget(self) -> Any: ... def fset(self, value: Any) -> None: ... def fdel(self) -> None: ... long = int class _NotImplementedType(Any): # type: ignore # A little weird, but typing the __call__ as NotImplemented makes the error message # for NotImplemented() much better __call__: NotImplemented # type: ignore NotImplemented: _NotImplementedType def abs(__x: SupportsAbs[_T]) -> _T: ... def all(__iterable: Iterable[object]) -> bool: ... def any(__iterable: Iterable[object]) -> bool: ... def apply(__func: Callable[..., _T], __args: Optional[Sequence[Any]] = ..., __kwds: Optional[Mapping[str, Any]] = ...) -> _T: ... def bin(__number: Union[int, _SupportsIndex]) -> str: ... def callable(__obj: object) -> bool: ... def chr(__i: int) -> str: ... def cmp(__x: Any, __y: Any) -> int: ... _N1 = TypeVar("_N1", bool, int, float, complex) def coerce(__x: _N1, __y: _N1) -> Tuple[_N1, _N1]: ... # This class is to be exported as PathLike from os, # but we define it here as _PathLike to avoid import cycle issues. # See https://github.com/python/typeshed/pull/991#issuecomment-288160993 _AnyStr_co = TypeVar("_AnyStr_co", str, bytes, covariant=True) @runtime_checkable class _PathLike(Protocol[_AnyStr_co]): def __fspath__(self) -> _AnyStr_co: ... def compile(source: Union[Text, mod], filename: Text, mode: Text, flags: int = ..., dont_inherit: int = ...) -> Any: ... def delattr(__obj: Any, __name: Text) -> None: ... def dir(__o: object = ...) -> List[str]: ... _N2 = TypeVar("_N2", int, float) def divmod(__x: _N2, __y: _N2) -> Tuple[_N2, _N2]: ... def eval( __source: Union[Text, bytes, CodeType], __globals: Optional[Dict[str, Any]] = ..., __locals: Optional[Mapping[str, Any]] = ... ) -> Any: ... def execfile(__filename: str, __globals: Optional[Dict[str, Any]] = ..., __locals: Optional[Dict[str, Any]] = ...) -> None: ... def exit(code: object = ...) -> NoReturn: ... @overload def filter(__function: Callable[[AnyStr], Any], __iterable: AnyStr) -> AnyStr: ... # type: ignore @overload def filter(__function: None, __iterable: Tuple[Optional[_T], ...]) -> Tuple[_T, ...]: ... # type: ignore @overload def filter(__function: Callable[[_T], Any], __iterable: Tuple[_T, ...]) -> Tuple[_T, ...]: ... # type: ignore @overload def filter(__function: None, __iterable: Iterable[Optional[_T]]) -> List[_T]: ... @overload def filter(__function: Callable[[_T], Any], __iterable: Iterable[_T]) -> List[_T]: ... def format(__value: object, __format_spec: str = ...) -> str: ... # TODO unicode def getattr(__o: Any, name: Text, __default: Any = ...) -> Any: ... def globals() -> Dict[str, Any]: ... def hasattr(__obj: Any, __name: Text) -> bool: ... def hash(__obj: object) -> int: ... def hex(__number: Union[int, _SupportsIndex]) -> str: ... def id(__obj: object) -> int: ... def input(__prompt: Any = ...) -> Any: ... def intern(__string: str) -> str: ... @overload def iter(__iterable: Iterable[_T]) -> Iterator[_T]: ... @overload def iter(__function: Callable[[], Optional[_T]], __sentinel: None) -> Iterator[_T]: ... @overload def iter(__function: Callable[[], _T], __sentinel: Any) -> Iterator[_T]: ... def isinstance(__obj: object, __class_or_tuple: Union[type, Tuple[Union[type, Tuple[Any, ...]], ...]]) -> bool: ... def issubclass(__cls: type, __class_or_tuple: Union[type, Tuple[Union[type, Tuple[Any, ...]], ...]]) -> bool: ... def len(__obj: Sized) -> int: ... def locals() -> Dict[str, Any]: ... @overload def map(__func: None, __iter1: Iterable[_T1]) -> List[_T1]: ... @overload def map(__func: None, __iter1: Iterable[_T1], __iter2: Iterable[_T2]) -> List[Tuple[_T1, _T2]]: ... @overload def map(__func: None, __iter1: Iterable[_T1], __iter2: Iterable[_T2], __iter3: Iterable[_T3]) -> List[Tuple[_T1, _T2, _T3]]: ... @overload def map( __func: None, __iter1: Iterable[_T1], __iter2: Iterable[_T2], __iter3: Iterable[_T3], __iter4: Iterable[_T4] ) -> List[Tuple[_T1, _T2, _T3, _T4]]: ... @overload def map( __func: None, __iter1: Iterable[_T1], __iter2: Iterable[_T2], __iter3: Iterable[_T3], __iter4: Iterable[_T4], __iter5: Iterable[_T5], ) -> List[Tuple[_T1, _T2, _T3, _T4, _T5]]: ... @overload def map( __func: None, __iter1: Iterable[Any], __iter2: Iterable[Any], __iter3: Iterable[Any], __iter4: Iterable[Any], __iter5: Iterable[Any], __iter6: Iterable[Any], *iterables: Iterable[Any], ) -> List[Tuple[Any, ...]]: ... @overload def map(__func: Callable[[_T1], _S], __iter1: Iterable[_T1]) -> List[_S]: ... @overload def map(__func: Callable[[_T1, _T2], _S], __iter1: Iterable[_T1], __iter2: Iterable[_T2]) -> List[_S]: ... @overload def map( __func: Callable[[_T1, _T2, _T3], _S], __iter1: Iterable[_T1], __iter2: Iterable[_T2], __iter3: Iterable[_T3] ) -> List[_S]: ... @overload def map( __func: Callable[[_T1, _T2, _T3, _T4], _S], __iter1: Iterable[_T1], __iter2: Iterable[_T2], __iter3: Iterable[_T3], __iter4: Iterable[_T4], ) -> List[_S]: ... @overload def map( __func: Callable[[_T1, _T2, _T3, _T4, _T5], _S], __iter1: Iterable[_T1], __iter2: Iterable[_T2], __iter3: Iterable[_T3], __iter4: Iterable[_T4], __iter5: Iterable[_T5], ) -> List[_S]: ... @overload def map( __func: Callable[..., _S], __iter1: Iterable[Any], __iter2: Iterable[Any], __iter3: Iterable[Any], __iter4: Iterable[Any], __iter5: Iterable[Any], __iter6: Iterable[Any], *iterables: Iterable[Any], ) -> List[_S]: ... @overload def max(__arg1: _T, __arg2: _T, *_args: _T, key: Callable[[_T], Any] = ...) -> _T: ... @overload def max(__iterable: Iterable[_T], *, key: Callable[[_T], Any] = ...) -> _T: ... @overload def min(__arg1: _T, __arg2: _T, *_args: _T, key: Callable[[_T], Any] = ...) -> _T: ... @overload def min(__iterable: Iterable[_T], *, key: Callable[[_T], Any] = ...) -> _T: ... @overload def next(__i: Iterator[_T]) -> _T: ... @overload def next(__i: Iterator[_T], default: _VT) -> Union[_T, _VT]: ... def oct(__number: Union[int, _SupportsIndex]) -> str: ... def open(name: Union[unicode, int], mode: unicode = ..., buffering: int = ...) -> BinaryIO: ... def ord(__c: Union[Text, bytes]) -> int: ... # This is only available after from __future__ import print_function. def print( *values: object, sep: Optional[Text] = ..., end: Optional[Text] = ..., file: Optional[SupportsWrite[Any]] = ... ) -> None: ... _E = TypeVar("_E", contravariant=True) _M = TypeVar("_M", contravariant=True) class _SupportsPow2(Protocol[_E, _T_co]): def __pow__(self, __other: _E) -> _T_co: ... class _SupportsPow3(Protocol[_E, _M, _T_co]): def __pow__(self, __other: _E, __modulo: _M) -> _T_co: ... @overload def pow(__base: int, __exp: int, __mod: None = ...) -> Any: ... # returns int or float depending on whether exp is non-negative @overload def pow(__base: int, __exp: int, __mod: int) -> int: ... @overload def pow(__base: float, __exp: float, __mod: None = ...) -> float: ... @overload def pow(__base: _SupportsPow2[_E, _T_co], __exp: _E) -> _T_co: ... @overload def pow(__base: _SupportsPow3[_E, _M, _T_co], __exp: _E, __mod: _M) -> _T_co: ... def quit(code: object = ...) -> NoReturn: ... def range(__x: int, __y: int = ..., __step: int = ...) -> List[int]: ... # noqa: F811 def raw_input(__prompt: Any = ...) -> str: ... @overload def reduce(__function: Callable[[_T, _S], _T], __iterable: Iterable[_S], __initializer: _T) -> _T: ... @overload def reduce(__function: Callable[[_T, _T], _T], __iterable: Iterable[_T]) -> _T: ... def reload(__module: Any) -> Any: ... @overload def reversed(__sequence: Sequence[_T]) -> Iterator[_T]: ... @overload def reversed(__sequence: Reversible[_T]) -> Iterator[_T]: ... def repr(__obj: object) -> str: ... @overload def round(number: float) -> float: ... @overload def round(number: float, ndigits: int) -> float: ... @overload def round(number: SupportsFloat) -> float: ... @overload def round(number: SupportsFloat, ndigits: int) -> float: ... def setattr(__obj: Any, __name: Text, __value: Any) -> None: ... def sorted( __iterable: Iterable[_T], *, cmp: Callable[[_T, _T], int] = ..., key: Optional[Callable[[_T], Any]] = ..., reverse: bool = ..., ) -> List[_T]: ... @overload def sum(__iterable: Iterable[_T]) -> Union[_T, int]: ... @overload def sum(__iterable: Iterable[_T], __start: _S) -> Union[_T, _S]: ... def unichr(__i: int) -> unicode: ... def vars(__object: Any = ...) -> Dict[str, Any]: ... @overload def zip(__iter1: Iterable[_T1]) -> List[Tuple[_T1]]: ... @overload def zip(__iter1: Iterable[_T1], __iter2: Iterable[_T2]) -> List[Tuple[_T1, _T2]]: ... @overload def zip(__iter1: Iterable[_T1], __iter2: Iterable[_T2], __iter3: Iterable[_T3]) -> List[Tuple[_T1, _T2, _T3]]: ... @overload def zip( __iter1: Iterable[_T1], __iter2: Iterable[_T2], __iter3: Iterable[_T3], __iter4: Iterable[_T4] ) -> List[Tuple[_T1, _T2, _T3, _T4]]: ... @overload def zip( __iter1: Iterable[_T1], __iter2: Iterable[_T2], __iter3: Iterable[_T3], __iter4: Iterable[_T4], __iter5: Iterable[_T5] ) -> List[Tuple[_T1, _T2, _T3, _T4, _T5]]: ... @overload def zip( __iter1: Iterable[Any], __iter2: Iterable[Any], __iter3: Iterable[Any], __iter4: Iterable[Any], __iter5: Iterable[Any], __iter6: Iterable[Any], *iterables: Iterable[Any], ) -> List[Tuple[Any, ...]]: ... def __import__( name: Text, globals: Optional[Mapping[str, Any]] = ..., locals: Optional[Mapping[str, Any]] = ..., fromlist: Sequence[str] = ..., level: int = ..., ) -> Any: ... # Actually the type of Ellipsis is , but since it's # not exposed anywhere under that name, we make it private here. class ellipsis: ... Ellipsis: ellipsis # TODO: buffer support is incomplete; e.g. some_string.startswith(some_buffer) doesn't type check. _AnyBuffer = TypeVar("_AnyBuffer", str, unicode, bytearray, buffer) class buffer(Sized): def __init__(self, object: _AnyBuffer, offset: int = ..., size: int = ...) -> None: ... def __add__(self, other: _AnyBuffer) -> str: ... def __cmp__(self, other: _AnyBuffer) -> bool: ... def __getitem__(self, key: Union[int, slice]) -> str: ... def __getslice__(self, i: int, j: int) -> str: ... def __len__(self) -> int: ... def __mul__(self, x: int) -> str: ... class BaseException(object): args: Tuple[Any, ...] message: Any def __init__(self, *args: object) -> None: ... def __str__(self) -> str: ... def __repr__(self) -> str: ... def __getitem__(self, i: int) -> Any: ... def __getslice__(self, start: int, stop: int) -> Tuple[Any, ...]: ... class GeneratorExit(BaseException): ... class KeyboardInterrupt(BaseException): ... class SystemExit(BaseException): code: int class Exception(BaseException): ... class StopIteration(Exception): ... class StandardError(Exception): ... _StandardError = StandardError class EnvironmentError(StandardError): errno: int strerror: str # TODO can this be unicode? filename: str class OSError(EnvironmentError): ... class IOError(EnvironmentError): ... class ArithmeticError(_StandardError): ... class AssertionError(_StandardError): ... class AttributeError(_StandardError): ... class BufferError(_StandardError): ... class EOFError(_StandardError): ... class ImportError(_StandardError): ... class LookupError(_StandardError): ... class MemoryError(_StandardError): ... class NameError(_StandardError): ... class ReferenceError(_StandardError): ... class RuntimeError(_StandardError): ... class SyntaxError(_StandardError): msg: str lineno: Optional[int] offset: Optional[int] text: Optional[str] filename: Optional[str] class SystemError(_StandardError): ... class TypeError(_StandardError): ... class ValueError(_StandardError): ... class FloatingPointError(ArithmeticError): ... class OverflowError(ArithmeticError): ... class ZeroDivisionError(ArithmeticError): ... class IndexError(LookupError): ... class KeyError(LookupError): ... class UnboundLocalError(NameError): ... class WindowsError(OSError): winerror: int class NotImplementedError(RuntimeError): ... class IndentationError(SyntaxError): ... class TabError(IndentationError): ... class UnicodeError(ValueError): ... class UnicodeDecodeError(UnicodeError): encoding: str object: bytes start: int end: int reason: str def __init__(self, __encoding: str, __object: bytes, __start: int, __end: int, __reason: str) -> None: ... class UnicodeEncodeError(UnicodeError): encoding: str object: Text start: int end: int reason: str def __init__(self, __encoding: str, __object: Text, __start: int, __end: int, __reason: str) -> None: ... class UnicodeTranslateError(UnicodeError): ... class Warning(Exception): ... class UserWarning(Warning): ... class DeprecationWarning(Warning): ... class SyntaxWarning(Warning): ... class RuntimeWarning(Warning): ... class FutureWarning(Warning): ... class PendingDeprecationWarning(Warning): ... class ImportWarning(Warning): ... class UnicodeWarning(Warning): ... class BytesWarning(Warning): ... class file(BinaryIO): @overload def __init__(self, file: str, mode: str = ..., buffering: int = ...) -> None: ... @overload def __init__(self, file: unicode, mode: str = ..., buffering: int = ...) -> None: ... @overload def __init__(self, file: int, mode: str = ..., buffering: int = ...) -> None: ... def __iter__(self) -> Iterator[str]: ... def next(self) -> str: ... def read(self, n: int = ...) -> str: ... def __enter__(self) -> BinaryIO: ... def __exit__( self, t: Optional[type] = ..., exc: Optional[BaseException] = ..., tb: Optional[Any] = ... ) -> Optional[bool]: ... def flush(self) -> None: ... def fileno(self) -> int: ... def isatty(self) -> bool: ... def close(self) -> None: ... def readable(self) -> bool: ... def writable(self) -> bool: ... def seekable(self) -> bool: ... def seek(self, offset: int, whence: int = ...) -> int: ... def tell(self) -> int: ... def readline(self, limit: int = ...) -> str: ... def readlines(self, hint: int = ...) -> List[str]: ... def write(self, data: str) -> int: ... def writelines(self, data: Iterable[str]) -> None: ... def truncate(self, pos: Optional[int] = ...) -> int: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/_ast.pyi0000664000175000017500000001313600000000000022570 0ustar00davedave00000000000000import typing from typing import Optional __version__: str PyCF_ONLY_AST: int _identifier = str class AST: _attributes: typing.Tuple[str, ...] _fields: typing.Tuple[str, ...] def __init__(self, *args, **kwargs) -> None: ... class mod(AST): ... class Module(mod): body: typing.List[stmt] class Interactive(mod): body: typing.List[stmt] class Expression(mod): body: expr class Suite(mod): body: typing.List[stmt] class stmt(AST): lineno: int col_offset: int class FunctionDef(stmt): name: _identifier args: arguments body: typing.List[stmt] decorator_list: typing.List[expr] class ClassDef(stmt): name: _identifier bases: typing.List[expr] body: typing.List[stmt] decorator_list: typing.List[expr] class Return(stmt): value: Optional[expr] class Delete(stmt): targets: typing.List[expr] class Assign(stmt): targets: typing.List[expr] value: expr class AugAssign(stmt): target: expr op: operator value: expr class Print(stmt): dest: Optional[expr] values: typing.List[expr] nl: bool class For(stmt): target: expr iter: expr body: typing.List[stmt] orelse: typing.List[stmt] class While(stmt): test: expr body: typing.List[stmt] orelse: typing.List[stmt] class If(stmt): test: expr body: typing.List[stmt] orelse: typing.List[stmt] class With(stmt): context_expr: expr optional_vars: Optional[expr] body: typing.List[stmt] class Raise(stmt): type: Optional[expr] inst: Optional[expr] tback: Optional[expr] class TryExcept(stmt): body: typing.List[stmt] handlers: typing.List[ExceptHandler] orelse: typing.List[stmt] class TryFinally(stmt): body: typing.List[stmt] finalbody: typing.List[stmt] class Assert(stmt): test: expr msg: Optional[expr] class Import(stmt): names: typing.List[alias] class ImportFrom(stmt): module: Optional[_identifier] names: typing.List[alias] level: Optional[int] class Exec(stmt): body: expr globals: Optional[expr] locals: Optional[expr] class Global(stmt): names: typing.List[_identifier] class Expr(stmt): value: expr class Pass(stmt): ... class Break(stmt): ... class Continue(stmt): ... class slice(AST): ... _slice = slice # this lets us type the variable named 'slice' below class Slice(slice): lower: Optional[expr] upper: Optional[expr] step: Optional[expr] class ExtSlice(slice): dims: typing.List[slice] class Index(slice): value: expr class Ellipsis(slice): ... class expr(AST): lineno: int col_offset: int class BoolOp(expr): op: boolop values: typing.List[expr] class BinOp(expr): left: expr op: operator right: expr class UnaryOp(expr): op: unaryop operand: expr class Lambda(expr): args: arguments body: expr class IfExp(expr): test: expr body: expr orelse: expr class Dict(expr): keys: typing.List[expr] values: typing.List[expr] class Set(expr): elts: typing.List[expr] class ListComp(expr): elt: expr generators: typing.List[comprehension] class SetComp(expr): elt: expr generators: typing.List[comprehension] class DictComp(expr): key: expr value: expr generators: typing.List[comprehension] class GeneratorExp(expr): elt: expr generators: typing.List[comprehension] class Yield(expr): value: Optional[expr] class Compare(expr): left: expr ops: typing.List[cmpop] comparators: typing.List[expr] class Call(expr): func: expr args: typing.List[expr] keywords: typing.List[keyword] starargs: Optional[expr] kwargs: Optional[expr] class Repr(expr): value: expr class Num(expr): n: float class Str(expr): s: str class Attribute(expr): value: expr attr: _identifier ctx: expr_context class Subscript(expr): value: expr slice: _slice ctx: expr_context class Name(expr): id: _identifier ctx: expr_context class List(expr): elts: typing.List[expr] ctx: expr_context class Tuple(expr): elts: typing.List[expr] ctx: expr_context class expr_context(AST): ... class AugLoad(expr_context): ... class AugStore(expr_context): ... class Del(expr_context): ... class Load(expr_context): ... class Param(expr_context): ... class Store(expr_context): ... class boolop(AST): ... class And(boolop): ... class Or(boolop): ... class operator(AST): ... class Add(operator): ... class BitAnd(operator): ... class BitOr(operator): ... class BitXor(operator): ... class Div(operator): ... class FloorDiv(operator): ... class LShift(operator): ... class Mod(operator): ... class Mult(operator): ... class Pow(operator): ... class RShift(operator): ... class Sub(operator): ... class unaryop(AST): ... class Invert(unaryop): ... class Not(unaryop): ... class UAdd(unaryop): ... class USub(unaryop): ... class cmpop(AST): ... class Eq(cmpop): ... class Gt(cmpop): ... class GtE(cmpop): ... class In(cmpop): ... class Is(cmpop): ... class IsNot(cmpop): ... class Lt(cmpop): ... class LtE(cmpop): ... class NotEq(cmpop): ... class NotIn(cmpop): ... class comprehension(AST): target: expr iter: expr ifs: typing.List[expr] class excepthandler(AST): ... class ExceptHandler(excepthandler): type: Optional[expr] name: Optional[expr] body: typing.List[stmt] lineno: int col_offset: int class arguments(AST): args: typing.List[expr] vararg: Optional[_identifier] kwarg: Optional[_identifier] defaults: typing.List[expr] class keyword(AST): arg: _identifier value: expr class alias(AST): name: _identifier asname: Optional[_identifier] ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/_collections.pyi0000664000175000017500000000262600000000000024321 0ustar00davedave00000000000000from typing import Any, Callable, Dict, Generic, Iterator, Optional, TypeVar, Union _K = TypeVar("_K") _V = TypeVar("_V") _T = TypeVar("_T") _T2 = TypeVar("_T2") class defaultdict(Dict[_K, _V]): default_factory: None def __init__(self, __default_factory: Callable[[], _V] = ..., init: Any = ...) -> None: ... def __missing__(self, key: _K) -> _V: ... def __copy__(self: _T) -> _T: ... def copy(self: _T) -> _T: ... class deque(Generic[_T]): maxlen: Optional[int] def __init__(self, iterable: Iterator[_T] = ..., maxlen: int = ...) -> None: ... def append(self, x: _T) -> None: ... def appendleft(self, x: _T) -> None: ... def clear(self) -> None: ... def count(self, x: Any) -> int: ... def extend(self, iterable: Iterator[_T]) -> None: ... def extendleft(self, iterable: Iterator[_T]) -> None: ... def pop(self) -> _T: ... def popleft(self) -> _T: ... def remove(self, value: _T) -> None: ... def reverse(self) -> None: ... def rotate(self, n: int = ...) -> None: ... def __contains__(self, o: Any) -> bool: ... def __copy__(self) -> deque[_T]: ... def __getitem__(self, i: int) -> _T: ... def __iadd__(self, other: deque[_T2]) -> deque[Union[_T, _T2]]: ... def __iter__(self) -> Iterator[_T]: ... def __len__(self) -> int: ... def __reversed__(self) -> Iterator[_T]: ... def __setitem__(self, i: int, x: _T) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/_functools.pyi0000664000175000017500000000110000000000000024001 0ustar00davedave00000000000000from typing import Any, Callable, Dict, Iterable, Optional, Tuple, TypeVar, overload _T = TypeVar("_T") _S = TypeVar("_S") @overload def reduce(function: Callable[[_T, _T], _T], sequence: Iterable[_T]) -> _T: ... @overload def reduce(function: Callable[[_T, _S], _T], sequence: Iterable[_S], initial: _T) -> _T: ... class partial(object): func: Callable[..., Any] args: Tuple[Any, ...] keywords: Dict[str, Any] def __init__(self, func: Callable[..., Any], *args: Any, **kwargs: Any) -> None: ... def __call__(self, *args: Any, **kwargs: Any) -> Any: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/_hotshot.pyi0000664000175000017500000000117300000000000023467 0ustar00davedave00000000000000from typing import Any, Dict, Generic, List, Tuple def coverage(a: str) -> Any: ... def logreader(a: str) -> LogReaderType: ... def profiler(a: str, *args, **kwargs) -> Any: ... def resolution() -> Tuple[Any, ...]: ... class LogReaderType(object): def close(self) -> None: ... def fileno(self) -> int: ... class ProfilerType(object): def addinfo(self, a: str, b: str) -> None: ... def close(self) -> None: ... def fileno(self) -> int: ... def runcall(self, *args, **kwargs) -> Any: ... def runcode(self, a, b, *args, **kwargs) -> Any: ... def start(self) -> None: ... def stop(self) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/_io.pyi0000664000175000017500000001555000000000000022412 0ustar00davedave00000000000000from mmap import mmap from types import TracebackType from typing import IO, Any, AnyStr, BinaryIO, Iterable, Iterator, List, Optional, Text, TextIO, Tuple, Type, TypeVar, Union _bytearray_like = Union[bytearray, mmap] DEFAULT_BUFFER_SIZE: int class BlockingIOError(IOError): characters_written: int class UnsupportedOperation(ValueError, IOError): ... _T = TypeVar("_T") class _IOBase(BinaryIO): @property def closed(self) -> bool: ... def _checkClosed(self, msg: Optional[str] = ...) -> None: ... # undocumented def _checkReadable(self) -> None: ... def _checkSeekable(self) -> None: ... def _checkWritable(self) -> None: ... # All these methods are concrete here (you can instantiate this) def close(self) -> None: ... def fileno(self) -> int: ... def flush(self) -> None: ... def isatty(self) -> bool: ... def readable(self) -> bool: ... def seek(self, offset: int, whence: int = ...) -> int: ... def seekable(self) -> bool: ... def tell(self) -> int: ... def truncate(self, size: Optional[int] = ...) -> int: ... def writable(self) -> bool: ... def __enter__(self: _T) -> _T: ... def __exit__( self, t: Optional[Type[BaseException]], value: Optional[BaseException], traceback: Optional[Any] ) -> Optional[bool]: ... def __iter__(self: _T) -> _T: ... # The parameter type of writelines[s]() is determined by that of write(): def writelines(self, lines: Iterable[bytes]) -> None: ... # The return type of readline[s]() and next() is determined by that of read(): def readline(self, limit: int = ...) -> bytes: ... def readlines(self, hint: int = ...) -> List[bytes]: ... def next(self) -> bytes: ... # These don't actually exist but we need to pretend that it does # so that this class is concrete. def write(self, s: bytes) -> int: ... def read(self, n: int = ...) -> bytes: ... class _BufferedIOBase(_IOBase): def read1(self, n: int) -> bytes: ... def read(self, size: int = ...) -> bytes: ... def readinto(self, buffer: _bytearray_like) -> int: ... def write(self, s: bytes) -> int: ... def detach(self) -> _IOBase: ... class BufferedRWPair(_BufferedIOBase): def __init__(self, reader: _RawIOBase, writer: _RawIOBase, buffer_size: int = ..., max_buffer_size: int = ...) -> None: ... def peek(self, n: int = ...) -> bytes: ... def __enter__(self) -> BufferedRWPair: ... class BufferedRandom(_BufferedIOBase): mode: str name: str raw: _IOBase def __init__(self, raw: _IOBase, buffer_size: int = ..., max_buffer_size: int = ...) -> None: ... def peek(self, n: int = ...) -> bytes: ... class BufferedReader(_BufferedIOBase): mode: str name: str raw: _IOBase def __init__(self, raw: _IOBase, buffer_size: int = ...) -> None: ... def peek(self, n: int = ...) -> bytes: ... class BufferedWriter(_BufferedIOBase): name: str raw: _IOBase mode: str def __init__(self, raw: _IOBase, buffer_size: int = ..., max_buffer_size: int = ...) -> None: ... class BytesIO(_BufferedIOBase): def __init__(self, initial_bytes: bytes = ...) -> None: ... def __setstate__(self, state: Tuple[Any, ...]) -> None: ... def __getstate__(self) -> Tuple[Any, ...]: ... # BytesIO does not contain a "name" field. This workaround is necessary # to allow BytesIO sub-classes to add this field, as it is defined # as a read-only property on IO[]. name: Any def getvalue(self) -> bytes: ... def write(self, s: bytes) -> int: ... def writelines(self, lines: Iterable[bytes]) -> None: ... def read1(self, size: int) -> bytes: ... def next(self) -> bytes: ... class _RawIOBase(_IOBase): def readall(self) -> str: ... def read(self, n: int = ...) -> str: ... class FileIO(_RawIOBase, BytesIO): mode: str closefd: bool def __init__(self, file: Union[str, int], mode: str = ..., closefd: bool = ...) -> None: ... def readinto(self, buffer: _bytearray_like) -> int: ... def write(self, pbuf: str) -> int: ... class IncrementalNewlineDecoder(object): newlines: Union[str, unicode] def __init__(self, decoder, translate, z=...) -> None: ... def decode(self, input, final) -> Any: ... def getstate(self) -> Tuple[Any, int]: ... def setstate(self, state: Tuple[Any, int]) -> None: ... def reset(self) -> None: ... # Note: In the actual _io.py, _TextIOBase inherits from _IOBase. class _TextIOBase(TextIO): errors: Optional[str] # TODO: On _TextIOBase, this is always None. But it's unicode/bytes in subclasses. newlines: Union[None, unicode, bytes] encoding: str @property def closed(self) -> bool: ... def _checkClosed(self) -> None: ... def _checkReadable(self) -> None: ... def _checkSeekable(self) -> None: ... def _checkWritable(self) -> None: ... def close(self) -> None: ... def detach(self) -> IO[Any]: ... def fileno(self) -> int: ... def flush(self) -> None: ... def isatty(self) -> bool: ... def next(self) -> unicode: ... def read(self, size: int = ...) -> unicode: ... def readable(self) -> bool: ... def readline(self, limit: int = ...) -> unicode: ... def readlines(self, hint: int = ...) -> list[unicode]: ... def seek(self, offset: int, whence: int = ...) -> int: ... def seekable(self) -> bool: ... def tell(self) -> int: ... def truncate(self, size: Optional[int] = ...) -> int: ... def writable(self) -> bool: ... def write(self, pbuf: unicode) -> int: ... def writelines(self, lines: Iterable[unicode]) -> None: ... def __enter__(self: _T) -> _T: ... def __exit__( self, t: Optional[Type[BaseException]], value: Optional[BaseException], traceback: Optional[Any] ) -> Optional[bool]: ... def __iter__(self: _T) -> _T: ... class StringIO(_TextIOBase): line_buffering: bool def __init__(self, initial_value: Optional[unicode] = ..., newline: Optional[unicode] = ...) -> None: ... def __setstate__(self, state: Tuple[Any, ...]) -> None: ... def __getstate__(self) -> Tuple[Any, ...]: ... # StringIO does not contain a "name" field. This workaround is necessary # to allow StringIO sub-classes to add this field, as it is defined # as a read-only property on IO[]. name: Any def getvalue(self) -> unicode: ... class TextIOWrapper(_TextIOBase): name: str line_buffering: bool buffer: BinaryIO _CHUNK_SIZE: int def __init__( self, buffer: IO[Any], encoding: Optional[Text] = ..., errors: Optional[Text] = ..., newline: Optional[Text] = ..., line_buffering: bool = ..., write_through: bool = ..., ) -> None: ... def open( file: Union[str, unicode, int], mode: Text = ..., buffering: int = ..., encoding: Optional[Text] = ..., errors: Optional[Text] = ..., newline: Optional[Text] = ..., closefd: bool = ..., ) -> IO[Any]: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/_json.pyi0000664000175000017500000000034200000000000022745 0ustar00davedave00000000000000from typing import Any, Dict, Generic, List, Tuple def encode_basestring_ascii(*args, **kwargs) -> str: ... def scanstring(a, b, *args, **kwargs) -> Tuple[Any, ...]: ... class Encoder(object): ... class Scanner(object): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/_md5.pyi0000664000175000017500000000045400000000000022465 0ustar00davedave00000000000000blocksize: int digest_size: int class MD5Type(object): name: str block_size: int digest_size: int def copy(self) -> MD5Type: ... def digest(self) -> str: ... def hexdigest(self) -> str: ... def update(self, arg: str) -> None: ... def new(arg: str = ...) -> MD5Type: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/_sha.pyi0000664000175000017500000000053400000000000022552 0ustar00davedave00000000000000blocksize: int block_size: int digest_size: int class sha(object): # not actually exposed name: str block_size: int digest_size: int digestsize: int def copy(self) -> sha: ... def digest(self) -> str: ... def hexdigest(self) -> str: ... def update(self, arg: str) -> None: ... def new(arg: str = ...) -> sha: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/_sha256.pyi0000664000175000017500000000117000000000000023004 0ustar00davedave00000000000000from typing import Optional class sha224(object): name: str block_size: int digest_size: int digestsize: int def __init__(self, init: Optional[str]) -> None: ... def copy(self) -> sha224: ... def digest(self) -> str: ... def hexdigest(self) -> str: ... def update(self, arg: str) -> None: ... class sha256(object): name: str block_size: int digest_size: int digestsize: int def __init__(self, init: Optional[str]) -> None: ... def copy(self) -> sha256: ... def digest(self) -> str: ... def hexdigest(self) -> str: ... def update(self, arg: str) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/_sha512.pyi0000664000175000017500000000117000000000000022777 0ustar00davedave00000000000000from typing import Optional class sha384(object): name: str block_size: int digest_size: int digestsize: int def __init__(self, init: Optional[str]) -> None: ... def copy(self) -> sha384: ... def digest(self) -> str: ... def hexdigest(self) -> str: ... def update(self, arg: str) -> None: ... class sha512(object): name: str block_size: int digest_size: int digestsize: int def __init__(self, init: Optional[str]) -> None: ... def copy(self) -> sha512: ... def digest(self) -> str: ... def hexdigest(self) -> str: ... def update(self, arg: str) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/_socket.pyi0000664000175000017500000001421600000000000023271 0ustar00davedave00000000000000from typing import IO, Any, Optional, Tuple, Union, overload AF_APPLETALK: int AF_ASH: int AF_ATMPVC: int AF_ATMSVC: int AF_AX25: int AF_BLUETOOTH: int AF_BRIDGE: int AF_DECnet: int AF_ECONET: int AF_INET: int AF_INET6: int AF_IPX: int AF_IRDA: int AF_KEY: int AF_LLC: int AF_NETBEUI: int AF_NETLINK: int AF_NETROM: int AF_PACKET: int AF_PPPOX: int AF_ROSE: int AF_ROUTE: int AF_SECURITY: int AF_SNA: int AF_TIPC: int AF_UNIX: int AF_UNSPEC: int AF_WANPIPE: int AF_X25: int AI_ADDRCONFIG: int AI_ALL: int AI_CANONNAME: int AI_NUMERICHOST: int AI_NUMERICSERV: int AI_PASSIVE: int AI_V4MAPPED: int BDADDR_ANY: str BDADDR_LOCAL: str BTPROTO_HCI: int BTPROTO_L2CAP: int BTPROTO_RFCOMM: int BTPROTO_SCO: int EAI_ADDRFAMILY: int EAI_AGAIN: int EAI_BADFLAGS: int EAI_FAIL: int EAI_FAMILY: int EAI_MEMORY: int EAI_NODATA: int EAI_NONAME: int EAI_OVERFLOW: int EAI_SERVICE: int EAI_SOCKTYPE: int EAI_SYSTEM: int EBADF: int EINTR: int HCI_DATA_DIR: int HCI_FILTER: int HCI_TIME_STAMP: int INADDR_ALLHOSTS_GROUP: int INADDR_ANY: int INADDR_BROADCAST: int INADDR_LOOPBACK: int INADDR_MAX_LOCAL_GROUP: int INADDR_NONE: int INADDR_UNSPEC_GROUP: int IPPORT_RESERVED: int IPPORT_USERRESERVED: int IPPROTO_AH: int IPPROTO_DSTOPTS: int IPPROTO_EGP: int IPPROTO_ESP: int IPPROTO_FRAGMENT: int IPPROTO_GRE: int IPPROTO_HOPOPTS: int IPPROTO_ICMP: int IPPROTO_ICMPV6: int IPPROTO_IDP: int IPPROTO_IGMP: int IPPROTO_IP: int IPPROTO_IPIP: int IPPROTO_IPV6: int IPPROTO_NONE: int IPPROTO_PIM: int IPPROTO_PUP: int IPPROTO_RAW: int IPPROTO_ROUTING: int IPPROTO_RSVP: int IPPROTO_TCP: int IPPROTO_TP: int IPPROTO_UDP: int IPV6_CHECKSUM: int IPV6_DSTOPTS: int IPV6_HOPLIMIT: int IPV6_HOPOPTS: int IPV6_JOIN_GROUP: int IPV6_LEAVE_GROUP: int IPV6_MULTICAST_HOPS: int IPV6_MULTICAST_IF: int IPV6_MULTICAST_LOOP: int IPV6_NEXTHOP: int IPV6_PKTINFO: int IPV6_RECVDSTOPTS: int IPV6_RECVHOPLIMIT: int IPV6_RECVHOPOPTS: int IPV6_RECVPKTINFO: int IPV6_RECVRTHDR: int IPV6_RECVTCLASS: int IPV6_RTHDR: int IPV6_RTHDRDSTOPTS: int IPV6_RTHDR_TYPE_0: int IPV6_TCLASS: int IPV6_UNICAST_HOPS: int IPV6_V6ONLY: int IP_ADD_MEMBERSHIP: int IP_DEFAULT_MULTICAST_LOOP: int IP_DEFAULT_MULTICAST_TTL: int IP_DROP_MEMBERSHIP: int IP_HDRINCL: int IP_MAX_MEMBERSHIPS: int IP_MULTICAST_IF: int IP_MULTICAST_LOOP: int IP_MULTICAST_TTL: int IP_OPTIONS: int IP_RECVOPTS: int IP_RECVRETOPTS: int IP_RETOPTS: int IP_TOS: int IP_TTL: int MSG_CTRUNC: int MSG_DONTROUTE: int MSG_DONTWAIT: int MSG_EOR: int MSG_OOB: int MSG_PEEK: int MSG_TRUNC: int MSG_WAITALL: int MethodType: type NETLINK_DNRTMSG: int NETLINK_FIREWALL: int NETLINK_IP6_FW: int NETLINK_NFLOG: int NETLINK_ROUTE: int NETLINK_USERSOCK: int NETLINK_XFRM: int NI_DGRAM: int NI_MAXHOST: int NI_MAXSERV: int NI_NAMEREQD: int NI_NOFQDN: int NI_NUMERICHOST: int NI_NUMERICSERV: int PACKET_BROADCAST: int PACKET_FASTROUTE: int PACKET_HOST: int PACKET_LOOPBACK: int PACKET_MULTICAST: int PACKET_OTHERHOST: int PACKET_OUTGOING: int PF_PACKET: int SHUT_RD: int SHUT_RDWR: int SHUT_WR: int SOCK_DGRAM: int SOCK_RAW: int SOCK_RDM: int SOCK_SEQPACKET: int SOCK_STREAM: int SOL_HCI: int SOL_IP: int SOL_SOCKET: int SOL_TCP: int SOL_TIPC: int SOL_UDP: int SOMAXCONN: int SO_ACCEPTCONN: int SO_BROADCAST: int SO_DEBUG: int SO_DONTROUTE: int SO_ERROR: int SO_KEEPALIVE: int SO_LINGER: int SO_OOBINLINE: int SO_RCVBUF: int SO_RCVLOWAT: int SO_RCVTIMEO: int SO_REUSEADDR: int SO_REUSEPORT: int SO_SNDBUF: int SO_SNDLOWAT: int SO_SNDTIMEO: int SO_TYPE: int SSL_ERROR_EOF: int SSL_ERROR_INVALID_ERROR_CODE: int SSL_ERROR_SSL: int SSL_ERROR_SYSCALL: int SSL_ERROR_WANT_CONNECT: int SSL_ERROR_WANT_READ: int SSL_ERROR_WANT_WRITE: int SSL_ERROR_WANT_X509_LOOKUP: int SSL_ERROR_ZERO_RETURN: int TCP_CORK: int TCP_DEFER_ACCEPT: int TCP_INFO: int TCP_KEEPCNT: int TCP_KEEPIDLE: int TCP_KEEPINTVL: int TCP_LINGER2: int TCP_MAXSEG: int TCP_NODELAY: int TCP_QUICKACK: int TCP_SYNCNT: int TCP_WINDOW_CLAMP: int TIPC_ADDR_ID: int TIPC_ADDR_NAME: int TIPC_ADDR_NAMESEQ: int TIPC_CFG_SRV: int TIPC_CLUSTER_SCOPE: int TIPC_CONN_TIMEOUT: int TIPC_CRITICAL_IMPORTANCE: int TIPC_DEST_DROPPABLE: int TIPC_HIGH_IMPORTANCE: int TIPC_IMPORTANCE: int TIPC_LOW_IMPORTANCE: int TIPC_MEDIUM_IMPORTANCE: int TIPC_NODE_SCOPE: int TIPC_PUBLISHED: int TIPC_SRC_DROPPABLE: int TIPC_SUBSCR_TIMEOUT: int TIPC_SUB_CANCEL: int TIPC_SUB_PORTS: int TIPC_SUB_SERVICE: int TIPC_TOP_SRV: int TIPC_WAIT_FOREVER: int TIPC_WITHDRAWN: int TIPC_ZONE_SCOPE: int # PyCapsule CAPI: Any has_ipv6: bool class error(IOError): ... class gaierror(error): ... class timeout(error): ... class SocketType(object): family: int type: int proto: int timeout: float def __init__(self, family: int = ..., type: int = ..., proto: int = ...) -> None: ... def accept(self) -> Tuple[SocketType, Tuple[Any, ...]]: ... def bind(self, address: Tuple[Any, ...]) -> None: ... def close(self) -> None: ... def connect(self, address: Tuple[Any, ...]) -> None: ... def connect_ex(self, address: Tuple[Any, ...]) -> int: ... def dup(self) -> SocketType: ... def fileno(self) -> int: ... def getpeername(self) -> Tuple[Any, ...]: ... def getsockname(self) -> Tuple[Any, ...]: ... def getsockopt(self, level: int, option: int, buffersize: int = ...) -> str: ... def gettimeout(self) -> float: ... def listen(self, backlog: int) -> None: ... def makefile(self, mode: str = ..., buffersize: int = ...) -> IO[Any]: ... def recv(self, buffersize: int, flags: int = ...) -> str: ... def recv_into(self, buffer: bytearray, nbytes: int = ..., flags: int = ...) -> int: ... def recvfrom(self, buffersize: int, flags: int = ...) -> Tuple[Any, ...]: ... def recvfrom_into(self, buffer: bytearray, nbytes: int = ..., flags: int = ...) -> int: ... def send(self, data: str, flags: int = ...) -> int: ... def sendall(self, data: str, flags: int = ...) -> None: ... @overload def sendto(self, data: str, address: Tuple[Any, ...]) -> int: ... @overload def sendto(self, data: str, flags: int, address: Tuple[Any, ...]) -> int: ... def setblocking(self, flag: bool) -> None: ... def setsockopt(self, level: int, option: int, value: Union[int, str]) -> None: ... def settimeout(self, value: Optional[float]) -> None: ... def shutdown(self, flag: int) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/_sre.pyi0000664000175000017500000000361600000000000022574 0ustar00davedave00000000000000from typing import Any, Dict, Iterable, List, Mapping, Optional, Sequence, Tuple, Union, overload CODESIZE: int MAGIC: int MAXREPEAT: long copyright: str class SRE_Match(object): def start(self, group: int = ...) -> int: ... def end(self, group: int = ...) -> int: ... def expand(self, s: str) -> Any: ... @overload def group(self) -> str: ... @overload def group(self, group: int = ...) -> Optional[str]: ... def groupdict(self) -> Dict[int, Optional[str]]: ... def groups(self) -> Tuple[Optional[str], ...]: ... def span(self) -> Tuple[int, int]: ... @property def regs(self) -> Tuple[Tuple[int, int], ...]: ... # undocumented class SRE_Scanner(object): pattern: str def match(self) -> SRE_Match: ... def search(self) -> SRE_Match: ... class SRE_Pattern(object): pattern: str flags: int groups: int groupindex: Mapping[str, int] indexgroup: Sequence[int] def findall(self, source: str, pos: int = ..., endpos: int = ...) -> List[Union[Tuple[Any, ...], str]]: ... def finditer(self, source: str, pos: int = ..., endpos: int = ...) -> Iterable[Union[Tuple[Any, ...], str]]: ... def match(self, pattern, pos: int = ..., endpos: int = ...) -> SRE_Match: ... def scanner(self, s: str, start: int = ..., end: int = ...) -> SRE_Scanner: ... def search(self, pattern, pos: int = ..., endpos: int = ...) -> SRE_Match: ... def split(self, source: str, maxsplit: int = ...) -> List[Optional[str]]: ... def sub(self, repl: str, string: str, count: int = ...) -> Tuple[Any, ...]: ... def subn(self, repl: str, string: str, count: int = ...) -> Tuple[Any, ...]: ... def compile( pattern: str, flags: int, code: List[int], groups: int = ..., groupindex: Mapping[str, int] = ..., indexgroup: Sequence[int] = ..., ) -> SRE_Pattern: ... def getcodesize() -> int: ... def getlower(a: int, b: int) -> int: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/_struct.pyi0000664000175000017500000000137700000000000023331 0ustar00davedave00000000000000from typing import Any, AnyStr, Tuple class error(Exception): ... class Struct(object): size: int format: str def __init__(self, fmt: str) -> None: ... def pack_into(self, buffer: bytearray, offset: int, obj: Any) -> None: ... def pack(self, *args) -> str: ... def unpack(self, s: str) -> Tuple[Any, ...]: ... def unpack_from(self, buffer: bytearray, offset: int = ...) -> Tuple[Any, ...]: ... def _clearcache() -> None: ... def calcsize(fmt: str) -> int: ... def pack(fmt: AnyStr, obj: Any) -> str: ... def pack_into(fmt: AnyStr, buffer: bytearray, offset: int, obj: Any) -> None: ... def unpack(fmt: AnyStr, data: str) -> Tuple[Any, ...]: ... def unpack_from(fmt: AnyStr, buffer: bytearray, offset: int = ...) -> Tuple[Any, ...]: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/_symtable.pyi0000664000175000017500000000124500000000000023617 0ustar00davedave00000000000000from typing import Dict, List CELL: int DEF_BOUND: int DEF_FREE: int DEF_FREE_CLASS: int DEF_GLOBAL: int DEF_IMPORT: int DEF_LOCAL: int DEF_PARAM: int FREE: int GLOBAL_EXPLICIT: int GLOBAL_IMPLICIT: int LOCAL: int OPT_BARE_EXEC: int OPT_EXEC: int OPT_IMPORT_STAR: int SCOPE_MASK: int SCOPE_OFF: int TYPE_CLASS: int TYPE_FUNCTION: int TYPE_MODULE: int USE: int class _symtable_entry(object): ... class symtable(object): children: List[_symtable_entry] id: int lineno: int name: str nested: int optimized: int symbols: Dict[str, int] type: int varnames: List[str] def __init__(self, src: str, filename: str, startstr: str) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/_threading_local.pyi0000664000175000017500000000047700000000000025124 0ustar00davedave00000000000000from typing import Any class _localbase(object): ... class local(_localbase): def __getattribute__(self, name: str) -> Any: ... def __setattr__(self, name: str, value: Any) -> None: ... def __delattr__(self, name: str) -> None: ... def __del__(self) -> None: ... def _patch(self: local) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/_winreg.pyi0000664000175000017500000000716000000000000023274 0ustar00davedave00000000000000import sys from types import TracebackType from typing import Any, Optional, Tuple, Type, Union _KeyType = Union[HKEYType, int] def CloseKey(__hkey: _KeyType) -> None: ... def ConnectRegistry(__computer_name: Optional[str], __key: _KeyType) -> HKEYType: ... def CreateKey(__key: _KeyType, __sub_key: Optional[str]) -> HKEYType: ... def CreateKeyEx(key: _KeyType, sub_key: Optional[str], reserved: int = ..., access: int = ...) -> HKEYType: ... def DeleteKey(__key: _KeyType, __sub_key: str) -> None: ... def DeleteKeyEx(key: _KeyType, sub_key: str, access: int = ..., reserved: int = ...) -> None: ... def DeleteValue(__key: _KeyType, __value: str) -> None: ... def EnumKey(__key: _KeyType, __index: int) -> str: ... def EnumValue(__key: _KeyType, __index: int) -> Tuple[str, Any, int]: ... def ExpandEnvironmentStrings(__str: str) -> str: ... def FlushKey(__key: _KeyType) -> None: ... def LoadKey(__key: _KeyType, __sub_key: str, __file_name: str) -> None: ... def OpenKey(key: _KeyType, sub_key: str, reserved: int = ..., access: int = ...) -> HKEYType: ... def OpenKeyEx(key: _KeyType, sub_key: str, reserved: int = ..., access: int = ...) -> HKEYType: ... def QueryInfoKey(__key: _KeyType) -> Tuple[int, int, int]: ... def QueryValue(__key: _KeyType, __sub_key: Optional[str]) -> str: ... def QueryValueEx(__key: _KeyType, __name: str) -> Tuple[Any, int]: ... def SaveKey(__key: _KeyType, __file_name: str) -> None: ... def SetValue(__key: _KeyType, __sub_key: str, __type: int, __value: str) -> None: ... def SetValueEx( __key: _KeyType, __value_name: Optional[str], __reserved: Any, __type: int, __value: Union[str, int] ) -> None: ... # reserved is ignored def DisableReflectionKey(__key: _KeyType) -> None: ... def EnableReflectionKey(__key: _KeyType) -> None: ... def QueryReflectionKey(__key: _KeyType) -> bool: ... HKEY_CLASSES_ROOT: int HKEY_CURRENT_USER: int HKEY_LOCAL_MACHINE: int HKEY_USERS: int HKEY_PERFORMANCE_DATA: int HKEY_CURRENT_CONFIG: int HKEY_DYN_DATA: int KEY_ALL_ACCESS: int KEY_WRITE: int KEY_READ: int KEY_EXECUTE: int KEY_QUERY_VALUE: int KEY_SET_VALUE: int KEY_CREATE_SUB_KEY: int KEY_ENUMERATE_SUB_KEYS: int KEY_NOTIFY: int KEY_CREATE_LINK: int KEY_WOW64_64KEY: int KEY_WOW64_32KEY: int REG_BINARY: int REG_DWORD: int REG_DWORD_LITTLE_ENDIAN: int REG_DWORD_BIG_ENDIAN: int REG_EXPAND_SZ: int REG_LINK: int REG_MULTI_SZ: int REG_NONE: int REG_RESOURCE_LIST: int REG_FULL_RESOURCE_DESCRIPTOR: int REG_RESOURCE_REQUIREMENTS_LIST: int REG_SZ: int REG_CREATED_NEW_KEY: int # undocumented REG_LEGAL_CHANGE_FILTER: int # undocumented REG_LEGAL_OPTION: int # undocumented REG_NOTIFY_CHANGE_ATTRIBUTES: int # undocumented REG_NOTIFY_CHANGE_LAST_SET: int # undocumented REG_NOTIFY_CHANGE_NAME: int # undocumented REG_NOTIFY_CHANGE_SECURITY: int # undocumented REG_NO_LAZY_FLUSH: int # undocumented REG_OPENED_EXISTING_KEY: int # undocumented REG_OPTION_BACKUP_RESTORE: int # undocumented REG_OPTION_CREATE_LINK: int # undocumented REG_OPTION_NON_VOLATILE: int # undocumented REG_OPTION_OPEN_LINK: int # undocumented REG_OPTION_RESERVED: int # undocumented REG_OPTION_VOLATILE: int # undocumented REG_REFRESH_HIVE: int # undocumented REG_WHOLE_HIVE_VOLATILE: int # undocumented error = OSError # Though this class has a __name__ of PyHKEY, it's exposed as HKEYType for some reason class HKEYType: def __bool__(self) -> bool: ... def __int__(self) -> int: ... def __enter__(self) -> HKEYType: ... def __exit__( self, exc_type: Optional[Type[BaseException]], exc_val: Optional[BaseException], exc_tb: Optional[TracebackType] ) -> Optional[bool]: ... def Close(self) -> None: ... def Detach(self) -> int: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/abc.pyi0000664000175000017500000000217300000000000022366 0ustar00davedave00000000000000import _weakrefset from typing import Any, Callable, Dict, Set, Tuple, Type, TypeVar _FuncT = TypeVar("_FuncT", bound=Callable[..., Any]) # NOTE: mypy has special processing for ABCMeta and abstractmethod. def abstractmethod(funcobj: _FuncT) -> _FuncT: ... class ABCMeta(type): # TODO: FrozenSet __abstractmethods__: Set[Any] _abc_cache: _weakrefset.WeakSet[Any] _abc_invalidation_counter: int _abc_negative_cache: _weakrefset.WeakSet[Any] _abc_negative_cache_version: int _abc_registry: _weakrefset.WeakSet[Any] def __init__(self, name: str, bases: Tuple[type, ...], namespace: Dict[Any, Any]) -> None: ... def __instancecheck__(cls: ABCMeta, instance: Any) -> Any: ... def __subclasscheck__(cls: ABCMeta, subclass: Any) -> Any: ... def _dump_registry(cls: ABCMeta, *args: Any, **kwargs: Any) -> None: ... def register(cls: ABCMeta, subclass: Type[Any]) -> None: ... # TODO: The real abc.abstractproperty inherits from "property". class abstractproperty(object): def __new__(cls, func: Any) -> Any: ... __isabstractmethod__: bool doc: Any fdel: Any fget: Any fset: Any ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/ast.pyi0000664000175000017500000000225700000000000022433 0ustar00davedave00000000000000# Python 2.7 ast # Rename typing to _typing, as not to conflict with typing imported # from _ast below when loaded in an unorthodox way by the Dropbox # internal Bazel integration. import typing as _typing from typing import Any, Iterator, Optional, Union from _ast import * from _ast import AST, Module def parse(source: Union[str, unicode], filename: Union[str, unicode] = ..., mode: Union[str, unicode] = ...) -> Module: ... def copy_location(new_node: AST, old_node: AST) -> AST: ... def dump(node: AST, annotate_fields: bool = ..., include_attributes: bool = ...) -> str: ... def fix_missing_locations(node: AST) -> AST: ... def get_docstring(node: AST, clean: bool = ...) -> str: ... def increment_lineno(node: AST, n: int = ...) -> AST: ... def iter_child_nodes(node: AST) -> Iterator[AST]: ... def iter_fields(node: AST) -> Iterator[_typing.Tuple[str, Any]]: ... def literal_eval(node_or_string: Union[str, unicode, AST]) -> Any: ... def walk(node: AST) -> Iterator[AST]: ... class NodeVisitor: def visit(self, node: AST) -> Any: ... def generic_visit(self, node: AST) -> Any: ... class NodeTransformer(NodeVisitor): def generic_visit(self, node: AST) -> Optional[AST]: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/atexit.pyi0000664000175000017500000000016500000000000023136 0ustar00davedave00000000000000from typing import Any, TypeVar _FT = TypeVar("_FT") def register(func: _FT, *args: Any, **kargs: Any) -> _FT: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/builtins.pyi0000664000175000017500000013732500000000000023502 0ustar00davedave00000000000000# True and False are deliberately omitted because they are keywords in # Python 3, and stub files conform to Python 3 syntax. from _typeshed import ReadableBuffer, SupportsKeysAndGetItem, SupportsWrite from abc import ABCMeta from ast import mod from types import CodeType from typing import ( AbstractSet, Any, AnyStr, BinaryIO, ByteString, Callable, Container, Dict, FrozenSet, Generic, ItemsView, Iterable, Iterator, KeysView, List, Mapping, MutableMapping, MutableSequence, MutableSet, NoReturn, Optional, Protocol, Reversible, Sequence, Set, Sized, SupportsAbs, SupportsComplex, SupportsFloat, SupportsInt, Text, Tuple, Type, TypeVar, Union, ValuesView, overload, runtime_checkable, ) from typing_extensions import Literal class _SupportsIndex(Protocol): def __index__(self) -> int: ... class _SupportsTrunc(Protocol): def __trunc__(self) -> int: ... _T = TypeVar("_T") _T_co = TypeVar("_T_co", covariant=True) _KT = TypeVar("_KT") _VT = TypeVar("_VT") _S = TypeVar("_S") _T1 = TypeVar("_T1") _T2 = TypeVar("_T2") _T3 = TypeVar("_T3") _T4 = TypeVar("_T4") _T5 = TypeVar("_T5") _TT = TypeVar("_TT", bound="type") _TBE = TypeVar("_TBE", bound="BaseException") class object: __doc__: Optional[str] __dict__: Dict[str, Any] __slots__: Union[Text, Iterable[Text]] __module__: str @property def __class__(self: _T) -> Type[_T]: ... @__class__.setter def __class__(self, __type: Type[object]) -> None: ... # noqa: F811 def __init__(self) -> None: ... def __new__(cls) -> Any: ... def __setattr__(self, name: str, value: Any) -> None: ... def __eq__(self, o: object) -> bool: ... def __ne__(self, o: object) -> bool: ... def __str__(self) -> str: ... def __repr__(self) -> str: ... def __hash__(self) -> int: ... def __format__(self, format_spec: str) -> str: ... def __getattribute__(self, name: str) -> Any: ... def __delattr__(self, name: str) -> None: ... def __sizeof__(self) -> int: ... def __reduce__(self) -> Union[str, Tuple[Any, ...]]: ... def __reduce_ex__(self, protocol: int) -> Union[str, Tuple[Any, ...]]: ... class staticmethod(object): # Special, only valid as a decorator. __func__: Callable[..., Any] def __init__(self, f: Callable[..., Any]) -> None: ... def __new__(cls: Type[_T], *args: Any, **kwargs: Any) -> _T: ... def __get__(self, obj: _T, type: Optional[Type[_T]] = ...) -> Callable[..., Any]: ... class classmethod(object): # Special, only valid as a decorator. __func__: Callable[..., Any] def __init__(self, f: Callable[..., Any]) -> None: ... def __new__(cls: Type[_T], *args: Any, **kwargs: Any) -> _T: ... def __get__(self, obj: _T, type: Optional[Type[_T]] = ...) -> Callable[..., Any]: ... class type(object): __base__: type __bases__: Tuple[type, ...] __basicsize__: int __dict__: Dict[str, Any] __dictoffset__: int __flags__: int __itemsize__: int __module__: str __mro__: Tuple[type, ...] __name__: str __weakrefoffset__: int @overload def __init__(self, o: object) -> None: ... @overload def __init__(self, name: str, bases: Tuple[type, ...], dict: Dict[str, Any]) -> None: ... @overload def __new__(cls, o: object) -> type: ... @overload def __new__(cls, name: str, bases: Tuple[type, ...], namespace: Dict[str, Any]) -> type: ... def __call__(self, *args: Any, **kwds: Any) -> Any: ... def __subclasses__(self: _TT) -> List[_TT]: ... # Note: the documentation doesnt specify what the return type is, the standard # implementation seems to be returning a list. def mro(self) -> List[type]: ... def __instancecheck__(self, instance: Any) -> bool: ... def __subclasscheck__(self, subclass: type) -> bool: ... class super(object): @overload def __init__(self, t: Any, obj: Any) -> None: ... @overload def __init__(self, t: Any) -> None: ... class int: @overload def __new__(cls: Type[_T], x: Union[Text, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc] = ...) -> _T: ... @overload def __new__(cls: Type[_T], x: Union[Text, bytes, bytearray], base: int) -> _T: ... @property def real(self) -> int: ... @property def imag(self) -> int: ... @property def numerator(self) -> int: ... @property def denominator(self) -> int: ... def conjugate(self) -> int: ... def bit_length(self) -> int: ... def __add__(self, x: int) -> int: ... def __sub__(self, x: int) -> int: ... def __mul__(self, x: int) -> int: ... def __floordiv__(self, x: int) -> int: ... def __div__(self, x: int) -> int: ... def __truediv__(self, x: int) -> float: ... def __mod__(self, x: int) -> int: ... def __divmod__(self, x: int) -> Tuple[int, int]: ... def __radd__(self, x: int) -> int: ... def __rsub__(self, x: int) -> int: ... def __rmul__(self, x: int) -> int: ... def __rfloordiv__(self, x: int) -> int: ... def __rdiv__(self, x: int) -> int: ... def __rtruediv__(self, x: int) -> float: ... def __rmod__(self, x: int) -> int: ... def __rdivmod__(self, x: int) -> Tuple[int, int]: ... @overload def __pow__(self, __x: Literal[2], __modulo: Optional[int] = ...) -> int: ... @overload def __pow__(self, __x: int, __modulo: Optional[int] = ...) -> Any: ... # Return type can be int or float, depending on x. def __rpow__(self, x: int, mod: Optional[int] = ...) -> Any: ... def __and__(self, n: int) -> int: ... def __or__(self, n: int) -> int: ... def __xor__(self, n: int) -> int: ... def __lshift__(self, n: int) -> int: ... def __rshift__(self, n: int) -> int: ... def __rand__(self, n: int) -> int: ... def __ror__(self, n: int) -> int: ... def __rxor__(self, n: int) -> int: ... def __rlshift__(self, n: int) -> int: ... def __rrshift__(self, n: int) -> int: ... def __neg__(self) -> int: ... def __pos__(self) -> int: ... def __invert__(self) -> int: ... def __trunc__(self) -> int: ... def __getnewargs__(self) -> Tuple[int]: ... def __eq__(self, x: object) -> bool: ... def __ne__(self, x: object) -> bool: ... def __lt__(self, x: int) -> bool: ... def __le__(self, x: int) -> bool: ... def __gt__(self, x: int) -> bool: ... def __ge__(self, x: int) -> bool: ... def __str__(self) -> str: ... def __float__(self) -> float: ... def __int__(self) -> int: ... def __abs__(self) -> int: ... def __hash__(self) -> int: ... def __nonzero__(self) -> bool: ... def __index__(self) -> int: ... class float: def __new__(cls: Type[_T], x: Union[SupportsFloat, _SupportsIndex, Text, bytes, bytearray] = ...) -> _T: ... def as_integer_ratio(self) -> Tuple[int, int]: ... def hex(self) -> str: ... def is_integer(self) -> bool: ... @classmethod def fromhex(cls, __s: str) -> float: ... @property def real(self) -> float: ... @property def imag(self) -> float: ... def conjugate(self) -> float: ... def __add__(self, x: float) -> float: ... def __sub__(self, x: float) -> float: ... def __mul__(self, x: float) -> float: ... def __floordiv__(self, x: float) -> float: ... def __div__(self, x: float) -> float: ... def __truediv__(self, x: float) -> float: ... def __mod__(self, x: float) -> float: ... def __divmod__(self, x: float) -> Tuple[float, float]: ... def __pow__( self, x: float, mod: None = ... ) -> float: ... # In Python 3, returns complex if self is negative and x is not whole def __radd__(self, x: float) -> float: ... def __rsub__(self, x: float) -> float: ... def __rmul__(self, x: float) -> float: ... def __rfloordiv__(self, x: float) -> float: ... def __rdiv__(self, x: float) -> float: ... def __rtruediv__(self, x: float) -> float: ... def __rmod__(self, x: float) -> float: ... def __rdivmod__(self, x: float) -> Tuple[float, float]: ... def __rpow__(self, x: float, mod: None = ...) -> float: ... def __getnewargs__(self) -> Tuple[float]: ... def __trunc__(self) -> int: ... def __eq__(self, x: object) -> bool: ... def __ne__(self, x: object) -> bool: ... def __lt__(self, x: float) -> bool: ... def __le__(self, x: float) -> bool: ... def __gt__(self, x: float) -> bool: ... def __ge__(self, x: float) -> bool: ... def __neg__(self) -> float: ... def __pos__(self) -> float: ... def __str__(self) -> str: ... def __int__(self) -> int: ... def __float__(self) -> float: ... def __abs__(self) -> float: ... def __hash__(self) -> int: ... def __nonzero__(self) -> bool: ... class complex: @overload def __new__(cls: Type[_T], real: float = ..., imag: float = ...) -> _T: ... @overload def __new__(cls: Type[_T], real: Union[str, SupportsComplex, _SupportsIndex]) -> _T: ... @property def real(self) -> float: ... @property def imag(self) -> float: ... def conjugate(self) -> complex: ... def __add__(self, x: complex) -> complex: ... def __sub__(self, x: complex) -> complex: ... def __mul__(self, x: complex) -> complex: ... def __pow__(self, x: complex, mod: None = ...) -> complex: ... def __div__(self, x: complex) -> complex: ... def __truediv__(self, x: complex) -> complex: ... def __radd__(self, x: complex) -> complex: ... def __rsub__(self, x: complex) -> complex: ... def __rmul__(self, x: complex) -> complex: ... def __rpow__(self, x: complex, mod: None = ...) -> complex: ... def __rdiv__(self, x: complex) -> complex: ... def __rtruediv__(self, x: complex) -> complex: ... def __eq__(self, x: object) -> bool: ... def __ne__(self, x: object) -> bool: ... def __neg__(self) -> complex: ... def __pos__(self) -> complex: ... def __str__(self) -> str: ... def __complex__(self) -> complex: ... def __abs__(self) -> float: ... def __hash__(self) -> int: ... def __nonzero__(self) -> bool: ... class basestring(metaclass=ABCMeta): ... class unicode(basestring, Sequence[unicode]): @overload def __init__(self) -> None: ... @overload def __init__(self, o: object) -> None: ... @overload def __init__(self, o: str, encoding: unicode = ..., errors: unicode = ...) -> None: ... def capitalize(self) -> unicode: ... def center(self, width: int, fillchar: unicode = ...) -> unicode: ... def count(self, x: unicode) -> int: ... def decode(self, encoding: unicode = ..., errors: unicode = ...) -> unicode: ... def encode(self, encoding: unicode = ..., errors: unicode = ...) -> str: ... def endswith(self, suffix: Union[unicode, Tuple[unicode, ...]], start: int = ..., end: int = ...) -> bool: ... def expandtabs(self, tabsize: int = ...) -> unicode: ... def find(self, sub: unicode, start: int = ..., end: int = ...) -> int: ... def format(self, *args: object, **kwargs: object) -> unicode: ... def index(self, sub: unicode, start: int = ..., end: int = ...) -> int: ... def isalnum(self) -> bool: ... def isalpha(self) -> bool: ... def isdecimal(self) -> bool: ... def isdigit(self) -> bool: ... def isidentifier(self) -> bool: ... def islower(self) -> bool: ... def isnumeric(self) -> bool: ... def isprintable(self) -> bool: ... def isspace(self) -> bool: ... def istitle(self) -> bool: ... def isupper(self) -> bool: ... def join(self, iterable: Iterable[unicode]) -> unicode: ... def ljust(self, width: int, fillchar: unicode = ...) -> unicode: ... def lower(self) -> unicode: ... def lstrip(self, chars: unicode = ...) -> unicode: ... def partition(self, sep: unicode) -> Tuple[unicode, unicode, unicode]: ... def replace(self, old: unicode, new: unicode, count: int = ...) -> unicode: ... def rfind(self, sub: unicode, start: int = ..., end: int = ...) -> int: ... def rindex(self, sub: unicode, start: int = ..., end: int = ...) -> int: ... def rjust(self, width: int, fillchar: unicode = ...) -> unicode: ... def rpartition(self, sep: unicode) -> Tuple[unicode, unicode, unicode]: ... def rsplit(self, sep: Optional[unicode] = ..., maxsplit: int = ...) -> List[unicode]: ... def rstrip(self, chars: unicode = ...) -> unicode: ... def split(self, sep: Optional[unicode] = ..., maxsplit: int = ...) -> List[unicode]: ... def splitlines(self, keepends: bool = ...) -> List[unicode]: ... def startswith(self, prefix: Union[unicode, Tuple[unicode, ...]], start: int = ..., end: int = ...) -> bool: ... def strip(self, chars: unicode = ...) -> unicode: ... def swapcase(self) -> unicode: ... def title(self) -> unicode: ... def translate(self, table: Union[Dict[int, Any], unicode]) -> unicode: ... def upper(self) -> unicode: ... def zfill(self, width: int) -> unicode: ... @overload def __getitem__(self, i: int) -> unicode: ... @overload def __getitem__(self, s: slice) -> unicode: ... def __getslice__(self, start: int, stop: int) -> unicode: ... def __add__(self, s: unicode) -> unicode: ... def __mul__(self, n: int) -> unicode: ... def __rmul__(self, n: int) -> unicode: ... def __mod__(self, x: Any) -> unicode: ... def __eq__(self, x: object) -> bool: ... def __ne__(self, x: object) -> bool: ... def __lt__(self, x: unicode) -> bool: ... def __le__(self, x: unicode) -> bool: ... def __gt__(self, x: unicode) -> bool: ... def __ge__(self, x: unicode) -> bool: ... def __len__(self) -> int: ... # The argument type is incompatible with Sequence def __contains__(self, s: Union[unicode, bytes]) -> bool: ... # type: ignore def __iter__(self) -> Iterator[unicode]: ... def __str__(self) -> str: ... def __repr__(self) -> str: ... def __int__(self) -> int: ... def __float__(self) -> float: ... def __hash__(self) -> int: ... def __getnewargs__(self) -> Tuple[unicode]: ... class _FormatMapMapping(Protocol): def __getitem__(self, __key: str) -> Any: ... class str(Sequence[str], basestring): def __init__(self, o: object = ...) -> None: ... def capitalize(self) -> str: ... def center(self, __width: int, __fillchar: str = ...) -> str: ... def count(self, x: Text, __start: Optional[int] = ..., __end: Optional[int] = ...) -> int: ... def decode(self, encoding: Text = ..., errors: Text = ...) -> unicode: ... def encode(self, encoding: Text = ..., errors: Text = ...) -> bytes: ... def endswith(self, suffix: Union[Text, Tuple[Text, ...]]) -> bool: ... def expandtabs(self, tabsize: int = ...) -> str: ... def find(self, sub: Text, __start: Optional[int] = ..., __end: Optional[int] = ...) -> int: ... def format(self, *args: object, **kwargs: object) -> str: ... def format_map(self, map: _FormatMapMapping) -> str: ... def index(self, sub: Text, __start: Optional[int] = ..., __end: Optional[int] = ...) -> int: ... def isalnum(self) -> bool: ... def isalpha(self) -> bool: ... def isdigit(self) -> bool: ... def islower(self) -> bool: ... def isspace(self) -> bool: ... def istitle(self) -> bool: ... def isupper(self) -> bool: ... def join(self, __iterable: Iterable[AnyStr]) -> AnyStr: ... def ljust(self, __width: int, __fillchar: str = ...) -> str: ... def lower(self) -> str: ... @overload def lstrip(self, __chars: str = ...) -> str: ... @overload def lstrip(self, __chars: unicode) -> unicode: ... @overload def partition(self, __sep: bytearray) -> Tuple[str, bytearray, str]: ... @overload def partition(self, __sep: str) -> Tuple[str, str, str]: ... @overload def partition(self, __sep: unicode) -> Tuple[unicode, unicode, unicode]: ... def replace(self, __old: AnyStr, __new: AnyStr, __count: int = ...) -> AnyStr: ... def rfind(self, sub: Text, __start: Optional[int] = ..., __end: Optional[int] = ...) -> int: ... def rindex(self, sub: Text, __start: Optional[int] = ..., __end: Optional[int] = ...) -> int: ... def rjust(self, __width: int, __fillchar: str = ...) -> str: ... @overload def rpartition(self, __sep: bytearray) -> Tuple[str, bytearray, str]: ... @overload def rpartition(self, __sep: str) -> Tuple[str, str, str]: ... @overload def rpartition(self, __sep: unicode) -> Tuple[unicode, unicode, unicode]: ... @overload def rsplit(self, sep: Optional[str] = ..., maxsplit: int = ...) -> List[str]: ... @overload def rsplit(self, sep: unicode, maxsplit: int = ...) -> List[unicode]: ... @overload def rstrip(self, __chars: str = ...) -> str: ... @overload def rstrip(self, __chars: unicode) -> unicode: ... @overload def split(self, sep: Optional[str] = ..., maxsplit: int = ...) -> List[str]: ... @overload def split(self, sep: unicode, maxsplit: int = ...) -> List[unicode]: ... def splitlines(self, keepends: bool = ...) -> List[str]: ... def startswith(self, prefix: Union[Text, Tuple[Text, ...]]) -> bool: ... @overload def strip(self, __chars: str = ...) -> str: ... @overload def strip(self, chars: unicode) -> unicode: ... def swapcase(self) -> str: ... def title(self) -> str: ... def translate(self, __table: Optional[AnyStr], deletechars: AnyStr = ...) -> AnyStr: ... def upper(self) -> str: ... def zfill(self, __width: int) -> str: ... def __add__(self, s: AnyStr) -> AnyStr: ... # Incompatible with Sequence.__contains__ def __contains__(self, o: Union[str, Text]) -> bool: ... # type: ignore def __eq__(self, x: object) -> bool: ... def __ge__(self, x: Text) -> bool: ... def __getitem__(self, i: Union[int, slice]) -> str: ... def __gt__(self, x: Text) -> bool: ... def __hash__(self) -> int: ... def __iter__(self) -> Iterator[str]: ... def __le__(self, x: Text) -> bool: ... def __len__(self) -> int: ... def __lt__(self, x: Text) -> bool: ... def __mod__(self, x: Any) -> str: ... def __mul__(self, n: int) -> str: ... def __ne__(self, x: object) -> bool: ... def __repr__(self) -> str: ... def __rmul__(self, n: int) -> str: ... def __str__(self) -> str: ... def __getnewargs__(self) -> Tuple[str]: ... def __getslice__(self, start: int, stop: int) -> str: ... def __float__(self) -> float: ... def __int__(self) -> int: ... bytes = str class bytearray(MutableSequence[int], ByteString): @overload def __init__(self) -> None: ... @overload def __init__(self, ints: Iterable[int]) -> None: ... @overload def __init__(self, string: str) -> None: ... @overload def __init__(self, string: Text, encoding: Text, errors: Text = ...) -> None: ... @overload def __init__(self, length: int) -> None: ... def capitalize(self) -> bytearray: ... def center(self, __width: int, __fillchar: bytes = ...) -> bytearray: ... def count(self, __sub: str) -> int: ... def decode(self, encoding: Text = ..., errors: Text = ...) -> str: ... def endswith(self, __suffix: Union[bytes, Tuple[bytes, ...]]) -> bool: ... def expandtabs(self, tabsize: int = ...) -> bytearray: ... def extend(self, iterable: Union[str, Iterable[int]]) -> None: ... def find(self, __sub: str, __start: int = ..., __end: int = ...) -> int: ... def index(self, __sub: str, __start: int = ..., __end: int = ...) -> int: ... def insert(self, __index: int, __item: int) -> None: ... def isalnum(self) -> bool: ... def isalpha(self) -> bool: ... def isdigit(self) -> bool: ... def islower(self) -> bool: ... def isspace(self) -> bool: ... def istitle(self) -> bool: ... def isupper(self) -> bool: ... def join(self, __iterable: Iterable[str]) -> bytearray: ... def ljust(self, __width: int, __fillchar: str = ...) -> bytearray: ... def lower(self) -> bytearray: ... def lstrip(self, __bytes: Optional[bytes] = ...) -> bytearray: ... def partition(self, __sep: bytes) -> Tuple[bytearray, bytearray, bytearray]: ... def replace(self, __old: bytes, __new: bytes, __count: int = ...) -> bytearray: ... def rfind(self, __sub: bytes, __start: int = ..., __end: int = ...) -> int: ... def rindex(self, __sub: bytes, __start: int = ..., __end: int = ...) -> int: ... def rjust(self, __width: int, __fillchar: bytes = ...) -> bytearray: ... def rpartition(self, __sep: bytes) -> Tuple[bytearray, bytearray, bytearray]: ... def rsplit(self, sep: Optional[bytes] = ..., maxsplit: int = ...) -> List[bytearray]: ... def rstrip(self, __bytes: Optional[bytes] = ...) -> bytearray: ... def split(self, sep: Optional[bytes] = ..., maxsplit: int = ...) -> List[bytearray]: ... def splitlines(self, keepends: bool = ...) -> List[bytearray]: ... def startswith( self, __prefix: Union[bytes, Tuple[bytes, ...]], __start: Optional[int] = ..., __end: Optional[int] = ... ) -> bool: ... def strip(self, __bytes: Optional[bytes] = ...) -> bytearray: ... def swapcase(self) -> bytearray: ... def title(self) -> bytearray: ... def translate(self, __table: str) -> bytearray: ... def upper(self) -> bytearray: ... def zfill(self, __width: int) -> bytearray: ... @classmethod def fromhex(cls, __string: str) -> bytearray: ... def __len__(self) -> int: ... def __iter__(self) -> Iterator[int]: ... def __str__(self) -> str: ... def __repr__(self) -> str: ... def __int__(self) -> int: ... def __float__(self) -> float: ... __hash__: None # type: ignore @overload def __getitem__(self, i: int) -> int: ... @overload def __getitem__(self, s: slice) -> bytearray: ... @overload def __setitem__(self, i: int, x: int) -> None: ... @overload def __setitem__(self, s: slice, x: Union[Iterable[int], bytes]) -> None: ... def __delitem__(self, i: Union[int, slice]) -> None: ... def __getslice__(self, start: int, stop: int) -> bytearray: ... def __setslice__(self, start: int, stop: int, x: Union[Sequence[int], str]) -> None: ... def __delslice__(self, start: int, stop: int) -> None: ... def __add__(self, s: bytes) -> bytearray: ... def __mul__(self, n: int) -> bytearray: ... # Incompatible with Sequence.__contains__ def __contains__(self, o: Union[int, bytes]) -> bool: ... # type: ignore def __eq__(self, x: object) -> bool: ... def __ne__(self, x: object) -> bool: ... def __lt__(self, x: bytes) -> bool: ... def __le__(self, x: bytes) -> bool: ... def __gt__(self, x: bytes) -> bool: ... def __ge__(self, x: bytes) -> bool: ... class memoryview(Sized, Container[str]): format: str itemsize: int shape: Optional[Tuple[int, ...]] strides: Optional[Tuple[int, ...]] suboffsets: Optional[Tuple[int, ...]] readonly: bool ndim: int def __init__(self, obj: ReadableBuffer) -> None: ... @overload def __getitem__(self, i: int) -> str: ... @overload def __getitem__(self, s: slice) -> memoryview: ... def __contains__(self, x: object) -> bool: ... def __iter__(self) -> Iterator[str]: ... def __len__(self) -> int: ... @overload def __setitem__(self, s: slice, o: memoryview) -> None: ... @overload def __setitem__(self, i: int, o: bytes) -> None: ... @overload def __setitem__(self, s: slice, o: Sequence[bytes]) -> None: ... def tobytes(self) -> bytes: ... def tolist(self) -> List[int]: ... class bool(int): def __new__(cls: Type[_T], __o: object = ...) -> _T: ... @overload def __and__(self, x: bool) -> bool: ... @overload def __and__(self, x: int) -> int: ... @overload def __or__(self, x: bool) -> bool: ... @overload def __or__(self, x: int) -> int: ... @overload def __xor__(self, x: bool) -> bool: ... @overload def __xor__(self, x: int) -> int: ... @overload def __rand__(self, x: bool) -> bool: ... @overload def __rand__(self, x: int) -> int: ... @overload def __ror__(self, x: bool) -> bool: ... @overload def __ror__(self, x: int) -> int: ... @overload def __rxor__(self, x: bool) -> bool: ... @overload def __rxor__(self, x: int) -> int: ... def __getnewargs__(self) -> Tuple[int]: ... class slice(object): start: Any step: Any stop: Any @overload def __init__(self, stop: Any) -> None: ... @overload def __init__(self, start: Any, stop: Any, step: Any = ...) -> None: ... __hash__: None # type: ignore def indices(self, len: int) -> Tuple[int, int, int]: ... class tuple(Sequence[_T_co], Generic[_T_co]): def __new__(cls: Type[_T], iterable: Iterable[_T_co] = ...) -> _T: ... def __len__(self) -> int: ... def __contains__(self, x: object) -> bool: ... @overload def __getitem__(self, x: int) -> _T_co: ... @overload def __getitem__(self, x: slice) -> Tuple[_T_co, ...]: ... def __iter__(self) -> Iterator[_T_co]: ... def __lt__(self, x: Tuple[_T_co, ...]) -> bool: ... def __le__(self, x: Tuple[_T_co, ...]) -> bool: ... def __gt__(self, x: Tuple[_T_co, ...]) -> bool: ... def __ge__(self, x: Tuple[_T_co, ...]) -> bool: ... @overload def __add__(self, x: Tuple[_T_co, ...]) -> Tuple[_T_co, ...]: ... @overload def __add__(self, x: Tuple[Any, ...]) -> Tuple[Any, ...]: ... def __mul__(self, n: int) -> Tuple[_T_co, ...]: ... def __rmul__(self, n: int) -> Tuple[_T_co, ...]: ... def count(self, __value: Any) -> int: ... def index(self, __value: Any) -> int: ... class function: # TODO not defined in builtins! __name__: str __module__: str __code__: CodeType class list(MutableSequence[_T], Generic[_T]): @overload def __init__(self) -> None: ... @overload def __init__(self, iterable: Iterable[_T]) -> None: ... def append(self, __object: _T) -> None: ... def extend(self, __iterable: Iterable[_T]) -> None: ... def pop(self, __index: int = ...) -> _T: ... def index(self, __value: _T, __start: int = ..., __stop: int = ...) -> int: ... def count(self, __value: _T) -> int: ... def insert(self, __index: int, __object: _T) -> None: ... def remove(self, __value: _T) -> None: ... def reverse(self) -> None: ... def sort(self, cmp: Callable[[_T, _T], Any] = ..., key: Callable[[_T], Any] = ..., reverse: bool = ...) -> None: ... def __len__(self) -> int: ... def __iter__(self) -> Iterator[_T]: ... def __str__(self) -> str: ... __hash__: None # type: ignore @overload def __getitem__(self, i: int) -> _T: ... @overload def __getitem__(self, s: slice) -> List[_T]: ... @overload def __setitem__(self, i: int, o: _T) -> None: ... @overload def __setitem__(self, s: slice, o: Iterable[_T]) -> None: ... def __delitem__(self, i: Union[int, slice]) -> None: ... def __getslice__(self, start: int, stop: int) -> List[_T]: ... def __setslice__(self, start: int, stop: int, o: Sequence[_T]) -> None: ... def __delslice__(self, start: int, stop: int) -> None: ... def __add__(self, x: List[_T]) -> List[_T]: ... def __iadd__(self: _S, x: Iterable[_T]) -> _S: ... def __mul__(self, n: int) -> List[_T]: ... def __rmul__(self, n: int) -> List[_T]: ... def __contains__(self, o: object) -> bool: ... def __reversed__(self) -> Iterator[_T]: ... def __gt__(self, x: List[_T]) -> bool: ... def __ge__(self, x: List[_T]) -> bool: ... def __lt__(self, x: List[_T]) -> bool: ... def __le__(self, x: List[_T]) -> bool: ... class dict(MutableMapping[_KT, _VT], Generic[_KT, _VT]): # NOTE: Keyword arguments are special. If they are used, _KT must include # str, but we have no way of enforcing it here. @overload def __init__(self, **kwargs: _VT) -> None: ... @overload def __init__(self, map: SupportsKeysAndGetItem[_KT, _VT], **kwargs: _VT) -> None: ... @overload def __init__(self, iterable: Iterable[Tuple[_KT, _VT]], **kwargs: _VT) -> None: ... def __new__(cls: Type[_T1], *args: Any, **kwargs: Any) -> _T1: ... def has_key(self, k: _KT) -> bool: ... def clear(self) -> None: ... def copy(self) -> Dict[_KT, _VT]: ... def popitem(self) -> Tuple[_KT, _VT]: ... def setdefault(self, __key: _KT, __default: _VT = ...) -> _VT: ... @overload def update(self, __m: Mapping[_KT, _VT], **kwargs: _VT) -> None: ... @overload def update(self, __m: Iterable[Tuple[_KT, _VT]], **kwargs: _VT) -> None: ... @overload def update(self, **kwargs: _VT) -> None: ... def iterkeys(self) -> Iterator[_KT]: ... def itervalues(self) -> Iterator[_VT]: ... def iteritems(self) -> Iterator[Tuple[_KT, _VT]]: ... def viewkeys(self) -> KeysView[_KT]: ... def viewvalues(self) -> ValuesView[_VT]: ... def viewitems(self) -> ItemsView[_KT, _VT]: ... @classmethod @overload def fromkeys(cls, __iterable: Iterable[_T]) -> Dict[_T, Any]: ... @classmethod @overload def fromkeys(cls, __iterable: Iterable[_T], __value: _S) -> Dict[_T, _S]: ... def __len__(self) -> int: ... def __getitem__(self, k: _KT) -> _VT: ... def __setitem__(self, k: _KT, v: _VT) -> None: ... def __delitem__(self, v: _KT) -> None: ... def __iter__(self) -> Iterator[_KT]: ... def __str__(self) -> str: ... __hash__: None # type: ignore class set(MutableSet[_T], Generic[_T]): def __init__(self, iterable: Iterable[_T] = ...) -> None: ... def add(self, element: _T) -> None: ... def clear(self) -> None: ... def copy(self) -> Set[_T]: ... def difference(self, *s: Iterable[Any]) -> Set[_T]: ... def difference_update(self, *s: Iterable[Any]) -> None: ... def discard(self, element: _T) -> None: ... def intersection(self, *s: Iterable[Any]) -> Set[_T]: ... def intersection_update(self, *s: Iterable[Any]) -> None: ... def isdisjoint(self, s: Iterable[Any]) -> bool: ... def issubset(self, s: Iterable[Any]) -> bool: ... def issuperset(self, s: Iterable[Any]) -> bool: ... def pop(self) -> _T: ... def remove(self, element: _T) -> None: ... def symmetric_difference(self, s: Iterable[_T]) -> Set[_T]: ... def symmetric_difference_update(self, s: Iterable[_T]) -> None: ... def union(self, *s: Iterable[_T]) -> Set[_T]: ... def update(self, *s: Iterable[_T]) -> None: ... def __len__(self) -> int: ... def __contains__(self, o: object) -> bool: ... def __iter__(self) -> Iterator[_T]: ... def __str__(self) -> str: ... def __and__(self, s: AbstractSet[object]) -> Set[_T]: ... def __iand__(self, s: AbstractSet[object]) -> Set[_T]: ... def __or__(self, s: AbstractSet[_S]) -> Set[Union[_T, _S]]: ... def __ior__(self, s: AbstractSet[_S]) -> Set[Union[_T, _S]]: ... @overload def __sub__(self: Set[str], s: AbstractSet[Optional[Text]]) -> Set[_T]: ... @overload def __sub__(self, s: AbstractSet[Optional[_T]]) -> Set[_T]: ... @overload # type: ignore def __isub__(self: Set[str], s: AbstractSet[Optional[Text]]) -> Set[_T]: ... @overload def __isub__(self, s: AbstractSet[Optional[_T]]) -> Set[_T]: ... def __xor__(self, s: AbstractSet[_S]) -> Set[Union[_T, _S]]: ... def __ixor__(self, s: AbstractSet[_S]) -> Set[Union[_T, _S]]: ... def __le__(self, s: AbstractSet[object]) -> bool: ... def __lt__(self, s: AbstractSet[object]) -> bool: ... def __ge__(self, s: AbstractSet[object]) -> bool: ... def __gt__(self, s: AbstractSet[object]) -> bool: ... __hash__: None # type: ignore class frozenset(AbstractSet[_T_co], Generic[_T_co]): def __init__(self, iterable: Iterable[_T_co] = ...) -> None: ... def copy(self) -> FrozenSet[_T_co]: ... def difference(self, *s: Iterable[object]) -> FrozenSet[_T_co]: ... def intersection(self, *s: Iterable[object]) -> FrozenSet[_T_co]: ... def isdisjoint(self, s: Iterable[_T_co]) -> bool: ... def issubset(self, s: Iterable[object]) -> bool: ... def issuperset(self, s: Iterable[object]) -> bool: ... def symmetric_difference(self, s: Iterable[_T_co]) -> FrozenSet[_T_co]: ... def union(self, *s: Iterable[_T_co]) -> FrozenSet[_T_co]: ... def __len__(self) -> int: ... def __contains__(self, o: object) -> bool: ... def __iter__(self) -> Iterator[_T_co]: ... def __str__(self) -> str: ... def __and__(self, s: AbstractSet[_T_co]) -> FrozenSet[_T_co]: ... def __or__(self, s: AbstractSet[_S]) -> FrozenSet[Union[_T_co, _S]]: ... def __sub__(self, s: AbstractSet[_T_co]) -> FrozenSet[_T_co]: ... def __xor__(self, s: AbstractSet[_S]) -> FrozenSet[Union[_T_co, _S]]: ... def __le__(self, s: AbstractSet[object]) -> bool: ... def __lt__(self, s: AbstractSet[object]) -> bool: ... def __ge__(self, s: AbstractSet[object]) -> bool: ... def __gt__(self, s: AbstractSet[object]) -> bool: ... class enumerate(Iterator[Tuple[int, _T]], Generic[_T]): def __init__(self, iterable: Iterable[_T], start: int = ...) -> None: ... def __iter__(self) -> Iterator[Tuple[int, _T]]: ... def next(self) -> Tuple[int, _T]: ... class xrange(Sized, Iterable[int], Reversible[int]): @overload def __init__(self, stop: int) -> None: ... @overload def __init__(self, start: int, stop: int, step: int = ...) -> None: ... def __len__(self) -> int: ... def __iter__(self) -> Iterator[int]: ... def __getitem__(self, i: int) -> int: ... def __reversed__(self) -> Iterator[int]: ... class property(object): def __init__( self, fget: Optional[Callable[[Any], Any]] = ..., fset: Optional[Callable[[Any, Any], None]] = ..., fdel: Optional[Callable[[Any], None]] = ..., doc: Optional[str] = ..., ) -> None: ... def getter(self, fget: Callable[[Any], Any]) -> property: ... def setter(self, fset: Callable[[Any, Any], None]) -> property: ... def deleter(self, fdel: Callable[[Any], None]) -> property: ... def __get__(self, obj: Any, type: Optional[type] = ...) -> Any: ... def __set__(self, obj: Any, value: Any) -> None: ... def __delete__(self, obj: Any) -> None: ... def fget(self) -> Any: ... def fset(self, value: Any) -> None: ... def fdel(self) -> None: ... long = int class _NotImplementedType(Any): # type: ignore # A little weird, but typing the __call__ as NotImplemented makes the error message # for NotImplemented() much better __call__: NotImplemented # type: ignore NotImplemented: _NotImplementedType def abs(__x: SupportsAbs[_T]) -> _T: ... def all(__iterable: Iterable[object]) -> bool: ... def any(__iterable: Iterable[object]) -> bool: ... def apply(__func: Callable[..., _T], __args: Optional[Sequence[Any]] = ..., __kwds: Optional[Mapping[str, Any]] = ...) -> _T: ... def bin(__number: Union[int, _SupportsIndex]) -> str: ... def callable(__obj: object) -> bool: ... def chr(__i: int) -> str: ... def cmp(__x: Any, __y: Any) -> int: ... _N1 = TypeVar("_N1", bool, int, float, complex) def coerce(__x: _N1, __y: _N1) -> Tuple[_N1, _N1]: ... # This class is to be exported as PathLike from os, # but we define it here as _PathLike to avoid import cycle issues. # See https://github.com/python/typeshed/pull/991#issuecomment-288160993 _AnyStr_co = TypeVar("_AnyStr_co", str, bytes, covariant=True) @runtime_checkable class _PathLike(Protocol[_AnyStr_co]): def __fspath__(self) -> _AnyStr_co: ... def compile(source: Union[Text, mod], filename: Text, mode: Text, flags: int = ..., dont_inherit: int = ...) -> Any: ... def delattr(__obj: Any, __name: Text) -> None: ... def dir(__o: object = ...) -> List[str]: ... _N2 = TypeVar("_N2", int, float) def divmod(__x: _N2, __y: _N2) -> Tuple[_N2, _N2]: ... def eval( __source: Union[Text, bytes, CodeType], __globals: Optional[Dict[str, Any]] = ..., __locals: Optional[Mapping[str, Any]] = ... ) -> Any: ... def execfile(__filename: str, __globals: Optional[Dict[str, Any]] = ..., __locals: Optional[Dict[str, Any]] = ...) -> None: ... def exit(code: object = ...) -> NoReturn: ... @overload def filter(__function: Callable[[AnyStr], Any], __iterable: AnyStr) -> AnyStr: ... # type: ignore @overload def filter(__function: None, __iterable: Tuple[Optional[_T], ...]) -> Tuple[_T, ...]: ... # type: ignore @overload def filter(__function: Callable[[_T], Any], __iterable: Tuple[_T, ...]) -> Tuple[_T, ...]: ... # type: ignore @overload def filter(__function: None, __iterable: Iterable[Optional[_T]]) -> List[_T]: ... @overload def filter(__function: Callable[[_T], Any], __iterable: Iterable[_T]) -> List[_T]: ... def format(__value: object, __format_spec: str = ...) -> str: ... # TODO unicode def getattr(__o: Any, name: Text, __default: Any = ...) -> Any: ... def globals() -> Dict[str, Any]: ... def hasattr(__obj: Any, __name: Text) -> bool: ... def hash(__obj: object) -> int: ... def hex(__number: Union[int, _SupportsIndex]) -> str: ... def id(__obj: object) -> int: ... def input(__prompt: Any = ...) -> Any: ... def intern(__string: str) -> str: ... @overload def iter(__iterable: Iterable[_T]) -> Iterator[_T]: ... @overload def iter(__function: Callable[[], Optional[_T]], __sentinel: None) -> Iterator[_T]: ... @overload def iter(__function: Callable[[], _T], __sentinel: Any) -> Iterator[_T]: ... def isinstance(__obj: object, __class_or_tuple: Union[type, Tuple[Union[type, Tuple[Any, ...]], ...]]) -> bool: ... def issubclass(__cls: type, __class_or_tuple: Union[type, Tuple[Union[type, Tuple[Any, ...]], ...]]) -> bool: ... def len(__obj: Sized) -> int: ... def locals() -> Dict[str, Any]: ... @overload def map(__func: None, __iter1: Iterable[_T1]) -> List[_T1]: ... @overload def map(__func: None, __iter1: Iterable[_T1], __iter2: Iterable[_T2]) -> List[Tuple[_T1, _T2]]: ... @overload def map(__func: None, __iter1: Iterable[_T1], __iter2: Iterable[_T2], __iter3: Iterable[_T3]) -> List[Tuple[_T1, _T2, _T3]]: ... @overload def map( __func: None, __iter1: Iterable[_T1], __iter2: Iterable[_T2], __iter3: Iterable[_T3], __iter4: Iterable[_T4] ) -> List[Tuple[_T1, _T2, _T3, _T4]]: ... @overload def map( __func: None, __iter1: Iterable[_T1], __iter2: Iterable[_T2], __iter3: Iterable[_T3], __iter4: Iterable[_T4], __iter5: Iterable[_T5], ) -> List[Tuple[_T1, _T2, _T3, _T4, _T5]]: ... @overload def map( __func: None, __iter1: Iterable[Any], __iter2: Iterable[Any], __iter3: Iterable[Any], __iter4: Iterable[Any], __iter5: Iterable[Any], __iter6: Iterable[Any], *iterables: Iterable[Any], ) -> List[Tuple[Any, ...]]: ... @overload def map(__func: Callable[[_T1], _S], __iter1: Iterable[_T1]) -> List[_S]: ... @overload def map(__func: Callable[[_T1, _T2], _S], __iter1: Iterable[_T1], __iter2: Iterable[_T2]) -> List[_S]: ... @overload def map( __func: Callable[[_T1, _T2, _T3], _S], __iter1: Iterable[_T1], __iter2: Iterable[_T2], __iter3: Iterable[_T3] ) -> List[_S]: ... @overload def map( __func: Callable[[_T1, _T2, _T3, _T4], _S], __iter1: Iterable[_T1], __iter2: Iterable[_T2], __iter3: Iterable[_T3], __iter4: Iterable[_T4], ) -> List[_S]: ... @overload def map( __func: Callable[[_T1, _T2, _T3, _T4, _T5], _S], __iter1: Iterable[_T1], __iter2: Iterable[_T2], __iter3: Iterable[_T3], __iter4: Iterable[_T4], __iter5: Iterable[_T5], ) -> List[_S]: ... @overload def map( __func: Callable[..., _S], __iter1: Iterable[Any], __iter2: Iterable[Any], __iter3: Iterable[Any], __iter4: Iterable[Any], __iter5: Iterable[Any], __iter6: Iterable[Any], *iterables: Iterable[Any], ) -> List[_S]: ... @overload def max(__arg1: _T, __arg2: _T, *_args: _T, key: Callable[[_T], Any] = ...) -> _T: ... @overload def max(__iterable: Iterable[_T], *, key: Callable[[_T], Any] = ...) -> _T: ... @overload def min(__arg1: _T, __arg2: _T, *_args: _T, key: Callable[[_T], Any] = ...) -> _T: ... @overload def min(__iterable: Iterable[_T], *, key: Callable[[_T], Any] = ...) -> _T: ... @overload def next(__i: Iterator[_T]) -> _T: ... @overload def next(__i: Iterator[_T], default: _VT) -> Union[_T, _VT]: ... def oct(__number: Union[int, _SupportsIndex]) -> str: ... def open(name: Union[unicode, int], mode: unicode = ..., buffering: int = ...) -> BinaryIO: ... def ord(__c: Union[Text, bytes]) -> int: ... # This is only available after from __future__ import print_function. def print( *values: object, sep: Optional[Text] = ..., end: Optional[Text] = ..., file: Optional[SupportsWrite[Any]] = ... ) -> None: ... _E = TypeVar("_E", contravariant=True) _M = TypeVar("_M", contravariant=True) class _SupportsPow2(Protocol[_E, _T_co]): def __pow__(self, __other: _E) -> _T_co: ... class _SupportsPow3(Protocol[_E, _M, _T_co]): def __pow__(self, __other: _E, __modulo: _M) -> _T_co: ... @overload def pow(__base: int, __exp: int, __mod: None = ...) -> Any: ... # returns int or float depending on whether exp is non-negative @overload def pow(__base: int, __exp: int, __mod: int) -> int: ... @overload def pow(__base: float, __exp: float, __mod: None = ...) -> float: ... @overload def pow(__base: _SupportsPow2[_E, _T_co], __exp: _E) -> _T_co: ... @overload def pow(__base: _SupportsPow3[_E, _M, _T_co], __exp: _E, __mod: _M) -> _T_co: ... def quit(code: object = ...) -> NoReturn: ... def range(__x: int, __y: int = ..., __step: int = ...) -> List[int]: ... # noqa: F811 def raw_input(__prompt: Any = ...) -> str: ... @overload def reduce(__function: Callable[[_T, _S], _T], __iterable: Iterable[_S], __initializer: _T) -> _T: ... @overload def reduce(__function: Callable[[_T, _T], _T], __iterable: Iterable[_T]) -> _T: ... def reload(__module: Any) -> Any: ... @overload def reversed(__sequence: Sequence[_T]) -> Iterator[_T]: ... @overload def reversed(__sequence: Reversible[_T]) -> Iterator[_T]: ... def repr(__obj: object) -> str: ... @overload def round(number: float) -> float: ... @overload def round(number: float, ndigits: int) -> float: ... @overload def round(number: SupportsFloat) -> float: ... @overload def round(number: SupportsFloat, ndigits: int) -> float: ... def setattr(__obj: Any, __name: Text, __value: Any) -> None: ... def sorted( __iterable: Iterable[_T], *, cmp: Callable[[_T, _T], int] = ..., key: Optional[Callable[[_T], Any]] = ..., reverse: bool = ..., ) -> List[_T]: ... @overload def sum(__iterable: Iterable[_T]) -> Union[_T, int]: ... @overload def sum(__iterable: Iterable[_T], __start: _S) -> Union[_T, _S]: ... def unichr(__i: int) -> unicode: ... def vars(__object: Any = ...) -> Dict[str, Any]: ... @overload def zip(__iter1: Iterable[_T1]) -> List[Tuple[_T1]]: ... @overload def zip(__iter1: Iterable[_T1], __iter2: Iterable[_T2]) -> List[Tuple[_T1, _T2]]: ... @overload def zip(__iter1: Iterable[_T1], __iter2: Iterable[_T2], __iter3: Iterable[_T3]) -> List[Tuple[_T1, _T2, _T3]]: ... @overload def zip( __iter1: Iterable[_T1], __iter2: Iterable[_T2], __iter3: Iterable[_T3], __iter4: Iterable[_T4] ) -> List[Tuple[_T1, _T2, _T3, _T4]]: ... @overload def zip( __iter1: Iterable[_T1], __iter2: Iterable[_T2], __iter3: Iterable[_T3], __iter4: Iterable[_T4], __iter5: Iterable[_T5] ) -> List[Tuple[_T1, _T2, _T3, _T4, _T5]]: ... @overload def zip( __iter1: Iterable[Any], __iter2: Iterable[Any], __iter3: Iterable[Any], __iter4: Iterable[Any], __iter5: Iterable[Any], __iter6: Iterable[Any], *iterables: Iterable[Any], ) -> List[Tuple[Any, ...]]: ... def __import__( name: Text, globals: Optional[Mapping[str, Any]] = ..., locals: Optional[Mapping[str, Any]] = ..., fromlist: Sequence[str] = ..., level: int = ..., ) -> Any: ... # Actually the type of Ellipsis is , but since it's # not exposed anywhere under that name, we make it private here. class ellipsis: ... Ellipsis: ellipsis # TODO: buffer support is incomplete; e.g. some_string.startswith(some_buffer) doesn't type check. _AnyBuffer = TypeVar("_AnyBuffer", str, unicode, bytearray, buffer) class buffer(Sized): def __init__(self, object: _AnyBuffer, offset: int = ..., size: int = ...) -> None: ... def __add__(self, other: _AnyBuffer) -> str: ... def __cmp__(self, other: _AnyBuffer) -> bool: ... def __getitem__(self, key: Union[int, slice]) -> str: ... def __getslice__(self, i: int, j: int) -> str: ... def __len__(self) -> int: ... def __mul__(self, x: int) -> str: ... class BaseException(object): args: Tuple[Any, ...] message: Any def __init__(self, *args: object) -> None: ... def __str__(self) -> str: ... def __repr__(self) -> str: ... def __getitem__(self, i: int) -> Any: ... def __getslice__(self, start: int, stop: int) -> Tuple[Any, ...]: ... class GeneratorExit(BaseException): ... class KeyboardInterrupt(BaseException): ... class SystemExit(BaseException): code: int class Exception(BaseException): ... class StopIteration(Exception): ... class StandardError(Exception): ... _StandardError = StandardError class EnvironmentError(StandardError): errno: int strerror: str # TODO can this be unicode? filename: str class OSError(EnvironmentError): ... class IOError(EnvironmentError): ... class ArithmeticError(_StandardError): ... class AssertionError(_StandardError): ... class AttributeError(_StandardError): ... class BufferError(_StandardError): ... class EOFError(_StandardError): ... class ImportError(_StandardError): ... class LookupError(_StandardError): ... class MemoryError(_StandardError): ... class NameError(_StandardError): ... class ReferenceError(_StandardError): ... class RuntimeError(_StandardError): ... class SyntaxError(_StandardError): msg: str lineno: Optional[int] offset: Optional[int] text: Optional[str] filename: Optional[str] class SystemError(_StandardError): ... class TypeError(_StandardError): ... class ValueError(_StandardError): ... class FloatingPointError(ArithmeticError): ... class OverflowError(ArithmeticError): ... class ZeroDivisionError(ArithmeticError): ... class IndexError(LookupError): ... class KeyError(LookupError): ... class UnboundLocalError(NameError): ... class WindowsError(OSError): winerror: int class NotImplementedError(RuntimeError): ... class IndentationError(SyntaxError): ... class TabError(IndentationError): ... class UnicodeError(ValueError): ... class UnicodeDecodeError(UnicodeError): encoding: str object: bytes start: int end: int reason: str def __init__(self, __encoding: str, __object: bytes, __start: int, __end: int, __reason: str) -> None: ... class UnicodeEncodeError(UnicodeError): encoding: str object: Text start: int end: int reason: str def __init__(self, __encoding: str, __object: Text, __start: int, __end: int, __reason: str) -> None: ... class UnicodeTranslateError(UnicodeError): ... class Warning(Exception): ... class UserWarning(Warning): ... class DeprecationWarning(Warning): ... class SyntaxWarning(Warning): ... class RuntimeWarning(Warning): ... class FutureWarning(Warning): ... class PendingDeprecationWarning(Warning): ... class ImportWarning(Warning): ... class UnicodeWarning(Warning): ... class BytesWarning(Warning): ... class file(BinaryIO): @overload def __init__(self, file: str, mode: str = ..., buffering: int = ...) -> None: ... @overload def __init__(self, file: unicode, mode: str = ..., buffering: int = ...) -> None: ... @overload def __init__(self, file: int, mode: str = ..., buffering: int = ...) -> None: ... def __iter__(self) -> Iterator[str]: ... def next(self) -> str: ... def read(self, n: int = ...) -> str: ... def __enter__(self) -> BinaryIO: ... def __exit__( self, t: Optional[type] = ..., exc: Optional[BaseException] = ..., tb: Optional[Any] = ... ) -> Optional[bool]: ... def flush(self) -> None: ... def fileno(self) -> int: ... def isatty(self) -> bool: ... def close(self) -> None: ... def readable(self) -> bool: ... def writable(self) -> bool: ... def seekable(self) -> bool: ... def seek(self, offset: int, whence: int = ...) -> int: ... def tell(self) -> int: ... def readline(self, limit: int = ...) -> str: ... def readlines(self, hint: int = ...) -> List[str]: ... def write(self, data: str) -> int: ... def writelines(self, data: Iterable[str]) -> None: ... def truncate(self, pos: Optional[int] = ...) -> int: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/cPickle.pyi0000664000175000017500000000143300000000000023211 0ustar00davedave00000000000000from typing import IO, Any, List HIGHEST_PROTOCOL: int compatible_formats: List[str] format_version: str class Pickler: def __init__(self, file: IO[str], protocol: int = ...) -> None: ... def dump(self, obj: Any) -> None: ... def clear_memo(self) -> None: ... class Unpickler: def __init__(self, file: IO[str]) -> None: ... def load(self) -> Any: ... def noload(self) -> Any: ... def dump(obj: Any, file: IO[str], protocol: int = ...) -> None: ... def dumps(obj: Any, protocol: int = ...) -> str: ... def load(file: IO[str]) -> Any: ... def loads(str: str) -> Any: ... class PickleError(Exception): ... class UnpicklingError(PickleError): ... class BadPickleGet(UnpicklingError): ... class PicklingError(PickleError): ... class UnpickleableError(PicklingError): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/cStringIO.pyi0000664000175000017500000000351600000000000023504 0ustar00davedave00000000000000from abc import ABCMeta from types import TracebackType from typing import IO, Iterable, Iterator, List, Optional, Union, overload # This class isn't actually abstract, but you can't instantiate it # directly, so we might as well treat it as abstract in the stub. class InputType(IO[str], Iterator[str], metaclass=ABCMeta): def getvalue(self) -> str: ... def close(self) -> None: ... @property def closed(self) -> bool: ... def flush(self) -> None: ... def isatty(self) -> bool: ... def read(self, size: int = ...) -> str: ... def readline(self, size: int = ...) -> str: ... def readlines(self, hint: int = ...) -> List[str]: ... def seek(self, offset: int, whence: int = ...) -> int: ... def tell(self) -> int: ... def truncate(self, size: Optional[int] = ...) -> int: ... def __iter__(self) -> InputType: ... def next(self) -> str: ... def reset(self) -> None: ... class OutputType(IO[str], Iterator[str], metaclass=ABCMeta): @property def softspace(self) -> int: ... def getvalue(self) -> str: ... def close(self) -> None: ... @property def closed(self) -> bool: ... def flush(self) -> None: ... def isatty(self) -> bool: ... def read(self, size: int = ...) -> str: ... def readline(self, size: int = ...) -> str: ... def readlines(self, hint: int = ...) -> List[str]: ... def seek(self, offset: int, whence: int = ...) -> int: ... def tell(self) -> int: ... def truncate(self, size: Optional[int] = ...) -> int: ... def __iter__(self) -> OutputType: ... def next(self) -> str: ... def reset(self) -> None: ... def write(self, b: Union[str, unicode]) -> int: ... def writelines(self, lines: Iterable[Union[str, unicode]]) -> None: ... @overload def StringIO() -> OutputType: ... @overload def StringIO(s: str) -> InputType: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/collections.pyi0000664000175000017500000001146100000000000024157 0ustar00davedave00000000000000from typing import ( AbstractSet, Any, Callable as Callable, Container as Container, Dict, Generic, Hashable as Hashable, ItemsView as ItemsView, Iterable as Iterable, Iterator as Iterator, KeysView as KeysView, List, Mapping as Mapping, MappingView as MappingView, MutableMapping as MutableMapping, MutableSequence as MutableSequence, MutableSet as MutableSet, Optional, Reversible, Sequence as Sequence, Sized as Sized, Tuple, Type, TypeVar, Union, ValuesView as ValuesView, overload, ) Set = AbstractSet _S = TypeVar("_S") _T = TypeVar("_T") _KT = TypeVar("_KT") _VT = TypeVar("_VT") # namedtuple is special-cased in the type checker; the initializer is ignored. def namedtuple( typename: Union[str, unicode], field_names: Union[str, unicode, Iterable[Union[str, unicode]]], verbose: bool = ..., rename: bool = ..., ) -> Type[Tuple[Any, ...]]: ... class deque(Sized, Iterable[_T], Reversible[_T], Generic[_T]): def __init__(self, iterable: Iterable[_T] = ..., maxlen: int = ...) -> None: ... @property def maxlen(self) -> Optional[int]: ... def append(self, x: _T) -> None: ... def appendleft(self, x: _T) -> None: ... def clear(self) -> None: ... def count(self, x: _T) -> int: ... def extend(self, iterable: Iterable[_T]) -> None: ... def extendleft(self, iterable: Iterable[_T]) -> None: ... def pop(self) -> _T: ... def popleft(self) -> _T: ... def remove(self, value: _T) -> None: ... def reverse(self) -> None: ... def rotate(self, n: int = ...) -> None: ... def __len__(self) -> int: ... def __iter__(self) -> Iterator[_T]: ... def __str__(self) -> str: ... def __hash__(self) -> int: ... def __getitem__(self, i: int) -> _T: ... def __setitem__(self, i: int, x: _T) -> None: ... def __contains__(self, o: _T) -> bool: ... def __reversed__(self) -> Iterator[_T]: ... def __iadd__(self: _S, iterable: Iterable[_T]) -> _S: ... class Counter(Dict[_T, int], Generic[_T]): @overload def __init__(self, **kwargs: int) -> None: ... @overload def __init__(self, mapping: Mapping[_T, int]) -> None: ... @overload def __init__(self, iterable: Iterable[_T]) -> None: ... def copy(self: _S) -> _S: ... def elements(self) -> Iterator[_T]: ... def most_common(self, n: Optional[int] = ...) -> List[Tuple[_T, int]]: ... @overload def subtract(self, __mapping: Mapping[_T, int]) -> None: ... @overload def subtract(self, iterable: Iterable[_T]) -> None: ... # The Iterable[Tuple[...]] argument type is not actually desirable # (the tuples will be added as keys, breaking type safety) but # it's included so that the signature is compatible with # Dict.update. Not sure if we should use '# type: ignore' instead # and omit the type from the union. @overload def update(self, __m: Mapping[_T, int], **kwargs: int) -> None: ... @overload def update(self, __m: Union[Iterable[_T], Iterable[Tuple[_T, int]]], **kwargs: int) -> None: ... @overload def update(self, **kwargs: int) -> None: ... def __add__(self, other: Counter[_T]) -> Counter[_T]: ... def __sub__(self, other: Counter[_T]) -> Counter[_T]: ... def __and__(self, other: Counter[_T]) -> Counter[_T]: ... def __or__(self, other: Counter[_T]) -> Counter[_T]: ... def __iadd__(self, other: Counter[_T]) -> Counter[_T]: ... def __isub__(self, other: Counter[_T]) -> Counter[_T]: ... def __iand__(self, other: Counter[_T]) -> Counter[_T]: ... def __ior__(self, other: Counter[_T]) -> Counter[_T]: ... class OrderedDict(Dict[_KT, _VT], Reversible[_KT], Generic[_KT, _VT]): def popitem(self, last: bool = ...) -> Tuple[_KT, _VT]: ... def copy(self: _S) -> _S: ... def __reversed__(self) -> Iterator[_KT]: ... class defaultdict(Dict[_KT, _VT], Generic[_KT, _VT]): default_factory: Callable[[], _VT] @overload def __init__(self, **kwargs: _VT) -> None: ... @overload def __init__(self, default_factory: Optional[Callable[[], _VT]]) -> None: ... @overload def __init__(self, default_factory: Optional[Callable[[], _VT]], **kwargs: _VT) -> None: ... @overload def __init__(self, default_factory: Optional[Callable[[], _VT]], map: Mapping[_KT, _VT]) -> None: ... @overload def __init__(self, default_factory: Optional[Callable[[], _VT]], map: Mapping[_KT, _VT], **kwargs: _VT) -> None: ... @overload def __init__(self, default_factory: Optional[Callable[[], _VT]], iterable: Iterable[Tuple[_KT, _VT]]) -> None: ... @overload def __init__( self, default_factory: Optional[Callable[[], _VT]], iterable: Iterable[Tuple[_KT, _VT]], **kwargs: _VT ) -> None: ... def __missing__(self, key: _KT) -> _VT: ... def copy(self: _S) -> _S: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/commands.pyi0000664000175000017500000000051100000000000023434 0ustar00davedave00000000000000from typing import AnyStr, Text, Tuple, overload def getstatus(file: Text) -> str: ... def getoutput(cmd: Text) -> str: ... def getstatusoutput(cmd: Text) -> Tuple[int, str]: ... @overload def mk2arg(head: bytes, x: bytes) -> bytes: ... @overload def mk2arg(head: Text, x: Text) -> Text: ... def mkarg(x: AnyStr) -> AnyStr: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/compileall.pyi0000664000175000017500000000116400000000000023761 0ustar00davedave00000000000000from _typeshed import AnyPath from typing import Any, Optional, Pattern # rx can be any object with a 'search' method; once we have Protocols we can change the type def compile_dir( dir: AnyPath, maxlevels: int = ..., ddir: Optional[AnyPath] = ..., force: bool = ..., rx: Optional[Pattern[Any]] = ..., quiet: int = ..., ) -> int: ... def compile_file( fullname: AnyPath, ddir: Optional[AnyPath] = ..., force: bool = ..., rx: Optional[Pattern[Any]] = ..., quiet: int = ... ) -> int: ... def compile_path(skip_curdir: bool = ..., maxlevels: int = ..., force: bool = ..., quiet: int = ...) -> int: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/cookielib.pyi0000664000175000017500000001115400000000000023600 0ustar00davedave00000000000000from typing import Any, Optional class Cookie: version: Any name: Any value: Any port: Any port_specified: Any domain: Any domain_specified: Any domain_initial_dot: Any path: Any path_specified: Any secure: Any expires: Any discard: Any comment: Any comment_url: Any rfc2109: Any def __init__( self, version, name, value, port, port_specified, domain, domain_specified, domain_initial_dot, path, path_specified, secure, expires, discard, comment, comment_url, rest, rfc2109: bool = ..., ): ... def has_nonstandard_attr(self, name): ... def get_nonstandard_attr(self, name, default: Optional[Any] = ...): ... def set_nonstandard_attr(self, name, value): ... def is_expired(self, now: Optional[Any] = ...): ... class CookiePolicy: def set_ok(self, cookie, request): ... def return_ok(self, cookie, request): ... def domain_return_ok(self, domain, request): ... def path_return_ok(self, path, request): ... class DefaultCookiePolicy(CookiePolicy): DomainStrictNoDots: Any DomainStrictNonDomain: Any DomainRFC2965Match: Any DomainLiberal: Any DomainStrict: Any netscape: Any rfc2965: Any rfc2109_as_netscape: Any hide_cookie2: Any strict_domain: Any strict_rfc2965_unverifiable: Any strict_ns_unverifiable: Any strict_ns_domain: Any strict_ns_set_initial_dollar: Any strict_ns_set_path: Any def __init__( self, blocked_domains: Optional[Any] = ..., allowed_domains: Optional[Any] = ..., netscape: bool = ..., rfc2965: bool = ..., rfc2109_as_netscape: Optional[Any] = ..., hide_cookie2: bool = ..., strict_domain: bool = ..., strict_rfc2965_unverifiable: bool = ..., strict_ns_unverifiable: bool = ..., strict_ns_domain=..., strict_ns_set_initial_dollar: bool = ..., strict_ns_set_path: bool = ..., ): ... def blocked_domains(self): ... def set_blocked_domains(self, blocked_domains): ... def is_blocked(self, domain): ... def allowed_domains(self): ... def set_allowed_domains(self, allowed_domains): ... def is_not_allowed(self, domain): ... def set_ok(self, cookie, request): ... def set_ok_version(self, cookie, request): ... def set_ok_verifiability(self, cookie, request): ... def set_ok_name(self, cookie, request): ... def set_ok_path(self, cookie, request): ... def set_ok_domain(self, cookie, request): ... def set_ok_port(self, cookie, request): ... def return_ok(self, cookie, request): ... def return_ok_version(self, cookie, request): ... def return_ok_verifiability(self, cookie, request): ... def return_ok_secure(self, cookie, request): ... def return_ok_expires(self, cookie, request): ... def return_ok_port(self, cookie, request): ... def return_ok_domain(self, cookie, request): ... def domain_return_ok(self, domain, request): ... def path_return_ok(self, path, request): ... class Absent: ... class CookieJar: non_word_re: Any quote_re: Any strict_domain_re: Any domain_re: Any dots_re: Any magic_re: Any def __init__(self, policy: Optional[Any] = ...): ... def set_policy(self, policy): ... def add_cookie_header(self, request): ... def make_cookies(self, response, request): ... def set_cookie_if_ok(self, cookie, request): ... def set_cookie(self, cookie): ... def extract_cookies(self, response, request): ... def clear(self, domain: Optional[Any] = ..., path: Optional[Any] = ..., name: Optional[Any] = ...): ... def clear_session_cookies(self): ... def clear_expired_cookies(self): ... def __iter__(self): ... def __len__(self): ... class LoadError(IOError): ... class FileCookieJar(CookieJar): filename: Any delayload: Any def __init__(self, filename: Optional[Any] = ..., delayload: bool = ..., policy: Optional[Any] = ...): ... def save(self, filename: Optional[Any] = ..., ignore_discard: bool = ..., ignore_expires: bool = ...): ... def load(self, filename: Optional[Any] = ..., ignore_discard: bool = ..., ignore_expires: bool = ...): ... def revert(self, filename: Optional[Any] = ..., ignore_discard: bool = ..., ignore_expires: bool = ...): ... class LWPCookieJar(FileCookieJar): def as_lwp_str(self, ignore_discard: bool = ..., ignore_expires: bool = ...) -> str: ... # undocumented MozillaCookieJar = FileCookieJar def lwp_cookie_str(cookie: Cookie) -> str: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/copy_reg.pyi0000664000175000017500000000134300000000000023446 0ustar00davedave00000000000000from typing import Any, Callable, Hashable, List, Optional, SupportsInt, Tuple, TypeVar, Union _Type = TypeVar("_Type", bound=type) _Reduce = Union[Tuple[Callable[..., _Type], Tuple[Any, ...]], Tuple[Callable[..., _Type], Tuple[Any, ...], Optional[Any]]] __all__: List[str] def pickle( ob_type: _Type, pickle_function: Callable[[_Type], Union[str, _Reduce[_Type]]], constructor_ob: Optional[Callable[[_Reduce[_Type]], _Type]] = ..., ) -> None: ... def constructor(object: Callable[[_Reduce[_Type]], _Type]) -> None: ... def add_extension(module: Hashable, name: Hashable, code: SupportsInt) -> None: ... def remove_extension(module: Hashable, name: Hashable, code: int) -> None: ... def clear_extension_cache() -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/dircache.pyi0000664000175000017500000000042100000000000023375 0ustar00davedave00000000000000from typing import List, MutableSequence, Text, Union def reset() -> None: ... def listdir(path: Text) -> List[str]: ... opendir = listdir def annotate(head: Text, list: Union[MutableSequence[str], MutableSequence[Text], MutableSequence[Union[str, Text]]]) -> None: ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4143794 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/distutils/0000775000175000017500000000000000000000000023137 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/distutils/__init__.pyi0000664000175000017500000000000000000000000025407 0ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/distutils/archive_util.pyi0000664000175000017500000000067700000000000026352 0ustar00davedave00000000000000from typing import Optional def make_archive( base_name: str, format: str, root_dir: Optional[str] = ..., base_dir: Optional[str] = ..., verbose: int = ..., dry_run: int = ..., ) -> str: ... def make_tarball(base_name: str, base_dir: str, compress: Optional[str] = ..., verbose: int = ..., dry_run: int = ...) -> str: ... def make_zipfile(base_name: str, base_dir: str, verbose: int = ..., dry_run: int = ...) -> str: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/distutils/bcppcompiler.pyi0000664000175000017500000000011600000000000026337 0ustar00davedave00000000000000from distutils.ccompiler import CCompiler class BCPPCompiler(CCompiler): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/distutils/ccompiler.pyi0000664000175000017500000001446100000000000025645 0ustar00davedave00000000000000from typing import Any, Callable, List, Optional, Tuple, Union _Macro = Union[Tuple[str], Tuple[str, Optional[str]]] def gen_lib_options( compiler: CCompiler, library_dirs: List[str], runtime_library_dirs: List[str], libraries: List[str] ) -> List[str]: ... def gen_preprocess_options(macros: List[_Macro], include_dirs: List[str]) -> List[str]: ... def get_default_compiler(osname: Optional[str] = ..., platform: Optional[str] = ...) -> str: ... def new_compiler( plat: Optional[str] = ..., compiler: Optional[str] = ..., verbose: int = ..., dry_run: int = ..., force: int = ... ) -> CCompiler: ... def show_compilers() -> None: ... class CCompiler: dry_run: bool force: bool verbose: bool output_dir: Optional[str] macros: List[_Macro] include_dirs: List[str] libraries: List[str] library_dirs: List[str] runtime_library_dirs: List[str] objects: List[str] def __init__(self, verbose: int = ..., dry_run: int = ..., force: int = ...) -> None: ... def add_include_dir(self, dir: str) -> None: ... def set_include_dirs(self, dirs: List[str]) -> None: ... def add_library(self, libname: str) -> None: ... def set_libraries(self, libnames: List[str]) -> None: ... def add_library_dir(self, dir: str) -> None: ... def set_library_dirs(self, dirs: List[str]) -> None: ... def add_runtime_library_dir(self, dir: str) -> None: ... def set_runtime_library_dirs(self, dirs: List[str]) -> None: ... def define_macro(self, name: str, value: Optional[str] = ...) -> None: ... def undefine_macro(self, name: str) -> None: ... def add_link_object(self, object: str) -> None: ... def set_link_objects(self, objects: List[str]) -> None: ... def detect_language(self, sources: Union[str, List[str]]) -> Optional[str]: ... def find_library_file(self, dirs: List[str], lib: str, debug: bool = ...) -> Optional[str]: ... def has_function( self, funcname: str, includes: Optional[List[str]] = ..., include_dirs: Optional[List[str]] = ..., libraries: Optional[List[str]] = ..., library_dirs: Optional[List[str]] = ..., ) -> bool: ... def library_dir_option(self, dir: str) -> str: ... def library_option(self, lib: str) -> str: ... def runtime_library_dir_option(self, dir: str) -> str: ... def set_executables(self, **args: str) -> None: ... def compile( self, sources: List[str], output_dir: Optional[str] = ..., macros: Optional[_Macro] = ..., include_dirs: Optional[List[str]] = ..., debug: bool = ..., extra_preargs: Optional[List[str]] = ..., extra_postargs: Optional[List[str]] = ..., depends: Optional[List[str]] = ..., ) -> List[str]: ... def create_static_lib( self, objects: List[str], output_libname: str, output_dir: Optional[str] = ..., debug: bool = ..., target_lang: Optional[str] = ..., ) -> None: ... def link( self, target_desc: str, objects: List[str], output_filename: str, output_dir: Optional[str] = ..., libraries: Optional[List[str]] = ..., library_dirs: Optional[List[str]] = ..., runtime_library_dirs: Optional[List[str]] = ..., export_symbols: Optional[List[str]] = ..., debug: bool = ..., extra_preargs: Optional[List[str]] = ..., extra_postargs: Optional[List[str]] = ..., build_temp: Optional[str] = ..., target_lang: Optional[str] = ..., ) -> None: ... def link_executable( self, objects: List[str], output_progname: str, output_dir: Optional[str] = ..., libraries: Optional[List[str]] = ..., library_dirs: Optional[List[str]] = ..., runtime_library_dirs: Optional[List[str]] = ..., debug: bool = ..., extra_preargs: Optional[List[str]] = ..., extra_postargs: Optional[List[str]] = ..., target_lang: Optional[str] = ..., ) -> None: ... def link_shared_lib( self, objects: List[str], output_libname: str, output_dir: Optional[str] = ..., libraries: Optional[List[str]] = ..., library_dirs: Optional[List[str]] = ..., runtime_library_dirs: Optional[List[str]] = ..., export_symbols: Optional[List[str]] = ..., debug: bool = ..., extra_preargs: Optional[List[str]] = ..., extra_postargs: Optional[List[str]] = ..., build_temp: Optional[str] = ..., target_lang: Optional[str] = ..., ) -> None: ... def link_shared_object( self, objects: List[str], output_filename: str, output_dir: Optional[str] = ..., libraries: Optional[List[str]] = ..., library_dirs: Optional[List[str]] = ..., runtime_library_dirs: Optional[List[str]] = ..., export_symbols: Optional[List[str]] = ..., debug: bool = ..., extra_preargs: Optional[List[str]] = ..., extra_postargs: Optional[List[str]] = ..., build_temp: Optional[str] = ..., target_lang: Optional[str] = ..., ) -> None: ... def preprocess( self, source: str, output_file: Optional[str] = ..., macros: Optional[List[_Macro]] = ..., include_dirs: Optional[List[str]] = ..., extra_preargs: Optional[List[str]] = ..., extra_postargs: Optional[List[str]] = ..., ) -> None: ... def executable_filename(self, basename: str, strip_dir: int = ..., output_dir: str = ...) -> str: ... def library_filename(self, libname: str, lib_type: str = ..., strip_dir: int = ..., output_dir: str = ...) -> str: ... def object_filenames(self, source_filenames: List[str], strip_dir: int = ..., output_dir: str = ...) -> List[str]: ... def shared_object_filename(self, basename: str, strip_dir: int = ..., output_dir: str = ...) -> str: ... def execute(self, func: Callable[..., None], args: Tuple[Any, ...], msg: Optional[str] = ..., level: int = ...) -> None: ... def spawn(self, cmd: List[str]) -> None: ... def mkpath(self, name: str, mode: int = ...) -> None: ... def move_file(self, src: str, dst: str) -> str: ... def announce(self, msg: str, level: int = ...) -> None: ... def warn(self, msg: str) -> None: ... def debug_print(self, msg: str) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/distutils/cmd.pyi0000664000175000017500000000540100000000000024425 0ustar00davedave00000000000000from abc import abstractmethod from distutils.dist import Distribution from typing import Any, Callable, Iterable, List, Optional, Text, Tuple, Union class Command: sub_commands: List[Tuple[str, Optional[Callable[[Command], bool]]]] def __init__(self, dist: Distribution) -> None: ... @abstractmethod def initialize_options(self) -> None: ... @abstractmethod def finalize_options(self) -> None: ... @abstractmethod def run(self) -> None: ... def announce(self, msg: Text, level: int = ...) -> None: ... def debug_print(self, msg: Text) -> None: ... def ensure_string(self, option: str, default: Optional[str] = ...) -> None: ... def ensure_string_list(self, option: Union[str, List[str]]) -> None: ... def ensure_filename(self, option: str) -> None: ... def ensure_dirname(self, option: str) -> None: ... def get_command_name(self) -> str: ... def set_undefined_options(self, src_cmd: Text, *option_pairs: Tuple[str, str]) -> None: ... def get_finalized_command(self, command: Text, create: int = ...) -> Command: ... def reinitialize_command(self, command: Union[Command, Text], reinit_subcommands: int = ...) -> Command: ... def run_command(self, command: Text) -> None: ... def get_sub_commands(self) -> List[str]: ... def warn(self, msg: Text) -> None: ... def execute(self, func: Callable[..., Any], args: Iterable[Any], msg: Optional[Text] = ..., level: int = ...) -> None: ... def mkpath(self, name: str, mode: int = ...) -> None: ... def copy_file( self, infile: str, outfile: str, preserve_mode: int = ..., preserve_times: int = ..., link: Optional[str] = ..., level: Any = ..., ) -> Tuple[str, bool]: ... # level is not used def copy_tree( self, infile: str, outfile: str, preserve_mode: int = ..., preserve_times: int = ..., preserve_symlinks: int = ..., level: Any = ..., ) -> List[str]: ... # level is not used def move_file(self, src: str, dst: str, level: Any = ...) -> str: ... # level is not used def spawn(self, cmd: Iterable[str], search_path: int = ..., level: Any = ...) -> None: ... # level is not used def make_archive( self, base_name: str, format: str, root_dir: Optional[str] = ..., base_dir: Optional[str] = ..., owner: Optional[str] = ..., group: Optional[str] = ..., ) -> str: ... def make_file( self, infiles: Union[str, List[str], Tuple[str]], outfile: str, func: Callable[..., Any], args: List[Any], exec_msg: Optional[str] = ..., skip_msg: Optional[str] = ..., level: Any = ..., ) -> None: ... # level is not used ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4143794 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/distutils/command/0000775000175000017500000000000000000000000024555 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/distutils/command/__init__.pyi0000664000175000017500000000000000000000000027025 0ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/distutils/command/bdist.pyi0000664000175000017500000000000000000000000026373 0ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/distutils/command/bdist_dumb.pyi0000664000175000017500000000000000000000000027402 0ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/distutils/command/bdist_msi.pyi0000664000175000017500000000026600000000000027261 0ustar00davedave00000000000000from distutils.cmd import Command class bdist_msi(Command): def initialize_options(self) -> None: ... def finalize_options(self) -> None: ... def run(self) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/distutils/command/bdist_packager.pyi0000664000175000017500000000000000000000000030230 0ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/distutils/command/bdist_rpm.pyi0000664000175000017500000000000000000000000027251 0ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/distutils/command/bdist_wininst.pyi0000664000175000017500000000000000000000000030146 0ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/distutils/command/build.pyi0000664000175000017500000000000000000000000026365 0ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/distutils/command/build_clib.pyi0000664000175000017500000000000000000000000027356 0ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/distutils/command/build_ext.pyi0000664000175000017500000000000000000000000027245 0ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/distutils/command/build_py.pyi0000664000175000017500000000026500000000000027112 0ustar00davedave00000000000000from distutils.cmd import Command class build_py(Command): def initialize_options(self) -> None: ... def finalize_options(self) -> None: ... def run(self) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/distutils/command/build_scripts.pyi0000664000175000017500000000000000000000000030134 0ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/distutils/command/check.pyi0000664000175000017500000000000000000000000026343 0ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/distutils/command/clean.pyi0000664000175000017500000000000000000000000026350 0ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/distutils/command/config.pyi0000664000175000017500000000576300000000000026560 0ustar00davedave00000000000000from distutils import log as log from distutils.ccompiler import CCompiler from distutils.core import Command as Command from distutils.errors import DistutilsExecError as DistutilsExecError from distutils.sysconfig import customize_compiler as customize_compiler from typing import Dict, List, Optional, Pattern, Sequence, Tuple, Union LANG_EXT: Dict[str, str] class config(Command): description: str = ... # Tuple is full name, short name, description user_options: Sequence[Tuple[str, Optional[str], str]] = ... compiler: Optional[Union[str, CCompiler]] = ... cc: Optional[str] = ... include_dirs: Optional[Sequence[str]] = ... libraries: Optional[Sequence[str]] = ... library_dirs: Optional[Sequence[str]] = ... noisy: int = ... dump_source: int = ... temp_files: Sequence[str] = ... def initialize_options(self) -> None: ... def finalize_options(self) -> None: ... def run(self) -> None: ... def try_cpp( self, body: Optional[str] = ..., headers: Optional[Sequence[str]] = ..., include_dirs: Optional[Sequence[str]] = ..., lang: str = ..., ) -> bool: ... def search_cpp( self, pattern: Union[Pattern[str], str], body: Optional[str] = ..., headers: Optional[Sequence[str]] = ..., include_dirs: Optional[Sequence[str]] = ..., lang: str = ..., ) -> bool: ... def try_compile( self, body: str, headers: Optional[Sequence[str]] = ..., include_dirs: Optional[Sequence[str]] = ..., lang: str = ... ) -> bool: ... def try_link( self, body: str, headers: Optional[Sequence[str]] = ..., include_dirs: Optional[Sequence[str]] = ..., libraries: Optional[Sequence[str]] = ..., library_dirs: Optional[Sequence[str]] = ..., lang: str = ..., ) -> bool: ... def try_run( self, body: str, headers: Optional[Sequence[str]] = ..., include_dirs: Optional[Sequence[str]] = ..., libraries: Optional[Sequence[str]] = ..., library_dirs: Optional[Sequence[str]] = ..., lang: str = ..., ) -> bool: ... def check_func( self, func: str, headers: Optional[Sequence[str]] = ..., include_dirs: Optional[Sequence[str]] = ..., libraries: Optional[Sequence[str]] = ..., library_dirs: Optional[Sequence[str]] = ..., decl: int = ..., call: int = ..., ) -> bool: ... def check_lib( self, library: str, library_dirs: Optional[Sequence[str]] = ..., headers: Optional[Sequence[str]] = ..., include_dirs: Optional[Sequence[str]] = ..., other_libraries: List[str] = ..., ) -> bool: ... def check_header( self, header: str, include_dirs: Optional[Sequence[str]] = ..., library_dirs: Optional[Sequence[str]] = ..., lang: str = ..., ) -> bool: ... def dump_file(filename: str, head: Optional[str] = ...) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/distutils/command/install.pyi0000664000175000017500000000052200000000000026745 0ustar00davedave00000000000000from distutils.cmd import Command from typing import Optional, Text class install(Command): user: bool prefix: Optional[Text] home: Optional[Text] root: Optional[Text] install_lib: Optional[Text] def initialize_options(self) -> None: ... def finalize_options(self) -> None: ... def run(self) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/distutils/command/install_data.pyi0000664000175000017500000000000000000000000027725 0ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/distutils/command/install_egg_info.pyi0000664000175000017500000000057400000000000030611 0ustar00davedave00000000000000from distutils.cmd import Command from typing import ClassVar, List, Optional, Tuple class install_egg_info(Command): description: ClassVar[str] user_options: ClassVar[List[Tuple[str, Optional[str], str]]] def initialize_options(self) -> None: ... def finalize_options(self) -> None: ... def run(self) -> None: ... def get_outputs(self) -> List[str]: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/distutils/command/install_headers.pyi0000664000175000017500000000000000000000000030427 0ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/distutils/command/install_lib.pyi0000664000175000017500000000000000000000000027562 0ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/distutils/command/install_scripts.pyi0000664000175000017500000000000000000000000030503 0ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/distutils/command/register.pyi0000664000175000017500000000000000000000000027112 0ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/distutils/command/sdist.pyi0000664000175000017500000000000000000000000026414 0ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/distutils/command/upload.pyi0000664000175000017500000000045000000000000026563 0ustar00davedave00000000000000from distutils.config import PyPIRCCommand from typing import ClassVar, List, Optional, Tuple class upload(PyPIRCCommand): description: ClassVar[str] boolean_options: ClassVar[List[str]] def run(self) -> None: ... def upload_file(self, command, pyversion, filename) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/distutils/config.pyi0000664000175000017500000000101300000000000025122 0ustar00davedave00000000000000from abc import abstractmethod from distutils.cmd import Command from typing import ClassVar, List, Optional, Tuple DEFAULT_PYPIRC: str class PyPIRCCommand(Command): DEFAULT_REPOSITORY: ClassVar[str] DEFAULT_REALM: ClassVar[str] repository: None realm: None user_options: ClassVar[List[Tuple[str, Optional[str], str]]] boolean_options: ClassVar[List[str]] def initialize_options(self) -> None: ... def finalize_options(self) -> None: ... @abstractmethod def run(self) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/distutils/core.pyi0000664000175000017500000000323000000000000024610 0ustar00davedave00000000000000from distutils.cmd import Command as Command from distutils.dist import Distribution as Distribution from distutils.extension import Extension as Extension from typing import Any, List, Mapping, Optional, Tuple, Type, Union def setup( *, name: str = ..., version: str = ..., description: str = ..., long_description: str = ..., author: str = ..., author_email: str = ..., maintainer: str = ..., maintainer_email: str = ..., url: str = ..., download_url: str = ..., packages: List[str] = ..., py_modules: List[str] = ..., scripts: List[str] = ..., ext_modules: List[Extension] = ..., classifiers: List[str] = ..., distclass: Type[Distribution] = ..., script_name: str = ..., script_args: List[str] = ..., options: Mapping[str, Any] = ..., license: str = ..., keywords: Union[List[str], str] = ..., platforms: Union[List[str], str] = ..., cmdclass: Mapping[str, Type[Command]] = ..., data_files: List[Tuple[str, List[str]]] = ..., package_dir: Mapping[str, str] = ..., obsoletes: List[str] = ..., provides: List[str] = ..., requires: List[str] = ..., command_packages: List[str] = ..., command_options: Mapping[str, Mapping[str, Tuple[Any, Any]]] = ..., package_data: Mapping[str, List[str]] = ..., include_package_data: bool = ..., libraries: List[str] = ..., headers: List[str] = ..., ext_package: str = ..., include_dirs: List[str] = ..., password: str = ..., fullname: str = ..., **attrs: Any, ) -> None: ... def run_setup(script_name: str, script_args: Optional[List[str]] = ..., stop_after: str = ...) -> Distribution: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/distutils/cygwinccompiler.pyi0000664000175000017500000000021200000000000027053 0ustar00davedave00000000000000from distutils.unixccompiler import UnixCCompiler class CygwinCCompiler(UnixCCompiler): ... class Mingw32CCompiler(CygwinCCompiler): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/distutils/debug.pyi0000664000175000017500000000001400000000000024743 0ustar00davedave00000000000000DEBUG: bool ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/distutils/dep_util.pyi0000664000175000017500000000037400000000000025473 0ustar00davedave00000000000000from typing import List, Tuple def newer(source: str, target: str) -> bool: ... def newer_pairwise(sources: List[str], targets: List[str]) -> List[Tuple[str, str]]: ... def newer_group(sources: List[str], target: str, missing: str = ...) -> bool: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/distutils/dir_util.pyi0000664000175000017500000000105300000000000025474 0ustar00davedave00000000000000from typing import List def mkpath(name: str, mode: int = ..., verbose: int = ..., dry_run: int = ...) -> List[str]: ... def create_tree(base_dir: str, files: List[str], mode: int = ..., verbose: int = ..., dry_run: int = ...) -> None: ... def copy_tree( src: str, dst: str, preserve_mode: int = ..., preserve_times: int = ..., preserve_symlinks: int = ..., update: int = ..., verbose: int = ..., dry_run: int = ..., ) -> List[str]: ... def remove_tree(directory: str, verbose: int = ..., dry_run: int = ...) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/distutils/dist.pyi0000664000175000017500000000077400000000000024635 0ustar00davedave00000000000000from distutils.cmd import Command from typing import Any, Dict, Iterable, Mapping, Optional, Text, Tuple, Type class Distribution: cmdclass: Dict[str, Type[Command]] def __init__(self, attrs: Optional[Mapping[str, Any]] = ...) -> None: ... def get_option_dict(self, command: str) -> Dict[str, Tuple[str, Text]]: ... def parse_config_files(self, filenames: Optional[Iterable[Text]] = ...) -> None: ... def get_command_obj(self, command: str, create: bool = ...) -> Optional[Command]: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/distutils/emxccompiler.pyi0000664000175000017500000000013200000000000026345 0ustar00davedave00000000000000from distutils.unixccompiler import UnixCCompiler class EMXCCompiler(UnixCCompiler): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/distutils/errors.pyi0000664000175000017500000000152400000000000025200 0ustar00davedave00000000000000class DistutilsError(Exception): ... class DistutilsModuleError(DistutilsError): ... class DistutilsClassError(DistutilsError): ... class DistutilsGetoptError(DistutilsError): ... class DistutilsArgError(DistutilsError): ... class DistutilsFileError(DistutilsError): ... class DistutilsOptionError(DistutilsError): ... class DistutilsSetupError(DistutilsError): ... class DistutilsPlatformError(DistutilsError): ... class DistutilsExecError(DistutilsError): ... class DistutilsInternalError(DistutilsError): ... class DistutilsTemplateError(DistutilsError): ... class DistutilsByteCompileError(DistutilsError): ... class CCompilerError(Exception): ... class PreprocessError(CCompilerError): ... class CompileError(CCompilerError): ... class LibError(CCompilerError): ... class LinkError(CCompilerError): ... class UnknownFileError(CCompilerError): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/distutils/extension.pyi0000664000175000017500000000130200000000000025672 0ustar00davedave00000000000000from typing import List, Optional, Tuple class Extension: def __init__( self, name: str, sources: List[str], include_dirs: List[str] = ..., define_macros: List[Tuple[str, Optional[str]]] = ..., undef_macros: List[str] = ..., library_dirs: List[str] = ..., libraries: List[str] = ..., runtime_library_dirs: List[str] = ..., extra_objects: List[str] = ..., extra_compile_args: List[str] = ..., extra_link_args: List[str] = ..., export_symbols: List[str] = ..., swig_opts: Optional[str] = ..., # undocumented depends: List[str] = ..., language: str = ..., ) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/distutils/fancy_getopt.pyi0000664000175000017500000000153300000000000026346 0ustar00davedave00000000000000from typing import Any, List, Mapping, Optional, Tuple, Union, overload _Option = Tuple[str, Optional[str], str] _GR = Tuple[List[str], OptionDummy] def fancy_getopt( options: List[_Option], negative_opt: Mapping[_Option, _Option], object: Any, args: Optional[List[str]] ) -> Union[List[str], _GR]: ... def wrap_text(text: str, width: int) -> List[str]: ... class FancyGetopt: def __init__(self, option_table: Optional[List[_Option]] = ...) -> None: ... # TODO kinda wrong, `getopt(object=object())` is invalid @overload def getopt(self, args: Optional[List[str]] = ...) -> _GR: ... @overload def getopt(self, args: Optional[List[str]], object: Any) -> List[str]: ... def get_option_order(self) -> List[Tuple[str, str]]: ... def generate_help(self, header: Optional[str] = ...) -> List[str]: ... class OptionDummy: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/distutils/file_util.pyi0000664000175000017500000000066700000000000025647 0ustar00davedave00000000000000from typing import Optional, Sequence, Tuple def copy_file( src: str, dst: str, preserve_mode: bool = ..., preserve_times: bool = ..., update: bool = ..., link: Optional[str] = ..., verbose: bool = ..., dry_run: bool = ..., ) -> Tuple[str, str]: ... def move_file(src: str, dst: str, verbose: bool = ..., dry_run: bool = ...) -> str: ... def write_file(filename: str, contents: Sequence[str]) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/distutils/filelist.pyi0000664000175000017500000000002400000000000025471 0ustar00davedave00000000000000class FileList: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/distutils/log.pyi0000664000175000017500000000153700000000000024451 0ustar00davedave00000000000000from typing import Any, Text DEBUG: int INFO: int WARN: int ERROR: int FATAL: int class Log: def __init__(self, threshold: int = ...) -> None: ... def log(self, level: int, msg: Text, *args: Any) -> None: ... def debug(self, msg: Text, *args: Any) -> None: ... def info(self, msg: Text, *args: Any) -> None: ... def warn(self, msg: Text, *args: Any) -> None: ... def error(self, msg: Text, *args: Any) -> None: ... def fatal(self, msg: Text, *args: Any) -> None: ... def log(level: int, msg: Text, *args: Any) -> None: ... def debug(msg: Text, *args: Any) -> None: ... def info(msg: Text, *args: Any) -> None: ... def warn(msg: Text, *args: Any) -> None: ... def error(msg: Text, *args: Any) -> None: ... def fatal(msg: Text, *args: Any) -> None: ... def set_threshold(level: int) -> int: ... def set_verbosity(v: int) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/distutils/msvccompiler.pyi0000664000175000017500000000011600000000000026363 0ustar00davedave00000000000000from distutils.ccompiler import CCompiler class MSVCCompiler(CCompiler): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/distutils/spawn.pyi0000664000175000017500000000034300000000000025012 0ustar00davedave00000000000000from typing import List, Optional def spawn(cmd: List[str], search_path: bool = ..., verbose: bool = ..., dry_run: bool = ...) -> None: ... def find_executable(executable: str, path: Optional[str] = ...) -> Optional[str]: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/distutils/sysconfig.pyi0000664000175000017500000000115400000000000025667 0ustar00davedave00000000000000from distutils.ccompiler import CCompiler from typing import Mapping, Optional, Union PREFIX: str EXEC_PREFIX: str def get_config_var(name: str) -> Union[int, str, None]: ... def get_config_vars(*args: str) -> Mapping[str, Union[int, str]]: ... def get_config_h_filename() -> str: ... def get_makefile_filename() -> str: ... def get_python_inc(plat_specific: bool = ..., prefix: Optional[str] = ...) -> str: ... def get_python_lib(plat_specific: bool = ..., standard_lib: bool = ..., prefix: Optional[str] = ...) -> str: ... def customize_compiler(compiler: CCompiler) -> None: ... def set_python_build() -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/distutils/text_file.pyi0000664000175000017500000000131400000000000025644 0ustar00davedave00000000000000from typing import IO, List, Optional, Tuple, Union class TextFile: def __init__( self, filename: Optional[str] = ..., file: Optional[IO[str]] = ..., *, strip_comments: bool = ..., lstrip_ws: bool = ..., rstrip_ws: bool = ..., skip_blanks: bool = ..., join_lines: bool = ..., collapse_join: bool = ..., ) -> None: ... def open(self, filename: str) -> None: ... def close(self) -> None: ... def warn(self, msg: str, line: Union[List[int], Tuple[int, int], int] = ...) -> None: ... def readline(self) -> Optional[str]: ... def readlines(self) -> List[str]: ... def unreadline(self, line: str) -> str: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/distutils/unixccompiler.pyi0000664000175000017500000000011700000000000026542 0ustar00davedave00000000000000from distutils.ccompiler import CCompiler class UnixCCompiler(CCompiler): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/distutils/util.pyi0000664000175000017500000000147500000000000024646 0ustar00davedave00000000000000from typing import Any, Callable, List, Mapping, Optional, Tuple def get_platform() -> str: ... def convert_path(pathname: str) -> str: ... def change_root(new_root: str, pathname: str) -> str: ... def check_environ() -> None: ... def subst_vars(s: str, local_vars: Mapping[str, str]) -> None: ... def split_quoted(s: str) -> List[str]: ... def execute( func: Callable[..., None], args: Tuple[Any, ...], msg: Optional[str] = ..., verbose: bool = ..., dry_run: bool = ... ) -> None: ... def strtobool(val: str) -> bool: ... def byte_compile( py_files: List[str], optimize: int = ..., force: bool = ..., prefix: Optional[str] = ..., base_dir: Optional[str] = ..., verbose: bool = ..., dry_run: bool = ..., direct: Optional[bool] = ..., ) -> None: ... def rfc822_escape(header: str) -> str: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/distutils/version.pyi0000664000175000017500000000221000000000000025342 0ustar00davedave00000000000000from abc import abstractmethod from typing import Optional, Pattern, Text, Tuple, TypeVar, Union _T = TypeVar("_T", bound=Version) class Version: def __repr__(self) -> str: ... @abstractmethod def __init__(self, vstring: Optional[Text] = ...) -> None: ... @abstractmethod def parse(self: _T, vstring: Text) -> _T: ... @abstractmethod def __str__(self) -> str: ... @abstractmethod def __cmp__(self: _T, other: Union[_T, str]) -> bool: ... class StrictVersion(Version): version_re: Pattern[str] version: Tuple[int, int, int] prerelease: Optional[Tuple[Text, int]] def __init__(self, vstring: Optional[Text] = ...) -> None: ... def parse(self: _T, vstring: Text) -> _T: ... def __str__(self) -> str: ... def __cmp__(self: _T, other: Union[_T, str]) -> bool: ... class LooseVersion(Version): component_re: Pattern[str] vstring: Text version: Tuple[Union[Text, int], ...] def __init__(self, vstring: Optional[Text] = ...) -> None: ... def parse(self: _T, vstring: Text) -> _T: ... def __str__(self) -> str: ... def __cmp__(self: _T, other: Union[_T, str]) -> bool: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/dummy_thread.pyi0000664000175000017500000000143200000000000024320 0ustar00davedave00000000000000from typing import Any, Callable, Dict, NoReturn, Optional, Tuple class error(Exception): def __init__(self, *args: Any) -> None: ... def start_new_thread(function: Callable[..., Any], args: Tuple[Any, ...], kwargs: Dict[str, Any] = ...) -> None: ... def exit() -> NoReturn: ... def get_ident() -> int: ... def allocate_lock() -> LockType: ... def stack_size(size: Optional[int] = ...) -> int: ... class LockType(object): locked_status: bool def __init__(self) -> None: ... def acquire(self, waitflag: Optional[bool] = ...) -> bool: ... def __enter__(self, waitflag: Optional[bool] = ...) -> bool: ... def __exit__(self, typ: Any, val: Any, tb: Any) -> None: ... def release(self) -> bool: ... def locked(self) -> bool: ... def interrupt_main() -> None: ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4143794 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/email/0000775000175000017500000000000000000000000022202 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/email/MIMEText.pyi0000664000175000017500000000023700000000000024323 0ustar00davedave00000000000000from email.mime.nonmultipart import MIMENonMultipart class MIMEText(MIMENonMultipart): def __init__(self, _text, _subtype=..., _charset=...) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/email/__init__.pyi0000664000175000017500000000041600000000000024465 0ustar00davedave00000000000000from typing import IO, Any, AnyStr def message_from_string(s: AnyStr, *args, **kwargs): ... def message_from_bytes(s: str, *args, **kwargs): ... def message_from_file(fp: IO[AnyStr], *args, **kwargs): ... def message_from_binary_file(fp: IO[str], *args, **kwargs): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/email/_parseaddr.pyi0000664000175000017500000000206000000000000025027 0ustar00davedave00000000000000from typing import Any, Optional def parsedate_tz(data): ... def parsedate(data): ... def mktime_tz(data): ... def quote(str): ... class AddrlistClass: specials: Any pos: Any LWS: Any CR: Any FWS: Any atomends: Any phraseends: Any field: Any commentlist: Any def __init__(self, field): ... def gotonext(self): ... def getaddrlist(self): ... def getaddress(self): ... def getrouteaddr(self): ... def getaddrspec(self): ... def getdomain(self): ... def getdelimited(self, beginchar, endchars, allowcomments: bool = ...): ... def getquote(self): ... def getcomment(self): ... def getdomainliteral(self): ... def getatom(self, atomends: Optional[Any] = ...): ... def getphraselist(self): ... class AddressList(AddrlistClass): addresslist: Any def __init__(self, field): ... def __len__(self): ... def __add__(self, other): ... def __iadd__(self, other): ... def __sub__(self, other): ... def __isub__(self, other): ... def __getitem__(self, index): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/email/base64mime.pyi0000664000175000017500000000045700000000000024667 0ustar00davedave00000000000000def base64_len(s: bytes) -> int: ... def header_encode(header, charset=..., keep_eols=..., maxlinelen=..., eol=...): ... def encode(s, binary=..., maxlinelen=..., eol=...): ... body_encode = encode encodestring = encode def decode(s, convert_eols=...): ... body_decode = decode decodestring = decode ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/email/charset.pyi0000664000175000017500000000160600000000000024361 0ustar00davedave00000000000000def add_charset(charset, header_enc=..., body_enc=..., output_charset=...) -> None: ... def add_alias(alias, canonical) -> None: ... def add_codec(charset, codecname) -> None: ... QP: int # undocumented BASE64: int # undocumented SHORTEST: int # undocumented class Charset: input_charset = ... header_encoding = ... body_encoding = ... output_charset = ... input_codec = ... output_codec = ... def __init__(self, input_charset=...) -> None: ... def __eq__(self, other): ... def __ne__(self, other): ... def get_body_encoding(self): ... def convert(self, s): ... def to_splittable(self, s): ... def from_splittable(self, ustr, to_output: bool = ...): ... def get_output_charset(self): ... def encoded_header_len(self, s): ... def header_encode(self, s, convert: bool = ...): ... def body_encode(self, s, convert: bool = ...): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/email/encoders.pyi0000664000175000017500000000021700000000000024527 0ustar00davedave00000000000000def encode_base64(msg) -> None: ... def encode_quopri(msg) -> None: ... def encode_7or8bit(msg) -> None: ... def encode_noop(msg) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/email/feedparser.pyi0000664000175000017500000000103000000000000025037 0ustar00davedave00000000000000class BufferedSubFile: def __init__(self) -> None: ... def push_eof_matcher(self, pred) -> None: ... def pop_eof_matcher(self): ... def close(self) -> None: ... def readline(self): ... def unreadline(self, line) -> None: ... def push(self, data): ... def pushlines(self, lines) -> None: ... def is_closed(self): ... def __iter__(self): ... def next(self): ... class FeedParser: def __init__(self, _factory=...) -> None: ... def feed(self, data) -> None: ... def close(self): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/email/generator.pyi0000664000175000017500000000057100000000000024716 0ustar00davedave00000000000000class Generator: def __init__(self, outfp, mangle_from_: bool = ..., maxheaderlen: int = ...) -> None: ... def write(self, s) -> None: ... def flatten(self, msg, unixfrom: bool = ...) -> None: ... def clone(self, fp): ... class DecodedGenerator(Generator): def __init__(self, outfp, mangle_from_: bool = ..., maxheaderlen: int = ..., fmt=...) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/email/header.pyi0000664000175000017500000000071100000000000024154 0ustar00davedave00000000000000def decode_header(header): ... def make_header(decoded_seq, maxlinelen=..., header_name=..., continuation_ws=...): ... class Header: def __init__(self, s=..., charset=..., maxlinelen=..., header_name=..., continuation_ws=..., errors=...) -> None: ... def __unicode__(self): ... def __eq__(self, other): ... def __ne__(self, other): ... def append(self, s, charset=..., errors=...) -> None: ... def encode(self, splitchars=...): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/email/iterators.pyi0000664000175000017500000000040000000000000024733 0ustar00davedave00000000000000from typing import Any, Generator def walk(self) -> Generator[Any, Any, Any]: ... def body_line_iterator(msg, decode: bool = ...) -> Generator[Any, Any, Any]: ... def typed_subpart_iterator(msg, maintype=..., subtype=...) -> Generator[Any, Any, Any]: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/email/message.pyi0000664000175000017500000000363600000000000024361 0ustar00davedave00000000000000from typing import Any, Generator class Message: preamble = ... epilogue = ... defects = ... def __init__(self): ... def as_string(self, unixfrom=...): ... def is_multipart(self) -> bool: ... def set_unixfrom(self, unixfrom) -> None: ... def get_unixfrom(self): ... def attach(self, payload) -> None: ... def get_payload(self, i=..., decode: bool = ...): ... def set_payload(self, payload, charset=...) -> None: ... def set_charset(self, charset): ... def get_charset(self): ... def __len__(self): ... def __getitem__(self, name): ... def __setitem__(self, name, val) -> None: ... def __delitem__(self, name) -> None: ... def __contains__(self, name): ... def has_key(self, name) -> bool: ... def keys(self): ... def values(self): ... def items(self): ... def get(self, name, failobj=...): ... def get_all(self, name, failobj=...): ... def add_header(self, _name, _value, **_params) -> None: ... def replace_header(self, _name, _value) -> None: ... def get_content_type(self): ... def get_content_maintype(self): ... def get_content_subtype(self): ... def get_default_type(self): ... def set_default_type(self, ctype) -> None: ... def get_params(self, failobj=..., header=..., unquote: bool = ...): ... def get_param(self, param, failobj=..., header=..., unquote: bool = ...): ... def set_param(self, param, value, header=..., requote: bool = ..., charset=..., language=...) -> None: ... def del_param(self, param, header=..., requote: bool = ...): ... def set_type(self, type, header=..., requote: bool = ...): ... def get_filename(self, failobj=...): ... def get_boundary(self, failobj=...): ... def set_boundary(self, boundary) -> None: ... def get_content_charset(self, failobj=...): ... def get_charsets(self, failobj=...): ... def walk(self) -> Generator[Any, Any, Any]: ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4183793 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/email/mime/0000775000175000017500000000000000000000000023131 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/email/mime/__init__.pyi0000664000175000017500000000000000000000000025401 0ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/email/mime/application.pyi0000664000175000017500000000056300000000000026163 0ustar00davedave00000000000000from email.mime.nonmultipart import MIMENonMultipart from typing import Callable, Optional, Tuple, Union _ParamsType = Union[str, None, Tuple[str, Optional[str], str]] class MIMEApplication(MIMENonMultipart): def __init__( self, _data: bytes, _subtype: str = ..., _encoder: Callable[[MIMEApplication], None] = ..., **_params: _ParamsType ) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/email/mime/audio.pyi0000664000175000017500000000026000000000000024753 0ustar00davedave00000000000000from email.mime.nonmultipart import MIMENonMultipart class MIMEAudio(MIMENonMultipart): def __init__(self, _audiodata, _subtype=..., _encoder=..., **_params) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/email/mime/base.pyi0000664000175000017500000000020000000000000024556 0ustar00davedave00000000000000from email import message class MIMEBase(message.Message): def __init__(self, _maintype, _subtype, **_params) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/email/mime/image.pyi0000664000175000017500000000026000000000000024734 0ustar00davedave00000000000000from email.mime.nonmultipart import MIMENonMultipart class MIMEImage(MIMENonMultipart): def __init__(self, _imagedata, _subtype=..., _encoder=..., **_params) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/email/mime/message.pyi0000664000175000017500000000022300000000000025275 0ustar00davedave00000000000000from email.mime.nonmultipart import MIMENonMultipart class MIMEMessage(MIMENonMultipart): def __init__(self, _msg, _subtype=...) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/email/mime/multipart.pyi0000664000175000017500000000023700000000000025677 0ustar00davedave00000000000000from email.mime.base import MIMEBase class MIMEMultipart(MIMEBase): def __init__(self, _subtype=..., boundary=..., _subparts=..., **_params) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/email/mime/nonmultipart.pyi0000664000175000017500000000015300000000000026407 0ustar00davedave00000000000000from email.mime.base import MIMEBase class MIMENonMultipart(MIMEBase): def attach(self, payload): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/email/mime/text.pyi0000664000175000017500000000023700000000000024642 0ustar00davedave00000000000000from email.mime.nonmultipart import MIMENonMultipart class MIMEText(MIMENonMultipart): def __init__(self, _text, _subtype=..., _charset=...) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/email/parser.pyi0000664000175000017500000000063700000000000024227 0ustar00davedave00000000000000from .feedparser import FeedParser as FeedParser # not in __all__ but listed in documentation class Parser: def __init__(self, *args, **kws) -> None: ... def parse(self, fp, headersonly: bool = ...): ... def parsestr(self, text, headersonly: bool = ...): ... class HeaderParser(Parser): def parse(self, fp, headersonly: bool = ...): ... def parsestr(self, text, headersonly: bool = ...): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/email/quoprimime.pyi0000664000175000017500000000075200000000000025120 0ustar00davedave00000000000000def header_quopri_check(c): ... def body_quopri_check(c): ... def header_quopri_len(s): ... def body_quopri_len(str): ... def unquote(s): ... def quote(c): ... def header_encode(header, charset: str = ..., keep_eols: bool = ..., maxlinelen: int = ..., eol=...): ... def encode(body, binary: bool = ..., maxlinelen: int = ..., eol=...): ... body_encode = encode encodestring = encode def decode(encoded, eol=...): ... body_decode = decode decodestring = decode def header_decode(s): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/email/utils.pyi0000664000175000017500000000137000000000000024066 0ustar00davedave00000000000000from email._parseaddr import ( AddressList as _AddressList, mktime_tz as mktime_tz, parsedate as _parsedate, parsedate_tz as _parsedate_tz, ) from quopri import decodestring as _qdecode from typing import Any, Optional def formataddr(pair): ... def getaddresses(fieldvalues): ... def formatdate(timeval: Optional[Any] = ..., localtime: bool = ..., usegmt: bool = ...): ... def make_msgid(idstring: Optional[Any] = ...): ... def parsedate(data): ... def parsedate_tz(data): ... def parseaddr(addr): ... def unquote(str): ... def decode_rfc2231(s): ... def encode_rfc2231(s, charset: Optional[Any] = ..., language: Optional[Any] = ...): ... def decode_params(params): ... def collapse_rfc2231_value(value, errors=..., fallback_charset=...): ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4183793 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/encodings/0000775000175000017500000000000000000000000023064 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/encodings/__init__.pyi0000664000175000017500000000027000000000000025345 0ustar00davedave00000000000000import codecs from typing import Any def search_function(encoding: str) -> codecs.CodecInfo: ... # Explicitly mark this package as incomplete. def __getattr__(name: str) -> Any: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/encodings/utf_8.pyi0000664000175000017500000000107500000000000024637 0ustar00davedave00000000000000import codecs from typing import Text, Tuple class IncrementalEncoder(codecs.IncrementalEncoder): def encode(self, input: Text, final: bool = ...) -> bytes: ... class IncrementalDecoder(codecs.BufferedIncrementalDecoder): def _buffer_decode(self, input: bytes, errors: str, final: bool) -> Tuple[Text, int]: ... class StreamWriter(codecs.StreamWriter): ... class StreamReader(codecs.StreamReader): ... def getregentry() -> codecs.CodecInfo: ... def encode(input: Text, errors: Text = ...) -> bytes: ... def decode(input: bytes, errors: Text = ...) -> Text: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/exceptions.pyi0000664000175000017500000000333400000000000024022 0ustar00davedave00000000000000from __builtin__ import ( ArithmeticError as ArithmeticError, AssertionError as AssertionError, AttributeError as AttributeError, BaseException as BaseException, BufferError as BufferError, BytesWarning as BytesWarning, DeprecationWarning as DeprecationWarning, EnvironmentError as EnvironmentError, EOFError as EOFError, Exception as Exception, FloatingPointError as FloatingPointError, FutureWarning as FutureWarning, GeneratorExit as GeneratorExit, ImportError as ImportError, ImportWarning as ImportWarning, IndentationError as IndentationError, IndexError as IndexError, IOError as IOError, KeyboardInterrupt as KeyboardInterrupt, KeyError as KeyError, LookupError as LookupError, MemoryError as MemoryError, NameError as NameError, NotImplementedError as NotImplementedError, OSError as OSError, OverflowError as OverflowError, PendingDeprecationWarning as PendingDeprecationWarning, ReferenceError as ReferenceError, RuntimeError as RuntimeError, RuntimeWarning as RuntimeWarning, StandardError as StandardError, StopIteration as StopIteration, SyntaxError as SyntaxError, SyntaxWarning as SyntaxWarning, SystemError as SystemError, SystemExit as SystemExit, TabError as TabError, TypeError as TypeError, UnboundLocalError as UnboundLocalError, UnicodeDecodeError as UnicodeDecodeError, UnicodeEncodeError as UnicodeEncodeError, UnicodeError as UnicodeError, UnicodeTranslateError as UnicodeTranslateError, UnicodeWarning as UnicodeWarning, UserWarning as UserWarning, ValueError as ValueError, Warning as Warning, ZeroDivisionError as ZeroDivisionError, ) ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/fcntl.pyi0000664000175000017500000000305400000000000022746 0ustar00davedave00000000000000from _typeshed import FileDescriptorLike from typing import Any, Union FASYNC: int FD_CLOEXEC: int DN_ACCESS: int DN_ATTRIB: int DN_CREATE: int DN_DELETE: int DN_MODIFY: int DN_MULTISHOT: int DN_RENAME: int F_DUPFD: int F_EXLCK: int F_GETFD: int F_GETFL: int F_GETLEASE: int F_GETLK: int F_GETLK64: int F_GETOWN: int F_GETSIG: int F_NOTIFY: int F_RDLCK: int F_SETFD: int F_SETFL: int F_SETLEASE: int F_SETLK: int F_SETLK64: int F_SETLKW: int F_SETLKW64: int F_SETOWN: int F_SETSIG: int F_SHLCK: int F_UNLCK: int F_WRLCK: int I_ATMARK: int I_CANPUT: int I_CKBAND: int I_FDINSERT: int I_FIND: int I_FLUSH: int I_FLUSHBAND: int I_GETBAND: int I_GETCLTIME: int I_GETSIG: int I_GRDOPT: int I_GWROPT: int I_LINK: int I_LIST: int I_LOOK: int I_NREAD: int I_PEEK: int I_PLINK: int I_POP: int I_PUNLINK: int I_PUSH: int I_RECVFD: int I_SENDFD: int I_SETCLTIME: int I_SETSIG: int I_SRDOPT: int I_STR: int I_SWROPT: int I_UNLINK: int LOCK_EX: int LOCK_MAND: int LOCK_NB: int LOCK_READ: int LOCK_RW: int LOCK_SH: int LOCK_UN: int LOCK_WRITE: int # TODO All these return either int or bytes depending on the value of # cmd (not on the type of arg). def fcntl(fd: FileDescriptorLike, op: int, arg: Union[int, bytes] = ...) -> Any: ... # TODO: arg: int or read-only buffer interface or read-write buffer interface def ioctl(fd: FileDescriptorLike, op: int, arg: Union[int, bytes] = ..., mutate_flag: bool = ...) -> Any: ... def flock(fd: FileDescriptorLike, op: int) -> None: ... def lockf(fd: FileDescriptorLike, op: int, length: int = ..., start: int = ..., whence: int = ...) -> Any: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/fnmatch.pyi0000664000175000017500000000053400000000000023260 0ustar00davedave00000000000000from typing import AnyStr, Iterable, List, Union _EitherStr = Union[str, unicode] def fnmatch(filename: _EitherStr, pattern: _EitherStr) -> bool: ... def fnmatchcase(filename: _EitherStr, pattern: _EitherStr) -> bool: ... def filter(names: Iterable[AnyStr], pattern: _EitherStr) -> List[AnyStr]: ... def translate(pattern: AnyStr) -> AnyStr: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/functools.pyi0000664000175000017500000000223400000000000023653 0ustar00davedave00000000000000from abc import ABCMeta, abstractmethod from typing import Any, Callable, Dict, Generic, Iterable, Optional, Sequence, Tuple, Type, TypeVar, overload _AnyCallable = Callable[..., Any] _T = TypeVar("_T") _S = TypeVar("_S") @overload def reduce(function: Callable[[_T, _T], _T], sequence: Iterable[_T]) -> _T: ... @overload def reduce(function: Callable[[_T, _S], _T], sequence: Iterable[_S], initial: _T) -> _T: ... WRAPPER_ASSIGNMENTS: Sequence[str] WRAPPER_UPDATES: Sequence[str] def update_wrapper( wrapper: _AnyCallable, wrapped: _AnyCallable, assigned: Sequence[str] = ..., updated: Sequence[str] = ... ) -> _AnyCallable: ... def wraps( wrapped: _AnyCallable, assigned: Sequence[str] = ..., updated: Sequence[str] = ... ) -> Callable[[_AnyCallable], _AnyCallable]: ... def total_ordering(cls: Type[_T]) -> Type[_T]: ... def cmp_to_key(mycmp: Callable[[_T, _T], int]) -> Callable[[_T], Any]: ... class partial(Generic[_T]): func = ... # Callable[..., _T] args: Tuple[Any, ...] keywords: Dict[str, Any] def __init__(self, func: Callable[..., _T], *args: Any, **kwargs: Any) -> None: ... def __call__(self, *args: Any, **kwargs: Any) -> _T: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/future_builtins.pyi0000664000175000017500000000030200000000000025054 0ustar00davedave00000000000000from itertools import ifilter, imap, izip from typing import Any filter = ifilter map = imap zip = izip def ascii(obj: Any) -> str: ... def hex(x: int) -> str: ... def oct(x: int) -> str: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/gc.pyi0000664000175000017500000000136000000000000022227 0ustar00davedave00000000000000from typing import Any, List, Tuple def enable() -> None: ... def disable() -> None: ... def isenabled() -> bool: ... def collect(generation: int = ...) -> int: ... def set_debug(flags: int) -> None: ... def get_debug() -> int: ... def get_objects() -> List[Any]: ... def set_threshold(threshold0: int, threshold1: int = ..., threshold2: int = ...) -> None: ... def get_count() -> Tuple[int, int, int]: ... def get_threshold() -> Tuple[int, int, int]: ... def get_referrers(*objs: Any) -> List[Any]: ... def get_referents(*objs: Any) -> List[Any]: ... def is_tracked(obj: Any) -> bool: ... garbage: List[Any] DEBUG_STATS: int DEBUG_COLLECTABLE: int DEBUG_UNCOLLECTABLE: int DEBUG_INSTANCES: int DEBUG_OBJECTS: int DEBUG_SAVEALL: int DEBUG_LEAK: int ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/getopt.pyi0000664000175000017500000000070000000000000023135 0ustar00davedave00000000000000from typing import List, Tuple class GetoptError(Exception): opt: str msg: str def __init__(self, msg: str, opt: str = ...) -> None: ... def __str__(self) -> str: ... error = GetoptError def getopt(args: List[str], shortopts: str, longopts: List[str] = ...) -> Tuple[List[Tuple[str, str]], List[str]]: ... def gnu_getopt(args: List[str], shortopts: str, longopts: List[str] = ...) -> Tuple[List[Tuple[str, str]], List[str]]: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/getpass.pyi0000664000175000017500000000024000000000000023300 0ustar00davedave00000000000000from typing import IO, Any class GetPassWarning(UserWarning): ... def getpass(prompt: str = ..., stream: IO[Any] = ...) -> str: ... def getuser() -> str: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/gettext.pyi0000664000175000017500000000435500000000000023331 0ustar00davedave00000000000000from typing import IO, Any, Container, Dict, List, Optional, Sequence, Type, Union def bindtextdomain(domain: str, localedir: str = ...) -> str: ... def bind_textdomain_codeset(domain: str, codeset: str = ...) -> str: ... def textdomain(domain: str = ...) -> str: ... def gettext(message: str) -> str: ... def lgettext(message: str) -> str: ... def dgettext(domain: str, message: str) -> str: ... def ldgettext(domain: str, message: str) -> str: ... def ngettext(singular: str, plural: str, n: int) -> str: ... def lngettext(singular: str, plural: str, n: int) -> str: ... def dngettext(domain: str, singular: str, plural: str, n: int) -> str: ... def ldngettext(domain: str, singular: str, plural: str, n: int) -> str: ... class NullTranslations(object): def __init__(self, fp: IO[str] = ...) -> None: ... def _parse(self, fp: IO[str]) -> None: ... def add_fallback(self, fallback: NullTranslations) -> None: ... def gettext(self, message: str) -> str: ... def lgettext(self, message: str) -> str: ... def ugettext(self, message: Union[str, unicode]) -> unicode: ... def ngettext(self, singular: str, plural: str, n: int) -> str: ... def lngettext(self, singular: str, plural: str, n: int) -> str: ... def ungettext(self, singular: Union[str, unicode], plural: Union[str, unicode], n: int) -> unicode: ... def info(self) -> Dict[str, str]: ... def charset(self) -> Optional[str]: ... def output_charset(self) -> Optional[str]: ... def set_output_charset(self, charset: Optional[str]) -> None: ... def install(self, unicode: bool = ..., names: Container[str] = ...) -> None: ... class GNUTranslations(NullTranslations): LE_MAGIC: int BE_MAGIC: int def find( domain: str, localedir: Optional[str] = ..., languages: Optional[Sequence[str]] = ..., all: Any = ... ) -> Optional[Union[str, List[str]]]: ... def translation( domain: str, localedir: Optional[str] = ..., languages: Optional[Sequence[str]] = ..., class_: Optional[Type[NullTranslations]] = ..., fallback: bool = ..., codeset: Optional[str] = ..., ) -> NullTranslations: ... def install( domain: str, localedir: Optional[str] = ..., unicode: bool = ..., codeset: Optional[str] = ..., names: Container[str] = ... ) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/glob.pyi0000664000175000017500000000056700000000000022571 0ustar00davedave00000000000000from typing import AnyStr, Iterator, List, Union def glob(pathname: AnyStr) -> List[AnyStr]: ... def iglob(pathname: AnyStr) -> Iterator[AnyStr]: ... def glob1(dirname: Union[str, unicode], pattern: AnyStr) -> List[AnyStr]: ... def glob0(dirname: Union[str, unicode], basename: AnyStr) -> List[AnyStr]: ... def has_magic(s: Union[str, unicode]) -> bool: ... # undocumented ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/gzip.pyi0000664000175000017500000000174500000000000022616 0ustar00davedave00000000000000import io from typing import IO, Any, Text class GzipFile(io.BufferedIOBase): myfileobj: Any max_read_chunk: Any mode: Any extrabuf: Any extrasize: Any extrastart: Any name: Any min_readsize: Any compress: Any fileobj: Any offset: Any mtime: Any def __init__( self, filename: str = ..., mode: Text = ..., compresslevel: int = ..., fileobj: IO[str] = ..., mtime: float = ... ) -> None: ... @property def filename(self): ... size: Any crc: Any def write(self, data): ... def read(self, size=...): ... @property def closed(self): ... def close(self): ... def flush(self, zlib_mode=...): ... def fileno(self): ... def rewind(self): ... def readable(self): ... def writable(self): ... def seekable(self): ... def seek(self, offset, whence=...): ... def readline(self, size=...): ... def open(filename: str, mode: Text = ..., compresslevel: int = ...) -> GzipFile: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/hashlib.pyi0000664000175000017500000000171300000000000023252 0ustar00davedave00000000000000from typing import Tuple, Union _DataType = Union[str, unicode, bytearray, buffer, memoryview] class _hash(object): # This is not actually in the module namespace. name: str block_size: int digest_size: int digestsize: int def __init__(self, arg: _DataType = ...) -> None: ... def update(self, arg: _DataType) -> None: ... def digest(self) -> str: ... def hexdigest(self) -> str: ... def copy(self) -> _hash: ... def new(name: str, data: str = ...) -> _hash: ... def md5(s: _DataType = ...) -> _hash: ... def sha1(s: _DataType = ...) -> _hash: ... def sha224(s: _DataType = ...) -> _hash: ... def sha256(s: _DataType = ...) -> _hash: ... def sha384(s: _DataType = ...) -> _hash: ... def sha512(s: _DataType = ...) -> _hash: ... algorithms: Tuple[str, ...] algorithms_guaranteed: Tuple[str, ...] algorithms_available: Tuple[str, ...] def pbkdf2_hmac(name: str, password: str, salt: str, rounds: int, dklen: int = ...) -> str: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/heapq.pyi0000664000175000017500000000136400000000000022740 0ustar00davedave00000000000000from _typeshed import SupportsLessThan from typing import Any, Callable, Iterable, List, Optional, Protocol, TypeVar _T = TypeVar("_T") def cmp_lt(x, y) -> bool: ... def heappush(heap: List[_T], item: _T) -> None: ... def heappop(heap: List[_T]) -> _T: ... def heappushpop(heap: List[_T], item: _T) -> _T: ... def heapify(x: List[_T]) -> None: ... def heapreplace(heap: List[_T], item: _T) -> _T: ... def merge(*iterables: Iterable[_T]) -> Iterable[_T]: ... def nlargest(n: int, iterable: Iterable[_T], key: Optional[Callable[[_T], SupportsLessThan]] = ...) -> List[_T]: ... def nsmallest(n: int, iterable: Iterable[_T], key: Optional[Callable[[_T], SupportsLessThan]] = ...) -> List[_T]: ... def _heapify_max(__x: List[_T]) -> None: ... # undocumented ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/htmlentitydefs.pyi0000664000175000017500000000016200000000000024700 0ustar00davedave00000000000000from typing import Dict name2codepoint: Dict[str, int] codepoint2name: Dict[int, str] entitydefs: Dict[str, str] ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/httplib.pyi0000664000175000017500000001345100000000000023310 0ustar00davedave00000000000000import mimetools import ssl from typing import Any, Dict, Optional, Protocol class HTTPMessage(mimetools.Message): def addcontinue(self, key: str, more: str) -> None: ... dict: Dict[str, str] def addheader(self, key: str, value: str) -> None: ... unixfrom: str headers: Any status: str seekable: bool def readheaders(self) -> None: ... class HTTPResponse: fp: Any debuglevel: Any strict: Any msg: Any version: Any status: Any reason: Any chunked: Any chunk_left: Any length: Any will_close: Any def __init__( self, sock, debuglevel: int = ..., strict: int = ..., method: Optional[Any] = ..., buffering: bool = ... ) -> None: ... def begin(self): ... def close(self): ... def isclosed(self): ... def read(self, amt: Optional[Any] = ...): ... def fileno(self): ... def getheader(self, name, default: Optional[Any] = ...): ... def getheaders(self): ... # This is an API stub only for HTTPConnection and HTTPSConnection, as used in # urllib2.AbstractHTTPHandler.do_open, which takes either the class # HTTPConnection or the class HTTPSConnection, *not* an instance of either # class. do_open does not use all of the parameters of HTTPConnection.__init__ # or HTTPSConnection.__init__, so HTTPConnectionProtocol only implements the # parameters that do_open does use. class HTTPConnectionProtocol(Protocol): def __call__(self, host: str, timeout: int = ..., **http_con_args: Any) -> HTTPConnection: ... class HTTPConnection: response_class: Any default_port: Any auto_open: Any debuglevel: Any strict: Any timeout: Any source_address: Any sock: Any host: str = ... port: int = ... def __init__( self, host, port: Optional[Any] = ..., strict: Optional[Any] = ..., timeout=..., source_address: Optional[Any] = ... ) -> None: ... def set_tunnel(self, host, port: Optional[Any] = ..., headers: Optional[Any] = ...): ... def set_debuglevel(self, level): ... def connect(self): ... def close(self): ... def send(self, data): ... def putrequest(self, method, url, skip_host: int = ..., skip_accept_encoding: int = ...): ... def putheader(self, header, *values): ... def endheaders(self, message_body: Optional[Any] = ...): ... def request(self, method, url, body: Optional[Any] = ..., headers=...): ... def getresponse(self, buffering: bool = ...): ... class HTTP: debuglevel: Any def __init__(self, host: str = ..., port: Optional[Any] = ..., strict: Optional[Any] = ...) -> None: ... def connect(self, host: Optional[Any] = ..., port: Optional[Any] = ...): ... def getfile(self): ... file: Any headers: Any def getreply(self, buffering: bool = ...): ... def close(self): ... class HTTPSConnection(HTTPConnection): default_port: Any key_file: Any cert_file: Any def __init__( self, host, port: Optional[Any] = ..., key_file: Optional[Any] = ..., cert_file: Optional[Any] = ..., strict: Optional[Any] = ..., timeout=..., source_address: Optional[Any] = ..., context: Optional[Any] = ..., ) -> None: ... sock: Any def connect(self): ... class HTTPS(HTTP): key_file: Any cert_file: Any def __init__( self, host: str = ..., port: Optional[Any] = ..., key_file: Optional[Any] = ..., cert_file: Optional[Any] = ..., strict: Optional[Any] = ..., context: Optional[Any] = ..., ) -> None: ... class HTTPException(Exception): ... class NotConnected(HTTPException): ... class InvalidURL(HTTPException): ... class UnknownProtocol(HTTPException): args: Any version: Any def __init__(self, version) -> None: ... class UnknownTransferEncoding(HTTPException): ... class UnimplementedFileMode(HTTPException): ... class IncompleteRead(HTTPException): args: Any partial: Any expected: Any def __init__(self, partial, expected: Optional[Any] = ...) -> None: ... class ImproperConnectionState(HTTPException): ... class CannotSendRequest(ImproperConnectionState): ... class CannotSendHeader(ImproperConnectionState): ... class ResponseNotReady(ImproperConnectionState): ... class BadStatusLine(HTTPException): args: Any line: Any def __init__(self, line) -> None: ... class LineTooLong(HTTPException): def __init__(self, line_type) -> None: ... error: Any class LineAndFileWrapper: def __init__(self, line, file) -> None: ... def __getattr__(self, attr): ... def read(self, amt: Optional[Any] = ...): ... def readline(self): ... def readlines(self, size: Optional[Any] = ...): ... # Constants responses: Dict[int, str] HTTP_PORT: int HTTPS_PORT: int # status codes # informational CONTINUE: int SWITCHING_PROTOCOLS: int PROCESSING: int # successful OK: int CREATED: int ACCEPTED: int NON_AUTHORITATIVE_INFORMATION: int NO_CONTENT: int RESET_CONTENT: int PARTIAL_CONTENT: int MULTI_STATUS: int IM_USED: int # redirection MULTIPLE_CHOICES: int MOVED_PERMANENTLY: int FOUND: int SEE_OTHER: int NOT_MODIFIED: int USE_PROXY: int TEMPORARY_REDIRECT: int # client error BAD_REQUEST: int UNAUTHORIZED: int PAYMENT_REQUIRED: int FORBIDDEN: int NOT_FOUND: int METHOD_NOT_ALLOWED: int NOT_ACCEPTABLE: int PROXY_AUTHENTICATION_REQUIRED: int REQUEST_TIMEOUT: int CONFLICT: int GONE: int LENGTH_REQUIRED: int PRECONDITION_FAILED: int REQUEST_ENTITY_TOO_LARGE: int REQUEST_URI_TOO_LONG: int UNSUPPORTED_MEDIA_TYPE: int REQUESTED_RANGE_NOT_SATISFIABLE: int EXPECTATION_FAILED: int UNPROCESSABLE_ENTITY: int LOCKED: int FAILED_DEPENDENCY: int UPGRADE_REQUIRED: int # server error INTERNAL_SERVER_ERROR: int NOT_IMPLEMENTED: int BAD_GATEWAY: int SERVICE_UNAVAILABLE: int GATEWAY_TIMEOUT: int HTTP_VERSION_NOT_SUPPORTED: int INSUFFICIENT_STORAGE: int NOT_EXTENDED: int ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/imp.pyi0000664000175000017500000000241200000000000022422 0ustar00davedave00000000000000import types from typing import IO, Any, Iterable, List, Optional, Tuple C_BUILTIN: int C_EXTENSION: int IMP_HOOK: int PKG_DIRECTORY: int PY_CODERESOURCE: int PY_COMPILED: int PY_FROZEN: int PY_RESOURCE: int PY_SOURCE: int SEARCH_ERROR: int def acquire_lock() -> None: ... def find_module(name: str, path: Iterable[str] = ...) -> Optional[Tuple[IO[Any], str, Tuple[str, str, int]]]: ... def get_magic() -> str: ... def get_suffixes() -> List[Tuple[str, str, int]]: ... def init_builtin(name: str) -> types.ModuleType: ... def init_frozen(name: str) -> types.ModuleType: ... def is_builtin(name: str) -> int: ... def is_frozen(name: str) -> bool: ... def load_compiled(name: str, pathname: str, file: IO[Any] = ...) -> types.ModuleType: ... def load_dynamic(name: str, pathname: str, file: IO[Any] = ...) -> types.ModuleType: ... def load_module(name: str, file: str, pathname: str, description: Tuple[str, str, int]) -> types.ModuleType: ... def load_source(name: str, pathname: str, file: IO[Any] = ...) -> types.ModuleType: ... def lock_held() -> bool: ... def new_module(name: str) -> types.ModuleType: ... def release_lock() -> None: ... class NullImporter: def __init__(self, path_string: str) -> None: ... def find_module(self, fullname: str, path: str = ...) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/importlib.pyi0000664000175000017500000000020600000000000023635 0ustar00davedave00000000000000import types from typing import Optional, Text def import_module(name: Text, package: Optional[Text] = ...) -> types.ModuleType: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/inspect.pyi0000664000175000017500000001112400000000000023302 0ustar00davedave00000000000000from types import CodeType, FrameType, FunctionType, MethodType, ModuleType, TracebackType from typing import Any, AnyStr, Callable, Dict, List, NamedTuple, Optional, Sequence, Tuple, Type, Union # Types and members class EndOfBlock(Exception): ... class BlockFinder: indent: int islambda: bool started: bool passline: bool last: int def tokeneater( self, type: int, token: AnyStr, srow_scol: Tuple[int, int], erow_ecol: Tuple[int, int], line: AnyStr ) -> None: ... CO_GENERATOR: int CO_NESTED: int CO_NEWLOCALS: int CO_NOFREE: int CO_OPTIMIZED: int CO_VARARGS: int CO_VARKEYWORDS: int TPFLAGS_IS_ABSTRACT: int class ModuleInfo(NamedTuple): name: str suffix: str mode: str module_type: int def getmembers(object: object, predicate: Optional[Callable[[Any], bool]] = ...) -> List[Tuple[str, Any]]: ... def getmoduleinfo(path: Union[str, unicode]) -> Optional[ModuleInfo]: ... def getmodulename(path: AnyStr) -> Optional[AnyStr]: ... def ismodule(object: object) -> bool: ... def isclass(object: object) -> bool: ... def ismethod(object: object) -> bool: ... def isfunction(object: object) -> bool: ... def isgeneratorfunction(object: object) -> bool: ... def isgenerator(object: object) -> bool: ... def istraceback(object: object) -> bool: ... def isframe(object: object) -> bool: ... def iscode(object: object) -> bool: ... def isbuiltin(object: object) -> bool: ... def isroutine(object: object) -> bool: ... def isabstract(object: object) -> bool: ... def ismethoddescriptor(object: object) -> bool: ... def isdatadescriptor(object: object) -> bool: ... def isgetsetdescriptor(object: object) -> bool: ... def ismemberdescriptor(object: object) -> bool: ... # Retrieving source code _SourceObjectType = Union[ModuleType, Type[Any], MethodType, FunctionType, TracebackType, FrameType, CodeType, Callable[..., Any]] def findsource(object: _SourceObjectType) -> Tuple[List[str], int]: ... def getabsfile(object: _SourceObjectType) -> str: ... def getblock(lines: Sequence[AnyStr]) -> Sequence[AnyStr]: ... def getdoc(object: object) -> Optional[str]: ... def getcomments(object: object) -> Optional[str]: ... def getfile(object: _SourceObjectType) -> str: ... def getmodule(object: object) -> Optional[ModuleType]: ... def getsourcefile(object: _SourceObjectType) -> Optional[str]: ... def getsourcelines(object: _SourceObjectType) -> Tuple[List[str], int]: ... def getsource(object: _SourceObjectType) -> str: ... def cleandoc(doc: AnyStr) -> AnyStr: ... def indentsize(line: Union[str, unicode]) -> int: ... # Classes and functions def getclasstree(classes: List[type], unique: bool = ...) -> List[Union[Tuple[type, Tuple[type, ...]], List[Any]]]: ... class ArgSpec(NamedTuple): args: List[str] varargs: Optional[str] keywords: Optional[str] defaults: Tuple[Any, ...] class ArgInfo(NamedTuple): args: List[str] varargs: Optional[str] keywords: Optional[str] locals: Dict[str, Any] class Arguments(NamedTuple): args: List[Union[str, List[Any]]] varargs: Optional[str] keywords: Optional[str] def getargs(co: CodeType) -> Arguments: ... def getargspec(func: object) -> ArgSpec: ... def getargvalues(frame: FrameType) -> ArgInfo: ... def formatargspec( args, varargs=..., varkw=..., defaults=..., formatarg=..., formatvarargs=..., formatvarkw=..., formatvalue=..., join=... ) -> str: ... def formatargvalues( args, varargs=..., varkw=..., defaults=..., formatarg=..., formatvarargs=..., formatvarkw=..., formatvalue=..., join=... ) -> str: ... def getmro(cls: type) -> Tuple[type, ...]: ... def getcallargs(func, *args, **kwds) -> Dict[str, Any]: ... # The interpreter stack class Traceback(NamedTuple): filename: str lineno: int function: str code_context: Optional[List[str]] index: Optional[int] # type: ignore _FrameInfo = Tuple[FrameType, str, int, str, Optional[List[str]], Optional[int]] def getouterframes(frame: FrameType, context: int = ...) -> List[_FrameInfo]: ... def getframeinfo(frame: Union[FrameType, TracebackType], context: int = ...) -> Traceback: ... def getinnerframes(traceback: TracebackType, context: int = ...) -> List[_FrameInfo]: ... def getlineno(frame: FrameType) -> int: ... def currentframe(depth: int = ...) -> FrameType: ... def stack(context: int = ...) -> List[_FrameInfo]: ... def trace(context: int = ...) -> List[_FrameInfo]: ... # Create private type alias to avoid conflict with symbol of same # name created in Attribute class. _Object = object class Attribute(NamedTuple): name: str kind: str defining_class: type object: _Object def classify_class_attrs(cls: type) -> List[Attribute]: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/io.pyi0000664000175000017500000000216000000000000022244 0ustar00davedave00000000000000from typing import IO, Any, Union import _io from _io import ( DEFAULT_BUFFER_SIZE as DEFAULT_BUFFER_SIZE, BlockingIOError as BlockingIOError, BufferedRandom as BufferedRandom, BufferedReader as BufferedReader, BufferedRWPair as BufferedRWPair, BufferedWriter as BufferedWriter, BytesIO as BytesIO, FileIO as FileIO, IncrementalNewlineDecoder as IncrementalNewlineDecoder, StringIO as StringIO, TextIOWrapper as TextIOWrapper, UnsupportedOperation as UnsupportedOperation, open as open, ) def _OpenWrapper( file: Union[str, unicode, int], mode: unicode = ..., buffering: int = ..., encoding: unicode = ..., errors: unicode = ..., newline: unicode = ..., closefd: bool = ..., ) -> IO[Any]: ... SEEK_SET: int SEEK_CUR: int SEEK_END: int class IOBase(_io._IOBase): ... class RawIOBase(_io._RawIOBase, IOBase): ... class BufferedIOBase(_io._BufferedIOBase, IOBase): ... # Note: In the actual io.py, TextIOBase subclasses IOBase. # (Which we don't do here because we don't want to subclass both TextIO and BinaryIO.) class TextIOBase(_io._TextIOBase): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/itertools.pyi0000664000175000017500000001352700000000000023672 0ustar00davedave00000000000000from typing import Any, Callable, Generic, Iterable, Iterator, Optional, Sequence, Tuple, TypeVar, Union, overload _T = TypeVar("_T") _S = TypeVar("_S") def count(start: int = ..., step: int = ...) -> Iterator[int]: ... # more general types? class cycle(Iterator[_T], Generic[_T]): def __init__(self, iterable: Iterable[_T]) -> None: ... def next(self) -> _T: ... def __iter__(self) -> Iterator[_T]: ... def repeat(object: _T, times: int = ...) -> Iterator[_T]: ... class chain(Iterator[_T], Generic[_T]): def __init__(self, *iterables: Iterable[_T]) -> None: ... def next(self) -> _T: ... def __iter__(self) -> Iterator[_T]: ... @staticmethod def from_iterable(iterable: Iterable[Iterable[_S]]) -> Iterator[_S]: ... def compress(data: Iterable[_T], selectors: Iterable[Any]) -> Iterator[_T]: ... def dropwhile(predicate: Callable[[_T], Any], iterable: Iterable[_T]) -> Iterator[_T]: ... def ifilter(predicate: Optional[Callable[[_T], Any]], iterable: Iterable[_T]) -> Iterator[_T]: ... def ifilterfalse(predicate: Optional[Callable[[_T], Any]], iterable: Iterable[_T]) -> Iterator[_T]: ... @overload def groupby(iterable: Iterable[_T], key: None = ...) -> Iterator[Tuple[_T, Iterator[_T]]]: ... @overload def groupby(iterable: Iterable[_T], key: Callable[[_T], _S]) -> Iterator[Tuple[_S, Iterator[_T]]]: ... @overload def islice(iterable: Iterable[_T], stop: Optional[int]) -> Iterator[_T]: ... @overload def islice(iterable: Iterable[_T], start: Optional[int], stop: Optional[int], step: Optional[int] = ...) -> Iterator[_T]: ... _T1 = TypeVar("_T1") _T2 = TypeVar("_T2") _T3 = TypeVar("_T3") _T4 = TypeVar("_T4") _T5 = TypeVar("_T5") _T6 = TypeVar("_T6") @overload def imap(func: Callable[[_T1], _S], iter1: Iterable[_T1]) -> Iterator[_S]: ... @overload def imap(func: Callable[[_T1, _T2], _S], iter1: Iterable[_T1], iter2: Iterable[_T2]) -> Iterator[_S]: ... @overload def imap( func: Callable[[_T1, _T2, _T3], _S], iter1: Iterable[_T1], iter2: Iterable[_T2], iter3: Iterable[_T3] ) -> Iterator[_S]: ... @overload def imap( func: Callable[[_T1, _T2, _T3, _T4], _S], iter1: Iterable[_T1], iter2: Iterable[_T2], iter3: Iterable[_T3], iter4: Iterable[_T4], ) -> Iterator[_S]: ... @overload def imap( func: Callable[[_T1, _T2, _T3, _T4, _T5], _S], iter1: Iterable[_T1], iter2: Iterable[_T2], iter3: Iterable[_T3], iter4: Iterable[_T4], iter5: Iterable[_T5], ) -> Iterator[_S]: ... @overload def imap( func: Callable[[_T1, _T2, _T3, _T4, _T5, _T6], _S], iter1: Iterable[_T1], iter2: Iterable[_T2], iter3: Iterable[_T3], iter4: Iterable[_T4], iter5: Iterable[_T5], iter6: Iterable[_T6], ) -> Iterator[_S]: ... @overload def imap( func: Callable[..., _S], iter1: Iterable[Any], iter2: Iterable[Any], iter3: Iterable[Any], iter4: Iterable[Any], iter5: Iterable[Any], iter6: Iterable[Any], iter7: Iterable[Any], *iterables: Iterable[Any], ) -> Iterator[_S]: ... def starmap(func: Any, iterable: Iterable[Any]) -> Iterator[Any]: ... def takewhile(predicate: Callable[[_T], Any], iterable: Iterable[_T]) -> Iterator[_T]: ... def tee(iterable: Iterable[_T], n: int = ...) -> Tuple[Iterator[_T], ...]: ... @overload def izip(iter1: Iterable[_T1]) -> Iterator[Tuple[_T1]]: ... @overload def izip(iter1: Iterable[_T1], iter2: Iterable[_T2]) -> Iterator[Tuple[_T1, _T2]]: ... @overload def izip(iter1: Iterable[_T1], iter2: Iterable[_T2], iter3: Iterable[_T3]) -> Iterator[Tuple[_T1, _T2, _T3]]: ... @overload def izip( iter1: Iterable[_T1], iter2: Iterable[_T2], iter3: Iterable[_T3], iter4: Iterable[_T4] ) -> Iterator[Tuple[_T1, _T2, _T3, _T4]]: ... @overload def izip( iter1: Iterable[_T1], iter2: Iterable[_T2], iter3: Iterable[_T3], iter4: Iterable[_T4], iter5: Iterable[_T5] ) -> Iterator[Tuple[_T1, _T2, _T3, _T4, _T5]]: ... @overload def izip( iter1: Iterable[_T1], iter2: Iterable[_T2], iter3: Iterable[_T3], iter4: Iterable[_T4], iter5: Iterable[_T5], iter6: Iterable[_T6], ) -> Iterator[Tuple[_T1, _T2, _T3, _T4, _T5, _T6]]: ... @overload def izip( iter1: Iterable[Any], iter2: Iterable[Any], iter3: Iterable[Any], iter4: Iterable[Any], iter5: Iterable[Any], iter6: Iterable[Any], iter7: Iterable[Any], *iterables: Iterable[Any], ) -> Iterator[Tuple[Any, ...]]: ... def izip_longest(*p: Iterable[Any], fillvalue: Any = ...) -> Iterator[Any]: ... @overload def product(iter1: Iterable[_T1]) -> Iterator[Tuple[_T1]]: ... @overload def product(iter1: Iterable[_T1], iter2: Iterable[_T2]) -> Iterator[Tuple[_T1, _T2]]: ... @overload def product(iter1: Iterable[_T1], iter2: Iterable[_T2], iter3: Iterable[_T3]) -> Iterator[Tuple[_T1, _T2, _T3]]: ... @overload def product( iter1: Iterable[_T1], iter2: Iterable[_T2], iter3: Iterable[_T3], iter4: Iterable[_T4] ) -> Iterator[Tuple[_T1, _T2, _T3, _T4]]: ... @overload def product( iter1: Iterable[_T1], iter2: Iterable[_T2], iter3: Iterable[_T3], iter4: Iterable[_T4], iter5: Iterable[_T5] ) -> Iterator[Tuple[_T1, _T2, _T3, _T4, _T5]]: ... @overload def product( iter1: Iterable[_T1], iter2: Iterable[_T2], iter3: Iterable[_T3], iter4: Iterable[_T4], iter5: Iterable[_T5], iter6: Iterable[_T6], ) -> Iterator[Tuple[_T1, _T2, _T3, _T4, _T5, _T6]]: ... @overload def product( iter1: Iterable[Any], iter2: Iterable[Any], iter3: Iterable[Any], iter4: Iterable[Any], iter5: Iterable[Any], iter6: Iterable[Any], iter7: Iterable[Any], *iterables: Iterable[Any], ) -> Iterator[Tuple[Any, ...]]: ... @overload def product(*iterables: Iterable[Any], repeat: int) -> Iterator[Tuple[Any, ...]]: ... def permutations(iterable: Iterable[_T], r: int = ...) -> Iterator[Sequence[_T]]: ... def combinations(iterable: Iterable[_T], r: int) -> Iterator[Sequence[_T]]: ... def combinations_with_replacement(iterable: Iterable[_T], r: int) -> Iterator[Sequence[_T]]: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/json.pyi0000664000175000017500000000620600000000000022613 0ustar00davedave00000000000000from _typeshed import SupportsRead from typing import IO, Any, Callable, Dict, List, Optional, Text, Tuple, Type, Union def dumps( obj: Any, skipkeys: bool = ..., ensure_ascii: bool = ..., check_circular: bool = ..., allow_nan: bool = ..., cls: Optional[Type[JSONEncoder]] = ..., indent: Optional[int] = ..., separators: Optional[Tuple[str, str]] = ..., encoding: str = ..., default: Optional[Callable[[Any], Any]] = ..., sort_keys: bool = ..., **kwds: Any, ) -> str: ... def dump( obj: Any, fp: Union[IO[str], IO[Text]], skipkeys: bool = ..., ensure_ascii: bool = ..., check_circular: bool = ..., allow_nan: bool = ..., cls: Optional[Type[JSONEncoder]] = ..., indent: Optional[int] = ..., separators: Optional[Tuple[str, str]] = ..., encoding: str = ..., default: Optional[Callable[[Any], Any]] = ..., sort_keys: bool = ..., **kwds: Any, ) -> None: ... def loads( s: Union[Text, bytes], encoding: Any = ..., cls: Optional[Type[JSONDecoder]] = ..., object_hook: Optional[Callable[[Dict[Any, Any]], Any]] = ..., parse_float: Optional[Callable[[str], Any]] = ..., parse_int: Optional[Callable[[str], Any]] = ..., parse_constant: Optional[Callable[[str], Any]] = ..., object_pairs_hook: Optional[Callable[[List[Tuple[Any, Any]]], Any]] = ..., **kwds: Any, ) -> Any: ... def load( fp: SupportsRead[Union[Text, bytes]], encoding: Optional[str] = ..., cls: Optional[Type[JSONDecoder]] = ..., object_hook: Optional[Callable[[Dict[Any, Any]], Any]] = ..., parse_float: Optional[Callable[[str], Any]] = ..., parse_int: Optional[Callable[[str], Any]] = ..., parse_constant: Optional[Callable[[str], Any]] = ..., object_pairs_hook: Optional[Callable[[List[Tuple[Any, Any]]], Any]] = ..., **kwds: Any, ) -> Any: ... class JSONDecoder(object): def __init__( self, encoding: Union[Text, bytes] = ..., object_hook: Callable[..., Any] = ..., parse_float: Callable[[str], float] = ..., parse_int: Callable[[str], int] = ..., parse_constant: Callable[[str], Any] = ..., strict: bool = ..., object_pairs_hook: Callable[..., Any] = ..., ) -> None: ... def decode(self, s: Union[Text, bytes], _w: Any = ...) -> Any: ... def raw_decode(self, s: Union[Text, bytes], idx: int = ...) -> Tuple[Any, Any]: ... class JSONEncoder(object): item_separator: str key_separator: str skipkeys: bool ensure_ascii: bool check_circular: bool allow_nan: bool sort_keys: bool indent: Optional[int] def __init__( self, skipkeys: bool = ..., ensure_ascii: bool = ..., check_circular: bool = ..., allow_nan: bool = ..., sort_keys: bool = ..., indent: Optional[int] = ..., separators: Tuple[Union[Text, bytes], Union[Text, bytes]] = ..., encoding: Union[Text, bytes] = ..., default: Callable[..., Any] = ..., ) -> None: ... def default(self, o: Any) -> Any: ... def encode(self, o: Any) -> str: ... def iterencode(self, o: Any, _one_shot: bool = ...) -> str: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/markupbase.pyi0000664000175000017500000000041000000000000023763 0ustar00davedave00000000000000from typing import Tuple class ParserBase(object): def __init__(self) -> None: ... def error(self, message: str) -> None: ... def reset(self) -> None: ... def getpos(self) -> Tuple[int, int]: ... def unknown_decl(self, data: str) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/md5.pyi0000664000175000017500000000011200000000000022315 0ustar00davedave00000000000000from hashlib import md5 as md5 new = md5 blocksize: int digest_size: int ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/mimetools.pyi0000664000175000017500000000127700000000000023655 0ustar00davedave00000000000000import rfc822 from typing import Any class Message(rfc822.Message): encodingheader: Any typeheader: Any def __init__(self, fp, seekable: int = ...): ... plisttext: Any type: Any maintype: Any subtype: Any def parsetype(self): ... plist: Any def parseplist(self): ... def getplist(self): ... def getparam(self, name): ... def getparamnames(self): ... def getencoding(self): ... def gettype(self): ... def getmaintype(self): ... def getsubtype(self): ... def choose_boundary(): ... def decode(input, output, encoding): ... def encode(input, output, encoding): ... def copyliteral(input, output): ... def copybinary(input, output): ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4183793 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/multiprocessing/0000775000175000017500000000000000000000000024342 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/multiprocessing/__init__.pyi0000664000175000017500000000360100000000000026624 0ustar00davedave00000000000000from multiprocessing import pool from multiprocessing.process import Process as Process, active_children as active_children, current_process as current_process from multiprocessing.util import SUBDEBUG as SUBDEBUG, SUBWARNING as SUBWARNING from Queue import Queue as _BaseQueue from typing import Any, Callable, Iterable, Optional, TypeVar class ProcessError(Exception): ... class BufferTooShort(ProcessError): ... class TimeoutError(ProcessError): ... class AuthenticationError(ProcessError): ... _T = TypeVar("_T") class Queue(_BaseQueue[_T]): def __init__(self, maxsize: int = ...) -> None: ... def get(self, block: bool = ..., timeout: Optional[float] = ...) -> _T: ... def put(self, item: _T, block: bool = ..., timeout: Optional[float] = ...) -> None: ... def qsize(self) -> int: ... def empty(self) -> bool: ... def full(self) -> bool: ... def put_nowait(self, item: _T) -> None: ... def get_nowait(self) -> _T: ... def close(self) -> None: ... def join_thread(self) -> None: ... def cancel_join_thread(self) -> None: ... def Manager(): ... def Pipe(duplex: bool = ...): ... def cpu_count() -> int: ... def freeze_support(): ... def get_logger(): ... def log_to_stderr(level: Optional[Any] = ...): ... def allow_connection_pickling(): ... def Lock(): ... def RLock(): ... def Condition(lock: Optional[Any] = ...): ... def Semaphore(value: int = ...): ... def BoundedSemaphore(value: int = ...): ... def Event(): ... def JoinableQueue(maxsize: int = ...): ... def RawValue(typecode_or_type, *args): ... def RawArray(typecode_or_type, size_or_initializer): ... def Value(typecode_or_type, *args, **kwds): ... def Array(typecode_or_type, size_or_initializer, **kwds): ... def Pool( processes: Optional[int] = ..., initializer: Optional[Callable[..., Any]] = ..., initargs: Iterable[Any] = ..., maxtasksperchild: Optional[int] = ..., ) -> pool.Pool: ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4183793 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/multiprocessing/dummy/0000775000175000017500000000000000000000000025475 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/multiprocessing/dummy/__init__.pyi0000664000175000017500000000256000000000000027762 0ustar00davedave00000000000000import array import itertools import sys import threading import weakref from multiprocessing import TimeoutError, cpu_count from multiprocessing.dummy.connection import Pipe from Queue import Queue from threading import BoundedSemaphore, Event, Lock, RLock, Semaphore from typing import Any, List, Optional, Type class DummyProcess(threading.Thread): _children: weakref.WeakKeyDictionary[Any, Any] _parent: threading.Thread _pid: None _start_called: bool def __init__(self, group=..., target=..., name=..., args=..., kwargs=...) -> None: ... @property def exitcode(self) -> Optional[int]: ... Process = DummyProcess # This should be threading._Condition but threading.pyi exports it as Condition class Condition(threading.Condition): notify_all: Any class Namespace(object): def __init__(self, **kwds) -> None: ... class Value(object): _typecode: Any _value: Any value: Any def __init__(self, typecode, value, lock=...) -> None: ... def _get(self) -> Any: ... def _set(self, value) -> None: ... JoinableQueue = Queue def Array(typecode, sequence, lock=...) -> array.array[Any]: ... def Manager() -> Any: ... def Pool(processes=..., initializer=..., initargs=...) -> Any: ... def active_children() -> List[Any]: ... def current_process() -> threading.Thread: ... def freeze_support() -> None: ... def shutdown() -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/multiprocessing/dummy/connection.pyi0000664000175000017500000000124100000000000030355 0ustar00davedave00000000000000from Queue import Queue from typing import Any, List, Optional, Tuple, Type families: List[None] class Connection(object): _in: Any _out: Any recv: Any recv_bytes: Any send: Any send_bytes: Any def __init__(self, _in, _out) -> None: ... def close(self) -> None: ... def poll(self, timeout=...) -> Any: ... class Listener(object): _backlog_queue: Optional[Queue[Any]] address: Any def __init__(self, address=..., family=..., backlog=...) -> None: ... def accept(self) -> Connection: ... def close(self) -> None: ... def Client(address) -> Connection: ... def Pipe(duplex=...) -> Tuple[Connection, Connection]: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/multiprocessing/pool.pyi0000664000175000017500000000376600000000000026052 0ustar00davedave00000000000000from typing import Any, Callable, Dict, Iterable, Iterator, List, Optional, TypeVar _T = TypeVar("_T", bound=Pool) class AsyncResult: def get(self, timeout: Optional[float] = ...) -> Any: ... def wait(self, timeout: Optional[float] = ...) -> None: ... def ready(self) -> bool: ... def successful(self) -> bool: ... class IMapIterator(Iterator[Any]): def __iter__(self) -> Iterator[Any]: ... def next(self, timeout: Optional[float] = ...) -> Any: ... class IMapUnorderedIterator(IMapIterator): ... class Pool(object): def __init__( self, processes: Optional[int] = ..., initializer: Optional[Callable[..., None]] = ..., initargs: Iterable[Any] = ..., maxtasksperchild: Optional[int] = ..., ) -> None: ... def apply(self, func: Callable[..., Any], args: Iterable[Any] = ..., kwds: Dict[str, Any] = ...) -> Any: ... def apply_async( self, func: Callable[..., Any], args: Iterable[Any] = ..., kwds: Dict[str, Any] = ..., callback: Optional[Callable[..., None]] = ..., ) -> AsyncResult: ... def map(self, func: Callable[..., Any], iterable: Iterable[Any] = ..., chunksize: Optional[int] = ...) -> List[Any]: ... def map_async( self, func: Callable[..., Any], iterable: Iterable[Any] = ..., chunksize: Optional[int] = ..., callback: Optional[Callable[..., None]] = ..., ) -> AsyncResult: ... def imap(self, func: Callable[..., Any], iterable: Iterable[Any] = ..., chunksize: Optional[int] = ...) -> IMapIterator: ... def imap_unordered( self, func: Callable[..., Any], iterable: Iterable[Any] = ..., chunksize: Optional[int] = ... ) -> IMapIterator: ... def close(self) -> None: ... def terminate(self) -> None: ... def join(self) -> None: ... class ThreadPool(Pool): def __init__( self, processes: Optional[int] = ..., initializer: Optional[Callable[..., Any]] = ..., initargs: Iterable[Any] = ... ) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/multiprocessing/process.pyi0000664000175000017500000000161200000000000026543 0ustar00davedave00000000000000from typing import Any, Optional def current_process(): ... def active_children(): ... class Process: def __init__( self, group: Optional[Any] = ..., target: Optional[Any] = ..., name: Optional[Any] = ..., args=..., kwargs=... ): ... def run(self): ... def start(self): ... def terminate(self): ... def join(self, timeout: Optional[Any] = ...): ... def is_alive(self): ... @property def name(self): ... @name.setter def name(self, name): ... @property def daemon(self): ... @daemon.setter def daemon(self, daemonic): ... @property def authkey(self): ... @authkey.setter def authkey(self, authkey): ... @property def exitcode(self): ... @property def ident(self): ... pid: Any class AuthenticationString(bytes): def __reduce__(self): ... class _MainProcess(Process): def __init__(self): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/multiprocessing/util.pyi0000664000175000017500000000136600000000000026050 0ustar00davedave00000000000000import threading from typing import Any, Optional SUBDEBUG: Any SUBWARNING: Any def sub_debug(msg, *args): ... def debug(msg, *args): ... def info(msg, *args): ... def sub_warning(msg, *args): ... def get_logger(): ... def log_to_stderr(level: Optional[Any] = ...): ... def get_temp_dir(): ... def register_after_fork(obj, func): ... class Finalize: def __init__(self, obj, callback, args=..., kwargs: Optional[Any] = ..., exitpriority: Optional[Any] = ...): ... def __call__(self, wr: Optional[Any] = ...): ... def cancel(self): ... def still_active(self): ... def is_exiting(): ... class ForkAwareThreadLock: def __init__(self): ... class ForkAwareLocal(threading.local): def __init__(self): ... def __reduce__(self): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/mutex.pyi0000664000175000017500000000055300000000000023003 0ustar00davedave00000000000000from typing import Any, Callable, Deque, TypeVar _ArgType = TypeVar("_ArgType") class mutex: locked: bool queue: Deque[Any] def __init__(self) -> None: ... def test(self) -> bool: ... def testandset(self) -> bool: ... def lock(self, function: Callable[[_ArgType], Any], argument: _ArgType) -> None: ... def unlock(self) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/ntpath.pyi0000664000175000017500000000557100000000000023144 0ustar00davedave00000000000000import os import sys from _typeshed import AnyPath, BytesPath, StrPath from genericpath import exists as exists from typing import Any, AnyStr, Callable, List, Optional, Sequence, Text, Tuple, TypeVar, overload _T = TypeVar("_T") # ----- os.path variables ----- supports_unicode_filenames: bool # aliases (also in os) curdir: str pardir: str sep: str if sys.platform == "win32": altsep: str else: altsep: Optional[str] extsep: str pathsep: str defpath: str devnull: str # ----- os.path function stubs ----- def abspath(path: AnyStr) -> AnyStr: ... def basename(p: AnyStr) -> AnyStr: ... def dirname(p: AnyStr) -> AnyStr: ... def expanduser(path: AnyStr) -> AnyStr: ... def expandvars(path: AnyStr) -> AnyStr: ... def normcase(s: AnyStr) -> AnyStr: ... def normpath(path: AnyStr) -> AnyStr: ... if sys.platform == "win32": def realpath(path: AnyStr) -> AnyStr: ... else: def realpath(filename: AnyStr) -> AnyStr: ... # NOTE: Empty lists results in '' (str) regardless of contained type. # Also, in Python 2 mixed sequences of Text and bytes results in either Text or bytes # So, fall back to Any def commonprefix(m: Sequence[AnyPath]) -> Any: ... def lexists(path: AnyPath) -> bool: ... # These return float if os.stat_float_times() == True, # but int is a subclass of float. def getatime(filename: AnyPath) -> float: ... def getmtime(filename: AnyPath) -> float: ... def getctime(filename: AnyPath) -> float: ... def getsize(filename: AnyPath) -> int: ... def isabs(s: AnyPath) -> bool: ... def isfile(path: AnyPath) -> bool: ... def isdir(s: AnyPath) -> bool: ... def islink(path: AnyPath) -> bool: ... def ismount(path: AnyPath) -> bool: ... # Make sure signatures are disjunct, and allow combinations of bytes and unicode. # (Since Python 2 allows that, too) # Note that e.g. os.path.join("a", "b", "c", "d", u"e") will still result in # a type error. @overload def join(__p1: bytes, *p: bytes) -> bytes: ... @overload def join(__p1: bytes, __p2: bytes, __p3: bytes, __p4: Text, *p: AnyPath) -> Text: ... @overload def join(__p1: bytes, __p2: bytes, __p3: Text, *p: AnyPath) -> Text: ... @overload def join(__p1: bytes, __p2: Text, *p: AnyPath) -> Text: ... @overload def join(__p1: Text, *p: AnyPath) -> Text: ... @overload def relpath(path: BytesPath, start: Optional[BytesPath] = ...) -> bytes: ... @overload def relpath(path: StrPath, start: Optional[StrPath] = ...) -> Text: ... def samefile(f1: AnyPath, f2: AnyPath) -> bool: ... def sameopenfile(fp1: int, fp2: int) -> bool: ... def samestat(s1: os.stat_result, s2: os.stat_result) -> bool: ... def split(p: AnyStr) -> Tuple[AnyStr, AnyStr]: ... def splitdrive(p: AnyStr) -> Tuple[AnyStr, AnyStr]: ... def splitext(p: AnyStr) -> Tuple[AnyStr, AnyStr]: ... if sys.platform == "win32": def splitunc(p: AnyStr) -> Tuple[AnyStr, AnyStr]: ... # deprecated def walk(path: AnyStr, visit: Callable[[_T, AnyStr, List[AnyStr]], Any], arg: _T) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/nturl2path.pyi0000664000175000017500000000016300000000000023741 0ustar00davedave00000000000000from typing import AnyStr def url2pathname(url: AnyStr) -> AnyStr: ... def pathname2url(p: AnyStr) -> AnyStr: ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4183793 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/os/0000775000175000017500000000000000000000000021534 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/os/__init__.pyi0000664000175000017500000003210400000000000024016 0ustar00davedave00000000000000import sys from _typeshed import AnyPath, FileDescriptorLike from builtins import OSError from io import TextIOWrapper as _TextIOWrapper from posix import listdir as listdir, stat_result as stat_result # TODO: use this, see https://github.com/python/mypy/issues/3078 from typing import ( IO, Any, AnyStr, Callable, Dict, Generic, Iterator, List, Mapping, MutableMapping, NamedTuple, NoReturn, Optional, Sequence, Set, Text, Tuple, TypeVar, Union, overload, ) from . import path as path # We need to use something from path, or flake8 and pytype get unhappy _supports_unicode_filenames = path.supports_unicode_filenames _T = TypeVar("_T") # ----- os variables ----- error = OSError if sys.version_info >= (3, 2): supports_bytes_environ: bool if sys.version_info >= (3, 3): supports_dir_fd: Set[Callable[..., Any]] supports_fd: Set[Callable[..., Any]] supports_effective_ids: Set[Callable[..., Any]] supports_follow_symlinks: Set[Callable[..., Any]] SEEK_SET: int SEEK_CUR: int SEEK_END: int O_RDONLY: int O_WRONLY: int O_RDWR: int O_APPEND: int O_CREAT: int O_EXCL: int O_TRUNC: int # We don't use sys.platform for O_* flags to denote platform-dependent APIs because some codes, # including tests for mypy, use a more finer way than sys.platform before using these APIs # See https://github.com/python/typeshed/pull/2286 for discussions O_DSYNC: int # Unix only O_RSYNC: int # Unix only O_SYNC: int # Unix only O_NDELAY: int # Unix only O_NONBLOCK: int # Unix only O_NOCTTY: int # Unix only O_SHLOCK: int # Unix only O_EXLOCK: int # Unix only O_BINARY: int # Windows only O_NOINHERIT: int # Windows only O_SHORT_LIVED: int # Windows only O_TEMPORARY: int # Windows only O_RANDOM: int # Windows only O_SEQUENTIAL: int # Windows only O_TEXT: int # Windows only O_ASYNC: int # Gnu extension if in C library O_DIRECT: int # Gnu extension if in C library O_DIRECTORY: int # Gnu extension if in C library O_NOFOLLOW: int # Gnu extension if in C library O_NOATIME: int # Gnu extension if in C library O_LARGEFILE: int # Gnu extension if in C library curdir: str pardir: str sep: str if sys.platform == "win32": altsep: str else: altsep: Optional[str] extsep: str pathsep: str defpath: str linesep: str devnull: str name: str F_OK: int R_OK: int W_OK: int X_OK: int class _Environ(MutableMapping[AnyStr, AnyStr], Generic[AnyStr]): def copy(self) -> Dict[AnyStr, AnyStr]: ... def __delitem__(self, key: AnyStr) -> None: ... def __getitem__(self, key: AnyStr) -> AnyStr: ... def __setitem__(self, key: AnyStr, value: AnyStr) -> None: ... def __iter__(self) -> Iterator[AnyStr]: ... def __len__(self) -> int: ... environ: _Environ[str] if sys.version_info >= (3, 2): environb: _Environ[bytes] if sys.platform != "win32": # Unix only confstr_names: Dict[str, int] pathconf_names: Dict[str, int] sysconf_names: Dict[str, int] EX_OK: int EX_USAGE: int EX_DATAERR: int EX_NOINPUT: int EX_NOUSER: int EX_NOHOST: int EX_UNAVAILABLE: int EX_SOFTWARE: int EX_OSERR: int EX_OSFILE: int EX_CANTCREAT: int EX_IOERR: int EX_TEMPFAIL: int EX_PROTOCOL: int EX_NOPERM: int EX_CONFIG: int EX_NOTFOUND: int P_NOWAIT: int P_NOWAITO: int P_WAIT: int if sys.platform == "win32": P_DETACH: int P_OVERLAY: int # wait()/waitpid() options if sys.platform != "win32": WNOHANG: int # Unix only WCONTINUED: int # some Unix systems WUNTRACED: int # Unix only TMP_MAX: int # Undocumented, but used by tempfile # ----- os classes (structures) ----- if sys.version_info >= (3, 6): from builtins import _PathLike PathLike = _PathLike # See comment in builtins class _StatVFS(NamedTuple): f_bsize: int f_frsize: int f_blocks: int f_bfree: int f_bavail: int f_files: int f_ffree: int f_favail: int f_flag: int f_namemax: int def getlogin() -> str: ... def getpid() -> int: ... def getppid() -> int: ... def strerror(code: int) -> str: ... def umask(mask: int) -> int: ... if sys.platform != "win32": def ctermid() -> str: ... def getegid() -> int: ... def geteuid() -> int: ... def getgid() -> int: ... def getgroups() -> List[int]: ... # Unix only, behaves differently on Mac def initgroups(username: str, gid: int) -> None: ... def getpgid(pid: int) -> int: ... def getpgrp() -> int: ... def getresuid() -> Tuple[int, int, int]: ... def getresgid() -> Tuple[int, int, int]: ... def getuid() -> int: ... def setegid(egid: int) -> None: ... def seteuid(euid: int) -> None: ... def setgid(gid: int) -> None: ... def setgroups(groups: Sequence[int]) -> None: ... def setpgrp() -> None: ... def setpgid(pid: int, pgrp: int) -> None: ... def setregid(rgid: int, egid: int) -> None: ... def setresgid(rgid: int, egid: int, sgid: int) -> None: ... def setresuid(ruid: int, euid: int, suid: int) -> None: ... def setreuid(ruid: int, euid: int) -> None: ... def getsid(pid: int) -> int: ... def setsid() -> None: ... def setuid(uid: int) -> None: ... def uname() -> Tuple[str, str, str, str, str]: ... @overload def getenv(key: Text) -> Optional[str]: ... @overload def getenv(key: Text, default: _T) -> Union[str, _T]: ... def putenv(key: Union[bytes, Text], value: Union[bytes, Text]) -> None: ... def unsetenv(key: Union[bytes, Text]) -> None: ... def fdopen(fd: int, *args, **kwargs) -> IO[Any]: ... def close(fd: int) -> None: ... def closerange(fd_low: int, fd_high: int) -> None: ... def dup(fd: int) -> int: ... def dup2(fd: int, fd2: int) -> None: ... def fstat(fd: int) -> Any: ... def fsync(fd: FileDescriptorLike) -> None: ... def lseek(fd: int, pos: int, how: int) -> int: ... def open(file: AnyPath, flags: int, mode: int = ...) -> int: ... def pipe() -> Tuple[int, int]: ... def read(fd: int, n: int) -> bytes: ... def write(fd: int, string: Union[bytes, buffer]) -> int: ... def access(path: AnyPath, mode: int) -> bool: ... def chdir(path: AnyPath) -> None: ... def fchdir(fd: FileDescriptorLike) -> None: ... def getcwd() -> str: ... def getcwdu() -> unicode: ... def chmod(path: AnyPath, mode: int) -> None: ... def link(src: AnyPath, link_name: AnyPath) -> None: ... def lstat(path: AnyPath) -> Any: ... def mknod(filename: AnyPath, mode: int = ..., device: int = ...) -> None: ... def major(device: int) -> int: ... def minor(device: int) -> int: ... def makedev(major: int, minor: int) -> int: ... def mkdir(path: AnyPath, mode: int = ...) -> None: ... def makedirs(path: AnyPath, mode: int = ...) -> None: ... def readlink(path: AnyStr) -> AnyStr: ... def remove(path: AnyPath) -> None: ... def removedirs(path: AnyPath) -> None: ... def rename(src: AnyPath, dst: AnyPath) -> None: ... def renames(old: AnyPath, new: AnyPath) -> None: ... def rmdir(path: AnyPath) -> None: ... def stat(path: AnyPath) -> Any: ... @overload def stat_float_times() -> bool: ... @overload def stat_float_times(newvalue: bool) -> None: ... def symlink(source: AnyPath, link_name: AnyPath) -> None: ... def unlink(path: AnyPath) -> None: ... # TODO: add ns, dir_fd, follow_symlinks argument if sys.version_info >= (3, 0): def utime(path: AnyPath, times: Optional[Tuple[float, float]] = ...) -> None: ... else: def utime(path: AnyPath, times: Optional[Tuple[float, float]]) -> None: ... if sys.platform != "win32": # Unix only def fchmod(fd: int, mode: int) -> None: ... def fchown(fd: int, uid: int, gid: int) -> None: ... if sys.platform != "darwin": def fdatasync(fd: FileDescriptorLike) -> None: ... # Unix only, not Mac def fpathconf(fd: int, name: Union[str, int]) -> int: ... def fstatvfs(fd: int) -> _StatVFS: ... def ftruncate(fd: int, length: int) -> None: ... def isatty(fd: int) -> bool: ... def openpty() -> Tuple[int, int]: ... # some flavors of Unix def tcgetpgrp(fd: int) -> int: ... def tcsetpgrp(fd: int, pg: int) -> None: ... def ttyname(fd: int) -> str: ... def chflags(path: AnyPath, flags: int) -> None: ... def chroot(path: AnyPath) -> None: ... def chown(path: AnyPath, uid: int, gid: int) -> None: ... def lchflags(path: AnyPath, flags: int) -> None: ... def lchmod(path: AnyPath, mode: int) -> None: ... def lchown(path: AnyPath, uid: int, gid: int) -> None: ... def mkfifo(path: AnyPath, mode: int = ...) -> None: ... def pathconf(path: AnyPath, name: Union[str, int]) -> int: ... def statvfs(path: AnyPath) -> _StatVFS: ... if sys.version_info >= (3, 6): def walk( top: Union[AnyStr, PathLike[AnyStr]], topdown: bool = ..., onerror: Optional[Callable[[OSError], Any]] = ..., followlinks: bool = ..., ) -> Iterator[Tuple[AnyStr, List[AnyStr], List[AnyStr]]]: ... else: def walk( top: AnyStr, topdown: bool = ..., onerror: Optional[Callable[[OSError], Any]] = ..., followlinks: bool = ... ) -> Iterator[Tuple[AnyStr, List[AnyStr], List[AnyStr]]]: ... def abort() -> NoReturn: ... # These are defined as execl(file, *args) but the first *arg is mandatory. def execl(file: AnyPath, __arg0: Union[bytes, Text], *args: Union[bytes, Text]) -> NoReturn: ... def execlp(file: AnyPath, __arg0: Union[bytes, Text], *args: Union[bytes, Text]) -> NoReturn: ... # These are: execle(file, *args, env) but env is pulled from the last element of the args. def execle(file: AnyPath, __arg0: Union[bytes, Text], *args: Any) -> NoReturn: ... def execlpe(file: AnyPath, __arg0: Union[bytes, Text], *args: Any) -> NoReturn: ... # The docs say `args: tuple or list of strings` # The implementation enforces tuple or list so we can't use Sequence. _ExecVArgs = Union[Tuple[Union[bytes, Text], ...], List[bytes], List[Text], List[Union[bytes, Text]]] def execv(path: AnyPath, args: _ExecVArgs) -> NoReturn: ... def execve(path: AnyPath, args: _ExecVArgs, env: Mapping[str, str]) -> NoReturn: ... def execvp(file: AnyPath, args: _ExecVArgs) -> NoReturn: ... def execvpe(file: AnyPath, args: _ExecVArgs, env: Mapping[str, str]) -> NoReturn: ... def _exit(n: int) -> NoReturn: ... def kill(pid: int, sig: int) -> None: ... if sys.platform != "win32": # Unix only def fork() -> int: ... def forkpty() -> Tuple[int, int]: ... # some flavors of Unix def killpg(__pgid: int, __signal: int) -> None: ... def nice(increment: int) -> int: ... def plock(op: int) -> None: ... # ???op is int? if sys.version_info >= (3, 0): class popen(_TextIOWrapper): # TODO 'b' modes or bytes command not accepted? def __init__(self, command: str, mode: str = ..., bufsize: int = ...) -> None: ... def close(self) -> Any: ... # may return int else: def popen(command: str, *args, **kwargs) -> IO[Any]: ... def popen2(cmd: str, *args, **kwargs) -> Tuple[IO[Any], IO[Any]]: ... def popen3(cmd: str, *args, **kwargs) -> Tuple[IO[Any], IO[Any], IO[Any]]: ... def popen4(cmd: str, *args, **kwargs) -> Tuple[IO[Any], IO[Any]]: ... def spawnl(mode: int, path: AnyPath, arg0: Union[bytes, Text], *args: Union[bytes, Text]) -> int: ... def spawnle(mode: int, path: AnyPath, arg0: Union[bytes, Text], *args: Any) -> int: ... # Imprecise sig def spawnv(mode: int, path: AnyPath, args: List[Union[bytes, Text]]) -> int: ... def spawnve(mode: int, path: AnyPath, args: List[Union[bytes, Text]], env: Mapping[str, str]) -> int: ... def system(command: AnyPath) -> int: ... def times() -> Tuple[float, float, float, float, float]: ... def waitpid(pid: int, options: int) -> Tuple[int, int]: ... def urandom(n: int) -> bytes: ... if sys.platform == "win32": def startfile(path: AnyPath, operation: Optional[str] = ...) -> None: ... else: # Unix only def spawnlp(mode: int, file: AnyPath, arg0: Union[bytes, Text], *args: Union[bytes, Text]) -> int: ... def spawnlpe(mode: int, file: AnyPath, arg0: Union[bytes, Text], *args: Any) -> int: ... # Imprecise signature def spawnvp(mode: int, file: AnyPath, args: List[Union[bytes, Text]]) -> int: ... def spawnvpe(mode: int, file: AnyPath, args: List[Union[bytes, Text]], env: Mapping[str, str]) -> int: ... def wait() -> Tuple[int, int]: ... def wait3(options: int) -> Tuple[int, int, Any]: ... def wait4(pid: int, options: int) -> Tuple[int, int, Any]: ... def WCOREDUMP(status: int) -> bool: ... def WIFCONTINUED(status: int) -> bool: ... def WIFSTOPPED(status: int) -> bool: ... def WIFSIGNALED(status: int) -> bool: ... def WIFEXITED(status: int) -> bool: ... def WEXITSTATUS(status: int) -> int: ... def WSTOPSIG(status: int) -> int: ... def WTERMSIG(status: int) -> int: ... def confstr(name: Union[str, int]) -> Optional[str]: ... def getloadavg() -> Tuple[float, float, float]: ... def sysconf(name: Union[str, int]) -> int: ... if sys.version_info >= (3, 0): def sched_getaffinity(id: int) -> Set[int]: ... if sys.version_info >= (3, 3): class waitresult: si_pid: int def waitid(idtype: int, id: int, options: int) -> waitresult: ... if sys.version_info < (3, 0): def tmpfile() -> IO[Any]: ... def tmpnam() -> str: ... def tempnam(dir: str = ..., prefix: str = ...) -> str: ... P_ALL: int WEXITED: int WNOWAIT: int ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/os/path.pyi0000664000175000017500000000557100000000000023223 0ustar00davedave00000000000000import os import sys from _typeshed import AnyPath, BytesPath, StrPath from genericpath import exists as exists from typing import Any, AnyStr, Callable, List, Optional, Sequence, Text, Tuple, TypeVar, overload _T = TypeVar("_T") # ----- os.path variables ----- supports_unicode_filenames: bool # aliases (also in os) curdir: str pardir: str sep: str if sys.platform == "win32": altsep: str else: altsep: Optional[str] extsep: str pathsep: str defpath: str devnull: str # ----- os.path function stubs ----- def abspath(path: AnyStr) -> AnyStr: ... def basename(p: AnyStr) -> AnyStr: ... def dirname(p: AnyStr) -> AnyStr: ... def expanduser(path: AnyStr) -> AnyStr: ... def expandvars(path: AnyStr) -> AnyStr: ... def normcase(s: AnyStr) -> AnyStr: ... def normpath(path: AnyStr) -> AnyStr: ... if sys.platform == "win32": def realpath(path: AnyStr) -> AnyStr: ... else: def realpath(filename: AnyStr) -> AnyStr: ... # NOTE: Empty lists results in '' (str) regardless of contained type. # Also, in Python 2 mixed sequences of Text and bytes results in either Text or bytes # So, fall back to Any def commonprefix(m: Sequence[AnyPath]) -> Any: ... def lexists(path: AnyPath) -> bool: ... # These return float if os.stat_float_times() == True, # but int is a subclass of float. def getatime(filename: AnyPath) -> float: ... def getmtime(filename: AnyPath) -> float: ... def getctime(filename: AnyPath) -> float: ... def getsize(filename: AnyPath) -> int: ... def isabs(s: AnyPath) -> bool: ... def isfile(path: AnyPath) -> bool: ... def isdir(s: AnyPath) -> bool: ... def islink(path: AnyPath) -> bool: ... def ismount(path: AnyPath) -> bool: ... # Make sure signatures are disjunct, and allow combinations of bytes and unicode. # (Since Python 2 allows that, too) # Note that e.g. os.path.join("a", "b", "c", "d", u"e") will still result in # a type error. @overload def join(__p1: bytes, *p: bytes) -> bytes: ... @overload def join(__p1: bytes, __p2: bytes, __p3: bytes, __p4: Text, *p: AnyPath) -> Text: ... @overload def join(__p1: bytes, __p2: bytes, __p3: Text, *p: AnyPath) -> Text: ... @overload def join(__p1: bytes, __p2: Text, *p: AnyPath) -> Text: ... @overload def join(__p1: Text, *p: AnyPath) -> Text: ... @overload def relpath(path: BytesPath, start: Optional[BytesPath] = ...) -> bytes: ... @overload def relpath(path: StrPath, start: Optional[StrPath] = ...) -> Text: ... def samefile(f1: AnyPath, f2: AnyPath) -> bool: ... def sameopenfile(fp1: int, fp2: int) -> bool: ... def samestat(s1: os.stat_result, s2: os.stat_result) -> bool: ... def split(p: AnyStr) -> Tuple[AnyStr, AnyStr]: ... def splitdrive(p: AnyStr) -> Tuple[AnyStr, AnyStr]: ... def splitext(p: AnyStr) -> Tuple[AnyStr, AnyStr]: ... if sys.platform == "win32": def splitunc(p: AnyStr) -> Tuple[AnyStr, AnyStr]: ... # deprecated def walk(path: AnyStr, visit: Callable[[_T, AnyStr, List[AnyStr]], Any], arg: _T) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/os2emxpath.pyi0000664000175000017500000000557100000000000023740 0ustar00davedave00000000000000import os import sys from _typeshed import AnyPath, BytesPath, StrPath from genericpath import exists as exists from typing import Any, AnyStr, Callable, List, Optional, Sequence, Text, Tuple, TypeVar, overload _T = TypeVar("_T") # ----- os.path variables ----- supports_unicode_filenames: bool # aliases (also in os) curdir: str pardir: str sep: str if sys.platform == "win32": altsep: str else: altsep: Optional[str] extsep: str pathsep: str defpath: str devnull: str # ----- os.path function stubs ----- def abspath(path: AnyStr) -> AnyStr: ... def basename(p: AnyStr) -> AnyStr: ... def dirname(p: AnyStr) -> AnyStr: ... def expanduser(path: AnyStr) -> AnyStr: ... def expandvars(path: AnyStr) -> AnyStr: ... def normcase(s: AnyStr) -> AnyStr: ... def normpath(path: AnyStr) -> AnyStr: ... if sys.platform == "win32": def realpath(path: AnyStr) -> AnyStr: ... else: def realpath(filename: AnyStr) -> AnyStr: ... # NOTE: Empty lists results in '' (str) regardless of contained type. # Also, in Python 2 mixed sequences of Text and bytes results in either Text or bytes # So, fall back to Any def commonprefix(m: Sequence[AnyPath]) -> Any: ... def lexists(path: AnyPath) -> bool: ... # These return float if os.stat_float_times() == True, # but int is a subclass of float. def getatime(filename: AnyPath) -> float: ... def getmtime(filename: AnyPath) -> float: ... def getctime(filename: AnyPath) -> float: ... def getsize(filename: AnyPath) -> int: ... def isabs(s: AnyPath) -> bool: ... def isfile(path: AnyPath) -> bool: ... def isdir(s: AnyPath) -> bool: ... def islink(path: AnyPath) -> bool: ... def ismount(path: AnyPath) -> bool: ... # Make sure signatures are disjunct, and allow combinations of bytes and unicode. # (Since Python 2 allows that, too) # Note that e.g. os.path.join("a", "b", "c", "d", u"e") will still result in # a type error. @overload def join(__p1: bytes, *p: bytes) -> bytes: ... @overload def join(__p1: bytes, __p2: bytes, __p3: bytes, __p4: Text, *p: AnyPath) -> Text: ... @overload def join(__p1: bytes, __p2: bytes, __p3: Text, *p: AnyPath) -> Text: ... @overload def join(__p1: bytes, __p2: Text, *p: AnyPath) -> Text: ... @overload def join(__p1: Text, *p: AnyPath) -> Text: ... @overload def relpath(path: BytesPath, start: Optional[BytesPath] = ...) -> bytes: ... @overload def relpath(path: StrPath, start: Optional[StrPath] = ...) -> Text: ... def samefile(f1: AnyPath, f2: AnyPath) -> bool: ... def sameopenfile(fp1: int, fp2: int) -> bool: ... def samestat(s1: os.stat_result, s2: os.stat_result) -> bool: ... def split(p: AnyStr) -> Tuple[AnyStr, AnyStr]: ... def splitdrive(p: AnyStr) -> Tuple[AnyStr, AnyStr]: ... def splitext(p: AnyStr) -> Tuple[AnyStr, AnyStr]: ... if sys.platform == "win32": def splitunc(p: AnyStr) -> Tuple[AnyStr, AnyStr]: ... # deprecated def walk(path: AnyStr, visit: Callable[[_T, AnyStr, List[AnyStr]], Any], arg: _T) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/pipes.pyi0000664000175000017500000000072300000000000022760 0ustar00davedave00000000000000from typing import IO, Any, AnyStr class Template: def __init__(self) -> None: ... def reset(self) -> None: ... def clone(self) -> Template: ... def debug(self, flag: bool) -> None: ... def append(self, cmd: str, kind: str) -> None: ... def prepend(self, cmd: str, kind: str) -> None: ... def open(self, file: str, mode: str) -> IO[Any]: ... def copy(self, infile: str, outfile: str) -> None: ... def quote(s: AnyStr) -> AnyStr: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/platform.pyi0000664000175000017500000000300000000000000023453 0ustar00davedave00000000000000from typing import Any, Optional, Tuple __copyright__: Any DEV_NULL: Any def libc_ver(executable=..., lib=..., version=..., chunksize: int = ...): ... def linux_distribution(distname=..., version=..., id=..., supported_dists=..., full_distribution_name: int = ...): ... def dist(distname=..., version=..., id=..., supported_dists=...): ... class _popen: tmpfile: Any pipe: Any bufsize: Any mode: Any def __init__(self, cmd, mode=..., bufsize: Optional[Any] = ...): ... def read(self): ... def readlines(self): ... def close(self, remove=..., error=...): ... __del__: Any def popen(cmd, mode=..., bufsize: Optional[Any] = ...): ... def win32_ver(release=..., version=..., csd=..., ptype=...): ... def mac_ver(release=..., versioninfo=..., machine=...): ... def java_ver(release=..., vendor=..., vminfo=..., osinfo=...): ... def system_alias(system, release, version): ... def architecture(executable=..., bits=..., linkage=...) -> Tuple[str, str]: ... def uname() -> Tuple[str, str, str, str, str, str]: ... def system() -> str: ... def node() -> str: ... def release() -> str: ... def version() -> str: ... def machine() -> str: ... def processor() -> str: ... def python_implementation() -> str: ... def python_version() -> str: ... def python_version_tuple() -> Tuple[str, str, str]: ... def python_branch() -> str: ... def python_revision() -> str: ... def python_build() -> Tuple[str, str]: ... def python_compiler() -> str: ... def platform(aliased: int = ..., terse: int = ...) -> str: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/popen2.pyi0000664000175000017500000000174700000000000023052 0ustar00davedave00000000000000from typing import Any, Iterable, List, Optional, TextIO, Tuple, TypeVar, Union _T = TypeVar("_T") class Popen3: sts: int cmd: Iterable[Any] pid: int tochild: TextIO fromchild: TextIO childerr: Optional[TextIO] def __init__(self, cmd: Iterable[Any] = ..., capturestderr: bool = ..., bufsize: int = ...) -> None: ... def __del__(self) -> None: ... def poll(self, _deadstate: _T = ...) -> Union[int, _T]: ... def wait(self) -> int: ... class Popen4(Popen3): childerr: None cmd: Iterable[Any] pid: int tochild: TextIO fromchild: TextIO def __init__(self, cmd: Iterable[Any] = ..., bufsize: int = ...) -> None: ... def popen2(cmd: Iterable[Any] = ..., bufsize: int = ..., mode: str = ...) -> Tuple[TextIO, TextIO]: ... def popen3(cmd: Iterable[Any] = ..., bufsize: int = ..., mode: str = ...) -> Tuple[TextIO, TextIO, TextIO]: ... def popen4(cmd: Iterable[Any] = ..., bufsize: int = ..., mode: str = ...) -> Tuple[TextIO, TextIO]: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/posix.pyi0000664000175000017500000001437400000000000023011 0ustar00davedave00000000000000from _typeshed import FileDescriptorLike from typing import IO, AnyStr, Dict, List, Mapping, NamedTuple, Optional, Sequence, Tuple, TypeVar, Union error = OSError confstr_names: Dict[str, int] environ: Dict[str, str] pathconf_names: Dict[str, int] sysconf_names: Dict[str, int] _T = TypeVar("_T") EX_CANTCREAT: int EX_CONFIG: int EX_DATAERR: int EX_IOERR: int EX_NOHOST: int EX_NOINPUT: int EX_NOPERM: int EX_NOUSER: int EX_OK: int EX_OSERR: int EX_OSFILE: int EX_PROTOCOL: int EX_SOFTWARE: int EX_TEMPFAIL: int EX_UNAVAILABLE: int EX_USAGE: int F_OK: int NGROUPS_MAX: int O_APPEND: int O_ASYNC: int O_CREAT: int O_DIRECT: int O_DIRECTORY: int O_DSYNC: int O_EXCL: int O_LARGEFILE: int O_NDELAY: int O_NOATIME: int O_NOCTTY: int O_NOFOLLOW: int O_NONBLOCK: int O_RDONLY: int O_RDWR: int O_RSYNC: int O_SYNC: int O_TRUNC: int O_WRONLY: int R_OK: int TMP_MAX: int WCONTINUED: int WNOHANG: int WUNTRACED: int W_OK: int X_OK: int def WCOREDUMP(status: int) -> bool: ... def WEXITSTATUS(status: int) -> bool: ... def WIFCONTINUED(status: int) -> bool: ... def WIFEXITED(status: int) -> bool: ... def WIFSIGNALED(status: int) -> bool: ... def WIFSTOPPED(status: int) -> bool: ... def WSTOPSIG(status: int) -> bool: ... def WTERMSIG(status: int) -> bool: ... class stat_result(object): n_fields: int n_sequence_fields: int n_unnamed_fields: int st_mode: int st_ino: int st_dev: int st_nlink: int st_uid: int st_gid: int st_size: int st_atime: int st_mtime: int st_ctime: int class statvfs_result(NamedTuple): f_bsize: int f_frsize: int f_blocks: int f_bfree: int f_bavail: int f_files: int f_ffree: int f_favail: int f_flag: int f_namemax: int def _exit(status: int) -> None: ... def abort() -> None: ... def access(path: unicode, mode: int) -> bool: ... def chdir(path: unicode) -> None: ... def chmod(path: unicode, mode: int) -> None: ... def chown(path: unicode, uid: int, gid: int) -> None: ... def chroot(path: unicode) -> None: ... def close(fd: int) -> None: ... def closerange(fd_low: int, fd_high: int) -> None: ... def confstr(name: Union[str, int]) -> str: ... def ctermid() -> str: ... def dup(fd: int) -> int: ... def dup2(fd: int, fd2: int) -> None: ... def execv(path: str, args: Sequence[str], env: Mapping[str, str]) -> None: ... def execve(path: str, args: Sequence[str], env: Mapping[str, str]) -> None: ... def fchdir(fd: FileDescriptorLike) -> None: ... def fchmod(fd: int, mode: int) -> None: ... def fchown(fd: int, uid: int, gid: int) -> None: ... def fdatasync(fd: FileDescriptorLike) -> None: ... def fdopen(fd: int, mode: str = ..., bufsize: int = ...) -> IO[str]: ... def fork() -> int: ... def forkpty() -> Tuple[int, int]: ... def fpathconf(fd: int, name: str) -> None: ... def fstat(fd: int) -> stat_result: ... def fstatvfs(fd: int) -> statvfs_result: ... def fsync(fd: FileDescriptorLike) -> None: ... def ftruncate(fd: int, length: int) -> None: ... def getcwd() -> str: ... def getcwdu() -> unicode: ... def getegid() -> int: ... def geteuid() -> int: ... def getgid() -> int: ... def getgroups() -> List[int]: ... def getloadavg() -> Tuple[float, float, float]: ... def getlogin() -> str: ... def getpgid(pid: int) -> int: ... def getpgrp() -> int: ... def getpid() -> int: ... def getppid() -> int: ... def getresgid() -> Tuple[int, int, int]: ... def getresuid() -> Tuple[int, int, int]: ... def getsid(pid: int) -> int: ... def getuid() -> int: ... def initgroups(username: str, gid: int) -> None: ... def isatty(fd: int) -> bool: ... def kill(pid: int, sig: int) -> None: ... def killpg(pgid: int, sig: int) -> None: ... def lchown(path: unicode, uid: int, gid: int) -> None: ... def link(source: unicode, link_name: str) -> None: ... def listdir(path: AnyStr) -> List[AnyStr]: ... def lseek(fd: int, pos: int, how: int) -> None: ... def lstat(path: unicode) -> stat_result: ... def major(device: int) -> int: ... def makedev(major: int, minor: int) -> int: ... def minor(device: int) -> int: ... def mkdir(path: unicode, mode: int = ...) -> None: ... def mkfifo(path: unicode, mode: int = ...) -> None: ... def mknod(filename: unicode, mode: int = ..., device: int = ...) -> None: ... def nice(increment: int) -> int: ... def open(file: unicode, flags: int, mode: int = ...) -> int: ... def openpty() -> Tuple[int, int]: ... def pathconf(path: unicode, name: str) -> str: ... def pipe() -> Tuple[int, int]: ... def popen(command: str, mode: str = ..., bufsize: int = ...) -> IO[str]: ... def putenv(varname: str, value: str) -> None: ... def read(fd: int, n: int) -> str: ... def readlink(path: _T) -> _T: ... def remove(path: unicode) -> None: ... def rename(src: unicode, dst: unicode) -> None: ... def rmdir(path: unicode) -> None: ... def setegid(egid: int) -> None: ... def seteuid(euid: int) -> None: ... def setgid(gid: int) -> None: ... def setgroups(groups: Sequence[int]) -> None: ... def setpgid(pid: int, pgrp: int) -> None: ... def setpgrp() -> None: ... def setregid(rgid: int, egid: int) -> None: ... def setresgid(rgid: int, egid: int, sgid: int) -> None: ... def setresuid(ruid: int, euid: int, suid: int) -> None: ... def setreuid(ruid: int, euid: int) -> None: ... def setsid() -> None: ... def setuid(pid: int) -> None: ... def stat(path: unicode) -> stat_result: ... def statvfs(path: unicode) -> statvfs_result: ... def stat_float_times(fd: int) -> None: ... def strerror(code: int) -> str: ... def symlink(source: unicode, link_name: unicode) -> None: ... def sysconf(name: Union[str, int]) -> int: ... def system(command: unicode) -> int: ... def tcgetpgrp(fd: int) -> int: ... def tcsetpgrp(fd: int, pg: int) -> None: ... def times() -> Tuple[float, float, float, float, float]: ... def tmpfile() -> IO[str]: ... def ttyname(fd: int) -> str: ... def umask(mask: int) -> int: ... def uname() -> Tuple[str, str, str, str, str]: ... def unlink(path: unicode) -> None: ... def unsetenv(varname: str) -> None: ... def urandom(n: int) -> str: ... def utime(path: unicode, times: Optional[Tuple[int, int]]) -> None: ... def wait() -> int: ... _r = Tuple[float, float, int, int, int, int, int, int, int, int, int, int, int, int, int, int] def wait3(options: int) -> Tuple[int, int, _r]: ... def wait4(pid: int, options: int) -> Tuple[int, int, _r]: ... def waitpid(pid: int, options: int) -> int: ... def write(fd: int, str: str) -> int: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/posixpath.pyi0000664000175000017500000000557100000000000023665 0ustar00davedave00000000000000import os import sys from _typeshed import AnyPath, BytesPath, StrPath from genericpath import exists as exists from typing import Any, AnyStr, Callable, List, Optional, Sequence, Text, Tuple, TypeVar, overload _T = TypeVar("_T") # ----- os.path variables ----- supports_unicode_filenames: bool # aliases (also in os) curdir: str pardir: str sep: str if sys.platform == "win32": altsep: str else: altsep: Optional[str] extsep: str pathsep: str defpath: str devnull: str # ----- os.path function stubs ----- def abspath(path: AnyStr) -> AnyStr: ... def basename(p: AnyStr) -> AnyStr: ... def dirname(p: AnyStr) -> AnyStr: ... def expanduser(path: AnyStr) -> AnyStr: ... def expandvars(path: AnyStr) -> AnyStr: ... def normcase(s: AnyStr) -> AnyStr: ... def normpath(path: AnyStr) -> AnyStr: ... if sys.platform == "win32": def realpath(path: AnyStr) -> AnyStr: ... else: def realpath(filename: AnyStr) -> AnyStr: ... # NOTE: Empty lists results in '' (str) regardless of contained type. # Also, in Python 2 mixed sequences of Text and bytes results in either Text or bytes # So, fall back to Any def commonprefix(m: Sequence[AnyPath]) -> Any: ... def lexists(path: AnyPath) -> bool: ... # These return float if os.stat_float_times() == True, # but int is a subclass of float. def getatime(filename: AnyPath) -> float: ... def getmtime(filename: AnyPath) -> float: ... def getctime(filename: AnyPath) -> float: ... def getsize(filename: AnyPath) -> int: ... def isabs(s: AnyPath) -> bool: ... def isfile(path: AnyPath) -> bool: ... def isdir(s: AnyPath) -> bool: ... def islink(path: AnyPath) -> bool: ... def ismount(path: AnyPath) -> bool: ... # Make sure signatures are disjunct, and allow combinations of bytes and unicode. # (Since Python 2 allows that, too) # Note that e.g. os.path.join("a", "b", "c", "d", u"e") will still result in # a type error. @overload def join(__p1: bytes, *p: bytes) -> bytes: ... @overload def join(__p1: bytes, __p2: bytes, __p3: bytes, __p4: Text, *p: AnyPath) -> Text: ... @overload def join(__p1: bytes, __p2: bytes, __p3: Text, *p: AnyPath) -> Text: ... @overload def join(__p1: bytes, __p2: Text, *p: AnyPath) -> Text: ... @overload def join(__p1: Text, *p: AnyPath) -> Text: ... @overload def relpath(path: BytesPath, start: Optional[BytesPath] = ...) -> bytes: ... @overload def relpath(path: StrPath, start: Optional[StrPath] = ...) -> Text: ... def samefile(f1: AnyPath, f2: AnyPath) -> bool: ... def sameopenfile(fp1: int, fp2: int) -> bool: ... def samestat(s1: os.stat_result, s2: os.stat_result) -> bool: ... def split(p: AnyStr) -> Tuple[AnyStr, AnyStr]: ... def splitdrive(p: AnyStr) -> Tuple[AnyStr, AnyStr]: ... def splitext(p: AnyStr) -> Tuple[AnyStr, AnyStr]: ... if sys.platform == "win32": def splitunc(p: AnyStr) -> Tuple[AnyStr, AnyStr]: ... # deprecated def walk(path: AnyStr, visit: Callable[[_T, AnyStr, List[AnyStr]], Any], arg: _T) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/random.pyi0000664000175000017500000000612400000000000023121 0ustar00davedave00000000000000import _random from typing import AbstractSet, Any, Callable, Iterator, List, MutableSequence, Protocol, Sequence, TypeVar, Union, overload _T = TypeVar("_T") _T_co = TypeVar("_T_co", covariant=True) class _Sampleable(Protocol[_T_co]): def __iter__(self) -> Iterator[_T_co]: ... def __len__(self) -> int: ... class Random(_random.Random): def __init__(self, x: object = ...) -> None: ... def seed(self, x: object = ...) -> None: ... def getstate(self) -> _random._State: ... def setstate(self, state: _random._State) -> None: ... def jumpahead(self, n: int) -> None: ... def getrandbits(self, k: int) -> int: ... @overload def randrange(self, stop: int) -> int: ... @overload def randrange(self, start: int, stop: int, step: int = ...) -> int: ... def randint(self, a: int, b: int) -> int: ... def choice(self, seq: Sequence[_T]) -> _T: ... def shuffle(self, x: MutableSequence[Any], random: Callable[[], None] = ...) -> None: ... def sample(self, population: _Sampleable[_T], k: int) -> List[_T]: ... def random(self) -> float: ... def uniform(self, a: float, b: float) -> float: ... def triangular(self, low: float = ..., high: float = ..., mode: float = ...) -> float: ... def betavariate(self, alpha: float, beta: float) -> float: ... def expovariate(self, lambd: float) -> float: ... def gammavariate(self, alpha: float, beta: float) -> float: ... def gauss(self, mu: float, sigma: float) -> float: ... def lognormvariate(self, mu: float, sigma: float) -> float: ... def normalvariate(self, mu: float, sigma: float) -> float: ... def vonmisesvariate(self, mu: float, kappa: float) -> float: ... def paretovariate(self, alpha: float) -> float: ... def weibullvariate(self, alpha: float, beta: float) -> float: ... # SystemRandom is not implemented for all OS's; good on Windows & Linux class SystemRandom(Random): ... # ----- random function stubs ----- def seed(x: object = ...) -> None: ... def getstate() -> object: ... def setstate(state: object) -> None: ... def jumpahead(n: int) -> None: ... def getrandbits(k: int) -> int: ... @overload def randrange(stop: int) -> int: ... @overload def randrange(start: int, stop: int, step: int = ...) -> int: ... def randint(a: int, b: int) -> int: ... def choice(seq: Sequence[_T]) -> _T: ... def shuffle(x: MutableSequence[Any], random: Callable[[], float] = ...) -> None: ... def sample(population: _Sampleable[_T], k: int) -> List[_T]: ... def random() -> float: ... def uniform(a: float, b: float) -> float: ... def triangular(low: float = ..., high: float = ..., mode: float = ...) -> float: ... def betavariate(alpha: float, beta: float) -> float: ... def expovariate(lambd: float) -> float: ... def gammavariate(alpha: float, beta: float) -> float: ... def gauss(mu: float, sigma: float) -> float: ... def lognormvariate(mu: float, sigma: float) -> float: ... def normalvariate(mu: float, sigma: float) -> float: ... def vonmisesvariate(mu: float, kappa: float) -> float: ... def paretovariate(alpha: float) -> float: ... def weibullvariate(alpha: float, beta: float) -> float: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/re.pyi0000664000175000017500000000707100000000000022251 0ustar00davedave00000000000000from typing import ( Any, AnyStr, Callable, Dict, Generic, Iterator, List, Match, Optional, Pattern, Sequence, Tuple, Union, overload, ) # ----- re variables and constants ----- DEBUG: int I: int IGNORECASE: int L: int LOCALE: int M: int MULTILINE: int S: int DOTALL: int X: int VERBOSE: int U: int UNICODE: int T: int TEMPLATE: int class error(Exception): ... @overload def compile(pattern: AnyStr, flags: int = ...) -> Pattern[AnyStr]: ... @overload def compile(pattern: Pattern[AnyStr], flags: int = ...) -> Pattern[AnyStr]: ... @overload def search(pattern: Union[str, unicode], string: AnyStr, flags: int = ...) -> Optional[Match[AnyStr]]: ... @overload def search(pattern: Union[Pattern[str], Pattern[unicode]], string: AnyStr, flags: int = ...) -> Optional[Match[AnyStr]]: ... @overload def match(pattern: Union[str, unicode], string: AnyStr, flags: int = ...) -> Optional[Match[AnyStr]]: ... @overload def match(pattern: Union[Pattern[str], Pattern[unicode]], string: AnyStr, flags: int = ...) -> Optional[Match[AnyStr]]: ... @overload def split(pattern: Union[str, unicode], string: AnyStr, maxsplit: int = ..., flags: int = ...) -> List[AnyStr]: ... @overload def split( pattern: Union[Pattern[str], Pattern[unicode]], string: AnyStr, maxsplit: int = ..., flags: int = ... ) -> List[AnyStr]: ... @overload def findall(pattern: Union[str, unicode], string: AnyStr, flags: int = ...) -> List[Any]: ... @overload def findall(pattern: Union[Pattern[str], Pattern[unicode]], string: AnyStr, flags: int = ...) -> List[Any]: ... # Return an iterator yielding match objects over all non-overlapping matches # for the RE pattern in string. The string is scanned left-to-right, and # matches are returned in the order found. Empty matches are included in the # result unless they touch the beginning of another match. @overload def finditer(pattern: Union[str, unicode], string: AnyStr, flags: int = ...) -> Iterator[Match[AnyStr]]: ... @overload def finditer(pattern: Union[Pattern[str], Pattern[unicode]], string: AnyStr, flags: int = ...) -> Iterator[Match[AnyStr]]: ... @overload def sub(pattern: Union[str, unicode], repl: AnyStr, string: AnyStr, count: int = ..., flags: int = ...) -> AnyStr: ... @overload def sub( pattern: Union[str, unicode], repl: Callable[[Match[AnyStr]], AnyStr], string: AnyStr, count: int = ..., flags: int = ... ) -> AnyStr: ... @overload def sub( pattern: Union[Pattern[str], Pattern[unicode]], repl: AnyStr, string: AnyStr, count: int = ..., flags: int = ... ) -> AnyStr: ... @overload def sub( pattern: Union[Pattern[str], Pattern[unicode]], repl: Callable[[Match[AnyStr]], AnyStr], string: AnyStr, count: int = ..., flags: int = ..., ) -> AnyStr: ... @overload def subn( pattern: Union[str, unicode], repl: AnyStr, string: AnyStr, count: int = ..., flags: int = ... ) -> Tuple[AnyStr, int]: ... @overload def subn( pattern: Union[str, unicode], repl: Callable[[Match[AnyStr]], AnyStr], string: AnyStr, count: int = ..., flags: int = ... ) -> Tuple[AnyStr, int]: ... @overload def subn( pattern: Union[Pattern[str], Pattern[unicode]], repl: AnyStr, string: AnyStr, count: int = ..., flags: int = ... ) -> Tuple[AnyStr, int]: ... @overload def subn( pattern: Union[Pattern[str], Pattern[unicode]], repl: Callable[[Match[AnyStr]], AnyStr], string: AnyStr, count: int = ..., flags: int = ..., ) -> Tuple[AnyStr, int]: ... def escape(string: AnyStr) -> AnyStr: ... def purge() -> None: ... def template(pattern: Union[AnyStr, Pattern[AnyStr]], flags: int = ...) -> Pattern[AnyStr]: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/repr.pyi0000664000175000017500000000210700000000000022606 0ustar00davedave00000000000000from typing import Any, List class Repr: maxarray: int maxdeque: int maxdict: int maxfrozenset: int maxlevel: int maxlist: int maxlong: int maxother: int maxset: int maxstring: int maxtuple: int def __init__(self) -> None: ... def _repr_iterable(self, x, level: complex, left, right, maxiter, trail=...) -> str: ... def repr(self, x) -> str: ... def repr1(self, x, level: complex) -> str: ... def repr_array(self, x, level: complex) -> str: ... def repr_deque(self, x, level: complex) -> str: ... def repr_dict(self, x, level: complex) -> str: ... def repr_frozenset(self, x, level: complex) -> str: ... def repr_instance(self, x, level: complex) -> str: ... def repr_list(self, x, level: complex) -> str: ... def repr_long(self, x, level: complex) -> str: ... def repr_set(self, x, level: complex) -> str: ... def repr_str(self, x, level: complex) -> str: ... def repr_tuple(self, x, level: complex) -> str: ... def _possibly_sorted(x) -> List[Any]: ... aRepr: Repr def repr(x) -> str: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/resource.pyi0000664000175000017500000000155500000000000023473 0ustar00davedave00000000000000from typing import NamedTuple, Tuple class error(Exception): ... RLIM_INFINITY: int def getrlimit(resource: int) -> Tuple[int, int]: ... def setrlimit(resource: int, limits: Tuple[int, int]) -> None: ... RLIMIT_CORE: int RLIMIT_CPU: int RLIMIT_FSIZE: int RLIMIT_DATA: int RLIMIT_STACK: int RLIMIT_RSS: int RLIMIT_NPROC: int RLIMIT_NOFILE: int RLIMIT_OFILE: int RLIMIT_MEMLOCK: int RLIMIT_VMEM: int RLIMIT_AS: int class _RUsage(NamedTuple): ru_utime: float ru_stime: float ru_maxrss: int ru_ixrss: int ru_idrss: int ru_isrss: int ru_minflt: int ru_majflt: int ru_nswap: int ru_inblock: int ru_oublock: int ru_msgsnd: int ru_msgrcv: int ru_nsignals: int ru_nvcsw: int ru_nivcsw: int def getrusage(who: int) -> _RUsage: ... def getpagesize() -> int: ... RUSAGE_SELF: int RUSAGE_CHILDREN: int RUSAGE_BOTH: int ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/rfc822.pyi0000664000175000017500000000416300000000000022650 0ustar00davedave00000000000000from typing import Any, Optional class Message: fp: Any seekable: Any startofheaders: Any startofbody: Any def __init__(self, fp, seekable: int = ...): ... def rewindbody(self): ... dict: Any unixfrom: Any headers: Any status: Any def readheaders(self): ... def isheader(self, line): ... def islast(self, line): ... def iscomment(self, line): ... def getallmatchingheaders(self, name): ... def getfirstmatchingheader(self, name): ... def getrawheader(self, name): ... def getheader(self, name, default: Optional[Any] = ...): ... get: Any def getheaders(self, name): ... def getaddr(self, name): ... def getaddrlist(self, name): ... def getdate(self, name): ... def getdate_tz(self, name): ... def __len__(self): ... def __getitem__(self, name): ... def __setitem__(self, name, value): ... def __delitem__(self, name): ... def setdefault(self, name, default=...): ... def has_key(self, name): ... def __contains__(self, name): ... def __iter__(self): ... def keys(self): ... def values(self): ... def items(self): ... class AddrlistClass: specials: Any pos: Any LWS: Any CR: Any atomends: Any phraseends: Any field: Any commentlist: Any def __init__(self, field): ... def gotonext(self): ... def getaddrlist(self): ... def getaddress(self): ... def getrouteaddr(self): ... def getaddrspec(self): ... def getdomain(self): ... def getdelimited(self, beginchar, endchars, allowcomments: int = ...): ... def getquote(self): ... def getcomment(self): ... def getdomainliteral(self): ... def getatom(self, atomends: Optional[Any] = ...): ... def getphraselist(self): ... class AddressList(AddrlistClass): addresslist: Any def __init__(self, field): ... def __len__(self): ... def __add__(self, other): ... def __iadd__(self, other): ... def __sub__(self, other): ... def __isub__(self, other): ... def __getitem__(self, index): ... def parsedate_tz(data): ... def parsedate(data): ... def mktime_tz(data): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/robotparser.pyi0000664000175000017500000000034600000000000024203 0ustar00davedave00000000000000class RobotFileParser: def set_url(self, url: str): ... def read(self): ... def parse(self, lines: str): ... def can_fetch(self, user_agent: str, url: str): ... def mtime(self): ... def modified(self): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/runpy.pyi0000664000175000017500000000103500000000000023012 0ustar00davedave00000000000000from typing import Any, Optional class _TempModule: mod_name: Any module: Any def __init__(self, mod_name): ... def __enter__(self): ... def __exit__(self, *args): ... class _ModifiedArgv0: value: Any def __init__(self, value): ... def __enter__(self): ... def __exit__(self, *args): ... def run_module(mod_name, init_globals: Optional[Any] = ..., run_name: Optional[Any] = ..., alter_sys: bool = ...): ... def run_path(path_name, init_globals: Optional[Any] = ..., run_name: Optional[Any] = ...): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/sets.pyi0000664000175000017500000000563700000000000022627 0ustar00davedave00000000000000from typing import Any, Callable, Hashable, Iterable, Iterator, MutableMapping, Optional, TypeVar, Union _T = TypeVar("_T") _Setlike = Union[BaseSet[_T], Iterable[_T]] _SelfT = TypeVar("_SelfT") class BaseSet(Iterable[_T]): def __init__(self) -> None: ... def __len__(self) -> int: ... def __repr__(self) -> str: ... def __str__(self) -> str: ... def __iter__(self) -> Iterator[_T]: ... def __cmp__(self, other: Any) -> int: ... def __eq__(self, other: Any) -> bool: ... def __ne__(self, other: Any) -> bool: ... def copy(self: _SelfT) -> _SelfT: ... def __copy__(self: _SelfT) -> _SelfT: ... def __deepcopy__(self: _SelfT, memo: MutableMapping[int, BaseSet[_T]]) -> _SelfT: ... def __or__(self: _SelfT, other: BaseSet[_T]) -> _SelfT: ... def union(self: _SelfT, other: _Setlike[_T]) -> _SelfT: ... def __and__(self: _SelfT, other: BaseSet[_T]) -> _SelfT: ... def intersection(self: _SelfT, other: _Setlike[Any]) -> _SelfT: ... def __xor__(self: _SelfT, other: BaseSet[_T]) -> _SelfT: ... def symmetric_difference(self: _SelfT, other: _Setlike[_T]) -> _SelfT: ... def __sub__(self: _SelfT, other: BaseSet[_T]) -> _SelfT: ... def difference(self: _SelfT, other: _Setlike[Any]) -> _SelfT: ... def __contains__(self, element: Any) -> bool: ... def issubset(self, other: BaseSet[_T]) -> bool: ... def issuperset(self, other: BaseSet[_T]) -> bool: ... def __le__(self, other: BaseSet[_T]) -> bool: ... def __ge__(self, other: BaseSet[_T]) -> bool: ... def __lt__(self, other: BaseSet[_T]) -> bool: ... def __gt__(self, other: BaseSet[_T]) -> bool: ... class ImmutableSet(BaseSet[_T], Hashable): def __init__(self, iterable: Optional[_Setlike[_T]] = ...) -> None: ... def __hash__(self) -> int: ... class Set(BaseSet[_T]): def __init__(self, iterable: Optional[_Setlike[_T]] = ...) -> None: ... def __ior__(self: _SelfT, other: BaseSet[_T]) -> _SelfT: ... def union_update(self, other: _Setlike[_T]) -> None: ... def __iand__(self: _SelfT, other: BaseSet[_T]) -> _SelfT: ... def intersection_update(self, other: _Setlike[Any]) -> None: ... def __ixor__(self: _SelfT, other: BaseSet[_T]) -> _SelfT: ... def symmetric_difference_update(self, other: _Setlike[_T]) -> None: ... def __isub__(self: _SelfT, other: BaseSet[_T]) -> _SelfT: ... def difference_update(self, other: _Setlike[Any]) -> None: ... def update(self, iterable: _Setlike[_T]) -> None: ... def clear(self) -> None: ... def add(self, element: _T) -> None: ... def remove(self, element: _T) -> None: ... def discard(self, element: _T) -> None: ... def pop(self) -> _T: ... def __as_immutable__(self) -> ImmutableSet[_T]: ... def __as_temporarily_immutable__(self) -> _TemporarilyImmutableSet[_T]: ... class _TemporarilyImmutableSet(BaseSet[_T]): def __init__(self, set: BaseSet[_T]) -> None: ... def __hash__(self) -> int: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/sha.pyi0000664000175000017500000000035400000000000022413 0ustar00davedave00000000000000class sha(object): def update(self, arg: str) -> None: ... def digest(self) -> str: ... def hexdigest(self) -> str: ... def copy(self) -> sha: ... def new(string: str = ...) -> sha: ... blocksize: int digest_size: int ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/shelve.pyi0000664000175000017500000000311400000000000023123 0ustar00davedave00000000000000import collections from typing import Any, Dict, Iterator, List, Optional, Tuple class Shelf(collections.MutableMapping[Any, Any]): def __init__( self, dict: Dict[Any, Any], protocol: Optional[int] = ..., writeback: bool = ..., keyencoding: str = ... ) -> None: ... def __iter__(self) -> Iterator[str]: ... def keys(self) -> List[Any]: ... def __len__(self) -> int: ... def has_key(self, key: Any) -> bool: ... def __contains__(self, key: Any) -> bool: ... def get(self, key: Any, default: Any = ...) -> Any: ... def __getitem__(self, key: Any) -> Any: ... def __setitem__(self, key: Any, value: Any) -> None: ... def __delitem__(self, key: Any) -> None: ... def __enter__(self) -> Shelf: ... def __exit__(self, type: Any, value: Any, traceback: Any) -> None: ... def close(self) -> None: ... def __del__(self) -> None: ... def sync(self) -> None: ... class BsdDbShelf(Shelf): def __init__( self, dict: Dict[Any, Any], protocol: Optional[int] = ..., writeback: bool = ..., keyencoding: str = ... ) -> None: ... def set_location(self, key: Any) -> Tuple[str, Any]: ... def next(self) -> Tuple[str, Any]: ... def previous(self) -> Tuple[str, Any]: ... def first(self) -> Tuple[str, Any]: ... def last(self) -> Tuple[str, Any]: ... class DbfilenameShelf(Shelf): def __init__(self, filename: str, flag: str = ..., protocol: Optional[int] = ..., writeback: bool = ...) -> None: ... def open(filename: str, flag: str = ..., protocol: Optional[int] = ..., writeback: bool = ...) -> DbfilenameShelf: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/shlex.pyi0000664000175000017500000000200100000000000022752 0ustar00davedave00000000000000from typing import IO, Any, List, Optional, Text, TypeVar, Union def split(s: Optional[str], comments: bool = ..., posix: bool = ...) -> List[str]: ... _SLT = TypeVar("_SLT", bound=shlex) class shlex: def __init__(self, instream: Union[IO[Any], Text] = ..., infile: IO[Any] = ..., posix: bool = ...) -> None: ... def __iter__(self: _SLT) -> _SLT: ... def next(self) -> str: ... def get_token(self) -> Optional[str]: ... def push_token(self, _str: str) -> None: ... def read_token(self) -> str: ... def sourcehook(self, filename: str) -> None: ... def push_source(self, stream: IO[Any], filename: str = ...) -> None: ... def pop_source(self) -> IO[Any]: ... def error_leader(self, file: str = ..., line: int = ...) -> str: ... commenters: str wordchars: str whitespace: str escape: str quotes: str escapedquotes: str whitespace_split: bool infile: IO[Any] source: Optional[str] debug: int lineno: int token: Any eof: Optional[str] ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/signal.pyi0000664000175000017500000000304300000000000023113 0ustar00davedave00000000000000from types import FrameType from typing import Any, Callable, Tuple, Union SIG_DFL: int = ... SIG_IGN: int = ... ITIMER_REAL: int = ... ITIMER_VIRTUAL: int = ... ITIMER_PROF: int = ... NSIG: int = ... SIGABRT: int = ... SIGALRM: int = ... SIGBREAK: int = ... # Windows SIGBUS: int = ... SIGCHLD: int = ... SIGCLD: int = ... SIGCONT: int = ... SIGEMT: int = ... SIGFPE: int = ... SIGHUP: int = ... SIGILL: int = ... SIGINFO: int = ... SIGINT: int = ... SIGIO: int = ... SIGIOT: int = ... SIGKILL: int = ... SIGPIPE: int = ... SIGPOLL: int = ... SIGPROF: int = ... SIGPWR: int = ... SIGQUIT: int = ... SIGRTMAX: int = ... SIGRTMIN: int = ... SIGSEGV: int = ... SIGSTOP: int = ... SIGSYS: int = ... SIGTERM: int = ... SIGTRAP: int = ... SIGTSTP: int = ... SIGTTIN: int = ... SIGTTOU: int = ... SIGURG: int = ... SIGUSR1: int = ... SIGUSR2: int = ... SIGVTALRM: int = ... SIGWINCH: int = ... SIGXCPU: int = ... SIGXFSZ: int = ... # Windows CTRL_C_EVENT: int = ... CTRL_BREAK_EVENT: int = ... class ItimerError(IOError): ... _HANDLER = Union[Callable[[int, FrameType], None], int, None] def alarm(time: int) -> int: ... def getsignal(signalnum: int) -> _HANDLER: ... def pause() -> None: ... def setitimer(which: int, seconds: float, interval: float = ...) -> Tuple[float, float]: ... def getitimer(which: int) -> Tuple[float, float]: ... def set_wakeup_fd(fd: int) -> int: ... def siginterrupt(signalnum: int, flag: bool) -> None: ... def signal(signalnum: int, handler: _HANDLER) -> _HANDLER: ... def default_int_handler(signum: int, frame: FrameType) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/smtplib.pyi0000664000175000017500000000475600000000000023324 0ustar00davedave00000000000000from typing import Any class SMTPException(Exception): ... class SMTPServerDisconnected(SMTPException): ... class SMTPResponseException(SMTPException): smtp_code: Any smtp_error: Any args: Any def __init__(self, code, msg) -> None: ... class SMTPSenderRefused(SMTPResponseException): smtp_code: Any smtp_error: Any sender: Any args: Any def __init__(self, code, msg, sender) -> None: ... class SMTPRecipientsRefused(SMTPException): recipients: Any args: Any def __init__(self, recipients) -> None: ... class SMTPDataError(SMTPResponseException): ... class SMTPConnectError(SMTPResponseException): ... class SMTPHeloError(SMTPResponseException): ... class SMTPAuthenticationError(SMTPResponseException): ... def quoteaddr(addr): ... def quotedata(data): ... class SSLFakeFile: sslobj: Any def __init__(self, sslobj) -> None: ... def readline(self, size=...): ... def close(self): ... class SMTP: debuglevel: Any file: Any helo_resp: Any ehlo_msg: Any ehlo_resp: Any does_esmtp: Any default_port: Any timeout: Any esmtp_features: Any local_hostname: Any def __init__(self, host: str = ..., port: int = ..., local_hostname=..., timeout=...) -> None: ... def set_debuglevel(self, debuglevel): ... sock: Any def connect(self, host=..., port=...): ... def send(self, str): ... def putcmd(self, cmd, args=...): ... def getreply(self): ... def docmd(self, cmd, args=...): ... def helo(self, name=...): ... def ehlo(self, name=...): ... def has_extn(self, opt): ... def help(self, args=...): ... def rset(self): ... def noop(self): ... def mail(self, sender, options=...): ... def rcpt(self, recip, options=...): ... def data(self, msg): ... def verify(self, address): ... vrfy: Any def expn(self, address): ... def ehlo_or_helo_if_needed(self): ... def login(self, user, password): ... def starttls(self, keyfile=..., certfile=...): ... def sendmail(self, from_addr, to_addrs, msg, mail_options=..., rcpt_options=...): ... def close(self): ... def quit(self): ... class SMTP_SSL(SMTP): default_port: Any keyfile: Any certfile: Any def __init__(self, host=..., port=..., local_hostname=..., keyfile=..., certfile=..., timeout=...) -> None: ... class LMTP(SMTP): ehlo_msg: Any def __init__(self, host=..., port=..., local_hostname=...) -> None: ... sock: Any def connect(self, host=..., port=...): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/spwd.pyi0000664000175000017500000000046400000000000022617 0ustar00davedave00000000000000from typing import List, NamedTuple class struct_spwd(NamedTuple): sp_nam: str sp_pwd: str sp_lstchg: int sp_min: int sp_max: int sp_warn: int sp_inact: int sp_expire: int sp_flag: int def getspall() -> List[struct_spwd]: ... def getspnam(name: str) -> struct_spwd: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/sre_constants.pyi0000664000175000017500000000332000000000000024521 0ustar00davedave00000000000000from typing import Dict, List, TypeVar MAGIC: int MAXREPEAT: int class error(Exception): ... FAILURE: str SUCCESS: str ANY: str ANY_ALL: str ASSERT: str ASSERT_NOT: str AT: str BIGCHARSET: str BRANCH: str CALL: str CATEGORY: str CHARSET: str GROUPREF: str GROUPREF_IGNORE: str GROUPREF_EXISTS: str IN: str IN_IGNORE: str INFO: str JUMP: str LITERAL: str LITERAL_IGNORE: str MARK: str MAX_REPEAT: str MAX_UNTIL: str MIN_REPEAT: str MIN_UNTIL: str NEGATE: str NOT_LITERAL: str NOT_LITERAL_IGNORE: str RANGE: str REPEAT: str REPEAT_ONE: str SUBPATTERN: str MIN_REPEAT_ONE: str AT_BEGINNING: str AT_BEGINNING_LINE: str AT_BEGINNING_STRING: str AT_BOUNDARY: str AT_NON_BOUNDARY: str AT_END: str AT_END_LINE: str AT_END_STRING: str AT_LOC_BOUNDARY: str AT_LOC_NON_BOUNDARY: str AT_UNI_BOUNDARY: str AT_UNI_NON_BOUNDARY: str CATEGORY_DIGIT: str CATEGORY_NOT_DIGIT: str CATEGORY_SPACE: str CATEGORY_NOT_SPACE: str CATEGORY_WORD: str CATEGORY_NOT_WORD: str CATEGORY_LINEBREAK: str CATEGORY_NOT_LINEBREAK: str CATEGORY_LOC_WORD: str CATEGORY_LOC_NOT_WORD: str CATEGORY_UNI_DIGIT: str CATEGORY_UNI_NOT_DIGIT: str CATEGORY_UNI_SPACE: str CATEGORY_UNI_NOT_SPACE: str CATEGORY_UNI_WORD: str CATEGORY_UNI_NOT_WORD: str CATEGORY_UNI_LINEBREAK: str CATEGORY_UNI_NOT_LINEBREAK: str _T = TypeVar("_T") def makedict(list: List[_T]) -> Dict[_T, int]: ... OP_IGNORE: Dict[str, str] AT_MULTILINE: Dict[str, str] AT_LOCALE: Dict[str, str] AT_UNICODE: Dict[str, str] CH_LOCALE: Dict[str, str] CH_UNICODE: Dict[str, str] SRE_FLAG_TEMPLATE: int SRE_FLAG_IGNORECASE: int SRE_FLAG_LOCALE: int SRE_FLAG_MULTILINE: int SRE_FLAG_DOTALL: int SRE_FLAG_UNICODE: int SRE_FLAG_VERBOSE: int SRE_FLAG_DEBUG: int SRE_INFO_PREFIX: int SRE_INFO_LITERAL: int SRE_INFO_CHARSET: int ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/sre_parse.pyi0000664000175000017500000000440700000000000023626 0ustar00davedave00000000000000from typing import Any, Dict, Iterable, List, Match, Optional, Pattern as _Pattern, Set, Tuple, Union SPECIAL_CHARS: str REPEAT_CHARS: str DIGITS: Set[Any] OCTDIGITS: Set[Any] HEXDIGITS: Set[Any] WHITESPACE: Set[Any] ESCAPES: Dict[str, Tuple[str, int]] CATEGORIES: Dict[str, Union[Tuple[str, str], Tuple[str, List[Tuple[str, str]]]]] FLAGS: Dict[str, int] class Pattern: flags: int open: List[int] groups: int groupdict: Dict[str, int] lookbehind: int def __init__(self) -> None: ... def opengroup(self, name: str = ...) -> int: ... def closegroup(self, gid: int) -> None: ... def checkgroup(self, gid: int) -> bool: ... _OpSubpatternType = Tuple[Optional[int], int, int, SubPattern] _OpGroupRefExistsType = Tuple[int, SubPattern, SubPattern] _OpInType = List[Tuple[str, int]] _OpBranchType = Tuple[None, List[SubPattern]] _AvType = Union[_OpInType, _OpBranchType, Iterable[SubPattern], _OpGroupRefExistsType, _OpSubpatternType] _CodeType = Union[str, _AvType] class SubPattern: pattern: str data: List[_CodeType] width: Optional[int] def __init__(self, pattern, data: List[_CodeType] = ...) -> None: ... def dump(self, level: int = ...) -> None: ... def __len__(self) -> int: ... def __delitem__(self, index: Union[int, slice]) -> None: ... def __getitem__(self, index: Union[int, slice]) -> Union[SubPattern, _CodeType]: ... def __setitem__(self, index: Union[int, slice], code: _CodeType): ... def insert(self, index, code: _CodeType) -> None: ... def append(self, code: _CodeType) -> None: ... def getwidth(self) -> int: ... class Tokenizer: string: str index: int def __init__(self, string: str) -> None: ... def match(self, char: str, skip: int = ...) -> int: ... def get(self) -> Optional[str]: ... def tell(self) -> Tuple[int, Optional[str]]: ... def seek(self, index: int) -> None: ... def isident(char: str) -> bool: ... def isdigit(char: str) -> bool: ... def isname(name: str) -> bool: ... def parse(str: str, flags: int = ..., pattern: Pattern = ...) -> SubPattern: ... _Template = Tuple[List[Tuple[int, int]], List[Optional[int]]] def parse_template(source: str, pattern: _Pattern[Any]) -> _Template: ... def expand_template(template: _Template, match: Match[Any]) -> str: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/stat.pyi0000664000175000017500000000174000000000000022613 0ustar00davedave00000000000000def S_ISDIR(mode: int) -> bool: ... def S_ISCHR(mode: int) -> bool: ... def S_ISBLK(mode: int) -> bool: ... def S_ISREG(mode: int) -> bool: ... def S_ISFIFO(mode: int) -> bool: ... def S_ISLNK(mode: int) -> bool: ... def S_ISSOCK(mode: int) -> bool: ... def S_IMODE(mode: int) -> int: ... def S_IFMT(mode: int) -> int: ... ST_MODE: int ST_INO: int ST_DEV: int ST_NLINK: int ST_UID: int ST_GID: int ST_SIZE: int ST_ATIME: int ST_MTIME: int ST_CTIME: int S_IFSOCK: int S_IFLNK: int S_IFREG: int S_IFBLK: int S_IFDIR: int S_IFCHR: int S_IFIFO: int S_ISUID: int S_ISGID: int S_ISVTX: int S_IRWXU: int S_IRUSR: int S_IWUSR: int S_IXUSR: int S_IRWXG: int S_IRGRP: int S_IWGRP: int S_IXGRP: int S_IRWXO: int S_IROTH: int S_IWOTH: int S_IXOTH: int S_ENFMT: int S_IREAD: int S_IWRITE: int S_IEXEC: int UF_NODUMP: int UF_IMMUTABLE: int UF_APPEND: int UF_OPAQUE: int UF_NOUNLINK: int UF_COMPRESSED: int UF_HIDDEN: int SF_ARCHIVED: int SF_IMMUTABLE: int SF_APPEND: int SF_NOUNLINK: int SF_SNAPSHOT: int ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/string.pyi0000664000175000017500000000675700000000000023163 0ustar00davedave00000000000000from typing import Any, AnyStr, Iterable, List, Mapping, Optional, Sequence, Text, Tuple, Union, overload ascii_letters: str ascii_lowercase: str ascii_uppercase: str digits: str hexdigits: str letters: str lowercase: str octdigits: str punctuation: str printable: str uppercase: str whitespace: str def capwords(s: AnyStr, sep: AnyStr = ...) -> AnyStr: ... # TODO: originally named 'from' def maketrans(_from: str, to: str) -> str: ... def atof(s: unicode) -> float: ... def atoi(s: unicode, base: int = ...) -> int: ... def atol(s: unicode, base: int = ...) -> int: ... def capitalize(word: AnyStr) -> AnyStr: ... def find(s: unicode, sub: unicode, start: int = ..., end: int = ...) -> int: ... def rfind(s: unicode, sub: unicode, start: int = ..., end: int = ...) -> int: ... def index(s: unicode, sub: unicode, start: int = ..., end: int = ...) -> int: ... def rindex(s: unicode, sub: unicode, start: int = ..., end: int = ...) -> int: ... def count(s: unicode, sub: unicode, start: int = ..., end: int = ...) -> int: ... def lower(s: AnyStr) -> AnyStr: ... def split(s: AnyStr, sep: AnyStr = ..., maxsplit: int = ...) -> List[AnyStr]: ... def rsplit(s: AnyStr, sep: AnyStr = ..., maxsplit: int = ...) -> List[AnyStr]: ... def splitfields(s: AnyStr, sep: AnyStr = ..., maxsplit: int = ...) -> List[AnyStr]: ... def join(words: Iterable[AnyStr], sep: AnyStr = ...) -> AnyStr: ... def joinfields(word: Iterable[AnyStr], sep: AnyStr = ...) -> AnyStr: ... def lstrip(s: AnyStr, chars: AnyStr = ...) -> AnyStr: ... def rstrip(s: AnyStr, chars: AnyStr = ...) -> AnyStr: ... def strip(s: AnyStr, chars: AnyStr = ...) -> AnyStr: ... def swapcase(s: AnyStr) -> AnyStr: ... def translate(s: str, table: str, deletechars: str = ...) -> str: ... def upper(s: AnyStr) -> AnyStr: ... def ljust(s: AnyStr, width: int, fillchar: AnyStr = ...) -> AnyStr: ... def rjust(s: AnyStr, width: int, fillchar: AnyStr = ...) -> AnyStr: ... def center(s: AnyStr, width: int, fillchar: AnyStr = ...) -> AnyStr: ... def zfill(s: AnyStr, width: int) -> AnyStr: ... def replace(s: AnyStr, old: AnyStr, new: AnyStr, maxreplace: int = ...) -> AnyStr: ... class Template: template: Text def __init__(self, template: Text) -> None: ... @overload def substitute(self, mapping: Union[Mapping[str, str], Mapping[unicode, str]] = ..., **kwds: str) -> str: ... @overload def substitute(self, mapping: Union[Mapping[str, Text], Mapping[unicode, Text]] = ..., **kwds: Text) -> Text: ... @overload def safe_substitute(self, mapping: Union[Mapping[str, str], Mapping[unicode, str]] = ..., **kwds: str) -> str: ... @overload def safe_substitute(self, mapping: Union[Mapping[str, Text], Mapping[unicode, Text]], **kwds: Text) -> Text: ... # TODO(MichalPokorny): This is probably badly and/or loosely typed. class Formatter(object): def format(self, format_string: str, *args, **kwargs) -> str: ... def vformat(self, format_string: str, args: Sequence[Any], kwargs: Mapping[str, Any]) -> str: ... def parse(self, format_string: str) -> Iterable[Tuple[str, str, str, str]]: ... def get_field(self, field_name: str, args: Sequence[Any], kwargs: Mapping[str, Any]) -> Any: ... def get_value(self, key: Union[int, str], args: Sequence[Any], kwargs: Mapping[str, Any]) -> Any: ... def check_unused_args(self, used_args: Sequence[Union[int, str]], args: Sequence[Any], kwargs: Mapping[str, Any]) -> None: ... def format_field(self, value: Any, format_spec: str) -> Any: ... def convert_field(self, value: Any, conversion: str) -> Any: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/stringold.pyi0000664000175000017500000000373200000000000023650 0ustar00davedave00000000000000from typing import AnyStr, Iterable, List, Optional, Type whitespace: str lowercase: str uppercase: str letters: str digits: str hexdigits: str octdigits: str _idmap: str _idmapL: Optional[List[str]] index_error = ValueError atoi_error = ValueError atof_error = ValueError atol_error = ValueError def lower(s: AnyStr) -> AnyStr: ... def upper(s: AnyStr) -> AnyStr: ... def swapcase(s: AnyStr) -> AnyStr: ... def strip(s: AnyStr) -> AnyStr: ... def lstrip(s: AnyStr) -> AnyStr: ... def rstrip(s: AnyStr) -> AnyStr: ... def split(s: AnyStr, sep: AnyStr = ..., maxsplit: int = ...) -> List[AnyStr]: ... def splitfields(s: AnyStr, sep: AnyStr = ..., maxsplit: int = ...) -> List[AnyStr]: ... def join(words: Iterable[AnyStr], sep: AnyStr = ...) -> AnyStr: ... def joinfields(words: Iterable[AnyStr], sep: AnyStr = ...) -> AnyStr: ... def index(s: unicode, sub: unicode, start: int = ..., end: int = ...) -> int: ... def rindex(s: unicode, sub: unicode, start: int = ..., end: int = ...) -> int: ... def count(s: unicode, sub: unicode, start: int = ..., end: int = ...) -> int: ... def find(s: unicode, sub: unicode, start: int = ..., end: int = ...) -> int: ... def rfind(s: unicode, sub: unicode, start: int = ..., end: int = ...) -> int: ... def atof(s: unicode) -> float: ... def atoi(s: unicode, base: int = ...) -> int: ... def atol(s: unicode, base: int = ...) -> long: ... def ljust(s: AnyStr, width: int, fillchar: AnyStr = ...) -> AnyStr: ... def rjust(s: AnyStr, width: int, fillchar: AnyStr = ...) -> AnyStr: ... def center(s: AnyStr, width: int, fillchar: AnyStr = ...) -> AnyStr: ... def zfill(s: AnyStr, width: int) -> AnyStr: ... def expandtabs(s: AnyStr, tabsize: int = ...) -> AnyStr: ... def translate(s: str, table: str, deletions: str = ...) -> str: ... def capitalize(s: AnyStr) -> AnyStr: ... def capwords(s: AnyStr, sep: AnyStr = ...) -> AnyStr: ... def maketrans(fromstr: str, tostr: str) -> str: ... def replace(s: AnyStr, old: AnyStr, new: AnyStr, maxreplace: int = ...) -> AnyStr: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/strop.pyi0000664000175000017500000000220500000000000023004 0ustar00davedave00000000000000from typing import List, Sequence lowercase: str uppercase: str whitespace: str def atof(a: str) -> float: ... def atoi(a: str, base: int = ...) -> int: ... def atol(a: str, base: int = ...) -> long: ... def capitalize(s: str) -> str: ... def count(s: str, sub: str, start: int = ..., end: int = ...) -> int: ... def expandtabs(string: str, tabsize: int = ...) -> str: ... def find(s: str, sub: str, start: int = ..., end: int = ...) -> int: ... def join(list: Sequence[str], sep: str = ...) -> str: ... def joinfields(list: Sequence[str], sep: str = ...) -> str: ... def lower(s: str) -> str: ... def lstrip(s: str) -> str: ... def maketrans(frm: str, to: str) -> str: ... def replace(s: str, old: str, new: str, maxsplit: int = ...) -> str: ... def rfind(s: str, sub: str, start: int = ..., end: int = ...) -> int: ... def rstrip(s: str) -> str: ... def split(s: str, sep: str, maxsplit: int = ...) -> List[str]: ... def splitfields(s: str, sep: str, maxsplit: int = ...) -> List[str]: ... def strip(s: str) -> str: ... def swapcase(s: str) -> str: ... def translate(s: str, table: str, deletechars: str = ...) -> str: ... def upper(s: str) -> str: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/subprocess.pyi0000664000175000017500000000632200000000000024031 0ustar00davedave00000000000000from typing import IO, Any, Callable, Generic, List, Mapping, Optional, Sequence, Text, Tuple, TypeVar, Union _FILE = Union[None, int, IO[Any]] _TXT = Union[bytes, Text] _CMD = Union[_TXT, Sequence[_TXT]] _ENV = Union[Mapping[bytes, _TXT], Mapping[Text, _TXT]] # Same args as Popen.__init__ def call( args: _CMD, bufsize: int = ..., executable: _TXT = ..., stdin: _FILE = ..., stdout: _FILE = ..., stderr: _FILE = ..., preexec_fn: Callable[[], Any] = ..., close_fds: bool = ..., shell: bool = ..., cwd: Optional[_TXT] = ..., env: Optional[_ENV] = ..., universal_newlines: bool = ..., startupinfo: Any = ..., creationflags: int = ..., ) -> int: ... def check_call( args: _CMD, bufsize: int = ..., executable: _TXT = ..., stdin: _FILE = ..., stdout: _FILE = ..., stderr: _FILE = ..., preexec_fn: Callable[[], Any] = ..., close_fds: bool = ..., shell: bool = ..., cwd: Optional[_TXT] = ..., env: Optional[_ENV] = ..., universal_newlines: bool = ..., startupinfo: Any = ..., creationflags: int = ..., ) -> int: ... # Same args as Popen.__init__ except for stdout def check_output( args: _CMD, bufsize: int = ..., executable: _TXT = ..., stdin: _FILE = ..., stderr: _FILE = ..., preexec_fn: Callable[[], Any] = ..., close_fds: bool = ..., shell: bool = ..., cwd: Optional[_TXT] = ..., env: Optional[_ENV] = ..., universal_newlines: bool = ..., startupinfo: Any = ..., creationflags: int = ..., ) -> bytes: ... PIPE: int STDOUT: int class CalledProcessError(Exception): returncode: int # morally: _CMD cmd: Any # morally: Optional[bytes] output: bytes def __init__(self, returncode: int, cmd: _CMD, output: Optional[bytes] = ...) -> None: ... # We use a dummy type variable used to make Popen generic like it is in python 3 _T = TypeVar("_T", bound=bytes) class Popen(Generic[_T]): stdin: Optional[IO[bytes]] stdout: Optional[IO[bytes]] stderr: Optional[IO[bytes]] pid: int returncode: int def __new__( cls, args: _CMD, bufsize: int = ..., executable: Optional[_TXT] = ..., stdin: Optional[_FILE] = ..., stdout: Optional[_FILE] = ..., stderr: Optional[_FILE] = ..., preexec_fn: Optional[Callable[[], Any]] = ..., close_fds: bool = ..., shell: bool = ..., cwd: Optional[_TXT] = ..., env: Optional[_ENV] = ..., universal_newlines: bool = ..., startupinfo: Optional[Any] = ..., creationflags: int = ..., ) -> Popen[bytes]: ... def poll(self) -> Optional[int]: ... def wait(self) -> int: ... # morally: -> Tuple[Optional[bytes], Optional[bytes]] def communicate(self, input: Optional[_TXT] = ...) -> Tuple[bytes, bytes]: ... def send_signal(self, signal: int) -> None: ... def terminate(self) -> None: ... def kill(self) -> None: ... def list2cmdline(seq: Sequence[str]) -> str: ... # undocumented # Windows-only: STARTUPINFO etc. STD_INPUT_HANDLE: Any STD_OUTPUT_HANDLE: Any STD_ERROR_HANDLE: Any SW_HIDE: Any STARTF_USESTDHANDLES: Any STARTF_USESHOWWINDOW: Any CREATE_NEW_CONSOLE: Any CREATE_NEW_PROCESS_GROUP: Any ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/symbol.pyi0000664000175000017500000000247500000000000023153 0ustar00davedave00000000000000from typing import Dict single_input: int file_input: int eval_input: int decorator: int decorators: int decorated: int funcdef: int parameters: int varargslist: int fpdef: int fplist: int stmt: int simple_stmt: int small_stmt: int expr_stmt: int augassign: int print_stmt: int del_stmt: int pass_stmt: int flow_stmt: int break_stmt: int continue_stmt: int return_stmt: int yield_stmt: int raise_stmt: int import_stmt: int import_name: int import_from: int import_as_name: int dotted_as_name: int import_as_names: int dotted_as_names: int dotted_name: int global_stmt: int exec_stmt: int assert_stmt: int compound_stmt: int if_stmt: int while_stmt: int for_stmt: int try_stmt: int with_stmt: int with_item: int except_clause: int suite: int testlist_safe: int old_test: int old_lambdef: int test: int or_test: int and_test: int not_test: int comparison: int comp_op: int expr: int xor_expr: int and_expr: int shift_expr: int arith_expr: int term: int factor: int power: int atom: int listmaker: int testlist_comp: int lambdef: int trailer: int subscriptlist: int subscript: int sliceop: int exprlist: int testlist: int dictorsetmaker: int classdef: int arglist: int argument: int list_iter: int list_for: int list_if: int comp_iter: int comp_for: int comp_if: int testlist1: int encoding_decl: int yield_expr: int sym_name: Dict[int, str] ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/sys.pyi0000664000175000017500000000704000000000000022455 0ustar00davedave00000000000000from types import ClassType, FrameType, ModuleType, TracebackType from typing import IO, Any, BinaryIO, Callable, Dict, List, NoReturn, Optional, Sequence, Text, Tuple, Type, Union, overload # The following type alias are stub-only and do not exist during runtime _ExcInfo = Tuple[Type[BaseException], BaseException, TracebackType] _OptExcInfo = Union[_ExcInfo, Tuple[None, None, None]] class _flags: bytes_warning: int debug: int division_new: int division_warning: int dont_write_bytecode: int hash_randomization: int ignore_environment: int inspect: int interactive: int no_site: int no_user_site: int optimize: int py3k_warning: int tabcheck: int unicode: int verbose: int class _float_info: max: float max_exp: int max_10_exp: int min: float min_exp: int min_10_exp: int dig: int mant_dig: int epsilon: float radix: int rounds: int class _version_info(Tuple[int, int, int, str, int]): major: int minor: int micro: int releaselevel: str serial: int _mercurial: Tuple[str, str, str] api_version: int argv: List[str] builtin_module_names: Tuple[str, ...] byteorder: str copyright: str dont_write_bytecode: bool exec_prefix: str executable: str flags: _flags float_repr_style: str hexversion: int long_info: object maxint: int maxsize: int maxunicode: int modules: Dict[str, Any] path: List[str] platform: str prefix: str py3kwarning: bool __stderr__: IO[str] __stdin__: IO[str] __stdout__: IO[str] stderr: IO[str] stdin: IO[str] stdout: IO[str] subversion: Tuple[str, str, str] version: str warnoptions: object float_info: _float_info version_info: _version_info ps1: str ps2: str last_type: type last_value: BaseException last_traceback: TracebackType # TODO precise types meta_path: List[Any] path_hooks: List[Any] path_importer_cache: Dict[str, Any] displayhook: Callable[[object], Any] excepthook: Callable[[Type[BaseException], BaseException, TracebackType], Any] exc_type: Optional[type] exc_value: Union[BaseException, ClassType] exc_traceback: TracebackType class _WindowsVersionType: major: Any minor: Any build: Any platform: Any service_pack: Any service_pack_major: Any service_pack_minor: Any suite_mask: Any product_type: Any def getwindowsversion() -> _WindowsVersionType: ... def _clear_type_cache() -> None: ... def _current_frames() -> Dict[int, FrameType]: ... def _getframe(depth: int = ...) -> FrameType: ... def call_tracing(fn: Any, args: Any) -> Any: ... def __displayhook__(value: object) -> None: ... def __excepthook__(type_: type, value: BaseException, traceback: TracebackType) -> None: ... def exc_clear() -> None: ... def exc_info() -> _OptExcInfo: ... # sys.exit() accepts an optional argument of anything printable def exit(arg: Any = ...) -> NoReturn: ... def getcheckinterval() -> int: ... # deprecated def getdefaultencoding() -> str: ... def getdlopenflags() -> int: ... def getfilesystemencoding() -> str: ... # In practice, never returns None def getrefcount(arg: Any) -> int: ... def getrecursionlimit() -> int: ... def getsizeof(obj: object, default: int = ...) -> int: ... def getprofile() -> Optional[Any]: ... def gettrace() -> Optional[Any]: ... def setcheckinterval(interval: int) -> None: ... # deprecated def setdlopenflags(n: int) -> None: ... def setdefaultencoding(encoding: Text) -> None: ... # only exists after reload(sys) def setprofile(profilefunc: Any) -> None: ... # TODO type def setrecursionlimit(limit: int) -> None: ... def settrace(tracefunc: Any) -> None: ... # TODO type ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/tempfile.pyi0000664000175000017500000000716000000000000023447 0ustar00davedave00000000000000from random import Random from thread import LockType from typing import IO, Any, AnyStr, Iterable, Iterator, List, Optional, Text, Tuple, Union, overload TMP_MAX: int tempdir: str template: str _name_sequence: Optional[_RandomNameSequence] class _RandomNameSequence: characters: str = ... mutex: LockType @property def rng(self) -> Random: ... def __iter__(self) -> _RandomNameSequence: ... def next(self) -> str: ... # from os.path: def normcase(self, path: AnyStr) -> AnyStr: ... class _TemporaryFileWrapper(IO[str]): delete: bool file: IO[str] name: Any def __init__(self, file: IO[str], name: Any, delete: bool = ...) -> None: ... def __del__(self) -> None: ... def __enter__(self) -> _TemporaryFileWrapper: ... def __exit__(self, exc, value, tb) -> Optional[bool]: ... def __getattr__(self, name: unicode) -> Any: ... def close(self) -> None: ... def unlink(self, path: unicode) -> None: ... # These methods don't exist directly on this object, but # are delegated to the underlying IO object through __getattr__. # We need to add them here so that this class is concrete. def __iter__(self) -> Iterator[str]: ... def fileno(self) -> int: ... def flush(self) -> None: ... def isatty(self) -> bool: ... def next(self) -> str: ... def read(self, n: int = ...) -> str: ... def readable(self) -> bool: ... def readline(self, limit: int = ...) -> str: ... def readlines(self, hint: int = ...) -> List[str]: ... def seek(self, offset: int, whence: int = ...) -> int: ... def seekable(self) -> bool: ... def tell(self) -> int: ... def truncate(self, size: Optional[int] = ...) -> int: ... def writable(self) -> bool: ... def write(self, s: Text) -> int: ... def writelines(self, lines: Iterable[str]) -> None: ... # TODO text files def TemporaryFile( mode: Union[bytes, unicode] = ..., bufsize: int = ..., suffix: Union[bytes, unicode] = ..., prefix: Union[bytes, unicode] = ..., dir: Union[bytes, unicode] = ..., ) -> _TemporaryFileWrapper: ... def NamedTemporaryFile( mode: Union[bytes, unicode] = ..., bufsize: int = ..., suffix: Union[bytes, unicode] = ..., prefix: Union[bytes, unicode] = ..., dir: Union[bytes, unicode] = ..., delete: bool = ..., ) -> _TemporaryFileWrapper: ... def SpooledTemporaryFile( max_size: int = ..., mode: Union[bytes, unicode] = ..., buffering: int = ..., suffix: Union[bytes, unicode] = ..., prefix: Union[bytes, unicode] = ..., dir: Union[bytes, unicode] = ..., ) -> _TemporaryFileWrapper: ... class TemporaryDirectory: name: Any def __init__( self, suffix: Union[bytes, unicode] = ..., prefix: Union[bytes, unicode] = ..., dir: Union[bytes, unicode] = ... ) -> None: ... def cleanup(self) -> None: ... def __enter__(self) -> Any: ... # Can be str or unicode def __exit__(self, type, value, traceback) -> None: ... @overload def mkstemp() -> Tuple[int, str]: ... @overload def mkstemp(suffix: AnyStr = ..., prefix: AnyStr = ..., dir: Optional[AnyStr] = ..., text: bool = ...) -> Tuple[int, AnyStr]: ... @overload def mkdtemp() -> str: ... @overload def mkdtemp(suffix: AnyStr = ..., prefix: AnyStr = ..., dir: Optional[AnyStr] = ...) -> AnyStr: ... @overload def mktemp() -> str: ... @overload def mktemp(suffix: AnyStr = ..., prefix: AnyStr = ..., dir: Optional[AnyStr] = ...) -> AnyStr: ... def gettempdir() -> str: ... def gettempprefix() -> str: ... def _candidate_tempdir_list() -> List[str]: ... def _get_candidate_names() -> Optional[_RandomNameSequence]: ... def _get_default_tempdir() -> str: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/textwrap.pyi0000664000175000017500000000347600000000000023526 0ustar00davedave00000000000000from typing import AnyStr, Dict, List, Pattern class TextWrapper(object): width: int = ... initial_indent: str = ... subsequent_indent: str = ... expand_tabs: bool = ... replace_whitespace: bool = ... fix_sentence_endings: bool = ... drop_whitespace: bool = ... break_long_words: bool = ... break_on_hyphens: bool = ... # Attributes not present in documentation sentence_end_re: Pattern[str] = ... wordsep_re: Pattern[str] = ... wordsep_simple_re: Pattern[str] = ... whitespace_trans: str = ... unicode_whitespace_trans: Dict[int, int] = ... uspace: int = ... x: int = ... def __init__( self, width: int = ..., initial_indent: str = ..., subsequent_indent: str = ..., expand_tabs: bool = ..., replace_whitespace: bool = ..., fix_sentence_endings: bool = ..., break_long_words: bool = ..., drop_whitespace: bool = ..., break_on_hyphens: bool = ..., ) -> None: ... def wrap(self, text: AnyStr) -> List[AnyStr]: ... def fill(self, text: AnyStr) -> AnyStr: ... def wrap( text: AnyStr, width: int = ..., initial_indent: AnyStr = ..., subsequent_indent: AnyStr = ..., expand_tabs: bool = ..., replace_whitespace: bool = ..., fix_sentence_endings: bool = ..., break_long_words: bool = ..., drop_whitespace: bool = ..., break_on_hyphens: bool = ..., ) -> List[AnyStr]: ... def fill( text: AnyStr, width: int = ..., initial_indent: AnyStr = ..., subsequent_indent: AnyStr = ..., expand_tabs: bool = ..., replace_whitespace: bool = ..., fix_sentence_endings: bool = ..., break_long_words: bool = ..., drop_whitespace: bool = ..., break_on_hyphens: bool = ..., ) -> AnyStr: ... def dedent(text: AnyStr) -> AnyStr: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/thread.pyi0000664000175000017500000000163000000000000023105 0ustar00davedave00000000000000from typing import Any, Callable def _count() -> int: ... class error(Exception): ... class LockType: def acquire(self, waitflag: int = ...) -> bool: ... def acquire_lock(self, waitflag: int = ...) -> bool: ... def release(self) -> None: ... def release_lock(self) -> None: ... def locked(self) -> bool: ... def locked_lock(self) -> bool: ... def __enter__(self) -> LockType: ... def __exit__(self, typ: Any, value: Any, traceback: Any) -> None: ... class _local(object): ... class _localdummy(object): ... def start_new(function: Callable[..., Any], args: Any, kwargs: Any = ...) -> int: ... def start_new_thread(function: Callable[..., Any], args: Any, kwargs: Any = ...) -> int: ... def interrupt_main() -> None: ... def exit() -> None: ... def exit_thread() -> Any: ... def allocate_lock() -> LockType: ... def get_ident() -> int: ... def stack_size(size: int = ...) -> int: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/toaiff.pyi0000664000175000017500000000036300000000000023110 0ustar00davedave00000000000000from pipes import Template from typing import Dict, List table: Dict[str, Template] t: Template uncompress: Template class error(Exception): ... def toaiff(filename: str) -> str: ... def _toaiff(filename: str, temps: List[str]) -> str: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/tokenize.pyi0000664000175000017500000000517600000000000023477 0ustar00davedave00000000000000from typing import Any, Callable, Dict, Generator, Iterable, Iterator, List, Tuple, Union __author__: str __credits__: str AMPER: int AMPEREQUAL: int AT: int BACKQUOTE: int Binnumber: str Bracket: str CIRCUMFLEX: int CIRCUMFLEXEQUAL: int COLON: int COMMA: int COMMENT: int Comment: str ContStr: str DEDENT: int DOT: int DOUBLESLASH: int DOUBLESLASHEQUAL: int DOUBLESTAR: int DOUBLESTAREQUAL: int Decnumber: str Double: str Double3: str ENDMARKER: int EQEQUAL: int EQUAL: int ERRORTOKEN: int Expfloat: str Exponent: str Floatnumber: str Funny: str GREATER: int GREATEREQUAL: int Hexnumber: str INDENT: int def ISEOF(x: int) -> bool: ... def ISNONTERMINAL(x: int) -> bool: ... def ISTERMINAL(x: int) -> bool: ... Ignore: str Imagnumber: str Intnumber: str LBRACE: int LEFTSHIFT: int LEFTSHIFTEQUAL: int LESS: int LESSEQUAL: int LPAR: int LSQB: int MINEQUAL: int MINUS: int NAME: int NEWLINE: int NL: int NOTEQUAL: int NT_OFFSET: int NUMBER: int N_TOKENS: int Name: str Number: str OP: int Octnumber: str Operator: str PERCENT: int PERCENTEQUAL: int PLUS: int PLUSEQUAL: int PlainToken: str Pointfloat: str PseudoExtras: str PseudoToken: str RBRACE: int RIGHTSHIFT: int RIGHTSHIFTEQUAL: int RPAR: int RSQB: int SEMI: int SLASH: int SLASHEQUAL: int STAR: int STAREQUAL: int STRING: int Single: str Single3: str Special: str String: str TILDE: int Token: str Triple: str VBAR: int VBAREQUAL: int Whitespace: str chain: type double3prog: type endprogs: Dict[str, Any] pseudoprog: type single3prog: type single_quoted: Dict[str, str] t: str tabsize: int tok_name: Dict[int, str] tokenprog: type triple_quoted: Dict[str, str] x: str _Pos = Tuple[int, int] _TokenType = Tuple[int, str, _Pos, _Pos, str] def any(*args, **kwargs) -> str: ... def generate_tokens(readline: Callable[[], str]) -> Generator[_TokenType, None, None]: ... def group(*args: str) -> str: ... def maybe(*args: str) -> str: ... def printtoken(type: int, token: str, srow_scol: _Pos, erow_ecol: _Pos, line: str) -> None: ... def tokenize(readline: Callable[[], str], tokeneater: Callable[[Tuple[int, str, _Pos, _Pos, str]], None]) -> None: ... def tokenize_loop(readline: Callable[[], str], tokeneater: Callable[[Tuple[int, str, _Pos, _Pos, str]], None]) -> None: ... def untokenize(iterable: Iterable[_TokenType]) -> str: ... class StopTokenizing(Exception): ... class TokenError(Exception): ... class Untokenizer: prev_col: int prev_row: int tokens: List[str] def __init__(self) -> None: ... def add_whitespace(self, _Pos) -> None: ... def compat(self, token: Tuple[int, Any], iterable: Iterator[_TokenType]) -> None: ... def untokenize(self, iterable: Iterable[_TokenType]) -> str: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/types.pyi0000664000175000017500000001253100000000000023004 0ustar00davedave00000000000000from typing import Any, Callable, Dict, Iterable, Iterator, List, Optional, Tuple, Type, TypeVar, Union, overload _T = TypeVar("_T") # Note, all classes "defined" here require special handling. class NoneType: ... TypeType = type ObjectType = object IntType = int LongType = int # Really long, but can't reference that due to a mypy import cycle FloatType = float BooleanType = bool ComplexType = complex StringType = str UnicodeType = unicode StringTypes: Tuple[Type[StringType], Type[UnicodeType]] BufferType = buffer TupleType = tuple ListType = list DictType = dict DictionaryType = dict class _Cell: cell_contents: Any class FunctionType: func_closure: Optional[Tuple[_Cell, ...]] = ... func_code: CodeType = ... func_defaults: Optional[Tuple[Any, ...]] = ... func_dict: Dict[str, Any] = ... func_doc: Optional[str] = ... func_globals: Dict[str, Any] = ... func_name: str = ... __closure__ = func_closure __code__ = func_code __defaults__ = func_defaults __dict__ = func_dict __globals__ = func_globals __name__ = func_name def __init__( self, code: CodeType, globals: Dict[str, Any], name: Optional[str] = ..., argdefs: Optional[Tuple[object, ...]] = ..., closure: Optional[Tuple[_Cell, ...]] = ..., ) -> None: ... def __call__(self, *args: Any, **kwargs: Any) -> Any: ... def __get__(self, obj: Optional[object], type: Optional[type]) -> UnboundMethodType: ... LambdaType = FunctionType class CodeType: co_argcount: int co_cellvars: Tuple[str, ...] co_code: str co_consts: Tuple[Any, ...] co_filename: str co_firstlineno: int co_flags: int co_freevars: Tuple[str, ...] co_lnotab: str co_name: str co_names: Tuple[str, ...] co_nlocals: int co_stacksize: int co_varnames: Tuple[str, ...] def __init__( self, argcount: int, nlocals: int, stacksize: int, flags: int, codestring: str, constants: Tuple[Any, ...], names: Tuple[str, ...], varnames: Tuple[str, ...], filename: str, name: str, firstlineno: int, lnotab: str, freevars: Tuple[str, ...] = ..., cellvars: Tuple[str, ...] = ..., ) -> None: ... class GeneratorType: gi_code: CodeType gi_frame: FrameType gi_running: int def __iter__(self) -> GeneratorType: ... def close(self) -> None: ... def next(self) -> Any: ... def send(self, __arg: Any) -> Any: ... @overload def throw( self, __typ: Type[BaseException], __val: Union[BaseException, object] = ..., __tb: Optional[TracebackType] = ... ) -> Any: ... @overload def throw(self, __typ: BaseException, __val: None = ..., __tb: Optional[TracebackType] = ...) -> Any: ... class ClassType: ... class UnboundMethodType: im_class: type = ... im_func: FunctionType = ... im_self: object = ... __name__: str __func__ = im_func __self__ = im_self def __init__(self, func: Callable[..., Any], obj: object) -> None: ... def __call__(self, *args: Any, **kwargs: Any) -> Any: ... class InstanceType(object): ... MethodType = UnboundMethodType class BuiltinFunctionType: __self__: Optional[object] def __call__(self, *args: Any, **kwargs: Any) -> Any: ... BuiltinMethodType = BuiltinFunctionType class ModuleType: __doc__: Optional[str] __file__: Optional[str] __name__: str __package__: Optional[str] __path__: Optional[Iterable[str]] __dict__: Dict[str, Any] def __init__(self, name: str, doc: Optional[str] = ...) -> None: ... FileType = file XRangeType = xrange class TracebackType: tb_frame: FrameType tb_lasti: int tb_lineno: int tb_next: TracebackType class FrameType: f_back: FrameType f_builtins: Dict[str, Any] f_code: CodeType f_exc_type: None f_exc_value: None f_exc_traceback: None f_globals: Dict[str, Any] f_lasti: int f_lineno: int f_locals: Dict[str, Any] f_restricted: bool f_trace: Callable[[], None] def clear(self) -> None: ... SliceType = slice class EllipsisType: ... class DictProxyType: # TODO is it possible to have non-string keys? # no __init__ def copy(self) -> Dict[Any, Any]: ... def get(self, key: str, default: _T = ...) -> Union[Any, _T]: ... def has_key(self, key: str) -> bool: ... def items(self) -> List[Tuple[str, Any]]: ... def iteritems(self) -> Iterator[Tuple[str, Any]]: ... def iterkeys(self) -> Iterator[str]: ... def itervalues(self) -> Iterator[Any]: ... def keys(self) -> List[str]: ... def values(self) -> List[Any]: ... def __contains__(self, key: str) -> bool: ... def __getitem__(self, key: str) -> Any: ... def __iter__(self) -> Iterator[str]: ... def __len__(self) -> int: ... class NotImplementedType: ... class GetSetDescriptorType: __name__: str __objclass__: type def __get__(self, obj: Any, type: type = ...) -> Any: ... def __set__(self, obj: Any) -> None: ... def __delete__(self, obj: Any) -> None: ... # Same type on Jython, different on CPython and PyPy, unknown on IronPython. class MemberDescriptorType: __name__: str __objclass__: type def __get__(self, obj: Any, type: type = ...) -> Any: ... def __set__(self, obj: Any) -> None: ... def __delete__(self, obj: Any) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/typing.pyi0000664000175000017500000004255400000000000023162 0ustar00davedave00000000000000import collections # Needed by aliases like DefaultDict, see mypy issue 2986 from abc import ABCMeta, abstractmethod from types import CodeType, FrameType, TracebackType # Definitions of special type checking related constructs. Their definitions # are not used, so their value does not matter. overload = object() Any = object() class TypeVar: __name__: str __bound__: Optional[Type[Any]] __constraints__: Tuple[Type[Any], ...] __covariant__: bool __contravariant__: bool def __init__( self, name: str, *constraints: Type[Any], bound: Optional[Type[Any]] = ..., covariant: bool = ..., contravariant: bool = ..., ) -> None: ... _promote = object() class _SpecialForm(object): def __getitem__(self, typeargs: Any) -> object: ... Union: _SpecialForm = ... Optional: _SpecialForm = ... Tuple: _SpecialForm = ... Generic: _SpecialForm = ... Protocol: _SpecialForm = ... Callable: _SpecialForm = ... Type: _SpecialForm = ... ClassVar: _SpecialForm = ... Final: _SpecialForm = ... _F = TypeVar("_F", bound=Callable[..., Any]) def final(f: _F) -> _F: ... Literal: _SpecialForm = ... # TypedDict is a (non-subscriptable) special form. TypedDict: object = ... class GenericMeta(type): ... # Return type that indicates a function does not return. # This type is equivalent to the None type, but the no-op Union is necessary to # distinguish the None type from the None value. NoReturn = Union[None] # These type variables are used by the container types. _T = TypeVar("_T") _S = TypeVar("_S") _KT = TypeVar("_KT") # Key type. _VT = TypeVar("_VT") # Value type. _T_co = TypeVar("_T_co", covariant=True) # Any type covariant containers. _V_co = TypeVar("_V_co", covariant=True) # Any type covariant containers. _KT_co = TypeVar("_KT_co", covariant=True) # Key type covariant containers. _VT_co = TypeVar("_VT_co", covariant=True) # Value type covariant containers. _T_contra = TypeVar("_T_contra", contravariant=True) # Ditto contravariant. _TC = TypeVar("_TC", bound=Type[object]) _C = TypeVar("_C", bound=Callable[..., Any]) no_type_check = object() def no_type_check_decorator(decorator: _C) -> _C: ... # Type aliases and type constructors class _Alias: # Class for defining generic aliases for library types. def __getitem__(self, typeargs: Any) -> Any: ... List = _Alias() Dict = _Alias() DefaultDict = _Alias() Set = _Alias() FrozenSet = _Alias() Counter = _Alias() Deque = _Alias() # Predefined type variables. AnyStr = TypeVar("AnyStr", str, unicode) # Abstract base classes. def runtime_checkable(cls: _TC) -> _TC: ... @runtime_checkable class SupportsInt(Protocol, metaclass=ABCMeta): @abstractmethod def __int__(self) -> int: ... @runtime_checkable class SupportsFloat(Protocol, metaclass=ABCMeta): @abstractmethod def __float__(self) -> float: ... @runtime_checkable class SupportsComplex(Protocol, metaclass=ABCMeta): @abstractmethod def __complex__(self) -> complex: ... @runtime_checkable class SupportsAbs(Protocol[_T_co]): @abstractmethod def __abs__(self) -> _T_co: ... @runtime_checkable class Reversible(Protocol[_T_co]): @abstractmethod def __reversed__(self) -> Iterator[_T_co]: ... @runtime_checkable class Sized(Protocol, metaclass=ABCMeta): @abstractmethod def __len__(self) -> int: ... @runtime_checkable class Hashable(Protocol, metaclass=ABCMeta): # TODO: This is special, in that a subclass of a hashable class may not be hashable # (for example, list vs. object). It's not obvious how to represent this. This class # is currently mostly useless for static checking. @abstractmethod def __hash__(self) -> int: ... @runtime_checkable class Iterable(Protocol[_T_co]): @abstractmethod def __iter__(self) -> Iterator[_T_co]: ... @runtime_checkable class Iterator(Iterable[_T_co], Protocol[_T_co]): @abstractmethod def next(self) -> _T_co: ... def __iter__(self) -> Iterator[_T_co]: ... class Generator(Iterator[_T_co], Generic[_T_co, _T_contra, _V_co]): @abstractmethod def next(self) -> _T_co: ... @abstractmethod def send(self, __value: _T_contra) -> _T_co: ... @overload @abstractmethod def throw( self, __typ: Type[BaseException], __val: Union[BaseException, object] = ..., __tb: Optional[TracebackType] = ... ) -> _T_co: ... @overload @abstractmethod def throw(self, __typ: BaseException, __val: None = ..., __tb: Optional[TracebackType] = ...) -> _T_co: ... @abstractmethod def close(self) -> None: ... @property def gi_code(self) -> CodeType: ... @property def gi_frame(self) -> FrameType: ... @property def gi_running(self) -> bool: ... @runtime_checkable class Container(Protocol[_T_co]): @abstractmethod def __contains__(self, x: object) -> bool: ... class Sequence(Iterable[_T_co], Container[_T_co], Reversible[_T_co], Generic[_T_co]): @overload @abstractmethod def __getitem__(self, i: int) -> _T_co: ... @overload @abstractmethod def __getitem__(self, s: slice) -> Sequence[_T_co]: ... # Mixin methods def index(self, x: Any) -> int: ... def count(self, x: Any) -> int: ... def __contains__(self, x: object) -> bool: ... def __iter__(self) -> Iterator[_T_co]: ... def __reversed__(self) -> Iterator[_T_co]: ... # Implement Sized (but don't have it as a base class). @abstractmethod def __len__(self) -> int: ... class MutableSequence(Sequence[_T], Generic[_T]): @abstractmethod def insert(self, index: int, object: _T) -> None: ... @overload @abstractmethod def __getitem__(self, i: int) -> _T: ... @overload @abstractmethod def __getitem__(self, s: slice) -> MutableSequence[_T]: ... @overload @abstractmethod def __setitem__(self, i: int, o: _T) -> None: ... @overload @abstractmethod def __setitem__(self, s: slice, o: Iterable[_T]) -> None: ... @overload @abstractmethod def __delitem__(self, i: int) -> None: ... @overload @abstractmethod def __delitem__(self, i: slice) -> None: ... # Mixin methods def append(self, object: _T) -> None: ... def extend(self, iterable: Iterable[_T]) -> None: ... def reverse(self) -> None: ... def pop(self, index: int = ...) -> _T: ... def remove(self, object: _T) -> None: ... def __iadd__(self, x: Iterable[_T]) -> MutableSequence[_T]: ... class AbstractSet(Iterable[_T_co], Container[_T_co], Generic[_T_co]): @abstractmethod def __contains__(self, x: object) -> bool: ... # Mixin methods def __le__(self, s: AbstractSet[Any]) -> bool: ... def __lt__(self, s: AbstractSet[Any]) -> bool: ... def __gt__(self, s: AbstractSet[Any]) -> bool: ... def __ge__(self, s: AbstractSet[Any]) -> bool: ... def __and__(self, s: AbstractSet[Any]) -> AbstractSet[_T_co]: ... def __or__(self, s: AbstractSet[_T]) -> AbstractSet[Union[_T_co, _T]]: ... def __sub__(self, s: AbstractSet[Any]) -> AbstractSet[_T_co]: ... def __xor__(self, s: AbstractSet[_T]) -> AbstractSet[Union[_T_co, _T]]: ... # TODO: argument can be any container? def isdisjoint(self, s: AbstractSet[Any]) -> bool: ... # Implement Sized (but don't have it as a base class). @abstractmethod def __len__(self) -> int: ... class MutableSet(AbstractSet[_T], Generic[_T]): @abstractmethod def add(self, x: _T) -> None: ... @abstractmethod def discard(self, x: _T) -> None: ... # Mixin methods def clear(self) -> None: ... def pop(self) -> _T: ... def remove(self, element: _T) -> None: ... def __ior__(self, s: AbstractSet[_S]) -> MutableSet[Union[_T, _S]]: ... def __iand__(self, s: AbstractSet[Any]) -> MutableSet[_T]: ... def __ixor__(self, s: AbstractSet[_S]) -> MutableSet[Union[_T, _S]]: ... def __isub__(self, s: AbstractSet[Any]) -> MutableSet[_T]: ... class MappingView(object): def __len__(self) -> int: ... class ItemsView(MappingView, AbstractSet[Tuple[_KT_co, _VT_co]], Generic[_KT_co, _VT_co]): def __init__(self, mapping: Mapping[_KT_co, _VT_co]) -> None: ... def __contains__(self, o: object) -> bool: ... def __iter__(self) -> Iterator[Tuple[_KT_co, _VT_co]]: ... class KeysView(MappingView, AbstractSet[_KT_co], Generic[_KT_co]): def __init__(self, mapping: Mapping[_KT_co, _VT_co]) -> None: ... def __contains__(self, o: object) -> bool: ... def __iter__(self) -> Iterator[_KT_co]: ... class ValuesView(MappingView, Iterable[_VT_co], Generic[_VT_co]): def __init__(self, mapping: Mapping[_KT_co, _VT_co]) -> None: ... def __contains__(self, o: object) -> bool: ... def __iter__(self) -> Iterator[_VT_co]: ... @runtime_checkable class ContextManager(Protocol[_T_co]): def __enter__(self) -> _T_co: ... def __exit__( self, __exc_type: Optional[Type[BaseException]], __exc_value: Optional[BaseException], __traceback: Optional[TracebackType], ) -> Optional[bool]: ... class Mapping(Iterable[_KT], Container[_KT], Generic[_KT, _VT_co]): # TODO: We wish the key type could also be covariant, but that doesn't work, # see discussion in https: //github.com/python/typing/pull/273. @abstractmethod def __getitem__(self, k: _KT) -> _VT_co: ... # Mixin methods @overload def get(self, k: _KT) -> Optional[_VT_co]: ... @overload def get(self, k: _KT, default: Union[_VT_co, _T]) -> Union[_VT_co, _T]: ... def keys(self) -> list[_KT]: ... def values(self) -> list[_VT_co]: ... def items(self) -> list[Tuple[_KT, _VT_co]]: ... def iterkeys(self) -> Iterator[_KT]: ... def itervalues(self) -> Iterator[_VT_co]: ... def iteritems(self) -> Iterator[Tuple[_KT, _VT_co]]: ... def __contains__(self, o: object) -> bool: ... # Implement Sized (but don't have it as a base class). @abstractmethod def __len__(self) -> int: ... class MutableMapping(Mapping[_KT, _VT], Generic[_KT, _VT]): @abstractmethod def __setitem__(self, k: _KT, v: _VT) -> None: ... @abstractmethod def __delitem__(self, v: _KT) -> None: ... def clear(self) -> None: ... @overload def pop(self, k: _KT) -> _VT: ... @overload def pop(self, k: _KT, default: Union[_VT, _T] = ...) -> Union[_VT, _T]: ... def popitem(self) -> Tuple[_KT, _VT]: ... def setdefault(self, k: _KT, default: _VT = ...) -> _VT: ... @overload def update(self, __m: Mapping[_KT, _VT], **kwargs: _VT) -> None: ... @overload def update(self, __m: Iterable[Tuple[_KT, _VT]], **kwargs: _VT) -> None: ... @overload def update(self, **kwargs: _VT) -> None: ... Text = unicode TYPE_CHECKING = True class IO(Iterator[AnyStr], Generic[AnyStr]): # TODO detach # TODO use abstract properties @property def mode(self) -> str: ... @property def name(self) -> str: ... @abstractmethod def close(self) -> None: ... @property def closed(self) -> bool: ... @abstractmethod def fileno(self) -> int: ... @abstractmethod def flush(self) -> None: ... @abstractmethod def isatty(self) -> bool: ... # TODO what if n is None? @abstractmethod def read(self, n: int = ...) -> AnyStr: ... @abstractmethod def readable(self) -> bool: ... @abstractmethod def readline(self, limit: int = ...) -> AnyStr: ... @abstractmethod def readlines(self, hint: int = ...) -> list[AnyStr]: ... @abstractmethod def seek(self, offset: int, whence: int = ...) -> int: ... @abstractmethod def seekable(self) -> bool: ... @abstractmethod def tell(self) -> int: ... @abstractmethod def truncate(self, size: Optional[int] = ...) -> int: ... @abstractmethod def writable(self) -> bool: ... # TODO buffer objects @abstractmethod def write(self, s: AnyStr) -> int: ... @abstractmethod def writelines(self, lines: Iterable[AnyStr]) -> None: ... @abstractmethod def next(self) -> AnyStr: ... @abstractmethod def __iter__(self) -> Iterator[AnyStr]: ... @abstractmethod def __enter__(self) -> IO[AnyStr]: ... @abstractmethod def __exit__( self, t: Optional[Type[BaseException]], value: Optional[BaseException], traceback: Optional[TracebackType] ) -> Optional[bool]: ... class BinaryIO(IO[str]): # TODO readinto # TODO read1? # TODO peek? @abstractmethod def __enter__(self) -> BinaryIO: ... class TextIO(IO[unicode]): # TODO use abstractproperty @property def buffer(self) -> BinaryIO: ... @property def encoding(self) -> str: ... @property def errors(self) -> Optional[str]: ... @property def line_buffering(self) -> bool: ... @property def newlines(self) -> Any: ... # None, str or tuple @abstractmethod def __enter__(self) -> TextIO: ... class ByteString(Sequence[int], metaclass=ABCMeta): ... class Match(Generic[AnyStr]): pos: int endpos: int lastindex: Optional[int] string: AnyStr # The regular expression object whose match() or search() method produced # this match instance. This should not be Pattern[AnyStr] because the type # of the pattern is independent of the type of the matched string in # Python 2. Strictly speaking Match should be generic over AnyStr twice: # once for the type of the pattern and once for the type of the matched # string. re: Pattern[Any] # Can be None if there are no groups or if the last group was unnamed; # otherwise matches the type of the pattern. lastgroup: Optional[Any] def expand(self, template: Union[str, Text]) -> Any: ... @overload def group(self, group1: int = ...) -> AnyStr: ... @overload def group(self, group1: str) -> AnyStr: ... @overload def group(self, group1: int, group2: int, *groups: int) -> Tuple[AnyStr, ...]: ... @overload def group(self, group1: str, group2: str, *groups: str) -> Tuple[AnyStr, ...]: ... def groups(self, default: AnyStr = ...) -> Tuple[AnyStr, ...]: ... def groupdict(self, default: AnyStr = ...) -> Dict[str, AnyStr]: ... def start(self, __group: Union[int, str] = ...) -> int: ... def end(self, __group: Union[int, str] = ...) -> int: ... def span(self, __group: Union[int, str] = ...) -> Tuple[int, int]: ... @property def regs(self) -> Tuple[Tuple[int, int], ...]: ... # undocumented # We need a second TypeVar with the same definition as AnyStr, because # Pattern is generic over AnyStr (determining the type of its .pattern # attribute), but at the same time its methods take either bytes or # Text and return the same type, regardless of the type of the pattern. _AnyStr2 = TypeVar("_AnyStr2", bytes, Text) class Pattern(Generic[AnyStr]): flags: int groupindex: Dict[AnyStr, int] groups: int pattern: AnyStr def search(self, string: _AnyStr2, pos: int = ..., endpos: int = ...) -> Optional[Match[_AnyStr2]]: ... def match(self, string: _AnyStr2, pos: int = ..., endpos: int = ...) -> Optional[Match[_AnyStr2]]: ... def split(self, string: _AnyStr2, maxsplit: int = ...) -> List[_AnyStr2]: ... # Returns either a list of _AnyStr2 or a list of tuples, depending on # whether there are groups in the pattern. def findall(self, string: Union[bytes, Text], pos: int = ..., endpos: int = ...) -> List[Any]: ... def finditer(self, string: _AnyStr2, pos: int = ..., endpos: int = ...) -> Iterator[Match[_AnyStr2]]: ... @overload def sub(self, repl: _AnyStr2, string: _AnyStr2, count: int = ...) -> _AnyStr2: ... @overload def sub(self, repl: Callable[[Match[_AnyStr2]], _AnyStr2], string: _AnyStr2, count: int = ...) -> _AnyStr2: ... @overload def subn(self, repl: _AnyStr2, string: _AnyStr2, count: int = ...) -> Tuple[_AnyStr2, int]: ... @overload def subn(self, repl: Callable[[Match[_AnyStr2]], _AnyStr2], string: _AnyStr2, count: int = ...) -> Tuple[_AnyStr2, int]: ... # Functions def get_type_hints( obj: Callable[..., Any], globalns: Optional[Dict[Text, Any]] = ..., localns: Optional[Dict[Text, Any]] = ... ) -> None: ... @overload def cast(tp: Type[_T], obj: Any) -> _T: ... @overload def cast(tp: str, obj: Any) -> Any: ... @overload def cast(tp: object, obj: Any) -> Any: ... # Type constructors # NamedTuple is special-cased in the type checker class NamedTuple(Tuple[Any, ...]): _fields: Tuple[str, ...] def __init__(self, typename: Text, fields: Iterable[Tuple[Text, Any]] = ..., **kwargs: Any) -> None: ... @classmethod def _make(cls: Type[_T], iterable: Iterable[Any]) -> _T: ... def _asdict(self) -> Dict[str, Any]: ... def _replace(self: _T, **kwargs: Any) -> _T: ... # Internal mypy fallback type for all typed dicts (does not exist at runtime) class _TypedDict(Mapping[str, object], metaclass=ABCMeta): def copy(self: _T) -> _T: ... # Using NoReturn so that only calls using mypy plugin hook that specialize the signature # can go through. def setdefault(self, k: NoReturn, default: object) -> object: ... # Mypy plugin hook for 'pop' expects that 'default' has a type variable type. def pop(self, k: NoReturn, default: _T = ...) -> object: ... def update(self: _T, __m: _T) -> None: ... def has_key(self, k: str) -> bool: ... def viewitems(self) -> ItemsView[str, object]: ... def viewkeys(self) -> KeysView[str]: ... def viewvalues(self) -> ValuesView[object]: ... def __delitem__(self, k: NoReturn) -> None: ... def NewType(name: str, tp: Type[_T]) -> Type[_T]: ... # This itself is only available during type checking def type_check_only(func_or_cls: _C) -> _C: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/unittest.pyi0000664000175000017500000003066600000000000023530 0ustar00davedave00000000000000import datetime import types from abc import ABCMeta, abstractmethod from typing import ( Any, Callable, Dict, FrozenSet, Iterable, Iterator, List, Mapping, NoReturn, Optional, Pattern, Sequence, Set, Text, TextIO, Tuple, Type, TypeVar, Union, overload, ) _T = TypeVar("_T") _FT = TypeVar("_FT") _ExceptionType = Union[Type[BaseException], Tuple[Type[BaseException], ...]] _Regexp = Union[Text, Pattern[Text]] _SysExcInfoType = Union[Tuple[Type[BaseException], BaseException, types.TracebackType], Tuple[None, None, None]] class Testable(metaclass=ABCMeta): @abstractmethod def run(self, result: TestResult) -> None: ... @abstractmethod def debug(self) -> None: ... @abstractmethod def countTestCases(self) -> int: ... # TODO ABC for test runners? class TestResult: errors: List[Tuple[TestCase, str]] failures: List[Tuple[TestCase, str]] skipped: List[Tuple[TestCase, str]] expectedFailures: List[Tuple[TestCase, str]] unexpectedSuccesses: List[TestCase] shouldStop: bool testsRun: int buffer: bool failfast: bool def wasSuccessful(self) -> bool: ... def stop(self) -> None: ... def startTest(self, test: TestCase) -> None: ... def stopTest(self, test: TestCase) -> None: ... def startTestRun(self) -> None: ... def stopTestRun(self) -> None: ... def addError(self, test: TestCase, err: _SysExcInfoType) -> None: ... def addFailure(self, test: TestCase, err: _SysExcInfoType) -> None: ... def addSuccess(self, test: TestCase) -> None: ... def addSkip(self, test: TestCase, reason: str) -> None: ... def addExpectedFailure(self, test: TestCase, err: str) -> None: ... def addUnexpectedSuccess(self, test: TestCase) -> None: ... class _AssertRaisesBaseContext: expected: Any failureException: Type[BaseException] obj_name: str expected_regex: Pattern[str] class _AssertRaisesContext(_AssertRaisesBaseContext): exception: Any def __enter__(self) -> _AssertRaisesContext: ... def __exit__(self, exc_type, exc_value, tb) -> bool: ... class TestCase(Testable): failureException: Type[BaseException] longMessage: bool maxDiff: Optional[int] # undocumented _testMethodName: str def __init__(self, methodName: str = ...) -> None: ... def setUp(self) -> None: ... def tearDown(self) -> None: ... @classmethod def setUpClass(cls) -> None: ... @classmethod def tearDownClass(cls) -> None: ... def run(self, result: TestResult = ...) -> None: ... def debug(self) -> None: ... def assert_(self, expr: Any, msg: object = ...) -> None: ... def failUnless(self, expr: Any, msg: object = ...) -> None: ... def assertTrue(self, expr: Any, msg: object = ...) -> None: ... def assertEqual(self, first: Any, second: Any, msg: object = ...) -> None: ... def assertEquals(self, first: Any, second: Any, msg: object = ...) -> None: ... def failUnlessEqual(self, first: Any, second: Any, msg: object = ...) -> None: ... def assertNotEqual(self, first: Any, second: Any, msg: object = ...) -> None: ... def assertNotEquals(self, first: Any, second: Any, msg: object = ...) -> None: ... def failIfEqual(self, first: Any, second: Any, msg: object = ...) -> None: ... @overload def assertAlmostEqual(self, first: float, second: float, places: int = ..., msg: Any = ...) -> None: ... @overload def assertAlmostEqual(self, first: float, second: float, *, msg: Any = ..., delta: float = ...) -> None: ... @overload def assertAlmostEqual( self, first: datetime.datetime, second: datetime.datetime, *, msg: Any = ..., delta: datetime.timedelta = ... ) -> None: ... @overload def assertAlmostEquals(self, first: float, second: float, places: int = ..., msg: Any = ...) -> None: ... @overload def assertAlmostEquals(self, first: float, second: float, *, msg: Any = ..., delta: float = ...) -> None: ... @overload def assertAlmostEquals( self, first: datetime.datetime, second: datetime.datetime, *, msg: Any = ..., delta: datetime.timedelta = ... ) -> None: ... def failUnlessAlmostEqual(self, first: float, second: float, places: int = ..., msg: object = ...) -> None: ... @overload def assertNotAlmostEqual(self, first: float, second: float, places: int = ..., msg: Any = ...) -> None: ... @overload def assertNotAlmostEqual(self, first: float, second: float, *, msg: Any = ..., delta: float = ...) -> None: ... @overload def assertNotAlmostEqual( self, first: datetime.datetime, second: datetime.datetime, *, msg: Any = ..., delta: datetime.timedelta = ... ) -> None: ... @overload def assertNotAlmostEquals(self, first: float, second: float, places: int = ..., msg: Any = ...) -> None: ... @overload def assertNotAlmostEquals(self, first: float, second: float, *, msg: Any = ..., delta: float = ...) -> None: ... @overload def assertNotAlmostEquals( self, first: datetime.datetime, second: datetime.datetime, *, msg: Any = ..., delta: datetime.timedelta = ... ) -> None: ... def failIfAlmostEqual( self, first: float, second: float, places: int = ..., msg: object = ..., delta: float = ... ) -> None: ... def assertGreater(self, first: Any, second: Any, msg: object = ...) -> None: ... def assertGreaterEqual(self, first: Any, second: Any, msg: object = ...) -> None: ... def assertMultiLineEqual(self, first: str, second: str, msg: object = ...) -> None: ... def assertSequenceEqual( self, first: Sequence[Any], second: Sequence[Any], msg: object = ..., seq_type: type = ... ) -> None: ... def assertListEqual(self, first: List[Any], second: List[Any], msg: object = ...) -> None: ... def assertTupleEqual(self, first: Tuple[Any, ...], second: Tuple[Any, ...], msg: object = ...) -> None: ... def assertSetEqual( self, first: Union[Set[Any], FrozenSet[Any]], second: Union[Set[Any], FrozenSet[Any]], msg: object = ... ) -> None: ... def assertDictEqual(self, first: Dict[Any, Any], second: Dict[Any, Any], msg: object = ...) -> None: ... def assertLess(self, first: Any, second: Any, msg: object = ...) -> None: ... def assertLessEqual(self, first: Any, second: Any, msg: object = ...) -> None: ... @overload def assertRaises(self, exception: _ExceptionType, callable: Callable[..., Any], *args: Any, **kwargs: Any) -> None: ... @overload def assertRaises(self, exception: _ExceptionType) -> _AssertRaisesContext: ... @overload def assertRaisesRegexp( self, exception: _ExceptionType, regexp: _Regexp, callable: Callable[..., Any], *args: Any, **kwargs: Any ) -> None: ... @overload def assertRaisesRegexp(self, exception: _ExceptionType, regexp: _Regexp) -> _AssertRaisesContext: ... def assertRegexpMatches(self, text: Text, regexp: _Regexp, msg: object = ...) -> None: ... def assertNotRegexpMatches(self, text: Text, regexp: _Regexp, msg: object = ...) -> None: ... def assertItemsEqual(self, first: Iterable[Any], second: Iterable[Any], msg: object = ...) -> None: ... def assertDictContainsSubset(self, expected: Mapping[Any, Any], actual: Mapping[Any, Any], msg: object = ...) -> None: ... def addTypeEqualityFunc(self, typeobj: type, function: Callable[..., None]) -> None: ... @overload def failUnlessRaises(self, exception: _ExceptionType, callable: Callable[..., Any], *args: Any, **kwargs: Any) -> None: ... @overload def failUnlessRaises(self, exception: _ExceptionType) -> _AssertRaisesContext: ... def failIf(self, expr: Any, msg: object = ...) -> None: ... def assertFalse(self, expr: Any, msg: object = ...) -> None: ... def assertIs(self, first: object, second: object, msg: object = ...) -> None: ... def assertIsNot(self, first: object, second: object, msg: object = ...) -> None: ... def assertIsNone(self, expr: Any, msg: object = ...) -> None: ... def assertIsNotNone(self, expr: Any, msg: object = ...) -> None: ... def assertIn(self, first: _T, second: Iterable[_T], msg: object = ...) -> None: ... def assertNotIn(self, first: _T, second: Iterable[_T], msg: object = ...) -> None: ... def assertIsInstance(self, obj: Any, cls: Union[type, Tuple[type, ...]], msg: object = ...) -> None: ... def assertNotIsInstance(self, obj: Any, cls: Union[type, Tuple[type, ...]], msg: object = ...) -> None: ... def fail(self, msg: object = ...) -> NoReturn: ... def countTestCases(self) -> int: ... def defaultTestResult(self) -> TestResult: ... def id(self) -> str: ... def shortDescription(self) -> str: ... # May return None def addCleanup(self, function: Any, *args: Any, **kwargs: Any) -> None: ... def doCleanups(self) -> bool: ... def skipTest(self, reason: Any) -> None: ... def _formatMessage(self, msg: Optional[Text], standardMsg: Text) -> str: ... # undocumented def _getAssertEqualityFunc(self, first: Any, second: Any) -> Callable[..., None]: ... # undocumented class FunctionTestCase(TestCase): def __init__( self, testFunc: Callable[[], None], setUp: Optional[Callable[[], None]] = ..., tearDown: Optional[Callable[[], None]] = ..., description: Optional[str] = ..., ) -> None: ... def debug(self) -> None: ... def countTestCases(self) -> int: ... class TestSuite(Testable): def __init__(self, tests: Iterable[Testable] = ...) -> None: ... def addTest(self, test: Testable) -> None: ... def addTests(self, tests: Iterable[Testable]) -> None: ... def run(self, result: TestResult) -> None: ... def debug(self) -> None: ... def countTestCases(self) -> int: ... def __iter__(self) -> Iterator[Testable]: ... class TestLoader: testMethodPrefix: str sortTestMethodsUsing: Optional[Callable[[str, str], int]] suiteClass: Callable[[List[TestCase]], TestSuite] def loadTestsFromTestCase(self, testCaseClass: Type[TestCase]) -> TestSuite: ... def loadTestsFromModule(self, module: types.ModuleType = ..., use_load_tests: bool = ...) -> TestSuite: ... def loadTestsFromName(self, name: str = ..., module: Optional[types.ModuleType] = ...) -> TestSuite: ... def loadTestsFromNames(self, names: List[str] = ..., module: Optional[types.ModuleType] = ...) -> TestSuite: ... def discover(self, start_dir: str, pattern: str = ..., top_level_dir: Optional[str] = ...) -> TestSuite: ... def getTestCaseNames(self, testCaseClass: Type[TestCase] = ...) -> List[str]: ... defaultTestLoader: TestLoader class TextTestResult(TestResult): def __init__(self, stream: TextIO, descriptions: bool, verbosity: int) -> None: ... def getDescription(self, test: TestCase) -> str: ... # undocumented def printErrors(self) -> None: ... # undocumented def printErrorList(self, flavour: str, errors: List[Tuple[TestCase, str]]) -> None: ... # undocumented class TextTestRunner: def __init__( self, stream: Optional[TextIO] = ..., descriptions: bool = ..., verbosity: int = ..., failfast: bool = ..., buffer: bool = ..., resultclass: Optional[Type[TestResult]] = ..., ) -> None: ... def _makeResult(self) -> TestResult: ... def run(self, test: Testable) -> TestResult: ... # undocumented class SkipTest(Exception): ... # TODO precise types def skipUnless(condition: Any, reason: Union[str, unicode]) -> Any: ... def skipIf(condition: Any, reason: Union[str, unicode]) -> Any: ... def expectedFailure(func: _FT) -> _FT: ... def skip(reason: Union[str, unicode]) -> Any: ... # not really documented class TestProgram: result: TestResult def runTests(self) -> None: ... # undocumented def main( module: Union[None, Text, types.ModuleType] = ..., defaultTest: Optional[str] = ..., argv: Optional[Sequence[str]] = ..., testRunner: Union[Type[TextTestRunner], TextTestRunner, None] = ..., testLoader: TestLoader = ..., exit: bool = ..., verbosity: int = ..., failfast: Optional[bool] = ..., catchbreak: Optional[bool] = ..., buffer: Optional[bool] = ..., ) -> TestProgram: ... def load_tests(loader: TestLoader, tests: TestSuite, pattern: Optional[Text]) -> TestSuite: ... def installHandler() -> None: ... def registerResult(result: TestResult) -> None: ... def removeResult(result: TestResult) -> bool: ... @overload def removeHandler() -> None: ... @overload def removeHandler(function: Callable[..., Any]) -> Callable[..., Any]: ... # private but occasionally used util: types.ModuleType ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/urllib.pyi0000664000175000017500000001123500000000000023131 0ustar00davedave00000000000000from typing import IO, Any, AnyStr, List, Mapping, Sequence, Text, Tuple, TypeVar, Union def url2pathname(pathname: AnyStr) -> AnyStr: ... def pathname2url(pathname: AnyStr) -> AnyStr: ... def urlopen(url: str, data=..., proxies: Mapping[str, str] = ..., context=...) -> IO[Any]: ... def urlretrieve(url, filename=..., reporthook=..., data=..., context=...): ... def urlcleanup() -> None: ... class ContentTooShortError(IOError): content: Any def __init__(self, message, content) -> None: ... class URLopener: version: Any proxies: Any key_file: Any cert_file: Any context: Any addheaders: Any tempcache: Any ftpcache: Any def __init__(self, proxies: Mapping[str, str] = ..., context=..., **x509) -> None: ... def __del__(self): ... def close(self): ... def cleanup(self): ... def addheader(self, *args): ... type: Any def open(self, fullurl: str, data=...): ... def open_unknown(self, fullurl, data=...): ... def open_unknown_proxy(self, proxy, fullurl, data=...): ... def retrieve(self, url, filename=..., reporthook=..., data=...): ... def open_http(self, url, data=...): ... def http_error(self, url, fp, errcode, errmsg, headers, data=...): ... def http_error_default(self, url, fp, errcode, errmsg, headers): ... def open_https(self, url, data=...): ... def open_file(self, url): ... def open_local_file(self, url): ... def open_ftp(self, url): ... def open_data(self, url, data=...): ... class FancyURLopener(URLopener): auth_cache: Any tries: Any maxtries: Any def __init__(self, *args, **kwargs) -> None: ... def http_error_default(self, url, fp, errcode, errmsg, headers): ... def http_error_302(self, url, fp, errcode, errmsg, headers, data=...): ... def redirect_internal(self, url, fp, errcode, errmsg, headers, data): ... def http_error_301(self, url, fp, errcode, errmsg, headers, data=...): ... def http_error_303(self, url, fp, errcode, errmsg, headers, data=...): ... def http_error_307(self, url, fp, errcode, errmsg, headers, data=...): ... def http_error_401(self, url, fp, errcode, errmsg, headers, data=...): ... def http_error_407(self, url, fp, errcode, errmsg, headers, data=...): ... def retry_proxy_http_basic_auth(self, url, realm, data=...): ... def retry_proxy_https_basic_auth(self, url, realm, data=...): ... def retry_http_basic_auth(self, url, realm, data=...): ... def retry_https_basic_auth(self, url, realm, data=...): ... def get_user_passwd(self, host, realm, clear_cache=...): ... def prompt_user_passwd(self, host, realm): ... class ftpwrapper: user: Any passwd: Any host: Any port: Any dirs: Any timeout: Any refcount: Any keepalive: Any def __init__(self, user, passwd, host, port, dirs, timeout=..., persistent=...) -> None: ... busy: Any ftp: Any def init(self): ... def retrfile(self, file, type): ... def endtransfer(self): ... def close(self): ... def file_close(self): ... def real_close(self): ... _AIUT = TypeVar("_AIUT", bound=addbase) class addbase: fp: Any def read(self, n: int = ...) -> bytes: ... def readline(self, limit: int = ...) -> bytes: ... def readlines(self, hint: int = ...) -> List[bytes]: ... def fileno(self) -> int: ... # Optional[int], but that is rare def __iter__(self: _AIUT) -> _AIUT: ... def next(self) -> bytes: ... def __init__(self, fp) -> None: ... def close(self) -> None: ... class addclosehook(addbase): closehook: Any hookargs: Any def __init__(self, fp, closehook, *hookargs) -> None: ... def close(self): ... class addinfo(addbase): headers: Any def __init__(self, fp, headers) -> None: ... def info(self): ... class addinfourl(addbase): headers: Any url: Any code: Any def __init__(self, fp, headers, url, code=...) -> None: ... def info(self): ... def getcode(self): ... def geturl(self): ... def unwrap(url): ... def splittype(url): ... def splithost(url): ... def splituser(host): ... def splitpasswd(user): ... def splitport(host): ... def splitnport(host, defport=...): ... def splitquery(url): ... def splittag(url): ... def splitattr(url): ... def splitvalue(attr): ... def unquote(s: AnyStr) -> AnyStr: ... def unquote_plus(s: AnyStr) -> AnyStr: ... def quote(s: AnyStr, safe: Text = ...) -> AnyStr: ... def quote_plus(s: AnyStr, safe: Text = ...) -> AnyStr: ... def urlencode(query: Union[Sequence[Tuple[Any, Any]], Mapping[Any, Any]], doseq=...) -> str: ... def getproxies() -> Mapping[str, str]: ... def proxy_bypass(host: str) -> Any: ... # Undocumented # Names in __all__ with no definition: # basejoin ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/urllib2.pyi0000664000175000017500000002017000000000000023211 0ustar00davedave00000000000000import ssl from httplib import HTTPConnectionProtocol, HTTPResponse from typing import Any, AnyStr, Callable, Dict, List, Mapping, Optional, Sequence, Text, Tuple, Type, Union from urllib import addinfourl _string = Union[str, unicode] class URLError(IOError): reason: Union[str, BaseException] class HTTPError(URLError, addinfourl): code: int headers: Mapping[str, str] def __init__(self, url, code: int, msg: str, hdrs: Mapping[str, str], fp: addinfourl) -> None: ... class Request(object): host: str port: str data: str headers: Dict[str, str] unverifiable: bool type: Optional[str] origin_req_host = ... unredirected_hdrs: Dict[str, str] def __init__( self, url: str, data: Optional[str] = ..., headers: Dict[str, str] = ..., origin_req_host: Optional[str] = ..., unverifiable: bool = ..., ) -> None: ... def __getattr__(self, attr): ... def get_method(self) -> str: ... def add_data(self, data) -> None: ... def has_data(self) -> bool: ... def get_data(self) -> str: ... def get_full_url(self) -> str: ... def get_type(self): ... def get_host(self) -> str: ... def get_selector(self): ... def set_proxy(self, host, type) -> None: ... def has_proxy(self) -> bool: ... def get_origin_req_host(self) -> str: ... def is_unverifiable(self) -> bool: ... def add_header(self, key: str, val: str) -> None: ... def add_unredirected_header(self, key: str, val: str) -> None: ... def has_header(self, header_name: str) -> bool: ... def get_header(self, header_name: str, default: Optional[str] = ...) -> str: ... def header_items(self): ... class OpenerDirector(object): addheaders: List[Tuple[str, str]] def add_handler(self, handler: BaseHandler) -> None: ... def open( self, fullurl: Union[Request, _string], data: Optional[_string] = ..., timeout: Optional[float] = ... ) -> Optional[addinfourl]: ... def error(self, proto: _string, *args: Any): ... # Note that this type is somewhat a lie. The return *can* be None if # a custom opener has been installed that fails to handle the request. def urlopen( url: Union[Request, _string], data: Optional[_string] = ..., timeout: Optional[float] = ..., cafile: Optional[_string] = ..., capath: Optional[_string] = ..., cadefault: bool = ..., context: Optional[ssl.SSLContext] = ..., ) -> addinfourl: ... def install_opener(opener: OpenerDirector) -> None: ... def build_opener(*handlers: Union[BaseHandler, Type[BaseHandler]]) -> OpenerDirector: ... class BaseHandler: handler_order: int parent: OpenerDirector def add_parent(self, parent: OpenerDirector) -> None: ... def close(self) -> None: ... def __lt__(self, other: Any) -> bool: ... class HTTPErrorProcessor(BaseHandler): def http_response(self, request, response): ... class HTTPDefaultErrorHandler(BaseHandler): def http_error_default(self, req: Request, fp: addinfourl, code: int, msg: str, hdrs: Mapping[str, str]): ... class HTTPRedirectHandler(BaseHandler): max_repeats: int max_redirections: int def redirect_request(self, req: Request, fp: addinfourl, code: int, msg: str, headers: Mapping[str, str], newurl): ... def http_error_301(self, req: Request, fp: addinfourl, code: int, msg: str, headers: Mapping[str, str]): ... def http_error_302(self, req: Request, fp: addinfourl, code: int, msg: str, headers: Mapping[str, str]): ... def http_error_303(self, req: Request, fp: addinfourl, code: int, msg: str, headers: Mapping[str, str]): ... def http_error_307(self, req: Request, fp: addinfourl, code: int, msg: str, headers: Mapping[str, str]): ... inf_msg: str class ProxyHandler(BaseHandler): proxies: Mapping[str, str] def __init__(self, proxies: Optional[Mapping[str, str]] = ...): ... def proxy_open(self, req: Request, proxy, type): ... class HTTPPasswordMgr: def __init__(self) -> None: ... def add_password(self, realm: Optional[Text], uri: Union[Text, Sequence[Text]], user: Text, passwd: Text) -> None: ... def find_user_password(self, realm: Optional[Text], authuri: Text) -> Tuple[Any, Any]: ... def reduce_uri(self, uri: _string, default_port: bool = ...) -> Tuple[Any, Any]: ... def is_suburi(self, base: _string, test: _string) -> bool: ... class HTTPPasswordMgrWithDefaultRealm(HTTPPasswordMgr): ... class AbstractBasicAuthHandler: def __init__(self, password_mgr: Optional[HTTPPasswordMgr] = ...) -> None: ... def add_password(self, realm: Optional[Text], uri: Union[Text, Sequence[Text]], user: Text, passwd: Text) -> None: ... def http_error_auth_reqed(self, authreq, host, req: Request, headers: Mapping[str, str]): ... def retry_http_basic_auth(self, host, req: Request, realm): ... class HTTPBasicAuthHandler(AbstractBasicAuthHandler, BaseHandler): auth_header: str def http_error_401(self, req: Request, fp: addinfourl, code: int, msg: str, headers: Mapping[str, str]): ... class ProxyBasicAuthHandler(AbstractBasicAuthHandler, BaseHandler): auth_header: str def http_error_407(self, req: Request, fp: addinfourl, code: int, msg: str, headers: Mapping[str, str]): ... class AbstractDigestAuthHandler: def __init__(self, passwd: Optional[HTTPPasswordMgr] = ...) -> None: ... def add_password(self, realm: Optional[Text], uri: Union[Text, Sequence[Text]], user: Text, passwd: Text) -> None: ... def reset_retry_count(self) -> None: ... def http_error_auth_reqed(self, auth_header: str, host: str, req: Request, headers: Mapping[str, str]) -> None: ... def retry_http_digest_auth(self, req: Request, auth: str) -> Optional[HTTPResponse]: ... def get_cnonce(self, nonce: str) -> str: ... def get_authorization(self, req: Request, chal: Mapping[str, str]) -> str: ... def get_algorithm_impls(self, algorithm: str) -> Tuple[Callable[[str], str], Callable[[str, str], str]]: ... def get_entity_digest(self, data: Optional[bytes], chal: Mapping[str, str]) -> Optional[str]: ... class HTTPDigestAuthHandler(BaseHandler, AbstractDigestAuthHandler): auth_header: str handler_order: int def http_error_401(self, req: Request, fp: addinfourl, code: int, msg: str, headers: Mapping[str, str]): ... class ProxyDigestAuthHandler(BaseHandler, AbstractDigestAuthHandler): auth_header: str handler_order: int def http_error_407(self, req: Request, fp: addinfourl, code: int, msg: str, headers: Mapping[str, str]): ... class AbstractHTTPHandler(BaseHandler): # undocumented def __init__(self, debuglevel: int = ...) -> None: ... def set_http_debuglevel(self, level: int) -> None: ... def do_request_(self, request: Request) -> Request: ... def do_open(self, http_class: HTTPConnectionProtocol, req: Request, **http_conn_args: Optional[Any]) -> addinfourl: ... class HTTPHandler(AbstractHTTPHandler): def http_open(self, req: Request) -> addinfourl: ... def http_request(self, request: Request) -> Request: ... # undocumented class HTTPSHandler(AbstractHTTPHandler): def __init__(self, debuglevel: int = ..., context: Optional[ssl.SSLContext] = ...) -> None: ... def https_open(self, req: Request) -> addinfourl: ... def https_request(self, request: Request) -> Request: ... # undocumented class HTTPCookieProcessor(BaseHandler): def __init__(self, cookiejar: Optional[Any] = ...): ... def http_request(self, request: Request): ... def http_response(self, request: Request, response): ... class UnknownHandler(BaseHandler): def unknown_open(self, req: Request): ... class FileHandler(BaseHandler): def file_open(self, req: Request): ... def get_names(self): ... def open_local_file(self, req: Request): ... class FTPHandler(BaseHandler): def ftp_open(self, req: Request): ... def connect_ftp(self, user, passwd, host, port, dirs, timeout): ... class CacheFTPHandler(FTPHandler): def __init__(self) -> None: ... def setTimeout(self, t: Optional[float]): ... def setMaxConns(self, m: int): ... def check_cache(self): ... def clear_cache(self): ... def parse_http_list(s: AnyStr) -> List[AnyStr]: ... def parse_keqv_list(l: List[AnyStr]) -> Dict[AnyStr, AnyStr]: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/urlparse.pyi0000664000175000017500000000363000000000000023475 0ustar00davedave00000000000000from typing import AnyStr, Dict, List, NamedTuple, Optional, Sequence, Tuple, Union, overload _String = Union[str, unicode] uses_relative: List[str] uses_netloc: List[str] uses_params: List[str] non_hierarchical: List[str] uses_query: List[str] uses_fragment: List[str] scheme_chars: str MAX_CACHE_SIZE: int def clear_cache() -> None: ... class ResultMixin(object): @property def username(self) -> Optional[str]: ... @property def password(self) -> Optional[str]: ... @property def hostname(self) -> Optional[str]: ... @property def port(self) -> Optional[int]: ... class _SplitResult(NamedTuple): scheme: str netloc: str path: str query: str fragment: str class SplitResult(_SplitResult, ResultMixin): def geturl(self) -> str: ... class _ParseResult(NamedTuple): scheme: str netloc: str path: str params: str query: str fragment: str class ParseResult(_ParseResult, ResultMixin): def geturl(self) -> _String: ... def urlparse(url: _String, scheme: _String = ..., allow_fragments: bool = ...) -> ParseResult: ... def urlsplit(url: _String, scheme: _String = ..., allow_fragments: bool = ...) -> SplitResult: ... @overload def urlunparse(data: Tuple[AnyStr, AnyStr, AnyStr, AnyStr, AnyStr, AnyStr]) -> AnyStr: ... @overload def urlunparse(data: Sequence[AnyStr]) -> AnyStr: ... @overload def urlunsplit(data: Tuple[AnyStr, AnyStr, AnyStr, AnyStr, AnyStr]) -> AnyStr: ... @overload def urlunsplit(data: Sequence[AnyStr]) -> AnyStr: ... def urljoin(base: AnyStr, url: AnyStr, allow_fragments: bool = ...) -> AnyStr: ... def urldefrag(url: AnyStr) -> Tuple[AnyStr, AnyStr]: ... def unquote(s: AnyStr) -> AnyStr: ... def parse_qs(qs: AnyStr, keep_blank_values: bool = ..., strict_parsing: bool = ...) -> Dict[AnyStr, List[AnyStr]]: ... def parse_qsl(qs: AnyStr, keep_blank_values: int = ..., strict_parsing: bool = ...) -> List[Tuple[AnyStr, AnyStr]]: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/user.pyi0000664000175000017500000000012300000000000022610 0ustar00davedave00000000000000from typing import Any def __getattr__(name) -> Any: ... home: str pythonrc: str ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/whichdb.pyi0000664000175000017500000000012500000000000023244 0ustar00davedave00000000000000from typing import Optional, Text def whichdb(filename: Text) -> Optional[str]: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2/xmlrpclib.pyi0000664000175000017500000002305100000000000023633 0ustar00davedave00000000000000from datetime import datetime from gzip import GzipFile from httplib import HTTPConnection, HTTPResponse, HTTPSConnection from ssl import SSLContext from StringIO import StringIO from time import struct_time from types import InstanceType from typing import IO, Any, AnyStr, Callable, Iterable, List, Mapping, MutableMapping, Optional, Tuple, Type, TypeVar, Union _Unmarshaller = Any _timeTuple = Tuple[int, int, int, int, int, int, int, int, int] # Represents types that can be compared against a DateTime object _dateTimeComp = Union[unicode, DateTime, datetime] # A "host description" used by Transport factories _hostDesc = Union[str, Tuple[str, Mapping[Any, Any]]] def escape(s: AnyStr, replace: Callable[[AnyStr, AnyStr, AnyStr], AnyStr] = ...) -> AnyStr: ... MAXINT: int MININT: int PARSE_ERROR: int SERVER_ERROR: int APPLICATION_ERROR: int SYSTEM_ERROR: int TRANSPORT_ERROR: int NOT_WELLFORMED_ERROR: int UNSUPPORTED_ENCODING: int INVALID_ENCODING_CHAR: int INVALID_XMLRPC: int METHOD_NOT_FOUND: int INVALID_METHOD_PARAMS: int INTERNAL_ERROR: int class Error(Exception): ... class ProtocolError(Error): url: str errcode: int errmsg: str headers: Any def __init__(self, url: str, errcode: int, errmsg: str, headers: Any) -> None: ... class ResponseError(Error): ... class Fault(Error): faultCode: Any faultString: str def __init__(self, faultCode: Any, faultString: str, **extra: Any) -> None: ... boolean: Type[bool] Boolean: Type[bool] class DateTime: value: str def __init__(self, value: Union[str, unicode, datetime, float, int, _timeTuple, struct_time] = ...) -> None: ... def make_comparable(self, other: _dateTimeComp) -> Tuple[unicode, unicode]: ... def __lt__(self, other: _dateTimeComp) -> bool: ... def __le__(self, other: _dateTimeComp) -> bool: ... def __gt__(self, other: _dateTimeComp) -> bool: ... def __ge__(self, other: _dateTimeComp) -> bool: ... def __eq__(self, other: _dateTimeComp) -> bool: ... # type: ignore def __ne__(self, other: _dateTimeComp) -> bool: ... # type: ignore def timetuple(self) -> struct_time: ... def __cmp__(self, other: _dateTimeComp) -> int: ... def decode(self, data: Any) -> None: ... def encode(self, out: IO[str]) -> None: ... class Binary: data: str def __init__(self, data: Optional[str] = ...) -> None: ... def __cmp__(self, other: Any) -> int: ... def decode(self, data: str) -> None: ... def encode(self, out: IO[str]) -> None: ... WRAPPERS: Tuple[Type[Any], ...] # Still part of the public API, but see http://bugs.python.org/issue1773632 FastParser: None FastUnmarshaller: None FastMarshaller: None # xmlrpclib.py will leave ExpatParser undefined if it can't import expat from # xml.parsers. Because this is Python 2.7, the import will succeed. class ExpatParser: def __init__(self, target: _Unmarshaller) -> None: ... def feed(self, data: str): ... def close(self): ... # TODO: Add xmllib.XMLParser as base class class SlowParser: handle_xml: Callable[[str, bool], None] unknown_starttag: Callable[[str, Any], None] handle_data: Callable[[str], None] handle_cdata: Callable[[str], None] unknown_endtag: Callable[[str, Callable[[Iterable[str], str], str]], None] def __init__(self, target: _Unmarshaller) -> None: ... class Marshaller: memo: MutableMapping[int, Any] data: Optional[str] encoding: Optional[str] allow_none: bool def __init__(self, encoding: Optional[str] = ..., allow_none: bool = ...) -> None: ... dispatch: Mapping[type, Callable[[Marshaller, str, Callable[[str], None]], None]] def dumps( self, values: Union[ Iterable[ Union[ None, int, bool, long, float, str, unicode, List[Any], Tuple[Any, ...], Mapping[Any, Any], datetime, InstanceType, ] ], Fault, ], ) -> str: ... def dump_nil(self, value: None, write: Callable[[str], None]) -> None: ... def dump_int(self, value: int, write: Callable[[str], None]) -> None: ... def dump_bool(self, value: bool, write: Callable[[str], None]) -> None: ... def dump_long(self, value: long, write: Callable[[str], None]) -> None: ... def dump_double(self, value: float, write: Callable[[str], None]) -> None: ... def dump_string( self, value: str, write: Callable[[str], None], escape: Callable[[AnyStr, Callable[[AnyStr, AnyStr, AnyStr], AnyStr]], AnyStr] = ..., ) -> None: ... def dump_unicode( self, value: unicode, write: Callable[[str], None], escape: Callable[[AnyStr, Callable[[AnyStr, AnyStr, AnyStr], AnyStr]], AnyStr] = ..., ) -> None: ... def dump_array(self, value: Iterable[Any], write: Callable[[str], None]) -> None: ... def dump_struct( self, value: Mapping[unicode, Any], write: Callable[[str], None], escape: Callable[[AnyStr, Callable[[AnyStr, AnyStr, AnyStr], AnyStr]], AnyStr] = ..., ) -> None: ... def dump_datetime(self, value: datetime, write: Callable[[str], None]) -> None: ... def dump_instance(self, value: InstanceType, write: Callable[[str], None]) -> None: ... class Unmarshaller: def append(self, object: Any) -> None: ... def __init__(self, use_datetime: bool = ...) -> None: ... def close(self) -> Tuple[Any, ...]: ... def getmethodname(self) -> Optional[str]: ... def xml(self, encoding: str, standalone: bool) -> None: ... def start(self, tag: str, attrs: Any) -> None: ... def data(self, text: str) -> None: ... def end(self, tag: str, join: Callable[[Iterable[str], str], str] = ...) -> None: ... def end_dispatch(self, tag: str, data: str) -> None: ... dispatch: Mapping[str, Callable[[Unmarshaller, str], None]] def end_nil(self, data: str): ... def end_boolean(self, data: str) -> None: ... def end_int(self, data: str) -> None: ... def end_double(self, data: str) -> None: ... def end_string(self, data: str) -> None: ... def end_array(self, data: str) -> None: ... def end_struct(self, data: str) -> None: ... def end_base64(self, data: str) -> None: ... def end_dateTime(self, data: str) -> None: ... def end_value(self, data: str) -> None: ... def end_params(self, data: str) -> None: ... def end_fault(self, data: str) -> None: ... def end_methodName(self, data: str) -> None: ... class _MultiCallMethod: def __init__(self, call_list: List[Tuple[str, Tuple[Any, ...]]], name: str) -> None: ... class MultiCallIterator: def __init__(self, results: List[Any]) -> None: ... class MultiCall: def __init__(self, server: ServerProxy) -> None: ... def __getattr__(self, name: str) -> _MultiCallMethod: ... def __call__(self) -> MultiCallIterator: ... def getparser(use_datetime: bool = ...) -> Tuple[Union[ExpatParser, SlowParser], Unmarshaller]: ... def dumps( params: Union[Tuple[Any, ...], Fault], methodname: Optional[str] = ..., methodresponse: Optional[bool] = ..., encoding: Optional[str] = ..., allow_none: bool = ..., ) -> str: ... def loads(data: str, use_datetime: bool = ...) -> Tuple[Tuple[Any, ...], Optional[str]]: ... def gzip_encode(data: str) -> str: ... def gzip_decode(data: str, max_decode: int = ...) -> str: ... class GzipDecodedResponse(GzipFile): stringio: StringIO[Any] def __init__(self, response: HTTPResponse) -> None: ... def close(self): ... class _Method: def __init__(self, send: Callable[[str, Tuple[Any, ...]], Any], name: str) -> None: ... def __getattr__(self, name: str) -> _Method: ... def __call__(self, *args: Any) -> Any: ... class Transport: user_agent: str accept_gzip_encoding: bool encode_threshold: Optional[int] def __init__(self, use_datetime: bool = ...) -> None: ... def request(self, host: _hostDesc, handler: str, request_body: str, verbose: bool = ...) -> Tuple[Any, ...]: ... verbose: bool def single_request(self, host: _hostDesc, handler: str, request_body: str, verbose: bool = ...) -> Tuple[Any, ...]: ... def getparser(self) -> Tuple[Union[ExpatParser, SlowParser], Unmarshaller]: ... def get_host_info(self, host: _hostDesc) -> Tuple[str, Optional[List[Tuple[str, str]]], Optional[Mapping[Any, Any]]]: ... def make_connection(self, host: _hostDesc) -> HTTPConnection: ... def close(self) -> None: ... def send_request(self, connection: HTTPConnection, handler: str, request_body: str) -> None: ... def send_host(self, connection: HTTPConnection, host: str) -> None: ... def send_user_agent(self, connection: HTTPConnection) -> None: ... def send_content(self, connection: HTTPConnection, request_body: str) -> None: ... def parse_response(self, response: HTTPResponse) -> Tuple[Any, ...]: ... class SafeTransport(Transport): def __init__(self, use_datetime: bool = ..., context: Optional[SSLContext] = ...) -> None: ... def make_connection(self, host: _hostDesc) -> HTTPSConnection: ... class ServerProxy: def __init__( self, uri: str, transport: Optional[Transport] = ..., encoding: Optional[str] = ..., verbose: bool = ..., allow_none: bool = ..., use_datetime: bool = ..., context: Optional[SSLContext] = ..., ) -> None: ... def __getattr__(self, name: str) -> _Method: ... def __call__(self, attr: str) -> Optional[Transport]: ... Server = ServerProxy ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4223793 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/0000775000175000017500000000000000000000000021661 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/__future__.pyi0000664000175000017500000000111300000000000024506 0ustar00davedave00000000000000import sys from typing import List class _Feature: def getOptionalRelease(self) -> sys._version_info: ... def getMandatoryRelease(self) -> sys._version_info: ... compiler_flag: int absolute_import: _Feature division: _Feature generators: _Feature nested_scopes: _Feature print_function: _Feature unicode_literals: _Feature with_statement: _Feature if sys.version_info >= (3, 0): barry_as_FLUFL: _Feature if sys.version_info >= (3, 5): generator_stop: _Feature if sys.version_info >= (3, 7): annotations: _Feature all_feature_names: List[str] # undocumented ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/_bisect.pyi0000664000175000017500000000072700000000000024022 0ustar00davedave00000000000000from typing import MutableSequence, Optional, Sequence, TypeVar _T = TypeVar("_T") def bisect_left(a: Sequence[_T], x: _T, lo: int = ..., hi: Optional[int] = ...) -> int: ... def bisect_right(a: Sequence[_T], x: _T, lo: int = ..., hi: Optional[int] = ...) -> int: ... def insort_left(a: MutableSequence[_T], x: _T, lo: int = ..., hi: Optional[int] = ...) -> None: ... def insort_right(a: MutableSequence[_T], x: _T, lo: int = ..., hi: Optional[int] = ...) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/_codecs.pyi0000664000175000017500000001227400000000000024011 0ustar00davedave00000000000000import codecs import sys from typing import Any, Callable, Dict, Optional, Text, Tuple, Union # For convenience: _Handler = Callable[[Exception], Tuple[Text, int]] _String = Union[bytes, str] _Errors = Union[str, Text, None] if sys.version_info < (3, 0): _Decodable = Union[bytes, Text] _Encodable = Union[bytes, Text] else: _Decodable = bytes _Encodable = str # This type is not exposed; it is defined in unicodeobject.c class _EncodingMap(object): def size(self) -> int: ... _MapT = Union[Dict[int, int], _EncodingMap] def register(__search_function: Callable[[str], Any]) -> None: ... def register_error(__errors: Union[str, Text], __handler: _Handler) -> None: ... def lookup(__encoding: Union[str, Text]) -> codecs.CodecInfo: ... def lookup_error(__name: Union[str, Text]) -> _Handler: ... def decode(obj: Any, encoding: Union[str, Text] = ..., errors: _Errors = ...) -> Any: ... def encode(obj: Any, encoding: Union[str, Text] = ..., errors: _Errors = ...) -> Any: ... def charmap_build(__map: Text) -> _MapT: ... def ascii_decode(__data: _Decodable, __errors: _Errors = ...) -> Tuple[Text, int]: ... def ascii_encode(__str: _Encodable, __errors: _Errors = ...) -> Tuple[bytes, int]: ... if sys.version_info < (3, 2): def charbuffer_encode(__data: _Encodable, __errors: _Errors = ...) -> Tuple[bytes, int]: ... def charmap_decode(__data: _Decodable, __errors: _Errors = ..., __mapping: Optional[_MapT] = ...) -> Tuple[Text, int]: ... def charmap_encode(__str: _Encodable, __errors: _Errors = ..., __mapping: Optional[_MapT] = ...) -> Tuple[bytes, int]: ... def escape_decode(__data: _String, __errors: _Errors = ...) -> Tuple[str, int]: ... def escape_encode(__data: bytes, __errors: _Errors = ...) -> Tuple[bytes, int]: ... def latin_1_decode(__data: _Decodable, __errors: _Errors = ...) -> Tuple[Text, int]: ... def latin_1_encode(__str: _Encodable, __errors: _Errors = ...) -> Tuple[bytes, int]: ... def raw_unicode_escape_decode(__data: _String, __errors: _Errors = ...) -> Tuple[Text, int]: ... def raw_unicode_escape_encode(__str: _Encodable, __errors: _Errors = ...) -> Tuple[bytes, int]: ... def readbuffer_encode(__data: _String, __errors: _Errors = ...) -> Tuple[bytes, int]: ... def unicode_escape_decode(__data: _String, __errors: _Errors = ...) -> Tuple[Text, int]: ... def unicode_escape_encode(__str: _Encodable, __errors: _Errors = ...) -> Tuple[bytes, int]: ... if sys.version_info < (3, 8): def unicode_internal_decode(__obj: _String, __errors: _Errors = ...) -> Tuple[Text, int]: ... def unicode_internal_encode(__obj: _String, __errors: _Errors = ...) -> Tuple[bytes, int]: ... def utf_16_be_decode(__data: _Decodable, __errors: _Errors = ..., __final: int = ...) -> Tuple[Text, int]: ... def utf_16_be_encode(__str: _Encodable, __errors: _Errors = ...) -> Tuple[bytes, int]: ... def utf_16_decode(__data: _Decodable, __errors: _Errors = ..., __final: int = ...) -> Tuple[Text, int]: ... def utf_16_encode(__str: _Encodable, __errors: _Errors = ..., __byteorder: int = ...) -> Tuple[bytes, int]: ... def utf_16_ex_decode( __data: _Decodable, __errors: _Errors = ..., __byteorder: int = ..., __final: int = ... ) -> Tuple[Text, int, int]: ... def utf_16_le_decode(__data: _Decodable, __errors: _Errors = ..., __final: int = ...) -> Tuple[Text, int]: ... def utf_16_le_encode(__str: _Encodable, __errors: _Errors = ...) -> Tuple[bytes, int]: ... def utf_32_be_decode(__data: _Decodable, __errors: _Errors = ..., __final: int = ...) -> Tuple[Text, int]: ... def utf_32_be_encode(__str: _Encodable, __errors: _Errors = ...) -> Tuple[bytes, int]: ... def utf_32_decode(__data: _Decodable, __errors: _Errors = ..., __final: int = ...) -> Tuple[Text, int]: ... def utf_32_encode(__str: _Encodable, __errors: _Errors = ..., __byteorder: int = ...) -> Tuple[bytes, int]: ... def utf_32_ex_decode( __data: _Decodable, __errors: _Errors = ..., __byteorder: int = ..., __final: int = ... ) -> Tuple[Text, int, int]: ... def utf_32_le_decode(__data: _Decodable, __errors: _Errors = ..., __final: int = ...) -> Tuple[Text, int]: ... def utf_32_le_encode(__str: _Encodable, __errors: _Errors = ...) -> Tuple[bytes, int]: ... def utf_7_decode(__data: _Decodable, __errors: _Errors = ..., __final: int = ...) -> Tuple[Text, int]: ... def utf_7_encode(__str: _Encodable, __errors: _Errors = ...) -> Tuple[bytes, int]: ... def utf_8_decode(__data: _Decodable, __errors: _Errors = ..., __final: int = ...) -> Tuple[Text, int]: ... def utf_8_encode(__str: _Encodable, __errors: _Errors = ...) -> Tuple[bytes, int]: ... if sys.platform == "win32": def mbcs_decode(__data: _Decodable, __errors: _Errors = ..., __final: int = ...) -> Tuple[Text, int]: ... def mbcs_encode(__str: _Encodable, __errors: _Errors = ...) -> Tuple[bytes, int]: ... if sys.version_info >= (3, 0): def code_page_decode(__codepage: int, __data: bytes, __errors: _Errors = ..., __final: int = ...) -> Tuple[Text, int]: ... def code_page_encode(__code_page: int, __str: Text, __errors: _Errors = ...) -> Tuple[bytes, int]: ... if sys.version_info >= (3, 6): def oem_decode(__data: bytes, __errors: _Errors = ..., __final: int = ...) -> Tuple[Text, int]: ... def oem_encode(__str: Text, __errors: _Errors = ...) -> Tuple[bytes, int]: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/_csv.pyi0000664000175000017500000000304600000000000023341 0ustar00davedave00000000000000import sys from typing import Any, Iterable, Iterator, List, Optional, Protocol, Sequence, Text, Type, Union QUOTE_ALL: int QUOTE_MINIMAL: int QUOTE_NONE: int QUOTE_NONNUMERIC: int class Error(Exception): ... class Dialect: delimiter: str quotechar: Optional[str] escapechar: Optional[str] doublequote: bool skipinitialspace: bool lineterminator: str quoting: int strict: int def __init__(self) -> None: ... _DialectLike = Union[str, Dialect, Type[Dialect]] class _reader(Iterator[List[str]]): dialect: Dialect line_num: int if sys.version_info >= (3, 0): def __next__(self) -> List[str]: ... else: def next(self) -> List[str]: ... class _writer: dialect: Dialect if sys.version_info >= (3, 5): def writerow(self, row: Iterable[Any]) -> Any: ... def writerows(self, rows: Iterable[Iterable[Any]]) -> None: ... else: def writerow(self, row: Sequence[Any]) -> Any: ... def writerows(self, rows: Iterable[Sequence[Any]]) -> None: ... class _Writer(Protocol): def write(self, s: str) -> Any: ... def writer(csvfile: _Writer, dialect: _DialectLike = ..., **fmtparams: Any) -> _writer: ... def reader(csvfile: Iterable[Text], dialect: _DialectLike = ..., **fmtparams: Any) -> _reader: ... def register_dialect(name: str, dialect: Any = ..., **fmtparams: Any) -> None: ... def unregister_dialect(name: str) -> None: ... def get_dialect(name: str) -> Dialect: ... def list_dialects() -> List[str]: ... def field_size_limit(new_limit: int = ...) -> int: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/_curses.pyi0000664000175000017500000003243400000000000024055 0ustar00davedave00000000000000import sys from typing import IO, Any, BinaryIO, NamedTuple, Optional, Tuple, Union, overload _chtype = Union[str, bytes, int] ALL_MOUSE_EVENTS: int A_ALTCHARSET: int A_ATTRIBUTES: int A_BLINK: int A_BOLD: int A_CHARTEXT: int A_COLOR: int A_DIM: int A_HORIZONTAL: int A_INVIS: int if sys.version_info >= (3, 7): A_ITALIC: int A_LEFT: int A_LOW: int A_NORMAL: int A_PROTECT: int A_REVERSE: int A_RIGHT: int A_STANDOUT: int A_TOP: int A_UNDERLINE: int A_VERTICAL: int BUTTON1_CLICKED: int BUTTON1_DOUBLE_CLICKED: int BUTTON1_PRESSED: int BUTTON1_RELEASED: int BUTTON1_TRIPLE_CLICKED: int BUTTON2_CLICKED: int BUTTON2_DOUBLE_CLICKED: int BUTTON2_PRESSED: int BUTTON2_RELEASED: int BUTTON2_TRIPLE_CLICKED: int BUTTON3_CLICKED: int BUTTON3_DOUBLE_CLICKED: int BUTTON3_PRESSED: int BUTTON3_RELEASED: int BUTTON3_TRIPLE_CLICKED: int BUTTON4_CLICKED: int BUTTON4_DOUBLE_CLICKED: int BUTTON4_PRESSED: int BUTTON4_RELEASED: int BUTTON4_TRIPLE_CLICKED: int BUTTON_ALT: int BUTTON_CTRL: int BUTTON_SHIFT: int COLOR_BLACK: int COLOR_BLUE: int COLOR_CYAN: int COLOR_GREEN: int COLOR_MAGENTA: int COLOR_RED: int COLOR_WHITE: int COLOR_YELLOW: int ERR: int KEY_A1: int KEY_A3: int KEY_B2: int KEY_BACKSPACE: int KEY_BEG: int KEY_BREAK: int KEY_BTAB: int KEY_C1: int KEY_C3: int KEY_CANCEL: int KEY_CATAB: int KEY_CLEAR: int KEY_CLOSE: int KEY_COMMAND: int KEY_COPY: int KEY_CREATE: int KEY_CTAB: int KEY_DC: int KEY_DL: int KEY_DOWN: int KEY_EIC: int KEY_END: int KEY_ENTER: int KEY_EOL: int KEY_EOS: int KEY_EXIT: int KEY_F0: int KEY_F1: int KEY_F10: int KEY_F11: int KEY_F12: int KEY_F13: int KEY_F14: int KEY_F15: int KEY_F16: int KEY_F17: int KEY_F18: int KEY_F19: int KEY_F2: int KEY_F20: int KEY_F21: int KEY_F22: int KEY_F23: int KEY_F24: int KEY_F25: int KEY_F26: int KEY_F27: int KEY_F28: int KEY_F29: int KEY_F3: int KEY_F30: int KEY_F31: int KEY_F32: int KEY_F33: int KEY_F34: int KEY_F35: int KEY_F36: int KEY_F37: int KEY_F38: int KEY_F39: int KEY_F4: int KEY_F40: int KEY_F41: int KEY_F42: int KEY_F43: int KEY_F44: int KEY_F45: int KEY_F46: int KEY_F47: int KEY_F48: int KEY_F49: int KEY_F5: int KEY_F50: int KEY_F51: int KEY_F52: int KEY_F53: int KEY_F54: int KEY_F55: int KEY_F56: int KEY_F57: int KEY_F58: int KEY_F59: int KEY_F6: int KEY_F60: int KEY_F61: int KEY_F62: int KEY_F63: int KEY_F7: int KEY_F8: int KEY_F9: int KEY_FIND: int KEY_HELP: int KEY_HOME: int KEY_IC: int KEY_IL: int KEY_LEFT: int KEY_LL: int KEY_MARK: int KEY_MAX: int KEY_MESSAGE: int KEY_MIN: int KEY_MOUSE: int KEY_MOVE: int KEY_NEXT: int KEY_NPAGE: int KEY_OPEN: int KEY_OPTIONS: int KEY_PPAGE: int KEY_PREVIOUS: int KEY_PRINT: int KEY_REDO: int KEY_REFERENCE: int KEY_REFRESH: int KEY_REPLACE: int KEY_RESET: int KEY_RESIZE: int KEY_RESTART: int KEY_RESUME: int KEY_RIGHT: int KEY_SAVE: int KEY_SBEG: int KEY_SCANCEL: int KEY_SCOMMAND: int KEY_SCOPY: int KEY_SCREATE: int KEY_SDC: int KEY_SDL: int KEY_SELECT: int KEY_SEND: int KEY_SEOL: int KEY_SEXIT: int KEY_SF: int KEY_SFIND: int KEY_SHELP: int KEY_SHOME: int KEY_SIC: int KEY_SLEFT: int KEY_SMESSAGE: int KEY_SMOVE: int KEY_SNEXT: int KEY_SOPTIONS: int KEY_SPREVIOUS: int KEY_SPRINT: int KEY_SR: int KEY_SREDO: int KEY_SREPLACE: int KEY_SRESET: int KEY_SRIGHT: int KEY_SRSUME: int KEY_SSAVE: int KEY_SSUSPEND: int KEY_STAB: int KEY_SUNDO: int KEY_SUSPEND: int KEY_UNDO: int KEY_UP: int OK: int REPORT_MOUSE_POSITION: int _C_API: Any version: bytes def baudrate() -> int: ... def beep() -> None: ... def can_change_color() -> bool: ... def cbreak(__flag: bool = ...) -> None: ... def color_content(__color_number: int) -> Tuple[int, int, int]: ... def color_pair(__color_number: int) -> int: ... def curs_set(__visibility: int) -> int: ... def def_prog_mode() -> None: ... def def_shell_mode() -> None: ... def delay_output(__ms: int) -> None: ... def doupdate() -> None: ... def echo(__flag: bool = ...) -> None: ... def endwin() -> None: ... def erasechar() -> bytes: ... def filter() -> None: ... def flash() -> None: ... def flushinp() -> None: ... def getmouse() -> Tuple[int, int, int, int, int]: ... def getsyx() -> Tuple[int, int]: ... def getwin(__file: BinaryIO) -> _CursesWindow: ... def halfdelay(__tenths: int) -> None: ... def has_colors() -> bool: ... def has_ic() -> bool: ... def has_il() -> bool: ... def has_key(__key: int) -> bool: ... def init_color(__color_number: int, __r: int, __g: int, __b: int) -> None: ... def init_pair(__pair_number: int, __fg: int, __bg: int) -> None: ... def initscr() -> _CursesWindow: ... def intrflush(__flag: bool) -> None: ... def is_term_resized(__nlines: int, __ncols: int) -> bool: ... def isendwin() -> bool: ... def keyname(__key: int) -> bytes: ... def killchar() -> bytes: ... def longname() -> bytes: ... def meta(__yes: bool) -> None: ... def mouseinterval(__interval: int) -> None: ... def mousemask(__newmask: int) -> Tuple[int, int]: ... def napms(__ms: int) -> int: ... def newpad(__nlines: int, __ncols: int) -> _CursesWindow: ... def newwin(__nlines: int, __ncols: int, __begin_y: int = ..., __begin_x: int = ...) -> _CursesWindow: ... def nl(__flag: bool = ...) -> None: ... def nocbreak() -> None: ... def noecho() -> None: ... def nonl() -> None: ... def noqiflush() -> None: ... def noraw() -> None: ... def pair_content(__pair_number: int) -> Tuple[int, int]: ... def pair_number(__attr: int) -> int: ... def putp(__string: bytes) -> None: ... def qiflush(__flag: bool = ...) -> None: ... def raw(__flag: bool = ...) -> None: ... def reset_prog_mode() -> None: ... def reset_shell_mode() -> None: ... def resetty() -> None: ... def resize_term(__nlines: int, __ncols: int) -> None: ... def resizeterm(__nlines: int, __ncols: int) -> None: ... def savetty() -> None: ... def setsyx(__y: int, __x: int) -> None: ... def setupterm(term: Optional[str] = ..., fd: int = ...) -> None: ... def start_color() -> None: ... def termattrs() -> int: ... def termname() -> bytes: ... def tigetflag(__capname: str) -> int: ... def tigetnum(__capname: str) -> int: ... def tigetstr(__capname: str) -> bytes: ... def tparm( __str: bytes, __i1: int = ..., __i2: int = ..., __i3: int = ..., __i4: int = ..., __i5: int = ..., __i6: int = ..., __i7: int = ..., __i8: int = ..., __i9: int = ..., ) -> bytes: ... def typeahead(__fd: int) -> None: ... def unctrl(__ch: _chtype) -> bytes: ... if sys.version_info >= (3, 3): def unget_wch(__ch: Union[int, str]) -> None: ... def ungetch(__ch: _chtype) -> None: ... def ungetmouse(__id: int, __x: int, __y: int, __z: int, __bstate: int) -> None: ... if sys.version_info >= (3, 5): def update_lines_cols() -> int: ... def use_default_colors() -> None: ... def use_env(__flag: bool) -> None: ... class error(Exception): ... class _CursesWindow: if sys.version_info >= (3, 3): encoding: str @overload def addch(self, ch: _chtype, attr: int = ...) -> None: ... @overload def addch(self, y: int, x: int, ch: _chtype, attr: int = ...) -> None: ... @overload def addnstr(self, str: str, n: int, attr: int = ...) -> None: ... @overload def addnstr(self, y: int, x: int, str: str, n: int, attr: int = ...) -> None: ... @overload def addstr(self, str: str, attr: int = ...) -> None: ... @overload def addstr(self, y: int, x: int, str: str, attr: int = ...) -> None: ... def attroff(self, attr: int) -> None: ... def attron(self, attr: int) -> None: ... def attrset(self, attr: int) -> None: ... def bkgd(self, ch: _chtype, attr: int = ...) -> None: ... def bkgdset(self, ch: _chtype, attr: int = ...) -> None: ... def border( self, ls: _chtype = ..., rs: _chtype = ..., ts: _chtype = ..., bs: _chtype = ..., tl: _chtype = ..., tr: _chtype = ..., bl: _chtype = ..., br: _chtype = ..., ) -> None: ... @overload def box(self) -> None: ... @overload def box(self, vertch: _chtype = ..., horch: _chtype = ...) -> None: ... @overload def chgat(self, attr: int) -> None: ... @overload def chgat(self, num: int, attr: int) -> None: ... @overload def chgat(self, y: int, x: int, attr: int) -> None: ... @overload def chgat(self, y: int, x: int, num: int, attr: int) -> None: ... def clear(self) -> None: ... def clearok(self, yes: int) -> None: ... def clrtobot(self) -> None: ... def clrtoeol(self) -> None: ... def cursyncup(self) -> None: ... @overload def delch(self) -> None: ... @overload def delch(self, y: int, x: int) -> None: ... def deleteln(self) -> None: ... @overload def derwin(self, begin_y: int, begin_x: int) -> _CursesWindow: ... @overload def derwin(self, nlines: int, ncols: int, begin_y: int, begin_x: int) -> _CursesWindow: ... def echochar(self, ch: _chtype, attr: int = ...) -> None: ... def enclose(self, y: int, x: int) -> bool: ... def erase(self) -> None: ... def getbegyx(self) -> Tuple[int, int]: ... def getbkgd(self) -> Tuple[int, int]: ... @overload def getch(self) -> int: ... @overload def getch(self, y: int, x: int) -> int: ... if sys.version_info >= (3, 3): @overload def get_wch(self) -> Union[int, str]: ... @overload def get_wch(self, y: int, x: int) -> Union[int, str]: ... @overload def getkey(self) -> str: ... @overload def getkey(self, y: int, x: int) -> str: ... def getmaxyx(self) -> Tuple[int, int]: ... def getparyx(self) -> Tuple[int, int]: ... @overload def getstr(self) -> _chtype: ... @overload def getstr(self, n: int) -> _chtype: ... @overload def getstr(self, y: int, x: int) -> _chtype: ... @overload def getstr(self, y: int, x: int, n: int) -> _chtype: ... def getyx(self) -> Tuple[int, int]: ... @overload def hline(self, ch: _chtype, n: int) -> None: ... @overload def hline(self, y: int, x: int, ch: _chtype, n: int) -> None: ... def idcok(self, flag: bool) -> None: ... def idlok(self, yes: bool) -> None: ... def immedok(self, flag: bool) -> None: ... @overload def inch(self) -> _chtype: ... @overload def inch(self, y: int, x: int) -> _chtype: ... @overload def insch(self, ch: _chtype, attr: int = ...) -> None: ... @overload def insch(self, y: int, x: int, ch: _chtype, attr: int = ...) -> None: ... def insdelln(self, nlines: int) -> None: ... def insertln(self) -> None: ... @overload def insnstr(self, str: str, n: int, attr: int = ...) -> None: ... @overload def insnstr(self, y: int, x: int, str: str, n: int, attr: int = ...) -> None: ... @overload def insstr(self, str: str, attr: int = ...) -> None: ... @overload def insstr(self, y: int, x: int, str: str, attr: int = ...) -> None: ... @overload def instr(self, n: int = ...) -> _chtype: ... @overload def instr(self, y: int, x: int, n: int = ...) -> _chtype: ... def is_linetouched(self, line: int) -> bool: ... def is_wintouched(self) -> bool: ... def keypad(self, yes: bool) -> None: ... def leaveok(self, yes: bool) -> None: ... def move(self, new_y: int, new_x: int) -> None: ... def mvderwin(self, y: int, x: int) -> None: ... def mvwin(self, new_y: int, new_x: int) -> None: ... def nodelay(self, yes: bool) -> None: ... def notimeout(self, yes: bool) -> None: ... def noutrefresh(self) -> None: ... @overload def overlay(self, destwin: _CursesWindow) -> None: ... @overload def overlay( self, destwin: _CursesWindow, sminrow: int, smincol: int, dminrow: int, dmincol: int, dmaxrow: int, dmaxcol: int ) -> None: ... @overload def overwrite(self, destwin: _CursesWindow) -> None: ... @overload def overwrite( self, destwin: _CursesWindow, sminrow: int, smincol: int, dminrow: int, dmincol: int, dmaxrow: int, dmaxcol: int ) -> None: ... def putwin(self, file: IO[Any]) -> None: ... def redrawln(self, beg: int, num: int) -> None: ... def redrawwin(self) -> None: ... @overload def refresh(self) -> None: ... @overload def refresh(self, pminrow: int, pmincol: int, sminrow: int, smincol: int, smaxrow: int, smaxcol: int) -> None: ... def resize(self, nlines: int, ncols: int) -> None: ... def scroll(self, lines: int = ...) -> None: ... def scrollok(self, flag: bool) -> None: ... def setscrreg(self, top: int, bottom: int) -> None: ... def standend(self) -> None: ... def standout(self) -> None: ... @overload def subpad(self, begin_y: int, begin_x: int) -> _CursesWindow: ... @overload def subpad(self, nlines: int, ncols: int, begin_y: int, begin_x: int) -> _CursesWindow: ... @overload def subwin(self, begin_y: int, begin_x: int) -> _CursesWindow: ... @overload def subwin(self, nlines: int, ncols: int, begin_y: int, begin_x: int) -> _CursesWindow: ... def syncdown(self) -> None: ... def syncok(self, flag: bool) -> None: ... def syncup(self) -> None: ... def timeout(self, delay: int) -> None: ... def touchline(self, start: int, count: int, changed: bool = ...) -> None: ... def touchwin(self) -> None: ... def untouchwin(self) -> None: ... @overload def vline(self, ch: _chtype, n: int) -> None: ... @overload def vline(self, y: int, x: int, ch: _chtype, n: int) -> None: ... if sys.version_info >= (3, 8): class _ncurses_version(NamedTuple): major: int minor: int patch: int ncurses_version: _ncurses_version ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/_dummy_threading.pyi0000664000175000017500000001424500000000000025731 0ustar00davedave00000000000000import sys from types import FrameType, TracebackType from typing import Any, Callable, Iterable, List, Mapping, Optional, Text, Type, TypeVar, Union # TODO recursive type _TF = Callable[[FrameType, str, Any], Optional[Callable[..., Any]]] _PF = Callable[[FrameType, str, Any], None] _T = TypeVar("_T") __all__: List[str] def active_count() -> int: ... if sys.version_info < (3,): def activeCount() -> int: ... def current_thread() -> Thread: ... def currentThread() -> Thread: ... if sys.version_info >= (3,): def get_ident() -> int: ... def enumerate() -> List[Thread]: ... if sys.version_info >= (3, 4): def main_thread() -> Thread: ... if sys.version_info >= (3, 8): from _thread import get_native_id as get_native_id def settrace(func: _TF) -> None: ... def setprofile(func: Optional[_PF]) -> None: ... def stack_size(size: int = ...) -> int: ... if sys.version_info >= (3,): TIMEOUT_MAX: float class ThreadError(Exception): ... class local(object): def __getattribute__(self, name: str) -> Any: ... def __setattr__(self, name: str, value: Any) -> None: ... def __delattr__(self, name: str) -> None: ... class Thread: name: str ident: Optional[int] daemon: bool if sys.version_info >= (3,): def __init__( self, group: None = ..., target: Optional[Callable[..., Any]] = ..., name: Optional[str] = ..., args: Iterable[Any] = ..., kwargs: Mapping[str, Any] = ..., *, daemon: Optional[bool] = ..., ) -> None: ... else: def __init__( self, group: None = ..., target: Optional[Callable[..., Any]] = ..., name: Optional[Text] = ..., args: Iterable[Any] = ..., kwargs: Mapping[Text, Any] = ..., ) -> None: ... def start(self) -> None: ... def run(self) -> None: ... def join(self, timeout: Optional[float] = ...) -> None: ... def getName(self) -> str: ... def setName(self, name: Text) -> None: ... if sys.version_info >= (3, 8): @property def native_id(self) -> Optional[int]: ... # only available on some platforms def is_alive(self) -> bool: ... if sys.version_info < (3, 9): def isAlive(self) -> bool: ... def isDaemon(self) -> bool: ... def setDaemon(self, daemonic: bool) -> None: ... class _DummyThread(Thread): ... class Lock: def __init__(self) -> None: ... def __enter__(self) -> bool: ... def __exit__( self, exc_type: Optional[Type[BaseException]], exc_val: Optional[BaseException], exc_tb: Optional[TracebackType] ) -> Optional[bool]: ... if sys.version_info >= (3,): def acquire(self, blocking: bool = ..., timeout: float = ...) -> bool: ... else: def acquire(self, blocking: bool = ...) -> bool: ... def release(self) -> None: ... def locked(self) -> bool: ... class _RLock: def __init__(self) -> None: ... def __enter__(self) -> bool: ... def __exit__( self, exc_type: Optional[Type[BaseException]], exc_val: Optional[BaseException], exc_tb: Optional[TracebackType] ) -> Optional[bool]: ... if sys.version_info >= (3,): def acquire(self, blocking: bool = ..., timeout: float = ...) -> bool: ... else: def acquire(self, blocking: bool = ...) -> bool: ... def release(self) -> None: ... RLock = _RLock class Condition: def __init__(self, lock: Union[Lock, _RLock, None] = ...) -> None: ... def __enter__(self) -> bool: ... def __exit__( self, exc_type: Optional[Type[BaseException]], exc_val: Optional[BaseException], exc_tb: Optional[TracebackType] ) -> Optional[bool]: ... if sys.version_info >= (3,): def acquire(self, blocking: bool = ..., timeout: float = ...) -> bool: ... else: def acquire(self, blocking: bool = ...) -> bool: ... def release(self) -> None: ... def wait(self, timeout: Optional[float] = ...) -> bool: ... if sys.version_info >= (3,): def wait_for(self, predicate: Callable[[], _T], timeout: Optional[float] = ...) -> _T: ... def notify(self, n: int = ...) -> None: ... def notify_all(self) -> None: ... def notifyAll(self) -> None: ... class Semaphore: def __init__(self, value: int = ...) -> None: ... def __enter__(self) -> bool: ... def __exit__( self, exc_type: Optional[Type[BaseException]], exc_val: Optional[BaseException], exc_tb: Optional[TracebackType] ) -> Optional[bool]: ... if sys.version_info >= (3,): def acquire(self, blocking: bool = ..., timeout: float = ...) -> bool: ... else: def acquire(self, blocking: bool = ...) -> bool: ... if sys.version_info >= (3, 9): def release(self, n: int = ...) -> None: ... else: def release(self) -> None: ... class BoundedSemaphore(Semaphore): ... class Event: def __init__(self) -> None: ... def is_set(self) -> bool: ... if sys.version_info < (3,): def isSet(self) -> bool: ... def set(self) -> None: ... def clear(self) -> None: ... def wait(self, timeout: Optional[float] = ...) -> bool: ... if sys.version_info >= (3, 8): from _thread import _excepthook, _ExceptHookArgs excepthook = _excepthook ExceptHookArgs = _ExceptHookArgs class Timer(Thread): if sys.version_info >= (3,): def __init__( self, interval: float, function: Callable[..., Any], args: Optional[Iterable[Any]] = ..., kwargs: Optional[Mapping[str, Any]] = ..., ) -> None: ... else: def __init__( self, interval: float, function: Callable[..., Any], args: Iterable[Any] = ..., kwargs: Mapping[str, Any] = ... ) -> None: ... def cancel(self) -> None: ... if sys.version_info >= (3,): class Barrier: parties: int n_waiting: int broken: bool def __init__(self, parties: int, action: Optional[Callable[[], None]] = ..., timeout: Optional[float] = ...) -> None: ... def wait(self, timeout: Optional[float] = ...) -> int: ... def reset(self) -> None: ... def abort(self) -> None: ... class BrokenBarrierError(RuntimeError): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/_heapq.pyi0000664000175000017500000000114400000000000023641 0ustar00davedave00000000000000import sys from typing import Any, Callable, Iterable, List, Optional, TypeVar _T = TypeVar("_T") def heapify(__heap: List[_T]) -> None: ... def heappop(__heap: List[_T]) -> _T: ... def heappush(__heap: List[_T], __item: _T) -> None: ... def heappushpop(__heap: List[_T], __item: _T) -> _T: ... def heapreplace(__heap: List[_T], __item: _T) -> _T: ... if sys.version_info < (3,): def nlargest(__n: int, __iterable: Iterable[_T], __key: Optional[Callable[[_T], Any]] = ...) -> List[_T]: ... def nsmallest(__n: int, __iterable: Iterable[_T], __key: Optional[Callable[[_T], Any]] = ...) -> List[_T]: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/_msi.pyi0000664000175000017500000000417000000000000023335 0ustar00davedave00000000000000import sys from typing import List, Optional, Union if sys.platform == "win32": # Actual typename View, not exposed by the implementation class _View: def Execute(self, params: Optional[_Record] = ...) -> None: ... def GetColumnInfo(self, kind: int) -> _Record: ... def Fetch(self) -> _Record: ... def Modify(self, mode: int, record: _Record) -> None: ... def Close(self) -> None: ... # Don't exist at runtime __new__: None # type: ignore __init__: None # type: ignore # Actual typename Summary, not exposed by the implementation class _Summary: def GetProperty(self, propid: int) -> Optional[Union[str, bytes]]: ... def GetPropertyCount(self) -> int: ... def SetProperty(self, propid: int, value: Union[str, bytes]) -> None: ... def Persist(self) -> None: ... # Don't exist at runtime __new__: None # type: ignore __init__: None # type: ignore # Actual typename Database, not exposed by the implementation class _Database: def OpenView(self, sql: str) -> _View: ... def Commit(self) -> None: ... def GetSummaryInformation(self, updateCount: int) -> _Summary: ... def Close(self) -> None: ... # Don't exist at runtime __new__: None # type: ignore __init__: None # type: ignore # Actual typename Record, not exposed by the implementation class _Record: def GetFieldCount(self) -> int: ... def GetInteger(self, field: int) -> int: ... def GetString(self, field: int) -> str: ... def SetString(self, field: int, str: str) -> None: ... def SetStream(self, field: int, stream: str) -> None: ... def SetInteger(self, field: int, int: int) -> None: ... def ClearData(self) -> None: ... # Don't exist at runtime __new__: None # type: ignore __init__: None # type: ignore def UuidCreate() -> str: ... def FCICreate(cabname: str, files: List[str]) -> None: ... def OpenDatabase(name: str, flags: int) -> _Database: ... def CreateRecord(count: int) -> _Record: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/_random.pyi0000664000175000017500000000073600000000000024031 0ustar00davedave00000000000000import sys from typing import Tuple # Actually Tuple[(int,) * 625] _State = Tuple[int, ...] class Random(object): def __init__(self, seed: object = ...) -> None: ... def seed(self, __n: object = ...) -> None: ... def getstate(self) -> _State: ... def setstate(self, __state: _State) -> None: ... def random(self) -> float: ... def getrandbits(self, __k: int) -> int: ... if sys.version_info < (3,): def jumpahead(self, i: int) -> None: ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4223793 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/_typeshed/0000775000175000017500000000000000000000000023645 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/_typeshed/__init__.pyi0000664000175000017500000001100700000000000026126 0ustar00davedave00000000000000# Utility types for typeshed # This module contains various common types to be used by typeshed. The # module and its types do not exist at runtime. You can use this module # outside of typeshed, but no API stability guarantees are made. To use # it in implementation (.py) files, the following construct must be used: # # from typing import TYPE_CHECKING # if TYPE_CHECKING: # from _typeshed import ... # # If on Python versions < 3.10 and "from __future__ import annotations" # is not used, types from this module must be quoted. import array import mmap import sys from typing import AbstractSet, Any, Container, Iterable, Protocol, Text, Tuple, TypeVar, Union from typing_extensions import Literal, final _KT = TypeVar("_KT") _KT_co = TypeVar("_KT_co", covariant=True) _KT_contra = TypeVar("_KT_contra", contravariant=True) _VT = TypeVar("_VT") _VT_co = TypeVar("_VT_co", covariant=True) _T_co = TypeVar("_T_co", covariant=True) _T_contra = TypeVar("_T_contra", contravariant=True) class SupportsLessThan(Protocol): def __lt__(self, __other: Any) -> bool: ... SupportsLessThanT = TypeVar("SupportsLessThanT", bound=SupportsLessThan) # noqa: Y001 # Mapping-like protocols class SupportsItems(Protocol[_KT_co, _VT_co]): if sys.version_info >= (3,): def items(self) -> AbstractSet[Tuple[_KT_co, _VT_co]]: ... else: # We want dictionaries to support this on Python 2. def items(self) -> Iterable[Tuple[_KT_co, _VT_co]]: ... class SupportsKeysAndGetItem(Protocol[_KT, _VT_co]): def keys(self) -> Iterable[_KT]: ... def __getitem__(self, __k: _KT) -> _VT_co: ... class SupportsGetItem(Container[_KT_contra], Protocol[_KT_contra, _VT_co]): def __getitem__(self, __k: _KT_contra) -> _VT_co: ... class SupportsItemAccess(SupportsGetItem[_KT_contra, _VT], Protocol[_KT_contra, _VT]): def __setitem__(self, __k: _KT_contra, __v: _VT) -> None: ... def __delitem__(self, __v: _KT_contra) -> None: ... # StrPath and AnyPath can be used in places where a # path can be used instead of a string, starting with Python 3.6. if sys.version_info >= (3, 6): from os import PathLike StrPath = Union[str, PathLike[str]] BytesPath = Union[bytes, PathLike[bytes]] AnyPath = Union[str, bytes, PathLike[str], PathLike[bytes]] else: StrPath = Text BytesPath = bytes AnyPath = Union[Text, bytes] OpenTextMode = Literal[ "r", "r+", "+r", "rt", "tr", "rt+", "r+t", "+rt", "tr+", "t+r", "+tr", "w", "w+", "+w", "wt", "tw", "wt+", "w+t", "+wt", "tw+", "t+w", "+tw", "a", "a+", "+a", "at", "ta", "at+", "a+t", "+at", "ta+", "t+a", "+ta", "x", "x+", "+x", "xt", "tx", "xt+", "x+t", "+xt", "tx+", "t+x", "+tx", "U", "rU", "Ur", "rtU", "rUt", "Urt", "trU", "tUr", "Utr", ] OpenBinaryModeUpdating = Literal[ "rb+", "r+b", "+rb", "br+", "b+r", "+br", "wb+", "w+b", "+wb", "bw+", "b+w", "+bw", "ab+", "a+b", "+ab", "ba+", "b+a", "+ba", "xb+", "x+b", "+xb", "bx+", "b+x", "+bx", ] OpenBinaryModeWriting = Literal["wb", "bw", "ab", "ba", "xb", "bx"] OpenBinaryModeReading = Literal["rb", "br", "rbU", "rUb", "Urb", "brU", "bUr", "Ubr"] OpenBinaryMode = Union[OpenBinaryModeUpdating, OpenBinaryModeReading, OpenBinaryModeWriting] class HasFileno(Protocol): def fileno(self) -> int: ... FileDescriptor = int FileDescriptorLike = Union[int, HasFileno] class SupportsRead(Protocol[_T_co]): def read(self, __length: int = ...) -> _T_co: ... class SupportsReadline(Protocol[_T_co]): def readline(self, __length: int = ...) -> _T_co: ... class SupportsNoArgReadline(Protocol[_T_co]): def readline(self) -> _T_co: ... class SupportsWrite(Protocol[_T_contra]): def write(self, __s: _T_contra) -> int: ... if sys.version_info >= (3,): ReadableBuffer = Union[bytes, bytearray, memoryview, array.array, mmap.mmap] WriteableBuffer = Union[bytearray, memoryview, array.array, mmap.mmap] else: ReadableBuffer = Union[bytes, bytearray, memoryview, array.array, mmap.mmap, buffer] WriteableBuffer = Union[bytearray, memoryview, array.array, mmap.mmap, buffer] if sys.version_info >= (3, 10): from types import NoneType as NoneType else: # Used by type checkers for checks involving None (does not exist at runtime) @final class NoneType: def __bool__(self) -> Literal[False]: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/_typeshed/wsgi.pyi0000664000175000017500000000241500000000000025343 0ustar00davedave00000000000000# Types to support PEP 3333 (WSGI) # # This module doesn't exist at runtime and neither do the types defined in this # file. They are provided for type checking purposes. from sys import _OptExcInfo from typing import Any, Callable, Dict, Iterable, List, Optional, Protocol, Text, Tuple class StartResponse(Protocol): def __call__( self, status: str, headers: List[Tuple[str, str]], exc_info: Optional[_OptExcInfo] = ... ) -> Callable[[bytes], Any]: ... WSGIEnvironment = Dict[Text, Any] WSGIApplication = Callable[[WSGIEnvironment, StartResponse], Iterable[bytes]] # WSGI input streams per PEP 3333 class InputStream(Protocol): def read(self, size: int = ...) -> bytes: ... def readline(self, size: int = ...) -> bytes: ... def readlines(self, hint: int = ...) -> List[bytes]: ... def __iter__(self) -> Iterable[bytes]: ... # WSGI error streams per PEP 3333 class ErrorStream(Protocol): def flush(self) -> None: ... def write(self, s: str) -> None: ... def writelines(self, seq: List[str]) -> None: ... class _Readable(Protocol): def read(self, size: int = ...) -> bytes: ... # Optional file wrapper in wsgi.file_wrapper class FileWrapper(Protocol): def __call__(self, file: _Readable, block_size: int = ...) -> Iterable[bytes]: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/_typeshed/xml.pyi0000664000175000017500000000102000000000000025161 0ustar00davedave00000000000000# Stub-only types. This module does not exist at runtime. from typing import Any, Optional from typing_extensions import Protocol # As defined https://docs.python.org/3/library/xml.dom.html#domimplementation-objects class DOMImplementation(Protocol): def hasFeature(self, feature: str, version: Optional[str]) -> bool: ... def createDocument(self, namespaceUri: str, qualifiedName: str, doctype: Optional[Any]) -> Any: ... def createDocumentType(self, qualifiedName: str, publicId: str, systemId: str) -> Any: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/_warnings.pyi0000664000175000017500000000427100000000000024377 0ustar00davedave00000000000000import sys from typing import Any, Dict, List, Optional, Tuple, Type, Union, overload if sys.version_info >= (3, 0): _defaultaction: str _onceregistry: Dict[Any, Any] else: default_action: str once_registry: Dict[Any, Any] filters: List[Tuple[Any, ...]] if sys.version_info >= (3, 6): @overload def warn( message: str, category: Optional[Type[Warning]] = ..., stacklevel: int = ..., source: Optional[Any] = ... ) -> None: ... @overload def warn(message: Warning, category: Any = ..., stacklevel: int = ..., source: Optional[Any] = ...) -> None: ... @overload def warn_explicit( message: str, category: Type[Warning], filename: str, lineno: int, module: Optional[str] = ..., registry: Optional[Dict[Union[str, Tuple[str, Type[Warning], int]], int]] = ..., module_globals: Optional[Dict[str, Any]] = ..., source: Optional[Any] = ..., ) -> None: ... @overload def warn_explicit( message: Warning, category: Any, filename: str, lineno: int, module: Optional[str] = ..., registry: Optional[Dict[Union[str, Tuple[str, Type[Warning], int]], int]] = ..., module_globals: Optional[Dict[str, Any]] = ..., source: Optional[Any] = ..., ) -> None: ... else: @overload def warn(message: str, category: Optional[Type[Warning]] = ..., stacklevel: int = ...) -> None: ... @overload def warn(message: Warning, category: Any = ..., stacklevel: int = ...) -> None: ... @overload def warn_explicit( message: str, category: Type[Warning], filename: str, lineno: int, module: Optional[str] = ..., registry: Optional[Dict[Union[str, Tuple[str, Type[Warning], int]], int]] = ..., module_globals: Optional[Dict[str, Any]] = ..., ) -> None: ... @overload def warn_explicit( message: Warning, category: Any, filename: str, lineno: int, module: Optional[str] = ..., registry: Optional[Dict[Union[str, Tuple[str, Type[Warning], int]], int]] = ..., module_globals: Optional[Dict[str, Any]] = ..., ) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/_weakref.pyi0000664000175000017500000000226000000000000024167 0ustar00davedave00000000000000import sys from typing import Any, Callable, Generic, Optional, TypeVar, overload if sys.version_info >= (3, 9): from types import GenericAlias _C = TypeVar("_C", bound=Callable[..., Any]) _T = TypeVar("_T") class CallableProxyType(object): # "weakcallableproxy" def __getattr__(self, attr: str) -> Any: ... class ProxyType(object): # "weakproxy" def __getattr__(self, attr: str) -> Any: ... class ReferenceType(Generic[_T]): if sys.version_info >= (3, 4): __callback__: Callable[[ReferenceType[_T]], Any] def __init__(self, o: _T, callback: Optional[Callable[[ReferenceType[_T]], Any]] = ...) -> None: ... def __call__(self) -> Optional[_T]: ... def __hash__(self) -> int: ... if sys.version_info >= (3, 9): def __class_getitem__(cls, item: Any) -> GenericAlias: ... ref = ReferenceType def getweakrefcount(__object: Any) -> int: ... def getweakrefs(object: Any) -> int: ... @overload def proxy(object: _C, callback: Optional[Callable[[_C], Any]] = ...) -> CallableProxyType: ... # Return CallableProxyType if object is callable, ProxyType otherwise @overload def proxy(object: _T, callback: Optional[Callable[[_T], Any]] = ...) -> Any: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/_weakrefset.pyi0000664000175000017500000000456100000000000024711 0ustar00davedave00000000000000import sys from typing import Any, Generic, Iterable, Iterator, MutableSet, Optional, TypeVar, Union if sys.version_info >= (3, 9): from types import GenericAlias _S = TypeVar("_S") _T = TypeVar("_T") _SelfT = TypeVar("_SelfT", bound=WeakSet[Any]) class WeakSet(MutableSet[_T], Generic[_T]): def __init__(self, data: Optional[Iterable[_T]] = ...) -> None: ... def add(self, item: _T) -> None: ... def clear(self) -> None: ... def discard(self, item: _T) -> None: ... def copy(self: _SelfT) -> _SelfT: ... def pop(self) -> _T: ... def remove(self, item: _T) -> None: ... def update(self, other: Iterable[_T]) -> None: ... def __contains__(self, item: object) -> bool: ... def __len__(self) -> int: ... def __iter__(self) -> Iterator[_T]: ... def __ior__(self, other: Iterable[_S]) -> WeakSet[Union[_S, _T]]: ... def difference(self: _SelfT, other: Iterable[_T]) -> _SelfT: ... def __sub__(self: _SelfT, other: Iterable[_T]) -> _SelfT: ... def difference_update(self: _SelfT, other: Iterable[_T]) -> None: ... def __isub__(self: _SelfT, other: Iterable[_T]) -> _SelfT: ... def intersection(self: _SelfT, other: Iterable[_T]) -> _SelfT: ... def __and__(self: _SelfT, other: Iterable[_T]) -> _SelfT: ... def intersection_update(self, other: Iterable[_T]) -> None: ... def __iand__(self: _SelfT, other: Iterable[_T]) -> _SelfT: ... def issubset(self, other: Iterable[_T]) -> bool: ... def __le__(self, other: Iterable[_T]) -> bool: ... def __lt__(self, other: Iterable[_T]) -> bool: ... def issuperset(self, other: Iterable[_T]) -> bool: ... def __ge__(self, other: Iterable[_T]) -> bool: ... def __gt__(self, other: Iterable[_T]) -> bool: ... def __eq__(self, other: object) -> bool: ... def symmetric_difference(self, other: Iterable[_S]) -> WeakSet[Union[_S, _T]]: ... def __xor__(self, other: Iterable[_S]) -> WeakSet[Union[_S, _T]]: ... def symmetric_difference_update(self, other: Iterable[_S]) -> None: ... def __ixor__(self, other: Iterable[_S]) -> WeakSet[Union[_S, _T]]: ... def union(self, other: Iterable[_S]) -> WeakSet[Union[_S, _T]]: ... def __or__(self, other: Iterable[_S]) -> WeakSet[Union[_S, _T]]: ... def isdisjoint(self, other: Iterable[_T]) -> bool: ... if sys.version_info >= (3, 9): def __class_getitem__(cls, item: Any) -> GenericAlias: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/aifc.pyi0000664000175000017500000000650100000000000023310 0ustar00davedave00000000000000import sys from types import TracebackType from typing import IO, Any, List, NamedTuple, Optional, Text, Tuple, Type, Union, overload from typing_extensions import Literal class Error(Exception): ... class _aifc_params(NamedTuple): nchannels: int sampwidth: int framerate: int nframes: int comptype: bytes compname: bytes _File = Union[Text, IO[bytes]] _Marker = Tuple[int, int, bytes] class Aifc_read: def __init__(self, f: _File) -> None: ... if sys.version_info >= (3, 4): def __enter__(self) -> Aifc_read: ... def __exit__( self, exc_type: Optional[Type[BaseException]], exc_val: Optional[BaseException], exc_tb: Optional[TracebackType] ) -> None: ... def initfp(self, file: IO[bytes]) -> None: ... def getfp(self) -> IO[bytes]: ... def rewind(self) -> None: ... def close(self) -> None: ... def tell(self) -> int: ... def getnchannels(self) -> int: ... def getnframes(self) -> int: ... def getsampwidth(self) -> int: ... def getframerate(self) -> int: ... def getcomptype(self) -> bytes: ... def getcompname(self) -> bytes: ... def getparams(self) -> _aifc_params: ... def getmarkers(self) -> Optional[List[_Marker]]: ... def getmark(self, id: int) -> _Marker: ... def setpos(self, pos: int) -> None: ... def readframes(self, nframes: int) -> bytes: ... class Aifc_write: def __init__(self, f: _File) -> None: ... def __del__(self) -> None: ... if sys.version_info >= (3, 4): def __enter__(self) -> Aifc_write: ... def __exit__( self, exc_type: Optional[Type[BaseException]], exc_val: Optional[BaseException], exc_tb: Optional[TracebackType] ) -> None: ... def initfp(self, file: IO[bytes]) -> None: ... def aiff(self) -> None: ... def aifc(self) -> None: ... def setnchannels(self, nchannels: int) -> None: ... def getnchannels(self) -> int: ... def setsampwidth(self, sampwidth: int) -> None: ... def getsampwidth(self) -> int: ... def setframerate(self, framerate: int) -> None: ... def getframerate(self) -> int: ... def setnframes(self, nframes: int) -> None: ... def getnframes(self) -> int: ... def setcomptype(self, comptype: bytes, compname: bytes) -> None: ... def getcomptype(self) -> bytes: ... def getcompname(self) -> bytes: ... def setparams(self, params: Tuple[int, int, int, int, bytes, bytes]) -> None: ... def getparams(self) -> _aifc_params: ... def setmark(self, id: int, pos: int, name: bytes) -> None: ... def getmark(self, id: int) -> _Marker: ... def getmarkers(self) -> Optional[List[_Marker]]: ... def tell(self) -> int: ... def writeframesraw(self, data: Any) -> None: ... # Actual type for data is Buffer Protocol def writeframes(self, data: Any) -> None: ... def close(self) -> None: ... @overload def open(f: _File, mode: Literal["r", "rb"]) -> Aifc_read: ... @overload def open(f: _File, mode: Literal["w", "wb"]) -> Aifc_write: ... @overload def open(f: _File, mode: Optional[str] = ...) -> Any: ... if sys.version_info < (3, 9): @overload def openfp(f: _File, mode: Literal["r", "rb"]) -> Aifc_read: ... @overload def openfp(f: _File, mode: Literal["w", "wb"]) -> Aifc_write: ... @overload def openfp(f: _File, mode: Optional[str] = ...) -> Any: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/antigravity.pyi0000664000175000017500000000017300000000000024746 0ustar00davedave00000000000000import sys if sys.version_info >= (3, 0): def geohash(latitude: float, longitude: float, datedow: bytes) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/argparse.pyi0000664000175000017500000004363700000000000024225 0ustar00davedave00000000000000import sys from typing import ( IO, Any, Callable, Dict, Generator, Iterable, List, NoReturn, Optional, Pattern, Protocol, Sequence, Text, Tuple, Type, TypeVar, Union, overload, ) _T = TypeVar("_T") _ActionT = TypeVar("_ActionT", bound=Action) _N = TypeVar("_N") if sys.version_info >= (3,): _Text = str else: _Text = Union[str, unicode] ONE_OR_MORE: str OPTIONAL: str PARSER: str REMAINDER: str SUPPRESS: str ZERO_OR_MORE: str _UNRECOGNIZED_ARGS_ATTR: str # undocumented class ArgumentError(Exception): argument_name: Optional[str] message: str def __init__(self, argument: Optional[Action], message: str) -> None: ... # undocumented class _AttributeHolder: def _get_kwargs(self) -> List[Tuple[str, Any]]: ... def _get_args(self) -> List[Any]: ... # undocumented class _ActionsContainer: description: Optional[_Text] prefix_chars: _Text argument_default: Any conflict_handler: _Text _registries: Dict[_Text, Dict[Any, Any]] _actions: List[Action] _option_string_actions: Dict[_Text, Action] _action_groups: List[_ArgumentGroup] _mutually_exclusive_groups: List[_MutuallyExclusiveGroup] _defaults: Dict[str, Any] _negative_number_matcher: Pattern[str] _has_negative_number_optionals: List[bool] def __init__( self, description: Optional[Text], prefix_chars: Text, argument_default: Any, conflict_handler: Text ) -> None: ... def register(self, registry_name: Text, value: Any, object: Any) -> None: ... def _registry_get(self, registry_name: Text, value: Any, default: Any = ...) -> Any: ... def set_defaults(self, **kwargs: Any) -> None: ... def get_default(self, dest: Text) -> Any: ... def add_argument( self, *name_or_flags: Text, action: Union[Text, Type[Action]] = ..., nargs: Union[int, Text] = ..., const: Any = ..., default: Any = ..., type: Union[Callable[[Text], _T], Callable[[str], _T], FileType] = ..., choices: Iterable[_T] = ..., required: bool = ..., help: Optional[Text] = ..., metavar: Optional[Union[Text, Tuple[Text, ...]]] = ..., dest: Optional[Text] = ..., version: Text = ..., **kwargs: Any, ) -> Action: ... def add_argument_group(self, *args: Any, **kwargs: Any) -> _ArgumentGroup: ... def add_mutually_exclusive_group(self, **kwargs: Any) -> _MutuallyExclusiveGroup: ... def _add_action(self, action: _ActionT) -> _ActionT: ... def _remove_action(self, action: Action) -> None: ... def _add_container_actions(self, container: _ActionsContainer) -> None: ... def _get_positional_kwargs(self, dest: Text, **kwargs: Any) -> Dict[str, Any]: ... def _get_optional_kwargs(self, *args: Any, **kwargs: Any) -> Dict[str, Any]: ... def _pop_action_class(self, kwargs: Any, default: Optional[Type[Action]] = ...) -> Type[Action]: ... def _get_handler(self) -> Callable[[Action, Iterable[Tuple[Text, Action]]], Any]: ... def _check_conflict(self, action: Action) -> None: ... def _handle_conflict_error(self, action: Action, conflicting_actions: Iterable[Tuple[Text, Action]]) -> NoReturn: ... def _handle_conflict_resolve(self, action: Action, conflicting_actions: Iterable[Tuple[Text, Action]]) -> None: ... class _FormatterClass(Protocol): def __call__(self, prog: str) -> HelpFormatter: ... class ArgumentParser(_AttributeHolder, _ActionsContainer): prog: _Text usage: Optional[_Text] epilog: Optional[_Text] formatter_class: _FormatterClass fromfile_prefix_chars: Optional[_Text] add_help: bool if sys.version_info >= (3, 5): allow_abbrev: bool # undocumented _positionals: _ArgumentGroup _optionals: _ArgumentGroup _subparsers: Optional[_ArgumentGroup] if sys.version_info >= (3, 9): def __init__( self, prog: Optional[str] = ..., usage: Optional[str] = ..., description: Optional[str] = ..., epilog: Optional[str] = ..., parents: Sequence[ArgumentParser] = ..., formatter_class: _FormatterClass = ..., prefix_chars: str = ..., fromfile_prefix_chars: Optional[str] = ..., argument_default: Any = ..., conflict_handler: str = ..., add_help: bool = ..., allow_abbrev: bool = ..., exit_on_error: bool = ..., ) -> None: ... elif sys.version_info >= (3, 5): def __init__( self, prog: Optional[str] = ..., usage: Optional[str] = ..., description: Optional[str] = ..., epilog: Optional[str] = ..., parents: Sequence[ArgumentParser] = ..., formatter_class: _FormatterClass = ..., prefix_chars: str = ..., fromfile_prefix_chars: Optional[str] = ..., argument_default: Any = ..., conflict_handler: str = ..., add_help: bool = ..., allow_abbrev: bool = ..., ) -> None: ... else: def __init__( self, prog: Optional[Text] = ..., usage: Optional[Text] = ..., description: Optional[Text] = ..., epilog: Optional[Text] = ..., parents: Sequence[ArgumentParser] = ..., formatter_class: _FormatterClass = ..., prefix_chars: Text = ..., fromfile_prefix_chars: Optional[Text] = ..., argument_default: Any = ..., conflict_handler: Text = ..., add_help: bool = ..., ) -> None: ... # The type-ignores in these overloads should be temporary. See: # https://github.com/python/typeshed/pull/2643#issuecomment-442280277 @overload def parse_args(self, args: Optional[Sequence[Text]] = ...) -> Namespace: ... @overload def parse_args(self, args: Optional[Sequence[Text]], namespace: None) -> Namespace: ... # type: ignore @overload def parse_args(self, args: Optional[Sequence[Text]], namespace: _N) -> _N: ... @overload def parse_args(self, *, namespace: None) -> Namespace: ... # type: ignore @overload def parse_args(self, *, namespace: _N) -> _N: ... if sys.version_info >= (3, 7): def add_subparsers( self, *, title: str = ..., description: Optional[str] = ..., prog: str = ..., parser_class: Type[ArgumentParser] = ..., action: Type[Action] = ..., option_string: str = ..., dest: Optional[str] = ..., required: bool = ..., help: Optional[str] = ..., metavar: Optional[str] = ..., ) -> _SubParsersAction: ... else: def add_subparsers( self, *, title: Text = ..., description: Optional[Text] = ..., prog: Text = ..., parser_class: Type[ArgumentParser] = ..., action: Type[Action] = ..., option_string: Text = ..., dest: Optional[Text] = ..., help: Optional[Text] = ..., metavar: Optional[Text] = ..., ) -> _SubParsersAction: ... def print_usage(self, file: Optional[IO[str]] = ...) -> None: ... def print_help(self, file: Optional[IO[str]] = ...) -> None: ... def format_usage(self) -> str: ... def format_help(self) -> str: ... def parse_known_args( self, args: Optional[Sequence[Text]] = ..., namespace: Optional[Namespace] = ... ) -> Tuple[Namespace, List[str]]: ... def convert_arg_line_to_args(self, arg_line: Text) -> List[str]: ... def exit(self, status: int = ..., message: Optional[Text] = ...) -> NoReturn: ... def error(self, message: Text) -> NoReturn: ... if sys.version_info >= (3, 7): def parse_intermixed_args( self, args: Optional[Sequence[str]] = ..., namespace: Optional[Namespace] = ... ) -> Namespace: ... def parse_known_intermixed_args( self, args: Optional[Sequence[str]] = ..., namespace: Optional[Namespace] = ... ) -> Tuple[Namespace, List[str]]: ... # undocumented def _get_optional_actions(self) -> List[Action]: ... def _get_positional_actions(self) -> List[Action]: ... def _parse_known_args(self, arg_strings: List[Text], namespace: Namespace) -> Tuple[Namespace, List[str]]: ... def _read_args_from_files(self, arg_strings: List[Text]) -> List[Text]: ... def _match_argument(self, action: Action, arg_strings_pattern: Text) -> int: ... def _match_arguments_partial(self, actions: Sequence[Action], arg_strings_pattern: Text) -> List[int]: ... def _parse_optional(self, arg_string: Text) -> Optional[Tuple[Optional[Action], Text, Optional[Text]]]: ... def _get_option_tuples(self, option_string: Text) -> List[Tuple[Action, Text, Optional[Text]]]: ... def _get_nargs_pattern(self, action: Action) -> _Text: ... def _get_values(self, action: Action, arg_strings: List[Text]) -> Any: ... def _get_value(self, action: Action, arg_string: Text) -> Any: ... def _check_value(self, action: Action, value: Any) -> None: ... def _get_formatter(self) -> HelpFormatter: ... def _print_message(self, message: str, file: Optional[IO[str]] = ...) -> None: ... class HelpFormatter: # undocumented _prog: _Text _indent_increment: int _max_help_position: int _width: int _current_indent: int _level: int _action_max_length: int _root_section: Any _current_section: Any _whitespace_matcher: Pattern[str] _long_break_matcher: Pattern[str] _Section: Type[Any] # Nested class def __init__( self, prog: Text, indent_increment: int = ..., max_help_position: int = ..., width: Optional[int] = ... ) -> None: ... def _indent(self) -> None: ... def _dedent(self) -> None: ... def _add_item(self, func: Callable[..., _Text], args: Iterable[Any]) -> None: ... def start_section(self, heading: Optional[Text]) -> None: ... def end_section(self) -> None: ... def add_text(self, text: Optional[Text]) -> None: ... def add_usage( self, usage: Text, actions: Iterable[Action], groups: Iterable[_ArgumentGroup], prefix: Optional[Text] = ... ) -> None: ... def add_argument(self, action: Action) -> None: ... def add_arguments(self, actions: Iterable[Action]) -> None: ... def format_help(self) -> _Text: ... def _join_parts(self, part_strings: Iterable[Text]) -> _Text: ... def _format_usage( self, usage: Text, actions: Iterable[Action], groups: Iterable[_ArgumentGroup], prefix: Optional[Text] ) -> _Text: ... def _format_actions_usage(self, actions: Iterable[Action], groups: Iterable[_ArgumentGroup]) -> _Text: ... def _format_text(self, text: Text) -> _Text: ... def _format_action(self, action: Action) -> _Text: ... def _format_action_invocation(self, action: Action) -> _Text: ... def _metavar_formatter(self, action: Action, default_metavar: Text) -> Callable[[int], Tuple[_Text, ...]]: ... def _format_args(self, action: Action, default_metavar: Text) -> _Text: ... def _expand_help(self, action: Action) -> _Text: ... def _iter_indented_subactions(self, action: Action) -> Generator[Action, None, None]: ... def _split_lines(self, text: Text, width: int) -> List[_Text]: ... def _fill_text(self, text: Text, width: int, indent: Text) -> _Text: ... def _get_help_string(self, action: Action) -> Optional[_Text]: ... def _get_default_metavar_for_optional(self, action: Action) -> _Text: ... def _get_default_metavar_for_positional(self, action: Action) -> _Text: ... class RawDescriptionHelpFormatter(HelpFormatter): ... class RawTextHelpFormatter(RawDescriptionHelpFormatter): ... class ArgumentDefaultsHelpFormatter(HelpFormatter): ... if sys.version_info >= (3,): class MetavarTypeHelpFormatter(HelpFormatter): ... class Action(_AttributeHolder): option_strings: Sequence[_Text] dest: _Text nargs: Optional[Union[int, _Text]] const: Any default: Any type: Union[Callable[[str], Any], FileType, None] choices: Optional[Iterable[Any]] required: bool help: Optional[_Text] metavar: Optional[Union[_Text, Tuple[_Text, ...]]] def __init__( self, option_strings: Sequence[Text], dest: Text, nargs: Optional[Union[int, Text]] = ..., const: Optional[_T] = ..., default: Union[_T, str, None] = ..., type: Optional[Union[Callable[[Text], _T], Callable[[str], _T], FileType]] = ..., choices: Optional[Iterable[_T]] = ..., required: bool = ..., help: Optional[Text] = ..., metavar: Optional[Union[Text, Tuple[Text, ...]]] = ..., ) -> None: ... def __call__( self, parser: ArgumentParser, namespace: Namespace, values: Union[Text, Sequence[Any], None], option_string: Optional[Text] = ..., ) -> None: ... if sys.version_info >= (3, 9): def format_usage(self) -> str: ... if sys.version_info >= (3, 9): class BooleanOptionalAction(Action): def __init__( self, option_strings: Sequence[str], dest: str, default: Union[_T, str, None] = ..., type: Optional[Union[Callable[[Text], _T], Callable[[str], _T], FileType]] = ..., choices: Optional[Iterable[_T]] = ..., required: bool = ..., help: Optional[Text] = ..., metavar: Optional[Union[Text, Tuple[Text, ...]]] = ..., ) -> None: ... class Namespace(_AttributeHolder): def __init__(self, **kwargs: Any) -> None: ... def __getattr__(self, name: Text) -> Any: ... def __setattr__(self, name: Text, value: Any) -> None: ... def __contains__(self, key: str) -> bool: ... class FileType: # undocumented _mode: _Text _bufsize: int if sys.version_info >= (3,): _encoding: Optional[str] _errors: Optional[str] def __init__( self, mode: str = ..., bufsize: int = ..., encoding: Optional[str] = ..., errors: Optional[str] = ... ) -> None: ... else: def __init__(self, mode: Text = ..., bufsize: Optional[int] = ...) -> None: ... def __call__(self, string: Text) -> IO[Any]: ... # undocumented class _ArgumentGroup(_ActionsContainer): title: Optional[_Text] _group_actions: List[Action] def __init__( self, container: _ActionsContainer, title: Optional[Text] = ..., description: Optional[Text] = ..., **kwargs: Any ) -> None: ... # undocumented class _MutuallyExclusiveGroup(_ArgumentGroup): required: bool _container: _ActionsContainer def __init__(self, container: _ActionsContainer, required: bool = ...) -> None: ... # undocumented class _StoreAction(Action): ... # undocumented class _StoreConstAction(Action): def __init__( self, option_strings: Sequence[Text], dest: Text, const: Any, default: Any = ..., required: bool = ..., help: Optional[Text] = ..., metavar: Optional[Union[Text, Tuple[Text, ...]]] = ..., ) -> None: ... # undocumented class _StoreTrueAction(_StoreConstAction): def __init__( self, option_strings: Sequence[Text], dest: Text, default: bool = ..., required: bool = ..., help: Optional[Text] = ... ) -> None: ... # undocumented class _StoreFalseAction(_StoreConstAction): def __init__( self, option_strings: Sequence[Text], dest: Text, default: bool = ..., required: bool = ..., help: Optional[Text] = ... ) -> None: ... # undocumented class _AppendAction(Action): ... # undocumented class _AppendConstAction(Action): def __init__( self, option_strings: Sequence[Text], dest: Text, const: Any, default: Any = ..., required: bool = ..., help: Optional[Text] = ..., metavar: Optional[Union[Text, Tuple[Text, ...]]] = ..., ) -> None: ... # undocumented class _CountAction(Action): def __init__( self, option_strings: Sequence[Text], dest: Text, default: Any = ..., required: bool = ..., help: Optional[Text] = ... ) -> None: ... # undocumented class _HelpAction(Action): def __init__( self, option_strings: Sequence[Text], dest: Text = ..., default: Text = ..., help: Optional[Text] = ... ) -> None: ... # undocumented class _VersionAction(Action): version: Optional[_Text] def __init__( self, option_strings: Sequence[Text], version: Optional[Text] = ..., dest: Text = ..., default: Text = ..., help: Text = ..., ) -> None: ... # undocumented class _SubParsersAction(Action): _ChoicesPseudoAction: Type[Any] # nested class _prog_prefix: _Text _parser_class: Type[ArgumentParser] _name_parser_map: Dict[_Text, ArgumentParser] choices: Dict[_Text, ArgumentParser] _choices_actions: List[Action] if sys.version_info >= (3, 7): def __init__( self, option_strings: Sequence[Text], prog: Text, parser_class: Type[ArgumentParser], dest: Text = ..., required: bool = ..., help: Optional[Text] = ..., metavar: Optional[Union[Text, Tuple[Text, ...]]] = ..., ) -> None: ... else: def __init__( self, option_strings: Sequence[Text], prog: Text, parser_class: Type[ArgumentParser], dest: Text = ..., help: Optional[Text] = ..., metavar: Optional[Union[Text, Tuple[Text, ...]]] = ..., ) -> None: ... # TODO: Type keyword args properly. def add_parser(self, name: Text, **kwargs: Any) -> ArgumentParser: ... def _get_subactions(self) -> List[Action]: ... # undocumented class ArgumentTypeError(Exception): ... if sys.version_info < (3, 7): # undocumented def _ensure_value(namespace: Namespace, name: Text, value: Any) -> Any: ... # undocumented def _get_action_name(argument: Optional[Action]) -> Optional[str]: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/array.pyi0000664000175000017500000000664100000000000023531 0ustar00davedave00000000000000import sys from typing import Any, BinaryIO, Generic, Iterable, List, MutableSequence, Text, Tuple, TypeVar, Union, overload from typing_extensions import Literal _IntTypeCode = Literal["b", "B", "h", "H", "i", "I", "l", "L", "q", "Q"] _FloatTypeCode = Literal["f", "d"] _UnicodeTypeCode = Literal["u"] _TypeCode = Union[_IntTypeCode, _FloatTypeCode, _UnicodeTypeCode] _T = TypeVar("_T", int, float, Text) if sys.version_info >= (3,): typecodes: str class array(MutableSequence[_T], Generic[_T]): typecode: _TypeCode itemsize: int @overload def __init__(self: array[int], typecode: _IntTypeCode, __initializer: Union[bytes, Iterable[_T]] = ...) -> None: ... @overload def __init__(self: array[float], typecode: _FloatTypeCode, __initializer: Union[bytes, Iterable[_T]] = ...) -> None: ... @overload def __init__(self: array[Text], typecode: _UnicodeTypeCode, __initializer: Union[bytes, Iterable[_T]] = ...) -> None: ... @overload def __init__(self, typecode: str, __initializer: Union[bytes, Iterable[_T]] = ...) -> None: ... def append(self, __v: _T) -> None: ... def buffer_info(self) -> Tuple[int, int]: ... def byteswap(self) -> None: ... def count(self, __v: Any) -> int: ... def extend(self, __bb: Iterable[_T]) -> None: ... if sys.version_info >= (3, 2): def frombytes(self, __buffer: bytes) -> None: ... def fromfile(self, __f: BinaryIO, __n: int) -> None: ... def fromlist(self, __list: List[_T]) -> None: ... def fromunicode(self, __ustr: str) -> None: ... def index(self, __v: _T) -> int: ... # type: ignore # Overrides Sequence def insert(self, __i: int, __v: _T) -> None: ... def pop(self, __i: int = ...) -> _T: ... if sys.version_info < (3,): def read(self, f: BinaryIO, n: int) -> None: ... def remove(self, __v: Any) -> None: ... def reverse(self) -> None: ... if sys.version_info >= (3, 2): def tobytes(self) -> bytes: ... def tofile(self, __f: BinaryIO) -> None: ... def tolist(self) -> List[_T]: ... def tounicode(self) -> str: ... if sys.version_info < (3,): def write(self, f: BinaryIO) -> None: ... if sys.version_info < (3, 9): def fromstring(self, __buffer: bytes) -> None: ... def tostring(self) -> bytes: ... def __len__(self) -> int: ... @overload def __getitem__(self, i: int) -> _T: ... @overload def __getitem__(self, s: slice) -> array[_T]: ... @overload # type: ignore # Overrides MutableSequence def __setitem__(self, i: int, o: _T) -> None: ... @overload def __setitem__(self, s: slice, o: array[_T]) -> None: ... def __delitem__(self, i: Union[int, slice]) -> None: ... def __add__(self, x: array[_T]) -> array[_T]: ... def __ge__(self, other: array[_T]) -> bool: ... def __gt__(self, other: array[_T]) -> bool: ... def __iadd__(self, x: array[_T]) -> array[_T]: ... # type: ignore # Overrides MutableSequence def __imul__(self, n: int) -> array[_T]: ... def __le__(self, other: array[_T]) -> bool: ... def __lt__(self, other: array[_T]) -> bool: ... def __mul__(self, n: int) -> array[_T]: ... def __rmul__(self, n: int) -> array[_T]: ... if sys.version_info < (3,): def __delslice__(self, i: int, j: int) -> None: ... def __getslice__(self, i: int, j: int) -> array[_T]: ... def __setslice__(self, i: int, j: int, y: array[_T]) -> None: ... ArrayType = array ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/asynchat.pyi0000664000175000017500000000302300000000000024214 0ustar00davedave00000000000000import asyncore import socket import sys from abc import abstractmethod from typing import Optional, Sequence, Tuple, Union class simple_producer: def __init__(self, data: bytes, buffer_size: int = ...) -> None: ... def more(self) -> bytes: ... class async_chat(asyncore.dispatcher): ac_in_buffer_size: int ac_out_buffer_size: int def __init__(self, sock: Optional[socket.socket] = ..., map: Optional[asyncore._maptype] = ...) -> None: ... @abstractmethod def collect_incoming_data(self, data: bytes) -> None: ... @abstractmethod def found_terminator(self) -> None: ... def set_terminator(self, term: Union[bytes, int, None]) -> None: ... def get_terminator(self) -> Union[bytes, int, None]: ... def handle_read(self) -> None: ... def handle_write(self) -> None: ... def handle_close(self) -> None: ... def push(self, data: bytes) -> None: ... def push_with_producer(self, producer: simple_producer) -> None: ... def readable(self) -> bool: ... def writable(self) -> bool: ... def close_when_done(self) -> None: ... def initiate_send(self) -> None: ... def discard_buffers(self) -> None: ... if sys.version_info < (3, 0): class fifo: def __init__(self, list: Sequence[Union[bytes, simple_producer]] = ...) -> None: ... def __len__(self) -> int: ... def is_empty(self) -> bool: ... def first(self) -> bytes: ... def push(self, data: Union[bytes, simple_producer]) -> None: ... def pop(self) -> Tuple[int, bytes]: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/asyncore.pyi0000664000175000017500000001263600000000000024237 0ustar00davedave00000000000000import sys from _typeshed import FileDescriptorLike from socket import SocketType from typing import Any, Dict, Optional, Tuple, Union, overload # cyclic dependence with asynchat _maptype = Dict[int, Any] socket_map: _maptype = ... # Undocumented class ExitNow(Exception): ... def read(obj: Any) -> None: ... def write(obj: Any) -> None: ... def readwrite(obj: Any, flags: int) -> None: ... def poll(timeout: float = ..., map: Optional[_maptype] = ...) -> None: ... def poll2(timeout: float = ..., map: Optional[_maptype] = ...) -> None: ... poll3 = poll2 def loop(timeout: float = ..., use_poll: bool = ..., map: Optional[_maptype] = ..., count: Optional[int] = ...) -> None: ... # Not really subclass of socket.socket; it's only delegation. # It is not covariant to it. class dispatcher: debug: bool connected: bool accepting: bool connecting: bool closing: bool ignore_log_types: frozenset[str] socket: Optional[SocketType] def __init__(self, sock: Optional[SocketType] = ..., map: Optional[_maptype] = ...) -> None: ... def add_channel(self, map: Optional[_maptype] = ...) -> None: ... def del_channel(self, map: Optional[_maptype] = ...) -> None: ... def create_socket(self, family: int = ..., type: int = ...) -> None: ... def set_socket(self, sock: SocketType, map: Optional[_maptype] = ...) -> None: ... def set_reuse_addr(self) -> None: ... def readable(self) -> bool: ... def writable(self) -> bool: ... def listen(self, num: int) -> None: ... def bind(self, addr: Union[Tuple[Any, ...], str]) -> None: ... def connect(self, address: Union[Tuple[Any, ...], str]) -> None: ... def accept(self) -> Optional[Tuple[SocketType, Any]]: ... def send(self, data: bytes) -> int: ... def recv(self, buffer_size: int) -> bytes: ... def close(self) -> None: ... def log(self, message: Any) -> None: ... def log_info(self, message: Any, type: str = ...) -> None: ... def handle_read_event(self) -> None: ... def handle_connect_event(self) -> None: ... def handle_write_event(self) -> None: ... def handle_expt_event(self) -> None: ... def handle_error(self) -> None: ... def handle_expt(self) -> None: ... def handle_read(self) -> None: ... def handle_write(self) -> None: ... def handle_connect(self) -> None: ... def handle_accept(self) -> None: ... def handle_close(self) -> None: ... if sys.version_info < (3, 5): # Historically, some methods were "imported" from `self.socket` by # means of `__getattr__`. This was long deprecated, and as of Python # 3.5 has been removed; simply call the relevant methods directly on # self.socket if necessary. def detach(self) -> int: ... def fileno(self) -> int: ... # return value is an address def getpeername(self) -> Any: ... def getsockname(self) -> Any: ... @overload def getsockopt(self, level: int, optname: int, buflen: None = ...) -> int: ... @overload def getsockopt(self, level: int, optname: int, buflen: int) -> bytes: ... def gettimeout(self) -> float: ... def ioctl(self, control: object, option: Tuple[int, int, int]) -> None: ... # TODO the return value may be BinaryIO or TextIO, depending on mode def makefile( self, mode: str = ..., buffering: int = ..., encoding: str = ..., errors: str = ..., newline: str = ... ) -> Any: ... # return type is an address def recvfrom(self, bufsize: int, flags: int = ...) -> Any: ... def recvfrom_into(self, buffer: bytes, nbytes: int, flags: int = ...) -> Any: ... def recv_into(self, buffer: bytes, nbytes: int, flags: int = ...) -> Any: ... def sendall(self, data: bytes, flags: int = ...) -> None: ... def sendto(self, data: bytes, address: Union[Tuple[str, int], str], flags: int = ...) -> int: ... def setblocking(self, flag: bool) -> None: ... def settimeout(self, value: Union[float, None]) -> None: ... def setsockopt(self, level: int, optname: int, value: Union[int, bytes]) -> None: ... def shutdown(self, how: int) -> None: ... class dispatcher_with_send(dispatcher): def __init__(self, sock: SocketType = ..., map: Optional[_maptype] = ...) -> None: ... def initiate_send(self) -> None: ... def handle_write(self) -> None: ... # incompatible signature: # def send(self, data: bytes) -> Optional[int]: ... def compact_traceback() -> Tuple[Tuple[str, str, str], type, type, str]: ... def close_all(map: Optional[_maptype] = ..., ignore_all: bool = ...) -> None: ... if sys.platform != "win32": class file_wrapper: fd: int def __init__(self, fd: int) -> None: ... def recv(self, bufsize: int, flags: int = ...) -> bytes: ... def send(self, data: bytes, flags: int = ...) -> int: ... @overload def getsockopt(self, level: int, optname: int, buflen: None = ...) -> int: ... @overload def getsockopt(self, level: int, optname: int, buflen: int) -> bytes: ... def read(self, bufsize: int, flags: int = ...) -> bytes: ... def write(self, data: bytes, flags: int = ...) -> int: ... def close(self) -> None: ... def fileno(self) -> int: ... class file_dispatcher(dispatcher): def __init__(self, fd: FileDescriptorLike, map: Optional[_maptype] = ...) -> None: ... def set_file(self, fd: int) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/audioop.pyi0000664000175000017500000000410700000000000024046 0ustar00davedave00000000000000from typing import Optional, Tuple AdpcmState = Tuple[int, int] RatecvState = Tuple[int, Tuple[Tuple[int, int], ...]] class error(Exception): ... def add(__fragment1: bytes, __fragment2: bytes, __width: int) -> bytes: ... def adpcm2lin(__fragment: bytes, __width: int, __state: Optional[AdpcmState]) -> Tuple[bytes, AdpcmState]: ... def alaw2lin(__fragment: bytes, __width: int) -> bytes: ... def avg(__fragment: bytes, __width: int) -> int: ... def avgpp(__fragment: bytes, __width: int) -> int: ... def bias(__fragment: bytes, __width: int, __bias: int) -> bytes: ... def byteswap(__fragment: bytes, __width: int) -> bytes: ... def cross(__fragment: bytes, __width: int) -> int: ... def findfactor(__fragment: bytes, __reference: bytes) -> float: ... def findfit(__fragment: bytes, __reference: bytes) -> Tuple[int, float]: ... def findmax(__fragment: bytes, __length: int) -> int: ... def getsample(__fragment: bytes, __width: int, __index: int) -> int: ... def lin2adpcm(__fragment: bytes, __width: int, __state: Optional[AdpcmState]) -> Tuple[bytes, AdpcmState]: ... def lin2alaw(__fragment: bytes, __width: int) -> bytes: ... def lin2lin(__fragment: bytes, __width: int, __newwidth: int) -> bytes: ... def lin2ulaw(__fragment: bytes, __width: int) -> bytes: ... def max(__fragment: bytes, __width: int) -> int: ... def maxpp(__fragment: bytes, __width: int) -> int: ... def minmax(__fragment: bytes, __width: int) -> Tuple[int, int]: ... def mul(__fragment: bytes, __width: int, __factor: float) -> bytes: ... def ratecv( __fragment: bytes, __width: int, __nchannels: int, __inrate: int, __outrate: int, __state: Optional[RatecvState], __weightA: int = ..., __weightB: int = ..., ) -> Tuple[bytes, RatecvState]: ... def reverse(__fragment: bytes, __width: int) -> bytes: ... def rms(__fragment: bytes, __width: int) -> int: ... def tomono(__fragment: bytes, __width: int, __lfactor: float, __rfactor: float) -> bytes: ... def tostereo(__fragment: bytes, __width: int, __lfactor: float, __rfactor: float) -> bytes: ... def ulaw2lin(__fragment: bytes, __width: int) -> bytes: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/base64.pyi0000664000175000017500000000311600000000000023471 0ustar00davedave00000000000000import sys from typing import IO, Optional, Union if sys.version_info < (3,): _encodable = Union[bytes, unicode] _decodable = Union[bytes, unicode] else: _encodable = bytes _decodable = Union[bytes, str] def b64encode(s: _encodable, altchars: Optional[bytes] = ...) -> bytes: ... def b64decode(s: _decodable, altchars: Optional[bytes] = ..., validate: bool = ...) -> bytes: ... def standard_b64encode(s: _encodable) -> bytes: ... def standard_b64decode(s: _decodable) -> bytes: ... def urlsafe_b64encode(s: _encodable) -> bytes: ... def urlsafe_b64decode(s: _decodable) -> bytes: ... def b32encode(s: _encodable) -> bytes: ... def b32decode(s: _decodable, casefold: bool = ..., map01: Optional[bytes] = ...) -> bytes: ... def b16encode(s: _encodable) -> bytes: ... def b16decode(s: _decodable, casefold: bool = ...) -> bytes: ... if sys.version_info >= (3, 4): def a85encode(b: _encodable, *, foldspaces: bool = ..., wrapcol: int = ..., pad: bool = ..., adobe: bool = ...) -> bytes: ... def a85decode(b: _decodable, *, foldspaces: bool = ..., adobe: bool = ..., ignorechars: Union[str, bytes] = ...) -> bytes: ... def b85encode(b: _encodable, pad: bool = ...) -> bytes: ... def b85decode(b: _decodable) -> bytes: ... def decode(input: IO[bytes], output: IO[bytes]) -> None: ... def encode(input: IO[bytes], output: IO[bytes]) -> None: ... if sys.version_info >= (3,): def encodebytes(s: bytes) -> bytes: ... def decodebytes(s: bytes) -> bytes: ... if sys.version_info < (3, 9): def encodestring(s: bytes) -> bytes: ... def decodestring(s: bytes) -> bytes: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/bdb.pyi0000664000175000017500000001104400000000000023133 0ustar00davedave00000000000000from types import CodeType, FrameType, TracebackType from typing import IO, Any, Callable, Dict, Iterable, List, Mapping, Optional, Set, SupportsInt, Tuple, Type, TypeVar, Union _T = TypeVar("_T") _TraceDispatch = Callable[[FrameType, str, Any], Any] # TODO: Recursive type _ExcInfo = Tuple[Type[BaseException], BaseException, FrameType] GENERATOR_AND_COROUTINE_FLAGS: int = ... class BdbQuit(Exception): ... class Bdb: skip: Optional[Set[str]] breaks: Dict[str, List[int]] fncache: Dict[str, str] frame_returning: Optional[FrameType] botframe: Optional[FrameType] quitting: bool stopframe: Optional[FrameType] returnframe: Optional[FrameType] stoplineno: int def __init__(self, skip: Optional[Iterable[str]] = ...) -> None: ... def canonic(self, filename: str) -> str: ... def reset(self) -> None: ... def trace_dispatch(self, frame: FrameType, event: str, arg: Any) -> _TraceDispatch: ... def dispatch_line(self, frame: FrameType) -> _TraceDispatch: ... def dispatch_call(self, frame: FrameType, arg: None) -> _TraceDispatch: ... def dispatch_return(self, frame: FrameType, arg: Any) -> _TraceDispatch: ... def dispatch_exception(self, frame: FrameType, arg: _ExcInfo) -> _TraceDispatch: ... def is_skipped_module(self, module_name: str) -> bool: ... def stop_here(self, frame: FrameType) -> bool: ... def break_here(self, frame: FrameType) -> bool: ... def do_clear(self, arg: Any) -> Optional[bool]: ... def break_anywhere(self, frame: FrameType) -> bool: ... def user_call(self, frame: FrameType, argument_list: None) -> None: ... def user_line(self, frame: FrameType) -> None: ... def user_return(self, frame: FrameType, return_value: Any) -> None: ... def user_exception(self, frame: FrameType, exc_info: _ExcInfo) -> None: ... def set_until(self, frame: FrameType, lineno: Optional[int] = ...) -> None: ... def set_step(self) -> None: ... def set_next(self, frame: FrameType) -> None: ... def set_return(self, frame: FrameType) -> None: ... def set_trace(self, frame: Optional[FrameType] = ...) -> None: ... def set_continue(self) -> None: ... def set_quit(self) -> None: ... def set_break( self, filename: str, lineno: int, temporary: bool = ..., cond: Optional[str] = ..., funcname: Optional[str] = ... ) -> None: ... def clear_break(self, filename: str, lineno: int) -> None: ... def clear_bpbynumber(self, arg: SupportsInt) -> None: ... def clear_all_file_breaks(self, filename: str) -> None: ... def clear_all_breaks(self) -> None: ... def get_bpbynumber(self, arg: SupportsInt) -> Breakpoint: ... def get_break(self, filename: str, lineno: int) -> bool: ... def get_breaks(self, filename: str, lineno: int) -> List[Breakpoint]: ... def get_file_breaks(self, filename: str) -> List[Breakpoint]: ... def get_all_breaks(self) -> List[Breakpoint]: ... def get_stack(self, f: Optional[FrameType], t: Optional[TracebackType]) -> Tuple[List[Tuple[FrameType, int]], int]: ... def format_stack_entry(self, frame_lineno: int, lprefix: str = ...) -> str: ... def run( self, cmd: Union[str, CodeType], globals: Optional[Dict[str, Any]] = ..., locals: Optional[Mapping[str, Any]] = ... ) -> None: ... def runeval(self, expr: str, globals: Optional[Dict[str, Any]] = ..., locals: Optional[Mapping[str, Any]] = ...) -> None: ... def runctx( self, cmd: Union[str, CodeType], globals: Optional[Dict[str, Any]], locals: Optional[Mapping[str, Any]] ) -> None: ... def runcall(self, __func: Callable[..., _T], *args: Any, **kwds: Any) -> Optional[_T]: ... class Breakpoint: next: int = ... bplist: Dict[Tuple[str, int], List[Breakpoint]] = ... bpbynumber: List[Optional[Breakpoint]] = ... funcname: Optional[str] func_first_executable_line: Optional[int] file: str line: int temporary: bool cond: Optional[str] enabled: bool ignore: int hits: int number: int def __init__( self, file: str, line: int, temporary: bool = ..., cond: Optional[str] = ..., funcname: Optional[str] = ... ) -> None: ... def deleteMe(self) -> None: ... def enable(self) -> None: ... def disable(self) -> None: ... def bpprint(self, out: Optional[IO[str]] = ...) -> None: ... def bpformat(self) -> str: ... def __str__(self) -> str: ... def checkfuncname(b: Breakpoint, frame: FrameType) -> bool: ... def effective(file: str, line: int, frame: FrameType) -> Union[Tuple[Breakpoint, bool], Tuple[None, None]]: ... def set_trace() -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/binascii.pyi0000664000175000017500000000302000000000000024160 0ustar00davedave00000000000000import sys from typing import Text, Union if sys.version_info < (3,): # Python 2 accepts unicode ascii pretty much everywhere. _Bytes = Text _Ascii = Text else: # But since Python 3.3 ASCII-only unicode strings are accepted by the # a2b_* functions. _Bytes = bytes _Ascii = Union[bytes, str] def a2b_uu(__data: _Ascii) -> bytes: ... if sys.version_info >= (3, 7): def b2a_uu(__data: _Bytes, *, backtick: bool = ...) -> bytes: ... else: def b2a_uu(__data: _Bytes) -> bytes: ... def a2b_base64(__data: _Ascii) -> bytes: ... if sys.version_info >= (3, 6): def b2a_base64(__data: _Bytes, *, newline: bool = ...) -> bytes: ... else: def b2a_base64(__data: _Bytes) -> bytes: ... def a2b_qp(data: _Ascii, header: bool = ...) -> bytes: ... def b2a_qp(data: _Bytes, quotetabs: bool = ..., istext: bool = ..., header: bool = ...) -> bytes: ... def a2b_hqx(__data: _Ascii) -> bytes: ... def rledecode_hqx(__data: _Bytes) -> bytes: ... def rlecode_hqx(__data: _Bytes) -> bytes: ... def b2a_hqx(__data: _Bytes) -> bytes: ... def crc_hqx(__data: _Bytes, __crc: int) -> int: ... def crc32(__data: _Bytes, __crc: int = ...) -> int: ... def b2a_hex(__data: _Bytes) -> bytes: ... if sys.version_info >= (3, 8): def hexlify(data: bytes, sep: Union[str, bytes] = ..., bytes_per_sep: int = ...) -> bytes: ... else: def hexlify(__data: _Bytes) -> bytes: ... def a2b_hex(__hexstr: _Ascii) -> bytes: ... def unhexlify(__hexstr: _Ascii) -> bytes: ... class Error(ValueError): ... class Incomplete(Exception): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/binhex.pyi0000664000175000017500000000217300000000000023664 0ustar00davedave00000000000000from typing import IO, Any, Tuple, Union class Error(Exception): ... REASONABLY_LARGE: int LINELEN: int RUNCHAR: bytes class FInfo: def __init__(self) -> None: ... Type: str Creator: str Flags: int _FileInfoTuple = Tuple[str, FInfo, int, int] _FileHandleUnion = Union[str, IO[bytes]] def getfileinfo(name: str) -> _FileInfoTuple: ... class openrsrc: def __init__(self, *args: Any) -> None: ... def read(self, *args: Any) -> bytes: ... def write(self, *args: Any) -> None: ... def close(self) -> None: ... class BinHex: def __init__(self, name_finfo_dlen_rlen: _FileInfoTuple, ofp: _FileHandleUnion) -> None: ... def write(self, data: bytes) -> None: ... def close_data(self) -> None: ... def write_rsrc(self, data: bytes) -> None: ... def close(self) -> None: ... def binhex(inp: str, out: str) -> None: ... class HexBin: def __init__(self, ifp: _FileHandleUnion) -> None: ... def read(self, *n: int) -> bytes: ... def close_data(self) -> None: ... def read_rsrc(self, *n: int) -> bytes: ... def close(self) -> None: ... def hexbin(inp: str, out: str) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/bisect.pyi0000664000175000017500000000010300000000000023647 0ustar00davedave00000000000000from _bisect import * bisect = bisect_right insort = insort_right ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/bz2.pyi0000664000175000017500000000433300000000000023104 0ustar00davedave00000000000000import io import sys from _typeshed import AnyPath from typing import IO, Any, Optional, TextIO, TypeVar, Union, overload from typing_extensions import Literal _PathOrFile = Union[AnyPath, IO[bytes]] _T = TypeVar("_T") def compress(data: bytes, compresslevel: int = ...) -> bytes: ... def decompress(data: bytes) -> bytes: ... if sys.version_info >= (3, 3): _OpenBinaryMode = Literal["r", "rb", "w", "wb", "x", "xb", "a", "ab"] _OpenTextMode = Literal["rt", "wt", "xt", "at"] @overload def open( filename: _PathOrFile, mode: _OpenBinaryMode = ..., compresslevel: int = ..., encoding: None = ..., errors: None = ..., newline: None = ..., ) -> BZ2File: ... @overload def open( filename: AnyPath, mode: _OpenTextMode, compresslevel: int = ..., encoding: Optional[str] = ..., errors: Optional[str] = ..., newline: Optional[str] = ..., ) -> TextIO: ... @overload def open( filename: _PathOrFile, mode: str, compresslevel: int = ..., encoding: Optional[str] = ..., errors: Optional[str] = ..., newline: Optional[str] = ..., ) -> Union[BZ2File, TextIO]: ... class BZ2File(io.BufferedIOBase, IO[bytes]): def __enter__(self: _T) -> _T: ... if sys.version_info >= (3, 9): def __init__(self, filename: _PathOrFile, mode: str = ..., *, compresslevel: int = ...) -> None: ... else: def __init__( self, filename: _PathOrFile, mode: str = ..., buffering: Optional[Any] = ..., compresslevel: int = ... ) -> None: ... class BZ2Compressor(object): def __init__(self, compresslevel: int = ...) -> None: ... def compress(self, data: bytes) -> bytes: ... def flush(self) -> bytes: ... class BZ2Decompressor(object): if sys.version_info >= (3, 5): def decompress(self, data: bytes, max_length: int = ...) -> bytes: ... else: def decompress(self, data: bytes) -> bytes: ... if sys.version_info >= (3, 3): @property def eof(self) -> bool: ... if sys.version_info >= (3, 5): @property def needs_input(self) -> bool: ... @property def unused_data(self) -> bytes: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/cProfile.pyi0000664000175000017500000000232700000000000024153 0ustar00davedave00000000000000import sys from _typeshed import AnyPath from typing import Any, Callable, Dict, Optional, TypeVar, Union def run(statement: str, filename: Optional[str] = ..., sort: Union[str, int] = ...) -> None: ... def runctx( statement: str, globals: Dict[str, Any], locals: Dict[str, Any], filename: Optional[str] = ..., sort: Union[str, int] = ... ) -> None: ... _SelfT = TypeVar("_SelfT", bound=Profile) _T = TypeVar("_T") class Profile: def __init__( self, timer: Callable[[], float] = ..., timeunit: float = ..., subcalls: bool = ..., builtins: bool = ... ) -> None: ... def enable(self) -> None: ... def disable(self) -> None: ... def print_stats(self, sort: Union[str, int] = ...) -> None: ... def dump_stats(self, file: AnyPath) -> None: ... def create_stats(self) -> None: ... def snapshot_stats(self) -> None: ... def run(self: _SelfT, cmd: str) -> _SelfT: ... def runctx(self: _SelfT, cmd: str, globals: Dict[str, Any], locals: Dict[str, Any]) -> _SelfT: ... def runcall(self, __func: Callable[..., _T], *args: Any, **kw: Any) -> _T: ... if sys.version_info >= (3, 8): def __enter__(self: _SelfT) -> _SelfT: ... def __exit__(self, *exc_info: Any) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/calendar.pyi0000664000175000017500000001321500000000000024157 0ustar00davedave00000000000000import datetime import sys from time import struct_time from typing import Any, Iterable, List, Optional, Sequence, Tuple, Union _LocaleType = Tuple[Optional[str], Optional[str]] class IllegalMonthError(ValueError): def __init__(self, month: int) -> None: ... def __str__(self) -> str: ... class IllegalWeekdayError(ValueError): def __init__(self, weekday: int) -> None: ... def __str__(self) -> str: ... def isleap(year: int) -> bool: ... def leapdays(y1: int, y2: int) -> int: ... def weekday(year: int, month: int, day: int) -> int: ... def monthrange(year: int, month: int) -> Tuple[int, int]: ... class Calendar: def __init__(self, firstweekday: int = ...) -> None: ... def getfirstweekday(self) -> int: ... def setfirstweekday(self, firstweekday: int) -> None: ... def iterweekdays(self) -> Iterable[int]: ... def itermonthdates(self, year: int, month: int) -> Iterable[datetime.date]: ... def itermonthdays2(self, year: int, month: int) -> Iterable[Tuple[int, int]]: ... def itermonthdays(self, year: int, month: int) -> Iterable[int]: ... def monthdatescalendar(self, year: int, month: int) -> List[List[datetime.date]]: ... def monthdays2calendar(self, year: int, month: int) -> List[List[Tuple[int, int]]]: ... def monthdayscalendar(self, year: int, month: int) -> List[List[int]]: ... def yeardatescalendar(self, year: int, width: int = ...) -> List[List[int]]: ... def yeardays2calendar(self, year: int, width: int = ...) -> List[List[Tuple[int, int]]]: ... def yeardayscalendar(self, year: int, width: int = ...) -> List[List[int]]: ... if sys.version_info >= (3, 7): def itermonthdays3(self, year: int, month: int) -> Iterable[Tuple[int, int, int]]: ... def itermonthdays4(self, year: int, month: int) -> Iterable[Tuple[int, int, int, int]]: ... class TextCalendar(Calendar): def prweek(self, theweek: int, width: int) -> None: ... def formatday(self, day: int, weekday: int, width: int) -> str: ... def formatweek(self, theweek: int, width: int) -> str: ... def formatweekday(self, day: int, width: int) -> str: ... def formatweekheader(self, width: int) -> str: ... def formatmonthname(self, theyear: int, themonth: int, width: int, withyear: bool = ...) -> str: ... def prmonth(self, theyear: int, themonth: int, w: int = ..., l: int = ...) -> None: ... def formatmonth(self, theyear: int, themonth: int, w: int = ..., l: int = ...) -> str: ... def formatyear(self, theyear: int, w: int = ..., l: int = ..., c: int = ..., m: int = ...) -> str: ... def pryear(self, theyear: int, w: int = ..., l: int = ..., c: int = ..., m: int = ...) -> None: ... def firstweekday() -> int: ... def monthcalendar(year: int, month: int) -> List[List[int]]: ... def prweek(theweek: int, width: int) -> None: ... def week(theweek: int, width: int) -> str: ... def weekheader(width: int) -> str: ... def prmonth(theyear: int, themonth: int, w: int = ..., l: int = ...) -> None: ... def month(theyear: int, themonth: int, w: int = ..., l: int = ...) -> str: ... def calendar(theyear: int, w: int = ..., l: int = ..., c: int = ..., m: int = ...) -> str: ... def prcal(theyear: int, w: int = ..., l: int = ..., c: int = ..., m: int = ...) -> None: ... class HTMLCalendar(Calendar): def formatday(self, day: int, weekday: int) -> str: ... def formatweek(self, theweek: int) -> str: ... def formatweekday(self, day: int) -> str: ... def formatweekheader(self) -> str: ... def formatmonthname(self, theyear: int, themonth: int, withyear: bool = ...) -> str: ... def formatmonth(self, theyear: int, themonth: int, withyear: bool = ...) -> str: ... def formatyear(self, theyear: int, width: int = ...) -> str: ... def formatyearpage(self, theyear: int, width: int = ..., css: Optional[str] = ..., encoding: Optional[str] = ...) -> str: ... if sys.version_info >= (3, 7): cssclasses: List[str] cssclass_noday: str cssclasses_weekday_head: List[str] cssclass_month_head: str cssclass_month: str cssclass_year: str cssclass_year_head: str if sys.version_info < (3, 0): class TimeEncoding: def __init__(self, locale: _LocaleType) -> None: ... def __enter__(self) -> _LocaleType: ... def __exit__(self, *args: Any) -> None: ... else: class different_locale: def __init__(self, locale: _LocaleType) -> None: ... def __enter__(self) -> _LocaleType: ... def __exit__(self, *args: Any) -> None: ... class LocaleTextCalendar(TextCalendar): def __init__(self, firstweekday: int = ..., locale: Optional[_LocaleType] = ...) -> None: ... def formatweekday(self, day: int, width: int) -> str: ... def formatmonthname(self, theyear: int, themonth: int, width: int, withyear: bool = ...) -> str: ... class LocaleHTMLCalendar(HTMLCalendar): def __init__(self, firstweekday: int = ..., locale: Optional[_LocaleType] = ...) -> None: ... def formatweekday(self, day: int) -> str: ... def formatmonthname(self, theyear: int, themonth: int, withyear: bool = ...) -> str: ... c: TextCalendar def setfirstweekday(firstweekday: int) -> None: ... def format(cols: int, colwidth: int = ..., spacing: int = ...) -> str: ... def formatstring(cols: int, colwidth: int = ..., spacing: int = ...) -> str: ... def timegm(tuple: Union[Tuple[int, ...], struct_time]) -> int: ... # Data attributes day_name: Sequence[str] day_abbr: Sequence[str] month_name: Sequence[str] month_abbr: Sequence[str] # Below constants are not in docs or __all__, but enough people have used them # they are now effectively public. MONDAY: int TUESDAY: int WEDNESDAY: int THURSDAY: int FRIDAY: int SATURDAY: int SUNDAY: int ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/cgi.pyi0000664000175000017500000001360000000000000023146 0ustar00davedave00000000000000import sys from _typeshed import SupportsGetItem, SupportsItemAccess from builtins import type as _type from typing import IO, Any, AnyStr, Dict, Iterable, Iterator, List, Mapping, Optional, Protocol, Tuple, TypeVar, Union _T = TypeVar("_T", bound=FieldStorage) def parse( fp: Optional[IO[Any]] = ..., environ: SupportsItemAccess[str, str] = ..., keep_blank_values: bool = ..., strict_parsing: bool = ..., ) -> Dict[str, List[str]]: ... if sys.version_info < (3, 8): def parse_qs(qs: str, keep_blank_values: bool = ..., strict_parsing: bool = ...) -> Dict[str, List[str]]: ... def parse_qsl(qs: str, keep_blank_values: bool = ..., strict_parsing: bool = ...) -> List[Tuple[str, str]]: ... if sys.version_info >= (3, 7): def parse_multipart( fp: IO[Any], pdict: SupportsGetItem[str, bytes], encoding: str = ..., errors: str = ... ) -> Dict[str, List[Any]]: ... else: def parse_multipart(fp: IO[Any], pdict: SupportsGetItem[str, bytes]) -> Dict[str, List[bytes]]: ... class _Environ(Protocol): def __getitem__(self, __k: str) -> str: ... def keys(self) -> Iterable[str]: ... def parse_header(line: str) -> Tuple[str, Dict[str, str]]: ... def test(environ: _Environ = ...) -> None: ... def print_environ(environ: _Environ = ...) -> None: ... def print_form(form: Dict[str, Any]) -> None: ... def print_directory() -> None: ... def print_environ_usage() -> None: ... if sys.version_info < (3,): def escape(s: AnyStr, quote: bool = ...) -> AnyStr: ... elif sys.version_info < (3, 8): def escape(s: str, quote: Optional[bool] = ...) -> str: ... class MiniFieldStorage: # The first five "Any" attributes here are always None, but mypy doesn't support that filename: Any list: Any type: Any file: Optional[IO[bytes]] type_options: Dict[Any, Any] disposition: Any disposition_options: Dict[Any, Any] headers: Dict[Any, Any] name: Any value: Any def __init__(self, name: Any, value: Any) -> None: ... def __repr__(self) -> str: ... class FieldStorage(object): FieldStorageClass: Optional[_type] keep_blank_values: int strict_parsing: int qs_on_post: Optional[str] headers: Mapping[str, str] fp: IO[bytes] encoding: str errors: str outerboundary: bytes bytes_read: int limit: Optional[int] disposition: str disposition_options: Dict[str, str] filename: Optional[str] file: Optional[IO[bytes]] type: str type_options: Dict[str, str] innerboundary: bytes length: int done: int list: Optional[List[Any]] value: Union[None, bytes, List[Any]] if sys.version_info >= (3, 6): def __init__( self, fp: Optional[IO[Any]] = ..., headers: Optional[Mapping[str, str]] = ..., outerboundary: bytes = ..., environ: SupportsGetItem[str, str] = ..., keep_blank_values: int = ..., strict_parsing: int = ..., limit: Optional[int] = ..., encoding: str = ..., errors: str = ..., max_num_fields: Optional[int] = ..., ) -> None: ... elif sys.version_info >= (3, 0): def __init__( self, fp: Optional[IO[Any]] = ..., headers: Optional[Mapping[str, str]] = ..., outerboundary: bytes = ..., environ: SupportsGetItem[str, str] = ..., keep_blank_values: int = ..., strict_parsing: int = ..., limit: Optional[int] = ..., encoding: str = ..., errors: str = ..., ) -> None: ... else: def __init__( self, fp: IO[Any] = ..., headers: Mapping[str, str] = ..., outerboundary: bytes = ..., environ: SupportsGetItem[str, str] = ..., keep_blank_values: int = ..., strict_parsing: int = ..., ) -> None: ... if sys.version_info >= (3, 0): def __enter__(self: _T) -> _T: ... def __exit__(self, *args: Any) -> None: ... def __repr__(self) -> str: ... def __iter__(self) -> Iterator[str]: ... def __getitem__(self, key: str) -> Any: ... def getvalue(self, key: str, default: Any = ...) -> Any: ... def getfirst(self, key: str, default: Any = ...) -> Any: ... def getlist(self, key: str) -> List[Any]: ... def keys(self) -> List[str]: ... if sys.version_info < (3, 0): def has_key(self, key: str) -> bool: ... def __contains__(self, key: str) -> bool: ... def __len__(self) -> int: ... if sys.version_info >= (3, 0): def __bool__(self) -> bool: ... else: def __nonzero__(self) -> bool: ... if sys.version_info >= (3, 0): # In Python 3 it returns bytes or str IO depending on an internal flag def make_file(self) -> IO[Any]: ... else: # In Python 2 it always returns bytes and ignores the "binary" flag def make_file(self, binary: Any = ...) -> IO[bytes]: ... if sys.version_info < (3, 0): from UserDict import UserDict class FormContentDict(UserDict[str, List[str]]): query_string: str def __init__(self, environ: Mapping[str, str] = ..., keep_blank_values: int = ..., strict_parsing: int = ...) -> None: ... class SvFormContentDict(FormContentDict): def getlist(self, key: Any) -> Any: ... class InterpFormContentDict(SvFormContentDict): ... class FormContent(FormContentDict): # TODO this should have # def values(self, key: Any) -> Any: ... # but this is incompatible with the supertype, and adding '# type: ignore' triggers # a parse error in pytype (https://github.com/google/pytype/issues/53) def indexed_value(self, key: Any, location: int) -> Any: ... def value(self, key: Any) -> Any: ... def length(self, key: Any) -> int: ... def stripped(self, key: Any) -> Any: ... def pars(self) -> Dict[Any, Any]: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/cgitb.pyi0000664000175000017500000000264700000000000023505 0ustar00davedave00000000000000from _typeshed import AnyPath from types import FrameType, TracebackType from typing import IO, Any, Callable, Dict, List, Optional, Tuple, Type _ExcInfo = Tuple[Optional[Type[BaseException]], Optional[BaseException], Optional[TracebackType]] def reset() -> str: ... # undocumented def small(text: str) -> str: ... # undocumented def strong(text: str) -> str: ... # undocumented def grey(text: str) -> str: ... # undocumented def lookup(name: str, frame: FrameType, locals: Dict[str, Any]) -> Tuple[Optional[str], Any]: ... # undocumented def scanvars( reader: Callable[[], bytes], frame: FrameType, locals: Dict[str, Any] ) -> List[Tuple[str, Optional[str], Any]]: ... # undocumented def html(einfo: _ExcInfo, context: int = ...) -> str: ... def text(einfo: _ExcInfo, context: int = ...) -> str: ... class Hook: # undocumented def __init__( self, display: int = ..., logdir: Optional[AnyPath] = ..., context: int = ..., file: Optional[IO[str]] = ..., format: str = ..., ) -> None: ... def __call__( self, etype: Optional[Type[BaseException]], evalue: Optional[BaseException], etb: Optional[TracebackType] ) -> None: ... def handle(self, info: Optional[_ExcInfo] = ...) -> None: ... def handler(info: Optional[_ExcInfo] = ...) -> None: ... def enable(display: int = ..., logdir: Optional[AnyPath] = ..., context: int = ..., format: str = ...) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/chunk.pyi0000664000175000017500000000114500000000000023515 0ustar00davedave00000000000000from typing import IO class Chunk: closed: bool align: bool file: IO[bytes] chunkname: bytes chunksize: int size_read: int offset: int seekable: bool def __init__(self, file: IO[bytes], align: bool = ..., bigendian: bool = ..., inclheader: bool = ...) -> None: ... def getname(self) -> bytes: ... def getsize(self) -> int: ... def close(self) -> None: ... def isatty(self) -> bool: ... def seek(self, pos: int, whence: int = ...) -> None: ... def tell(self) -> int: ... def read(self, size: int = ...) -> bytes: ... def skip(self) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/cmath.pyi0000664000175000017500000000230100000000000023474 0ustar00davedave00000000000000import sys from typing import SupportsComplex, SupportsFloat, Tuple, Union e: float pi: float if sys.version_info >= (3, 6): inf: float infj: complex nan: float nanj: complex tau: float _C = Union[SupportsFloat, SupportsComplex] def acos(__z: _C) -> complex: ... def acosh(__z: _C) -> complex: ... def asin(__z: _C) -> complex: ... def asinh(__z: _C) -> complex: ... def atan(__z: _C) -> complex: ... def atanh(__z: _C) -> complex: ... def cos(__z: _C) -> complex: ... def cosh(__z: _C) -> complex: ... def exp(__z: _C) -> complex: ... if sys.version_info >= (3, 5): def isclose(a: _C, b: _C, *, rel_tol: SupportsFloat = ..., abs_tol: SupportsFloat = ...) -> bool: ... def isinf(__z: _C) -> bool: ... def isnan(__z: _C) -> bool: ... def log(__x: _C, __y_obj: _C = ...) -> complex: ... def log10(__z: _C) -> complex: ... def phase(__z: _C) -> float: ... def polar(__z: _C) -> Tuple[float, float]: ... def rect(__r: float, __phi: float) -> complex: ... def sin(__z: _C) -> complex: ... def sinh(__z: _C) -> complex: ... def sqrt(__z: _C) -> complex: ... def tan(__z: _C) -> complex: ... def tanh(__z: _C) -> complex: ... if sys.version_info >= (3,): def isfinite(__z: _C) -> bool: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/cmd.pyi0000664000175000017500000000317200000000000023152 0ustar00davedave00000000000000from typing import IO, Any, Callable, List, Optional, Tuple class Cmd: prompt: str identchars: str ruler: str lastcmd: str intro: Optional[Any] doc_leader: str doc_header: str misc_header: str undoc_header: str nohelp: str use_rawinput: bool stdin: IO[str] stdout: IO[str] cmdqueue: List[str] completekey: str def __init__(self, completekey: str = ..., stdin: Optional[IO[str]] = ..., stdout: Optional[IO[str]] = ...) -> None: ... old_completer: Optional[Callable[[str, int], Optional[str]]] def cmdloop(self, intro: Optional[Any] = ...) -> None: ... def precmd(self, line: str) -> str: ... def postcmd(self, stop: bool, line: str) -> bool: ... def preloop(self) -> None: ... def postloop(self) -> None: ... def parseline(self, line: str) -> Tuple[Optional[str], Optional[str], str]: ... def onecmd(self, line: str) -> bool: ... def emptyline(self) -> bool: ... def default(self, line: str) -> bool: ... def completedefault(self, *ignored: Any) -> List[str]: ... def completenames(self, text: str, *ignored: Any) -> List[str]: ... completion_matches: Optional[List[str]] def complete(self, text: str, state: int) -> Optional[List[str]]: ... def get_names(self) -> List[str]: ... # Only the first element of args matters. def complete_help(self, *args: Any) -> List[str]: ... def do_help(self, arg: str) -> Optional[bool]: ... def print_topics(self, header: str, cmds: Optional[List[str]], cmdlen: Any, maxcol: int) -> None: ... def columnize(self, list: Optional[List[str]], displaywidth: int = ...) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/code.pyi0000664000175000017500000000276200000000000023325 0ustar00davedave00000000000000import sys from types import CodeType from typing import Any, Callable, Mapping, Optional class InteractiveInterpreter: def __init__(self, locals: Optional[Mapping[str, Any]] = ...) -> None: ... def runsource(self, source: str, filename: str = ..., symbol: str = ...) -> bool: ... def runcode(self, code: CodeType) -> None: ... def showsyntaxerror(self, filename: Optional[str] = ...) -> None: ... def showtraceback(self) -> None: ... def write(self, data: str) -> None: ... class InteractiveConsole(InteractiveInterpreter): def __init__(self, locals: Optional[Mapping[str, Any]] = ..., filename: str = ...) -> None: ... if sys.version_info >= (3, 6): def interact(self, banner: Optional[str] = ..., exitmsg: Optional[str] = ...) -> None: ... else: def interact(self, banner: Optional[str] = ...) -> None: ... def push(self, line: str) -> bool: ... def resetbuffer(self) -> None: ... def raw_input(self, prompt: str = ...) -> str: ... if sys.version_info >= (3, 6): def interact( banner: Optional[str] = ..., readfunc: Optional[Callable[[str], str]] = ..., local: Optional[Mapping[str, Any]] = ..., exitmsg: Optional[str] = ..., ) -> None: ... else: def interact( banner: Optional[str] = ..., readfunc: Optional[Callable[[str], str]] = ..., local: Optional[Mapping[str, Any]] = ... ) -> None: ... def compile_command(source: str, filename: str = ..., symbol: str = ...) -> Optional[CodeType]: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/codecs.pyi0000664000175000017500000003003000000000000023640 0ustar00davedave00000000000000import sys import types from abc import abstractmethod from typing import ( IO, Any, BinaryIO, Callable, Generator, Iterable, Iterator, List, Optional, Protocol, Text, TextIO, Tuple, Type, TypeVar, Union, overload, ) from typing_extensions import Literal # TODO: this only satisfies the most common interface, where # bytes (py2 str) is the raw form and str (py2 unicode) is the cooked form. # In the long run, both should become template parameters maybe? # There *are* bytes->bytes and str->str encodings in the standard library. # They are much more common in Python 2 than in Python 3. _Decoded = Text _Encoded = bytes class _Encoder(Protocol): def __call__(self, input: _Decoded, errors: str = ...) -> Tuple[_Encoded, int]: ... # signature of Codec().encode class _Decoder(Protocol): def __call__(self, input: _Encoded, errors: str = ...) -> Tuple[_Decoded, int]: ... # signature of Codec().decode class _StreamReader(Protocol): def __call__(self, stream: IO[_Encoded], errors: str = ...) -> StreamReader: ... class _StreamWriter(Protocol): def __call__(self, stream: IO[_Encoded], errors: str = ...) -> StreamWriter: ... class _IncrementalEncoder(Protocol): def __call__(self, errors: str = ...) -> IncrementalEncoder: ... class _IncrementalDecoder(Protocol): def __call__(self, errors: str = ...) -> IncrementalDecoder: ... # The type ignore on `encode` and `decode` is to avoid issues with overlapping overloads, for more details, see #300 # mypy and pytype disagree about where the type ignore can and cannot go, so alias the long type _BytesToBytesEncodingT = Literal[ "base64", "base_64", "base64_codec", "bz2", "bz2_codec", "hex", "hex_codec", "quopri", "quotedprintable", "quoted_printable", "quopri_codec", "uu", "uu_codec", "zip", "zlib", "zlib_codec", ] @overload def encode(obj: bytes, encoding: _BytesToBytesEncodingT, errors: str = ...) -> bytes: ... @overload def encode(obj: str, encoding: Literal["rot13", "rot_13"] = ..., errors: str = ...) -> str: ... # type: ignore @overload def encode(obj: _Decoded, encoding: str = ..., errors: str = ...) -> _Encoded: ... @overload def decode(obj: bytes, encoding: _BytesToBytesEncodingT, errors: str = ...) -> bytes: ... # type: ignore @overload def decode(obj: str, encoding: Literal["rot13", "rot_13"] = ..., errors: str = ...) -> Text: ... @overload def decode(obj: _Encoded, encoding: str = ..., errors: str = ...) -> _Decoded: ... def lookup(__encoding: str) -> CodecInfo: ... def utf_16_be_decode(__obj: _Encoded, __errors: str = ..., __final: bool = ...) -> Tuple[_Decoded, int]: ... # undocumented def utf_16_be_encode(__obj: _Decoded, __errors: str = ...) -> Tuple[_Encoded, int]: ... # undocumented class CodecInfo(Tuple[_Encoder, _Decoder, _StreamReader, _StreamWriter]): @property def encode(self) -> _Encoder: ... @property def decode(self) -> _Decoder: ... @property def streamreader(self) -> _StreamReader: ... @property def streamwriter(self) -> _StreamWriter: ... @property def incrementalencoder(self) -> _IncrementalEncoder: ... @property def incrementaldecoder(self) -> _IncrementalDecoder: ... name: str def __new__( cls, encode: _Encoder, decode: _Decoder, streamreader: Optional[_StreamReader] = ..., streamwriter: Optional[_StreamWriter] = ..., incrementalencoder: Optional[_IncrementalEncoder] = ..., incrementaldecoder: Optional[_IncrementalDecoder] = ..., name: Optional[str] = ..., *, _is_text_encoding: Optional[bool] = ..., ) -> CodecInfo: ... def getencoder(encoding: str) -> _Encoder: ... def getdecoder(encoding: str) -> _Decoder: ... def getincrementalencoder(encoding: str) -> _IncrementalEncoder: ... def getincrementaldecoder(encoding: str) -> _IncrementalDecoder: ... def getreader(encoding: str) -> _StreamReader: ... def getwriter(encoding: str) -> _StreamWriter: ... def register(__search_function: Callable[[str], Optional[CodecInfo]]) -> None: ... def open( filename: str, mode: str = ..., encoding: Optional[str] = ..., errors: str = ..., buffering: int = ... ) -> StreamReaderWriter: ... def EncodedFile( file: IO[_Encoded], data_encoding: str, file_encoding: Optional[str] = ..., errors: str = ... ) -> StreamRecoder: ... def iterencode(iterator: Iterable[_Decoded], encoding: str, errors: str = ...) -> Generator[_Encoded, None, None]: ... def iterdecode(iterator: Iterable[_Encoded], encoding: str, errors: str = ...) -> Generator[_Decoded, None, None]: ... BOM: bytes BOM_BE: bytes BOM_LE: bytes BOM_UTF8: bytes BOM_UTF16: bytes BOM_UTF16_BE: bytes BOM_UTF16_LE: bytes BOM_UTF32: bytes BOM_UTF32_BE: bytes BOM_UTF32_LE: bytes # It is expected that different actions be taken depending on which of the # three subclasses of `UnicodeError` is actually ...ed. However, the Union # is still needed for at least one of the cases. def register_error(__errors: str, __handler: Callable[[UnicodeError], Tuple[Union[str, bytes], int]]) -> None: ... def lookup_error(__name: str) -> Callable[[UnicodeError], Tuple[Union[str, bytes], int]]: ... def strict_errors(exception: UnicodeError) -> Tuple[Union[str, bytes], int]: ... def replace_errors(exception: UnicodeError) -> Tuple[Union[str, bytes], int]: ... def ignore_errors(exception: UnicodeError) -> Tuple[Union[str, bytes], int]: ... def xmlcharrefreplace_errors(exception: UnicodeError) -> Tuple[Union[str, bytes], int]: ... def backslashreplace_errors(exception: UnicodeError) -> Tuple[Union[str, bytes], int]: ... class Codec: # These are sort of @abstractmethod but sort of not. # The StreamReader and StreamWriter subclasses only implement one. def encode(self, input: _Decoded, errors: str = ...) -> Tuple[_Encoded, int]: ... def decode(self, input: _Encoded, errors: str = ...) -> Tuple[_Decoded, int]: ... class IncrementalEncoder: errors: str def __init__(self, errors: str = ...) -> None: ... @abstractmethod def encode(self, object: _Decoded, final: bool = ...) -> _Encoded: ... def reset(self) -> None: ... # documentation says int but str is needed for the subclass. def getstate(self) -> Union[int, _Decoded]: ... def setstate(self, state: Union[int, _Decoded]) -> None: ... class IncrementalDecoder: errors: str def __init__(self, errors: str = ...) -> None: ... @abstractmethod def decode(self, input: _Encoded, final: bool = ...) -> _Decoded: ... def reset(self) -> None: ... def getstate(self) -> Tuple[_Encoded, int]: ... def setstate(self, state: Tuple[_Encoded, int]) -> None: ... # These are not documented but used in encodings/*.py implementations. class BufferedIncrementalEncoder(IncrementalEncoder): buffer: str def __init__(self, errors: str = ...) -> None: ... @abstractmethod def _buffer_encode(self, input: _Decoded, errors: str, final: bool) -> _Encoded: ... def encode(self, input: _Decoded, final: bool = ...) -> _Encoded: ... class BufferedIncrementalDecoder(IncrementalDecoder): buffer: bytes def __init__(self, errors: str = ...) -> None: ... @abstractmethod def _buffer_decode(self, input: _Encoded, errors: str, final: bool) -> Tuple[_Decoded, int]: ... def decode(self, object: _Encoded, final: bool = ...) -> _Decoded: ... _SW = TypeVar("_SW", bound=StreamWriter) # TODO: it is not possible to specify the requirement that all other # attributes and methods are passed-through from the stream. class StreamWriter(Codec): errors: str def __init__(self, stream: IO[_Encoded], errors: str = ...) -> None: ... def write(self, obj: _Decoded) -> None: ... def writelines(self, list: Iterable[_Decoded]) -> None: ... def reset(self) -> None: ... def __enter__(self: _SW) -> _SW: ... def __exit__( self, typ: Optional[Type[BaseException]], exc: Optional[BaseException], tb: Optional[types.TracebackType] ) -> None: ... def __getattr__(self, name: str) -> Any: ... _SR = TypeVar("_SR", bound=StreamReader) class StreamReader(Codec): errors: str def __init__(self, stream: IO[_Encoded], errors: str = ...) -> None: ... def read(self, size: int = ..., chars: int = ..., firstline: bool = ...) -> _Decoded: ... def readline(self, size: int = ..., keepends: bool = ...) -> _Decoded: ... def readlines(self, sizehint: int = ..., keepends: bool = ...) -> List[_Decoded]: ... def reset(self) -> None: ... def __enter__(self: _SR) -> _SR: ... def __exit__( self, typ: Optional[Type[BaseException]], exc: Optional[BaseException], tb: Optional[types.TracebackType] ) -> None: ... def __iter__(self) -> Iterator[_Decoded]: ... def __getattr__(self, name: str) -> Any: ... _T = TypeVar("_T", bound=StreamReaderWriter) # Doesn't actually inherit from TextIO, but wraps a BinaryIO to provide text reading and writing # and delegates attributes to the underlying binary stream with __getattr__. class StreamReaderWriter(TextIO): def __init__(self, stream: IO[_Encoded], Reader: _StreamReader, Writer: _StreamWriter, errors: str = ...) -> None: ... def read(self, size: int = ...) -> _Decoded: ... def readline(self, size: Optional[int] = ...) -> _Decoded: ... def readlines(self, sizehint: Optional[int] = ...) -> List[_Decoded]: ... if sys.version_info >= (3,): def __next__(self) -> Text: ... else: def next(self) -> Text: ... def __iter__(self: _T) -> _T: ... # This actually returns None, but that's incompatible with the supertype def write(self, data: _Decoded) -> int: ... def writelines(self, list: Iterable[_Decoded]) -> None: ... def reset(self) -> None: ... # Same as write() def seek(self, offset: int, whence: int = ...) -> int: ... def __enter__(self: _T) -> _T: ... def __exit__( self, typ: Optional[Type[BaseException]], exc: Optional[BaseException], tb: Optional[types.TracebackType] ) -> None: ... def __getattr__(self, name: str) -> Any: ... # These methods don't actually exist directly, but they are needed to satisfy the TextIO # interface. At runtime, they are delegated through __getattr__. def close(self) -> None: ... def fileno(self) -> int: ... def flush(self) -> None: ... def isatty(self) -> bool: ... def readable(self) -> bool: ... def truncate(self, size: Optional[int] = ...) -> int: ... def seekable(self) -> bool: ... def tell(self) -> int: ... def writable(self) -> bool: ... _SRT = TypeVar("_SRT", bound=StreamRecoder) class StreamRecoder(BinaryIO): def __init__( self, stream: IO[_Encoded], encode: _Encoder, decode: _Decoder, Reader: _StreamReader, Writer: _StreamWriter, errors: str = ..., ) -> None: ... def read(self, size: int = ...) -> bytes: ... def readline(self, size: Optional[int] = ...) -> bytes: ... def readlines(self, sizehint: Optional[int] = ...) -> List[bytes]: ... if sys.version_info >= (3,): def __next__(self) -> bytes: ... else: def next(self) -> bytes: ... def __iter__(self: _SRT) -> _SRT: ... def write(self, data: bytes) -> int: ... def writelines(self, list: Iterable[bytes]) -> int: ... # type: ignore # it's supposed to return None def reset(self) -> None: ... def __getattr__(self, name: str) -> Any: ... def __enter__(self: _SRT) -> _SRT: ... def __exit__( self, type: Optional[Type[BaseException]], value: Optional[BaseException], tb: Optional[types.TracebackType] ) -> None: ... # These methods don't actually exist directly, but they are needed to satisfy the BinaryIO # interface. At runtime, they are delegated through __getattr__. def seek(self, offset: int, whence: int = ...) -> int: ... def close(self) -> None: ... def fileno(self) -> int: ... def flush(self) -> None: ... def isatty(self) -> bool: ... def readable(self) -> bool: ... def truncate(self, size: Optional[int] = ...) -> int: ... def seekable(self) -> bool: ... def tell(self) -> int: ... def writable(self) -> bool: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/codeop.pyi0000664000175000017500000000075100000000000023660 0ustar00davedave00000000000000from types import CodeType from typing import Optional def compile_command(source: str, filename: str = ..., symbol: str = ...) -> Optional[CodeType]: ... class Compile: flags: int def __init__(self) -> None: ... def __call__(self, source: str, filename: str, symbol: str) -> CodeType: ... class CommandCompiler: compiler: Compile def __init__(self) -> None: ... def __call__(self, source: str, filename: str = ..., symbol: str = ...) -> Optional[CodeType]: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/colorsys.pyi0000664000175000017500000000110200000000000024253 0ustar00davedave00000000000000from typing import Tuple def rgb_to_yiq(r: float, g: float, b: float) -> Tuple[float, float, float]: ... def yiq_to_rgb(y: float, i: float, q: float) -> Tuple[float, float, float]: ... def rgb_to_hls(r: float, g: float, b: float) -> Tuple[float, float, float]: ... def hls_to_rgb(h: float, l: float, s: float) -> Tuple[float, float, float]: ... def rgb_to_hsv(r: float, g: float, b: float) -> Tuple[float, float, float]: ... def hsv_to_rgb(h: float, s: float, v: float) -> Tuple[float, float, float]: ... # TODO undocumented ONE_SIXTH: float ONE_THIRD: float TWO_THIRD: float ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/contextlib.pyi0000664000175000017500000001050300000000000024556 0ustar00davedave00000000000000import sys from types import TracebackType from typing import IO, Any, Callable, ContextManager, Iterable, Iterator, Optional, Type, TypeVar, overload if sys.version_info >= (3, 5): from typing import AsyncContextManager, AsyncIterator if sys.version_info >= (3, 6): AbstractContextManager = ContextManager if sys.version_info >= (3, 7): AbstractAsyncContextManager = AsyncContextManager _T = TypeVar("_T") _T_co = TypeVar("_T_co", covariant=True) _T_io = TypeVar("_T_io", bound=Optional[IO[str]]) _F = TypeVar("_F", bound=Callable[..., Any]) _ExitFunc = Callable[[Optional[Type[BaseException]], Optional[BaseException], Optional[TracebackType]], bool] _CM_EF = TypeVar("_CM_EF", ContextManager[Any], _ExitFunc) if sys.version_info >= (3, 2): class _GeneratorContextManager(ContextManager[_T_co]): def __call__(self, func: _F) -> _F: ... def contextmanager(func: Callable[..., Iterator[_T]]) -> Callable[..., _GeneratorContextManager[_T]]: ... else: class GeneratorContextManager(ContextManager[_T_co]): def __call__(self, func: _F) -> _F: ... def contextmanager(func: Callable[..., Iterator[_T]]) -> Callable[..., ContextManager[_T]]: ... if sys.version_info >= (3, 7): def asynccontextmanager(func: Callable[..., AsyncIterator[_T]]) -> Callable[..., AsyncContextManager[_T]]: ... if sys.version_info < (3,): def nested(*mgr: ContextManager[Any]) -> ContextManager[Iterable[Any]]: ... class closing(ContextManager[_T]): def __init__(self, thing: _T) -> None: ... if sys.version_info >= (3, 4): class suppress(ContextManager[None]): def __init__(self, *exceptions: Type[BaseException]) -> None: ... def __exit__( self, exctype: Optional[Type[BaseException]], excinst: Optional[BaseException], exctb: Optional[TracebackType] ) -> bool: ... class redirect_stdout(ContextManager[_T_io]): def __init__(self, new_target: _T_io) -> None: ... if sys.version_info >= (3, 5): class redirect_stderr(ContextManager[_T_io]): def __init__(self, new_target: _T_io) -> None: ... if sys.version_info >= (3,): class ContextDecorator: def __call__(self, func: _F) -> _F: ... _U = TypeVar("_U", bound=ExitStack) class ExitStack(ContextManager[ExitStack]): def __init__(self) -> None: ... def enter_context(self, cm: ContextManager[_T]) -> _T: ... def push(self, exit: _CM_EF) -> _CM_EF: ... def callback(self, callback: Callable[..., Any], *args: Any, **kwds: Any) -> Callable[..., Any]: ... def pop_all(self: _U) -> _U: ... def close(self) -> None: ... def __enter__(self: _U) -> _U: ... def __exit__( self, __exc_type: Optional[Type[BaseException]], __exc_value: Optional[BaseException], __traceback: Optional[TracebackType], ) -> bool: ... if sys.version_info >= (3, 7): from typing import Awaitable _S = TypeVar("_S", bound=AsyncExitStack) _ExitCoroFunc = Callable[[Optional[Type[BaseException]], Optional[BaseException], Optional[TracebackType]], Awaitable[bool]] _CallbackCoroFunc = Callable[..., Awaitable[Any]] _ACM_EF = TypeVar("_ACM_EF", AsyncContextManager[Any], _ExitCoroFunc) class AsyncExitStack(AsyncContextManager[AsyncExitStack]): def __init__(self) -> None: ... def enter_context(self, cm: ContextManager[_T]) -> _T: ... def enter_async_context(self, cm: AsyncContextManager[_T]) -> Awaitable[_T]: ... def push(self, exit: _CM_EF) -> _CM_EF: ... def push_async_exit(self, exit: _ACM_EF) -> _ACM_EF: ... def callback(self, callback: Callable[..., Any], *args: Any, **kwds: Any) -> Callable[..., Any]: ... def push_async_callback(self, callback: _CallbackCoroFunc, *args: Any, **kwds: Any) -> _CallbackCoroFunc: ... def pop_all(self: _S) -> _S: ... def aclose(self) -> Awaitable[None]: ... def __aenter__(self: _S) -> Awaitable[_S]: ... def __aexit__( self, __exc_type: Optional[Type[BaseException]], __exc_value: Optional[BaseException], __traceback: Optional[TracebackType], ) -> Awaitable[bool]: ... if sys.version_info >= (3, 7): @overload def nullcontext(enter_result: _T) -> ContextManager[_T]: ... @overload def nullcontext() -> ContextManager[None]: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/copy.pyi0000664000175000017500000000051000000000000023352 0ustar00davedave00000000000000from typing import Any, Dict, Optional, TypeVar _T = TypeVar("_T") # None in CPython but non-None in Jython PyStringMap: Any # Note: memo and _nil are internal kwargs. def deepcopy(x: _T, memo: Optional[Dict[int, Any]] = ..., _nil: Any = ...) -> _T: ... def copy(x: _T) -> _T: ... class Error(Exception): ... error = Error ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/crypt.pyi0000664000175000017500000000121000000000000023537 0ustar00davedave00000000000000import sys from typing import List, Optional, Union if sys.version_info >= (3, 3): class _Method: ... METHOD_CRYPT: _Method METHOD_MD5: _Method METHOD_SHA256: _Method METHOD_SHA512: _Method if sys.version_info >= (3, 7): METHOD_BLOWFISH: _Method methods: List[_Method] if sys.version_info >= (3, 7): def mksalt(method: Optional[_Method] = ..., *, rounds: Optional[int] = ...) -> str: ... else: def mksalt(method: Optional[_Method] = ...) -> str: ... def crypt(word: str, salt: Optional[Union[str, _Method]] = ...) -> str: ... else: def crypt(word: str, salt: str) -> str: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/csv.pyi0000664000175000017500000000527700000000000023212 0ustar00davedave00000000000000import sys from _csv import ( QUOTE_ALL as QUOTE_ALL, QUOTE_MINIMAL as QUOTE_MINIMAL, QUOTE_NONE as QUOTE_NONE, QUOTE_NONNUMERIC as QUOTE_NONNUMERIC, Dialect as Dialect, Error as Error, _DialectLike, _reader, _writer, field_size_limit as field_size_limit, get_dialect as get_dialect, list_dialects as list_dialects, reader as reader, register_dialect as register_dialect, unregister_dialect as unregister_dialect, writer as writer, ) from collections import OrderedDict from typing import Any, Dict, Iterable, Iterator, List, Mapping, Optional, Sequence, Text, Type _DictRow = Mapping[str, Any] class excel(Dialect): delimiter: str quotechar: str doublequote: bool skipinitialspace: bool lineterminator: str quoting: int class excel_tab(excel): delimiter: str if sys.version_info >= (3,): class unix_dialect(Dialect): delimiter: str quotechar: str doublequote: bool skipinitialspace: bool lineterminator: str quoting: int if sys.version_info >= (3, 8): _DRMapping = Dict[str, str] elif sys.version_info >= (3, 6): _DRMapping = OrderedDict[str, str] else: _DRMapping = Dict[str, str] class DictReader(Iterator[_DRMapping]): restkey: Optional[str] restval: Optional[str] reader: _reader dialect: _DialectLike line_num: int fieldnames: Optional[Sequence[str]] def __init__( self, f: Iterable[Text], fieldnames: Optional[Sequence[str]] = ..., restkey: Optional[str] = ..., restval: Optional[str] = ..., dialect: _DialectLike = ..., *args: Any, **kwds: Any, ) -> None: ... def __iter__(self) -> DictReader: ... if sys.version_info >= (3,): def __next__(self) -> _DRMapping: ... else: def next(self) -> _DRMapping: ... class DictWriter(object): fieldnames: Sequence[str] restval: Optional[Any] extrasaction: str writer: _writer def __init__( self, f: Any, fieldnames: Iterable[str], restval: Optional[Any] = ..., extrasaction: str = ..., dialect: _DialectLike = ..., *args: Any, **kwds: Any, ) -> None: ... if sys.version_info >= (3, 8): def writeheader(self) -> Any: ... else: def writeheader(self) -> None: ... def writerow(self, rowdict: _DictRow) -> Any: ... def writerows(self, rowdicts: Iterable[_DictRow]) -> None: ... class Sniffer(object): preferred: List[str] def __init__(self) -> None: ... def sniff(self, sample: str, delimiters: Optional[str] = ...) -> Type[Dialect]: ... def has_header(self, sample: str) -> bool: ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4223793 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/ctypes/0000775000175000017500000000000000000000000023170 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/ctypes/__init__.pyi0000664000175000017500000002716500000000000025465 0ustar00davedave00000000000000import sys from array import array from typing import ( Any, Callable, ClassVar, Generic, Iterable, Iterator, List, Mapping, Optional, Sequence, Text, Tuple, Type, TypeVar, Union as _UnionT, overload, ) if sys.version_info >= (3, 9): from types import GenericAlias _T = TypeVar("_T") _DLLT = TypeVar("_DLLT", bound=CDLL) _CT = TypeVar("_CT", bound=_CData) RTLD_GLOBAL: int = ... RTLD_LOCAL: int = ... DEFAULT_MODE: int = ... class CDLL(object): _func_flags_: ClassVar[int] = ... _func_restype_: ClassVar[_CData] = ... _name: str = ... _handle: int = ... _FuncPtr: Type[_FuncPointer] = ... def __init__( self, name: Optional[str], mode: int = ..., handle: Optional[int] = ..., use_errno: bool = ..., use_last_error: bool = ..., winmode: Optional[int] = ..., ) -> None: ... def __getattr__(self, name: str) -> _NamedFuncPointer: ... def __getitem__(self, name: str) -> _NamedFuncPointer: ... if sys.platform == "win32": class OleDLL(CDLL): ... class WinDLL(CDLL): ... class PyDLL(CDLL): ... class LibraryLoader(Generic[_DLLT]): def __init__(self, dlltype: Type[_DLLT]) -> None: ... def __getattr__(self, name: str) -> _DLLT: ... def __getitem__(self, name: str) -> _DLLT: ... def LoadLibrary(self, name: str) -> _DLLT: ... if sys.version_info >= (3, 9): def __class_getitem__(cls, item: Any) -> GenericAlias: ... cdll: LibraryLoader[CDLL] = ... if sys.platform == "win32": windll: LibraryLoader[WinDLL] = ... oledll: LibraryLoader[OleDLL] = ... pydll: LibraryLoader[PyDLL] = ... pythonapi: PyDLL = ... # Anything that implements the read-write buffer interface. # The buffer interface is defined purely on the C level, so we cannot define a normal Protocol # for it. Instead we have to list the most common stdlib buffer classes in a Union. _WritableBuffer = _UnionT[bytearray, memoryview, array, _CData] # Same as _WritableBuffer, but also includes read-only buffer types (like bytes). _ReadOnlyBuffer = _UnionT[_WritableBuffer, bytes] class _CDataMeta(type): # By default mypy complains about the following two methods, because strictly speaking cls # might not be a Type[_CT]. However this can never actually happen, because the only class that # uses _CDataMeta as its metaclass is _CData. So it's safe to ignore the errors here. def __mul__(cls: Type[_CT], other: int) -> Type[Array[_CT]]: ... # type: ignore def __rmul__(cls: Type[_CT], other: int) -> Type[Array[_CT]]: ... # type: ignore class _CData(metaclass=_CDataMeta): _b_base: int = ... _b_needsfree_: bool = ... _objects: Optional[Mapping[Any, int]] = ... @classmethod def from_buffer(cls: Type[_CT], source: _WritableBuffer, offset: int = ...) -> _CT: ... @classmethod def from_buffer_copy(cls: Type[_CT], source: _ReadOnlyBuffer, offset: int = ...) -> _CT: ... @classmethod def from_address(cls: Type[_CT], address: int) -> _CT: ... @classmethod def from_param(cls: Type[_CT], obj: Any) -> _UnionT[_CT, _CArgObject]: ... @classmethod def in_dll(cls: Type[_CT], library: CDLL, name: str) -> _CT: ... class _CanCastTo(_CData): ... class _PointerLike(_CanCastTo): ... _ECT = Callable[[Optional[Type[_CData]], _FuncPointer, Tuple[_CData, ...]], _CData] _PF = _UnionT[Tuple[int], Tuple[int, str], Tuple[int, str, Any]] class _FuncPointer(_PointerLike, _CData): restype: _UnionT[Type[_CData], Callable[[int], None], None] = ... argtypes: Sequence[Type[_CData]] = ... errcheck: _ECT = ... @overload def __init__(self, address: int) -> None: ... @overload def __init__(self, callable: Callable[..., Any]) -> None: ... @overload def __init__(self, func_spec: Tuple[_UnionT[str, int], CDLL], paramflags: Tuple[_PF, ...] = ...) -> None: ... @overload def __init__(self, vtlb_index: int, name: str, paramflags: Tuple[_PF, ...] = ..., iid: pointer[c_int] = ...) -> None: ... def __call__(self, *args: Any, **kwargs: Any) -> Any: ... class _NamedFuncPointer(_FuncPointer): __name__: str class ArgumentError(Exception): ... def CFUNCTYPE( restype: Optional[Type[_CData]], *argtypes: Type[_CData], use_errno: bool = ..., use_last_error: bool = ... ) -> Type[_FuncPointer]: ... if sys.platform == "win32": def WINFUNCTYPE( restype: Optional[Type[_CData]], *argtypes: Type[_CData], use_errno: bool = ..., use_last_error: bool = ... ) -> Type[_FuncPointer]: ... def PYFUNCTYPE(restype: Optional[Type[_CData]], *argtypes: Type[_CData]) -> Type[_FuncPointer]: ... class _CArgObject: ... # Any type that can be implicitly converted to c_void_p when passed as a C function argument. # (bytes is not included here, see below.) _CVoidPLike = _UnionT[_PointerLike, Array[Any], _CArgObject, int] # Same as above, but including types known to be read-only (i. e. bytes). # This distinction is not strictly necessary (ctypes doesn't differentiate between const # and non-const pointers), but it catches errors like memmove(b'foo', buf, 4) # when memmove(buf, b'foo', 4) was intended. _CVoidConstPLike = _UnionT[_CVoidPLike, bytes] def addressof(obj: _CData) -> int: ... def alignment(obj_or_type: _UnionT[_CData, Type[_CData]]) -> int: ... def byref(obj: _CData, offset: int = ...) -> _CArgObject: ... _CastT = TypeVar("_CastT", bound=_CanCastTo) def cast(obj: _UnionT[_CData, _CArgObject, int], type: Type[_CastT]) -> _CastT: ... def create_string_buffer(init: _UnionT[int, bytes], size: Optional[int] = ...) -> Array[c_char]: ... c_buffer = create_string_buffer def create_unicode_buffer(init: _UnionT[int, Text], size: Optional[int] = ...) -> Array[c_wchar]: ... if sys.platform == "win32": def DllCanUnloadNow() -> int: ... def DllGetClassObject(rclsid: Any, riid: Any, ppv: Any) -> int: ... # TODO not documented def FormatError(code: int) -> str: ... def GetLastError() -> int: ... def get_errno() -> int: ... if sys.platform == "win32": def get_last_error() -> int: ... def memmove(dst: _CVoidPLike, src: _CVoidConstPLike, count: int) -> None: ... def memset(dst: _CVoidPLike, c: int, count: int) -> None: ... def POINTER(type: Type[_CT]) -> Type[pointer[_CT]]: ... # The real ctypes.pointer is a function, not a class. The stub version of pointer behaves like # ctypes._Pointer in that it is the base class for all pointer types. Unlike the real _Pointer, # it can be instantiated directly (to mimic the behavior of the real pointer function). class pointer(Generic[_CT], _PointerLike, _CData): _type_: ClassVar[Type[_CT]] = ... contents: _CT = ... def __init__(self, arg: _CT = ...) -> None: ... @overload def __getitem__(self, i: int) -> _CT: ... @overload def __getitem__(self, s: slice) -> List[_CT]: ... @overload def __setitem__(self, i: int, o: _CT) -> None: ... @overload def __setitem__(self, s: slice, o: Iterable[_CT]) -> None: ... def resize(obj: _CData, size: int) -> None: ... if sys.version_info < (3,): def set_conversion_mode(encoding: str, errors: str) -> Tuple[str, str]: ... def set_errno(value: int) -> int: ... if sys.platform == "win32": def set_last_error(value: int) -> int: ... def sizeof(obj_or_type: _UnionT[_CData, Type[_CData]]) -> int: ... def string_at(address: _CVoidConstPLike, size: int = ...) -> bytes: ... if sys.platform == "win32": def WinError(code: Optional[int] = ..., descr: Optional[str] = ...) -> OSError: ... def wstring_at(address: _CVoidConstPLike, size: int = ...) -> str: ... class _SimpleCData(Generic[_T], _CData): value: _T = ... def __init__(self, value: _T = ...) -> None: ... class c_byte(_SimpleCData[int]): ... class c_char(_SimpleCData[bytes]): def __init__(self, value: _UnionT[int, bytes] = ...) -> None: ... class c_char_p(_PointerLike, _SimpleCData[Optional[bytes]]): def __init__(self, value: Optional[_UnionT[int, bytes]] = ...) -> None: ... class c_double(_SimpleCData[float]): ... class c_longdouble(_SimpleCData[float]): ... class c_float(_SimpleCData[float]): ... class c_int(_SimpleCData[int]): ... class c_int8(_SimpleCData[int]): ... class c_int16(_SimpleCData[int]): ... class c_int32(_SimpleCData[int]): ... class c_int64(_SimpleCData[int]): ... class c_long(_SimpleCData[int]): ... class c_longlong(_SimpleCData[int]): ... class c_short(_SimpleCData[int]): ... class c_size_t(_SimpleCData[int]): ... class c_ssize_t(_SimpleCData[int]): ... class c_ubyte(_SimpleCData[int]): ... class c_uint(_SimpleCData[int]): ... class c_uint8(_SimpleCData[int]): ... class c_uint16(_SimpleCData[int]): ... class c_uint32(_SimpleCData[int]): ... class c_uint64(_SimpleCData[int]): ... class c_ulong(_SimpleCData[int]): ... class c_ulonglong(_SimpleCData[int]): ... class c_ushort(_SimpleCData[int]): ... class c_void_p(_PointerLike, _SimpleCData[Optional[int]]): ... class c_wchar(_SimpleCData[Text]): ... class c_wchar_p(_PointerLike, _SimpleCData[Optional[Text]]): def __init__(self, value: Optional[_UnionT[int, Text]] = ...) -> None: ... class c_bool(_SimpleCData[bool]): def __init__(self, value: bool = ...) -> None: ... if sys.platform == "win32": class HRESULT(_SimpleCData[int]): ... # TODO undocumented class py_object(_CanCastTo, _SimpleCData[_T]): ... class _CField: offset: int = ... size: int = ... class _StructUnionMeta(_CDataMeta): _fields_: Sequence[_UnionT[Tuple[str, Type[_CData]], Tuple[str, Type[_CData], int]]] = ... _pack_: int = ... _anonymous_: Sequence[str] = ... def __getattr__(self, name: str) -> _CField: ... class _StructUnionBase(_CData, metaclass=_StructUnionMeta): def __init__(self, *args: Any, **kw: Any) -> None: ... def __getattr__(self, name: str) -> Any: ... def __setattr__(self, name: str, value: Any) -> None: ... class Union(_StructUnionBase): ... class Structure(_StructUnionBase): ... class BigEndianStructure(Structure): ... class LittleEndianStructure(Structure): ... class Array(Generic[_CT], _CData): _length_: ClassVar[int] = ... _type_: ClassVar[Type[_CT]] = ... raw: bytes = ... # Note: only available if _CT == c_char value: Any = ... # Note: bytes if _CT == c_char, Text if _CT == c_wchar, unavailable otherwise # TODO These methods cannot be annotated correctly at the moment. # All of these "Any"s stand for the array's element type, but it's not possible to use _CT # here, because of a special feature of ctypes. # By default, when accessing an element of an Array[_CT], the returned object has type _CT. # However, when _CT is a "simple type" like c_int, ctypes automatically "unboxes" the object # and converts it to the corresponding Python primitive. For example, when accessing an element # of an Array[c_int], a Python int object is returned, not a c_int. # This behavior does *not* apply to subclasses of "simple types". # If MyInt is a subclass of c_int, then accessing an element of an Array[MyInt] returns # a MyInt, not an int. # This special behavior is not easy to model in a stub, so for now all places where # the array element type would belong are annotated with Any instead. def __init__(self, *args: Any) -> None: ... @overload def __getitem__(self, i: int) -> Any: ... @overload def __getitem__(self, s: slice) -> List[Any]: ... @overload def __setitem__(self, i: int, o: Any) -> None: ... @overload def __setitem__(self, s: slice, o: Iterable[Any]) -> None: ... def __iter__(self) -> Iterator[Any]: ... # Can't inherit from Sized because the metaclass conflict between # Sized and _CData prevents using _CDataMeta. def __len__(self) -> int: ... if sys.version_info >= (3, 9): def __class_getitem__(cls, item: Any) -> GenericAlias: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/ctypes/util.pyi0000664000175000017500000000024300000000000024667 0ustar00davedave00000000000000import sys from typing import Optional def find_library(name: str) -> Optional[str]: ... if sys.platform == "win32": def find_msvcrt() -> Optional[str]: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/ctypes/wintypes.pyi0000664000175000017500000001104200000000000025573 0ustar00davedave00000000000000from ctypes import ( Array, Structure, _SimpleCData, c_byte, c_char, c_char_p, c_double, c_float, c_int, c_long, c_longlong, c_short, c_uint, c_ulong, c_ulonglong, c_ushort, c_void_p, c_wchar, c_wchar_p, pointer, ) BYTE = c_byte WORD = c_ushort DWORD = c_ulong CHAR = c_char WCHAR = c_wchar UINT = c_uint INT = c_int DOUBLE = c_double FLOAT = c_float BOOLEAN = BYTE BOOL = c_long class VARIANT_BOOL(_SimpleCData[bool]): ... ULONG = c_ulong LONG = c_long USHORT = c_ushort SHORT = c_short LARGE_INTEGER = c_longlong _LARGE_INTEGER = c_longlong ULARGE_INTEGER = c_ulonglong _ULARGE_INTEGER = c_ulonglong OLESTR = c_wchar_p LPOLESTR = c_wchar_p LPCOLESTR = c_wchar_p LPWSTR = c_wchar_p LPCWSTR = c_wchar_p LPSTR = c_char_p LPCSTR = c_char_p LPVOID = c_void_p LPCVOID = c_void_p # These two types are pointer-sized unsigned and signed ints, respectively. # At runtime, they are either c_[u]long or c_[u]longlong, depending on the host's pointer size # (they are not really separate classes). class WPARAM(_SimpleCData[int]): ... class LPARAM(_SimpleCData[int]): ... ATOM = WORD LANGID = WORD COLORREF = DWORD LGRPID = DWORD LCTYPE = DWORD LCID = DWORD HANDLE = c_void_p HACCEL = HANDLE HBITMAP = HANDLE HBRUSH = HANDLE HCOLORSPACE = HANDLE HDC = HANDLE HDESK = HANDLE HDWP = HANDLE HENHMETAFILE = HANDLE HFONT = HANDLE HGDIOBJ = HANDLE HGLOBAL = HANDLE HHOOK = HANDLE HICON = HANDLE HINSTANCE = HANDLE HKEY = HANDLE HKL = HANDLE HLOCAL = HANDLE HMENU = HANDLE HMETAFILE = HANDLE HMODULE = HANDLE HMONITOR = HANDLE HPALETTE = HANDLE HPEN = HANDLE HRGN = HANDLE HRSRC = HANDLE HSTR = HANDLE HTASK = HANDLE HWINSTA = HANDLE HWND = HANDLE SC_HANDLE = HANDLE SERVICE_STATUS_HANDLE = HANDLE class RECT(Structure): left: LONG top: LONG right: LONG bottom: LONG RECTL = RECT _RECTL = RECT tagRECT = RECT class _SMALL_RECT(Structure): Left: SHORT Top: SHORT Right: SHORT Bottom: SHORT SMALL_RECT = _SMALL_RECT class _COORD(Structure): X: SHORT Y: SHORT class POINT(Structure): x: LONG y: LONG POINTL = POINT _POINTL = POINT tagPOINT = POINT class SIZE(Structure): cx: LONG cy: LONG SIZEL = SIZE tagSIZE = SIZE def RGB(red: int, green: int, blue: int) -> int: ... class FILETIME(Structure): dwLowDateTime: DWORD dwHighDateTime: DWORD _FILETIME = FILETIME class MSG(Structure): hWnd: HWND message: UINT wParam: WPARAM lParam: LPARAM time: DWORD pt: POINT tagMSG = MSG MAX_PATH: int class WIN32_FIND_DATAA(Structure): dwFileAttributes: DWORD ftCreationTime: FILETIME ftLastAccessTime: FILETIME ftLastWriteTime: FILETIME nFileSizeHigh: DWORD nFileSizeLow: DWORD dwReserved0: DWORD dwReserved1: DWORD cFileName: Array[CHAR] cAlternateFileName: Array[CHAR] class WIN32_FIND_DATAW(Structure): dwFileAttributes: DWORD ftCreationTime: FILETIME ftLastAccessTime: FILETIME ftLastWriteTime: FILETIME nFileSizeHigh: DWORD nFileSizeLow: DWORD dwReserved0: DWORD dwReserved1: DWORD cFileName: Array[WCHAR] cAlternateFileName: Array[WCHAR] # These pointer type definitions use pointer[...] instead of POINTER(...), to allow them # to be used in type annotations. PBOOL = pointer[BOOL] LPBOOL = pointer[BOOL] PBOOLEAN = pointer[BOOLEAN] PBYTE = pointer[BYTE] LPBYTE = pointer[BYTE] PCHAR = pointer[CHAR] LPCOLORREF = pointer[COLORREF] PDWORD = pointer[DWORD] LPDWORD = pointer[DWORD] PFILETIME = pointer[FILETIME] LPFILETIME = pointer[FILETIME] PFLOAT = pointer[FLOAT] PHANDLE = pointer[HANDLE] LPHANDLE = pointer[HANDLE] PHKEY = pointer[HKEY] LPHKL = pointer[HKL] PINT = pointer[INT] LPINT = pointer[INT] PLARGE_INTEGER = pointer[LARGE_INTEGER] PLCID = pointer[LCID] PLONG = pointer[LONG] LPLONG = pointer[LONG] PMSG = pointer[MSG] LPMSG = pointer[MSG] PPOINT = pointer[POINT] LPPOINT = pointer[POINT] PPOINTL = pointer[POINTL] PRECT = pointer[RECT] LPRECT = pointer[RECT] PRECTL = pointer[RECTL] LPRECTL = pointer[RECTL] LPSC_HANDLE = pointer[SC_HANDLE] PSHORT = pointer[SHORT] PSIZE = pointer[SIZE] LPSIZE = pointer[SIZE] PSIZEL = pointer[SIZEL] LPSIZEL = pointer[SIZEL] PSMALL_RECT = pointer[SMALL_RECT] PUINT = pointer[UINT] LPUINT = pointer[UINT] PULARGE_INTEGER = pointer[ULARGE_INTEGER] PULONG = pointer[ULONG] PUSHORT = pointer[USHORT] PWCHAR = pointer[WCHAR] PWIN32_FIND_DATAA = pointer[WIN32_FIND_DATAA] LPWIN32_FIND_DATAA = pointer[WIN32_FIND_DATAA] PWIN32_FIND_DATAW = pointer[WIN32_FIND_DATAW] LPWIN32_FIND_DATAW = pointer[WIN32_FIND_DATAW] PWORD = pointer[WORD] LPWORD = pointer[WORD] ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4223793 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/curses/0000775000175000017500000000000000000000000023165 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/curses/__init__.pyi0000664000175000017500000000056200000000000025452 0ustar00davedave00000000000000from _curses import * # noqa: F403 from _curses import _CursesWindow as _CursesWindow from typing import Any, Callable, TypeVar _T = TypeVar("_T") # available after calling `curses.initscr()` LINES: int COLS: int # available after calling `curses.start_color()` COLORS: int COLOR_PAIRS: int def wrapper(__func: Callable[..., _T], *arg: Any, **kwds: Any) -> _T: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/curses/ascii.pyi0000664000175000017500000000227400000000000025005 0ustar00davedave00000000000000from typing import List, TypeVar, Union _Ch = TypeVar("_Ch", str, int) NUL: int SOH: int STX: int ETX: int EOT: int ENQ: int ACK: int BEL: int BS: int TAB: int HT: int LF: int NL: int VT: int FF: int CR: int SO: int SI: int DLE: int DC1: int DC2: int DC3: int DC4: int NAK: int SYN: int ETB: int CAN: int EM: int SUB: int ESC: int FS: int GS: int RS: int US: int SP: int DEL: int controlnames: List[int] def isalnum(c: Union[str, int]) -> bool: ... def isalpha(c: Union[str, int]) -> bool: ... def isascii(c: Union[str, int]) -> bool: ... def isblank(c: Union[str, int]) -> bool: ... def iscntrl(c: Union[str, int]) -> bool: ... def isdigit(c: Union[str, int]) -> bool: ... def isgraph(c: Union[str, int]) -> bool: ... def islower(c: Union[str, int]) -> bool: ... def isprint(c: Union[str, int]) -> bool: ... def ispunct(c: Union[str, int]) -> bool: ... def isspace(c: Union[str, int]) -> bool: ... def isupper(c: Union[str, int]) -> bool: ... def isxdigit(c: Union[str, int]) -> bool: ... def isctrl(c: Union[str, int]) -> bool: ... def ismeta(c: Union[str, int]) -> bool: ... def ascii(c: _Ch) -> _Ch: ... def ctrl(c: _Ch) -> _Ch: ... def alt(c: _Ch) -> _Ch: ... def unctrl(c: Union[str, int]) -> str: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/curses/panel.pyi0000664000175000017500000000144100000000000025007 0ustar00davedave00000000000000from _curses import _CursesWindow class _Curses_Panel: # type is (note the space in the class name) def above(self) -> _Curses_Panel: ... def below(self) -> _Curses_Panel: ... def bottom(self) -> None: ... def hidden(self) -> bool: ... def hide(self) -> None: ... def move(self, y: int, x: int) -> None: ... def replace(self, win: _CursesWindow) -> None: ... def set_userptr(self, obj: object) -> None: ... def show(self) -> None: ... def top(self) -> None: ... def userptr(self) -> object: ... def window(self) -> _CursesWindow: ... def bottom_panel() -> _Curses_Panel: ... def new_panel(__win: _CursesWindow) -> _Curses_Panel: ... def top_panel() -> _Curses_Panel: ... def update_panels() -> _Curses_Panel: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/curses/textpad.pyi0000664000175000017500000000071100000000000025360 0ustar00davedave00000000000000from _curses import _CursesWindow from typing import Callable, Optional, Union def rectangle(win: _CursesWindow, uly: int, ulx: int, lry: int, lrx: int) -> None: ... class Textbox: stripspaces: bool def __init__(self, win: _CursesWindow, insert_mode: bool = ...) -> None: ... def edit(self, validate: Optional[Callable[[int], int]] = ...) -> str: ... def do_command(self, ch: Union[str, int]) -> None: ... def gather(self) -> str: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/datetime.pyi0000664000175000017500000003063300000000000024205 0ustar00davedave00000000000000import sys from time import struct_time from typing import AnyStr, ClassVar, Optional, SupportsAbs, Tuple, Type, TypeVar, Union, overload _S = TypeVar("_S") if sys.version_info >= (3,): _Text = str else: _Text = Union[str, unicode] MINYEAR: int MAXYEAR: int class tzinfo: def tzname(self, dt: Optional[datetime]) -> Optional[str]: ... def utcoffset(self, dt: Optional[datetime]) -> Optional[timedelta]: ... def dst(self, dt: Optional[datetime]) -> Optional[timedelta]: ... def fromutc(self, dt: datetime) -> datetime: ... if sys.version_info >= (3, 2): class timezone(tzinfo): utc: ClassVar[timezone] min: ClassVar[timezone] max: ClassVar[timezone] def __init__(self, offset: timedelta, name: str = ...) -> None: ... def __hash__(self) -> int: ... _tzinfo = tzinfo class date: min: ClassVar[date] max: ClassVar[date] resolution: ClassVar[timedelta] def __new__(cls: Type[_S], year: int, month: int, day: int) -> _S: ... @classmethod def fromtimestamp(cls: Type[_S], __timestamp: float) -> _S: ... @classmethod def today(cls: Type[_S]) -> _S: ... @classmethod def fromordinal(cls: Type[_S], n: int) -> _S: ... if sys.version_info >= (3, 7): @classmethod def fromisoformat(cls: Type[_S], date_string: str) -> _S: ... if sys.version_info >= (3, 8): @classmethod def fromisocalendar(cls: Type[_S], year: int, week: int, day: int) -> _S: ... @property def year(self) -> int: ... @property def month(self) -> int: ... @property def day(self) -> int: ... def ctime(self) -> str: ... def strftime(self, fmt: _Text) -> str: ... if sys.version_info >= (3,): def __format__(self, fmt: str) -> str: ... else: def __format__(self, fmt: AnyStr) -> AnyStr: ... def isoformat(self) -> str: ... def timetuple(self) -> struct_time: ... def toordinal(self) -> int: ... def replace(self, year: int = ..., month: int = ..., day: int = ...) -> date: ... def __le__(self, other: date) -> bool: ... def __lt__(self, other: date) -> bool: ... def __ge__(self, other: date) -> bool: ... def __gt__(self, other: date) -> bool: ... if sys.version_info >= (3, 8): def __add__(self: _S, other: timedelta) -> _S: ... def __radd__(self: _S, other: timedelta) -> _S: ... else: def __add__(self, other: timedelta) -> date: ... def __radd__(self, other: timedelta) -> date: ... @overload def __sub__(self, other: timedelta) -> date: ... @overload def __sub__(self, other: date) -> timedelta: ... def __hash__(self) -> int: ... def weekday(self) -> int: ... def isoweekday(self) -> int: ... def isocalendar(self) -> Tuple[int, int, int]: ... class time: min: ClassVar[time] max: ClassVar[time] resolution: ClassVar[timedelta] if sys.version_info >= (3, 6): def __init__( self, hour: int = ..., minute: int = ..., second: int = ..., microsecond: int = ..., tzinfo: Optional[_tzinfo] = ..., *, fold: int = ..., ) -> None: ... else: def __init__( self, hour: int = ..., minute: int = ..., second: int = ..., microsecond: int = ..., tzinfo: Optional[_tzinfo] = ... ) -> None: ... @property def hour(self) -> int: ... @property def minute(self) -> int: ... @property def second(self) -> int: ... @property def microsecond(self) -> int: ... @property def tzinfo(self) -> Optional[_tzinfo]: ... if sys.version_info >= (3, 6): @property def fold(self) -> int: ... def __le__(self, other: time) -> bool: ... def __lt__(self, other: time) -> bool: ... def __ge__(self, other: time) -> bool: ... def __gt__(self, other: time) -> bool: ... def __hash__(self) -> int: ... if sys.version_info >= (3, 6): def isoformat(self, timespec: str = ...) -> str: ... else: def isoformat(self) -> str: ... if sys.version_info >= (3, 7): @classmethod def fromisoformat(cls: Type[_S], time_string: str) -> _S: ... def strftime(self, fmt: _Text) -> str: ... if sys.version_info >= (3,): def __format__(self, fmt: str) -> str: ... else: def __format__(self, fmt: AnyStr) -> AnyStr: ... def utcoffset(self) -> Optional[timedelta]: ... def tzname(self) -> Optional[str]: ... def dst(self) -> Optional[timedelta]: ... if sys.version_info >= (3, 6): def replace( self, hour: int = ..., minute: int = ..., second: int = ..., microsecond: int = ..., tzinfo: Optional[_tzinfo] = ..., *, fold: int = ..., ) -> time: ... else: def replace( self, hour: int = ..., minute: int = ..., second: int = ..., microsecond: int = ..., tzinfo: Optional[_tzinfo] = ... ) -> time: ... _date = date _time = time class timedelta(SupportsAbs[timedelta]): min: ClassVar[timedelta] max: ClassVar[timedelta] resolution: ClassVar[timedelta] if sys.version_info >= (3, 6): def __init__( self, days: float = ..., seconds: float = ..., microseconds: float = ..., milliseconds: float = ..., minutes: float = ..., hours: float = ..., weeks: float = ..., *, fold: int = ..., ) -> None: ... else: def __init__( self, days: float = ..., seconds: float = ..., microseconds: float = ..., milliseconds: float = ..., minutes: float = ..., hours: float = ..., weeks: float = ..., ) -> None: ... @property def days(self) -> int: ... @property def seconds(self) -> int: ... @property def microseconds(self) -> int: ... def total_seconds(self) -> float: ... def __add__(self, other: timedelta) -> timedelta: ... def __radd__(self, other: timedelta) -> timedelta: ... def __sub__(self, other: timedelta) -> timedelta: ... def __rsub__(self, other: timedelta) -> timedelta: ... def __neg__(self) -> timedelta: ... def __pos__(self) -> timedelta: ... def __abs__(self) -> timedelta: ... def __mul__(self, other: float) -> timedelta: ... def __rmul__(self, other: float) -> timedelta: ... @overload def __floordiv__(self, other: timedelta) -> int: ... @overload def __floordiv__(self, other: int) -> timedelta: ... if sys.version_info >= (3,): @overload def __truediv__(self, other: timedelta) -> float: ... @overload def __truediv__(self, other: float) -> timedelta: ... def __mod__(self, other: timedelta) -> timedelta: ... def __divmod__(self, other: timedelta) -> Tuple[int, timedelta]: ... else: @overload def __div__(self, other: timedelta) -> float: ... @overload def __div__(self, other: float) -> timedelta: ... def __le__(self, other: timedelta) -> bool: ... def __lt__(self, other: timedelta) -> bool: ... def __ge__(self, other: timedelta) -> bool: ... def __gt__(self, other: timedelta) -> bool: ... def __hash__(self) -> int: ... class datetime(date): min: ClassVar[datetime] max: ClassVar[datetime] resolution: ClassVar[timedelta] if sys.version_info >= (3, 6): def __new__( cls: Type[_S], year: int, month: int, day: int, hour: int = ..., minute: int = ..., second: int = ..., microsecond: int = ..., tzinfo: Optional[_tzinfo] = ..., *, fold: int = ..., ) -> _S: ... else: def __new__( cls: Type[_S], year: int, month: int, day: int, hour: int = ..., minute: int = ..., second: int = ..., microsecond: int = ..., tzinfo: Optional[_tzinfo] = ..., ) -> _S: ... @property def year(self) -> int: ... @property def month(self) -> int: ... @property def day(self) -> int: ... @property def hour(self) -> int: ... @property def minute(self) -> int: ... @property def second(self) -> int: ... @property def microsecond(self) -> int: ... @property def tzinfo(self) -> Optional[_tzinfo]: ... if sys.version_info >= (3, 6): @property def fold(self) -> int: ... @classmethod def fromtimestamp(cls: Type[_S], t: float, tz: Optional[_tzinfo] = ...) -> _S: ... @classmethod def utcfromtimestamp(cls: Type[_S], t: float) -> _S: ... @classmethod def today(cls: Type[_S]) -> _S: ... @classmethod def fromordinal(cls: Type[_S], n: int) -> _S: ... if sys.version_info >= (3, 8): @classmethod def now(cls: Type[_S], tz: Optional[_tzinfo] = ...) -> _S: ... else: @overload @classmethod def now(cls: Type[_S], tz: None = ...) -> _S: ... @overload @classmethod def now(cls, tz: _tzinfo) -> datetime: ... @classmethod def utcnow(cls: Type[_S]) -> _S: ... if sys.version_info >= (3, 6): @classmethod def combine(cls, date: _date, time: _time, tzinfo: Optional[_tzinfo] = ...) -> datetime: ... else: @classmethod def combine(cls, date: _date, time: _time) -> datetime: ... if sys.version_info >= (3, 7): @classmethod def fromisoformat(cls: Type[_S], date_string: str) -> _S: ... def strftime(self, fmt: _Text) -> str: ... if sys.version_info >= (3,): def __format__(self, fmt: str) -> str: ... else: def __format__(self, fmt: AnyStr) -> AnyStr: ... def toordinal(self) -> int: ... def timetuple(self) -> struct_time: ... if sys.version_info >= (3, 3): def timestamp(self) -> float: ... def utctimetuple(self) -> struct_time: ... def date(self) -> _date: ... def time(self) -> _time: ... def timetz(self) -> _time: ... if sys.version_info >= (3, 6): def replace( self, year: int = ..., month: int = ..., day: int = ..., hour: int = ..., minute: int = ..., second: int = ..., microsecond: int = ..., tzinfo: Optional[_tzinfo] = ..., *, fold: int = ..., ) -> datetime: ... else: def replace( self, year: int = ..., month: int = ..., day: int = ..., hour: int = ..., minute: int = ..., second: int = ..., microsecond: int = ..., tzinfo: Optional[_tzinfo] = ..., ) -> datetime: ... if sys.version_info >= (3, 8): def astimezone(self: _S, tz: Optional[_tzinfo] = ...) -> _S: ... elif sys.version_info >= (3, 3): def astimezone(self, tz: Optional[_tzinfo] = ...) -> datetime: ... else: def astimezone(self, tz: _tzinfo) -> datetime: ... def ctime(self) -> str: ... if sys.version_info >= (3, 6): def isoformat(self, sep: str = ..., timespec: str = ...) -> str: ... else: def isoformat(self, sep: str = ...) -> str: ... @classmethod def strptime(cls, date_string: _Text, format: _Text) -> datetime: ... def utcoffset(self) -> Optional[timedelta]: ... def tzname(self) -> Optional[str]: ... def dst(self) -> Optional[timedelta]: ... def __le__(self, other: datetime) -> bool: ... # type: ignore def __lt__(self, other: datetime) -> bool: ... # type: ignore def __ge__(self, other: datetime) -> bool: ... # type: ignore def __gt__(self, other: datetime) -> bool: ... # type: ignore if sys.version_info >= (3, 8): def __add__(self: _S, other: timedelta) -> _S: ... def __radd__(self: _S, other: timedelta) -> _S: ... else: def __add__(self, other: timedelta) -> datetime: ... def __radd__(self, other: timedelta) -> datetime: ... @overload # type: ignore def __sub__(self, other: datetime) -> timedelta: ... @overload def __sub__(self, other: timedelta) -> datetime: ... def __hash__(self) -> int: ... def weekday(self) -> int: ... def isoweekday(self) -> int: ... def isocalendar(self) -> Tuple[int, int, int]: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/decimal.pyi0000664000175000017500000004257300000000000024015 0ustar00davedave00000000000000import numbers import sys from types import TracebackType from typing import Any, Container, Dict, List, NamedTuple, Optional, Sequence, Text, Tuple, Type, TypeVar, Union, overload _Decimal = Union[Decimal, int] _DecimalNew = Union[Decimal, float, Text, Tuple[int, Sequence[int], int]] if sys.version_info >= (3,): _ComparableNum = Union[Decimal, float, numbers.Rational] else: _ComparableNum = Union[Decimal, float] _DecimalT = TypeVar("_DecimalT", bound=Decimal) class DecimalTuple(NamedTuple): sign: int digits: Tuple[int, ...] exponent: int ROUND_DOWN: str ROUND_HALF_UP: str ROUND_HALF_EVEN: str ROUND_CEILING: str ROUND_FLOOR: str ROUND_UP: str ROUND_HALF_DOWN: str ROUND_05UP: str if sys.version_info >= (3,): HAVE_THREADS: bool MAX_EMAX: int MAX_PREC: int MIN_EMIN: int MIN_ETINY: int class DecimalException(ArithmeticError): if sys.version_info < (3,): def handle(self, context: Context, *args: Any) -> Optional[Decimal]: ... class Clamped(DecimalException): ... class InvalidOperation(DecimalException): ... class ConversionSyntax(InvalidOperation): ... class DivisionByZero(DecimalException, ZeroDivisionError): ... class DivisionImpossible(InvalidOperation): ... class DivisionUndefined(InvalidOperation, ZeroDivisionError): ... class Inexact(DecimalException): ... class InvalidContext(InvalidOperation): ... class Rounded(DecimalException): ... class Subnormal(DecimalException): ... class Overflow(Inexact, Rounded): ... class Underflow(Inexact, Rounded, Subnormal): ... if sys.version_info >= (3,): class FloatOperation(DecimalException, TypeError): ... def setcontext(__context: Context) -> None: ... def getcontext() -> Context: ... def localcontext(ctx: Optional[Context] = ...) -> _ContextManager: ... class Decimal(object): def __new__(cls: Type[_DecimalT], value: _DecimalNew = ..., context: Optional[Context] = ...) -> _DecimalT: ... @classmethod def from_float(cls, __f: float) -> Decimal: ... if sys.version_info >= (3,): def __bool__(self) -> bool: ... else: def __nonzero__(self) -> bool: ... def __div__(self, other: _Decimal, context: Optional[Context] = ...) -> Decimal: ... def __rdiv__(self, other: _Decimal, context: Optional[Context] = ...) -> Decimal: ... def __ne__(self, other: object, context: Optional[Context] = ...) -> bool: ... def compare(self, other: _Decimal, context: Optional[Context] = ...) -> Decimal: ... def __hash__(self) -> int: ... def as_tuple(self) -> DecimalTuple: ... if sys.version_info >= (3, 6): def as_integer_ratio(self) -> Tuple[int, int]: ... def to_eng_string(self, context: Optional[Context] = ...) -> str: ... if sys.version_info >= (3,): def __abs__(self) -> Decimal: ... def __add__(self, other: _Decimal) -> Decimal: ... def __divmod__(self, other: _Decimal) -> Tuple[Decimal, Decimal]: ... def __eq__(self, other: object) -> bool: ... def __floordiv__(self, other: _Decimal) -> Decimal: ... def __ge__(self, other: _ComparableNum) -> bool: ... def __gt__(self, other: _ComparableNum) -> bool: ... def __le__(self, other: _ComparableNum) -> bool: ... def __lt__(self, other: _ComparableNum) -> bool: ... def __mod__(self, other: _Decimal) -> Decimal: ... def __mul__(self, other: _Decimal) -> Decimal: ... def __neg__(self) -> Decimal: ... def __pos__(self) -> Decimal: ... def __pow__(self, other: _Decimal, modulo: Optional[_Decimal] = ...) -> Decimal: ... def __radd__(self, other: _Decimal) -> Decimal: ... def __rdivmod__(self, other: _Decimal) -> Tuple[Decimal, Decimal]: ... def __rfloordiv__(self, other: _Decimal) -> Decimal: ... def __rmod__(self, other: _Decimal) -> Decimal: ... def __rmul__(self, other: _Decimal) -> Decimal: ... def __rsub__(self, other: _Decimal) -> Decimal: ... def __rtruediv__(self, other: _Decimal) -> Decimal: ... def __str__(self) -> str: ... def __sub__(self, other: _Decimal) -> Decimal: ... def __truediv__(self, other: _Decimal) -> Decimal: ... else: def __abs__(self, round: bool = ..., context: Optional[Context] = ...) -> Decimal: ... def __add__(self, other: _Decimal, context: Optional[Context] = ...) -> Decimal: ... def __divmod__(self, other: _Decimal, context: Optional[Context] = ...) -> Tuple[Decimal, Decimal]: ... def __eq__(self, other: object, context: Optional[Context] = ...) -> bool: ... def __floordiv__(self, other: _Decimal, context: Optional[Context] = ...) -> Decimal: ... def __ge__(self, other: _ComparableNum, context: Optional[Context] = ...) -> bool: ... def __gt__(self, other: _ComparableNum, context: Optional[Context] = ...) -> bool: ... def __le__(self, other: _ComparableNum, context: Optional[Context] = ...) -> bool: ... def __lt__(self, other: _ComparableNum, context: Optional[Context] = ...) -> bool: ... def __mod__(self, other: _Decimal, context: Optional[Context] = ...) -> Decimal: ... def __mul__(self, other: _Decimal, context: Optional[Context] = ...) -> Decimal: ... def __neg__(self, context: Optional[Context] = ...) -> Decimal: ... def __pos__(self, context: Optional[Context] = ...) -> Decimal: ... def __pow__(self, other: _Decimal, modulo: Optional[_Decimal] = ..., context: Optional[Context] = ...) -> Decimal: ... def __radd__(self, other: _Decimal, context: Optional[Context] = ...) -> Decimal: ... def __rdivmod__(self, other: _Decimal, context: Optional[Context] = ...) -> Tuple[Decimal, Decimal]: ... def __rfloordiv__(self, other: _Decimal, context: Optional[Context] = ...) -> Decimal: ... def __rmod__(self, other: _Decimal, context: Optional[Context] = ...) -> Decimal: ... def __rmul__(self, other: _Decimal, context: Optional[Context] = ...) -> Decimal: ... def __rsub__(self, other: _Decimal, context: Optional[Context] = ...) -> Decimal: ... def __rtruediv__(self, other: _Decimal, context: Optional[Context] = ...) -> Decimal: ... def __str__(self, eng: bool = ..., context: Optional[Context] = ...) -> str: ... def __sub__(self, other: _Decimal, context: Optional[Context] = ...) -> Decimal: ... def __truediv__(self, other: _Decimal, context: Optional[Context] = ...) -> Decimal: ... def remainder_near(self, other: _Decimal, context: Optional[Context] = ...) -> Decimal: ... def __float__(self) -> float: ... def __int__(self) -> int: ... def __trunc__(self) -> int: ... @property def real(self) -> Decimal: ... @property def imag(self) -> Decimal: ... def conjugate(self) -> Decimal: ... def __complex__(self) -> complex: ... if sys.version_info >= (3,): @overload def __round__(self) -> int: ... @overload def __round__(self, ndigits: int) -> Decimal: ... def __floor__(self) -> int: ... def __ceil__(self) -> int: ... else: def __long__(self) -> long: ... def fma(self, other: _Decimal, third: _Decimal, context: Optional[Context] = ...) -> Decimal: ... def __rpow__(self, other: _Decimal, context: Optional[Context] = ...) -> Decimal: ... def normalize(self, context: Optional[Context] = ...) -> Decimal: ... if sys.version_info >= (3,): def quantize(self, exp: _Decimal, rounding: Optional[str] = ..., context: Optional[Context] = ...) -> Decimal: ... def same_quantum(self, other: _Decimal, context: Optional[Context] = ...) -> bool: ... else: def quantize( self, exp: _Decimal, rounding: Optional[str] = ..., context: Optional[Context] = ..., watchexp: bool = ... ) -> Decimal: ... def same_quantum(self, other: _Decimal) -> bool: ... def to_integral_exact(self, rounding: Optional[str] = ..., context: Optional[Context] = ...) -> Decimal: ... def to_integral_value(self, rounding: Optional[str] = ..., context: Optional[Context] = ...) -> Decimal: ... def to_integral(self, rounding: Optional[str] = ..., context: Optional[Context] = ...) -> Decimal: ... def sqrt(self, context: Optional[Context] = ...) -> Decimal: ... def max(self, other: _Decimal, context: Optional[Context] = ...) -> Decimal: ... def min(self, other: _Decimal, context: Optional[Context] = ...) -> Decimal: ... def adjusted(self) -> int: ... if sys.version_info >= (3,): def canonical(self) -> Decimal: ... else: def canonical(self, context: Optional[Context] = ...) -> Decimal: ... def compare_signal(self, other: _Decimal, context: Optional[Context] = ...) -> Decimal: ... if sys.version_info >= (3,): def compare_total(self, other: _Decimal, context: Optional[Context] = ...) -> Decimal: ... def compare_total_mag(self, other: _Decimal, context: Optional[Context] = ...) -> Decimal: ... else: def compare_total(self, other: _Decimal) -> Decimal: ... def compare_total_mag(self, other: _Decimal) -> Decimal: ... def copy_abs(self) -> Decimal: ... def copy_negate(self) -> Decimal: ... if sys.version_info >= (3,): def copy_sign(self, other: _Decimal, context: Optional[Context] = ...) -> Decimal: ... else: def copy_sign(self, other: _Decimal) -> Decimal: ... def exp(self, context: Optional[Context] = ...) -> Decimal: ... def is_canonical(self) -> bool: ... def is_finite(self) -> bool: ... def is_infinite(self) -> bool: ... def is_nan(self) -> bool: ... def is_normal(self, context: Optional[Context] = ...) -> bool: ... def is_qnan(self) -> bool: ... def is_signed(self) -> bool: ... def is_snan(self) -> bool: ... def is_subnormal(self, context: Optional[Context] = ...) -> bool: ... def is_zero(self) -> bool: ... def ln(self, context: Optional[Context] = ...) -> Decimal: ... def log10(self, context: Optional[Context] = ...) -> Decimal: ... def logb(self, context: Optional[Context] = ...) -> Decimal: ... def logical_and(self, other: _Decimal, context: Optional[Context] = ...) -> Decimal: ... def logical_invert(self, context: Optional[Context] = ...) -> Decimal: ... def logical_or(self, other: _Decimal, context: Optional[Context] = ...) -> Decimal: ... def logical_xor(self, other: _Decimal, context: Optional[Context] = ...) -> Decimal: ... def max_mag(self, other: _Decimal, context: Optional[Context] = ...) -> Decimal: ... def min_mag(self, other: _Decimal, context: Optional[Context] = ...) -> Decimal: ... def next_minus(self, context: Optional[Context] = ...) -> Decimal: ... def next_plus(self, context: Optional[Context] = ...) -> Decimal: ... def next_toward(self, other: _Decimal, context: Optional[Context] = ...) -> Decimal: ... def number_class(self, context: Optional[Context] = ...) -> str: ... def radix(self) -> Decimal: ... def rotate(self, other: _Decimal, context: Optional[Context] = ...) -> Decimal: ... def scaleb(self, other: _Decimal, context: Optional[Context] = ...) -> Decimal: ... def shift(self, other: _Decimal, context: Optional[Context] = ...) -> Decimal: ... def __reduce__(self) -> Tuple[Type[Decimal], Tuple[str]]: ... def __copy__(self) -> Decimal: ... def __deepcopy__(self, memo: Any) -> Decimal: ... def __format__(self, specifier: str, context: Optional[Context] = ...) -> str: ... class _ContextManager(object): new_context: Context saved_context: Context def __init__(self, new_context: Context) -> None: ... def __enter__(self) -> Context: ... def __exit__(self, t: Optional[Type[BaseException]], v: Optional[BaseException], tb: Optional[TracebackType]) -> None: ... _TrapType = Type[DecimalException] class Context(object): prec: int rounding: str Emin: int Emax: int capitals: int if sys.version_info >= (3,): clamp: int else: _clamp: int traps: Dict[_TrapType, bool] flags: Dict[_TrapType, bool] if sys.version_info >= (3,): def __init__( self, prec: Optional[int] = ..., rounding: Optional[str] = ..., Emin: Optional[int] = ..., Emax: Optional[int] = ..., capitals: Optional[int] = ..., clamp: Optional[int] = ..., flags: Union[None, Dict[_TrapType, bool], Container[_TrapType]] = ..., traps: Union[None, Dict[_TrapType, bool], Container[_TrapType]] = ..., _ignored_flags: Optional[List[_TrapType]] = ..., ) -> None: ... else: def __init__( self, prec: Optional[int] = ..., rounding: Optional[str] = ..., traps: Union[None, Dict[_TrapType, bool], Container[_TrapType]] = ..., flags: Union[None, Dict[_TrapType, bool], Container[_TrapType]] = ..., Emin: Optional[int] = ..., Emax: Optional[int] = ..., capitals: Optional[int] = ..., _clamp: Optional[int] = ..., _ignored_flags: Optional[List[_TrapType]] = ..., ) -> None: ... if sys.version_info >= (3,): # __setattr__() only allows to set a specific set of attributes, # already defined above. def __delattr__(self, name: str) -> None: ... def __reduce__(self) -> Tuple[Type[Context], Tuple[Any, ...]]: ... def clear_flags(self) -> None: ... if sys.version_info >= (3,): def clear_traps(self) -> None: ... def copy(self) -> Context: ... def __copy__(self) -> Context: ... __hash__: Any = ... def Etiny(self) -> int: ... def Etop(self) -> int: ... def create_decimal(self, __num: _DecimalNew = ...) -> Decimal: ... def create_decimal_from_float(self, __f: float) -> Decimal: ... def abs(self, __x: _Decimal) -> Decimal: ... def add(self, __x: _Decimal, __y: _Decimal) -> Decimal: ... def canonical(self, __x: Decimal) -> Decimal: ... def compare(self, __x: _Decimal, __y: _Decimal) -> Decimal: ... def compare_signal(self, __x: _Decimal, __y: _Decimal) -> Decimal: ... def compare_total(self, __x: _Decimal, __y: _Decimal) -> Decimal: ... def compare_total_mag(self, __x: _Decimal, __y: _Decimal) -> Decimal: ... def copy_abs(self, __x: _Decimal) -> Decimal: ... def copy_decimal(self, __x: _Decimal) -> Decimal: ... def copy_negate(self, __x: _Decimal) -> Decimal: ... def copy_sign(self, __x: _Decimal, __y: _Decimal) -> Decimal: ... def divide(self, __x: _Decimal, __y: _Decimal) -> Decimal: ... def divide_int(self, __x: _Decimal, __y: _Decimal) -> Decimal: ... def divmod(self, __x: _Decimal, __y: _Decimal) -> Tuple[Decimal, Decimal]: ... def exp(self, __x: _Decimal) -> Decimal: ... def fma(self, __x: _Decimal, __y: _Decimal, __z: _Decimal) -> Decimal: ... def is_canonical(self, __x: _Decimal) -> bool: ... def is_finite(self, __x: _Decimal) -> bool: ... def is_infinite(self, __x: _Decimal) -> bool: ... def is_nan(self, __x: _Decimal) -> bool: ... def is_normal(self, __x: _Decimal) -> bool: ... def is_qnan(self, __x: _Decimal) -> bool: ... def is_signed(self, __x: _Decimal) -> bool: ... def is_snan(self, __x: _Decimal) -> bool: ... def is_subnormal(self, __x: _Decimal) -> bool: ... def is_zero(self, __x: _Decimal) -> bool: ... def ln(self, __x: _Decimal) -> Decimal: ... def log10(self, __x: _Decimal) -> Decimal: ... def logb(self, __x: _Decimal) -> Decimal: ... def logical_and(self, __x: _Decimal, __y: _Decimal) -> Decimal: ... def logical_invert(self, __x: _Decimal) -> Decimal: ... def logical_or(self, __x: _Decimal, __y: _Decimal) -> Decimal: ... def logical_xor(self, __x: _Decimal, __y: _Decimal) -> Decimal: ... def max(self, __x: _Decimal, __y: _Decimal) -> Decimal: ... def max_mag(self, __x: _Decimal, __y: _Decimal) -> Decimal: ... def min(self, __x: _Decimal, __y: _Decimal) -> Decimal: ... def min_mag(self, __x: _Decimal, __y: _Decimal) -> Decimal: ... def minus(self, __x: _Decimal) -> Decimal: ... def multiply(self, __x: _Decimal, __y: _Decimal) -> Decimal: ... def next_minus(self, __x: _Decimal) -> Decimal: ... def next_plus(self, __x: _Decimal) -> Decimal: ... def next_toward(self, __x: _Decimal, __y: _Decimal) -> Decimal: ... def normalize(self, __x: _Decimal) -> Decimal: ... def number_class(self, __x: _Decimal) -> str: ... def plus(self, __x: _Decimal) -> Decimal: ... def power(self, a: _Decimal, b: _Decimal, modulo: Optional[_Decimal] = ...) -> Decimal: ... def quantize(self, __x: _Decimal, __y: _Decimal) -> Decimal: ... def radix(self) -> Decimal: ... def remainder(self, __x: _Decimal, __y: _Decimal) -> Decimal: ... def remainder_near(self, __x: _Decimal, __y: _Decimal) -> Decimal: ... def rotate(self, __x: _Decimal, __y: _Decimal) -> Decimal: ... def same_quantum(self, __x: _Decimal, __y: _Decimal) -> bool: ... def scaleb(self, __x: _Decimal, __y: _Decimal) -> Decimal: ... def shift(self, __x: _Decimal, __y: _Decimal) -> Decimal: ... def sqrt(self, __x: _Decimal) -> Decimal: ... def subtract(self, __x: _Decimal, __y: _Decimal) -> Decimal: ... def to_eng_string(self, __x: _Decimal) -> str: ... def to_sci_string(self, __x: _Decimal) -> str: ... def to_integral_exact(self, __x: _Decimal) -> Decimal: ... def to_integral_value(self, __x: _Decimal) -> Decimal: ... def to_integral(self, __x: _Decimal) -> Decimal: ... DefaultContext: Context BasicContext: Context ExtendedContext: Context ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/difflib.pyi0000664000175000017500000001151000000000000024001 0ustar00davedave00000000000000import sys from typing import ( Any, AnyStr, Callable, Generic, Iterable, Iterator, List, NamedTuple, Optional, Sequence, Text, Tuple, TypeVar, Union, overload, ) if sys.version_info >= (3, 9): from types import GenericAlias _T = TypeVar("_T") if sys.version_info >= (3,): _StrType = Text else: # Aliases can't point to type vars, so we need to redeclare AnyStr _StrType = TypeVar("_StrType", Text, bytes) _JunkCallback = Union[Callable[[Text], bool], Callable[[str], bool]] class Match(NamedTuple): a: int b: int size: int class SequenceMatcher(Generic[_T]): def __init__( self, isjunk: Optional[Callable[[_T], bool]] = ..., a: Sequence[_T] = ..., b: Sequence[_T] = ..., autojunk: bool = ... ) -> None: ... def set_seqs(self, a: Sequence[_T], b: Sequence[_T]) -> None: ... def set_seq1(self, a: Sequence[_T]) -> None: ... def set_seq2(self, b: Sequence[_T]) -> None: ... if sys.version_info >= (3, 9): def find_longest_match( self, alo: int = ..., ahi: Optional[int] = ..., blo: int = ..., bhi: Optional[int] = ... ) -> Match: ... else: def find_longest_match(self, alo: int, ahi: int, blo: int, bhi: int) -> Match: ... def get_matching_blocks(self) -> List[Match]: ... def get_opcodes(self) -> List[Tuple[str, int, int, int, int]]: ... def get_grouped_opcodes(self, n: int = ...) -> Iterable[List[Tuple[str, int, int, int, int]]]: ... def ratio(self) -> float: ... def quick_ratio(self) -> float: ... def real_quick_ratio(self) -> float: ... if sys.version_info >= (3, 9): def __class_getitem__(cls, item: Any) -> GenericAlias: ... # mypy thinks the signatures of the overloads overlap, but the types still work fine @overload def get_close_matches( # type: ignore word: AnyStr, possibilities: Iterable[AnyStr], n: int = ..., cutoff: float = ... ) -> List[AnyStr]: ... @overload def get_close_matches( word: Sequence[_T], possibilities: Iterable[Sequence[_T]], n: int = ..., cutoff: float = ... ) -> List[Sequence[_T]]: ... class Differ: def __init__(self, linejunk: Optional[_JunkCallback] = ..., charjunk: Optional[_JunkCallback] = ...) -> None: ... def compare(self, a: Sequence[_StrType], b: Sequence[_StrType]) -> Iterator[_StrType]: ... def IS_LINE_JUNK(line: _StrType, pat: Any = ...) -> bool: ... # pat is undocumented def IS_CHARACTER_JUNK(ch: _StrType, ws: _StrType = ...) -> bool: ... # ws is undocumented def unified_diff( a: Sequence[_StrType], b: Sequence[_StrType], fromfile: _StrType = ..., tofile: _StrType = ..., fromfiledate: _StrType = ..., tofiledate: _StrType = ..., n: int = ..., lineterm: _StrType = ..., ) -> Iterator[_StrType]: ... def context_diff( a: Sequence[_StrType], b: Sequence[_StrType], fromfile: _StrType = ..., tofile: _StrType = ..., fromfiledate: _StrType = ..., tofiledate: _StrType = ..., n: int = ..., lineterm: _StrType = ..., ) -> Iterator[_StrType]: ... def ndiff( a: Sequence[_StrType], b: Sequence[_StrType], linejunk: Optional[_JunkCallback] = ..., charjunk: Optional[_JunkCallback] = ... ) -> Iterator[_StrType]: ... class HtmlDiff(object): def __init__( self, tabsize: int = ..., wrapcolumn: Optional[int] = ..., linejunk: Optional[_JunkCallback] = ..., charjunk: Optional[_JunkCallback] = ..., ) -> None: ... if sys.version_info >= (3, 5): def make_file( self, fromlines: Sequence[_StrType], tolines: Sequence[_StrType], fromdesc: _StrType = ..., todesc: _StrType = ..., context: bool = ..., numlines: int = ..., *, charset: str = ..., ) -> _StrType: ... else: def make_file( self, fromlines: Sequence[_StrType], tolines: Sequence[_StrType], fromdesc: _StrType = ..., todesc: _StrType = ..., context: bool = ..., numlines: int = ..., ) -> _StrType: ... def make_table( self, fromlines: Sequence[_StrType], tolines: Sequence[_StrType], fromdesc: _StrType = ..., todesc: _StrType = ..., context: bool = ..., numlines: int = ..., ) -> _StrType: ... def restore(delta: Iterable[_StrType], which: int) -> Iterator[_StrType]: ... if sys.version_info >= (3, 5): def diff_bytes( dfunc: Callable[[Sequence[str], Sequence[str], str, str, str, str, int, str], Iterator[str]], a: Sequence[bytes], b: Sequence[bytes], fromfile: bytes = ..., tofile: bytes = ..., fromfiledate: bytes = ..., tofiledate: bytes = ..., n: int = ..., lineterm: bytes = ..., ) -> Iterator[bytes]: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/dis.pyi0000664000175000017500000000602100000000000023162 0ustar00davedave00000000000000import sys import types from opcode import ( EXTENDED_ARG as EXTENDED_ARG, HAVE_ARGUMENT as HAVE_ARGUMENT, cmp_op as cmp_op, hascompare as hascompare, hasconst as hasconst, hasfree as hasfree, hasjabs as hasjabs, hasjrel as hasjrel, haslocal as haslocal, hasname as hasname, opmap as opmap, opname as opname, ) from typing import IO, Any, Callable, Dict, Iterator, List, NamedTuple, Optional, Tuple, Union if sys.version_info >= (3, 4): from opcode import stack_effect as stack_effect if sys.version_info >= (3, 6): from opcode import hasnargs as hasnargs # Strictly this should not have to include Callable, but mypy doesn't use FunctionType # for functions (python/mypy#3171) _have_code = Union[types.MethodType, types.FunctionType, types.CodeType, type, Callable[..., Any]] _have_code_or_string = Union[_have_code, str, bytes] if sys.version_info >= (3, 4): class Instruction(NamedTuple): opname: str opcode: int arg: Optional[int] argval: Any argrepr: str offset: int starts_line: Optional[int] is_jump_target: bool class Bytecode: codeobj: types.CodeType first_line: int def __init__( self, x: _have_code_or_string, *, first_line: Optional[int] = ..., current_offset: Optional[int] = ... ) -> None: ... def __iter__(self) -> Iterator[Instruction]: ... def __repr__(self) -> str: ... def info(self) -> str: ... def dis(self) -> str: ... @classmethod def from_traceback(cls, tb: types.TracebackType) -> Bytecode: ... COMPILER_FLAG_NAMES: Dict[int, str] def findlabels(code: _have_code) -> List[int]: ... def findlinestarts(code: _have_code) -> Iterator[Tuple[int, int]]: ... if sys.version_info >= (3, 0): def pretty_flags(flags: int) -> str: ... def code_info(x: _have_code_or_string) -> str: ... if sys.version_info >= (3, 7): def dis(x: Optional[_have_code_or_string] = ..., *, file: Optional[IO[str]] = ..., depth: Optional[int] = ...) -> None: ... elif sys.version_info >= (3, 4): def dis(x: Optional[_have_code_or_string] = ..., *, file: Optional[IO[str]] = ...) -> None: ... else: def dis(x: _have_code_or_string = ...) -> None: ... if sys.version_info >= (3, 4): def distb(tb: Optional[types.TracebackType] = ..., *, file: Optional[IO[str]] = ...) -> None: ... def disassemble(co: _have_code, lasti: int = ..., *, file: Optional[IO[str]] = ...) -> None: ... def disco(co: _have_code, lasti: int = ..., *, file: Optional[IO[str]] = ...) -> None: ... def show_code(co: _have_code, *, file: Optional[IO[str]] = ...) -> None: ... def get_instructions(x: _have_code, *, first_line: Optional[int] = ...) -> Iterator[Instruction]: ... else: def distb(tb: types.TracebackType = ...) -> None: ... def disassemble(co: _have_code, lasti: int = ...) -> None: ... def disco(co: _have_code, lasti: int = ...) -> None: ... if sys.version_info >= (3, 0): def show_code(co: _have_code) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/doctest.pyi0000664000175000017500000001565300000000000024063 0ustar00davedave00000000000000import sys import types import unittest from typing import Any, Callable, Dict, List, NamedTuple, Optional, Tuple, Type, Union class TestResults(NamedTuple): failed: int attempted: int OPTIONFLAGS_BY_NAME: Dict[str, int] def register_optionflag(name: str) -> int: ... DONT_ACCEPT_TRUE_FOR_1: int DONT_ACCEPT_BLANKLINE: int NORMALIZE_WHITESPACE: int ELLIPSIS: int SKIP: int IGNORE_EXCEPTION_DETAIL: int COMPARISON_FLAGS: int REPORT_UDIFF: int REPORT_CDIFF: int REPORT_NDIFF: int REPORT_ONLY_FIRST_FAILURE: int if sys.version_info >= (3, 4): FAIL_FAST: int REPORTING_FLAGS: int BLANKLINE_MARKER: str ELLIPSIS_MARKER: str class Example: source: str want: str exc_msg: Optional[str] lineno: int indent: int options: Dict[int, bool] def __init__( self, source: str, want: str, exc_msg: Optional[str] = ..., lineno: int = ..., indent: int = ..., options: Optional[Dict[int, bool]] = ..., ) -> None: ... def __hash__(self) -> int: ... class DocTest: examples: List[Example] globs: Dict[str, Any] name: str filename: Optional[str] lineno: Optional[int] docstring: Optional[str] def __init__( self, examples: List[Example], globs: Dict[str, Any], name: str, filename: Optional[str], lineno: Optional[int], docstring: Optional[str], ) -> None: ... def __hash__(self) -> int: ... def __lt__(self, other: DocTest) -> bool: ... class DocTestParser: def parse(self, string: str, name: str = ...) -> List[Union[str, Example]]: ... def get_doctest( self, string: str, globs: Dict[str, Any], name: str, filename: Optional[str], lineno: Optional[int] ) -> DocTest: ... def get_examples(self, string: str, name: str = ...) -> List[Example]: ... class DocTestFinder: def __init__( self, verbose: bool = ..., parser: DocTestParser = ..., recurse: bool = ..., exclude_empty: bool = ... ) -> None: ... def find( self, obj: object, name: Optional[str] = ..., module: Union[None, bool, types.ModuleType] = ..., globs: Optional[Dict[str, Any]] = ..., extraglobs: Optional[Dict[str, Any]] = ..., ) -> List[DocTest]: ... _Out = Callable[[str], Any] _ExcInfo = Tuple[Type[BaseException], BaseException, types.TracebackType] class DocTestRunner: DIVIDER: str optionflags: int original_optionflags: int tries: int failures: int test: DocTest def __init__(self, checker: Optional[OutputChecker] = ..., verbose: Optional[bool] = ..., optionflags: int = ...) -> None: ... def report_start(self, out: _Out, test: DocTest, example: Example) -> None: ... def report_success(self, out: _Out, test: DocTest, example: Example, got: str) -> None: ... def report_failure(self, out: _Out, test: DocTest, example: Example, got: str) -> None: ... def report_unexpected_exception(self, out: _Out, test: DocTest, example: Example, exc_info: _ExcInfo) -> None: ... def run( self, test: DocTest, compileflags: Optional[int] = ..., out: Optional[_Out] = ..., clear_globs: bool = ... ) -> TestResults: ... def summarize(self, verbose: Optional[bool] = ...) -> TestResults: ... def merge(self, other: DocTestRunner) -> None: ... class OutputChecker: def check_output(self, want: str, got: str, optionflags: int) -> bool: ... def output_difference(self, example: Example, got: str, optionflags: int) -> str: ... class DocTestFailure(Exception): test: DocTest example: Example got: str def __init__(self, test: DocTest, example: Example, got: str) -> None: ... class UnexpectedException(Exception): test: DocTest example: Example exc_info: _ExcInfo def __init__(self, test: DocTest, example: Example, exc_info: _ExcInfo) -> None: ... class DebugRunner(DocTestRunner): ... master: Optional[DocTestRunner] def testmod( m: Optional[types.ModuleType] = ..., name: Optional[str] = ..., globs: Optional[Dict[str, Any]] = ..., verbose: Optional[bool] = ..., report: bool = ..., optionflags: int = ..., extraglobs: Optional[Dict[str, Any]] = ..., raise_on_error: bool = ..., exclude_empty: bool = ..., ) -> TestResults: ... def testfile( filename: str, module_relative: bool = ..., name: Optional[str] = ..., package: Union[None, str, types.ModuleType] = ..., globs: Optional[Dict[str, Any]] = ..., verbose: Optional[bool] = ..., report: bool = ..., optionflags: int = ..., extraglobs: Optional[Dict[str, Any]] = ..., raise_on_error: bool = ..., parser: DocTestParser = ..., encoding: Optional[str] = ..., ) -> TestResults: ... def run_docstring_examples( f: object, globs: Dict[str, Any], verbose: bool = ..., name: str = ..., compileflags: Optional[int] = ..., optionflags: int = ..., ) -> None: ... def set_unittest_reportflags(flags: int) -> int: ... class DocTestCase(unittest.TestCase): def __init__( self, test: DocTest, optionflags: int = ..., setUp: Optional[Callable[[DocTest], Any]] = ..., tearDown: Optional[Callable[[DocTest], Any]] = ..., checker: Optional[OutputChecker] = ..., ) -> None: ... def setUp(self) -> None: ... def tearDown(self) -> None: ... def runTest(self) -> None: ... def format_failure(self, err: str) -> str: ... def debug(self) -> None: ... def id(self) -> str: ... def __hash__(self) -> int: ... def shortDescription(self) -> str: ... class SkipDocTestCase(DocTestCase): def __init__(self, module: types.ModuleType) -> None: ... def setUp(self) -> None: ... def test_skip(self) -> None: ... def shortDescription(self) -> str: ... if sys.version_info >= (3, 4): class _DocTestSuite(unittest.TestSuite): ... else: _DocTestSuite = unittest.TestSuite def DocTestSuite( module: Union[None, str, types.ModuleType] = ..., globs: Optional[Dict[str, Any]] = ..., extraglobs: Optional[Dict[str, Any]] = ..., test_finder: Optional[DocTestFinder] = ..., **options: Any, ) -> _DocTestSuite: ... class DocFileCase(DocTestCase): def id(self) -> str: ... def format_failure(self, err: str) -> str: ... def DocFileTest( path: str, module_relative: bool = ..., package: Union[None, str, types.ModuleType] = ..., globs: Optional[Dict[str, Any]] = ..., parser: DocTestParser = ..., encoding: Optional[str] = ..., **options: Any, ) -> DocFileCase: ... def DocFileSuite(*paths: str, **kw: Any) -> _DocTestSuite: ... def script_from_examples(s: str) -> str: ... def testsource(module: Union[None, str, types.ModuleType], name: str) -> str: ... def debug_src(src: str, pm: bool = ..., globs: Optional[Dict[str, Any]] = ...) -> None: ... def debug_script(src: str, pm: bool = ..., globs: Optional[Dict[str, Any]] = ...) -> None: ... def debug(module: Union[None, str, types.ModuleType], name: str, pm: bool = ...) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/dummy_threading.pyi0000664000175000017500000000011700000000000025563 0ustar00davedave00000000000000from _dummy_threading import * from _dummy_threading import __all__ as __all__ ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4223793 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/ensurepip/0000775000175000017500000000000000000000000023673 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/ensurepip/__init__.pyi0000664000175000017500000000106200000000000026154 0ustar00davedave00000000000000import sys from typing import Optional def version() -> str: ... if sys.version_info >= (3, 0): def bootstrap( *, root: Optional[str] = ..., upgrade: bool = ..., user: bool = ..., altinstall: bool = ..., default_pip: bool = ..., verbosity: int = ..., ) -> None: ... else: def bootstrap( root: Optional[str] = ..., upgrade: bool = ..., user: bool = ..., altinstall: bool = ..., default_pip: bool = ..., verbosity: int = ..., ) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/errno.pyi0000664000175000017500000000373300000000000023537 0ustar00davedave00000000000000from typing import Mapping errorcode: Mapping[int, str] EPERM: int ENOENT: int ESRCH: int EINTR: int EIO: int ENXIO: int E2BIG: int ENOEXEC: int EBADF: int ECHILD: int EAGAIN: int ENOMEM: int EACCES: int EFAULT: int ENOTBLK: int EBUSY: int EEXIST: int EXDEV: int ENODEV: int ENOTDIR: int EISDIR: int EINVAL: int ENFILE: int EMFILE: int ENOTTY: int ETXTBSY: int EFBIG: int ENOSPC: int ESPIPE: int EROFS: int EMLINK: int EPIPE: int EDOM: int ERANGE: int EDEADLCK: int ENAMETOOLONG: int ENOLCK: int ENOSYS: int ENOTEMPTY: int ELOOP: int EWOULDBLOCK: int ENOMSG: int EIDRM: int ECHRNG: int EL2NSYNC: int EL3HLT: int EL3RST: int ELNRNG: int EUNATCH: int ENOCSI: int EL2HLT: int EBADE: int EBADR: int EXFULL: int ENOANO: int EBADRQC: int EBADSLT: int EDEADLOCK: int EBFONT: int ENOSTR: int ENODATA: int ETIME: int ENOSR: int ENONET: int ENOPKG: int EREMOTE: int ENOLINK: int EADV: int ESRMNT: int ECOMM: int EPROTO: int EMULTIHOP: int EDOTDOT: int EBADMSG: int EOVERFLOW: int ENOTUNIQ: int EBADFD: int EREMCHG: int ELIBACC: int ELIBBAD: int ELIBSCN: int ELIBMAX: int ELIBEXEC: int EILSEQ: int ERESTART: int ESTRPIPE: int EUSERS: int ENOTSOCK: int EDESTADDRREQ: int EMSGSIZE: int EPROTOTYPE: int ENOPROTOOPT: int EPROTONOSUPPORT: int ESOCKTNOSUPPORT: int ENOTSUP: int EOPNOTSUPP: int EPFNOSUPPORT: int EAFNOSUPPORT: int EADDRINUSE: int EADDRNOTAVAIL: int ENETDOWN: int ENETUNREACH: int ENETRESET: int ECONNABORTED: int ECONNRESET: int ENOBUFS: int EISCONN: int ENOTCONN: int ESHUTDOWN: int ETOOMANYREFS: int ETIMEDOUT: int ECONNREFUSED: int EHOSTDOWN: int EHOSTUNREACH: int EALREADY: int EINPROGRESS: int ESTALE: int EUCLEAN: int ENOTNAM: int ENAVAIL: int EISNAM: int EREMOTEIO: int EDQUOT: int ECANCELED: int # undocumented EKEYEXPIRED: int # undocumented EKEYREJECTED: int # undocumented EKEYREVOKED: int # undocumented EMEDIUMTYPE: int # undocumented ENOKEY: int # undocumented ENOMEDIUM: int # undocumented ENOTRECOVERABLE: int # undocumented EOWNERDEAD: int # undocumented ERFKILL: int # undocumented ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/filecmp.pyi0000664000175000017500000000500600000000000024024 0ustar00davedave00000000000000import sys from typing import Any, AnyStr, Callable, Dict, Generic, Iterable, List, Optional, Sequence, Text, Tuple, Union if sys.version_info >= (3, 6): from os import PathLike if sys.version_info >= (3, 9): from types import GenericAlias DEFAULT_IGNORES: List[str] if sys.version_info >= (3, 6): def cmp( f1: Union[bytes, Text, PathLike[AnyStr]], f2: Union[bytes, Text, PathLike[AnyStr]], shallow: Union[int, bool] = ... ) -> bool: ... def cmpfiles( a: Union[AnyStr, PathLike[AnyStr]], b: Union[AnyStr, PathLike[AnyStr]], common: Iterable[AnyStr], shallow: Union[int, bool] = ..., ) -> Tuple[List[AnyStr], List[AnyStr], List[AnyStr]]: ... else: def cmp(f1: Union[bytes, Text], f2: Union[bytes, Text], shallow: Union[int, bool] = ...) -> bool: ... def cmpfiles( a: AnyStr, b: AnyStr, common: Iterable[AnyStr], shallow: Union[int, bool] = ... ) -> Tuple[List[AnyStr], List[AnyStr], List[AnyStr]]: ... class dircmp(Generic[AnyStr]): if sys.version_info >= (3, 6): def __init__( self, a: Union[AnyStr, PathLike[AnyStr]], b: Union[AnyStr, PathLike[AnyStr]], ignore: Optional[Sequence[AnyStr]] = ..., hide: Optional[Sequence[AnyStr]] = ..., ) -> None: ... else: def __init__( self, a: AnyStr, b: AnyStr, ignore: Optional[Sequence[AnyStr]] = ..., hide: Optional[Sequence[AnyStr]] = ... ) -> None: ... left: AnyStr right: AnyStr hide: Sequence[AnyStr] ignore: Sequence[AnyStr] # These properties are created at runtime by __getattr__ subdirs: Dict[AnyStr, dircmp[AnyStr]] same_files: List[AnyStr] diff_files: List[AnyStr] funny_files: List[AnyStr] common_dirs: List[AnyStr] common_files: List[AnyStr] common_funny: List[AnyStr] common: List[AnyStr] left_only: List[AnyStr] right_only: List[AnyStr] left_list: List[AnyStr] right_list: List[AnyStr] def report(self) -> None: ... def report_partial_closure(self) -> None: ... def report_full_closure(self) -> None: ... methodmap: Dict[str, Callable[[], None]] def phase0(self) -> None: ... def phase1(self) -> None: ... def phase2(self) -> None: ... def phase3(self) -> None: ... def phase4(self) -> None: ... def phase4_closure(self) -> None: ... if sys.version_info >= (3, 9): def __class_getitem__(cls, item: Any) -> GenericAlias: ... if sys.version_info >= (3,): def clear_cache() -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/fileinput.pyi0000664000175000017500000000505100000000000024404 0ustar00davedave00000000000000import sys from _typeshed import AnyPath from typing import IO, Any, AnyStr, Callable, Generic, Iterable, Iterator, Optional, Union if sys.version_info >= (3, 8): def input( files: Union[AnyPath, Iterable[AnyPath], None] = ..., inplace: bool = ..., backup: str = ..., *, mode: str = ..., openhook: Callable[[AnyPath, str], IO[AnyStr]] = ..., ) -> FileInput[AnyStr]: ... else: def input( files: Union[AnyPath, Iterable[AnyPath], None] = ..., inplace: bool = ..., backup: str = ..., bufsize: int = ..., mode: str = ..., openhook: Callable[[AnyPath, str], IO[AnyStr]] = ..., ) -> FileInput[AnyStr]: ... def close() -> None: ... def nextfile() -> None: ... def filename() -> str: ... def lineno() -> int: ... def filelineno() -> int: ... def fileno() -> int: ... def isfirstline() -> bool: ... def isstdin() -> bool: ... class FileInput(Iterable[AnyStr], Generic[AnyStr]): if sys.version_info >= (3, 8): def __init__( self, files: Union[None, AnyPath, Iterable[AnyPath]] = ..., inplace: bool = ..., backup: str = ..., *, mode: str = ..., openhook: Callable[[AnyPath, str], IO[AnyStr]] = ..., ) -> None: ... else: def __init__( self, files: Union[None, AnyPath, Iterable[AnyPath]] = ..., inplace: bool = ..., backup: str = ..., bufsize: int = ..., mode: str = ..., openhook: Callable[[AnyPath, str], IO[AnyStr]] = ..., ) -> None: ... def __del__(self) -> None: ... def close(self) -> None: ... if sys.version_info >= (3, 2): def __enter__(self) -> FileInput[AnyStr]: ... def __exit__(self, type: Any, value: Any, traceback: Any) -> None: ... def __iter__(self) -> Iterator[AnyStr]: ... def __next__(self) -> AnyStr: ... def __getitem__(self, i: int) -> AnyStr: ... def nextfile(self) -> None: ... def readline(self) -> AnyStr: ... def filename(self) -> str: ... def lineno(self) -> int: ... def filelineno(self) -> int: ... def fileno(self) -> int: ... def isfirstline(self) -> bool: ... def isstdin(self) -> bool: ... def hook_compressed(filename: AnyPath, mode: str) -> IO[Any]: ... if sys.version_info >= (3, 6): def hook_encoded(encoding: str, errors: Optional[str] = ...) -> Callable[[AnyPath, str], IO[Any]]: ... else: def hook_encoded(encoding: str) -> Callable[[AnyPath, str], IO[Any]]: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/formatter.pyi0000664000175000017500000001103700000000000024411 0ustar00davedave00000000000000from typing import IO, Any, Iterable, List, Optional, Tuple AS_IS: None _FontType = Tuple[str, bool, bool, bool] _StylesType = Tuple[Any, ...] class NullFormatter: writer: Optional[NullWriter] def __init__(self, writer: Optional[NullWriter] = ...) -> None: ... def end_paragraph(self, blankline: int) -> None: ... def add_line_break(self) -> None: ... def add_hor_rule(self, *args: Any, **kw: Any) -> None: ... def add_label_data(self, format: str, counter: int, blankline: Optional[int] = ...) -> None: ... def add_flowing_data(self, data: str) -> None: ... def add_literal_data(self, data: str) -> None: ... def flush_softspace(self) -> None: ... def push_alignment(self, align: Optional[str]) -> None: ... def pop_alignment(self) -> None: ... def push_font(self, x: _FontType) -> None: ... def pop_font(self) -> None: ... def push_margin(self, margin: int) -> None: ... def pop_margin(self) -> None: ... def set_spacing(self, spacing: Optional[str]) -> None: ... def push_style(self, *styles: _StylesType) -> None: ... def pop_style(self, n: int = ...) -> None: ... def assert_line_data(self, flag: int = ...) -> None: ... class AbstractFormatter: writer: NullWriter align: Optional[str] align_stack: List[Optional[str]] font_stack: List[_FontType] margin_stack: List[int] spacing: Optional[str] style_stack: Any nospace: int softspace: int para_end: int parskip: int hard_break: int have_label: int def __init__(self, writer: NullWriter) -> None: ... def end_paragraph(self, blankline: int) -> None: ... def add_line_break(self) -> None: ... def add_hor_rule(self, *args: Any, **kw: Any) -> None: ... def add_label_data(self, format: str, counter: int, blankline: Optional[int] = ...) -> None: ... def format_counter(self, format: Iterable[str], counter: int) -> str: ... def format_letter(self, case: str, counter: int) -> str: ... def format_roman(self, case: str, counter: int) -> str: ... def add_flowing_data(self, data: str) -> None: ... def add_literal_data(self, data: str) -> None: ... def flush_softspace(self) -> None: ... def push_alignment(self, align: Optional[str]) -> None: ... def pop_alignment(self) -> None: ... def push_font(self, font: _FontType) -> None: ... def pop_font(self) -> None: ... def push_margin(self, margin: int) -> None: ... def pop_margin(self) -> None: ... def set_spacing(self, spacing: Optional[str]) -> None: ... def push_style(self, *styles: _StylesType) -> None: ... def pop_style(self, n: int = ...) -> None: ... def assert_line_data(self, flag: int = ...) -> None: ... class NullWriter: def __init__(self) -> None: ... def flush(self) -> None: ... def new_alignment(self, align: Optional[str]) -> None: ... def new_font(self, font: _FontType) -> None: ... def new_margin(self, margin: int, level: int) -> None: ... def new_spacing(self, spacing: Optional[str]) -> None: ... def new_styles(self, styles: Tuple[Any, ...]) -> None: ... def send_paragraph(self, blankline: int) -> None: ... def send_line_break(self) -> None: ... def send_hor_rule(self, *args: Any, **kw: Any) -> None: ... def send_label_data(self, data: str) -> None: ... def send_flowing_data(self, data: str) -> None: ... def send_literal_data(self, data: str) -> None: ... class AbstractWriter(NullWriter): def new_alignment(self, align: Optional[str]) -> None: ... def new_font(self, font: _FontType) -> None: ... def new_margin(self, margin: int, level: int) -> None: ... def new_spacing(self, spacing: Optional[str]) -> None: ... def new_styles(self, styles: Tuple[Any, ...]) -> None: ... def send_paragraph(self, blankline: int) -> None: ... def send_line_break(self) -> None: ... def send_hor_rule(self, *args: Any, **kw: Any) -> None: ... def send_label_data(self, data: str) -> None: ... def send_flowing_data(self, data: str) -> None: ... def send_literal_data(self, data: str) -> None: ... class DumbWriter(NullWriter): file: IO[str] maxcol: int def __init__(self, file: Optional[IO[str]] = ..., maxcol: int = ...) -> None: ... def reset(self) -> None: ... def send_paragraph(self, blankline: int) -> None: ... def send_line_break(self) -> None: ... def send_hor_rule(self, *args: Any, **kw: Any) -> None: ... def send_literal_data(self, data: str) -> None: ... def send_flowing_data(self, data: str) -> None: ... def test(file: Optional[str] = ...) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/fractions.pyi0000664000175000017500000001346000000000000024400 0ustar00davedave00000000000000import sys from decimal import Decimal from numbers import Integral, Rational, Real from typing import Optional, Tuple, Union, overload from typing_extensions import Literal _ComparableNum = Union[int, float, Decimal, Real] if sys.version_info < (3, 9): @overload def gcd(a: int, b: int) -> int: ... @overload def gcd(a: Integral, b: int) -> Integral: ... @overload def gcd(a: int, b: Integral) -> Integral: ... @overload def gcd(a: Integral, b: Integral) -> Integral: ... class Fraction(Rational): @overload def __new__( cls, numerator: Union[int, Rational] = ..., denominator: Optional[Union[int, Rational]] = ..., *, _normalize: bool = ... ) -> Fraction: ... @overload def __new__(cls, __value: Union[float, Decimal, str], *, _normalize: bool = ...) -> Fraction: ... @classmethod def from_float(cls, f: float) -> Fraction: ... @classmethod def from_decimal(cls, dec: Decimal) -> Fraction: ... def limit_denominator(self, max_denominator: int = ...) -> Fraction: ... if sys.version_info >= (3, 8): def as_integer_ratio(self) -> Tuple[int, int]: ... @property def numerator(self) -> int: ... @property def denominator(self) -> int: ... @overload def __add__(self, other: Union[int, Fraction]) -> Fraction: ... @overload def __add__(self, other: float) -> float: ... @overload def __add__(self, other: complex) -> complex: ... @overload def __radd__(self, other: Union[int, Fraction]) -> Fraction: ... @overload def __radd__(self, other: float) -> float: ... @overload def __radd__(self, other: complex) -> complex: ... @overload def __sub__(self, other: Union[int, Fraction]) -> Fraction: ... @overload def __sub__(self, other: float) -> float: ... @overload def __sub__(self, other: complex) -> complex: ... @overload def __rsub__(self, other: Union[int, Fraction]) -> Fraction: ... @overload def __rsub__(self, other: float) -> float: ... @overload def __rsub__(self, other: complex) -> complex: ... @overload def __mul__(self, other: Union[int, Fraction]) -> Fraction: ... @overload def __mul__(self, other: float) -> float: ... @overload def __mul__(self, other: complex) -> complex: ... @overload def __rmul__(self, other: Union[int, Fraction]) -> Fraction: ... @overload def __rmul__(self, other: float) -> float: ... @overload def __rmul__(self, other: complex) -> complex: ... @overload def __truediv__(self, other: Union[int, Fraction]) -> Fraction: ... @overload def __truediv__(self, other: float) -> float: ... @overload def __truediv__(self, other: complex) -> complex: ... @overload def __rtruediv__(self, other: Union[int, Fraction]) -> Fraction: ... @overload def __rtruediv__(self, other: float) -> float: ... @overload def __rtruediv__(self, other: complex) -> complex: ... if sys.version_info < (3, 0): @overload def __div__(self, other: Union[int, Fraction]) -> Fraction: ... @overload def __div__(self, other: float) -> float: ... @overload def __div__(self, other: complex) -> complex: ... @overload def __rdiv__(self, other: Union[int, Fraction]) -> Fraction: ... @overload def __rdiv__(self, other: float) -> float: ... @overload def __rdiv__(self, other: complex) -> complex: ... @overload def __floordiv__(self, other: Union[int, Fraction]) -> int: ... @overload def __floordiv__(self, other: float) -> float: ... @overload def __rfloordiv__(self, other: Union[int, Fraction]) -> int: ... @overload def __rfloordiv__(self, other: float) -> float: ... @overload def __mod__(self, other: Union[int, Fraction]) -> Fraction: ... @overload def __mod__(self, other: float) -> float: ... @overload def __rmod__(self, other: Union[int, Fraction]) -> Fraction: ... @overload def __rmod__(self, other: float) -> float: ... @overload def __divmod__(self, other: Union[int, Fraction]) -> Tuple[int, Fraction]: ... @overload def __divmod__(self, other: float) -> Tuple[float, Fraction]: ... @overload def __rdivmod__(self, other: Union[int, Fraction]) -> Tuple[int, Fraction]: ... @overload def __rdivmod__(self, other: float) -> Tuple[float, Fraction]: ... @overload def __pow__(self, other: int) -> Fraction: ... @overload def __pow__(self, other: Union[float, Fraction]) -> float: ... @overload def __pow__(self, other: complex) -> complex: ... @overload def __rpow__(self, other: Union[int, float, Fraction]) -> float: ... @overload def __rpow__(self, other: complex) -> complex: ... def __pos__(self) -> Fraction: ... def __neg__(self) -> Fraction: ... def __abs__(self) -> Fraction: ... def __trunc__(self) -> int: ... if sys.version_info >= (3, 0): def __floor__(self) -> int: ... def __ceil__(self) -> int: ... @overload def __round__(self, ndigits: None = ...) -> int: ... @overload def __round__(self, ndigits: int) -> Fraction: ... def __hash__(self) -> int: ... def __eq__(self, other: object) -> bool: ... def __lt__(self, other: _ComparableNum) -> bool: ... def __gt__(self, other: _ComparableNum) -> bool: ... def __le__(self, other: _ComparableNum) -> bool: ... def __ge__(self, other: _ComparableNum) -> bool: ... if sys.version_info >= (3, 0): def __bool__(self) -> bool: ... else: def __nonzero__(self) -> bool: ... # Not actually defined within fractions.py, but provides more useful # overrides @property def real(self) -> Fraction: ... @property def imag(self) -> Literal[0]: ... def conjugate(self) -> Fraction: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/ftplib.pyi0000664000175000017500000001420600000000000023667 0ustar00davedave00000000000000import sys from _typeshed import SupportsRead, SupportsReadline from socket import socket from ssl import SSLContext from types import TracebackType from typing import Any, BinaryIO, Callable, Dict, Iterable, Iterator, List, Optional, Text, TextIO, Tuple, Type, TypeVar, Union from typing_extensions import Literal _T = TypeVar("_T") _IntOrStr = Union[int, Text] MSG_OOB: int FTP_PORT: int MAXLINE: int CRLF: str if sys.version_info >= (3,): B_CRLF: bytes class Error(Exception): ... class error_reply(Error): ... class error_temp(Error): ... class error_perm(Error): ... class error_proto(Error): ... all_errors = Tuple[Type[Exception], ...] class FTP: debugging: int # Note: This is technically the type that's passed in as the host argument. But to make it easier in Python 2 we # accept Text but return str. host: str port: int maxline: int sock: Optional[socket] welcome: Optional[str] passiveserver: int timeout: int af: int lastresp: str if sys.version_info >= (3,): file: Optional[TextIO] encoding: str def __enter__(self: _T) -> _T: ... def __exit__( self, exc_type: Optional[Type[BaseException]], exc_val: Optional[BaseException], exc_tb: Optional[TracebackType] ) -> None: ... else: file: Optional[BinaryIO] if sys.version_info >= (3, 3): source_address: Optional[Tuple[str, int]] def __init__( self, host: Text = ..., user: Text = ..., passwd: Text = ..., acct: Text = ..., timeout: float = ..., source_address: Optional[Tuple[str, int]] = ..., ) -> None: ... def connect( self, host: Text = ..., port: int = ..., timeout: float = ..., source_address: Optional[Tuple[str, int]] = ... ) -> str: ... else: def __init__( self, host: Text = ..., user: Text = ..., passwd: Text = ..., acct: Text = ..., timeout: float = ... ) -> None: ... def connect(self, host: Text = ..., port: int = ..., timeout: float = ...) -> str: ... def getwelcome(self) -> str: ... def set_debuglevel(self, level: int) -> None: ... def debug(self, level: int) -> None: ... def set_pasv(self, val: Union[bool, int]) -> None: ... def sanitize(self, s: Text) -> str: ... def putline(self, line: Text) -> None: ... def putcmd(self, line: Text) -> None: ... def getline(self) -> str: ... def getmultiline(self) -> str: ... def getresp(self) -> str: ... def voidresp(self) -> str: ... def abort(self) -> str: ... def sendcmd(self, cmd: Text) -> str: ... def voidcmd(self, cmd: Text) -> str: ... def sendport(self, host: Text, port: int) -> str: ... def sendeprt(self, host: Text, port: int) -> str: ... def makeport(self) -> socket: ... def makepasv(self) -> Tuple[str, int]: ... def login(self, user: Text = ..., passwd: Text = ..., acct: Text = ...) -> str: ... # In practice, `rest` rest can actually be anything whose str() is an integer sequence, so to make it simple we allow integers. def ntransfercmd(self, cmd: Text, rest: Optional[_IntOrStr] = ...) -> Tuple[socket, int]: ... def transfercmd(self, cmd: Text, rest: Optional[_IntOrStr] = ...) -> socket: ... def retrbinary( self, cmd: Text, callback: Callable[[bytes], Any], blocksize: int = ..., rest: Optional[_IntOrStr] = ... ) -> str: ... def storbinary( self, cmd: Text, fp: SupportsRead[bytes], blocksize: int = ..., callback: Optional[Callable[[bytes], Any]] = ..., rest: Optional[_IntOrStr] = ..., ) -> str: ... def retrlines(self, cmd: Text, callback: Optional[Callable[[str], Any]] = ...) -> str: ... def storlines(self, cmd: Text, fp: SupportsReadline[bytes], callback: Optional[Callable[[bytes], Any]] = ...) -> str: ... def acct(self, password: Text) -> str: ... def nlst(self, *args: Text) -> List[str]: ... # Technically only the last arg can be a Callable but ... def dir(self, *args: Union[str, Callable[[str], None]]) -> None: ... if sys.version_info >= (3, 3): def mlsd(self, path: Text = ..., facts: Iterable[str] = ...) -> Iterator[Tuple[str, Dict[str, str]]]: ... def rename(self, fromname: Text, toname: Text) -> str: ... def delete(self, filename: Text) -> str: ... def cwd(self, dirname: Text) -> str: ... def size(self, filename: Text) -> Optional[int]: ... def mkd(self, dirname: Text) -> str: ... def rmd(self, dirname: Text) -> str: ... def pwd(self) -> str: ... def quit(self) -> str: ... def close(self) -> None: ... class FTP_TLS(FTP): def __init__( self, host: Text = ..., user: Text = ..., passwd: Text = ..., acct: Text = ..., keyfile: Optional[str] = ..., certfile: Optional[str] = ..., context: Optional[SSLContext] = ..., timeout: float = ..., source_address: Optional[Tuple[str, int]] = ..., ) -> None: ... ssl_version: int keyfile: Optional[str] certfile: Optional[str] context: SSLContext def login(self, user: Text = ..., passwd: Text = ..., acct: Text = ..., secure: bool = ...) -> str: ... def auth(self) -> str: ... def prot_p(self) -> str: ... def prot_c(self) -> str: ... if sys.version_info >= (3, 3): def ccc(self) -> str: ... if sys.version_info < (3,): class Netrc: def __init__(self, filename: Optional[Text] = ...) -> None: ... def get_hosts(self) -> List[str]: ... def get_account(self, host: Text) -> Tuple[Optional[str], Optional[str], Optional[str]]: ... def get_macros(self) -> List[str]: ... def get_macro(self, macro: Text) -> Tuple[str, ...]: ... def parse150(resp: str) -> Optional[int]: ... # undocumented def parse227(resp: str) -> Tuple[str, int]: ... # undocumented def parse229(resp: str, peer: Any) -> Tuple[str, int]: ... # undocumented def parse257(resp: str) -> str: ... # undocumented def ftpcp( source: FTP, sourcename: str, target: FTP, targetname: str = ..., type: Literal["A", "I"] = ..., ) -> None: ... # undocumented ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/genericpath.pyi0000664000175000017500000000144600000000000024702 0ustar00davedave00000000000000import sys from typing import AnyStr, Sequence, Text, Union if sys.version_info >= (3, 0): def commonprefix(m: Sequence[str]) -> str: ... else: def commonprefix(m: Sequence[AnyStr]) -> AnyStr: ... if sys.version_info >= (3, 6): from builtins import _PathLike def exists(path: Union[AnyStr, _PathLike[AnyStr]]) -> bool: ... else: def exists(path: Text) -> bool: ... def isfile(path: Text) -> bool: ... def isdir(s: Text) -> bool: ... def getsize(filename: Text) -> int: ... def getmtime(filename: Text) -> float: ... def getatime(filename: Text) -> float: ... def getctime(filename: Text) -> float: ... if sys.version_info >= (3, 4): def samestat(s1: str, s2: str) -> int: ... def samefile(f1: str, f2: str) -> int: ... def sameopenfile(fp1: str, fp2: str) -> int: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/grp.pyi0000664000175000017500000000044700000000000023201 0ustar00davedave00000000000000from typing import List, NamedTuple, Optional class struct_group(NamedTuple): gr_name: str gr_passwd: Optional[str] gr_gid: int gr_mem: List[str] def getgrall() -> List[struct_group]: ... def getgrgid(gid: int) -> struct_group: ... def getgrnam(name: str) -> struct_group: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/hmac.pyi0000664000175000017500000000310700000000000023315 0ustar00davedave00000000000000import sys from _typeshed import ReadableBuffer from types import ModuleType from typing import Any, AnyStr, Callable, Optional, Union, overload # TODO more precise type for object of hashlib _Hash = Any _DigestMod = Union[str, Callable[[], _Hash], ModuleType] digest_size: None if sys.version_info >= (3, 8): # In reality digestmod has a default value, but the function always throws an error # if the argument is not given, so we pretend it is a required argument. @overload def new(key: bytes, msg: Optional[ReadableBuffer], digestmod: _DigestMod) -> HMAC: ... @overload def new(key: bytes, *, digestmod: _DigestMod) -> HMAC: ... elif sys.version_info >= (3, 4): def new(key: bytes, msg: Optional[ReadableBuffer] = ..., digestmod: Optional[_DigestMod] = ...) -> HMAC: ... else: def new(key: bytes, msg: Optional[ReadableBuffer] = ..., digestmod: Optional[_DigestMod] = ...) -> HMAC: ... class HMAC: if sys.version_info >= (3,): digest_size: int if sys.version_info >= (3, 4): block_size: int name: str def __init__(self, key: bytes, msg: Optional[ReadableBuffer] = ..., digestmod: _DigestMod = ...) -> None: ... def update(self, msg: ReadableBuffer) -> None: ... def digest(self) -> bytes: ... def hexdigest(self) -> str: ... def copy(self) -> HMAC: ... @overload def compare_digest(__a: ReadableBuffer, __b: ReadableBuffer) -> bool: ... @overload def compare_digest(__a: AnyStr, __b: AnyStr) -> bool: ... if sys.version_info >= (3, 7): def digest(key: bytes, msg: ReadableBuffer, digest: str) -> bytes: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/imaplib.pyi0000664000175000017500000001754200000000000024032 0ustar00davedave00000000000000import subprocess import sys import time from socket import socket as _socket from ssl import SSLContext, SSLSocket from types import TracebackType from typing import IO, Any, Callable, Dict, List, Optional, Pattern, Text, Tuple, Type, Union from typing_extensions import Literal # TODO: Commands should use their actual return types, not this type alias. # E.g. Tuple[Literal["OK"], List[bytes]] _CommandResults = Tuple[str, List[Any]] _AnyResponseData = Union[List[None], List[Union[bytes, Tuple[bytes, bytes]]]] class IMAP4: error: Type[Exception] = ... abort: Type[Exception] = ... readonly: Type[Exception] = ... mustquote: Pattern[Text] = ... debug: int = ... state: str = ... literal: Optional[Text] = ... tagged_commands: Dict[bytes, Optional[List[bytes]]] untagged_responses: Dict[str, List[Union[bytes, Tuple[bytes, bytes]]]] continuation_response: str = ... is_readonly: bool = ... tagnum: int = ... tagpre: str = ... tagre: Pattern[Text] = ... welcome: bytes = ... capabilities: Tuple[str] = ... PROTOCOL_VERSION: str = ... if sys.version_info >= (3, 9): def __init__(self, host: str = ..., port: int = ..., timeout: Optional[float] = ...) -> None: ... def open(self, host: str = ..., port: int = ..., timeout: Optional[float] = ...) -> None: ... else: def __init__(self, host: str = ..., port: int = ...) -> None: ... def open(self, host: str = ..., port: int = ...) -> None: ... def __getattr__(self, attr: str) -> Any: ... host: str = ... port: int = ... sock: _socket = ... file: Union[IO[Text], IO[bytes]] = ... def read(self, size: int) -> bytes: ... def readline(self) -> bytes: ... def send(self, data: bytes) -> None: ... def shutdown(self) -> None: ... def socket(self) -> _socket: ... def recent(self) -> _CommandResults: ... def response(self, code: str) -> _CommandResults: ... def append(self, mailbox: str, flags: str, date_time: str, message: str) -> str: ... def authenticate(self, mechanism: str, authobject: Callable[[bytes], Optional[bytes]]) -> Tuple[str, str]: ... def capability(self) -> _CommandResults: ... def check(self) -> _CommandResults: ... def close(self) -> _CommandResults: ... def copy(self, message_set: str, new_mailbox: str) -> _CommandResults: ... def create(self, mailbox: str) -> _CommandResults: ... def delete(self, mailbox: str) -> _CommandResults: ... def deleteacl(self, mailbox: str, who: str) -> _CommandResults: ... if sys.version_info >= (3, 5): def enable(self, capability: str) -> _CommandResults: ... def __enter__(self) -> IMAP4: ... def __exit__(self, t: Optional[Type[BaseException]], v: Optional[BaseException], tb: Optional[TracebackType]) -> None: ... def expunge(self) -> _CommandResults: ... def fetch(self, message_set: str, message_parts: str) -> Tuple[str, _AnyResponseData]: ... def getacl(self, mailbox: str) -> _CommandResults: ... def getannotation(self, mailbox: str, entry: str, attribute: str) -> _CommandResults: ... def getquota(self, root: str) -> _CommandResults: ... def getquotaroot(self, mailbox: str) -> _CommandResults: ... def list(self, directory: str = ..., pattern: str = ...) -> Tuple[str, _AnyResponseData]: ... def login(self, user: str, password: str) -> Tuple[Literal["OK"], List[bytes]]: ... def login_cram_md5(self, user: str, password: str) -> _CommandResults: ... def logout(self) -> Tuple[str, _AnyResponseData]: ... def lsub(self, directory: str = ..., pattern: str = ...) -> _CommandResults: ... def myrights(self, mailbox: str) -> _CommandResults: ... def namespace(self) -> _CommandResults: ... def noop(self) -> Tuple[str, List[bytes]]: ... def partial(self, message_num: str, message_part: str, start: str, length: str) -> _CommandResults: ... def proxyauth(self, user: str) -> _CommandResults: ... def rename(self, oldmailbox: str, newmailbox: str) -> _CommandResults: ... def search(self, charset: Optional[str], *criteria: str) -> _CommandResults: ... def select(self, mailbox: str = ..., readonly: bool = ...) -> Tuple[str, List[Optional[bytes]]]: ... def setacl(self, mailbox: str, who: str, what: str) -> _CommandResults: ... def setannotation(self, *args: str) -> _CommandResults: ... def setquota(self, root: str, limits: str) -> _CommandResults: ... def sort(self, sort_criteria: str, charset: str, *search_criteria: str) -> _CommandResults: ... if sys.version_info >= (3,): def starttls(self, ssl_context: Optional[Any] = ...) -> Tuple[Literal["OK"], List[None]]: ... def status(self, mailbox: str, names: str) -> _CommandResults: ... def store(self, message_set: str, command: str, flags: str) -> _CommandResults: ... def subscribe(self, mailbox: str) -> _CommandResults: ... def thread(self, threading_algorithm: str, charset: str, *search_criteria: str) -> _CommandResults: ... def uid(self, command: str, *args: str) -> _CommandResults: ... def unsubscribe(self, mailbox: str) -> _CommandResults: ... if sys.version_info >= (3, 9): def unselect(self) -> _CommandResults: ... def xatom(self, name: str, *args: str) -> _CommandResults: ... def print_log(self) -> None: ... class IMAP4_SSL(IMAP4): keyfile: str = ... certfile: str = ... if sys.version_info >= (3, 9): def __init__( self, host: str = ..., port: int = ..., keyfile: Optional[str] = ..., certfile: Optional[str] = ..., ssl_context: Optional[SSLContext] = ..., timeout: Optional[float] = ..., ) -> None: ... elif sys.version_info >= (3, 3): def __init__( self, host: str = ..., port: int = ..., keyfile: Optional[str] = ..., certfile: Optional[str] = ..., ssl_context: Optional[SSLContext] = ..., ) -> None: ... else: def __init__( self, host: str = ..., port: int = ..., keyfile: Optional[str] = ..., certfile: Optional[str] = ... ) -> None: ... host: str = ... port: int = ... sock: _socket = ... sslobj: SSLSocket = ... file: IO[Any] = ... if sys.version_info >= (3, 9): def open(self, host: str = ..., port: Optional[int] = ..., timeout: Optional[float] = ...) -> None: ... else: def open(self, host: str = ..., port: Optional[int] = ...) -> None: ... def read(self, size: int) -> bytes: ... def readline(self) -> bytes: ... def send(self, data: bytes) -> None: ... def shutdown(self) -> None: ... def socket(self) -> _socket: ... def ssl(self) -> SSLSocket: ... class IMAP4_stream(IMAP4): command: str = ... def __init__(self, command: str) -> None: ... host: str = ... port: int = ... sock: _socket = ... file: IO[Any] = ... process: subprocess.Popen[bytes] = ... writefile: IO[Any] = ... readfile: IO[Any] = ... if sys.version_info >= (3, 9): def open(self, host: Optional[str] = ..., port: Optional[int] = ..., timeout: Optional[float] = ...) -> None: ... else: def open(self, host: Optional[str] = ..., port: Optional[int] = ...) -> None: ... def read(self, size: int) -> bytes: ... def readline(self) -> bytes: ... def send(self, data: bytes) -> None: ... def shutdown(self) -> None: ... class _Authenticator: mech: Callable[[bytes], bytes] = ... def __init__(self, mechinst: Callable[[bytes], bytes]) -> None: ... def process(self, data: str) -> str: ... def encode(self, inp: bytes) -> str: ... def decode(self, inp: str) -> bytes: ... def Internaldate2tuple(resp: str) -> time.struct_time: ... def Int2AP(num: int) -> str: ... def ParseFlags(resp: str) -> Tuple[str]: ... def Time2Internaldate(date_time: Union[float, time.struct_time, str]) -> str: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/imghdr.pyi0000664000175000017500000000113400000000000023655 0ustar00davedave00000000000000import os import sys from typing import Any, BinaryIO, Callable, List, Optional, Protocol, Text, Union, overload class _ReadableBinary(Protocol): def tell(self) -> int: ... def read(self, size: int) -> bytes: ... def seek(self, offset: int) -> Any: ... if sys.version_info >= (3, 6): _File = Union[Text, os.PathLike[Text], _ReadableBinary] else: _File = Union[Text, _ReadableBinary] @overload def what(file: _File, h: None = ...) -> Optional[str]: ... @overload def what(file: Any, h: bytes) -> Optional[str]: ... tests: List[Callable[[bytes, Optional[BinaryIO]], Optional[str]]] ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/keyword.pyi0000664000175000017500000000032200000000000024065 0ustar00davedave00000000000000import sys from typing import Sequence, Text def iskeyword(s: Text) -> bool: ... kwlist: Sequence[str] if sys.version_info >= (3, 9): def issoftkeyword(s: str) -> bool: ... softkwlist: Sequence[str] ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4223793 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/lib2to3/0000775000175000017500000000000000000000000023137 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/lib2to3/__init__.pyi0000664000175000017500000000000000000000000025407 0ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4223793 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/lib2to3/pgen2/0000775000175000017500000000000000000000000024152 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/lib2to3/pgen2/__init__.pyi0000664000175000017500000000000000000000000026422 0ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/lib2to3/pgen2/driver.pyi0000664000175000017500000000167400000000000026200 0ustar00davedave00000000000000from _typeshed import StrPath from lib2to3.pgen2.grammar import Grammar from lib2to3.pytree import _NL, _Convert from logging import Logger from typing import IO, Any, Iterable, Optional, Text class Driver: grammar: Grammar logger: Logger convert: _Convert def __init__(self, grammar: Grammar, convert: Optional[_Convert] = ..., logger: Optional[Logger] = ...) -> None: ... def parse_tokens(self, tokens: Iterable[Any], debug: bool = ...) -> _NL: ... def parse_stream_raw(self, stream: IO[Text], debug: bool = ...) -> _NL: ... def parse_stream(self, stream: IO[Text], debug: bool = ...) -> _NL: ... def parse_file(self, filename: StrPath, encoding: Optional[Text] = ..., debug: bool = ...) -> _NL: ... def parse_string(self, text: Text, debug: bool = ...) -> _NL: ... def load_grammar( gt: Text = ..., gp: Optional[Text] = ..., save: bool = ..., force: bool = ..., logger: Optional[Logger] = ... ) -> Grammar: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/lib2to3/pgen2/grammar.pyi0000664000175000017500000000133500000000000026325 0ustar00davedave00000000000000from _typeshed import StrPath from typing import Dict, List, Optional, Text, Tuple, TypeVar _P = TypeVar("_P") _Label = Tuple[int, Optional[Text]] _DFA = List[List[Tuple[int, int]]] _DFAS = Tuple[_DFA, Dict[int, int]] class Grammar: symbol2number: Dict[Text, int] number2symbol: Dict[int, Text] states: List[_DFA] dfas: Dict[int, _DFAS] labels: List[_Label] keywords: Dict[Text, int] tokens: Dict[int, int] symbol2label: Dict[Text, int] start: int def __init__(self) -> None: ... def dump(self, filename: StrPath) -> None: ... def load(self, filename: StrPath) -> None: ... def copy(self: _P) -> _P: ... def report(self) -> None: ... opmap_raw: Text opmap: Dict[Text, Text] ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/lib2to3/pgen2/literals.pyi0000664000175000017500000000025400000000000026515 0ustar00davedave00000000000000from typing import Dict, Match, Text simple_escapes: Dict[Text, Text] def escape(m: Match[str]) -> Text: ... def evalString(s: Text) -> Text: ... def test() -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/lib2to3/pgen2/parse.pyi0000664000175000017500000000212300000000000026005 0ustar00davedave00000000000000from lib2to3.pgen2.grammar import _DFAS, Grammar from lib2to3.pytree import _NL, _Convert, _RawNode from typing import Any, List, Optional, Sequence, Set, Text, Tuple _Context = Sequence[Any] class ParseError(Exception): msg: Text type: int value: Optional[Text] context: _Context def __init__(self, msg: Text, type: int, value: Optional[Text], context: _Context) -> None: ... class Parser: grammar: Grammar convert: _Convert stack: List[Tuple[_DFAS, int, _RawNode]] rootnode: Optional[_NL] used_names: Set[Text] def __init__(self, grammar: Grammar, convert: Optional[_Convert] = ...) -> None: ... def setup(self, start: Optional[int] = ...) -> None: ... def addtoken(self, type: int, value: Optional[Text], context: _Context) -> bool: ... def classify(self, type: int, value: Optional[Text], context: _Context) -> int: ... def shift(self, type: int, value: Optional[Text], newstate: int, context: _Context) -> None: ... def push(self, type: int, newdfa: _DFAS, newstate: int, context: _Context) -> None: ... def pop(self) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/lib2to3/pgen2/pgen.pyi0000664000175000017500000000413400000000000025630 0ustar00davedave00000000000000from _typeshed import StrPath from lib2to3.pgen2 import grammar from lib2to3.pgen2.tokenize import _TokenInfo from typing import IO, Any, Dict, Iterable, Iterator, List, NoReturn, Optional, Text, Tuple class PgenGrammar(grammar.Grammar): ... class ParserGenerator: filename: StrPath stream: IO[Text] generator: Iterator[_TokenInfo] first: Dict[Text, Dict[Text, int]] def __init__(self, filename: StrPath, stream: Optional[IO[Text]] = ...) -> None: ... def make_grammar(self) -> PgenGrammar: ... def make_first(self, c: PgenGrammar, name: Text) -> Dict[int, int]: ... def make_label(self, c: PgenGrammar, label: Text) -> int: ... def addfirstsets(self) -> None: ... def calcfirst(self, name: Text) -> None: ... def parse(self) -> Tuple[Dict[Text, List[DFAState]], Text]: ... def make_dfa(self, start: NFAState, finish: NFAState) -> List[DFAState]: ... def dump_nfa(self, name: Text, start: NFAState, finish: NFAState) -> List[DFAState]: ... def dump_dfa(self, name: Text, dfa: Iterable[DFAState]) -> None: ... def simplify_dfa(self, dfa: List[DFAState]) -> None: ... def parse_rhs(self) -> Tuple[NFAState, NFAState]: ... def parse_alt(self) -> Tuple[NFAState, NFAState]: ... def parse_item(self) -> Tuple[NFAState, NFAState]: ... def parse_atom(self) -> Tuple[NFAState, NFAState]: ... def expect(self, type: int, value: Optional[Any] = ...) -> Text: ... def gettoken(self) -> None: ... def raise_error(self, msg: str, *args: Any) -> NoReturn: ... class NFAState: arcs: List[Tuple[Optional[Text], NFAState]] def __init__(self) -> None: ... def addarc(self, next: NFAState, label: Optional[Text] = ...) -> None: ... class DFAState: nfaset: Dict[NFAState, Any] isfinal: bool arcs: Dict[Text, DFAState] def __init__(self, nfaset: Dict[NFAState, Any], final: NFAState) -> None: ... def addarc(self, next: DFAState, label: Text) -> None: ... def unifystate(self, old: DFAState, new: DFAState) -> None: ... def __eq__(self, other: Any) -> bool: ... def generate_grammar(filename: StrPath = ...) -> PgenGrammar: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/lib2to3/pgen2/token.pyi0000664000175000017500000000205100000000000026013 0ustar00davedave00000000000000import sys from typing import Dict, Text ENDMARKER: int NAME: int NUMBER: int STRING: int NEWLINE: int INDENT: int DEDENT: int LPAR: int RPAR: int LSQB: int RSQB: int COLON: int COMMA: int SEMI: int PLUS: int MINUS: int STAR: int SLASH: int VBAR: int AMPER: int LESS: int GREATER: int EQUAL: int DOT: int PERCENT: int BACKQUOTE: int LBRACE: int RBRACE: int EQEQUAL: int NOTEQUAL: int LESSEQUAL: int GREATEREQUAL: int TILDE: int CIRCUMFLEX: int LEFTSHIFT: int RIGHTSHIFT: int DOUBLESTAR: int PLUSEQUAL: int MINEQUAL: int STAREQUAL: int SLASHEQUAL: int PERCENTEQUAL: int AMPEREQUAL: int VBAREQUAL: int CIRCUMFLEXEQUAL: int LEFTSHIFTEQUAL: int RIGHTSHIFTEQUAL: int DOUBLESTAREQUAL: int DOUBLESLASH: int DOUBLESLASHEQUAL: int OP: int COMMENT: int NL: int if sys.version_info >= (3,): RARROW: int if sys.version_info >= (3, 5): AT: int ATEQUAL: int AWAIT: int ASYNC: int ERRORTOKEN: int N_TOKENS: int NT_OFFSET: int tok_name: Dict[int, Text] def ISTERMINAL(x: int) -> bool: ... def ISNONTERMINAL(x: int) -> bool: ... def ISEOF(x: int) -> bool: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/lib2to3/pgen2/tokenize.pyi0000664000175000017500000000156300000000000026532 0ustar00davedave00000000000000from lib2to3.pgen2.token import * # noqa from typing import Callable, Iterable, Iterator, List, Text, Tuple _Coord = Tuple[int, int] _TokenEater = Callable[[int, Text, _Coord, _Coord, Text], None] _TokenInfo = Tuple[int, Text, _Coord, _Coord, Text] class TokenError(Exception): ... class StopTokenizing(Exception): ... def tokenize(readline: Callable[[], Text], tokeneater: _TokenEater = ...) -> None: ... class Untokenizer: tokens: List[Text] prev_row: int prev_col: int def __init__(self) -> None: ... def add_whitespace(self, start: _Coord) -> None: ... def untokenize(self, iterable: Iterable[_TokenInfo]) -> Text: ... def compat(self, token: Tuple[int, Text], iterable: Iterable[_TokenInfo]) -> None: ... def untokenize(iterable: Iterable[_TokenInfo]) -> Text: ... def generate_tokens(readline: Callable[[], Text]) -> Iterator[_TokenInfo]: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/lib2to3/pygram.pyi0000664000175000017500000000424000000000000025161 0ustar00davedave00000000000000from lib2to3.pgen2.grammar import Grammar class Symbols: def __init__(self, grammar: Grammar) -> None: ... class python_symbols(Symbols): and_expr: int and_test: int annassign: int arglist: int argument: int arith_expr: int assert_stmt: int async_funcdef: int async_stmt: int atom: int augassign: int break_stmt: int classdef: int comp_for: int comp_if: int comp_iter: int comp_op: int comparison: int compound_stmt: int continue_stmt: int decorated: int decorator: int decorators: int del_stmt: int dictsetmaker: int dotted_as_name: int dotted_as_names: int dotted_name: int encoding_decl: int eval_input: int except_clause: int exec_stmt: int expr: int expr_stmt: int exprlist: int factor: int file_input: int flow_stmt: int for_stmt: int funcdef: int global_stmt: int if_stmt: int import_as_name: int import_as_names: int import_from: int import_name: int import_stmt: int lambdef: int listmaker: int not_test: int old_lambdef: int old_test: int or_test: int parameters: int pass_stmt: int power: int print_stmt: int raise_stmt: int return_stmt: int shift_expr: int simple_stmt: int single_input: int sliceop: int small_stmt: int star_expr: int stmt: int subscript: int subscriptlist: int suite: int term: int test: int testlist: int testlist1: int testlist_gexp: int testlist_safe: int testlist_star_expr: int tfpdef: int tfplist: int tname: int trailer: int try_stmt: int typedargslist: int varargslist: int vfpdef: int vfplist: int vname: int while_stmt: int with_item: int with_stmt: int with_var: int xor_expr: int yield_arg: int yield_expr: int yield_stmt: int class pattern_symbols(Symbols): Alternative: int Alternatives: int Details: int Matcher: int NegatedUnit: int Repeater: int Unit: int python_grammar: Grammar python_grammar_no_print_statement: Grammar pattern_grammar: Grammar ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/lib2to3/pytree.pyi0000664000175000017500000000637200000000000025202 0ustar00davedave00000000000000import sys from lib2to3.pgen2.grammar import Grammar from typing import Any, Callable, Dict, Iterator, List, Optional, Text, Tuple, TypeVar, Union _P = TypeVar("_P") _NL = Union[Node, Leaf] _Context = Tuple[Text, int, int] _Results = Dict[Text, _NL] _RawNode = Tuple[int, Text, _Context, Optional[List[_NL]]] _Convert = Callable[[Grammar, _RawNode], Any] HUGE: int def type_repr(type_num: int) -> Text: ... class Base: type: int parent: Optional[Node] prefix: Text children: List[_NL] was_changed: bool was_checked: bool def __eq__(self, other: Any) -> bool: ... def _eq(self: _P, other: _P) -> bool: ... def clone(self: _P) -> _P: ... def post_order(self) -> Iterator[_NL]: ... def pre_order(self) -> Iterator[_NL]: ... def replace(self, new: Union[_NL, List[_NL]]) -> None: ... def get_lineno(self) -> int: ... def changed(self) -> None: ... def remove(self) -> Optional[int]: ... @property def next_sibling(self) -> Optional[_NL]: ... @property def prev_sibling(self) -> Optional[_NL]: ... def leaves(self) -> Iterator[Leaf]: ... def depth(self) -> int: ... def get_suffix(self) -> Text: ... if sys.version_info < (3,): def get_prefix(self) -> Text: ... def set_prefix(self, prefix: Text) -> None: ... class Node(Base): fixers_applied: List[Any] def __init__( self, type: int, children: List[_NL], context: Optional[Any] = ..., prefix: Optional[Text] = ..., fixers_applied: Optional[List[Any]] = ..., ) -> None: ... def set_child(self, i: int, child: _NL) -> None: ... def insert_child(self, i: int, child: _NL) -> None: ... def append_child(self, child: _NL) -> None: ... class Leaf(Base): lineno: int column: int value: Text fixers_applied: List[Any] def __init__( self, type: int, value: Text, context: Optional[_Context] = ..., prefix: Optional[Text] = ..., fixers_applied: List[Any] = ..., ) -> None: ... def convert(gr: Grammar, raw_node: _RawNode) -> _NL: ... class BasePattern: type: int content: Optional[Text] name: Optional[Text] def optimize(self) -> BasePattern: ... # sic, subclasses are free to optimize themselves into different patterns def match(self, node: _NL, results: Optional[_Results] = ...) -> bool: ... def match_seq(self, nodes: List[_NL], results: Optional[_Results] = ...) -> bool: ... def generate_matches(self, nodes: List[_NL]) -> Iterator[Tuple[int, _Results]]: ... class LeafPattern(BasePattern): def __init__(self, type: Optional[int] = ..., content: Optional[Text] = ..., name: Optional[Text] = ...) -> None: ... class NodePattern(BasePattern): wildcards: bool def __init__(self, type: Optional[int] = ..., content: Optional[Text] = ..., name: Optional[Text] = ...) -> None: ... class WildcardPattern(BasePattern): min: int max: int def __init__(self, content: Optional[Text] = ..., min: int = ..., max: int = ..., name: Optional[Text] = ...) -> None: ... class NegatedPattern(BasePattern): def __init__(self, content: Optional[Text] = ...) -> None: ... def generate_matches(patterns: List[BasePattern], nodes: List[_NL]) -> Iterator[Tuple[int, _Results]]: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/linecache.pyi0000664000175000017500000000111700000000000024317 0ustar00davedave00000000000000import sys from typing import Any, Dict, List, Optional, Text _ModuleGlobals = Dict[str, Any] def getline(filename: Text, lineno: int, module_globals: Optional[_ModuleGlobals] = ...) -> str: ... def clearcache() -> None: ... def getlines(filename: Text, module_globals: Optional[_ModuleGlobals] = ...) -> List[str]: ... def checkcache(filename: Optional[Text] = ...) -> None: ... def updatecache(filename: Text, module_globals: Optional[_ModuleGlobals] = ...) -> List[str]: ... if sys.version_info >= (3, 5): def lazycache(filename: Text, module_globals: _ModuleGlobals) -> bool: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/locale.pyi0000664000175000017500000000477300000000000023656 0ustar00davedave00000000000000import sys from decimal import Decimal from typing import Any, Callable, Dict, Iterable, List, Mapping, Optional, Sequence, Tuple, Union # workaround for mypy#2010 if sys.version_info < (3,): from __builtin__ import str as _str else: from builtins import str as _str CODESET: int D_T_FMT: int D_FMT: int T_FMT: int T_FMT_AMPM: int DAY_1: int DAY_2: int DAY_3: int DAY_4: int DAY_5: int DAY_6: int DAY_7: int ABDAY_1: int ABDAY_2: int ABDAY_3: int ABDAY_4: int ABDAY_5: int ABDAY_6: int ABDAY_7: int MON_1: int MON_2: int MON_3: int MON_4: int MON_5: int MON_6: int MON_7: int MON_8: int MON_9: int MON_10: int MON_11: int MON_12: int ABMON_1: int ABMON_2: int ABMON_3: int ABMON_4: int ABMON_5: int ABMON_6: int ABMON_7: int ABMON_8: int ABMON_9: int ABMON_10: int ABMON_11: int ABMON_12: int RADIXCHAR: int THOUSEP: int YESEXPR: int NOEXPR: int CRNCYSTR: int ERA: int ERA_D_T_FMT: int ERA_D_FMT: int ERA_T_FMT: int ALT_DIGITS: int LC_CTYPE: int LC_COLLATE: int LC_TIME: int LC_MONETARY: int LC_MESSAGES: int LC_NUMERIC: int LC_ALL: int CHAR_MAX: int class Error(Exception): ... def setlocale(category: int, locale: Union[_str, Iterable[_str], None] = ...) -> _str: ... def localeconv() -> Mapping[_str, Union[int, _str, List[int]]]: ... def nl_langinfo(option: int) -> _str: ... def getdefaultlocale(envvars: Tuple[_str, ...] = ...) -> Tuple[Optional[_str], Optional[_str]]: ... def getlocale(category: int = ...) -> Sequence[_str]: ... def getpreferredencoding(do_setlocale: bool = ...) -> _str: ... def normalize(localename: _str) -> _str: ... def resetlocale(category: int = ...) -> None: ... def strcoll(string1: _str, string2: _str) -> int: ... def strxfrm(string: _str) -> _str: ... def format(percent: _str, value: Union[float, Decimal], grouping: bool = ..., monetary: bool = ..., *additional: Any) -> _str: ... if sys.version_info >= (3, 7): def format_string(f: _str, val: Any, grouping: bool = ..., monetary: bool = ...) -> _str: ... else: def format_string(f: _str, val: Any, grouping: bool = ...) -> _str: ... def currency(val: Union[int, float, Decimal], symbol: bool = ..., grouping: bool = ..., international: bool = ...) -> _str: ... if sys.version_info >= (3, 5): def delocalize(string: _str) -> _str: ... def atof(string: _str, func: Callable[[_str], float] = ...) -> float: ... def atoi(string: _str) -> int: ... def str(val: float) -> _str: ... locale_alias: Dict[_str, _str] # undocumented locale_encoding_alias: Dict[_str, _str] # undocumented windows_locale: Dict[int, _str] # undocumented ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4223793 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/logging/0000775000175000017500000000000000000000000023307 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/logging/__init__.pyi0000664000175000017500000006730600000000000025605 0ustar00davedave00000000000000import sys import threading from _typeshed import StrPath from string import Template from time import struct_time from types import FrameType, TracebackType from typing import ( IO, Any, Callable, Dict, Iterable, List, Mapping, MutableMapping, Optional, Sequence, Text, Tuple, Union, overload, ) _SysExcInfoType = Union[Tuple[type, BaseException, Optional[TracebackType]], Tuple[None, None, None]] if sys.version_info >= (3, 5): _ExcInfoType = Union[None, bool, _SysExcInfoType, BaseException] else: _ExcInfoType = Union[None, bool, _SysExcInfoType] _ArgsType = Union[Tuple[Any, ...], Mapping[str, Any]] _FilterType = Union[Filter, Callable[[LogRecord], int]] _Level = Union[int, Text] raiseExceptions: bool logThreads: bool logMultiprocessing: bool logProcesses: bool _srcfile: Optional[str] def currentframe() -> FrameType: ... if sys.version_info >= (3,): _levelToName: Dict[int, str] _nameToLevel: Dict[str, int] else: _levelNames: Dict[Union[int, str], Union[str, int]] # Union[int:str, str:int] class Filterer(object): filters: List[Filter] def __init__(self) -> None: ... def addFilter(self, filter: _FilterType) -> None: ... def removeFilter(self, filter: _FilterType) -> None: ... def filter(self, record: LogRecord) -> bool: ... class Logger(Filterer): name: str level: int parent: Union[Logger, PlaceHolder] propagate: bool handlers: List[Handler] disabled: int def __init__(self, name: str, level: _Level = ...) -> None: ... def setLevel(self, level: _Level) -> None: ... def isEnabledFor(self, level: int) -> bool: ... def getEffectiveLevel(self) -> int: ... def getChild(self, suffix: str) -> Logger: ... if sys.version_info >= (3, 8): def debug( self, msg: Any, *args: Any, exc_info: _ExcInfoType = ..., stack_info: bool = ..., stacklevel: int = ..., extra: Optional[Dict[str, Any]] = ..., **kwargs: Any, ) -> None: ... def info( self, msg: Any, *args: Any, exc_info: _ExcInfoType = ..., stack_info: bool = ..., stacklevel: int = ..., extra: Optional[Dict[str, Any]] = ..., **kwargs: Any, ) -> None: ... def warning( self, msg: Any, *args: Any, exc_info: _ExcInfoType = ..., stack_info: bool = ..., stacklevel: int = ..., extra: Optional[Dict[str, Any]] = ..., **kwargs: Any, ) -> None: ... def warn( self, msg: Any, *args: Any, exc_info: _ExcInfoType = ..., stack_info: bool = ..., stacklevel: int = ..., extra: Optional[Dict[str, Any]] = ..., **kwargs: Any, ) -> None: ... def error( self, msg: Any, *args: Any, exc_info: _ExcInfoType = ..., stack_info: bool = ..., stacklevel: int = ..., extra: Optional[Dict[str, Any]] = ..., **kwargs: Any, ) -> None: ... def exception( self, msg: Any, *args: Any, exc_info: _ExcInfoType = ..., stack_info: bool = ..., stacklevel: int = ..., extra: Optional[Dict[str, Any]] = ..., **kwargs: Any, ) -> None: ... def critical( self, msg: Any, *args: Any, exc_info: _ExcInfoType = ..., stack_info: bool = ..., stacklevel: int = ..., extra: Optional[Dict[str, Any]] = ..., **kwargs: Any, ) -> None: ... def log( self, level: int, msg: Any, *args: Any, exc_info: _ExcInfoType = ..., stack_info: bool = ..., stacklevel: int = ..., extra: Optional[Dict[str, Any]] = ..., **kwargs: Any, ) -> None: ... def _log( self, level: int, msg: Any, args: _ArgsType, exc_info: Optional[_ExcInfoType] = ..., extra: Optional[Dict[str, Any]] = ..., stack_info: bool = ..., stacklevel: int = ..., ) -> None: ... # undocumented elif sys.version_info >= (3,): def debug( self, msg: Any, *args: Any, exc_info: _ExcInfoType = ..., stack_info: bool = ..., extra: Optional[Dict[str, Any]] = ..., **kwargs: Any, ) -> None: ... def info( self, msg: Any, *args: Any, exc_info: _ExcInfoType = ..., stack_info: bool = ..., extra: Optional[Dict[str, Any]] = ..., **kwargs: Any, ) -> None: ... def warning( self, msg: Any, *args: Any, exc_info: _ExcInfoType = ..., stack_info: bool = ..., extra: Optional[Dict[str, Any]] = ..., **kwargs: Any, ) -> None: ... def warn( self, msg: Any, *args: Any, exc_info: _ExcInfoType = ..., stack_info: bool = ..., extra: Optional[Dict[str, Any]] = ..., **kwargs: Any, ) -> None: ... def error( self, msg: Any, *args: Any, exc_info: _ExcInfoType = ..., stack_info: bool = ..., extra: Optional[Dict[str, Any]] = ..., **kwargs: Any, ) -> None: ... def critical( self, msg: Any, *args: Any, exc_info: _ExcInfoType = ..., stack_info: bool = ..., extra: Optional[Dict[str, Any]] = ..., **kwargs: Any, ) -> None: ... fatal = critical def log( self, level: int, msg: Any, *args: Any, exc_info: _ExcInfoType = ..., stack_info: bool = ..., extra: Optional[Dict[str, Any]] = ..., **kwargs: Any, ) -> None: ... def exception( self, msg: Any, *args: Any, exc_info: _ExcInfoType = ..., stack_info: bool = ..., extra: Optional[Dict[str, Any]] = ..., **kwargs: Any, ) -> None: ... def _log( self, level: int, msg: Any, args: _ArgsType, exc_info: Optional[_ExcInfoType] = ..., extra: Optional[Dict[str, Any]] = ..., stack_info: bool = ..., ) -> None: ... # undocumented else: def debug( self, msg: Any, *args: Any, exc_info: _ExcInfoType = ..., extra: Optional[Dict[str, Any]] = ..., **kwargs: Any ) -> None: ... def info( self, msg: Any, *args: Any, exc_info: _ExcInfoType = ..., extra: Optional[Dict[str, Any]] = ..., **kwargs: Any ) -> None: ... def warning( self, msg: Any, *args: Any, exc_info: _ExcInfoType = ..., extra: Optional[Dict[str, Any]] = ..., **kwargs: Any ) -> None: ... warn = warning def error( self, msg: Any, *args: Any, exc_info: _ExcInfoType = ..., extra: Optional[Dict[str, Any]] = ..., **kwargs: Any ) -> None: ... def critical( self, msg: Any, *args: Any, exc_info: _ExcInfoType = ..., extra: Optional[Dict[str, Any]] = ..., **kwargs: Any ) -> None: ... fatal = critical def log( self, level: int, msg: Any, *args: Any, exc_info: _ExcInfoType = ..., extra: Optional[Dict[str, Any]] = ..., **kwargs: Any, ) -> None: ... def exception( self, msg: Any, *args: Any, exc_info: _ExcInfoType = ..., extra: Optional[Dict[str, Any]] = ..., **kwargs: Any ) -> None: ... def _log( self, level: int, msg: Any, args: _ArgsType, exc_info: Optional[_ExcInfoType] = ..., extra: Optional[Dict[str, Any]] = ..., ) -> None: ... # undocumented def filter(self, record: LogRecord) -> bool: ... def addHandler(self, hdlr: Handler) -> None: ... def removeHandler(self, hdlr: Handler) -> None: ... if sys.version_info >= (3, 8): def findCaller(self, stack_info: bool = ..., stacklevel: int = ...) -> Tuple[str, int, str, Optional[str]]: ... elif sys.version_info >= (3,): def findCaller(self, stack_info: bool = ...) -> Tuple[str, int, str, Optional[str]]: ... else: def findCaller(self) -> Tuple[str, int, str]: ... def handle(self, record: LogRecord) -> None: ... if sys.version_info >= (3,): def makeRecord( self, name: str, level: int, fn: str, lno: int, msg: Any, args: _ArgsType, exc_info: Optional[_SysExcInfoType], func: Optional[str] = ..., extra: Optional[Mapping[str, Any]] = ..., sinfo: Optional[str] = ..., ) -> LogRecord: ... else: def makeRecord( self, name: str, level: int, fn: str, lno: int, msg: Any, args: _ArgsType, exc_info: Optional[_SysExcInfoType], func: Optional[str] = ..., extra: Optional[Mapping[str, Any]] = ..., ) -> LogRecord: ... if sys.version_info >= (3,): def hasHandlers(self) -> bool: ... CRITICAL: int FATAL: int ERROR: int WARNING: int WARN: int INFO: int DEBUG: int NOTSET: int class Handler(Filterer): level: int # undocumented formatter: Optional[Formatter] # undocumented lock: Optional[threading.Lock] # undocumented name: Optional[str] # undocumented def __init__(self, level: _Level = ...) -> None: ... def createLock(self) -> None: ... def acquire(self) -> None: ... def release(self) -> None: ... def setLevel(self, level: _Level) -> None: ... def setFormatter(self, fmt: Formatter) -> None: ... def filter(self, record: LogRecord) -> bool: ... def flush(self) -> None: ... def close(self) -> None: ... def handle(self, record: LogRecord) -> None: ... def handleError(self, record: LogRecord) -> None: ... def format(self, record: LogRecord) -> str: ... def emit(self, record: LogRecord) -> None: ... class Formatter: converter: Callable[[Optional[float]], struct_time] _fmt: Optional[str] datefmt: Optional[str] if sys.version_info >= (3,): _style: PercentStyle default_time_format: str default_msec_format: str if sys.version_info >= (3, 8): def __init__( self, fmt: Optional[str] = ..., datefmt: Optional[str] = ..., style: str = ..., validate: bool = ... ) -> None: ... elif sys.version_info >= (3,): def __init__(self, fmt: Optional[str] = ..., datefmt: Optional[str] = ..., style: str = ...) -> None: ... else: def __init__(self, fmt: Optional[str] = ..., datefmt: Optional[str] = ...) -> None: ... def format(self, record: LogRecord) -> str: ... def formatTime(self, record: LogRecord, datefmt: Optional[str] = ...) -> str: ... def formatException(self, ei: _SysExcInfoType) -> str: ... if sys.version_info >= (3,): def formatMessage(self, record: LogRecord) -> str: ... # undocumented def formatStack(self, stack_info: str) -> str: ... class Filter: def __init__(self, name: str = ...) -> None: ... def filter(self, record: LogRecord) -> bool: ... class LogRecord: args: _ArgsType asctime: str created: int exc_info: Optional[_SysExcInfoType] exc_text: Optional[str] filename: str funcName: str levelname: str levelno: int lineno: int module: str msecs: int message: str msg: str name: str pathname: str process: int processName: str relativeCreated: int if sys.version_info >= (3,): stack_info: Optional[str] thread: int threadName: str if sys.version_info >= (3,): def __init__( self, name: str, level: int, pathname: str, lineno: int, msg: Any, args: _ArgsType, exc_info: Optional[_SysExcInfoType], func: Optional[str] = ..., sinfo: Optional[str] = ..., ) -> None: ... else: def __init__( self, name: str, level: int, pathname: str, lineno: int, msg: Any, args: _ArgsType, exc_info: Optional[_SysExcInfoType], func: Optional[str] = ..., ) -> None: ... def getMessage(self) -> str: ... class LoggerAdapter: logger: Logger extra: Mapping[str, Any] def __init__(self, logger: Logger, extra: Mapping[str, Any]) -> None: ... def process(self, msg: Any, kwargs: MutableMapping[str, Any]) -> Tuple[Any, MutableMapping[str, Any]]: ... if sys.version_info >= (3, 8): def debug( self, msg: Any, *args: Any, exc_info: _ExcInfoType = ..., stack_info: bool = ..., stacklevel: int = ..., extra: Optional[Dict[str, Any]] = ..., **kwargs: Any, ) -> None: ... def info( self, msg: Any, *args: Any, exc_info: _ExcInfoType = ..., stack_info: bool = ..., stacklevel: int = ..., extra: Optional[Dict[str, Any]] = ..., **kwargs: Any, ) -> None: ... def warning( self, msg: Any, *args: Any, exc_info: _ExcInfoType = ..., stack_info: bool = ..., stacklevel: int = ..., extra: Optional[Dict[str, Any]] = ..., **kwargs: Any, ) -> None: ... def warn( self, msg: Any, *args: Any, exc_info: _ExcInfoType = ..., stack_info: bool = ..., stacklevel: int = ..., extra: Optional[Dict[str, Any]] = ..., **kwargs: Any, ) -> None: ... def error( self, msg: Any, *args: Any, exc_info: _ExcInfoType = ..., stack_info: bool = ..., stacklevel: int = ..., extra: Optional[Dict[str, Any]] = ..., **kwargs: Any, ) -> None: ... def exception( self, msg: Any, *args: Any, exc_info: _ExcInfoType = ..., stack_info: bool = ..., stacklevel: int = ..., extra: Optional[Dict[str, Any]] = ..., **kwargs: Any, ) -> None: ... def critical( self, msg: Any, *args: Any, exc_info: _ExcInfoType = ..., stack_info: bool = ..., stacklevel: int = ..., extra: Optional[Dict[str, Any]] = ..., **kwargs: Any, ) -> None: ... def log( self, level: int, msg: Any, *args: Any, exc_info: _ExcInfoType = ..., stack_info: bool = ..., stacklevel: int = ..., extra: Optional[Dict[str, Any]] = ..., **kwargs: Any, ) -> None: ... elif sys.version_info >= (3,): def debug( self, msg: Any, *args: Any, exc_info: _ExcInfoType = ..., stack_info: bool = ..., extra: Optional[Dict[str, Any]] = ..., **kwargs: Any, ) -> None: ... def info( self, msg: Any, *args: Any, exc_info: _ExcInfoType = ..., stack_info: bool = ..., extra: Optional[Dict[str, Any]] = ..., **kwargs: Any, ) -> None: ... def warning( self, msg: Any, *args: Any, exc_info: _ExcInfoType = ..., stack_info: bool = ..., extra: Optional[Dict[str, Any]] = ..., **kwargs: Any, ) -> None: ... def warn( self, msg: Any, *args: Any, exc_info: _ExcInfoType = ..., stack_info: bool = ..., extra: Optional[Dict[str, Any]] = ..., **kwargs: Any, ) -> None: ... def error( self, msg: Any, *args: Any, exc_info: _ExcInfoType = ..., stack_info: bool = ..., extra: Optional[Dict[str, Any]] = ..., **kwargs: Any, ) -> None: ... def exception( self, msg: Any, *args: Any, exc_info: _ExcInfoType = ..., stack_info: bool = ..., extra: Optional[Dict[str, Any]] = ..., **kwargs: Any, ) -> None: ... def critical( self, msg: Any, *args: Any, exc_info: _ExcInfoType = ..., stack_info: bool = ..., extra: Optional[Dict[str, Any]] = ..., **kwargs: Any, ) -> None: ... def log( self, level: int, msg: Any, *args: Any, exc_info: _ExcInfoType = ..., stack_info: bool = ..., extra: Optional[Dict[str, Any]] = ..., **kwargs: Any, ) -> None: ... else: def debug( self, msg: Any, *args: Any, exc_info: _ExcInfoType = ..., extra: Optional[Dict[str, Any]] = ..., **kwargs: Any ) -> None: ... def info( self, msg: Any, *args: Any, exc_info: _ExcInfoType = ..., extra: Optional[Dict[str, Any]] = ..., **kwargs: Any ) -> None: ... def warning( self, msg: Any, *args: Any, exc_info: _ExcInfoType = ..., extra: Optional[Dict[str, Any]] = ..., **kwargs: Any ) -> None: ... def error( self, msg: Any, *args: Any, exc_info: _ExcInfoType = ..., extra: Optional[Dict[str, Any]] = ..., **kwargs: Any ) -> None: ... def exception( self, msg: Any, *args: Any, exc_info: _ExcInfoType = ..., extra: Optional[Dict[str, Any]] = ..., **kwargs: Any ) -> None: ... def critical( self, msg: Any, *args: Any, exc_info: _ExcInfoType = ..., extra: Optional[Dict[str, Any]] = ..., **kwargs: Any ) -> None: ... def log( self, level: int, msg: Any, *args: Any, exc_info: _ExcInfoType = ..., extra: Optional[Dict[str, Any]] = ..., **kwargs: Any, ) -> None: ... def isEnabledFor(self, level: int) -> bool: ... if sys.version_info >= (3,): def getEffectiveLevel(self) -> int: ... def setLevel(self, level: Union[int, str]) -> None: ... def hasHandlers(self) -> bool: ... if sys.version_info >= (3, 6): def _log( self, level: int, msg: Any, args: _ArgsType, exc_info: Optional[_ExcInfoType] = ..., extra: Optional[Dict[str, Any]] = ..., stack_info: bool = ..., ) -> None: ... # undocumented if sys.version_info >= (3,): def getLogger(name: Optional[str] = ...) -> Logger: ... else: @overload def getLogger() -> Logger: ... @overload def getLogger(name: Union[Text, str]) -> Logger: ... def getLoggerClass() -> type: ... if sys.version_info >= (3,): def getLogRecordFactory() -> Callable[..., LogRecord]: ... if sys.version_info >= (3, 8): def debug( msg: Any, *args: Any, exc_info: _ExcInfoType = ..., stack_info: bool = ..., stacklevel: int = ..., extra: Optional[Dict[str, Any]] = ..., **kwargs: Any, ) -> None: ... def info( msg: Any, *args: Any, exc_info: _ExcInfoType = ..., stack_info: bool = ..., stacklevel: int = ..., extra: Optional[Dict[str, Any]] = ..., **kwargs: Any, ) -> None: ... def warning( msg: Any, *args: Any, exc_info: _ExcInfoType = ..., stack_info: bool = ..., stacklevel: int = ..., extra: Optional[Dict[str, Any]] = ..., **kwargs: Any, ) -> None: ... def warn( msg: Any, *args: Any, exc_info: _ExcInfoType = ..., stack_info: bool = ..., stacklevel: int = ..., extra: Optional[Dict[str, Any]] = ..., **kwargs: Any, ) -> None: ... def error( msg: Any, *args: Any, exc_info: _ExcInfoType = ..., stack_info: bool = ..., stacklevel: int = ..., extra: Optional[Dict[str, Any]] = ..., **kwargs: Any, ) -> None: ... def critical( msg: Any, *args: Any, exc_info: _ExcInfoType = ..., stack_info: bool = ..., stacklevel: int = ..., extra: Optional[Dict[str, Any]] = ..., **kwargs: Any, ) -> None: ... def exception( msg: Any, *args: Any, exc_info: _ExcInfoType = ..., stack_info: bool = ..., stacklevel: int = ..., extra: Optional[Dict[str, Any]] = ..., **kwargs: Any, ) -> None: ... def log( level: int, msg: Any, *args: Any, exc_info: _ExcInfoType = ..., stack_info: bool = ..., stacklevel: int = ..., extra: Optional[Dict[str, Any]] = ..., **kwargs: Any, ) -> None: ... elif sys.version_info >= (3,): def debug( msg: Any, *args: Any, exc_info: _ExcInfoType = ..., stack_info: bool = ..., extra: Optional[Dict[str, Any]] = ..., **kwargs: Any, ) -> None: ... def info( msg: Any, *args: Any, exc_info: _ExcInfoType = ..., stack_info: bool = ..., extra: Optional[Dict[str, Any]] = ..., **kwargs: Any, ) -> None: ... def warning( msg: Any, *args: Any, exc_info: _ExcInfoType = ..., stack_info: bool = ..., extra: Optional[Dict[str, Any]] = ..., **kwargs: Any, ) -> None: ... def warn( msg: Any, *args: Any, exc_info: _ExcInfoType = ..., stack_info: bool = ..., extra: Optional[Dict[str, Any]] = ..., **kwargs: Any, ) -> None: ... def error( msg: Any, *args: Any, exc_info: _ExcInfoType = ..., stack_info: bool = ..., extra: Optional[Dict[str, Any]] = ..., **kwargs: Any, ) -> None: ... def critical( msg: Any, *args: Any, exc_info: _ExcInfoType = ..., stack_info: bool = ..., extra: Optional[Dict[str, Any]] = ..., **kwargs: Any, ) -> None: ... def exception( msg: Any, *args: Any, exc_info: _ExcInfoType = ..., stack_info: bool = ..., extra: Optional[Dict[str, Any]] = ..., **kwargs: Any, ) -> None: ... def log( level: int, msg: Any, *args: Any, exc_info: _ExcInfoType = ..., stack_info: bool = ..., extra: Optional[Dict[str, Any]] = ..., **kwargs: Any, ) -> None: ... else: def debug( msg: Any, *args: Any, exc_info: _ExcInfoType = ..., extra: Optional[Dict[str, Any]] = ..., **kwargs: Any ) -> None: ... def info( msg: Any, *args: Any, exc_info: _ExcInfoType = ..., extra: Optional[Dict[str, Any]] = ..., **kwargs: Any ) -> None: ... def warning( msg: Any, *args: Any, exc_info: _ExcInfoType = ..., extra: Optional[Dict[str, Any]] = ..., **kwargs: Any ) -> None: ... warn = warning def error( msg: Any, *args: Any, exc_info: _ExcInfoType = ..., extra: Optional[Dict[str, Any]] = ..., **kwargs: Any ) -> None: ... def critical( msg: Any, *args: Any, exc_info: _ExcInfoType = ..., extra: Optional[Dict[str, Any]] = ..., **kwargs: Any ) -> None: ... def exception( msg: Any, *args: Any, exc_info: _ExcInfoType = ..., extra: Optional[Dict[str, Any]] = ..., **kwargs: Any ) -> None: ... def log( level: int, msg: Any, *args: Any, exc_info: _ExcInfoType = ..., extra: Optional[Dict[str, Any]] = ..., **kwargs: Any ) -> None: ... fatal = critical if sys.version_info >= (3, 7): def disable(level: int = ...) -> None: ... else: def disable(level: int) -> None: ... def addLevelName(level: int, levelName: str) -> None: ... def getLevelName(level: Union[int, str]) -> Any: ... def makeLogRecord(dict: Mapping[str, Any]) -> LogRecord: ... if sys.version_info >= (3, 8): def basicConfig( *, filename: Optional[StrPath] = ..., filemode: str = ..., format: str = ..., datefmt: Optional[str] = ..., style: str = ..., level: Optional[_Level] = ..., stream: Optional[IO[str]] = ..., handlers: Optional[Iterable[Handler]] = ..., force: bool = ..., ) -> None: ... elif sys.version_info >= (3,): def basicConfig( *, filename: Optional[StrPath] = ..., filemode: str = ..., format: str = ..., datefmt: Optional[str] = ..., style: str = ..., level: Optional[_Level] = ..., stream: Optional[IO[str]] = ..., handlers: Optional[Iterable[Handler]] = ..., ) -> None: ... else: @overload def basicConfig() -> None: ... @overload def basicConfig( *, filename: Optional[str] = ..., filemode: str = ..., format: str = ..., datefmt: Optional[str] = ..., level: Optional[_Level] = ..., stream: IO[str] = ..., ) -> None: ... def shutdown(handlerList: Sequence[Any] = ...) -> None: ... # handlerList is undocumented def setLoggerClass(klass: type) -> None: ... def captureWarnings(capture: bool) -> None: ... if sys.version_info >= (3,): def setLogRecordFactory(factory: Callable[..., LogRecord]) -> None: ... if sys.version_info >= (3,): lastResort: Optional[StreamHandler] class StreamHandler(Handler): stream: IO[str] # undocumented if sys.version_info >= (3, 2): terminator: str def __init__(self, stream: Optional[IO[str]] = ...) -> None: ... if sys.version_info >= (3, 7): def setStream(self, stream: IO[str]) -> Optional[IO[str]]: ... class FileHandler(StreamHandler): baseFilename: str # undocumented mode: str # undocumented encoding: Optional[str] # undocumented delay: bool # undocumented def __init__(self, filename: StrPath, mode: str = ..., encoding: Optional[str] = ..., delay: bool = ...) -> None: ... def _open(self) -> IO[Any]: ... class NullHandler(Handler): ... class PlaceHolder: def __init__(self, alogger: Logger) -> None: ... def append(self, alogger: Logger) -> None: ... # Below aren't in module docs but still visible class RootLogger(Logger): def __init__(self, level: int) -> None: ... root: RootLogger if sys.version_info >= (3,): class PercentStyle(object): default_format: str asctime_format: str asctime_search: str _fmt: str def __init__(self, fmt: str) -> None: ... def usesTime(self) -> bool: ... def format(self, record: Any) -> str: ... class StrFormatStyle(PercentStyle): ... class StringTemplateStyle(PercentStyle): _tpl: Template _STYLES: Dict[str, Tuple[PercentStyle, str]] BASIC_FORMAT: str ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/logging/config.pyi0000664000175000017500000000170700000000000025304 0ustar00davedave00000000000000import sys from _typeshed import AnyPath, StrPath from threading import Thread from typing import IO, Any, Callable, Dict, Optional, Union if sys.version_info >= (3,): from configparser import RawConfigParser else: from ConfigParser import RawConfigParser if sys.version_info >= (3, 7): _Path = AnyPath else: _Path = StrPath def dictConfig(config: Dict[str, Any]) -> None: ... if sys.version_info >= (3, 4): def fileConfig( fname: Union[_Path, IO[str], RawConfigParser], defaults: Optional[Dict[str, str]] = ..., disable_existing_loggers: bool = ..., ) -> None: ... def listen(port: int = ..., verify: Optional[Callable[[bytes], Optional[bytes]]] = ...) -> Thread: ... else: def fileConfig( fname: Union[str, IO[str]], defaults: Optional[Dict[str, str]] = ..., disable_existing_loggers: bool = ... ) -> None: ... def listen(port: int = ...) -> Thread: ... def stopListening() -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/logging/handlers.pyi0000664000175000017500000002121700000000000025635 0ustar00davedave00000000000000import datetime import ssl import sys from _typeshed import StrPath from logging import FileHandler, Handler, LogRecord from socket import SocketKind, SocketType from typing import Any, Callable, ClassVar, Dict, List, Optional, Tuple, Union if sys.version_info >= (3, 7): from queue import Queue, SimpleQueue elif sys.version_info >= (3,): from queue import Queue else: from Queue import Queue DEFAULT_TCP_LOGGING_PORT: int DEFAULT_UDP_LOGGING_PORT: int DEFAULT_HTTP_LOGGING_PORT: int DEFAULT_SOAP_LOGGING_PORT: int SYSLOG_UDP_PORT: int SYSLOG_TCP_PORT: int class WatchedFileHandler(FileHandler): dev: int ino: int def __init__(self, filename: StrPath, mode: str = ..., encoding: Optional[str] = ..., delay: bool = ...) -> None: ... def _statstream(self) -> None: ... if sys.version_info >= (3,): class BaseRotatingHandler(FileHandler): terminator: str namer: Optional[Callable[[str], str]] rotator: Optional[Callable[[str, str], None]] def __init__(self, filename: StrPath, mode: str, encoding: Optional[str] = ..., delay: bool = ...) -> None: ... def rotation_filename(self, default_name: str) -> None: ... def rotate(self, source: str, dest: str) -> None: ... if sys.version_info >= (3,): class RotatingFileHandler(BaseRotatingHandler): def __init__( self, filename: StrPath, mode: str = ..., maxBytes: int = ..., backupCount: int = ..., encoding: Optional[str] = ..., delay: bool = ..., ) -> None: ... def doRollover(self) -> None: ... else: class RotatingFileHandler(Handler): def __init__( self, filename: str, mode: str = ..., maxBytes: int = ..., backupCount: int = ..., encoding: Optional[str] = ..., delay: bool = ..., ) -> None: ... def doRollover(self) -> None: ... if sys.version_info >= (3,): class TimedRotatingFileHandler(BaseRotatingHandler): if sys.version_info >= (3, 4): def __init__( self, filename: StrPath, when: str = ..., interval: int = ..., backupCount: int = ..., encoding: Optional[str] = ..., delay: bool = ..., utc: bool = ..., atTime: Optional[datetime.datetime] = ..., ) -> None: ... else: def __init__( self, filename: str, when: str = ..., interval: int = ..., backupCount: int = ..., encoding: Optional[str] = ..., delay: bool = ..., utc: bool = ..., ) -> None: ... def doRollover(self) -> None: ... else: class TimedRotatingFileHandler(Handler): def __init__( self, filename: str, when: str = ..., interval: int = ..., backupCount: int = ..., encoding: Optional[str] = ..., delay: bool = ..., utc: bool = ..., ) -> None: ... def doRollover(self) -> None: ... class SocketHandler(Handler): retryStart: float retryFactor: float retryMax: float if sys.version_info >= (3, 4): def __init__(self, host: str, port: Optional[int]) -> None: ... else: def __init__(self, host: str, port: int) -> None: ... def makeSocket(self, timeout: float = ...) -> SocketType: ... # timeout is undocumented def makePickle(self, record: LogRecord) -> bytes: ... def send(self, s: bytes) -> None: ... def createSocket(self) -> None: ... class DatagramHandler(SocketHandler): def makeSocket(self) -> SocketType: ... # type: ignore class SysLogHandler(Handler): LOG_EMERG: int LOG_ALERT: int LOG_CRIT: int LOG_ERR: int LOG_WARNING: int LOG_NOTICE: int LOG_INFO: int LOG_DEBUG: int LOG_KERN: int LOG_USER: int LOG_MAIL: int LOG_DAEMON: int LOG_AUTH: int LOG_SYSLOG: int LOG_LPR: int LOG_NEWS: int LOG_UUCP: int LOG_CRON: int LOG_AUTHPRIV: int LOG_FTP: int if sys.version_info >= (3, 9): LOG_NTP: int LOG_SECURITY: int LOG_CONSOLE: int LOG_SOLCRON: int LOG_LOCAL0: int LOG_LOCAL1: int LOG_LOCAL2: int LOG_LOCAL3: int LOG_LOCAL4: int LOG_LOCAL5: int LOG_LOCAL6: int LOG_LOCAL7: int unixsocket: bool # undocumented socktype: SocketKind # undocumented if sys.version_info >= (3,): ident: str # undocumented facility: int # undocumented priority_names: ClassVar[Dict[str, int]] # undocumented facility_names: ClassVar[Dict[str, int]] # undocumented priority_map: ClassVar[Dict[str, str]] # undocumented def __init__( self, address: Union[Tuple[str, int], str] = ..., facility: int = ..., socktype: Optional[SocketKind] = ... ) -> None: ... def encodePriority(self, facility: Union[int, str], priority: Union[int, str]) -> int: ... def mapPriority(self, levelName: str) -> str: ... class NTEventLogHandler(Handler): def __init__(self, appname: str, dllname: Optional[str] = ..., logtype: str = ...) -> None: ... def getEventCategory(self, record: LogRecord) -> int: ... # TODO correct return value? def getEventType(self, record: LogRecord) -> int: ... def getMessageID(self, record: LogRecord) -> int: ... class SMTPHandler(Handler): # TODO `secure` can also be an empty tuple if sys.version_info >= (3,): def __init__( self, mailhost: Union[str, Tuple[str, int]], fromaddr: str, toaddrs: List[str], subject: str, credentials: Optional[Tuple[str, str]] = ..., secure: Union[Tuple[str], Tuple[str, str], None] = ..., timeout: float = ..., ) -> None: ... else: def __init__( self, mailhost: Union[str, Tuple[str, int]], fromaddr: str, toaddrs: List[str], subject: str, credentials: Optional[Tuple[str, str]] = ..., secure: Union[Tuple[str], Tuple[str, str], None] = ..., ) -> None: ... def getSubject(self, record: LogRecord) -> str: ... class BufferingHandler(Handler): buffer: List[LogRecord] def __init__(self, capacity: int) -> None: ... def shouldFlush(self, record: LogRecord) -> bool: ... class MemoryHandler(BufferingHandler): if sys.version_info >= (3, 6): def __init__( self, capacity: int, flushLevel: int = ..., target: Optional[Handler] = ..., flushOnClose: bool = ... ) -> None: ... else: def __init__(self, capacity: int, flushLevel: int = ..., target: Optional[Handler] = ...) -> None: ... def setTarget(self, target: Handler) -> None: ... class HTTPHandler(Handler): if sys.version_info >= (3, 5): def __init__( self, host: str, url: str, method: str = ..., secure: bool = ..., credentials: Optional[Tuple[str, str]] = ..., context: Optional[ssl.SSLContext] = ..., ) -> None: ... elif sys.version_info >= (3,): def __init__( self, host: str, url: str, method: str = ..., secure: bool = ..., credentials: Optional[Tuple[str, str]] = ... ) -> None: ... else: def __init__(self, host: str, url: str, method: str = ...) -> None: ... def mapLogRecord(self, record: LogRecord) -> Dict[str, Any]: ... if sys.version_info >= (3,): class QueueHandler(Handler): if sys.version_info >= (3, 7): def __init__(self, queue: Union[SimpleQueue[Any], Queue[Any]]) -> None: ... else: def __init__(self, queue: Queue[Any]) -> None: ... def prepare(self, record: LogRecord) -> Any: ... def enqueue(self, record: LogRecord) -> None: ... class QueueListener: if sys.version_info >= (3, 7): def __init__( self, queue: Union[SimpleQueue[Any], Queue[Any]], *handlers: Handler, respect_handler_level: bool = ... ) -> None: ... elif sys.version_info >= (3, 5): def __init__(self, queue: Queue[Any], *handlers: Handler, respect_handler_level: bool = ...) -> None: ... else: def __init__(self, queue: Queue, *handlers: Handler) -> None: ... def dequeue(self, block: bool) -> LogRecord: ... def prepare(self, record: LogRecord) -> Any: ... def start(self) -> None: ... def stop(self) -> None: ... def enqueue_sentinel(self) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/macpath.pyi0000664000175000017500000001232200000000000024021 0ustar00davedave00000000000000import os import sys from _typeshed import AnyPath, BytesPath, StrPath from typing import Any, AnyStr, Callable, List, Optional, Sequence, Text, Tuple, TypeVar, Union, overload if sys.version_info < (3, 8): _T = TypeVar("_T") if sys.version_info >= (3, 6): from builtins import _PathLike # ----- os.path variables ----- supports_unicode_filenames: bool # aliases (also in os) curdir: str pardir: str sep: str altsep: Optional[str] extsep: str pathsep: str defpath: str devnull: str # ----- os.path function stubs ----- if sys.version_info >= (3, 6): # Overloads are necessary to work around python/mypy#3644. @overload def abspath(path: _PathLike[AnyStr]) -> AnyStr: ... @overload def abspath(path: AnyStr) -> AnyStr: ... @overload def basename(s: _PathLike[AnyStr]) -> AnyStr: ... @overload def basename(s: AnyStr) -> AnyStr: ... @overload def dirname(s: _PathLike[AnyStr]) -> AnyStr: ... @overload def dirname(s: AnyStr) -> AnyStr: ... @overload def expanduser(path: _PathLike[AnyStr]) -> AnyStr: ... @overload def expanduser(path: AnyStr) -> AnyStr: ... @overload def expandvars(path: _PathLike[AnyStr]) -> AnyStr: ... @overload def expandvars(path: AnyStr) -> AnyStr: ... @overload def normcase(path: _PathLike[AnyStr]) -> AnyStr: ... @overload def normcase(path: AnyStr) -> AnyStr: ... @overload def normpath(s: _PathLike[AnyStr]) -> AnyStr: ... @overload def normpath(s: AnyStr) -> AnyStr: ... @overload def realpath(path: _PathLike[AnyStr]) -> AnyStr: ... @overload def realpath(path: AnyStr) -> AnyStr: ... else: def abspath(path: AnyStr) -> AnyStr: ... def basename(s: AnyStr) -> AnyStr: ... def dirname(s: AnyStr) -> AnyStr: ... def expanduser(path: AnyStr) -> AnyStr: ... def expandvars(path: AnyStr) -> AnyStr: ... def normcase(path: AnyStr) -> AnyStr: ... def normpath(s: AnyStr) -> AnyStr: ... def realpath(path: AnyStr) -> AnyStr: ... # NOTE: Empty lists results in '' (str) regardless of contained type. # Also, in Python 2 mixed sequences of Text and bytes results in either Text or bytes # So, fall back to Any def commonprefix(m: Sequence[AnyPath]) -> Any: ... if sys.version_info >= (3, 3): def exists(path: Union[AnyPath, int]) -> bool: ... else: def exists(path: AnyPath) -> bool: ... def lexists(path: AnyPath) -> bool: ... # These return float if os.stat_float_times() == True, # but int is a subclass of float. def getatime(filename: AnyPath) -> float: ... def getmtime(filename: AnyPath) -> float: ... def getctime(filename: AnyPath) -> float: ... def getsize(filename: AnyPath) -> int: ... def isabs(s: AnyPath) -> bool: ... def isfile(path: AnyPath) -> bool: ... def isdir(s: AnyPath) -> bool: ... def islink(s: AnyPath) -> bool: ... def ismount(s: AnyPath) -> bool: ... if sys.version_info < (3, 0): # Make sure signatures are disjunct, and allow combinations of bytes and unicode. # (Since Python 2 allows that, too) # Note that e.g. os.path.join("a", "b", "c", "d", u"e") will still result in # a type error. @overload def join(__p1: bytes, *p: bytes) -> bytes: ... @overload def join(__p1: bytes, __p2: bytes, __p3: bytes, __p4: Text, *p: AnyPath) -> Text: ... @overload def join(__p1: bytes, __p2: bytes, __p3: Text, *p: AnyPath) -> Text: ... @overload def join(__p1: bytes, __p2: Text, *p: AnyPath) -> Text: ... @overload def join(__p1: Text, *p: AnyPath) -> Text: ... elif sys.version_info >= (3, 6): # Mypy complains that the signatures overlap, but things seem to behave correctly anyway. @overload def join(s: StrPath, *paths: StrPath) -> Text: ... @overload def join(s: BytesPath, *paths: BytesPath) -> bytes: ... else: def join(s: AnyStr, *paths: AnyStr) -> AnyStr: ... def samefile(f1: AnyPath, f2: AnyPath) -> bool: ... def sameopenfile(fp1: int, fp2: int) -> bool: ... def samestat(s1: os.stat_result, s2: os.stat_result) -> bool: ... if sys.version_info >= (3, 6): @overload def split(s: _PathLike[AnyStr]) -> Tuple[AnyStr, AnyStr]: ... @overload def split(s: AnyStr) -> Tuple[AnyStr, AnyStr]: ... @overload def splitdrive(p: _PathLike[AnyStr]) -> Tuple[AnyStr, AnyStr]: ... @overload def splitdrive(p: AnyStr) -> Tuple[AnyStr, AnyStr]: ... @overload def splitext(p: _PathLike[AnyStr]) -> Tuple[AnyStr, AnyStr]: ... @overload def splitext(p: AnyStr) -> Tuple[AnyStr, AnyStr]: ... else: def split(s: AnyStr) -> Tuple[AnyStr, AnyStr]: ... def splitdrive(p: AnyStr) -> Tuple[AnyStr, AnyStr]: ... def splitext(p: AnyStr) -> Tuple[AnyStr, AnyStr]: ... if sys.version_info < (3,): def walk(path: AnyStr, visit: Callable[[_T, AnyStr, List[AnyStr]], Any], arg: _T) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/mailbox.pyi0000664000175000017500000001760700000000000024052 0ustar00davedave00000000000000import email.message import sys from _typeshed import AnyPath from types import TracebackType from typing import ( IO, Any, AnyStr, Callable, Dict, Generic, Iterable, Iterator, List, Mapping, Optional, Protocol, Sequence, Text, Tuple, Type, TypeVar, Union, overload, ) from typing_extensions import Literal if sys.version_info >= (3, 9): from types import GenericAlias _T = TypeVar("_T") _MessageType = TypeVar("_MessageType", bound=Message) _MessageData = Union[email.message.Message, bytes, str, IO[str], IO[bytes]] class _HasIteritems(Protocol): def iteritems(self) -> Iterator[Tuple[str, _MessageData]]: ... class _HasItems(Protocol): def items(self) -> Iterator[Tuple[str, _MessageData]]: ... linesep: bytes class Mailbox(Generic[_MessageType]): _path: Union[bytes, str] # undocumented _factory: Optional[Callable[[IO[Any]], _MessageType]] # undocumented def __init__(self, path: AnyPath, factory: Optional[Callable[[IO[Any]], _MessageType]] = ..., create: bool = ...) -> None: ... def add(self, message: _MessageData) -> str: ... def remove(self, key: str) -> None: ... def __delitem__(self, key: str) -> None: ... def discard(self, key: str) -> None: ... def __setitem__(self, key: str, message: _MessageData) -> None: ... @overload def get(self, key: str, default: None = ...) -> Optional[_MessageType]: ... @overload def get(self, key: str, default: _T) -> Union[_MessageType, _T]: ... def __getitem__(self, key: str) -> _MessageType: ... def get_message(self, key: str) -> _MessageType: ... def get_string(self, key: str) -> str: ... def get_bytes(self, key: str) -> bytes: ... # As '_ProxyFile' doesn't implement the full IO spec, and BytesIO is incompatible with it, get_file return is Any here def get_file(self, key: str) -> Any: ... def iterkeys(self) -> Iterator[str]: ... def keys(self) -> List[str]: ... def itervalues(self) -> Iterator[_MessageType]: ... def __iter__(self) -> Iterator[_MessageType]: ... def values(self) -> List[_MessageType]: ... def iteritems(self) -> Iterator[Tuple[str, _MessageType]]: ... def items(self) -> List[Tuple[str, _MessageType]]: ... def __contains__(self, key: str) -> bool: ... def __len__(self) -> int: ... def clear(self) -> None: ... @overload def pop(self, key: str, default: None = ...) -> Optional[_MessageType]: ... @overload def pop(self, key: str, default: _T = ...) -> Union[_MessageType, _T]: ... def popitem(self) -> Tuple[str, _MessageType]: ... def update(self, arg: Optional[Union[_HasIteritems, _HasItems, Iterable[Tuple[str, _MessageData]]]] = ...) -> None: ... def flush(self) -> None: ... def lock(self) -> None: ... def unlock(self) -> None: ... def close(self) -> None: ... if sys.version_info >= (3, 9): def __class_getitem__(cls, item: Any) -> GenericAlias: ... class Maildir(Mailbox[MaildirMessage]): colon: str def __init__( self, dirname: AnyPath, factory: Optional[Callable[[IO[Any]], MaildirMessage]] = ..., create: bool = ... ) -> None: ... def get_file(self, key: str) -> _ProxyFile[bytes]: ... def list_folders(self) -> List[str]: ... def get_folder(self, folder: Text) -> Maildir: ... def add_folder(self, folder: Text) -> Maildir: ... def remove_folder(self, folder: Text) -> None: ... def clean(self) -> None: ... def next(self) -> Optional[str]: ... class _singlefileMailbox(Mailbox[_MessageType]): ... class _mboxMMDF(_singlefileMailbox[_MessageType]): def get_file(self, key: str) -> _PartialFile[bytes]: ... class mbox(_mboxMMDF[mboxMessage]): def __init__( self, dirname: AnyPath, factory: Optional[Callable[[IO[Any]], mboxMessage]] = ..., create: bool = ... ) -> None: ... class MMDF(_mboxMMDF[MMDFMessage]): def __init__( self, dirname: AnyPath, factory: Optional[Callable[[IO[Any]], MMDFMessage]] = ..., create: bool = ... ) -> None: ... class MH(Mailbox[MHMessage]): def __init__(self, dirname: AnyPath, factory: Optional[Callable[[IO[Any]], MHMessage]] = ..., create: bool = ...) -> None: ... def get_file(self, key: str) -> _ProxyFile[bytes]: ... def list_folders(self) -> List[str]: ... def get_folder(self, folder: AnyPath) -> MH: ... def add_folder(self, folder: AnyPath) -> MH: ... def remove_folder(self, folder: AnyPath) -> None: ... def get_sequences(self) -> Dict[str, List[int]]: ... def set_sequences(self, sequences: Mapping[str, Sequence[int]]) -> None: ... def pack(self) -> None: ... class Babyl(_singlefileMailbox[BabylMessage]): def __init__( self, dirname: AnyPath, factory: Optional[Callable[[IO[Any]], BabylMessage]] = ..., create: bool = ... ) -> None: ... def get_file(self, key: str) -> IO[bytes]: ... def get_labels(self) -> List[str]: ... class Message(email.message.Message): def __init__(self, message: Optional[_MessageData] = ...) -> None: ... class MaildirMessage(Message): def get_subdir(self) -> str: ... def set_subdir(self, subdir: Literal["new", "cur"]) -> None: ... def get_flags(self) -> str: ... def set_flags(self, flags: Iterable[str]) -> None: ... def add_flag(self, flag: str) -> None: ... def remove_flag(self, flag: str) -> None: ... def get_date(self) -> int: ... def set_date(self, date: float) -> None: ... def get_info(self) -> str: ... def set_info(self, info: str) -> None: ... class _mboxMMDFMessage(Message): def get_from(self) -> str: ... def set_from( self, from_: str, time_: Optional[Union[bool, Tuple[int, int, int, int, int, int, int, int, int]]] = ... ) -> None: ... def get_flags(self) -> str: ... def set_flags(self, flags: Iterable[str]) -> None: ... def add_flag(self, flag: str) -> None: ... def remove_flag(self, flag: str) -> None: ... class mboxMessage(_mboxMMDFMessage): ... class MHMessage(Message): def get_sequences(self) -> List[str]: ... def set_sequences(self, sequences: Iterable[str]) -> None: ... def add_sequence(self, sequence: str) -> None: ... def remove_sequence(self, sequence: str) -> None: ... class BabylMessage(Message): def get_labels(self) -> List[str]: ... def set_labels(self, labels: Iterable[str]) -> None: ... def add_label(self, label: str) -> None: ... def remove_label(self, label: str) -> None: ... def get_visible(self) -> Message: ... def set_visible(self, visible: _MessageData) -> None: ... def update_visible(self) -> None: ... class MMDFMessage(_mboxMMDFMessage): ... class _ProxyFile(Generic[AnyStr]): def __init__(self, f: IO[AnyStr], pos: Optional[int] = ...) -> None: ... def read(self, size: Optional[int] = ...) -> AnyStr: ... def read1(self, size: Optional[int] = ...) -> AnyStr: ... def readline(self, size: Optional[int] = ...) -> AnyStr: ... def readlines(self, sizehint: Optional[int] = ...) -> List[AnyStr]: ... def __iter__(self) -> Iterator[AnyStr]: ... def tell(self) -> int: ... def seek(self, offset: int, whence: int = ...) -> None: ... def close(self) -> None: ... def __enter__(self) -> _ProxyFile[AnyStr]: ... def __exit__( self, exc_type: Optional[Type[BaseException]], exc: Optional[BaseException], tb: Optional[TracebackType] ) -> None: ... def readable(self) -> bool: ... def writable(self) -> bool: ... def seekable(self) -> bool: ... def flush(self) -> None: ... @property def closed(self) -> bool: ... if sys.version_info >= (3, 9): def __class_getitem__(cls, item: Any) -> GenericAlias: ... class _PartialFile(_ProxyFile[AnyStr]): def __init__(self, f: IO[AnyStr], start: Optional[int] = ..., stop: Optional[int] = ...) -> None: ... class Error(Exception): ... class NoSuchMailboxError(Error): ... class NotEmptyError(Error): ... class ExternalClashError(Error): ... class FormatError(Error): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/mailcap.pyi0000664000175000017500000000051200000000000024010 0ustar00davedave00000000000000from typing import Dict, List, Mapping, Optional, Sequence, Tuple, Union _Cap = Dict[str, Union[str, int]] def findmatch( caps: Mapping[str, List[_Cap]], MIMEtype: str, key: str = ..., filename: str = ..., plist: Sequence[str] = ... ) -> Tuple[Optional[str], Optional[_Cap]]: ... def getcaps() -> Dict[str, List[_Cap]]: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/marshal.pyi0000664000175000017500000000037500000000000024040 0ustar00davedave00000000000000from typing import IO, Any version: int def dump(__value: Any, __file: IO[Any], __version: int = ...) -> None: ... def load(__file: IO[Any]) -> Any: ... def dumps(__value: Any, __version: int = ...) -> bytes: ... def loads(__bytes: bytes) -> Any: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/math.pyi0000664000175000017500000000737300000000000023347 0ustar00davedave00000000000000import sys from typing import Iterable, Optional, SupportsFloat, SupportsInt, Tuple, overload e: float pi: float if sys.version_info >= (3, 5): inf: float nan: float if sys.version_info >= (3, 6): tau: float def acos(__x: SupportsFloat) -> float: ... def acosh(__x: SupportsFloat) -> float: ... def asin(__x: SupportsFloat) -> float: ... def asinh(__x: SupportsFloat) -> float: ... def atan(__x: SupportsFloat) -> float: ... def atan2(__y: SupportsFloat, __x: SupportsFloat) -> float: ... def atanh(__x: SupportsFloat) -> float: ... if sys.version_info >= (3,): def ceil(__x: SupportsFloat) -> int: ... else: def ceil(__x: SupportsFloat) -> float: ... if sys.version_info >= (3, 8): def comb(__n: int, __k: int) -> int: ... def copysign(__x: SupportsFloat, __y: SupportsFloat) -> float: ... def cos(__x: SupportsFloat) -> float: ... def cosh(__x: SupportsFloat) -> float: ... def degrees(__x: SupportsFloat) -> float: ... if sys.version_info >= (3, 8): def dist(__p: Iterable[SupportsFloat], __q: Iterable[SupportsFloat]) -> float: ... def erf(__x: SupportsFloat) -> float: ... def erfc(__x: SupportsFloat) -> float: ... def exp(__x: SupportsFloat) -> float: ... def expm1(__x: SupportsFloat) -> float: ... def fabs(__x: SupportsFloat) -> float: ... def factorial(__x: SupportsInt) -> int: ... if sys.version_info >= (3,): def floor(__x: SupportsFloat) -> int: ... else: def floor(__x: SupportsFloat) -> float: ... def fmod(__x: SupportsFloat, __y: SupportsFloat) -> float: ... def frexp(__x: SupportsFloat) -> Tuple[float, int]: ... def fsum(__seq: Iterable[float]) -> float: ... def gamma(__x: SupportsFloat) -> float: ... if sys.version_info >= (3, 9): def gcd(*integers: int) -> int: ... elif sys.version_info >= (3, 5): def gcd(__x: int, __y: int) -> int: ... if sys.version_info >= (3, 8): def hypot(*coordinates: SupportsFloat) -> float: ... else: def hypot(__x: SupportsFloat, __y: SupportsFloat) -> float: ... if sys.version_info >= (3, 5): def isclose(a: SupportsFloat, b: SupportsFloat, *, rel_tol: SupportsFloat = ..., abs_tol: SupportsFloat = ...) -> bool: ... def isinf(__x: SupportsFloat) -> bool: ... if sys.version_info >= (3,): def isfinite(__x: SupportsFloat) -> bool: ... def isnan(__x: SupportsFloat) -> bool: ... if sys.version_info >= (3, 8): def isqrt(__n: int) -> int: ... if sys.version_info >= (3, 9): def lcm(*integers: int) -> int: ... def ldexp(__x: SupportsFloat, __i: int) -> float: ... def lgamma(__x: SupportsFloat) -> float: ... def log(x: SupportsFloat, base: SupportsFloat = ...) -> float: ... def log10(__x: SupportsFloat) -> float: ... def log1p(__x: SupportsFloat) -> float: ... if sys.version_info >= (3, 3): def log2(__x: SupportsFloat) -> float: ... def modf(__x: SupportsFloat) -> Tuple[float, float]: ... if sys.version_info >= (3, 9): def nextafter(__x: SupportsFloat, __y: SupportsFloat) -> float: ... if sys.version_info >= (3, 8): def perm(__n: int, __k: Optional[int] = ...) -> int: ... def pow(__x: SupportsFloat, __y: SupportsFloat) -> float: ... if sys.version_info >= (3, 8): @overload def prod(__iterable: Iterable[int], *, start: int = ...) -> int: ... # type: ignore @overload def prod(__iterable: Iterable[SupportsFloat], *, start: SupportsFloat = ...) -> float: ... def radians(__x: SupportsFloat) -> float: ... if sys.version_info >= (3, 7): def remainder(__x: SupportsFloat, __y: SupportsFloat) -> float: ... def sin(__x: SupportsFloat) -> float: ... def sinh(__x: SupportsFloat) -> float: ... def sqrt(__x: SupportsFloat) -> float: ... def tan(__x: SupportsFloat) -> float: ... def tanh(__x: SupportsFloat) -> float: ... def trunc(__x: SupportsFloat) -> int: ... if sys.version_info >= (3, 9): def ulp(__x: SupportsFloat) -> float: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/mimetypes.pyi0000664000175000017500000000315100000000000024420 0ustar00davedave00000000000000import sys from typing import IO, Dict, List, Optional, Sequence, Text, Tuple, Union if sys.version_info >= (3, 8): from os import PathLike def guess_type(url: Union[Text, PathLike[str]], strict: bool = ...) -> Tuple[Optional[str], Optional[str]]: ... else: def guess_type(url: Text, strict: bool = ...) -> Tuple[Optional[str], Optional[str]]: ... def guess_all_extensions(type: str, strict: bool = ...) -> List[str]: ... def guess_extension(type: str, strict: bool = ...) -> Optional[str]: ... def init(files: Optional[Sequence[str]] = ...) -> None: ... def read_mime_types(filename: str) -> Optional[Dict[str, str]]: ... def add_type(type: str, ext: str, strict: bool = ...) -> None: ... inited: bool knownfiles: List[str] suffix_map: Dict[str, str] encodings_map: Dict[str, str] types_map: Dict[str, str] common_types: Dict[str, str] class MimeTypes: suffix_map: Dict[str, str] encodings_map: Dict[str, str] types_map: Tuple[Dict[str, str], Dict[str, str]] types_map_inv: Tuple[Dict[str, str], Dict[str, str]] def __init__(self, filenames: Tuple[str, ...] = ..., strict: bool = ...) -> None: ... def guess_extension(self, type: str, strict: bool = ...) -> Optional[str]: ... def guess_type(self, url: str, strict: bool = ...) -> Tuple[Optional[str], Optional[str]]: ... def guess_all_extensions(self, type: str, strict: bool = ...) -> List[str]: ... def read(self, filename: str, strict: bool = ...) -> None: ... def readfp(self, fp: IO[str], strict: bool = ...) -> None: ... if sys.platform == "win32": def read_windows_registry(self, strict: bool = ...) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/mmap.pyi0000664000175000017500000000764600000000000023353 0ustar00davedave00000000000000import sys from _typeshed import ReadableBuffer from typing import AnyStr, ContextManager, Generic, Iterable, Iterator, Optional, Sequence, Sized, Union, overload ACCESS_DEFAULT: int ACCESS_READ: int ACCESS_WRITE: int ACCESS_COPY: int ALLOCATIONGRANULARITY: int if sys.platform != "win32": MAP_ANON: int MAP_ANONYMOUS: int MAP_DENYWRITE: int MAP_EXECUTABLE: int MAP_PRIVATE: int MAP_SHARED: int PROT_EXEC: int PROT_READ: int PROT_WRITE: int PAGESIZE: int class _mmap(Generic[AnyStr]): if sys.platform == "win32": def __init__( self, fileno: int, length: int, tagname: Optional[str] = ..., access: int = ..., offset: int = ... ) -> None: ... else: def __init__( self, fileno: int, length: int, flags: int = ..., prot: int = ..., access: int = ..., offset: int = ... ) -> None: ... def close(self) -> None: ... if sys.version_info >= (3, 8): def flush(self, offset: int = ..., size: int = ...) -> None: ... else: def flush(self, offset: int = ..., size: int = ...) -> int: ... def move(self, dest: int, src: int, count: int) -> None: ... def read_byte(self) -> AnyStr: ... def readline(self) -> AnyStr: ... def resize(self, newsize: int) -> None: ... def seek(self, pos: int, whence: int = ...) -> None: ... def size(self) -> int: ... def tell(self) -> int: ... def write_byte(self, byte: AnyStr) -> None: ... def __len__(self) -> int: ... if sys.version_info >= (3,): class mmap(_mmap[bytes], ContextManager[mmap], Iterable[bytes], Sized): closed: bool if sys.version_info >= (3, 8) and sys.platform != "win32": def madvise(self, option: int, start: int = ..., length: int = ...) -> None: ... def find(self, sub: ReadableBuffer, start: int = ..., stop: int = ...) -> int: ... def rfind(self, sub: ReadableBuffer, start: int = ..., stop: int = ...) -> int: ... def read(self, n: Optional[int] = ...) -> bytes: ... if sys.version_info >= (3, 6): def write(self, bytes: ReadableBuffer) -> int: ... else: def write(self, bytes: ReadableBuffer) -> None: ... @overload def __getitem__(self, index: int) -> int: ... @overload def __getitem__(self, index: slice) -> bytes: ... def __delitem__(self, index: Union[int, slice]) -> None: ... @overload def __setitem__(self, index: int, object: int) -> None: ... @overload def __setitem__(self, index: slice, object: bytes) -> None: ... # Doesn't actually exist, but the object is actually iterable because it has __getitem__ and # __len__, so we claim that there is also an __iter__ to help type checkers. def __iter__(self) -> Iterator[bytes]: ... else: class mmap(_mmap[bytes], Sequence[bytes]): def find(self, string: bytes, start: int = ..., end: int = ...) -> int: ... def rfind(self, string: bytes, start: int = ..., stop: int = ...) -> int: ... def read(self, num: int) -> bytes: ... def write(self, string: bytes) -> None: ... def __getitem__(self, index: Union[int, slice]) -> bytes: ... def __getslice__(self, i: Optional[int], j: Optional[int]) -> bytes: ... def __delitem__(self, index: Union[int, slice]) -> None: ... def __setitem__(self, index: Union[int, slice], object: bytes) -> None: ... if sys.version_info >= (3, 8): MADV_NORMAL: int MADV_RANDOM: int MADV_SEQUENTIAL: int MADV_WILLNEED: int MADV_DONTNEED: int MADV_REMOVE: int MADV_DONTFORK: int MADV_DOFORK: int MADV_HWPOISON: int MADV_MERGEABLE: int MADV_UNMERGEABLE: int MADV_SOFT_OFFLINE: int MADV_HUGEPAGE: int MADV_NOHUGEPAGE: int MADV_DONTDUMP: int MADV_DODUMP: int MADV_FREE: int MADV_NOSYNC: int MADV_AUTOSYNC: int MADV_NOCORE: int MADV_CORE: int MADV_PROTECT: int ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/modulefinder.pyi0000664000175000017500000000713200000000000025064 0ustar00davedave00000000000000import sys from types import CodeType from typing import IO, Any, Container, Dict, Iterable, Iterator, List, Optional, Sequence, Tuple LOAD_CONST: int # undocumented IMPORT_NAME: int # undocumented STORE_NAME: int # undocumented STORE_GLOBAL: int # undocumented STORE_OPS: Tuple[int, int] # undocumented EXTENDED_ARG: int # undocumented packagePathMap: Dict[str, List[str]] # undocumented def AddPackagePath(packagename: str, path: str) -> None: ... replacePackageMap: Dict[str, str] # undocumented def ReplacePackage(oldname: str, newname: str) -> None: ... class Module: # undocumented def __init__(self, name: str, file: Optional[str] = ..., path: Optional[str] = ...) -> None: ... def __repr__(self) -> str: ... class ModuleFinder: modules: Dict[str, Module] path: List[str] # undocumented badmodules: Dict[str, Dict[str, int]] # undocumented debug: int # undocumented indent: int # undocumented excludes: Container[str] # undocumented replace_paths: Sequence[Tuple[str, str]] # undocumented if sys.version_info >= (3, 8): def __init__( self, path: Optional[List[str]] = ..., debug: int = ..., excludes: Optional[Container[str]] = ..., replace_paths: Optional[Sequence[Tuple[str, str]]] = ..., ) -> None: ... else: def __init__( self, path: Optional[List[str]] = ..., debug: int = ..., excludes: Container[str] = ..., replace_paths: Sequence[Tuple[str, str]] = ..., ) -> None: ... def msg(self, level: int, str: str, *args: Any) -> None: ... # undocumented def msgin(self, *args: Any) -> None: ... # undocumented def msgout(self, *args: Any) -> None: ... # undocumented def run_script(self, pathname: str) -> None: ... def load_file(self, pathname: str) -> None: ... # undocumented def import_hook( self, name: str, caller: Optional[Module] = ..., fromlist: Optional[List[str]] = ..., level: int = ... ) -> Optional[Module]: ... # undocumented def determine_parent(self, caller: Optional[Module], level: int = ...) -> Optional[Module]: ... # undocumented def find_head_package(self, parent: Module, name: str) -> Tuple[Module, str]: ... # undocumented def load_tail(self, q: Module, tail: str) -> Module: ... # undocumented def ensure_fromlist(self, m: Module, fromlist: Iterable[str], recursive: int = ...) -> None: ... # undocumented def find_all_submodules(self, m: Module) -> Iterable[str]: ... # undocumented def import_module(self, partname: str, fqname: str, parent: Module) -> Optional[Module]: ... # undocumented def load_module(self, fqname: str, fp: IO[str], pathname: str, file_info: Tuple[str, str, str]) -> Module: ... # undocumented if sys.version_info >= (3, 6): def scan_opcodes(self, co: CodeType) -> Iterator[Tuple[str, Tuple[Any, ...]]]: ... # undocumented def scan_code(self, co: CodeType, m: Module) -> None: ... # undocumented def load_package(self, fqname: str, pathname: str) -> Module: ... # undocumented def add_module(self, fqname: str) -> Module: ... # undocumented def find_module( self, name: str, path: Optional[str], parent: Optional[Module] = ... ) -> Tuple[Optional[IO[Any]], Optional[str], Tuple[str, str, int]]: ... # undocumented def report(self) -> None: ... def any_missing(self) -> List[str]: ... # undocumented def any_missing_maybe(self) -> Tuple[List[str], List[str]]: ... # undocumented def replace_paths_in_code(self, co: CodeType) -> CodeType: ... # undocumented ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4223793 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/msilib/0000775000175000017500000000000000000000000023140 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/msilib/__init__.pyi0000664000175000017500000001424200000000000025425 0ustar00davedave00000000000000import sys from types import ModuleType from typing import Any, Container, Dict, Iterable, List, Optional, Sequence, Set, Tuple, Type, Union from typing_extensions import Literal if sys.platform == "win32": from _msi import _Database AMD64: bool if sys.version_info < (3, 7): Itanium: bool Win64: bool datasizemask: Literal[0x00FF] type_valid: Literal[0x0100] type_localizable: Literal[0x0200] typemask: Literal[0x0C00] type_long: Literal[0x0000] type_short: Literal[0x0400] type_string: Literal[0x0C00] type_binary: Literal[0x0800] type_nullable: Literal[0x1000] type_key: Literal[0x2000] knownbits: Literal[0x3FFF] class Table: name: str fields: List[Tuple[int, str, int]] def __init__(self, name: str) -> None: ... def add_field(self, index: int, name: str, type: int) -> None: ... def sql(self) -> str: ... def create(self, db: _Database) -> None: ... class _Unspecified: ... def change_sequence( seq: Sequence[Tuple[str, Optional[str], int]], action: str, seqno: Union[int, Type[_Unspecified]] = ..., cond: Union[str, Type[_Unspecified]] = ..., ) -> None: ... def add_data(db: _Database, table: str, values: Iterable[Tuple[Any, ...]]) -> None: ... def add_stream(db: _Database, name: str, path: str) -> None: ... def init_database( name: str, schema: ModuleType, ProductName: str, ProductCode: str, ProductVersion: str, Manufacturer: str ) -> _Database: ... def add_tables(db: _Database, module: ModuleType) -> None: ... def make_id(str: str) -> str: ... def gen_uuid() -> str: ... class CAB: name: str files: List[Tuple[str, str]] filenames: Set[str] index: int def __init__(self, name: str) -> None: ... def gen_id(self, file: str) -> str: ... def append(self, full: str, file: str, logical: str) -> Tuple[int, str]: ... def commit(self, db: _Database) -> None: ... _directories: Set[str] class Directory: db: _Database cab: CAB basedir: str physical: str logical: str component: Optional[str] short_names: Set[str] ids: Set[str] keyfiles: Dict[str, str] componentflags: Optional[int] absolute: str def __init__( self, db: _Database, cab: CAB, basedir: str, physical: str, _logical: str, default: str, componentflags: Optional[int] = ..., ) -> None: ... def start_component( self, component: Optional[str] = ..., feature: Optional[Feature] = ..., flags: Optional[int] = ..., keyfile: Optional[str] = ..., uuid: Optional[str] = ..., ) -> None: ... def make_short(self, file: str) -> str: ... def add_file( self, file: str, src: Optional[str] = ..., version: Optional[str] = ..., language: Optional[str] = ... ) -> str: ... def glob(self, pattern: str, exclude: Optional[Container[str]] = ...) -> List[str]: ... def remove_pyc(self) -> None: ... class Binary: name: str def __init__(self, fname: str) -> None: ... def __repr__(self) -> str: ... class Feature: id: str def __init__( self, db: _Database, id: str, title: str, desc: str, display: int, level: int = ..., parent: Optional[Feature] = ..., directory: Optional[str] = ..., attributes: int = ..., ) -> None: ... def set_current(self) -> None: ... class Control: dlg: Dialog name: str def __init__(self, dlg: Dialog, name: str) -> None: ... def event(self, event: str, argument: str, condition: str = ..., ordering: Optional[int] = ...) -> None: ... def mapping(self, event: str, attribute: str) -> None: ... def condition(self, action: str, condition: str) -> None: ... class RadioButtonGroup(Control): property: str index: int def __init__(self, dlg: Dialog, name: str, property: str) -> None: ... def add(self, name: str, x: int, y: int, w: int, h: int, text: str, value: Optional[str] = ...) -> None: ... class Dialog: db: _Database name: str x: int y: int w: int h: int def __init__( self, db: _Database, name: str, x: int, y: int, w: int, h: int, attr: int, title: str, first: str, default: str, cancel: str, ) -> None: ... def control( self, name: str, type: str, x: int, y: int, w: int, h: int, attr: int, prop: Optional[str], text: Optional[str], next: Optional[str], help: Optional[str], ) -> Control: ... def text(self, name: str, x: int, y: int, w: int, h: int, attr: int, text: Optional[str]) -> Control: ... def bitmap(self, name: str, x: int, y: int, w: int, h: int, text: Optional[str]) -> Control: ... def line(self, name: str, x: int, y: int, w: int, h: int) -> Control: ... def pushbutton( self, name: str, x: int, y: int, w: int, h: int, attr: int, text: Optional[str], next: Optional[str] ) -> Control: ... def radiogroup( self, name: str, x: int, y: int, w: int, h: int, attr: int, prop: Optional[str], text: Optional[str], next: Optional[str], ) -> RadioButtonGroup: ... def checkbox( self, name: str, x: int, y: int, w: int, h: int, attr: int, prop: Optional[str], text: Optional[str], next: Optional[str], ) -> Control: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/msilib/schema.pyi0000664000175000017500000000424600000000000025131 0ustar00davedave00000000000000import sys from typing import List, Optional, Tuple if sys.platform == "win32": from . import Table _Validation: Table ActionText: Table AdminExecuteSequence: Table Condition: Table AdminUISequence: Table AdvtExecuteSequence: Table AdvtUISequence: Table AppId: Table AppSearch: Table Property: Table BBControl: Table Billboard: Table Feature: Table Binary: Table BindImage: Table File: Table CCPSearch: Table CheckBox: Table Class: Table Component: Table Icon: Table ProgId: Table ComboBox: Table CompLocator: Table Complus: Table Directory: Table Control: Table Dialog: Table ControlCondition: Table ControlEvent: Table CreateFolder: Table CustomAction: Table DrLocator: Table DuplicateFile: Table Environment: Table Error: Table EventMapping: Table Extension: Table MIME: Table FeatureComponents: Table FileSFPCatalog: Table SFPCatalog: Table Font: Table IniFile: Table IniLocator: Table InstallExecuteSequence: Table InstallUISequence: Table IsolatedComponent: Table LaunchCondition: Table ListBox: Table ListView: Table LockPermissions: Table Media: Table MoveFile: Table MsiAssembly: Table MsiAssemblyName: Table MsiDigitalCertificate: Table MsiDigitalSignature: Table MsiFileHash: Table MsiPatchHeaders: Table ODBCAttribute: Table ODBCDriver: Table ODBCDataSource: Table ODBCSourceAttribute: Table ODBCTranslator: Table Patch: Table PatchPackage: Table PublishComponent: Table RadioButton: Table Registry: Table RegLocator: Table RemoveFile: Table RemoveIniFile: Table RemoveRegistry: Table ReserveCost: Table SelfReg: Table ServiceControl: Table ServiceInstall: Table Shortcut: Table Signature: Table TextStyle: Table TypeLib: Table UIText: Table Upgrade: Table Verb: Table tables: List[Table] _Validation_records: List[ Tuple[str, str, str, Optional[int], Optional[int], Optional[str], Optional[int], Optional[str], Optional[str], str] ] ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/msilib/sequence.pyi0000664000175000017500000000054400000000000025476 0ustar00davedave00000000000000import sys from typing import List, Optional, Tuple if sys.platform == "win32": _SequenceType = List[Tuple[str, Optional[str], int]] AdminExecuteSequence: _SequenceType AdminUISequence: _SequenceType AdvtExecuteSequence: _SequenceType InstallExecuteSequence: _SequenceType InstallUISequence: _SequenceType tables: List[str] ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/msilib/text.pyi0000664000175000017500000000031200000000000024643 0ustar00davedave00000000000000import sys from typing import List, Optional, Tuple if sys.platform == "win32": ActionText: List[Tuple[str, str, Optional[str]]] UIText: List[Tuple[str, Optional[str]]] tables: List[str] ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/msvcrt.pyi0000664000175000017500000000143300000000000023723 0ustar00davedave00000000000000import sys from typing import Text # This module is only available on Windows if sys.platform == "win32": LK_LOCK: int LK_NBLCK: int LK_NBRLCK: int LK_RLCK: int LK_UNLCK: int def locking(__fd: int, __mode: int, __nbytes: int) -> None: ... def setmode(__fd: int, __mode: int) -> int: ... def open_osfhandle(__handle: int, __flags: int) -> int: ... def get_osfhandle(__fd: int) -> int: ... def kbhit() -> bool: ... def getch() -> bytes: ... def getwch() -> Text: ... def getche() -> bytes: ... def getwche() -> Text: ... def putch(__char: bytes) -> None: ... def putwch(__unicode_char: Text) -> None: ... def ungetch(__char: bytes) -> None: ... def ungetwch(__unicode_char: Text) -> None: ... def heapmin() -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/netrc.pyi0000664000175000017500000000067400000000000023526 0ustar00davedave00000000000000from typing import Dict, List, Optional, Tuple class NetrcParseError(Exception): filename: Optional[str] lineno: Optional[int] msg: str # (login, account, password) tuple _NetrcTuple = Tuple[str, Optional[str], Optional[str]] class netrc: hosts: Dict[str, _NetrcTuple] macros: Dict[str, List[str]] def __init__(self, file: str = ...) -> None: ... def authenticators(self, host: str) -> Optional[_NetrcTuple]: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/nis.pyi0000664000175000017500000000050200000000000023172 0ustar00davedave00000000000000import sys from typing import Dict, List if sys.platform != "win32": def cat(map: str, domain: str = ...) -> Dict[str, str]: ... def get_default_domain() -> str: ... def maps(domain: str = ...) -> List[str]: ... def match(key: str, map: str, domain: str = ...) -> str: ... class error(Exception): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/numbers.pyi0000664000175000017500000001035700000000000024065 0ustar00davedave00000000000000# Note: these stubs are incomplete. The more complex type # signatures are currently omitted. import sys from abc import ABCMeta, abstractmethod from typing import Any, Optional, SupportsFloat, overload class Number(metaclass=ABCMeta): @abstractmethod def __hash__(self) -> int: ... class Complex(Number): @abstractmethod def __complex__(self) -> complex: ... if sys.version_info >= (3, 0): def __bool__(self) -> bool: ... else: def __nonzero__(self) -> bool: ... @property @abstractmethod def real(self) -> Any: ... @property @abstractmethod def imag(self) -> Any: ... @abstractmethod def __add__(self, other: Any) -> Any: ... @abstractmethod def __radd__(self, other: Any) -> Any: ... @abstractmethod def __neg__(self) -> Any: ... @abstractmethod def __pos__(self) -> Any: ... def __sub__(self, other: Any) -> Any: ... def __rsub__(self, other: Any) -> Any: ... @abstractmethod def __mul__(self, other: Any) -> Any: ... @abstractmethod def __rmul__(self, other: Any) -> Any: ... if sys.version_info < (3, 0): @abstractmethod def __div__(self, other): ... @abstractmethod def __rdiv__(self, other): ... @abstractmethod def __truediv__(self, other: Any) -> Any: ... @abstractmethod def __rtruediv__(self, other: Any) -> Any: ... @abstractmethod def __pow__(self, exponent: Any) -> Any: ... @abstractmethod def __rpow__(self, base: Any) -> Any: ... def __abs__(self) -> Real: ... def conjugate(self) -> Any: ... def __eq__(self, other: Any) -> bool: ... if sys.version_info < (3, 0): def __ne__(self, other: Any) -> bool: ... class Real(Complex, SupportsFloat): @abstractmethod def __float__(self) -> float: ... @abstractmethod def __trunc__(self) -> int: ... if sys.version_info >= (3, 0): @abstractmethod def __floor__(self) -> int: ... @abstractmethod def __ceil__(self) -> int: ... @abstractmethod @overload def __round__(self, ndigits: None = ...) -> int: ... @abstractmethod @overload def __round__(self, ndigits: int) -> Any: ... def __divmod__(self, other: Any) -> Any: ... def __rdivmod__(self, other: Any) -> Any: ... @abstractmethod def __floordiv__(self, other: Any) -> int: ... @abstractmethod def __rfloordiv__(self, other: Any) -> int: ... @abstractmethod def __mod__(self, other: Any) -> Any: ... @abstractmethod def __rmod__(self, other: Any) -> Any: ... @abstractmethod def __lt__(self, other: Any) -> bool: ... @abstractmethod def __le__(self, other: Any) -> bool: ... def __complex__(self) -> complex: ... @property def real(self) -> Any: ... @property def imag(self) -> Any: ... def conjugate(self) -> Any: ... class Rational(Real): @property @abstractmethod def numerator(self) -> int: ... @property @abstractmethod def denominator(self) -> int: ... def __float__(self) -> float: ... class Integral(Rational): if sys.version_info >= (3, 0): @abstractmethod def __int__(self) -> int: ... else: @abstractmethod def __long__(self) -> long: ... def __index__(self) -> int: ... @abstractmethod def __pow__(self, exponent: Any, modulus: Optional[Any] = ...) -> Any: ... @abstractmethod def __lshift__(self, other: Any) -> Any: ... @abstractmethod def __rlshift__(self, other: Any) -> Any: ... @abstractmethod def __rshift__(self, other: Any) -> Any: ... @abstractmethod def __rrshift__(self, other: Any) -> Any: ... @abstractmethod def __and__(self, other: Any) -> Any: ... @abstractmethod def __rand__(self, other: Any) -> Any: ... @abstractmethod def __xor__(self, other: Any) -> Any: ... @abstractmethod def __rxor__(self, other: Any) -> Any: ... @abstractmethod def __or__(self, other: Any) -> Any: ... @abstractmethod def __ror__(self, other: Any) -> Any: ... @abstractmethod def __invert__(self) -> Any: ... def __float__(self) -> float: ... @property def numerator(self) -> int: ... @property def denominator(self) -> int: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/opcode.pyi0000664000175000017500000000114100000000000023652 0ustar00davedave00000000000000import sys from typing import Dict, List, Optional, Sequence cmp_op: Sequence[str] hasconst: List[int] hasname: List[int] hasjrel: List[int] hasjabs: List[int] haslocal: List[int] hascompare: List[int] hasfree: List[int] opname: List[str] opmap: Dict[str, int] HAVE_ARGUMENT: int EXTENDED_ARG: int if sys.version_info >= (3, 8): def stack_effect(__opcode: int, __oparg: Optional[int] = ..., *, jump: Optional[bool] = ...) -> int: ... elif sys.version_info >= (3, 4): def stack_effect(__opcode: int, __oparg: Optional[int] = ...) -> int: ... if sys.version_info >= (3, 6): hasnargs: List[int] ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/operator.pyi0000664000175000017500000001575200000000000024251 0ustar00davedave00000000000000import sys from typing import ( Any, Callable, Container, Mapping, MutableMapping, MutableSequence, Sequence, SupportsAbs, Tuple, TypeVar, overload, ) _T = TypeVar("_T") _K = TypeVar("_K") _V = TypeVar("_V") def lt(__a: Any, __b: Any) -> Any: ... def le(__a: Any, __b: Any) -> Any: ... def eq(__a: Any, __b: Any) -> Any: ... def ne(__a: Any, __b: Any) -> Any: ... def ge(__a: Any, __b: Any) -> Any: ... def gt(__a: Any, __b: Any) -> Any: ... def __lt__(a: Any, b: Any) -> Any: ... def __le__(a: Any, b: Any) -> Any: ... def __eq__(a: Any, b: Any) -> Any: ... def __ne__(a: Any, b: Any) -> Any: ... def __ge__(a: Any, b: Any) -> Any: ... def __gt__(a: Any, b: Any) -> Any: ... def not_(__a: Any) -> bool: ... def __not__(a: Any) -> bool: ... def truth(__a: Any) -> bool: ... def is_(__a: Any, __b: Any) -> bool: ... def is_not(__a: Any, __b: Any) -> bool: ... def abs(__a: SupportsAbs[_T]) -> _T: ... def __abs__(a: SupportsAbs[_T]) -> _T: ... def add(__a: Any, __b: Any) -> Any: ... def __add__(a: Any, b: Any) -> Any: ... def and_(__a: Any, __b: Any) -> Any: ... def __and__(a: Any, b: Any) -> Any: ... if sys.version_info < (3,): def div(a: Any, b: Any) -> Any: ... def __div__(a: Any, b: Any) -> Any: ... def floordiv(__a: Any, __b: Any) -> Any: ... def __floordiv__(a: Any, b: Any) -> Any: ... def index(__a: Any) -> int: ... def __index__(a: Any) -> int: ... def inv(__a: Any) -> Any: ... def invert(__a: Any) -> Any: ... def __inv__(a: Any) -> Any: ... def __invert__(a: Any) -> Any: ... def lshift(__a: Any, __b: Any) -> Any: ... def __lshift__(a: Any, b: Any) -> Any: ... def mod(__a: Any, __b: Any) -> Any: ... def __mod__(a: Any, b: Any) -> Any: ... def mul(__a: Any, __b: Any) -> Any: ... def __mul__(a: Any, b: Any) -> Any: ... if sys.version_info >= (3, 5): def matmul(__a: Any, __b: Any) -> Any: ... def __matmul__(a: Any, b: Any) -> Any: ... def neg(__a: Any) -> Any: ... def __neg__(a: Any) -> Any: ... def or_(__a: Any, __b: Any) -> Any: ... def __or__(a: Any, b: Any) -> Any: ... def pos(__a: Any) -> Any: ... def __pos__(a: Any) -> Any: ... def pow(__a: Any, __b: Any) -> Any: ... def __pow__(a: Any, b: Any) -> Any: ... def rshift(__a: Any, __b: Any) -> Any: ... def __rshift__(a: Any, b: Any) -> Any: ... def sub(__a: Any, __b: Any) -> Any: ... def __sub__(a: Any, b: Any) -> Any: ... def truediv(__a: Any, __b: Any) -> Any: ... def __truediv__(a: Any, b: Any) -> Any: ... def xor(__a: Any, __b: Any) -> Any: ... def __xor__(a: Any, b: Any) -> Any: ... def concat(__a: Sequence[_T], __b: Sequence[_T]) -> Sequence[_T]: ... def __concat__(a: Sequence[_T], b: Sequence[_T]) -> Sequence[_T]: ... def contains(__a: Container[Any], __b: Any) -> bool: ... def __contains__(a: Container[Any], b: Any) -> bool: ... def countOf(__a: Container[Any], __b: Any) -> int: ... @overload def delitem(__a: MutableSequence[_T], __b: int) -> None: ... @overload def delitem(__a: MutableSequence[_T], __b: slice) -> None: ... @overload def delitem(__a: MutableMapping[_K, _V], __b: _K) -> None: ... @overload def __delitem__(a: MutableSequence[_T], b: int) -> None: ... @overload def __delitem__(a: MutableSequence[_T], b: slice) -> None: ... @overload def __delitem__(a: MutableMapping[_K, _V], b: _K) -> None: ... if sys.version_info < (3,): def delslice(a: MutableSequence[Any], b: int, c: int) -> None: ... def __delslice__(a: MutableSequence[Any], b: int, c: int) -> None: ... @overload def getitem(__a: Sequence[_T], __b: int) -> _T: ... @overload def getitem(__a: Sequence[_T], __b: slice) -> Sequence[_T]: ... @overload def getitem(__a: Mapping[_K, _V], __b: _K) -> _V: ... @overload def __getitem__(a: Sequence[_T], b: int) -> _T: ... @overload def __getitem__(a: Sequence[_T], b: slice) -> Sequence[_T]: ... @overload def __getitem__(a: Mapping[_K, _V], b: _K) -> _V: ... if sys.version_info < (3,): def getslice(a: Sequence[_T], b: int, c: int) -> Sequence[_T]: ... def __getslice__(a: Sequence[_T], b: int, c: int) -> Sequence[_T]: ... def indexOf(__a: Sequence[_T], __b: _T) -> int: ... if sys.version_info < (3,): def repeat(a: Any, b: int) -> Any: ... def __repeat__(a: Any, b: int) -> Any: ... if sys.version_info < (3,): def sequenceIncludes(a: Container[Any], b: Any) -> bool: ... @overload def setitem(__a: MutableSequence[_T], __b: int, __c: _T) -> None: ... @overload def setitem(__a: MutableSequence[_T], __b: slice, __c: Sequence[_T]) -> None: ... @overload def setitem(__a: MutableMapping[_K, _V], __b: _K, __c: _V) -> None: ... @overload def __setitem__(a: MutableSequence[_T], b: int, c: _T) -> None: ... @overload def __setitem__(a: MutableSequence[_T], b: slice, c: Sequence[_T]) -> None: ... @overload def __setitem__(a: MutableMapping[_K, _V], b: _K, c: _V) -> None: ... if sys.version_info < (3,): def setslice(a: MutableSequence[_T], b: int, c: int, v: Sequence[_T]) -> None: ... def __setslice__(a: MutableSequence[_T], b: int, c: int, v: Sequence[_T]) -> None: ... if sys.version_info >= (3, 4): def length_hint(__obj: Any, __default: int = ...) -> int: ... @overload def attrgetter(attr: str) -> Callable[[Any], Any]: ... @overload def attrgetter(*attrs: str) -> Callable[[Any], Tuple[Any, ...]]: ... @overload def itemgetter(item: Any) -> Callable[[Any], Any]: ... @overload def itemgetter(*items: Any) -> Callable[[Any], Tuple[Any, ...]]: ... def methodcaller(__name: str, *args: Any, **kwargs: Any) -> Callable[..., Any]: ... def iadd(__a: Any, __b: Any) -> Any: ... def __iadd__(a: Any, b: Any) -> Any: ... def iand(__a: Any, __b: Any) -> Any: ... def __iand__(a: Any, b: Any) -> Any: ... def iconcat(__a: Any, __b: Any) -> Any: ... def __iconcat__(a: Any, b: Any) -> Any: ... if sys.version_info < (3,): def idiv(a: Any, b: Any) -> Any: ... def __idiv__(a: Any, b: Any) -> Any: ... def ifloordiv(__a: Any, __b: Any) -> Any: ... def __ifloordiv__(a: Any, b: Any) -> Any: ... def ilshift(__a: Any, __b: Any) -> Any: ... def __ilshift__(a: Any, b: Any) -> Any: ... def imod(__a: Any, __b: Any) -> Any: ... def __imod__(a: Any, b: Any) -> Any: ... def imul(__a: Any, __b: Any) -> Any: ... def __imul__(a: Any, b: Any) -> Any: ... if sys.version_info >= (3, 5): def imatmul(__a: Any, __b: Any) -> Any: ... def __imatmul__(a: Any, b: Any) -> Any: ... def ior(__a: Any, __b: Any) -> Any: ... def __ior__(a: Any, b: Any) -> Any: ... def ipow(__a: Any, __b: Any) -> Any: ... def __ipow__(a: Any, b: Any) -> Any: ... if sys.version_info < (3,): def irepeat(a: Any, b: int) -> Any: ... def __irepeat__(a: Any, b: int) -> Any: ... def irshift(__a: Any, __b: Any) -> Any: ... def __irshift__(a: Any, b: Any) -> Any: ... def isub(__a: Any, __b: Any) -> Any: ... def __isub__(a: Any, b: Any) -> Any: ... def itruediv(__a: Any, __b: Any) -> Any: ... def __itruediv__(a: Any, b: Any) -> Any: ... def ixor(__a: Any, __b: Any) -> Any: ... def __ixor__(a: Any, b: Any) -> Any: ... if sys.version_info < (3,): def isCallable(x: Any) -> bool: ... def isMappingType(x: Any) -> bool: ... def isNumberType(x: Any) -> bool: ... def isSequenceType(x: Any) -> bool: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/optparse.pyi0000664000175000017500000002356000000000000024247 0ustar00davedave00000000000000import sys from typing import IO, Any, AnyStr, Callable, Dict, Iterable, List, Mapping, Optional, Sequence, Tuple, Type, Union, overload # See https://groups.google.com/forum/#!topic/python-ideas/gA1gdj3RZ5g if sys.version_info >= (3,): _Text = str else: _Text = Union[str, unicode] NO_DEFAULT: Tuple[_Text, ...] SUPPRESS_HELP: _Text SUPPRESS_USAGE: _Text def check_builtin(option: Option, opt: Any, value: _Text) -> Any: ... def check_choice(option: Option, opt: Any, value: _Text) -> Any: ... if sys.version_info < (3,): def isbasestring(x: Any) -> bool: ... class OptParseError(Exception): msg: _Text def __init__(self, msg: _Text) -> None: ... class BadOptionError(OptParseError): opt_str: _Text def __init__(self, opt_str: _Text) -> None: ... class AmbiguousOptionError(BadOptionError): possibilities: Iterable[_Text] def __init__(self, opt_str: _Text, possibilities: Sequence[_Text]) -> None: ... class OptionError(OptParseError): msg: _Text option_id: _Text def __init__(self, msg: _Text, option: Option) -> None: ... class OptionConflictError(OptionError): ... class OptionValueError(OptParseError): ... class HelpFormatter: NO_DEFAULT_VALUE: _Text _long_opt_fmt: _Text _short_opt_fmt: _Text current_indent: int default_tag: _Text help_position: Any help_width: Any indent_increment: int level: int max_help_position: int option_strings: Dict[Option, _Text] parser: OptionParser short_first: Any width: int def __init__(self, indent_increment: int, max_help_position: int, width: Optional[int], short_first: int) -> None: ... def _format__Text(self, _Text: _Text) -> _Text: ... def dedent(self) -> None: ... def expand_default(self, option: Option) -> _Text: ... def format_description(self, description: _Text) -> _Text: ... def format_epilog(self, epilog: _Text) -> _Text: ... def format_heading(self, heading: Any) -> _Text: ... def format_option(self, option: OptionParser) -> _Text: ... def format_option_strings(self, option: OptionParser) -> Any: ... def format_usage(self, usage: Any) -> _Text: ... def indent(self) -> None: ... def set_long_opt_delimiter(self, delim: _Text) -> None: ... def set_parser(self, parser: OptionParser) -> None: ... def set_short_opt_delimiter(self, delim: _Text) -> None: ... def store_option_strings(self, parser: OptionParser) -> None: ... class IndentedHelpFormatter(HelpFormatter): def __init__( self, indent_increment: int = ..., max_help_position: int = ..., width: Optional[int] = ..., short_first: int = ... ) -> None: ... def format_heading(self, heading: _Text) -> _Text: ... def format_usage(self, usage: _Text) -> _Text: ... class TitledHelpFormatter(HelpFormatter): def __init__( self, indent_increment: int = ..., max_help_position: int = ..., width: Optional[int] = ..., short_first: int = ... ) -> None: ... def format_heading(self, heading: _Text) -> _Text: ... def format_usage(self, usage: _Text) -> _Text: ... class Option: ACTIONS: Tuple[_Text, ...] ALWAYS_TYPED_ACTIONS: Tuple[_Text, ...] ATTRS: List[_Text] CHECK_METHODS: Optional[List[Callable[..., Any]]] CONST_ACTIONS: Tuple[_Text, ...] STORE_ACTIONS: Tuple[_Text, ...] TYPED_ACTIONS: Tuple[_Text, ...] TYPES: Tuple[_Text, ...] TYPE_CHECKER: Dict[_Text, Callable[..., Any]] _long_opts: List[_Text] _short_opts: List[_Text] action: _Text dest: Optional[_Text] nargs: int type: Any def __init__(self, *opts: Optional[_Text], **attrs: Any) -> None: ... def _check_action(self) -> None: ... def _check_callback(self) -> None: ... def _check_choice(self) -> None: ... def _check_const(self) -> None: ... def _check_dest(self) -> None: ... def _check_nargs(self) -> None: ... def _check_opt_strings(self, opts: Iterable[Optional[_Text]]) -> List[_Text]: ... def _check_type(self) -> None: ... def _set_attrs(self, attrs: Dict[_Text, Any]) -> None: ... def _set_opt_strings(self, opts: Iterable[_Text]) -> None: ... def check_value(self, opt: Any, value: Any) -> Any: ... def convert_value(self, opt: Any, value: Any) -> Any: ... def get_opt_string(self) -> _Text: ... def process(self, opt: Any, value: Any, values: Any, parser: OptionParser) -> int: ... def take_action(self, action: _Text, dest: _Text, opt: Any, value: Any, values: Any, parser: OptionParser) -> int: ... def takes_value(self) -> bool: ... make_option = Option class OptionContainer: _long_opt: Dict[_Text, Option] _short_opt: Dict[_Text, Option] conflict_handler: _Text defaults: Dict[_Text, Any] description: Any option_class: Type[Option] def __init__(self, option_class: Type[Option], conflict_handler: Any, description: Any) -> None: ... def _check_conflict(self, option: Any) -> None: ... def _create_option_mappings(self) -> None: ... def _share_option_mappings(self, parser: OptionParser) -> None: ... @overload def add_option(self, opt: Option) -> Option: ... @overload def add_option(self, *args: Optional[_Text], **kwargs: Any) -> Any: ... def add_options(self, option_list: Iterable[Option]) -> None: ... def destroy(self) -> None: ... def format_description(self, formatter: Optional[HelpFormatter]) -> Any: ... def format_help(self, formatter: Optional[HelpFormatter]) -> _Text: ... def format_option_help(self, formatter: Optional[HelpFormatter]) -> _Text: ... def get_description(self) -> Any: ... def get_option(self, opt_str: _Text) -> Optional[Option]: ... def has_option(self, opt_str: _Text) -> bool: ... def remove_option(self, opt_str: _Text) -> None: ... def set_conflict_handler(self, handler: Any) -> None: ... def set_description(self, description: Any) -> None: ... class OptionGroup(OptionContainer): option_list: List[Option] parser: OptionParser title: _Text def __init__(self, parser: OptionParser, title: _Text, description: Optional[_Text] = ...) -> None: ... def _create_option_list(self) -> None: ... def set_title(self, title: _Text) -> None: ... class Values: def __init__(self, defaults: Optional[Mapping[str, Any]] = ...) -> None: ... def _update(self, dict: Mapping[_Text, Any], mode: Any) -> None: ... def _update_careful(self, dict: Mapping[_Text, Any]) -> None: ... def _update_loose(self, dict: Mapping[_Text, Any]) -> None: ... def ensure_value(self, attr: _Text, value: Any) -> Any: ... def read_file(self, filename: _Text, mode: _Text) -> None: ... def read_module(self, modname: _Text, mode: _Text) -> None: ... def __getattr__(self, name: str) -> Any: ... def __setattr__(self, name: str, value: Any) -> None: ... class OptionParser(OptionContainer): allow_interspersed_args: bool epilog: Optional[_Text] formatter: HelpFormatter largs: Optional[List[_Text]] option_groups: List[OptionParser] option_list: List[Option] process_default_values: Any prog: Optional[_Text] rargs: Optional[List[Any]] standard_option_list: List[Option] usage: Optional[_Text] values: Optional[Values] version: _Text def __init__( self, usage: Optional[_Text] = ..., option_list: Iterable[Option] = ..., option_class: Type[Option] = ..., version: Optional[_Text] = ..., conflict_handler: _Text = ..., description: Optional[_Text] = ..., formatter: Optional[HelpFormatter] = ..., add_help_option: bool = ..., prog: Optional[_Text] = ..., epilog: Optional[_Text] = ..., ) -> None: ... def _add_help_option(self) -> None: ... def _add_version_option(self) -> None: ... def _create_option_list(self) -> None: ... def _get_all_options(self) -> List[Option]: ... def _get_args(self, args: Iterable[Any]) -> List[Any]: ... def _init_parsing_state(self) -> None: ... def _match_long_opt(self, opt: _Text) -> _Text: ... def _populate_option_list(self, option_list: Iterable[Option], add_help: bool = ...) -> None: ... def _process_args(self, largs: List[Any], rargs: List[Any], values: Values) -> None: ... def _process_long_opt(self, rargs: List[Any], values: Any) -> None: ... def _process_short_opts(self, rargs: List[Any], values: Any) -> None: ... @overload def add_option_group(self, __opt_group: OptionGroup) -> OptionParser: ... @overload def add_option_group(self, *args: Any, **kwargs: Any) -> OptionParser: ... def check_values(self, values: Values, args: List[_Text]) -> Tuple[Values, List[_Text]]: ... def disable_interspersed_args(self) -> None: ... def enable_interspersed_args(self) -> None: ... def error(self, msg: _Text) -> None: ... def exit(self, status: int = ..., msg: Optional[str] = ...) -> None: ... def expand_prog_name(self, s: Optional[_Text]) -> Any: ... def format_epilog(self, formatter: HelpFormatter) -> Any: ... def format_help(self, formatter: Optional[HelpFormatter] = ...) -> _Text: ... def format_option_help(self, formatter: Optional[HelpFormatter] = ...) -> _Text: ... def get_default_values(self) -> Values: ... def get_option_group(self, opt_str: _Text) -> Any: ... def get_prog_name(self) -> _Text: ... def get_usage(self) -> _Text: ... def get_version(self) -> _Text: ... def parse_args( self, args: Optional[Sequence[AnyStr]] = ..., values: Optional[Values] = ... ) -> Tuple[Values, List[AnyStr]]: ... def print_usage(self, file: Optional[IO[str]] = ...) -> None: ... def print_help(self, file: Optional[IO[str]] = ...) -> None: ... def print_version(self, file: Optional[IO[str]] = ...) -> None: ... def set_default(self, dest: Any, value: Any) -> None: ... def set_defaults(self, **kwargs: Any) -> None: ... def set_process_default_values(self, process: Any) -> None: ... def set_usage(self, usage: _Text) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/parser.pyi0000664000175000017500000000170600000000000023704 0ustar00davedave00000000000000from _typeshed import AnyPath from types import CodeType from typing import Any, List, Sequence, Text, Tuple def expr(source: Text) -> STType: ... def suite(source: Text) -> STType: ... def sequence2st(sequence: Sequence[Any]) -> STType: ... def tuple2st(sequence: Sequence[Any]) -> STType: ... def st2list(st: STType, line_info: bool = ..., col_info: bool = ...) -> List[Any]: ... def st2tuple(st: STType, line_info: bool = ..., col_info: bool = ...) -> Tuple[Any]: ... def compilest(st: STType, filename: AnyPath = ...) -> CodeType: ... def isexpr(st: STType) -> bool: ... def issuite(st: STType) -> bool: ... class ParserError(Exception): ... class STType: def compile(self, filename: AnyPath = ...) -> CodeType: ... def isexpr(self) -> bool: ... def issuite(self) -> bool: ... def tolist(self, line_info: bool = ..., col_info: bool = ...) -> List[Any]: ... def totuple(self, line_info: bool = ..., col_info: bool = ...) -> Tuple[Any]: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/pdb.pyi0000664000175000017500000002412500000000000023155 0ustar00davedave00000000000000import signal import sys from bdb import Bdb from cmd import Cmd from inspect import _SourceObjectType from types import CodeType, FrameType, TracebackType from typing import IO, Any, Callable, ClassVar, Dict, Iterable, List, Mapping, Optional, Sequence, Tuple, TypeVar, Union _T = TypeVar("_T") line_prefix: str # undocumented class Restart(Exception): ... def run(statement: str, globals: Optional[Dict[str, Any]] = ..., locals: Optional[Mapping[str, Any]] = ...) -> None: ... def runeval(expression: str, globals: Optional[Dict[str, Any]] = ..., locals: Optional[Mapping[str, Any]] = ...) -> Any: ... def runctx(statement: str, globals: Dict[str, Any], locals: Mapping[str, Any]) -> None: ... def runcall(func: Callable[..., _T], *args: Any, **kwds: Any) -> Optional[_T]: ... if sys.version_info >= (3, 7): def set_trace(*, header: Optional[str] = ...) -> None: ... else: def set_trace() -> None: ... def post_mortem(t: Optional[TracebackType] = ...) -> None: ... def pm() -> None: ... class Pdb(Bdb, Cmd): # Everything here is undocumented, except for __init__ commands_resuming: ClassVar[List[str]] aliases: Dict[str, str] mainpyfile: str _wait_for_mainpyfile: bool rcLines: List[str] commands: Dict[int, List[str]] commands_doprompt: Dict[int, bool] commands_silent: Dict[int, bool] commands_defining: bool commands_bnum: Optional[int] lineno: Optional[int] stack: List[Tuple[FrameType, int]] curindex: int curframe: Optional[FrameType] curframe_locals: Mapping[str, Any] if sys.version_info >= (3, 6): def __init__( self, completekey: str = ..., stdin: Optional[IO[str]] = ..., stdout: Optional[IO[str]] = ..., skip: Optional[Iterable[str]] = ..., nosigint: bool = ..., readrc: bool = ..., ) -> None: ... elif sys.version_info >= (3, 2): def __init__( self, completekey: str = ..., stdin: Optional[IO[str]] = ..., stdout: Optional[IO[str]] = ..., skip: Optional[Iterable[str]] = ..., nosigint: bool = ..., ) -> None: ... else: def __init__( self, completekey: str = ..., stdin: Optional[IO[str]] = ..., stdout: Optional[IO[str]] = ..., skip: Optional[Iterable[str]] = ..., ) -> None: ... def forget(self) -> None: ... def setup(self, f: Optional[FrameType], tb: Optional[TracebackType]) -> None: ... def execRcLines(self) -> None: ... def bp_commands(self, frame: FrameType) -> bool: ... def interaction(self, frame: Optional[FrameType], traceback: Optional[TracebackType]) -> None: ... def displayhook(self, obj: object) -> None: ... def handle_command_def(self, line: str) -> bool: ... def defaultFile(self) -> str: ... def lineinfo(self, identifier: str) -> Union[Tuple[None, None, None], Tuple[str, str, int]]: ... def checkline(self, filename: str, lineno: int) -> int: ... def _getval(self, arg: str) -> object: ... def print_stack_trace(self) -> None: ... def print_stack_entry(self, frame_lineno: Tuple[FrameType, int], prompt_prefix: str = ...) -> None: ... def lookupmodule(self, filename: str) -> Optional[str]: ... def _runscript(self, filename: str) -> None: ... def do_commands(self, arg: str) -> Optional[bool]: ... def do_break(self, arg: str, temporary: bool = ...) -> Optional[bool]: ... def do_tbreak(self, arg: str) -> Optional[bool]: ... def do_enable(self, arg: str) -> Optional[bool]: ... def do_disable(self, arg: str) -> Optional[bool]: ... def do_condition(self, arg: str) -> Optional[bool]: ... def do_ignore(self, arg: str) -> Optional[bool]: ... def do_clear(self, arg: str) -> Optional[bool]: ... def do_where(self, arg: str) -> Optional[bool]: ... def do_up(self, arg: str) -> Optional[bool]: ... def do_down(self, arg: str) -> Optional[bool]: ... def do_until(self, arg: str) -> Optional[bool]: ... def do_step(self, arg: str) -> Optional[bool]: ... def do_next(self, arg: str) -> Optional[bool]: ... def do_run(self, arg: str) -> Optional[bool]: ... def do_return(self, arg: str) -> Optional[bool]: ... def do_continue(self, arg: str) -> Optional[bool]: ... def do_jump(self, arg: str) -> Optional[bool]: ... def do_debug(self, arg: str) -> Optional[bool]: ... def do_quit(self, arg: str) -> Optional[bool]: ... def do_EOF(self, arg: str) -> Optional[bool]: ... def do_args(self, arg: str) -> Optional[bool]: ... def do_retval(self, arg: str) -> Optional[bool]: ... def do_p(self, arg: str) -> Optional[bool]: ... def do_pp(self, arg: str) -> Optional[bool]: ... def do_list(self, arg: str) -> Optional[bool]: ... def do_whatis(self, arg: str) -> Optional[bool]: ... def do_alias(self, arg: str) -> Optional[bool]: ... def do_unalias(self, arg: str) -> Optional[bool]: ... def do_help(self, arg: str) -> Optional[bool]: ... do_b = do_break do_cl = do_clear do_w = do_where do_bt = do_where do_u = do_up do_d = do_down do_unt = do_until do_s = do_step do_n = do_next do_restart = do_run do_r = do_return do_c = do_continue do_cont = do_continue do_j = do_jump do_q = do_quit do_exit = do_quit do_a = do_args do_rv = do_retval do_l = do_list do_h = do_help def help_exec(self) -> None: ... def help_pdb(self) -> None: ... if sys.version_info < (3, 2): def help_help(self) -> None: ... def help_h(self) -> None: ... def help_where(self) -> None: ... def help_w(self) -> None: ... def help_down(self) -> None: ... def help_d(self) -> None: ... def help_up(self) -> None: ... def help_u(self) -> None: ... def help_break(self) -> None: ... def help_b(self) -> None: ... def help_clear(self) -> None: ... def help_cl(self) -> None: ... def help_tbreak(self) -> None: ... def help_enable(self) -> None: ... def help_disable(self) -> None: ... def help_ignore(self) -> None: ... def help_condition(self) -> None: ... def help_step(self) -> None: ... def help_s(self) -> None: ... def help_until(self) -> None: ... def help_unt(self) -> None: ... def help_next(self) -> None: ... def help_n(self) -> None: ... def help_return(self) -> None: ... def help_r(self) -> None: ... def help_continue(self) -> None: ... def help_cont(self) -> None: ... def help_c(self) -> None: ... def help_jump(self) -> None: ... def help_j(self) -> None: ... def help_debug(self) -> None: ... def help_list(self) -> None: ... def help_l(self) -> None: ... def help_args(self) -> None: ... def help_a(self) -> None: ... def help_p(self) -> None: ... def help_pp(self) -> None: ... def help_run(self) -> None: ... def help_quit(self) -> None: ... def help_q(self) -> None: ... def help_whatis(self) -> None: ... def help_EOF(self) -> None: ... def help_alias(self) -> None: ... def help_unalias(self) -> None: ... def help_commands(self) -> None: ... help_bt = help_w help_restart = help_run help_exit = help_q if sys.version_info >= (3, 2): def sigint_handler(self, signum: signal.Signals, frame: FrameType) -> None: ... def message(self, msg: str) -> None: ... def error(self, msg: str) -> None: ... def _select_frame(self, number: int) -> None: ... def _getval_except(self, arg: str, frame: Optional[FrameType] = ...) -> object: ... def _print_lines( self, lines: Sequence[str], start: int, breaks: Sequence[int] = ..., frame: Optional[FrameType] = ... ) -> None: ... def _cmdloop(self) -> None: ... def do_display(self, arg: str) -> Optional[bool]: ... def do_interact(self, arg: str) -> Optional[bool]: ... def do_longlist(self, arg: str) -> Optional[bool]: ... def do_source(self, arg: str) -> Optional[bool]: ... def do_undisplay(self, arg: str) -> Optional[bool]: ... do_ll = do_longlist if sys.version_info >= (3, 3): def _complete_location(self, text: str, line: str, begidx: int, endidx: int) -> List[str]: ... def _complete_bpnumber(self, text: str, line: str, begidx: int, endidx: int) -> List[str]: ... def _complete_expression(self, text: str, line: str, begidx: int, endidx: int) -> List[str]: ... def complete_undisplay(self, text: str, line: str, begidx: int, endidx: int) -> List[str]: ... def complete_unalias(self, text: str, line: str, begidx: int, endidx: int) -> List[str]: ... complete_commands = _complete_bpnumber complete_break = _complete_location complete_b = _complete_location complete_tbreak = _complete_location complete_enable = _complete_bpnumber complete_disable = _complete_bpnumber complete_condition = _complete_bpnumber complete_ignore = _complete_bpnumber complete_clear = _complete_location complete_cl = _complete_location complete_debug = _complete_expression complete_print = _complete_expression complete_p = _complete_expression complete_pp = _complete_expression complete_source = _complete_expression complete_whatis = _complete_expression complete_display = _complete_expression if sys.version_info >= (3, 7): def _runmodule(self, module_name: str) -> None: ... if sys.version_info >= (3,) and sys.version_info < (3, 4): do_print = do_p # undocumented def find_function(funcname: str, filename: str) -> Optional[Tuple[str, str, int]]: ... def main() -> None: ... def help() -> None: ... if sys.version_info >= (3, 2): def getsourcelines(obj: _SourceObjectType) -> Tuple[List[str], int]: ... def lasti2lineno(code: CodeType, lasti: int) -> int: ... class _rstr(str): def __repr__(self) -> _rstr: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/pickle.pyi0000664000175000017500000001231200000000000023652 0ustar00davedave00000000000000import sys from typing import IO, Any, Callable, Iterable, Iterator, Mapping, Optional, Tuple, Type, Union HIGHEST_PROTOCOL: int if sys.version_info >= (3, 0): DEFAULT_PROTOCOL: int bytes_types: Tuple[Type[Any], ...] # undocumented if sys.version_info >= (3, 8): # TODO: holistic design for buffer interface (typing.Buffer?) class PickleBuffer: # buffer must be a buffer-providing object def __init__(self, buffer: Any) -> None: ... def raw(self) -> memoryview: ... def release(self) -> None: ... _BufferCallback = Optional[Callable[[PickleBuffer], Any]] def dump( obj: Any, file: IO[bytes], protocol: Optional[int] = ..., *, fix_imports: bool = ..., buffer_callback: _BufferCallback = ..., ) -> None: ... def dumps( obj: Any, protocol: Optional[int] = ..., *, fix_imports: bool = ..., buffer_callback: _BufferCallback = ... ) -> bytes: ... def load( file: IO[bytes], *, fix_imports: bool = ..., encoding: str = ..., errors: str = ..., buffers: Optional[Iterable[Any]] = ..., ) -> Any: ... def loads( __data: bytes, *, fix_imports: bool = ..., encoding: str = ..., errors: str = ..., buffers: Optional[Iterable[Any]] = ... ) -> Any: ... elif sys.version_info >= (3, 0): def dump(obj: Any, file: IO[bytes], protocol: Optional[int] = ..., *, fix_imports: bool = ...) -> None: ... def dumps(obj: Any, protocol: Optional[int] = ..., *, fix_imports: bool = ...) -> bytes: ... def load(file: IO[bytes], *, fix_imports: bool = ..., encoding: str = ..., errors: str = ...) -> Any: ... def loads(data: bytes, *, fix_imports: bool = ..., encoding: str = ..., errors: str = ...) -> Any: ... else: def dump(obj: Any, file: IO[bytes], protocol: Optional[int] = ...) -> None: ... def dumps(obj: Any, protocol: Optional[int] = ...) -> bytes: ... def load(file: IO[bytes]) -> Any: ... def loads(string: bytes) -> Any: ... class PickleError(Exception): ... class PicklingError(PickleError): ... class UnpicklingError(PickleError): ... _reducedtype = Union[ str, Tuple[Callable[..., Any], Tuple[Any, ...]], Tuple[Callable[..., Any], Tuple[Any, ...], Any], Tuple[Callable[..., Any], Tuple[Any, ...], Any, Optional[Iterator[Any]]], Tuple[Callable[..., Any], Tuple[Any, ...], Any, Optional[Iterator[Any]], Optional[Iterator[Any]]], ] class Pickler: fast: bool if sys.version_info >= (3, 3): dispatch_table: Mapping[type, Callable[[Any], _reducedtype]] if sys.version_info >= (3, 8): def __init__( self, file: IO[bytes], protocol: Optional[int] = ..., *, fix_imports: bool = ..., buffer_callback: _BufferCallback = ..., ) -> None: ... def reducer_override(self, obj: Any) -> Any: ... elif sys.version_info >= (3, 0): def __init__(self, file: IO[bytes], protocol: Optional[int] = ..., *, fix_imports: bool = ...) -> None: ... else: def __init__(self, file: IO[bytes], protocol: Optional[int] = ...) -> None: ... def dump(self, __obj: Any) -> None: ... def clear_memo(self) -> None: ... def persistent_id(self, obj: Any) -> Any: ... class Unpickler: if sys.version_info >= (3, 8): def __init__( self, file: IO[bytes], *, fix_imports: bool = ..., encoding: str = ..., errors: str = ..., buffers: Optional[Iterable[Any]] = ..., ) -> None: ... elif sys.version_info >= (3, 0): def __init__(self, file: IO[bytes], *, fix_imports: bool = ..., encoding: str = ..., errors: str = ...) -> None: ... else: def __init__(self, file: IO[bytes]) -> None: ... def load(self) -> Any: ... def find_class(self, __module_name: str, __global_name: str) -> Any: ... if sys.version_info >= (3, 0): def persistent_load(self, pid: Any) -> Any: ... MARK: bytes STOP: bytes POP: bytes POP_MARK: bytes DUP: bytes FLOAT: bytes INT: bytes BININT: bytes BININT1: bytes LONG: bytes BININT2: bytes NONE: bytes PERSID: bytes BINPERSID: bytes REDUCE: bytes STRING: bytes BINSTRING: bytes SHORT_BINSTRING: bytes UNICODE: bytes BINUNICODE: bytes APPEND: bytes BUILD: bytes GLOBAL: bytes DICT: bytes EMPTY_DICT: bytes APPENDS: bytes GET: bytes BINGET: bytes INST: bytes LONG_BINGET: bytes LIST: bytes EMPTY_LIST: bytes OBJ: bytes PUT: bytes BINPUT: bytes LONG_BINPUT: bytes SETITEM: bytes TUPLE: bytes EMPTY_TUPLE: bytes SETITEMS: bytes BINFLOAT: bytes TRUE: bytes FALSE: bytes # protocol 2 PROTO: bytes NEWOBJ: bytes EXT1: bytes EXT2: bytes EXT4: bytes TUPLE1: bytes TUPLE2: bytes TUPLE3: bytes NEWTRUE: bytes NEWFALSE: bytes LONG1: bytes LONG4: bytes if sys.version_info >= (3, 0): # protocol 3 BINBYTES: bytes SHORT_BINBYTES: bytes if sys.version_info >= (3, 4): # protocol 4 SHORT_BINUNICODE: bytes BINUNICODE8: bytes BINBYTES8: bytes EMPTY_SET: bytes ADDITEMS: bytes FROZENSET: bytes NEWOBJ_EX: bytes STACK_GLOBAL: bytes MEMOIZE: bytes FRAME: bytes def encode_long(x: int) -> bytes: ... # undocumented def decode_long(data: bytes) -> int: ... # undocumented ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/pickletools.pyi0000664000175000017500000001063600000000000024742 0ustar00davedave00000000000000import sys from typing import IO, Any, Callable, Iterator, List, MutableMapping, Optional, Text, Tuple, Type, Union _Reader = Callable[[IO[bytes]], Any] if sys.version_info >= (3, 0): bytes_types: Tuple[Type[Any], ...] UP_TO_NEWLINE: int TAKEN_FROM_ARGUMENT1: int TAKEN_FROM_ARGUMENT4: int if sys.version_info >= (3, 3): TAKEN_FROM_ARGUMENT4U: int if sys.version_info >= (3, 4): TAKEN_FROM_ARGUMENT8U: int class ArgumentDescriptor(object): name: str n: int reader: _Reader doc: str def __init__(self, name: str, n: int, reader: _Reader, doc: str) -> None: ... def read_uint1(f: IO[bytes]) -> int: ... uint1: ArgumentDescriptor def read_uint2(f: IO[bytes]) -> int: ... uint2: ArgumentDescriptor def read_int4(f: IO[bytes]) -> int: ... int4: ArgumentDescriptor if sys.version_info >= (3, 3): def read_uint4(f: IO[bytes]) -> int: ... uint4: ArgumentDescriptor if sys.version_info >= (3, 5): def read_uint8(f: IO[bytes]) -> int: ... uint8: ArgumentDescriptor def read_stringnl(f: IO[bytes], decode: bool = ..., stripquotes: bool = ...) -> Union[bytes, Text]: ... stringnl: ArgumentDescriptor def read_stringnl_noescape(f: IO[bytes]) -> str: ... stringnl_noescape: ArgumentDescriptor def read_stringnl_noescape_pair(f: IO[bytes]) -> Text: ... stringnl_noescape_pair: ArgumentDescriptor def read_string1(f: IO[bytes]) -> str: ... string1: ArgumentDescriptor def read_string4(f: IO[bytes]) -> str: ... string4: ArgumentDescriptor if sys.version_info >= (3, 3): def read_bytes1(f: IO[bytes]) -> bytes: ... bytes1: ArgumentDescriptor def read_bytes4(f: IO[bytes]) -> bytes: ... bytes4: ArgumentDescriptor if sys.version_info >= (3, 4): def read_bytes8(f: IO[bytes]) -> bytes: ... bytes8: ArgumentDescriptor def read_unicodestringnl(f: IO[bytes]) -> Text: ... unicodestringnl: ArgumentDescriptor if sys.version_info >= (3, 4): def read_unicodestring1(f: IO[bytes]) -> Text: ... unicodestring1: ArgumentDescriptor def read_unicodestring4(f: IO[bytes]) -> Text: ... unicodestring4: ArgumentDescriptor if sys.version_info >= (3, 4): def read_unicodestring8(f: IO[bytes]) -> Text: ... unicodestring8: ArgumentDescriptor def read_decimalnl_short(f: IO[bytes]) -> int: ... def read_decimalnl_long(f: IO[bytes]) -> int: ... decimalnl_short: ArgumentDescriptor decimalnl_long: ArgumentDescriptor def read_floatnl(f: IO[bytes]) -> float: ... floatnl: ArgumentDescriptor def read_float8(f: IO[bytes]) -> float: ... float8: ArgumentDescriptor def read_long1(f: IO[bytes]) -> int: ... long1: ArgumentDescriptor def read_long4(f: IO[bytes]) -> int: ... long4: ArgumentDescriptor class StackObject(object): name: str obtype: Union[Type[Any], Tuple[Type[Any], ...]] doc: str def __init__(self, name: str, obtype: Union[Type[Any], Tuple[Type[Any], ...]], doc: str) -> None: ... pyint: StackObject pylong: StackObject pyinteger_or_bool: StackObject pybool: StackObject pyfloat: StackObject if sys.version_info >= (3, 4): pybytes_or_str: StackObject pystring: StackObject if sys.version_info >= (3, 0): pybytes: StackObject pyunicode: StackObject pynone: StackObject pytuple: StackObject pylist: StackObject pydict: StackObject if sys.version_info >= (3, 4): pyset: StackObject pyfrozenset: StackObject anyobject: StackObject markobject: StackObject stackslice: StackObject class OpcodeInfo(object): name: str code: str arg: Optional[ArgumentDescriptor] stack_before: List[StackObject] stack_after: List[StackObject] proto: int doc: str def __init__( self, name: str, code: str, arg: Optional[ArgumentDescriptor], stack_before: List[StackObject], stack_after: List[StackObject], proto: int, doc: str, ) -> None: ... opcodes: List[OpcodeInfo] def genops(pickle: Union[bytes, IO[bytes]]) -> Iterator[Tuple[OpcodeInfo, Optional[Any], Optional[int]]]: ... def optimize(p: Union[bytes, IO[bytes]]) -> bytes: ... if sys.version_info >= (3, 2): def dis( pickle: Union[bytes, IO[bytes]], out: Optional[IO[str]] = ..., memo: Optional[MutableMapping[int, Any]] = ..., indentlevel: int = ..., annotate: int = ..., ) -> None: ... else: def dis( pickle: Union[bytes, IO[bytes]], out: Optional[IO[str]] = ..., memo: Optional[MutableMapping[int, Any]] = ..., indentlevel: int = ..., ) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/pkgutil.pyi0000664000175000017500000000302600000000000024064 0ustar00davedave00000000000000import sys from _typeshed import SupportsRead from typing import IO, Any, Callable, Iterable, Iterator, NamedTuple, Optional, Tuple, Union if sys.version_info >= (3,): from importlib.abc import Loader, MetaPathFinder, PathEntryFinder else: Loader = Any MetaPathFinder = Any PathEntryFinder = Any if sys.version_info >= (3, 6): class ModuleInfo(NamedTuple): module_finder: Union[MetaPathFinder, PathEntryFinder] name: str ispkg: bool _ModuleInfoLike = ModuleInfo else: _ModuleInfoLike = Tuple[Union[MetaPathFinder, PathEntryFinder], str, bool] def extend_path(path: Iterable[str], name: str) -> Iterable[str]: ... class ImpImporter: def __init__(self, dirname: Optional[str] = ...) -> None: ... class ImpLoader: def __init__(self, fullname: str, file: IO[str], filename: str, etc: Tuple[str, str, int]) -> None: ... def find_loader(fullname: str) -> Optional[Loader]: ... def get_importer(path_item: str) -> Optional[PathEntryFinder]: ... def get_loader(module_or_name: str) -> Loader: ... def iter_importers(fullname: str = ...) -> Iterator[Union[MetaPathFinder, PathEntryFinder]]: ... def iter_modules(path: Optional[Iterable[str]] = ..., prefix: str = ...) -> Iterator[_ModuleInfoLike]: ... def read_code(stream: SupportsRead[bytes]) -> Any: ... # undocumented def walk_packages( path: Optional[Iterable[str]] = ..., prefix: str = ..., onerror: Optional[Callable[[str], None]] = ... ) -> Iterator[_ModuleInfoLike]: ... def get_data(package: str, resource: str) -> Optional[bytes]: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/plistlib.pyi0000664000175000017500000000526600000000000024237 0ustar00davedave00000000000000import sys from typing import IO, Any, Dict as DictT, Mapping, MutableMapping, Optional, Text, Type, Union if sys.version_info >= (3,): from enum import Enum class PlistFormat(Enum): FMT_XML: int FMT_BINARY: int FMT_XML = PlistFormat.FMT_XML FMT_BINARY = PlistFormat.FMT_BINARY _Path = Union[str, Text] if sys.version_info >= (3, 9): def load(fp: IO[bytes], *, fmt: Optional[PlistFormat] = ..., dict_type: Type[MutableMapping[str, Any]] = ...) -> Any: ... def loads(value: bytes, *, fmt: Optional[PlistFormat] = ..., dict_type: Type[MutableMapping[str, Any]] = ...) -> Any: ... elif sys.version_info >= (3, 4): def load( fp: IO[bytes], *, fmt: Optional[PlistFormat] = ..., use_builtin_types: bool = ..., dict_type: Type[MutableMapping[str, Any]] = ..., ) -> Any: ... def loads( value: bytes, *, fmt: Optional[PlistFormat] = ..., use_builtin_types: bool = ..., dict_type: Type[MutableMapping[str, Any]] = ..., ) -> Any: ... if sys.version_info >= (3, 4): def dump( value: Mapping[str, Any], fp: IO[bytes], *, fmt: PlistFormat = ..., sort_keys: bool = ..., skipkeys: bool = ... ) -> None: ... def dumps(value: Mapping[str, Any], *, fmt: PlistFormat = ..., skipkeys: bool = ..., sort_keys: bool = ...) -> bytes: ... if sys.version_info < (3, 9): def readPlist(pathOrFile: Union[_Path, IO[bytes]]) -> Any: ... def writePlist(value: Mapping[str, Any], pathOrFile: Union[_Path, IO[bytes]]) -> None: ... def readPlistFromBytes(data: bytes) -> Any: ... def writePlistToBytes(value: Mapping[str, Any]) -> bytes: ... if sys.version_info < (3,): def readPlistFromResource(path: _Path, restype: str = ..., resid: int = ...) -> Any: ... def writePlistToResource(rootObject: Mapping[str, Any], path: _Path, restype: str = ..., resid: int = ...) -> None: ... def readPlistFromString(data: str) -> Any: ... def writePlistToString(rootObject: Mapping[str, Any]) -> str: ... if sys.version_info < (3, 7): class Dict(DictT[str, Any]): def __getattr__(self, attr: str) -> Any: ... def __setattr__(self, attr: str, value: Any) -> None: ... def __delattr__(self, attr: str) -> None: ... if sys.version_info < (3, 9): class Data: data: bytes def __init__(self, data: bytes) -> None: ... if sys.version_info >= (3, 8): class UID: data: int def __init__(self, data: int) -> None: ... def __index__(self) -> int: ... def __reduce__(self) -> Any: ... def __hash__(self) -> int: ... class InvalidFileException(ValueError): def __init__(self, message: str = ...) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/poplib.pyi0000664000175000017500000000470400000000000023676 0ustar00davedave00000000000000import socket import ssl import sys from typing import Any, BinaryIO, Dict, List, Optional, Pattern, Text, Tuple, overload _LongResp = Tuple[bytes, List[bytes], int] class error_proto(Exception): ... POP3_PORT: int POP3_SSL_PORT: int CR: bytes LF: bytes CRLF: bytes class POP3: if sys.version_info >= (3, 0): encoding: Text host: Text port: int sock: socket.socket file: BinaryIO welcome: bytes def __init__(self, host: Text, port: int = ..., timeout: float = ...) -> None: ... def getwelcome(self) -> bytes: ... def set_debuglevel(self, level: int) -> None: ... def user(self, user: Text) -> bytes: ... def pass_(self, pswd: Text) -> bytes: ... def stat(self) -> Tuple[int, int]: ... def list(self, which: Optional[Any] = ...) -> _LongResp: ... def retr(self, which: Any) -> _LongResp: ... def dele(self, which: Any) -> bytes: ... def noop(self) -> bytes: ... def rset(self) -> bytes: ... def quit(self) -> bytes: ... def close(self) -> None: ... def rpop(self, user: Text) -> bytes: ... timestamp: Pattern[Text] if sys.version_info < (3, 0): def apop(self, user: Text, secret: Text) -> bytes: ... else: def apop(self, user: Text, password: Text) -> bytes: ... def top(self, which: Any, howmuch: int) -> _LongResp: ... @overload def uidl(self) -> _LongResp: ... @overload def uidl(self, which: Any) -> bytes: ... if sys.version_info >= (3, 5): def utf8(self) -> bytes: ... if sys.version_info >= (3, 4): def capa(self) -> Dict[Text, List[Text]]: ... def stls(self, context: Optional[ssl.SSLContext] = ...) -> bytes: ... class POP3_SSL(POP3): if sys.version_info >= (3, 0): def __init__( self, host: Text, port: int = ..., keyfile: Optional[Text] = ..., certfile: Optional[Text] = ..., timeout: float = ..., context: Optional[ssl.SSLContext] = ..., ) -> None: ... else: def __init__( self, host: Text, port: int = ..., keyfile: Optional[Text] = ..., certfile: Optional[Text] = ..., timeout: float = ... ) -> None: ... if sys.version_info >= (3, 4): # "context" is actually the last argument, but that breaks LSP and it doesn't really matter because all the arguments are ignored def stls(self, context: Any = ..., keyfile: Any = ..., certfile: Any = ...) -> bytes: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/pprint.pyi0000664000175000017500000000551500000000000023726 0ustar00davedave00000000000000import sys from typing import IO, Any, Dict, Optional, Tuple if sys.version_info >= (3, 8): def pformat( object: object, indent: int = ..., width: int = ..., depth: Optional[int] = ..., *, compact: bool = ..., sort_dicts: bool = ..., ) -> str: ... elif sys.version_info >= (3, 4): def pformat( object: object, indent: int = ..., width: int = ..., depth: Optional[int] = ..., *, compact: bool = ... ) -> str: ... else: def pformat(object: object, indent: int = ..., width: int = ..., depth: Optional[int] = ...) -> str: ... if sys.version_info >= (3, 8): def pp( object: object, stream: Optional[IO[str]] = ..., indent: int = ..., width: int = ..., depth: Optional[int] = ..., *, compact: bool = ..., sort_dicts: bool = ..., ) -> None: ... if sys.version_info >= (3, 8): def pprint( object: object, stream: Optional[IO[str]] = ..., indent: int = ..., width: int = ..., depth: Optional[int] = ..., *, compact: bool = ..., sort_dicts: bool = ..., ) -> None: ... elif sys.version_info >= (3, 4): def pprint( object: object, stream: Optional[IO[str]] = ..., indent: int = ..., width: int = ..., depth: Optional[int] = ..., *, compact: bool = ..., ) -> None: ... else: def pprint( object: object, stream: Optional[IO[str]] = ..., indent: int = ..., width: int = ..., depth: Optional[int] = ... ) -> None: ... def isreadable(object: object) -> bool: ... def isrecursive(object: object) -> bool: ... def saferepr(object: object) -> str: ... class PrettyPrinter: if sys.version_info >= (3, 8): def __init__( self, indent: int = ..., width: int = ..., depth: Optional[int] = ..., stream: Optional[IO[str]] = ..., *, compact: bool = ..., sort_dicts: bool = ..., ) -> None: ... elif sys.version_info >= (3, 4): def __init__( self, indent: int = ..., width: int = ..., depth: Optional[int] = ..., stream: Optional[IO[str]] = ..., *, compact: bool = ..., ) -> None: ... else: def __init__( self, indent: int = ..., width: int = ..., depth: Optional[int] = ..., stream: Optional[IO[str]] = ... ) -> None: ... def pformat(self, object: object) -> str: ... def pprint(self, object: object) -> None: ... def isreadable(self, object: object) -> bool: ... def isrecursive(self, object: object) -> bool: ... def format(self, object: object, context: Dict[int, Any], maxlevels: int, level: int) -> Tuple[str, bool, bool]: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/profile.pyi0000664000175000017500000000225700000000000024052 0ustar00davedave00000000000000from _typeshed import AnyPath from typing import Any, Callable, Dict, Optional, TypeVar, Union def run(statement: str, filename: Optional[str] = ..., sort: Union[str, int] = ...) -> None: ... def runctx( statement: str, globals: Dict[str, Any], locals: Dict[str, Any], filename: Optional[str] = ..., sort: Union[str, int] = ... ) -> None: ... _SelfT = TypeVar("_SelfT", bound=Profile) _T = TypeVar("_T") class Profile: bias: int def __init__(self, timer: Optional[Callable[[], float]] = ..., bias: Optional[int] = ...) -> None: ... def set_cmd(self, cmd: str) -> None: ... def simulate_call(self, name: str) -> None: ... def simulate_cmd_complete(self) -> None: ... def print_stats(self, sort: Union[str, int] = ...) -> None: ... def dump_stats(self, file: AnyPath) -> None: ... def create_stats(self) -> None: ... def snapshot_stats(self) -> None: ... def run(self: _SelfT, cmd: str) -> _SelfT: ... def runctx(self: _SelfT, cmd: str, globals: Dict[str, Any], locals: Dict[str, Any]) -> _SelfT: ... def runcall(self, __func: Callable[..., _T], *args: Any, **kw: Any) -> _T: ... def calibrate(self, m: int, verbose: int = ...) -> float: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/pstats.pyi0000664000175000017500000000424500000000000023727 0ustar00davedave00000000000000import sys from _typeshed import AnyPath from cProfile import Profile as _cProfile from profile import Profile from typing import IO, Any, Dict, Iterable, List, Optional, Text, Tuple, TypeVar, Union, overload _Selector = Union[str, float, int] _T = TypeVar("_T", bound=Stats) if sys.version_info >= (3, 7): from enum import Enum class SortKey(str, Enum): CALLS: str CUMULATIVE: str FILENAME: str LINE: str NAME: str NFL: str PCALLS: str STDNAME: str TIME: str class Stats: sort_arg_dict_default: Dict[str, Tuple[Any, str]] def __init__( self: _T, __arg: Union[None, str, Text, Profile, _cProfile] = ..., *args: Union[None, str, Text, Profile, _cProfile, _T], stream: Optional[IO[Any]] = ..., ) -> None: ... def init(self, arg: Union[None, str, Text, Profile, _cProfile]) -> None: ... def load_stats(self, arg: Union[None, str, Text, Profile, _cProfile]) -> None: ... def get_top_level_stats(self) -> None: ... def add(self: _T, *arg_list: Union[None, str, Text, Profile, _cProfile, _T]) -> _T: ... def dump_stats(self, filename: AnyPath) -> None: ... def get_sort_arg_defs(self) -> Dict[str, Tuple[Tuple[Tuple[int, int], ...], str]]: ... @overload def sort_stats(self: _T, field: int) -> _T: ... @overload def sort_stats(self: _T, *field: str) -> _T: ... def reverse_order(self: _T) -> _T: ... def strip_dirs(self: _T) -> _T: ... def calc_callees(self) -> None: ... def eval_print_amount(self, sel: _Selector, list: List[str], msg: str) -> Tuple[List[str], str]: ... def get_print_list(self, sel_list: Iterable[_Selector]) -> Tuple[int, List[str]]: ... def print_stats(self: _T, *amount: _Selector) -> _T: ... def print_callees(self: _T, *amount: _Selector) -> _T: ... def print_callers(self: _T, *amount: _Selector) -> _T: ... def print_call_heading(self, name_size: int, column_title: str) -> None: ... def print_call_line(self, name_size: int, source: str, call_dict: Dict[str, Any], arrow: str = ...) -> None: ... def print_title(self) -> None: ... def print_line(self, func: str) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/pty.pyi0000664000175000017500000000112000000000000023212 0ustar00davedave00000000000000import sys from typing import Callable, Iterable, Tuple, Union _Reader = Callable[[int], bytes] STDIN_FILENO: int STDOUT_FILENO: int STDERR_FILENO: int CHILD: int def openpty() -> Tuple[int, int]: ... def master_open() -> Tuple[int, str]: ... def slave_open(tty_name: str) -> int: ... def fork() -> Tuple[int, int]: ... if sys.version_info >= (3, 4): def spawn(argv: Union[str, Iterable[str]], master_read: _Reader = ..., stdin_read: _Reader = ...) -> int: ... else: def spawn(argv: Union[str, Iterable[str]], master_read: _Reader = ..., stdin_read: _Reader = ...) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/pwd.pyi0000664000175000017500000000053600000000000023202 0ustar00davedave00000000000000from typing import List, Tuple class struct_passwd(Tuple[str, str, int, int, str, str, str]): pw_name: str pw_passwd: str pw_uid: int pw_gid: int pw_gecos: str pw_dir: str pw_shell: str def getpwall() -> List[struct_passwd]: ... def getpwuid(uid: int) -> struct_passwd: ... def getpwnam(name: str) -> struct_passwd: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/py_compile.pyi0000664000175000017500000000315200000000000024545 0ustar00davedave00000000000000import enum import sys from typing import AnyStr, List, Optional, Text, Type, Union _EitherStr = Union[bytes, Text] class PyCompileError(Exception): exc_type_name: str exc_value: BaseException file: str msg: str def __init__(self, exc_type: Type[BaseException], exc_value: BaseException, file: str, msg: str = ...) -> None: ... if sys.version_info >= (3, 7): class PycInvalidationMode(enum.Enum): TIMESTAMP: int = ... CHECKED_HASH: int = ... UNCHECKED_HASH: int = ... def _get_default_invalidation_mode() -> PycInvalidationMode: ... if sys.version_info >= (3, 8): def compile( file: AnyStr, cfile: Optional[AnyStr] = ..., dfile: Optional[AnyStr] = ..., doraise: bool = ..., optimize: int = ..., invalidation_mode: Optional[PycInvalidationMode] = ..., quiet: int = ..., ) -> Optional[AnyStr]: ... elif sys.version_info >= (3, 7): def compile( file: AnyStr, cfile: Optional[AnyStr] = ..., dfile: Optional[AnyStr] = ..., doraise: bool = ..., optimize: int = ..., invalidation_mode: Optional[PycInvalidationMode] = ..., ) -> Optional[AnyStr]: ... elif sys.version_info >= (3, 2): def compile( file: AnyStr, cfile: Optional[AnyStr] = ..., dfile: Optional[AnyStr] = ..., doraise: bool = ..., optimize: int = ... ) -> Optional[AnyStr]: ... else: def compile( file: _EitherStr, cfile: Optional[_EitherStr] = ..., dfile: Optional[_EitherStr] = ..., doraise: bool = ... ) -> None: ... def main(args: Optional[List[Text]] = ...) -> int: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/pyclbr.pyi0000664000175000017500000000225000000000000023676 0ustar00davedave00000000000000import sys from typing import Dict, List, Optional, Sequence, Union class Class: module: str name: str super: Optional[List[Union[Class, str]]] methods: Dict[str, int] file: int lineno: int if sys.version_info >= (3, 7): def __init__( self, module: str, name: str, super: Optional[List[Union[Class, str]]], file: str, lineno: int, parent: Optional[Class] = ..., ) -> None: ... else: def __init__(self, module: str, name: str, super: Optional[List[Union[Class, str]]], file: str, lineno: int) -> None: ... class Function: module: str name: str file: int lineno: int if sys.version_info >= (3, 7): def __init__(self, module: str, name: str, file: str, lineno: int, parent: Optional[Function] = ...) -> None: ... else: def __init__(self, module: str, name: str, file: str, lineno: int) -> None: ... def readmodule(module: str, path: Optional[Sequence[str]] = ...) -> Dict[str, Class]: ... def readmodule_ex(module: str, path: Optional[Sequence[str]] = ...) -> Dict[str, Union[Class, Function, List[str]]]: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/pydoc.pyi0000664000175000017500000002464400000000000023534 0ustar00davedave00000000000000import sys from _typeshed import SupportsWrite from types import MethodType, ModuleType, TracebackType from typing import ( IO, Any, AnyStr, Callable, Container, Dict, List, Mapping, MutableMapping, NoReturn, Optional, Text, Tuple, Type, Union, ) if sys.version_info >= (3,): from reprlib import Repr else: from repr import Repr # the return type of sys.exc_info(), used by ErrorDuringImport.__init__ _Exc_Info = Tuple[Optional[Type[BaseException]], Optional[BaseException], Optional[TracebackType]] __author__: str __date__: str __version__: str __credits__: str def pathdirs() -> List[str]: ... def getdoc(object: object) -> Text: ... def splitdoc(doc: AnyStr) -> Tuple[AnyStr, AnyStr]: ... def classname(object: object, modname: str) -> str: ... def isdata(object: object) -> bool: ... def replace(text: AnyStr, *pairs: AnyStr) -> AnyStr: ... def cram(text: str, maxlen: int) -> str: ... def stripid(text: str) -> str: ... def allmethods(cl: type) -> MutableMapping[str, MethodType]: ... def visiblename(name: str, all: Optional[Container[str]] = ..., obj: Optional[object] = ...) -> bool: ... def classify_class_attrs(object: object) -> List[Tuple[str, str, type, str]]: ... def ispackage(path: str) -> bool: ... def source_synopsis(file: IO[AnyStr]) -> Optional[AnyStr]: ... def synopsis(filename: str, cache: MutableMapping[str, Tuple[int, str]] = ...) -> Optional[str]: ... class ErrorDuringImport(Exception): filename: str exc: Optional[Type[BaseException]] value: Optional[BaseException] tb: Optional[TracebackType] def __init__(self, filename: str, exc_info: _Exc_Info) -> None: ... def importfile(path: str) -> ModuleType: ... def safeimport(path: str, forceload: bool = ..., cache: MutableMapping[str, ModuleType] = ...) -> ModuleType: ... class Doc: PYTHONDOCS: str def document(self, object: object, name: Optional[str] = ..., *args: Any) -> str: ... def fail(self, object: object, name: Optional[str] = ..., *args: Any) -> NoReturn: ... def docmodule(self, object: object, name: Optional[str] = ..., *args: Any) -> str: ... def docclass(self, object: object, name: Optional[str] = ..., *args: Any) -> str: ... def docroutine(self, object: object, name: Optional[str] = ..., *args: Any) -> str: ... def docother(self, object: object, name: Optional[str] = ..., *args: Any) -> str: ... def docproperty(self, object: object, name: Optional[str] = ..., *args: Any) -> str: ... def docdata(self, object: object, name: Optional[str] = ..., *args: Any) -> str: ... def getdocloc(self, object: object, basedir: str = ...) -> Optional[str]: ... class HTMLRepr(Repr): maxlist: int maxtuple: int maxdict: int maxstring: int maxother: int def __init__(self) -> None: ... def escape(self, text: str) -> str: ... def repr(self, object: object) -> str: ... def repr1(self, x: object, level: complex) -> str: ... def repr_string(self, x: Text, level: complex) -> str: ... def repr_str(self, x: Text, level: complex) -> str: ... def repr_instance(self, x: object, level: complex) -> str: ... def repr_unicode(self, x: AnyStr, level: complex) -> str: ... class HTMLDoc(Doc): repr: Callable[[object], str] escape: Callable[[str], str] def page(self, title: str, contents: str) -> str: ... def heading(self, title: str, fgcol: str, bgcol: str, extras: str = ...) -> str: ... def section( self, title: str, fgcol: str, bgcol: str, contents: str, width: int = ..., prelude: str = ..., marginalia: Optional[str] = ..., gap: str = ..., ) -> str: ... def bigsection(self, title: str, *args: Any) -> str: ... def preformat(self, text: str) -> str: ... def multicolumn(self, list: List[Any], format: Callable[[Any], str], cols: int = ...) -> str: ... def grey(self, text: str) -> str: ... def namelink(self, name: str, *dicts: MutableMapping[str, str]) -> str: ... def classlink(self, object: object, modname: str) -> str: ... def modulelink(self, object: object) -> str: ... def modpkglink(self, modpkginfo: Tuple[str, str, bool, bool]) -> str: ... def markup( self, text: str, escape: Optional[Callable[[str], str]] = ..., funcs: Mapping[str, str] = ..., classes: Mapping[str, str] = ..., methods: Mapping[str, str] = ..., ) -> str: ... def formattree( self, tree: List[Union[Tuple[type, Tuple[type, ...]], List[Any]]], modname: str, parent: Optional[type] = ... ) -> str: ... def docmodule(self, object: object, name: Optional[str] = ..., mod: Optional[str] = ..., *ignored: Any) -> str: ... def docclass( self, object: object, name: Optional[str] = ..., mod: Optional[str] = ..., funcs: Mapping[str, str] = ..., classes: Mapping[str, str] = ..., *ignored: Any, ) -> str: ... def formatvalue(self, object: object) -> str: ... def docroutine( self, object: object, name: Optional[str] = ..., mod: Optional[str] = ..., funcs: Mapping[str, str] = ..., classes: Mapping[str, str] = ..., methods: Mapping[str, str] = ..., cl: Optional[type] = ..., *ignored: Any, ) -> str: ... def docproperty( self, object: object, name: Optional[str] = ..., mod: Optional[str] = ..., cl: Optional[Any] = ..., *ignored: Any ) -> str: ... def docother(self, object: object, name: Optional[str] = ..., mod: Optional[Any] = ..., *ignored: Any) -> str: ... def docdata( self, object: object, name: Optional[str] = ..., mod: Optional[Any] = ..., cl: Optional[Any] = ..., *ignored: Any ) -> str: ... def index(self, dir: str, shadowed: Optional[MutableMapping[str, bool]] = ...) -> str: ... def filelink(self, url: str, path: str) -> str: ... class TextRepr(Repr): maxlist: int maxtuple: int maxdict: int maxstring: int maxother: int def __init__(self) -> None: ... def repr1(self, x: object, level: complex) -> str: ... def repr_string(self, x: str, level: complex) -> str: ... def repr_str(self, x: str, level: complex) -> str: ... def repr_instance(self, x: object, level: complex) -> str: ... class TextDoc(Doc): repr: Callable[[object], str] def bold(self, text: str) -> str: ... def indent(self, text: str, prefix: str = ...) -> str: ... def section(self, title: str, contents: str) -> str: ... def formattree( self, tree: List[Union[Tuple[type, Tuple[type, ...]], List[Any]]], modname: str, parent: Optional[type] = ..., prefix: str = ..., ) -> str: ... def docmodule(self, object: object, name: Optional[str] = ..., mod: Optional[Any] = ..., *ignored: Any) -> str: ... def docclass(self, object: object, name: Optional[str] = ..., mod: Optional[str] = ..., *ignored: Any) -> str: ... def formatvalue(self, object: object) -> str: ... def docroutine( self, object: object, name: Optional[str] = ..., mod: Optional[str] = ..., cl: Optional[Any] = ..., *ignored: Any ) -> str: ... def docproperty( self, object: object, name: Optional[str] = ..., mod: Optional[Any] = ..., cl: Optional[Any] = ..., *ignored: Any ) -> str: ... def docdata( self, object: object, name: Optional[str] = ..., mod: Optional[str] = ..., cl: Optional[Any] = ..., *ignored: Any ) -> str: ... def docother( self, object: object, name: Optional[str] = ..., mod: Optional[str] = ..., parent: Optional[str] = ..., maxlen: Optional[int] = ..., doc: Optional[Any] = ..., *ignored: Any, ) -> str: ... def pager(text: str) -> None: ... def getpager() -> Callable[[str], None]: ... def plain(text: str) -> str: ... def pipepager(text: str, cmd: str) -> None: ... def tempfilepager(text: str, cmd: str) -> None: ... def ttypager(text: str) -> None: ... def plainpager(text: str) -> None: ... def describe(thing: Any) -> str: ... def locate(path: str, forceload: bool = ...) -> object: ... text: TextDoc html: HTMLDoc class _OldStyleClass: ... def resolve(thing: Union[str, object], forceload: bool = ...) -> Optional[Tuple[object, str]]: ... def render_doc(thing: Union[str, object], title: str = ..., forceload: bool = ..., renderer: Optional[Doc] = ...) -> str: ... def doc( thing: Union[str, object], title: str = ..., forceload: bool = ..., output: Optional[SupportsWrite[str]] = ... ) -> None: ... def writedoc(thing: Union[str, object], forceload: bool = ...) -> None: ... def writedocs(dir: str, pkgpath: str = ..., done: Optional[Any] = ...) -> None: ... class Helper: keywords: Dict[str, Union[str, Tuple[str, str]]] symbols: Dict[str, str] topics: Dict[str, Union[str, Tuple[str, ...]]] def __init__(self, input: Optional[IO[str]] = ..., output: Optional[IO[str]] = ...) -> None: ... input: IO[str] output: IO[str] def __call__(self, request: Union[str, Helper, object] = ...) -> None: ... def interact(self) -> None: ... def getline(self, prompt: str) -> str: ... def help(self, request: Any) -> None: ... def intro(self) -> None: ... def list(self, items: List[str], columns: int = ..., width: int = ...) -> None: ... def listkeywords(self) -> None: ... def listsymbols(self) -> None: ... def listtopics(self) -> None: ... def showtopic(self, topic: str, more_xrefs: str = ...) -> None: ... def showsymbol(self, symbol: str) -> None: ... def listmodules(self, key: str = ...) -> None: ... help: Helper # See Python issue #11182: "remove the unused and undocumented pydoc.Scanner class" # class Scanner: # roots = ... # type: Any # state = ... # type: Any # children = ... # type: Any # descendp = ... # type: Any # def __init__(self, roots, children, descendp) -> None: ... # def next(self): ... class ModuleScanner: quit: bool def run( self, callback: Callable[[Optional[str], str, str], None], key: Optional[Any] = ..., completer: Optional[Callable[[], None]] = ..., onerror: Optional[Callable[[str], None]] = ..., ) -> None: ... def apropos(key: str) -> None: ... def ispath(x: Any) -> bool: ... def cli() -> None: ... if sys.version_info < (3,): def serve( port: int, callback: Optional[Callable[[Any], None]] = ..., completer: Optional[Callable[[], None]] = ... ) -> None: ... def gui() -> None: ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4223793 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/pydoc_data/0000775000175000017500000000000000000000000023770 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/pydoc_data/__init__.pyi0000664000175000017500000000000000000000000026240 0ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/pydoc_data/topics.pyi0000664000175000017500000000006000000000000026010 0ustar00davedave00000000000000from typing import Dict topics: Dict[str, str] ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4223793 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/pyexpat/0000775000175000017500000000000000000000000023353 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/pyexpat/__init__.pyi0000664000175000017500000000651400000000000025643 0ustar00davedave00000000000000import pyexpat.errors as errors import pyexpat.model as model from _typeshed import SupportsRead from typing import Any, Callable, Dict, List, Optional, Text, Tuple, Union EXPAT_VERSION: str # undocumented version_info: Tuple[int, int, int] # undocumented native_encoding: str # undocumented features: List[Tuple[str, int]] # undocumented class ExpatError(Exception): code: int lineno: int offset: int error = ExpatError XML_PARAM_ENTITY_PARSING_NEVER: int XML_PARAM_ENTITY_PARSING_UNLESS_STANDALONE: int XML_PARAM_ENTITY_PARSING_ALWAYS: int _Model = Tuple[int, int, Optional[str], tuple] class XMLParserType(object): def Parse(self, __data: Union[Text, bytes], __isfinal: bool = ...) -> int: ... def ParseFile(self, __file: SupportsRead[bytes]) -> int: ... def SetBase(self, __base: Text) -> None: ... def GetBase(self) -> Optional[str]: ... def GetInputContext(self) -> Optional[bytes]: ... def ExternalEntityParserCreate(self, __context: Optional[Text], __encoding: Text = ...) -> XMLParserType: ... def SetParamEntityParsing(self, __flag: int) -> int: ... def UseForeignDTD(self, __flag: bool = ...) -> None: ... buffer_size: int buffer_text: bool buffer_used: int namespace_prefixes: bool # undocumented ordered_attributes: bool specified_attributes: bool ErrorByteIndex: int ErrorCode: int ErrorColumnNumber: int ErrorLineNumber: int CurrentByteIndex: int CurrentColumnNumber: int CurrentLineNumber: int XmlDeclHandler: Optional[Callable[[str, Optional[str], int], Any]] StartDoctypeDeclHandler: Optional[Callable[[str, Optional[str], Optional[str], bool], Any]] EndDoctypeDeclHandler: Optional[Callable[[], Any]] ElementDeclHandler: Optional[Callable[[str, _Model], Any]] AttlistDeclHandler: Optional[Callable[[str, str, str, Optional[str], bool], Any]] StartElementHandler: Optional[ Union[ Callable[[str, Dict[str, str]], Any], Callable[[str, List[str]], Any], Callable[[str, Union[Dict[str, str]], List[str]], Any], ] ] EndElementHandler: Optional[Callable[[str], Any]] ProcessingInstructionHandler: Optional[Callable[[str, str], Any]] CharacterDataHandler: Optional[Callable[[str], Any]] UnparsedEntityDeclHandler: Optional[Callable[[str, Optional[str], str, Optional[str], str], Any]] EntityDeclHandler: Optional[Callable[[str, bool, Optional[str], Optional[str], str, Optional[str], Optional[str]], Any]] NotationDeclHandler: Optional[Callable[[str, Optional[str], str, Optional[str]], Any]] StartNamespaceDeclHandler: Optional[Callable[[str, str], Any]] EndNamespaceDeclHandler: Optional[Callable[[str], Any]] CommentHandler: Optional[Callable[[str], Any]] StartCdataSectionHandler: Optional[Callable[[], Any]] EndCdataSectionHandler: Optional[Callable[[], Any]] DefaultHandler: Optional[Callable[[str], Any]] DefaultHandlerExpand: Optional[Callable[[str], Any]] NotStandaloneHandler: Optional[Callable[[], int]] ExternalEntityRefHandler: Optional[Callable[[str, Optional[str], Optional[str], Optional[str]], int]] def ErrorString(__code: int) -> str: ... # intern is undocumented def ParserCreate( encoding: Optional[Text] = ..., namespace_separator: Optional[Text] = ..., intern: Optional[Dict[str, Any]] = ... ) -> XMLParserType: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/pyexpat/errors.pyi0000664000175000017500000000237300000000000025417 0ustar00davedave00000000000000import sys from typing import Dict if sys.version_info >= (3, 2): codes: Dict[str, int] messages: Dict[int, str] XML_ERROR_ABORTED: str XML_ERROR_ASYNC_ENTITY: str XML_ERROR_ATTRIBUTE_EXTERNAL_ENTITY_REF: str XML_ERROR_BAD_CHAR_REF: str XML_ERROR_BINARY_ENTITY_REF: str XML_ERROR_CANT_CHANGE_FEATURE_ONCE_PARSING: str XML_ERROR_DUPLICATE_ATTRIBUTE: str XML_ERROR_ENTITY_DECLARED_IN_PE: str XML_ERROR_EXTERNAL_ENTITY_HANDLING: str XML_ERROR_FEATURE_REQUIRES_XML_DTD: str XML_ERROR_FINISHED: str XML_ERROR_INCOMPLETE_PE: str XML_ERROR_INCORRECT_ENCODING: str XML_ERROR_INVALID_TOKEN: str XML_ERROR_JUNK_AFTER_DOC_ELEMENT: str XML_ERROR_MISPLACED_XML_PI: str XML_ERROR_NOT_STANDALONE: str XML_ERROR_NOT_SUSPENDED: str XML_ERROR_NO_ELEMENTS: str XML_ERROR_NO_MEMORY: str XML_ERROR_PARAM_ENTITY_REF: str XML_ERROR_PARTIAL_CHAR: str XML_ERROR_PUBLICID: str XML_ERROR_RECURSIVE_ENTITY_REF: str XML_ERROR_SUSPENDED: str XML_ERROR_SUSPEND_PE: str XML_ERROR_SYNTAX: str XML_ERROR_TAG_MISMATCH: str XML_ERROR_TEXT_DECL: str XML_ERROR_UNBOUND_PREFIX: str XML_ERROR_UNCLOSED_CDATA_SECTION: str XML_ERROR_UNCLOSED_TOKEN: str XML_ERROR_UNDECLARING_PREFIX: str XML_ERROR_UNDEFINED_ENTITY: str XML_ERROR_UNEXPECTED_STATE: str XML_ERROR_UNKNOWN_ENCODING: str XML_ERROR_XML_DECL: str ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/pyexpat/model.pyi0000664000175000017500000000031500000000000025175 0ustar00davedave00000000000000XML_CTYPE_ANY: int XML_CTYPE_CHOICE: int XML_CTYPE_EMPTY: int XML_CTYPE_MIXED: int XML_CTYPE_NAME: int XML_CTYPE_SEQ: int XML_CQUANT_NONE: int XML_CQUANT_OPT: int XML_CQUANT_PLUS: int XML_CQUANT_REP: int ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/quopri.pyi0000664000175000017500000000052700000000000023727 0ustar00davedave00000000000000from typing import BinaryIO def encode(input: BinaryIO, output: BinaryIO, quotetabs: int, header: int = ...) -> None: ... def encodestring(s: bytes, quotetabs: int = ..., header: int = ...) -> bytes: ... def decode(input: BinaryIO, output: BinaryIO, header: int = ...) -> None: ... def decodestring(s: bytes, header: int = ...) -> bytes: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/readline.pyi0000664000175000017500000000306100000000000024167 0ustar00davedave00000000000000import sys from typing import Callable, Optional, Sequence _CompleterT = Optional[Callable[[str, int], Optional[str]]] _CompDispT = Optional[Callable[[str, Sequence[str], int], None]] def parse_and_bind(string: str) -> None: ... def read_init_file(filename: str = ...) -> None: ... def get_line_buffer() -> str: ... def insert_text(string: str) -> None: ... def redisplay() -> None: ... def read_history_file(filename: str = ...) -> None: ... def write_history_file(filename: str = ...) -> None: ... if sys.version_info >= (3, 5): def append_history_file(nelements: int, filename: str = ...) -> None: ... def get_history_length() -> int: ... def set_history_length(length: int) -> None: ... def clear_history() -> None: ... def get_current_history_length() -> int: ... def get_history_item(index: int) -> str: ... def remove_history_item(pos: int) -> None: ... def replace_history_item(pos: int, line: str) -> None: ... def add_history(string: str) -> None: ... if sys.version_info >= (3, 6): def set_auto_history(enabled: bool) -> None: ... def set_startup_hook(function: Optional[Callable[[], None]] = ...) -> None: ... def set_pre_input_hook(function: Optional[Callable[[], None]] = ...) -> None: ... def set_completer(function: _CompleterT = ...) -> None: ... def get_completer() -> _CompleterT: ... def get_completion_type() -> int: ... def get_begidx() -> int: ... def get_endidx() -> int: ... def set_completer_delims(string: str) -> None: ... def get_completer_delims() -> str: ... def set_completion_display_matches_hook(function: _CompDispT = ...) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/rlcompleter.pyi0000664000175000017500000000046400000000000024740 0ustar00davedave00000000000000import sys from typing import Any, Dict, Optional, Union if sys.version_info >= (3,): _Text = str else: _Text = Union[str, unicode] class Completer: def __init__(self, namespace: Optional[Dict[str, Any]] = ...) -> None: ... def complete(self, text: _Text, state: int) -> Optional[str]: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/sched.pyi0000664000175000017500000000273100000000000023475 0ustar00davedave00000000000000import sys from typing import Any, Callable, Dict, List, NamedTuple, Optional, Text, Tuple class Event(NamedTuple): time: float priority: Any action: Callable[..., Any] argument: Tuple[Any, ...] kwargs: Dict[Text, Any] class scheduler: if sys.version_info >= (3, 3): def __init__(self, timefunc: Callable[[], float] = ..., delayfunc: Callable[[float], None] = ...) -> None: ... def enterabs( self, time: float, priority: Any, action: Callable[..., Any], argument: Tuple[Any, ...] = ..., kwargs: Dict[str, Any] = ..., ) -> Event: ... def enter( self, delay: float, priority: Any, action: Callable[..., Any], argument: Tuple[Any, ...] = ..., kwargs: Dict[str, Any] = ..., ) -> Event: ... def run(self, blocking: bool = ...) -> Optional[float]: ... else: def __init__(self, timefunc: Callable[[], float], delayfunc: Callable[[float], None]) -> None: ... def enterabs(self, time: float, priority: Any, action: Callable[..., Any], argument: Tuple[Any, ...]) -> Event: ... def enter(self, delay: float, priority: Any, action: Callable[..., Any], argument: Tuple[Any, ...]) -> Event: ... def run(self) -> None: ... def cancel(self, event: Event) -> None: ... def empty(self) -> bool: ... @property def queue(self) -> List[Event]: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/select.pyi0000664000175000017500000001133400000000000023665 0ustar00davedave00000000000000import sys from _typeshed import FileDescriptorLike from types import TracebackType from typing import Any, Iterable, List, Optional, Tuple, Type if sys.platform != "win32": PIPE_BUF: int POLLERR: int POLLHUP: int POLLIN: int POLLMSG: int POLLNVAL: int POLLOUT: int POLLPRI: int POLLRDBAND: int POLLRDNORM: int POLLWRBAND: int POLLWRNORM: int class poll: def __init__(self) -> None: ... def register(self, fd: FileDescriptorLike, eventmask: int = ...) -> None: ... def modify(self, fd: FileDescriptorLike, eventmask: int) -> None: ... def unregister(self, fd: FileDescriptorLike) -> None: ... def poll(self, timeout: Optional[float] = ...) -> List[Tuple[int, int]]: ... def select( __rlist: Iterable[Any], __wlist: Iterable[Any], __xlist: Iterable[Any], __timeout: Optional[float] = ... ) -> Tuple[List[Any], List[Any], List[Any]]: ... if sys.version_info >= (3, 3): error = OSError else: class error(Exception): ... if sys.platform != "linux" and sys.platform != "win32": # BSD only class kevent(object): data: Any fflags: int filter: int flags: int ident: int udata: Any def __init__( self, ident: FileDescriptorLike, filter: int = ..., flags: int = ..., fflags: int = ..., data: Any = ..., udata: Any = ..., ) -> None: ... # BSD only class kqueue(object): closed: bool def __init__(self) -> None: ... def close(self) -> None: ... def control( self, __changelist: Optional[Iterable[kevent]], __maxevents: int, __timeout: Optional[float] = ... ) -> List[kevent]: ... def fileno(self) -> int: ... @classmethod def fromfd(cls, __fd: FileDescriptorLike) -> kqueue: ... KQ_EV_ADD: int KQ_EV_CLEAR: int KQ_EV_DELETE: int KQ_EV_DISABLE: int KQ_EV_ENABLE: int KQ_EV_EOF: int KQ_EV_ERROR: int KQ_EV_FLAG1: int KQ_EV_ONESHOT: int KQ_EV_SYSFLAGS: int KQ_FILTER_AIO: int KQ_FILTER_NETDEV: int KQ_FILTER_PROC: int KQ_FILTER_READ: int KQ_FILTER_SIGNAL: int KQ_FILTER_TIMER: int KQ_FILTER_VNODE: int KQ_FILTER_WRITE: int KQ_NOTE_ATTRIB: int KQ_NOTE_CHILD: int KQ_NOTE_DELETE: int KQ_NOTE_EXEC: int KQ_NOTE_EXIT: int KQ_NOTE_EXTEND: int KQ_NOTE_FORK: int KQ_NOTE_LINK: int if sys.platform != "darwin": KQ_NOTE_LINKDOWN: int KQ_NOTE_LINKINV: int KQ_NOTE_LINKUP: int KQ_NOTE_LOWAT: int KQ_NOTE_PCTRLMASK: int KQ_NOTE_PDATAMASK: int KQ_NOTE_RENAME: int KQ_NOTE_REVOKE: int KQ_NOTE_TRACK: int KQ_NOTE_TRACKERR: int KQ_NOTE_WRITE: int if sys.platform == "linux": class epoll(object): if sys.version_info >= (3, 3): def __init__(self, sizehint: int = ..., flags: int = ...) -> None: ... else: def __init__(self, sizehint: int = ...) -> None: ... if sys.version_info >= (3, 4): def __enter__(self) -> epoll: ... def __exit__( self, exc_type: Optional[Type[BaseException]] = ..., exc_val: Optional[BaseException] = ..., exc_tb: Optional[TracebackType] = ..., ) -> None: ... def close(self) -> None: ... closed: bool def fileno(self) -> int: ... def register(self, fd: FileDescriptorLike, eventmask: int = ...) -> None: ... def modify(self, fd: FileDescriptorLike, eventmask: int) -> None: ... def unregister(self, fd: FileDescriptorLike) -> None: ... def poll(self, timeout: Optional[float] = ..., maxevents: int = ...) -> List[Tuple[int, int]]: ... @classmethod def fromfd(cls, __fd: FileDescriptorLike) -> epoll: ... EPOLLERR: int EPOLLET: int EPOLLHUP: int EPOLLIN: int EPOLLMSG: int EPOLLONESHOT: int EPOLLOUT: int EPOLLPRI: int EPOLLRDBAND: int EPOLLRDNORM: int EPOLLWRBAND: int EPOLLWRNORM: int EPOLL_RDHUP: int if sys.platform != "linux" and sys.platform != "darwin" and sys.platform != "win32": if sys.version_info >= (3, 3): # Solaris only class devpoll: if sys.version_info >= (3, 4): def close(self) -> None: ... closed: bool def fileno(self) -> int: ... def register(self, fd: FileDescriptorLike, eventmask: int = ...) -> None: ... def modify(self, fd: FileDescriptorLike, eventmask: int = ...) -> None: ... def unregister(self, fd: FileDescriptorLike) -> None: ... def poll(self, timeout: Optional[float] = ...) -> List[Tuple[int, int]]: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/shutil.pyi0000664000175000017500000001351100000000000023715 0ustar00davedave00000000000000import os import sys from _typeshed import StrPath, SupportsRead, SupportsWrite from typing import ( Any, AnyStr, Callable, Iterable, List, NamedTuple, Optional, Sequence, Set, Tuple, Type, TypeVar, Union, overload, ) if sys.version_info >= (3, 6): _AnyStr = str _AnyPath = TypeVar("_AnyPath", str, os.PathLike[str]) # Return value of some functions that may either return a path-like object that was passed in or # a string _PathReturn = Any elif sys.version_info >= (3,): _AnyStr = str _AnyPath = str _PathReturn = str else: _AnyStr = TypeVar("_AnyStr", str, unicode) _AnyPath = TypeVar("_AnyPath", str, unicode) _PathReturn = Type[None] if sys.version_info >= (3,): class Error(OSError): ... class SameFileError(Error): ... class SpecialFileError(OSError): ... class ExecError(OSError): ... class ReadError(OSError): ... class RegistryError(Exception): ... else: class Error(EnvironmentError): ... class SpecialFileError(EnvironmentError): ... class ExecError(EnvironmentError): ... def copyfileobj(fsrc: SupportsRead[AnyStr], fdst: SupportsWrite[AnyStr], length: int = ...) -> None: ... if sys.version_info >= (3,): def copyfile(src: StrPath, dst: _AnyPath, *, follow_symlinks: bool = ...) -> _AnyPath: ... def copymode(src: StrPath, dst: StrPath, *, follow_symlinks: bool = ...) -> None: ... def copystat(src: StrPath, dst: StrPath, *, follow_symlinks: bool = ...) -> None: ... def copy(src: StrPath, dst: StrPath, *, follow_symlinks: bool = ...) -> _PathReturn: ... def copy2(src: StrPath, dst: StrPath, *, follow_symlinks: bool = ...) -> _PathReturn: ... else: def copyfile(src: StrPath, dst: StrPath) -> None: ... def copymode(src: StrPath, dst: StrPath) -> None: ... def copystat(src: StrPath, dst: StrPath) -> None: ... def copy(src: StrPath, dst: StrPath) -> _PathReturn: ... def copy2(src: StrPath, dst: StrPath) -> _PathReturn: ... def ignore_patterns(*patterns: StrPath) -> Callable[[Any, List[_AnyStr]], Set[_AnyStr]]: ... if sys.version_info >= (3, 8): def copytree( src: StrPath, dst: StrPath, symlinks: bool = ..., ignore: Union[None, Callable[[str, List[str]], Iterable[str]], Callable[[StrPath, List[str]], Iterable[str]]] = ..., copy_function: Callable[[str, str], None] = ..., ignore_dangling_symlinks: bool = ..., dirs_exist_ok: bool = ..., ) -> _PathReturn: ... elif sys.version_info >= (3,): def copytree( src: StrPath, dst: StrPath, symlinks: bool = ..., ignore: Union[None, Callable[[str, List[str]], Iterable[str]], Callable[[StrPath, List[str]], Iterable[str]]] = ..., copy_function: Callable[[str, str], None] = ..., ignore_dangling_symlinks: bool = ..., ) -> _PathReturn: ... else: def copytree( src: AnyStr, dst: AnyStr, symlinks: bool = ..., ignore: Union[None, Callable[[AnyStr, List[AnyStr]], Iterable[AnyStr]]] = ..., ) -> _PathReturn: ... if sys.version_info >= (3,): def rmtree( path: Union[bytes, StrPath], ignore_errors: bool = ..., onerror: Optional[Callable[[Any, Any, Any], Any]] = ... ) -> None: ... else: def rmtree( path: _AnyPath, ignore_errors: bool = ..., onerror: Optional[Callable[[Any, _AnyPath, Any], Any]] = ... ) -> None: ... _CopyFn = Union[Callable[[str, str], None], Callable[[StrPath, StrPath], None]] if sys.version_info >= (3, 9): def move(src: StrPath, dst: StrPath, copy_function: _CopyFn = ...) -> _PathReturn: ... elif sys.version_info >= (3, 5): # See https://bugs.python.org/issue32689 def move(src: str, dst: StrPath, copy_function: _CopyFn = ...) -> _PathReturn: ... else: def move(src: StrPath, dst: StrPath) -> _PathReturn: ... if sys.version_info >= (3,): class _ntuple_diskusage(NamedTuple): total: int used: int free: int def disk_usage(path: StrPath) -> _ntuple_diskusage: ... def chown(path: StrPath, user: Optional[Union[str, int]] = ..., group: Optional[Union[str, int]] = ...) -> None: ... if sys.version_info >= (3, 8): @overload def which(cmd: StrPath, mode: int = ..., path: Optional[StrPath] = ...) -> Optional[str]: ... @overload def which(cmd: bytes, mode: int = ..., path: Optional[StrPath] = ...) -> Optional[bytes]: ... elif sys.version_info >= (3,): def which(cmd: StrPath, mode: int = ..., path: Optional[StrPath] = ...) -> Optional[str]: ... def make_archive( base_name: _AnyStr, format: str, root_dir: Optional[StrPath] = ..., base_dir: Optional[StrPath] = ..., verbose: bool = ..., dry_run: bool = ..., owner: Optional[str] = ..., group: Optional[str] = ..., logger: Optional[Any] = ..., ) -> _AnyStr: ... def get_archive_formats() -> List[Tuple[str, str]]: ... def register_archive_format( name: str, function: Callable[..., Any], extra_args: Optional[Sequence[Union[Tuple[str, Any], List[Any]]]] = ..., description: str = ..., ) -> None: ... def unregister_archive_format(name: str) -> None: ... if sys.version_info >= (3,): if sys.version_info >= (3, 7): def unpack_archive(filename: StrPath, extract_dir: Optional[StrPath] = ..., format: Optional[str] = ...) -> None: ... else: # See http://bugs.python.org/issue30218 def unpack_archive(filename: str, extract_dir: Optional[StrPath] = ..., format: Optional[str] = ...) -> None: ... def register_unpack_format( name: str, extensions: List[str], function: Any, extra_args: Sequence[Tuple[str, Any]] = ..., description: str = ... ) -> None: ... def unregister_unpack_format(name: str) -> None: ... def get_unpack_formats() -> List[Tuple[str, List[str], str]]: ... def get_terminal_size(fallback: Tuple[int, int] = ...) -> os.terminal_size: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/site.pyi0000664000175000017500000000070200000000000023347 0ustar00davedave00000000000000import sys from typing import Iterable, List, Optional PREFIXES: List[str] ENABLE_USER_SITE: Optional[bool] USER_SITE: Optional[str] USER_BASE: Optional[str] if sys.version_info < (3,): def main() -> None: ... def addsitedir(sitedir: str, known_paths: Optional[Iterable[str]] = ...) -> None: ... def getsitepackages(prefixes: Optional[Iterable[str]] = ...) -> List[str]: ... def getuserbase() -> str: ... def getusersitepackages() -> str: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/smtpd.pyi0000664000175000017500000000556700000000000023550 0ustar00davedave00000000000000import asynchat import asyncore import socket import sys from typing import Any, DefaultDict, List, Optional, Text, Tuple, Type _Address = Tuple[str, int] # (host, port) class SMTPChannel(asynchat.async_chat): COMMAND: int DATA: int if sys.version_info >= (3,): command_size_limits: DefaultDict[str, int] smtp_server: SMTPServer conn: socket.socket addr: Any received_lines: List[Text] smtp_state: int seen_greeting: str mailfrom: str rcpttos: List[str] received_data: str fqdn: str peer: str command_size_limit: int data_size_limit: int enable_SMTPUTF8: bool @property def max_command_size_limit(self) -> int: ... if sys.version_info >= (3,): def __init__( self, server: SMTPServer, conn: socket.socket, addr: Any, data_size_limit: int = ..., map: Optional[asyncore._maptype] = ..., enable_SMTPUTF8: bool = ..., decode_data: bool = ..., ) -> None: ... else: def __init__(self, server: SMTPServer, conn: socket.socket, addr: Any, data_size_limit: int = ...) -> None: ... # base asynchat.async_chat.push() accepts bytes def push(self, msg: Text) -> None: ... # type: ignore def collect_incoming_data(self, data: bytes) -> None: ... def found_terminator(self) -> None: ... def smtp_HELO(self, arg: str) -> None: ... def smtp_NOOP(self, arg: str) -> None: ... def smtp_QUIT(self, arg: str) -> None: ... def smtp_MAIL(self, arg: str) -> None: ... def smtp_RCPT(self, arg: str) -> None: ... def smtp_RSET(self, arg: str) -> None: ... def smtp_DATA(self, arg: str) -> None: ... if sys.version_info >= (3, 3): def smtp_EHLO(self, arg: str) -> None: ... def smtp_HELP(self, arg: str) -> None: ... def smtp_VRFY(self, arg: str) -> None: ... def smtp_EXPN(self, arg: str) -> None: ... class SMTPServer(asyncore.dispatcher): channel_class: Type[SMTPChannel] data_size_limit: int enable_SMTPUTF8: bool if sys.version_info >= (3,): def __init__( self, localaddr: _Address, remoteaddr: _Address, data_size_limit: int = ..., map: Optional[asyncore._maptype] = ..., enable_SMTPUTF8: bool = ..., decode_data: bool = ..., ) -> None: ... else: def __init__(self, localaddr: _Address, remoteaddr: _Address, data_size_limit: int = ...) -> None: ... def handle_accepted(self, conn: socket.socket, addr: Any) -> None: ... def process_message(self, peer: _Address, mailfrom: str, rcpttos: List[Text], data: str, **kwargs: Any) -> Optional[str]: ... class DebuggingServer(SMTPServer): ... class PureProxy(SMTPServer): ... class MailmanProxy(PureProxy): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/sndhdr.pyi0000664000175000017500000000076500000000000023676 0ustar00davedave00000000000000import sys from _typeshed import AnyPath from typing import NamedTuple, Optional, Tuple, Union if sys.version_info >= (3, 5): class SndHeaders(NamedTuple): filetype: str framerate: int nchannels: int nframes: int sampwidth: Union[int, str] _SndHeaders = SndHeaders else: _SndHeaders = Tuple[str, int, int, int, Union[int, str]] def what(filename: AnyPath) -> Optional[_SndHeaders]: ... def whathdr(filename: AnyPath) -> Optional[_SndHeaders]: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/socket.pyi0000664000175000017500000005426700000000000023712 0ustar00davedave00000000000000import sys from typing import Any, BinaryIO, Iterable, List, Optional, Text, TextIO, Tuple, TypeVar, Union, overload from typing_extensions import Literal # ----- Constants ----- # Some socket families are listed in the "Socket families" section of the docs, # but not the "Constants" section. These are listed at the end of the list of # constants. # # Besides those and the first few constants listed, the constants are listed in # documentation order. # Constants defined by Python (i.e. not OS constants re-exported from C) has_ipv6: bool SocketType: Any if sys.version_info >= (3,): SocketIO: Any # Re-exported errno EAGAIN: int EBADF: int EINTR: int EWOULDBLOCK: int # Constants re-exported from C # Per socketmodule.c, only these three families are portable AF_UNIX: AddressFamily AF_INET: AddressFamily AF_INET6: AddressFamily SOCK_STREAM: SocketKind SOCK_DGRAM: SocketKind SOCK_RAW: SocketKind SOCK_RDM: SocketKind SOCK_SEQPACKET: SocketKind if sys.platform == "linux" and sys.version_info >= (3,): SOCK_CLOEXEC: SocketKind SOCK_NONBLOCK: SocketKind # Address families not mentioned in the docs AF_AAL5: AddressFamily AF_APPLETALK: AddressFamily AF_ASH: AddressFamily AF_ATMPVC: AddressFamily AF_ATMSVC: AddressFamily AF_AX25: AddressFamily AF_BRIDGE: AddressFamily AF_DECnet: AddressFamily AF_ECONET: AddressFamily AF_IPX: AddressFamily AF_IRDA: AddressFamily AF_KEY: AddressFamily AF_LLC: AddressFamily AF_NETBEUI: AddressFamily AF_NETROM: AddressFamily AF_PPPOX: AddressFamily AF_ROSE: AddressFamily AF_ROUTE: AddressFamily AF_SECURITY: AddressFamily AF_SNA: AddressFamily AF_SYSTEM: AddressFamily AF_UNSPEC: AddressFamily AF_WANPIPE: AddressFamily AF_X25: AddressFamily # The "many constants" referenced by the docs SOMAXCONN: int AI_ADDRCONFIG: AddressInfo AI_ALL: AddressInfo AI_CANONNAME: AddressInfo AI_DEFAULT: AddressInfo AI_MASK: AddressInfo AI_NUMERICHOST: AddressInfo AI_NUMERICSERV: AddressInfo AI_PASSIVE: AddressInfo AI_V4MAPPED: AddressInfo AI_V4MAPPED_CFG: AddressInfo EAI_ADDRFAMILY: int EAI_AGAIN: int EAI_BADFLAGS: int EAI_BADHINTS: int EAI_FAIL: int EAI_FAMILY: int EAI_MAX: int EAI_MEMORY: int EAI_NODATA: int EAI_NONAME: int EAI_OVERFLOW: int EAI_PROTOCOL: int EAI_SERVICE: int EAI_SOCKTYPE: int EAI_SYSTEM: int INADDR_ALLHOSTS_GROUP: int INADDR_ANY: int INADDR_BROADCAST: int INADDR_LOOPBACK: int INADDR_MAX_LOCAL_GROUP: int INADDR_NONE: int INADDR_UNSPEC_GROUP: int IPPORT_RESERVED: int IPPORT_USERRESERVED: int IPPROTO_AH: int IPPROTO_BIP: int IPPROTO_DSTOPTS: int IPPROTO_EGP: int IPPROTO_EON: int IPPROTO_ESP: int IPPROTO_FRAGMENT: int IPPROTO_GGP: int IPPROTO_GRE: int IPPROTO_HELLO: int IPPROTO_HOPOPTS: int IPPROTO_ICMP: int IPPROTO_ICMPV6: int IPPROTO_IDP: int IPPROTO_IGMP: int IPPROTO_IP: int IPPROTO_IPCOMP: int IPPROTO_IPIP: int IPPROTO_IPV4: int IPPROTO_IPV6: int IPPROTO_MAX: int IPPROTO_MOBILE: int IPPROTO_ND: int IPPROTO_NONE: int IPPROTO_PIM: int IPPROTO_PUP: int IPPROTO_RAW: int IPPROTO_ROUTING: int IPPROTO_RSVP: int IPPROTO_SCTP: int IPPROTO_TCP: int IPPROTO_TP: int IPPROTO_UDP: int IPPROTO_VRRP: int IPPROTO_XTP: int IPV6_CHECKSUM: int IPV6_DONTFRAG: int IPV6_DSTOPTS: int IPV6_HOPLIMIT: int IPV6_HOPOPTS: int IPV6_JOIN_GROUP: int IPV6_LEAVE_GROUP: int IPV6_MULTICAST_HOPS: int IPV6_MULTICAST_IF: int IPV6_MULTICAST_LOOP: int IPV6_NEXTHOP: int IPV6_PATHMTU: int IPV6_PKTINFO: int IPV6_RECVDSTOPTS: int IPV6_RECVHOPLIMIT: int IPV6_RECVHOPOPTS: int IPV6_RECVPATHMTU: int IPV6_RECVPKTINFO: int IPV6_RECVRTHDR: int IPV6_RECVTCLASS: int IPV6_RTHDR: int IPV6_RTHDRDSTOPTS: int IPV6_RTHDR_TYPE_0: int IPV6_TCLASS: int IPV6_UNICAST_HOPS: int IPV6_USE_MIN_MTU: int IPV6_V6ONLY: int IPX_TYPE: int IP_ADD_MEMBERSHIP: int IP_DEFAULT_MULTICAST_LOOP: int IP_DEFAULT_MULTICAST_TTL: int IP_DROP_MEMBERSHIP: int IP_HDRINCL: int IP_MAX_MEMBERSHIPS: int IP_MULTICAST_IF: int IP_MULTICAST_LOOP: int IP_MULTICAST_TTL: int IP_OPTIONS: int IP_RECVDSTADDR: int IP_RECVOPTS: int IP_RECVRETOPTS: int IP_RETOPTS: int IP_TOS: int IP_TRANSPARENT: int IP_TTL: int LOCAL_PEERCRED: int MSG_BCAST: MsgFlag MSG_BTAG: MsgFlag MSG_CMSG_CLOEXEC: MsgFlag MSG_CONFIRM: MsgFlag MSG_CTRUNC: MsgFlag MSG_DONTROUTE: MsgFlag MSG_DONTWAIT: MsgFlag MSG_EOF: MsgFlag MSG_EOR: MsgFlag MSG_ERRQUEUE: MsgFlag MSG_ETAG: MsgFlag MSG_FASTOPEN: MsgFlag MSG_MCAST: MsgFlag MSG_MORE: MsgFlag MSG_NOSIGNAL: MsgFlag MSG_NOTIFICATION: MsgFlag MSG_OOB: MsgFlag MSG_PEEK: MsgFlag MSG_TRUNC: MsgFlag MSG_WAITALL: MsgFlag NI_DGRAM: int NI_MAXHOST: int NI_MAXSERV: int NI_NAMEREQD: int NI_NOFQDN: int NI_NUMERICHOST: int NI_NUMERICSERV: int SCM_CREDENTIALS: int SCM_CREDS: int SCM_RIGHTS: int SHUT_RD: int SHUT_RDWR: int SHUT_WR: int SOL_ATALK: int SOL_AX25: int SOL_HCI: int SOL_IP: int SOL_IPX: int SOL_NETROM: int SOL_ROSE: int SOL_SOCKET: int SOL_TCP: int SOL_UDP: int SO_ACCEPTCONN: int SO_BINDTODEVICE: int SO_BROADCAST: int SO_DEBUG: int SO_DONTROUTE: int SO_ERROR: int SO_EXCLUSIVEADDRUSE: int SO_KEEPALIVE: int SO_LINGER: int SO_MARK: int SO_OOBINLINE: int SO_PASSCRED: int SO_PEERCRED: int SO_PRIORITY: int SO_RCVBUF: int SO_RCVLOWAT: int SO_RCVTIMEO: int SO_REUSEADDR: int SO_REUSEPORT: int SO_SETFIB: int SO_SNDBUF: int SO_SNDLOWAT: int SO_SNDTIMEO: int SO_TYPE: int SO_USELOOPBACK: int TCP_CORK: int TCP_DEFER_ACCEPT: int TCP_FASTOPEN: int TCP_INFO: int TCP_KEEPCNT: int TCP_KEEPIDLE: int TCP_KEEPINTVL: int TCP_LINGER2: int TCP_MAXSEG: int TCP_NODELAY: int TCP_QUICKACK: int TCP_SYNCNT: int TCP_WINDOW_CLAMP: int if sys.version_info >= (3, 7): TCP_NOTSENT_LOWAT: int # Specifically-documented constants if sys.platform == "linux" and sys.version_info >= (3,): AF_CAN: AddressFamily PF_CAN: int SOL_CAN_BASE: int SOL_CAN_RAW: int CAN_EFF_FLAG: int CAN_EFF_MASK: int CAN_ERR_FLAG: int CAN_ERR_MASK: int CAN_RAW: int CAN_RAW_ERR_FILTER: int CAN_RAW_FILTER: int CAN_RAW_LOOPBACK: int CAN_RAW_RECV_OWN_MSGS: int CAN_RTR_FLAG: int CAN_SFF_MASK: int CAN_BCM: int CAN_BCM_TX_SETUP: int CAN_BCM_TX_DELETE: int CAN_BCM_TX_READ: int CAN_BCM_TX_SEND: int CAN_BCM_RX_SETUP: int CAN_BCM_RX_DELETE: int CAN_BCM_RX_READ: int CAN_BCM_TX_STATUS: int CAN_BCM_TX_EXPIRED: int CAN_BCM_RX_STATUS: int CAN_BCM_RX_TIMEOUT: int CAN_BCM_RX_CHANGED: int CAN_RAW_FD_FRAMES: int if sys.platform == "linux" and sys.version_info >= (3, 8): CAN_BCM_SETTIMER: int CAN_BCM_STARTTIMER: int CAN_BCM_TX_COUNTEVT: int CAN_BCM_TX_ANNOUNCE: int CAN_BCM_TX_CP_CAN_ID: int CAN_BCM_RX_FILTER_ID: int CAN_BCM_RX_CHECK_DLC: int CAN_BCM_RX_NO_AUTOTIMER: int CAN_BCM_RX_ANNOUNCE_RESUME: int CAN_BCM_TX_RESET_MULTI_IDX: int CAN_BCM_RX_RTR_FRAME: int CAN_BCM_CAN_FD_FRAME: int if sys.platform == "linux" and sys.version_info >= (3, 7): CAN_ISOTP: int if sys.platform == "linux" and sys.version_info >= (3, 9): CAN_J1939: int J1939_MAX_UNICAST_ADDR: int J1939_IDLE_ADDR: int J1939_NO_ADDR: int J1939_NO_NAME: int J1939_PGN_REQUEST: int J1939_PGN_ADDRESS_CLAIMED: int J1939_PGN_ADDRESS_COMMANDED: int J1939_PGN_PDU1_MAX: int J1939_PGN_MAX: int J1939_NO_PGN: int SO_J1939_FILTER: int SO_J1939_PROMISC: int SO_J1939_SEND_PRIO: int SO_J1939_ERRQUEUE: int SCM_J1939_DEST_ADDR: int SCM_J1939_DEST_NAME: int SCM_J1939_PRIO: int SCM_J1939_ERRQUEUE: int J1939_NLA_PAD: int J1939_NLA_BYTES_ACKED: int J1939_EE_INFO_NONE: int J1939_EE_INFO_TX_ABORT: int J1939_FILTER_MAX: int if sys.platform == "linux": AF_PACKET: AddressFamily PF_PACKET: int PACKET_BROADCAST: int PACKET_FASTROUTE: int PACKET_HOST: int PACKET_LOOPBACK: int PACKET_MULTICAST: int PACKET_OTHERHOST: int PACKET_OUTGOING: int if sys.platform == "linux" and sys.version_info >= (3,): AF_RDS: AddressFamily PF_RDS: int SOL_RDS: int RDS_CANCEL_SENT_TO: int RDS_CMSG_RDMA_ARGS: int RDS_CMSG_RDMA_DEST: int RDS_CMSG_RDMA_MAP: int RDS_CMSG_RDMA_STATUS: int RDS_CMSG_RDMA_UPDATE: int RDS_CONG_MONITOR: int RDS_FREE_MR: int RDS_GET_MR: int RDS_GET_MR_FOR_DEST: int RDS_RDMA_DONTWAIT: int RDS_RDMA_FENCE: int RDS_RDMA_INVALIDATE: int RDS_RDMA_NOTIFY_ME: int RDS_RDMA_READWRITE: int RDS_RDMA_SILENT: int RDS_RDMA_USE_ONCE: int RDS_RECVERR: int if sys.platform == "win32": SIO_RCVALL: int SIO_KEEPALIVE_VALS: int if sys.version_info >= (3, 6): SIO_LOOPBACK_FAST_PATH: int RCVALL_IPLEVEL: int RCVALL_MAX: int RCVALL_OFF: int RCVALL_ON: int RCVALL_SOCKETLEVELONLY: int if sys.platform == "linux": AF_TIPC: AddressFamily SOL_TIPC: int TIPC_ADDR_ID: int TIPC_ADDR_NAME: int TIPC_ADDR_NAMESEQ: int TIPC_CFG_SRV: int TIPC_CLUSTER_SCOPE: int TIPC_CONN_TIMEOUT: int TIPC_CRITICAL_IMPORTANCE: int TIPC_DEST_DROPPABLE: int TIPC_HIGH_IMPORTANCE: int TIPC_IMPORTANCE: int TIPC_LOW_IMPORTANCE: int TIPC_MEDIUM_IMPORTANCE: int TIPC_NODE_SCOPE: int TIPC_PUBLISHED: int TIPC_SRC_DROPPABLE: int TIPC_SUBSCR_TIMEOUT: int TIPC_SUB_CANCEL: int TIPC_SUB_PORTS: int TIPC_SUB_SERVICE: int TIPC_TOP_SRV: int TIPC_WAIT_FOREVER: int TIPC_WITHDRAWN: int TIPC_ZONE_SCOPE: int if sys.platform == "linux" and sys.version_info >= (3, 6): AF_ALG: AddressFamily SOL_ALG: int ALG_OP_DECRYPT: int ALG_OP_ENCRYPT: int ALG_OP_SIGN: int ALG_OP_VERIFY: int ALG_SET_AEAD_ASSOCLEN: int ALG_SET_AEAD_AUTHSIZE: int ALG_SET_IV: int ALG_SET_KEY: int ALG_SET_OP: int ALG_SET_PUBKEY: int if sys.platform == "linux" and sys.version_info >= (3, 7): AF_VSOCK: AddressFamily IOCTL_VM_SOCKETS_GET_LOCAL_CID: int VMADDR_CID_ANY: int VMADDR_CID_HOST: int VMADDR_PORT_ANY: int SO_VM_SOCKETS_BUFFER_MAX_SIZE: int SO_VM_SOCKETS_BUFFER_SIZE: int SO_VM_SOCKETS_BUFFER_MIN_SIZE: int VM_SOCKETS_INVALID_VERSION: int AF_LINK: AddressFamily # Availability: BSD, macOS # BDADDR_* and HCI_* listed with other bluetooth constants below if sys.version_info >= (3, 6): SO_DOMAIN: int SO_PASSSEC: int SO_PEERSEC: int SO_PROTOCOL: int TCP_CONGESTION: int TCP_USER_TIMEOUT: int if sys.platform == "linux" and sys.version_info >= (3, 8): AF_QIPCRTR: AddressFamily # Semi-documented constants # (Listed under "Socket families" in the docs, but not "Constants") if sys.platform == "linux": # Netlink is defined by Linux AF_NETLINK: AddressFamily NETLINK_ARPD: int NETLINK_CRYPTO: int NETLINK_DNRTMSG: int NETLINK_FIREWALL: int NETLINK_IP6_FW: int NETLINK_NFLOG: int NETLINK_ROUTE6: int NETLINK_ROUTE: int NETLINK_SKIP: int NETLINK_TAPBASE: int NETLINK_TCPDIAG: int NETLINK_USERSOCK: int NETLINK_W1: int NETLINK_XFRM: int if sys.platform != "win32" and sys.platform != "darwin": # Linux and some BSD support is explicit in the docs # Windows and macOS do not support in practice AF_BLUETOOTH: AddressFamily BTPROTO_HCI: int BTPROTO_L2CAP: int BTPROTO_RFCOMM: int BTPROTO_SCO: int # not in FreeBSD BDADDR_ANY: str BDADDR_LOCAL: str HCI_FILTER: int # not in NetBSD or DragonFlyBSD # not in FreeBSD, NetBSD, or DragonFlyBSD HCI_TIME_STAMP: int HCI_DATA_DIR: int if sys.platform == "darwin": # PF_SYSTEM is defined by macOS PF_SYSTEM: int SYSPROTO_CONTROL: int # enum versions of above flags if sys.version_info >= (3, 4): from enum import IntEnum class AddressFamily(IntEnum): AF_UNIX: int AF_INET: int AF_INET6: int AF_AAL5: int AF_ALG: int AF_APPLETALK: int AF_ASH: int AF_ATMPVC: int AF_ATMSVC: int AF_AX25: int AF_BLUETOOTH: int AF_BRIDGE: int AF_CAN: int AF_DECnet: int AF_ECONET: int AF_IPX: int AF_IRDA: int AF_KEY: int AF_LINK: int AF_LLC: int AF_NETBEUI: int AF_NETLINK: int AF_NETROM: int AF_PACKET: int AF_PPPOX: int AF_QIPCRTR: int AF_RDS: int AF_ROSE: int AF_ROUTE: int AF_SECURITY: int AF_SNA: int AF_SYSTEM: int AF_TIPC: int AF_UNSPEC: int AF_VSOCK: int AF_WANPIPE: int AF_X25: int class SocketKind(IntEnum): SOCK_STREAM: int SOCK_DGRAM: int SOCK_RAW: int SOCK_RDM: int SOCK_SEQPACKET: int SOCK_CLOEXEC: int SOCK_NONBLOCK: int else: AddressFamily = int SocketKind = int if sys.version_info >= (3, 6): from enum import IntFlag class AddressInfo(IntFlag): AI_ADDRCONFIG: int AI_ALL: int AI_CANONNAME: int AI_NUMERICHOST: int AI_NUMERICSERV: int AI_PASSIVE: int AI_V4MAPPED: int class MsgFlag(IntFlag): MSG_CTRUNC: int MSG_DONTROUTE: int MSG_DONTWAIT: int MSG_EOR: int MSG_OOB: int MSG_PEEK: int MSG_TRUNC: int MSG_WAITALL: int else: AddressInfo = int MsgFlag = int # ----- Exceptions ----- if sys.version_info < (3,): class error(IOError): ... else: error = OSError class herror(error): def __init__(self, herror: int = ..., string: str = ...) -> None: ... class gaierror(error): def __init__(self, error: int = ..., string: str = ...) -> None: ... class timeout(error): def __init__(self, error: int = ..., string: str = ...) -> None: ... # ----- Classes ----- # Addresses can be either tuples of varying lengths (AF_INET, AF_INET6, # AF_NETLINK, AF_TIPC) or strings (AF_UNIX). _Address = Union[tuple, str] _RetAddress = Any # TODO Most methods allow bytes as address objects _WriteBuffer = Union[bytearray, memoryview] _CMSG = Tuple[int, int, bytes] _SelfT = TypeVar("_SelfT", bound=socket) class socket: family: int type: int proto: int if sys.version_info < (3,): def __init__(self, family: int = ..., type: int = ..., proto: int = ...) -> None: ... else: def __init__(self, family: int = ..., type: int = ..., proto: int = ..., fileno: Optional[int] = ...) -> None: ... def __enter__(self: _SelfT) -> _SelfT: ... def __exit__(self, *args: Any) -> None: ... # --- methods --- def accept(self) -> Tuple[socket, _RetAddress]: ... def bind(self, address: Union[_Address, bytes]) -> None: ... def close(self) -> None: ... def connect(self, address: Union[_Address, bytes]) -> None: ... def connect_ex(self, address: Union[_Address, bytes]) -> int: ... def detach(self) -> int: ... def dup(self) -> socket: ... def fileno(self) -> int: ... if sys.version_info >= (3, 4): def get_inheritable(self) -> bool: ... def getpeername(self) -> _RetAddress: ... def getsockname(self) -> _RetAddress: ... @overload def getsockopt(self, level: int, optname: int) -> int: ... @overload def getsockopt(self, level: int, optname: int, buflen: int) -> bytes: ... if sys.version_info >= (3, 7): def getblocking(self) -> bool: ... def gettimeout(self) -> Optional[float]: ... if sys.platform == "win32" and sys.version_info >= (3, 6): def ioctl(self, control: int, option: Union[int, Tuple[int, int, int], bool]) -> None: ... elif sys.platform == "win32": def ioctl(self, control: int, option: Union[int, Tuple[int, int, int]]) -> None: ... if sys.version_info >= (3, 5): def listen(self, __backlog: int = ...) -> None: ... else: def listen(self, __backlog: int) -> None: ... # Note that the makefile's documented windows-specific behavior is not represented if sys.version_info >= (3,): # mode strings with duplicates are intentionally excluded @overload def makefile( self, mode: Literal["r", "w", "rw", "wr", ""] = ..., buffering: Optional[int] = ..., *, encoding: Optional[str] = ..., errors: Optional[str] = ..., newline: Optional[str] = ..., ) -> TextIO: ... @overload def makefile( self, mode: Literal["b", "rb", "br", "wb", "bw", "rwb", "rbw", "wrb", "wbr", "brw", "bwr"], buffering: Optional[int] = ..., *, encoding: Optional[str] = ..., errors: Optional[str] = ..., newline: Optional[str] = ..., ) -> BinaryIO: ... else: def makefile(self, mode: unicode = ..., buffering: int = ...) -> BinaryIO: ... def recv(self, bufsize: int, flags: int = ...) -> bytes: ... def recvfrom(self, bufsize: int, flags: int = ...) -> Tuple[bytes, _RetAddress]: ... if sys.version_info >= (3, 3) and sys.platform != "win32": def recvmsg(self, __bufsize: int, __ancbufsize: int = ..., __flags: int = ...) -> Tuple[bytes, List[_CMSG], int, Any]: ... def recvmsg_into( self, __buffers: Iterable[_WriteBuffer], __ancbufsize: int = ..., __flags: int = ... ) -> Tuple[int, List[_CMSG], int, Any]: ... def recvfrom_into(self, buffer: _WriteBuffer, nbytes: int = ..., flags: int = ...) -> Tuple[int, _RetAddress]: ... def recv_into(self, buffer: _WriteBuffer, nbytes: int = ..., flags: int = ...) -> int: ... def send(self, data: bytes, flags: int = ...) -> int: ... def sendall(self, data: bytes, flags: int = ...) -> None: ... # return type: None on success @overload def sendto(self, data: bytes, address: _Address) -> int: ... @overload def sendto(self, data: bytes, flags: int, address: _Address) -> int: ... if sys.version_info >= (3, 3) and sys.platform != "win32": def sendmsg( self, __buffers: Iterable[bytes], __ancdata: Iterable[_CMSG] = ..., __flags: int = ..., __address: _Address = ... ) -> int: ... if sys.platform == "linux" and sys.version_info >= (3, 6): def sendmsg_afalg( self, msg: Iterable[bytes] = ..., *, op: int, iv: Any = ..., assoclen: int = ..., flags: int = ... ) -> int: ... if sys.version_info >= (3,): def sendfile(self, file: BinaryIO, offset: int = ..., count: Optional[int] = ...) -> int: ... def set_inheritable(self, inheritable: bool) -> None: ... def setblocking(self, flag: bool) -> None: ... def settimeout(self, value: Optional[float]) -> None: ... if sys.version_info < (3, 6): def setsockopt(self, level: int, optname: int, value: Union[int, bytes]) -> None: ... else: @overload def setsockopt(self, level: int, optname: int, value: Union[int, bytes]) -> None: ... @overload def setsockopt(self, level: int, optname: int, value: None, optlen: int) -> None: ... if sys.platform == "win32": def share(self, process_id: int) -> bytes: ... def shutdown(self, how: int) -> None: ... # ----- Functions ----- if sys.version_info >= (3, 7): def close(fd: int) -> None: ... def create_connection( address: Tuple[Optional[str], int], timeout: Optional[float] = ..., source_address: Optional[Tuple[Union[bytearray, bytes, Text], int]] = ..., ) -> socket: ... if sys.version_info >= (3, 8): def create_server( address: _Address, *, family: int = ..., backlog: Optional[int] = ..., reuse_port: bool = ..., dualstack_ipv6: bool = ... ) -> socket: ... def has_dualstack_ipv6() -> bool: ... def fromfd(fd: int, family: int, type: int, proto: int = ...) -> socket: ... if sys.platform == "win32" and sys.version_info >= (3, 3): def fromshare(info: bytes) -> socket: ... # the 5th tuple item is an address if sys.version_info >= (3,): def getaddrinfo( host: Optional[Union[bytearray, bytes, Text]], port: Union[str, int, None], family: int = ..., type: int = ..., proto: int = ..., flags: int = ..., ) -> List[Tuple[AddressFamily, SocketKind, int, str, Union[Tuple[str, int], Tuple[str, int, int, int]]]]: ... else: def getaddrinfo( host: Optional[Union[bytearray, bytes, Text]], port: Union[str, int, None], family: int = ..., socktype: int = ..., proto: int = ..., flags: int = ..., ) -> List[Tuple[AddressFamily, SocketKind, int, str, Tuple[Any, ...]]]: ... def getfqdn(name: str = ...) -> str: ... def gethostbyname(hostname: str) -> str: ... def gethostbyname_ex(hostname: str) -> Tuple[str, List[str], List[str]]: ... def gethostname() -> str: ... def gethostbyaddr(ip_address: str) -> Tuple[str, List[str], List[str]]: ... def getnameinfo(sockaddr: Union[Tuple[str, int], Tuple[str, int, int, int]], flags: int) -> Tuple[str, str]: ... def getprotobyname(protocolname: str) -> int: ... def getservbyname(servicename: str, protocolname: str = ...) -> int: ... def getservbyport(port: int, protocolname: str = ...) -> str: ... def socketpair(family: int = ..., type: int = ..., proto: int = ...) -> Tuple[socket, socket]: ... def ntohl(x: int) -> int: ... # param & ret val are 32-bit ints def ntohs(x: int) -> int: ... # param & ret val are 16-bit ints def htonl(x: int) -> int: ... # param & ret val are 32-bit ints def htons(x: int) -> int: ... # param & ret val are 16-bit ints def inet_aton(ip_string: str) -> bytes: ... # ret val 4 bytes in length def inet_ntoa(packed_ip: bytes) -> str: ... def inet_pton(address_family: int, ip_string: str) -> bytes: ... def inet_ntop(address_family: int, packed_ip: bytes) -> str: ... if sys.version_info >= (3, 9): if sys.platform != "win32": # flags and address appear to be unused in send_fds and recv_fds def send_fds( sock: socket, buffers: Iterable[bytes], fds: Union[bytes, Iterable[int]], flags: int = ..., address: None = ... ) -> int: ... def recv_fds(sock: socket, bufsize: int, maxfds: int, flags: int = ...) -> Tuple[bytes, List[int], int, Any]: ... if sys.version_info >= (3, 3): def CMSG_LEN(length: int) -> int: ... def CMSG_SPACE(length: int) -> int: ... def getdefaulttimeout() -> Optional[float]: ... def setdefaulttimeout(timeout: Optional[float]) -> None: ... if sys.version_info >= (3, 3): if sys.platform != "win32": def sethostname(name: str) -> None: ... # Windows added these in 3.8, but didn't have them before if sys.platform != "win32" or sys.version_info >= (3, 8): def if_nameindex() -> List[Tuple[int, str]]: ... def if_nametoindex(name: str) -> int: ... def if_indextoname(index: int) -> str: ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4223793 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/sqlite3/0000775000175000017500000000000000000000000023245 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/sqlite3/__init__.pyi0000664000175000017500000000005300000000000025525 0ustar00davedave00000000000000from sqlite3.dbapi2 import * # noqa: F403 ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/sqlite3/dbapi2.pyi0000664000175000017500000002606300000000000025140 0ustar00davedave00000000000000import os import sys from datetime import date, datetime, time from typing import Any, Callable, Generator, Iterable, Iterator, List, Optional, Text, Tuple, Type, TypeVar, Union _T = TypeVar("_T") paramstyle: str threadsafety: int apilevel: str Date = date Time = time Timestamp = datetime def DateFromTicks(ticks: float) -> Date: ... def TimeFromTicks(ticks: float) -> Time: ... def TimestampFromTicks(ticks: float) -> Timestamp: ... version_info: str sqlite_version_info: Tuple[int, int, int] if sys.version_info >= (3,): Binary = memoryview else: Binary = buffer # The remaining definitions are imported from _sqlite3. PARSE_COLNAMES: int PARSE_DECLTYPES: int SQLITE_ALTER_TABLE: int SQLITE_ANALYZE: int SQLITE_ATTACH: int SQLITE_CREATE_INDEX: int SQLITE_CREATE_TABLE: int SQLITE_CREATE_TEMP_INDEX: int SQLITE_CREATE_TEMP_TABLE: int SQLITE_CREATE_TEMP_TRIGGER: int SQLITE_CREATE_TEMP_VIEW: int SQLITE_CREATE_TRIGGER: int SQLITE_CREATE_VIEW: int SQLITE_DELETE: int SQLITE_DENY: int SQLITE_DETACH: int SQLITE_DROP_INDEX: int SQLITE_DROP_TABLE: int SQLITE_DROP_TEMP_INDEX: int SQLITE_DROP_TEMP_TABLE: int SQLITE_DROP_TEMP_TRIGGER: int SQLITE_DROP_TEMP_VIEW: int SQLITE_DROP_TRIGGER: int SQLITE_DROP_VIEW: int SQLITE_IGNORE: int SQLITE_INSERT: int SQLITE_OK: int SQLITE_PRAGMA: int SQLITE_READ: int SQLITE_REINDEX: int SQLITE_SELECT: int SQLITE_TRANSACTION: int SQLITE_UPDATE: int adapters: Any converters: Any sqlite_version: str version: str # TODO: adapt needs to get probed def adapt(obj, protocol, alternate): ... def complete_statement(sql: str) -> bool: ... if sys.version_info >= (3, 7): def connect( database: Union[bytes, Text, os.PathLike[Text]], timeout: float = ..., detect_types: int = ..., isolation_level: Optional[str] = ..., check_same_thread: bool = ..., factory: Optional[Type[Connection]] = ..., cached_statements: int = ..., uri: bool = ..., ) -> Connection: ... elif sys.version_info >= (3, 4): def connect( database: Union[bytes, Text], timeout: float = ..., detect_types: int = ..., isolation_level: Optional[str] = ..., check_same_thread: bool = ..., factory: Optional[Type[Connection]] = ..., cached_statements: int = ..., uri: bool = ..., ) -> Connection: ... else: def connect( database: Union[bytes, Text], timeout: float = ..., detect_types: int = ..., isolation_level: Optional[str] = ..., check_same_thread: bool = ..., factory: Optional[Type[Connection]] = ..., cached_statements: int = ..., ) -> Connection: ... def enable_callback_tracebacks(flag: bool) -> None: ... def enable_shared_cache(do_enable: int) -> None: ... def register_adapter(type: Type[_T], callable: Callable[[_T], Union[int, float, str, bytes]]) -> None: ... def register_converter(typename: str, callable: Callable[[bytes], Any]) -> None: ... if sys.version_info < (3, 8): class Cache(object): def __init__(self, *args, **kwargs) -> None: ... def display(self, *args, **kwargs) -> None: ... def get(self, *args, **kwargs) -> None: ... class Connection(object): DataError: Any DatabaseError: Any Error: Any IntegrityError: Any InterfaceError: Any InternalError: Any NotSupportedError: Any OperationalError: Any ProgrammingError: Any Warning: Any in_transaction: Any isolation_level: Any row_factory: Any text_factory: Any total_changes: Any def __init__(self, *args: Any, **kwargs: Any) -> None: ... def close(self) -> None: ... def commit(self) -> None: ... def create_aggregate(self, name: str, num_params: int, aggregate_class: type) -> None: ... def create_collation(self, name: str, callable: Any) -> None: ... if sys.version_info >= (3, 8): def create_function(self, name: str, num_params: int, func: Any, *, deterministic: bool = ...) -> None: ... else: def create_function(self, name: str, num_params: int, func: Any) -> None: ... def cursor(self, cursorClass: Optional[type] = ...) -> Cursor: ... def execute(self, sql: str, parameters: Iterable[Any] = ...) -> Cursor: ... # TODO: please check in executemany() if seq_of_parameters type is possible like this def executemany(self, sql: str, seq_of_parameters: Iterable[Iterable[Any]]) -> Cursor: ... def executescript(self, sql_script: Union[bytes, Text]) -> Cursor: ... def interrupt(self, *args: Any, **kwargs: Any) -> None: ... def iterdump(self, *args: Any, **kwargs: Any) -> Generator[str, None, None]: ... def rollback(self, *args: Any, **kwargs: Any) -> None: ... # TODO: set_authorizer(authorzer_callback) # see https://docs.python.org/2/library/sqlite3.html#sqlite3.Connection.set_authorizer # returns [SQLITE_OK, SQLITE_DENY, SQLITE_IGNORE] so perhaps int def set_authorizer(self, *args: Any, **kwargs: Any) -> None: ... # set_progress_handler(handler, n) -> see https://docs.python.org/2/library/sqlite3.html#sqlite3.Connection.set_progress_handler def set_progress_handler(self, *args: Any, **kwargs: Any) -> None: ... def set_trace_callback(self, *args: Any, **kwargs: Any) -> None: ... # enable_load_extension and load_extension is not available on python distributions compiled # without sqlite3 loadable extension support. see footnotes https://docs.python.org/3/library/sqlite3.html#f1 def enable_load_extension(self, enabled: bool) -> None: ... def load_extension(self, path: str) -> None: ... if sys.version_info >= (3, 7): def backup( self, target: Connection, *, pages: int = ..., progress: Optional[Callable[[int, int, int], object]] = ..., name: str = ..., sleep: float = ..., ) -> None: ... def __call__(self, *args: Any, **kwargs: Any) -> Any: ... def __enter__(self) -> Connection: ... def __exit__(self, t: Optional[type] = ..., exc: Optional[BaseException] = ..., tb: Optional[Any] = ...) -> None: ... class Cursor(Iterator[Any]): arraysize: Any connection: Any description: Any lastrowid: Any row_factory: Any rowcount: Any # TODO: Cursor class accepts exactly 1 argument # required type is sqlite3.Connection (which is imported as _Connection) # however, the name of the __init__ variable is unknown def __init__(self, *args: Any, **kwargs: Any) -> None: ... def close(self, *args: Any, **kwargs: Any) -> None: ... def execute(self, sql: str, parameters: Iterable[Any] = ...) -> Cursor: ... def executemany(self, sql: str, seq_of_parameters: Iterable[Iterable[Any]]) -> Cursor: ... def executescript(self, sql_script: Union[bytes, Text]) -> Cursor: ... def fetchall(self) -> List[Any]: ... def fetchmany(self, size: Optional[int] = ...) -> List[Any]: ... def fetchone(self) -> Any: ... def setinputsizes(self, *args: Any, **kwargs: Any) -> None: ... def setoutputsize(self, *args: Any, **kwargs: Any) -> None: ... def __iter__(self) -> Cursor: ... if sys.version_info >= (3, 0): def __next__(self) -> Any: ... else: def next(self) -> Any: ... class DataError(DatabaseError): ... class DatabaseError(Error): ... class Error(Exception): ... class IntegrityError(DatabaseError): ... class InterfaceError(Error): ... class InternalError(DatabaseError): ... class NotSupportedError(DatabaseError): ... class OperationalError(DatabaseError): ... if sys.version_info >= (3,): OptimizedUnicode = str else: class OptimizedUnicode(object): maketrans: Any def __init__(self, *args, **kwargs): ... def capitalize(self, *args, **kwargs): ... def casefold(self, *args, **kwargs): ... def center(self, *args, **kwargs): ... def count(self, *args, **kwargs): ... def encode(self, *args, **kwargs): ... def endswith(self, *args, **kwargs): ... def expandtabs(self, *args, **kwargs): ... def find(self, *args, **kwargs): ... def format(self, *args, **kwargs): ... def format_map(self, *args, **kwargs): ... def index(self, *args, **kwargs): ... def isalnum(self, *args, **kwargs): ... def isalpha(self, *args, **kwargs): ... def isdecimal(self, *args, **kwargs): ... def isdigit(self, *args, **kwargs): ... def isidentifier(self, *args, **kwargs): ... def islower(self, *args, **kwargs): ... def isnumeric(self, *args, **kwargs): ... def isprintable(self, *args, **kwargs): ... def isspace(self, *args, **kwargs): ... def istitle(self, *args, **kwargs): ... def isupper(self, *args, **kwargs): ... def join(self, *args, **kwargs): ... def ljust(self, *args, **kwargs): ... def lower(self, *args, **kwargs): ... def lstrip(self, *args, **kwargs): ... def partition(self, *args, **kwargs): ... def replace(self, *args, **kwargs): ... def rfind(self, *args, **kwargs): ... def rindex(self, *args, **kwargs): ... def rjust(self, *args, **kwargs): ... def rpartition(self, *args, **kwargs): ... def rsplit(self, *args, **kwargs): ... def rstrip(self, *args, **kwargs): ... def split(self, *args, **kwargs): ... def splitlines(self, *args, **kwargs): ... def startswith(self, *args, **kwargs): ... def strip(self, *args, **kwargs): ... def swapcase(self, *args, **kwargs): ... def title(self, *args, **kwargs): ... def translate(self, *args, **kwargs): ... def upper(self, *args, **kwargs): ... def zfill(self, *args, **kwargs): ... def __add__(self, other): ... def __contains__(self, *args, **kwargs): ... def __eq__(self, other): ... def __format__(self, *args, **kwargs): ... def __ge__(self, other): ... def __getitem__(self, index): ... def __getnewargs__(self, *args, **kwargs): ... def __gt__(self, other): ... def __hash__(self): ... def __iter__(self): ... def __le__(self, other): ... def __len__(self, *args, **kwargs): ... def __lt__(self, other): ... def __mod__(self, other): ... def __mul__(self, other): ... def __ne__(self, other): ... def __rmod__(self, other): ... def __rmul__(self, other): ... class PrepareProtocol(object): def __init__(self, *args: Any, **kwargs: Any) -> None: ... class ProgrammingError(DatabaseError): ... class Row(object): def __init__(self, *args: Any, **kwargs: Any) -> None: ... def keys(self, *args: Any, **kwargs: Any): ... def __eq__(self, other): ... def __ge__(self, other): ... def __getitem__(self, index): ... def __gt__(self, other): ... def __hash__(self): ... def __iter__(self): ... def __le__(self, other): ... def __len__(self, *args: Any, **kwargs: Any): ... def __lt__(self, other): ... def __ne__(self, other): ... if sys.version_info < (3, 8): class Statement(object): def __init__(self, *args, **kwargs): ... class Warning(Exception): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/sre_compile.pyi0000664000175000017500000000206100000000000024704 0ustar00davedave00000000000000import sys from sre_constants import ( SRE_FLAG_DEBUG as SRE_FLAG_DEBUG, SRE_FLAG_DOTALL as SRE_FLAG_DOTALL, SRE_FLAG_IGNORECASE as SRE_FLAG_IGNORECASE, SRE_FLAG_LOCALE as SRE_FLAG_LOCALE, SRE_FLAG_MULTILINE as SRE_FLAG_MULTILINE, SRE_FLAG_TEMPLATE as SRE_FLAG_TEMPLATE, SRE_FLAG_UNICODE as SRE_FLAG_UNICODE, SRE_FLAG_VERBOSE as SRE_FLAG_VERBOSE, SRE_INFO_CHARSET as SRE_INFO_CHARSET, SRE_INFO_LITERAL as SRE_INFO_LITERAL, SRE_INFO_PREFIX as SRE_INFO_PREFIX, ) from sre_parse import SubPattern from typing import Any, List, Pattern, Tuple, Type, Union if sys.version_info >= (3,): from sre_constants import SRE_FLAG_ASCII as SRE_FLAG_ASCII MAXCODE: int if sys.version_info < (3, 0): STRING_TYPES: Tuple[Type[str], Type[unicode]] _IsStringType = int else: from sre_constants import _NamedIntConstant def dis(code: List[_NamedIntConstant]) -> None: ... _IsStringType = bool def isstring(obj: Any) -> _IsStringType: ... def compile(p: Union[str, bytes, SubPattern], flags: int = ...) -> Pattern[Any]: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/ssl.pyi0000664000175000017500000003444200000000000023214 0ustar00davedave00000000000000import enum import socket import sys from _typeshed import StrPath from typing import Any, Callable, ClassVar, Dict, Iterable, List, NamedTuple, Optional, Set, Text, Tuple, Type, Union, overload from typing_extensions import Literal _PCTRTT = Tuple[Tuple[str, str], ...] _PCTRTTT = Tuple[_PCTRTT, ...] _PeerCertRetDictType = Dict[str, Union[str, _PCTRTTT, _PCTRTT]] _PeerCertRetType = Union[_PeerCertRetDictType, bytes, None] _EnumRetType = List[Tuple[bytes, str, Union[Set[str], bool]]] _PasswordType = Union[Callable[[], Union[str, bytes]], str, bytes] if sys.version_info >= (3, 5): _SC1ArgT = Union[SSLSocket, SSLObject] else: _SC1ArgT = SSLSocket _SrvnmeCbType = Callable[[_SC1ArgT, Optional[str], SSLSocket], Optional[int]] class SSLError(OSError): library: str reason: str class SSLZeroReturnError(SSLError): ... class SSLWantReadError(SSLError): ... class SSLWantWriteError(SSLError): ... class SSLSyscallError(SSLError): ... class SSLEOFError(SSLError): ... if sys.version_info >= (3, 7): class SSLCertVerificationError(SSLError, ValueError): verify_code: int verify_message: str CertificateError = SSLCertVerificationError else: class CertificateError(ValueError): ... def wrap_socket( sock: socket.socket, keyfile: Optional[str] = ..., certfile: Optional[str] = ..., server_side: bool = ..., cert_reqs: int = ..., ssl_version: int = ..., ca_certs: Optional[str] = ..., do_handshake_on_connect: bool = ..., suppress_ragged_eofs: bool = ..., ciphers: Optional[str] = ..., ) -> SSLSocket: ... def create_default_context( purpose: Any = ..., *, cafile: Optional[str] = ..., capath: Optional[str] = ..., cadata: Union[Text, bytes, None] = ... ) -> SSLContext: ... if sys.version_info >= (3, 7): def _create_unverified_context( protocol: int = ..., *, cert_reqs: int = ..., check_hostname: bool = ..., purpose: Any = ..., certfile: Optional[str] = ..., keyfile: Optional[str] = ..., cafile: Optional[str] = ..., capath: Optional[str] = ..., cadata: Union[Text, bytes, None] = ..., ) -> SSLContext: ... else: def _create_unverified_context( protocol: int = ..., *, cert_reqs: Optional[int] = ..., check_hostname: bool = ..., purpose: Any = ..., certfile: Optional[str] = ..., keyfile: Optional[str] = ..., cafile: Optional[str] = ..., capath: Optional[str] = ..., cadata: Union[Text, bytes, None] = ..., ) -> SSLContext: ... _create_default_https_context: Callable[..., SSLContext] if sys.version_info >= (3, 3): def RAND_bytes(__num: int) -> bytes: ... def RAND_pseudo_bytes(__num: int) -> Tuple[bytes, bool]: ... def RAND_status() -> bool: ... def RAND_egd(path: str) -> None: ... def RAND_add(__s: bytes, __entropy: float) -> None: ... def match_hostname(cert: _PeerCertRetType, hostname: str) -> None: ... def cert_time_to_seconds(cert_time: str) -> int: ... def get_server_certificate(addr: Tuple[str, int], ssl_version: int = ..., ca_certs: Optional[str] = ...) -> str: ... def DER_cert_to_PEM_cert(der_cert_bytes: bytes) -> str: ... def PEM_cert_to_DER_cert(pem_cert_string: str) -> bytes: ... class DefaultVerifyPaths(NamedTuple): cafile: str capath: str openssl_cafile_env: str openssl_cafile: str openssl_capath_env: str openssl_capath: str def get_default_verify_paths() -> DefaultVerifyPaths: ... if sys.platform == "win32": def enum_certificates(store_name: str) -> _EnumRetType: ... def enum_crls(store_name: str) -> _EnumRetType: ... CERT_NONE: int CERT_OPTIONAL: int CERT_REQUIRED: int VERIFY_DEFAULT: int VERIFY_CRL_CHECK_LEAF: int VERIFY_CRL_CHECK_CHAIN: int VERIFY_X509_STRICT: int VERIFY_X509_TRUSTED_FIRST: int PROTOCOL_SSLv23: int PROTOCOL_SSLv2: int PROTOCOL_SSLv3: int PROTOCOL_TLSv1: int PROTOCOL_TLSv1_1: int PROTOCOL_TLSv1_2: int PROTOCOL_TLS: int if sys.version_info >= (3, 6): PROTOCOL_TLS_CLIENT: int PROTOCOL_TLS_SERVER: int if sys.version_info >= (3, 6): class Options(enum.IntFlag): OP_ALL: int OP_NO_SSLv2: int OP_NO_SSLv3: int OP_NO_TLSv1: int OP_NO_TLSv1_1: int OP_NO_TLSv1_2: int OP_CIPHER_SERVER_PREFERENCE: int OP_SINGLE_DH_USE: int OP_SINGLE_ECDH_USE: int OP_NO_COMPRESSION: int OP_NO_TICKET: int if sys.version_info >= (3, 7): OP_NO_RENEGOTIATION: int OP_NO_TLSv1_3: int if sys.version_info >= (3, 8): OP_ENABLE_MIDDLEBOX_COMPAT: int OP_ALL: Options OP_NO_SSLv2: Options OP_NO_SSLv3: Options OP_NO_TLSv1: Options OP_NO_TLSv1_1: Options OP_NO_TLSv1_2: Options OP_CIPHER_SERVER_PREFERENCE: Options OP_SINGLE_DH_USE: Options OP_SINGLE_ECDH_USE: Options OP_NO_COMPRESSION: Options OP_NO_TICKET: Options if sys.version_info >= (3, 7): OP_NO_RENEGOTIATION: Options OP_NO_TLSv1_3: Options if sys.version_info >= (3, 8): OP_ENABLE_MIDDLEBOX_COMPAT: Options else: OP_ALL: int OP_NO_SSLv2: int OP_NO_SSLv3: int OP_NO_TLSv1: int OP_NO_TLSv1_1: int OP_NO_TLSv1_2: int OP_CIPHER_SERVER_PREFERENCE: int OP_SINGLE_DH_USE: int OP_SINGLE_ECDH_USE: int OP_NO_COMPRESSION: int if sys.version_info >= (3, 7): HAS_NEVER_CHECK_COMMON_NAME: bool HAS_SSLv2: bool HAS_SSLv3: bool HAS_TLSv1: bool HAS_TLSv1_1: bool HAS_TLSv1_2: bool HAS_TLSv1_3: bool HAS_ALPN: bool HAS_ECDH: bool HAS_SNI: bool HAS_NPN: bool CHANNEL_BINDING_TYPES: List[str] OPENSSL_VERSION: str OPENSSL_VERSION_INFO: Tuple[int, int, int, int, int] OPENSSL_VERSION_NUMBER: int ALERT_DESCRIPTION_HANDSHAKE_FAILURE: int ALERT_DESCRIPTION_INTERNAL_ERROR: int ALERT_DESCRIPTION_ACCESS_DENIED: int ALERT_DESCRIPTION_BAD_CERTIFICATE: int ALERT_DESCRIPTION_BAD_CERTIFICATE_HASH_VALUE: int ALERT_DESCRIPTION_BAD_CERTIFICATE_STATUS_RESPONSE: int ALERT_DESCRIPTION_BAD_RECORD_MAC: int ALERT_DESCRIPTION_CERTIFICATE_EXPIRED: int ALERT_DESCRIPTION_CERTIFICATE_REVOKED: int ALERT_DESCRIPTION_CERTIFICATE_UNKNOWN: int ALERT_DESCRIPTION_CERTIFICATE_UNOBTAINABLE: int ALERT_DESCRIPTION_CLOSE_NOTIFY: int ALERT_DESCRIPTION_DECODE_ERROR: int ALERT_DESCRIPTION_DECOMPRESSION_FAILURE: int ALERT_DESCRIPTION_DECRYPT_ERROR: int ALERT_DESCRIPTION_ILLEGAL_PARAMETER: int ALERT_DESCRIPTION_INSUFFICIENT_SECURITY: int ALERT_DESCRIPTION_NO_RENEGOTIATION: int ALERT_DESCRIPTION_PROTOCOL_VERSION: int ALERT_DESCRIPTION_RECORD_OVERFLOW: int ALERT_DESCRIPTION_UNEXPECTED_MESSAGE: int ALERT_DESCRIPTION_UNKNOWN_CA: int ALERT_DESCRIPTION_UNKNOWN_PSK_IDENTITY: int ALERT_DESCRIPTION_UNRECOGNIZED_NAME: int ALERT_DESCRIPTION_UNSUPPORTED_CERTIFICATE: int ALERT_DESCRIPTION_UNSUPPORTED_EXTENSION: int ALERT_DESCRIPTION_USER_CANCELLED: int class _ASN1Object(NamedTuple): nid: int shortname: str longname: str oid: str if sys.version_info < (3,): class Purpose(_ASN1Object): SERVER_AUTH: ClassVar[Purpose] CLIENT_AUTH: ClassVar[Purpose] else: class Purpose(_ASN1Object, enum.Enum): SERVER_AUTH: _ASN1Object CLIENT_AUTH: _ASN1Object class SSLSocket(socket.socket): context: SSLContext server_side: bool server_hostname: Optional[str] if sys.version_info >= (3, 6): session: Optional[SSLSession] session_reused: Optional[bool] def read(self, len: int = ..., buffer: Optional[bytearray] = ...) -> bytes: ... def write(self, data: bytes) -> int: ... def do_handshake(self, block: bool = ...) -> None: ... # block is undocumented @overload def getpeercert(self, binary_form: Literal[False] = ...) -> Optional[_PeerCertRetDictType]: ... @overload def getpeercert(self, binary_form: Literal[True]) -> Optional[bytes]: ... @overload def getpeercert(self, binary_form: bool) -> _PeerCertRetType: ... def cipher(self) -> Optional[Tuple[str, str, int]]: ... if sys.version_info >= (3, 5): def shared_ciphers(self) -> Optional[List[Tuple[str, str, int]]]: ... def compression(self) -> Optional[str]: ... def get_channel_binding(self, cb_type: str = ...) -> Optional[bytes]: ... def selected_alpn_protocol(self) -> Optional[str]: ... def selected_npn_protocol(self) -> Optional[str]: ... def accept(self) -> Tuple[SSLSocket, socket._RetAddress]: ... def unwrap(self) -> socket.socket: ... def version(self) -> Optional[str]: ... def pending(self) -> int: ... if sys.version_info >= (3, 8): def verify_client_post_handshake(self) -> None: ... if sys.version_info >= (3, 7): class TLSVersion(enum.IntEnum): MINIMUM_SUPPORTED: int MAXIMUM_SUPPORTED: int SSLv3: int TLSv1: int TLSv1_1: int TLSv1_2: int TLSv1_3: int class SSLContext: check_hostname: bool if sys.version_info >= (3, 6): options: Options else: options: int if sys.version_info >= (3, 8): post_handshake_auth: bool @property def protocol(self) -> int: ... verify_flags: int verify_mode: int if sys.version_info >= (3, 5): def __init__(self, protocol: int = ...) -> None: ... else: def __init__(self, protocol: int) -> None: ... def cert_store_stats(self) -> Dict[str, int]: ... def load_cert_chain( self, certfile: StrPath, keyfile: Optional[StrPath] = ..., password: Optional[_PasswordType] = ... ) -> None: ... def load_default_certs(self, purpose: Purpose = ...) -> None: ... def load_verify_locations( self, cafile: Optional[StrPath] = ..., capath: Optional[StrPath] = ..., cadata: Union[Text, bytes, None] = ... ) -> None: ... def get_ca_certs(self, binary_form: bool = ...) -> Union[List[_PeerCertRetDictType], List[bytes]]: ... def set_default_verify_paths(self) -> None: ... def set_ciphers(self, __cipherlist: str) -> None: ... def set_alpn_protocols(self, alpn_protocols: Iterable[str]) -> None: ... if sys.version_info >= (3, 7): sni_callback: Optional[Callable[[SSLObject, str, SSLContext], Union[None, int]]] sslobject_class: Type[SSLObject] def set_npn_protocols(self, npn_protocols: Iterable[str]) -> None: ... if sys.version_info >= (3, 7): def set_servername_callback(self, server_name_callback: Optional[_SrvnmeCbType]) -> None: ... else: def set_servername_callback(self, __method: Optional[_SrvnmeCbType]) -> None: ... def load_dh_params(self, __path: str) -> None: ... def set_ecdh_curve(self, __name: str) -> None: ... if sys.version_info >= (3, 6): def wrap_socket( self, sock: socket.socket, server_side: bool = ..., do_handshake_on_connect: bool = ..., suppress_ragged_eofs: bool = ..., server_hostname: Optional[str] = ..., session: Optional[SSLSession] = ..., ) -> SSLSocket: ... else: def wrap_socket( self, sock: socket.socket, server_side: bool = ..., do_handshake_on_connect: bool = ..., suppress_ragged_eofs: bool = ..., server_hostname: Optional[str] = ..., ) -> SSLSocket: ... if sys.version_info >= (3, 6): def wrap_bio( self, incoming: MemoryBIO, outgoing: MemoryBIO, server_side: bool = ..., server_hostname: Optional[str] = ..., session: Optional[SSLSession] = ..., ) -> SSLObject: ... elif sys.version_info >= (3, 5): def wrap_bio( self, incoming: MemoryBIO, outgoing: MemoryBIO, server_side: bool = ..., server_hostname: Optional[str] = ... ) -> SSLObject: ... def session_stats(self) -> Dict[str, int]: ... if sys.version_info >= (3, 7): hostname_checks_common_name: bool maximum_version: TLSVersion minimum_version: TLSVersion if sys.version_info >= (3, 5): class SSLObject: context: SSLContext server_side: bool server_hostname: Optional[str] if sys.version_info >= (3, 6): session: Optional[SSLSession] session_reused: bool def read(self, len: int = ..., buffer: Optional[bytearray] = ...) -> bytes: ... def write(self, data: bytes) -> int: ... @overload def getpeercert(self, binary_form: Literal[False] = ...) -> Optional[_PeerCertRetDictType]: ... @overload def getpeercert(self, binary_form: Literal[True]) -> Optional[bytes]: ... @overload def getpeercert(self, binary_form: bool) -> _PeerCertRetType: ... def selected_alpn_protocol(self) -> Optional[str]: ... def selected_npn_protocol(self) -> Optional[str]: ... def cipher(self) -> Optional[Tuple[str, str, int]]: ... def shared_ciphers(self) -> Optional[List[Tuple[str, str, int]]]: ... def compression(self) -> Optional[str]: ... def pending(self) -> int: ... def do_handshake(self) -> None: ... def unwrap(self) -> None: ... def version(self) -> Optional[str]: ... def get_channel_binding(self, cb_type: str = ...) -> Optional[bytes]: ... if sys.version_info >= (3, 8): def verify_client_post_handshake(self) -> None: ... class MemoryBIO: pending: int eof: bool def read(self, __size: int = ...) -> bytes: ... def write(self, __buf: bytes) -> int: ... def write_eof(self) -> None: ... if sys.version_info >= (3, 6): class SSLSession: id: bytes time: int timeout: int ticket_lifetime_hint: int has_ticket: bool class VerifyFlags(enum.IntFlag): VERIFY_DEFAULT: int VERIFY_CRL_CHECK_LEAF: int VERIFY_CRL_CHECK_CHAIN: int VERIFY_X509_STRICT: int VERIFY_X509_TRUSTED_FIRST: int class VerifyMode(enum.IntEnum): CERT_NONE: int CERT_OPTIONAL: int CERT_REQUIRED: int # TODO below documented in cpython but not in docs.python.org # taken from python 3.4 SSL_ERROR_EOF: int SSL_ERROR_INVALID_ERROR_CODE: int SSL_ERROR_SSL: int SSL_ERROR_SYSCALL: int SSL_ERROR_WANT_CONNECT: int SSL_ERROR_WANT_READ: int SSL_ERROR_WANT_WRITE: int SSL_ERROR_WANT_X509_LOOKUP: int SSL_ERROR_ZERO_RETURN: int def get_protocol_name(protocol_code: int) -> str: ... AF_INET: int PEM_FOOTER: str PEM_HEADER: str SOCK_STREAM: int SOL_SOCKET: int SO_TYPE: int ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/stringprep.pyi0000664000175000017500000000146100000000000024603 0ustar00davedave00000000000000from typing import Text def in_table_a1(code: Text) -> bool: ... def in_table_b1(code: Text) -> bool: ... def map_table_b3(code: Text) -> Text: ... def map_table_b2(a: Text) -> Text: ... def in_table_c11(code: Text) -> bool: ... def in_table_c12(code: Text) -> bool: ... def in_table_c11_c12(code: Text) -> bool: ... def in_table_c21(code: Text) -> bool: ... def in_table_c22(code: Text) -> bool: ... def in_table_c21_c22(code: Text) -> bool: ... def in_table_c3(code: Text) -> bool: ... def in_table_c4(code: Text) -> bool: ... def in_table_c5(code: Text) -> bool: ... def in_table_c6(code: Text) -> bool: ... def in_table_c7(code: Text) -> bool: ... def in_table_c8(code: Text) -> bool: ... def in_table_c9(code: Text) -> bool: ... def in_table_d1(code: Text) -> bool: ... def in_table_d2(code: Text) -> bool: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/struct.pyi0000664000175000017500000000304000000000000023725 0ustar00davedave00000000000000import sys from array import array from mmap import mmap from typing import Any, Iterator, Text, Tuple, Union class error(Exception): ... _FmtType = Union[bytes, Text] if sys.version_info >= (3,): _BufferType = Union[array[int], bytes, bytearray, memoryview, mmap] _WriteBufferType = Union[array, bytearray, memoryview, mmap] else: _BufferType = Union[array[int], bytes, bytearray, buffer, memoryview, mmap] _WriteBufferType = Union[array[Any], bytearray, buffer, memoryview, mmap] def pack(fmt: _FmtType, *v: Any) -> bytes: ... def pack_into(fmt: _FmtType, buffer: _WriteBufferType, offset: int, *v: Any) -> None: ... def unpack(__format: _FmtType, __buffer: _BufferType) -> Tuple[Any, ...]: ... def unpack_from(__format: _FmtType, buffer: _BufferType, offset: int = ...) -> Tuple[Any, ...]: ... if sys.version_info >= (3, 4): def iter_unpack(__format: _FmtType, __buffer: _BufferType) -> Iterator[Tuple[Any, ...]]: ... def calcsize(__format: _FmtType) -> int: ... class Struct: if sys.version_info >= (3, 7): format: str else: format: bytes size: int def __init__(self, format: _FmtType) -> None: ... def pack(self, *v: Any) -> bytes: ... def pack_into(self, buffer: _WriteBufferType, offset: int, *v: Any) -> None: ... def unpack(self, __buffer: _BufferType) -> Tuple[Any, ...]: ... def unpack_from(self, buffer: _BufferType, offset: int = ...) -> Tuple[Any, ...]: ... if sys.version_info >= (3, 4): def iter_unpack(self, __buffer: _BufferType) -> Iterator[Tuple[Any, ...]]: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/sunau.pyi0000664000175000017500000000601500000000000023541 0ustar00davedave00000000000000import sys from typing import IO, Any, NamedTuple, NoReturn, Optional, Text, Tuple, Union _File = Union[Text, IO[bytes]] class Error(Exception): ... AUDIO_FILE_MAGIC: int AUDIO_FILE_ENCODING_MULAW_8: int AUDIO_FILE_ENCODING_LINEAR_8: int AUDIO_FILE_ENCODING_LINEAR_16: int AUDIO_FILE_ENCODING_LINEAR_24: int AUDIO_FILE_ENCODING_LINEAR_32: int AUDIO_FILE_ENCODING_FLOAT: int AUDIO_FILE_ENCODING_DOUBLE: int AUDIO_FILE_ENCODING_ADPCM_G721: int AUDIO_FILE_ENCODING_ADPCM_G722: int AUDIO_FILE_ENCODING_ADPCM_G723_3: int AUDIO_FILE_ENCODING_ADPCM_G723_5: int AUDIO_FILE_ENCODING_ALAW_8: int AUDIO_UNKNOWN_SIZE: int if sys.version_info < (3, 0): _sunau_params = Tuple[int, int, int, int, str, str] else: class _sunau_params(NamedTuple): nchannels: int sampwidth: int framerate: int nframes: int comptype: str compname: str class Au_read: def __init__(self, f: _File) -> None: ... if sys.version_info >= (3, 3): def __enter__(self) -> Au_read: ... def __exit__(self, *args: Any) -> None: ... def getfp(self) -> Optional[IO[bytes]]: ... def rewind(self) -> None: ... def close(self) -> None: ... def tell(self) -> int: ... def getnchannels(self) -> int: ... def getnframes(self) -> int: ... def getsampwidth(self) -> int: ... def getframerate(self) -> int: ... def getcomptype(self) -> str: ... def getcompname(self) -> str: ... def getparams(self) -> _sunau_params: ... def getmarkers(self) -> None: ... def getmark(self, id: Any) -> NoReturn: ... def setpos(self, pos: int) -> None: ... def readframes(self, nframes: int) -> Optional[bytes]: ... class Au_write: def __init__(self, f: _File) -> None: ... if sys.version_info >= (3, 3): def __enter__(self) -> Au_write: ... def __exit__(self, *args: Any) -> None: ... def setnchannels(self, nchannels: int) -> None: ... def getnchannels(self) -> int: ... def setsampwidth(self, sampwidth: int) -> None: ... def getsampwidth(self) -> int: ... def setframerate(self, framerate: float) -> None: ... def getframerate(self) -> int: ... def setnframes(self, nframes: int) -> None: ... def getnframes(self) -> int: ... def setcomptype(self, comptype: str, compname: str) -> None: ... def getcomptype(self) -> str: ... def getcompname(self) -> str: ... def setparams(self, params: _sunau_params) -> None: ... def getparams(self) -> _sunau_params: ... def setmark(self, id: Any, pos: Any, name: Any) -> NoReturn: ... def getmark(self, id: Any) -> NoReturn: ... def getmarkers(self) -> None: ... def tell(self) -> int: ... # should be any bytes-like object after 3.4, but we don't have a type for that def writeframesraw(self, data: bytes) -> None: ... def writeframes(self, data: bytes) -> None: ... def close(self) -> None: ... # Returns a Au_read if mode is rb and Au_write if mode is wb def open(f: _File, mode: Optional[str] = ...) -> Any: ... if sys.version_info < (3, 9): openfp = open ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/symtable.pyi0000664000175000017500000000315500000000000024230 0ustar00davedave00000000000000import sys from typing import List, Sequence, Text, Tuple def symtable(code: Text, filename: Text, compile_type: Text) -> SymbolTable: ... class SymbolTable(object): def get_type(self) -> str: ... def get_id(self) -> int: ... def get_name(self) -> str: ... def get_lineno(self) -> int: ... def is_optimized(self) -> bool: ... def is_nested(self) -> bool: ... def has_children(self) -> bool: ... def has_exec(self) -> bool: ... if sys.version_info < (3, 0): def has_import_star(self) -> bool: ... def get_identifiers(self) -> Sequence[str]: ... def lookup(self, name: str) -> Symbol: ... def get_symbols(self) -> List[Symbol]: ... def get_children(self) -> List[SymbolTable]: ... class Function(SymbolTable): def get_parameters(self) -> Tuple[str, ...]: ... def get_locals(self) -> Tuple[str, ...]: ... def get_globals(self) -> Tuple[str, ...]: ... def get_frees(self) -> Tuple[str, ...]: ... class Class(SymbolTable): def get_methods(self) -> Tuple[str, ...]: ... class Symbol(object): def get_name(self) -> str: ... def is_referenced(self) -> bool: ... def is_parameter(self) -> bool: ... def is_global(self) -> bool: ... def is_declared_global(self) -> bool: ... def is_local(self) -> bool: ... if sys.version_info >= (3, 6): def is_annotated(self) -> bool: ... def is_free(self) -> bool: ... def is_imported(self) -> bool: ... def is_assigned(self) -> bool: ... def is_namespace(self) -> bool: ... def get_namespaces(self) -> Sequence[SymbolTable]: ... def get_namespace(self) -> SymbolTable: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/sysconfig.pyi0000664000175000017500000000151300000000000024410 0ustar00davedave00000000000000from typing import IO, Any, Dict, List, Optional, Tuple, overload def get_config_var(name: str) -> Optional[str]: ... @overload def get_config_vars() -> Dict[str, Any]: ... @overload def get_config_vars(arg: str, *args: str) -> List[Any]: ... def get_scheme_names() -> Tuple[str, ...]: ... def get_path_names() -> Tuple[str, ...]: ... def get_path(name: str, scheme: str = ..., vars: Optional[Dict[str, Any]] = ..., expand: bool = ...) -> Optional[str]: ... def get_paths(scheme: str = ..., vars: Optional[Dict[str, Any]] = ..., expand: bool = ...) -> Dict[str, str]: ... def get_python_version() -> str: ... def get_platform() -> str: ... def is_python_build() -> bool: ... def parse_config_h(fp: IO[Any], vars: Optional[Dict[str, Any]]) -> Dict[str, Any]: ... def get_config_h_filename() -> str: ... def get_makefile_filename() -> str: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/syslog.pyi0000664000175000017500000000146500000000000023732 0ustar00davedave00000000000000from typing import overload LOG_ALERT: int LOG_AUTH: int LOG_CONS: int LOG_CRIT: int LOG_CRON: int LOG_DAEMON: int LOG_DEBUG: int LOG_EMERG: int LOG_ERR: int LOG_INFO: int LOG_KERN: int LOG_LOCAL0: int LOG_LOCAL1: int LOG_LOCAL2: int LOG_LOCAL3: int LOG_LOCAL4: int LOG_LOCAL5: int LOG_LOCAL6: int LOG_LOCAL7: int LOG_LPR: int LOG_MAIL: int LOG_NDELAY: int LOG_NEWS: int LOG_NOTICE: int LOG_NOWAIT: int LOG_PERROR: int LOG_PID: int LOG_SYSLOG: int LOG_USER: int LOG_UUCP: int LOG_WARNING: int def LOG_MASK(a: int) -> int: ... def LOG_UPTO(a: int) -> int: ... def closelog() -> None: ... def openlog(ident: str = ..., logoption: int = ..., facility: int = ...) -> None: ... def setlogmask(x: int) -> int: ... @overload def syslog(priority: int, message: str) -> None: ... @overload def syslog(message: str) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/tabnanny.pyi0000664000175000017500000000067700000000000024230 0ustar00davedave00000000000000from _typeshed import AnyPath from typing import Iterable, Tuple verbose: int filename_only: int class NannyNag(Exception): def __init__(self, lineno: int, msg: str, line: str) -> None: ... def get_lineno(self) -> int: ... def get_msg(self) -> str: ... def get_line(self) -> str: ... def check(file: AnyPath) -> None: ... def process_tokens(tokens: Iterable[Tuple[int, str, Tuple[int, int], Tuple[int, int], str]]) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/tarfile.pyi0000664000175000017500000001776600000000000024053 0ustar00davedave00000000000000import sys from _typeshed import AnyPath, StrPath from types import TracebackType from typing import IO, Callable, Dict, Iterable, Iterator, List, Mapping, Optional, Set, Tuple, Type, Union # tar constants NUL: bytes BLOCKSIZE: int RECORDSIZE: int GNU_MAGIC: bytes POSIX_MAGIC: bytes LENGTH_NAME: int LENGTH_LINK: int LENGTH_PREFIX: int REGTYPE: bytes AREGTYPE: bytes LNKTYPE: bytes SYMTYPE: bytes CONTTYPE: bytes BLKTYPE: bytes DIRTYPE: bytes FIFOTYPE: bytes CHRTYPE: bytes GNUTYPE_LONGNAME: bytes GNUTYPE_LONGLINK: bytes GNUTYPE_SPARSE: bytes XHDTYPE: bytes XGLTYPE: bytes SOLARIS_XHDTYPE: bytes USTAR_FORMAT: int GNU_FORMAT: int PAX_FORMAT: int DEFAULT_FORMAT: int # tarfile constants SUPPORTED_TYPES: Tuple[bytes, ...] REGULAR_TYPES: Tuple[bytes, ...] GNU_TYPES: Tuple[bytes, ...] PAX_FIELDS: Tuple[str, ...] PAX_NUMBER_FIELDS: Dict[str, type] if sys.version_info >= (3,): PAX_NAME_FIELDS: Set[str] ENCODING: str if sys.version_info < (3,): TAR_PLAIN: int TAR_GZIPPED: int def open( name: Optional[AnyPath] = ..., mode: str = ..., fileobj: Optional[IO[bytes]] = ..., bufsize: int = ..., *, format: Optional[int] = ..., tarinfo: Optional[Type[TarInfo]] = ..., dereference: Optional[bool] = ..., ignore_zeros: Optional[bool] = ..., encoding: Optional[str] = ..., errors: str = ..., pax_headers: Optional[Mapping[str, str]] = ..., debug: Optional[int] = ..., errorlevel: Optional[int] = ..., compresslevel: Optional[int] = ..., ) -> TarFile: ... class TarFile(Iterable[TarInfo]): name: Optional[AnyPath] mode: str fileobj: Optional[IO[bytes]] format: Optional[int] tarinfo: Type[TarInfo] dereference: Optional[bool] ignore_zeros: Optional[bool] encoding: Optional[str] errors: str pax_headers: Optional[Mapping[str, str]] debug: Optional[int] errorlevel: Optional[int] if sys.version_info < (3,): posix: bool def __init__( self, name: Optional[AnyPath] = ..., mode: str = ..., fileobj: Optional[IO[bytes]] = ..., format: Optional[int] = ..., tarinfo: Optional[Type[TarInfo]] = ..., dereference: Optional[bool] = ..., ignore_zeros: Optional[bool] = ..., encoding: Optional[str] = ..., errors: str = ..., pax_headers: Optional[Mapping[str, str]] = ..., debug: Optional[int] = ..., errorlevel: Optional[int] = ..., copybufsize: Optional[int] = ..., # undocumented ) -> None: ... def __enter__(self) -> TarFile: ... def __exit__( self, exc_type: Optional[Type[BaseException]], exc_val: Optional[BaseException], exc_tb: Optional[TracebackType] ) -> None: ... def __iter__(self) -> Iterator[TarInfo]: ... @classmethod def open( cls, name: Optional[AnyPath] = ..., mode: str = ..., fileobj: Optional[IO[bytes]] = ..., bufsize: int = ..., *, format: Optional[int] = ..., tarinfo: Optional[Type[TarInfo]] = ..., dereference: Optional[bool] = ..., ignore_zeros: Optional[bool] = ..., encoding: Optional[str] = ..., errors: str = ..., pax_headers: Optional[Mapping[str, str]] = ..., debug: Optional[int] = ..., errorlevel: Optional[int] = ..., ) -> TarFile: ... def getmember(self, name: str) -> TarInfo: ... def getmembers(self) -> List[TarInfo]: ... def getnames(self) -> List[str]: ... if sys.version_info >= (3, 5): def list(self, verbose: bool = ..., *, members: Optional[List[TarInfo]] = ...) -> None: ... else: def list(self, verbose: bool = ...) -> None: ... def next(self) -> Optional[TarInfo]: ... if sys.version_info >= (3, 5): def extractall( self, path: AnyPath = ..., members: Optional[List[TarInfo]] = ..., *, numeric_owner: bool = ... ) -> None: ... else: def extractall(self, path: AnyPath = ..., members: Optional[List[TarInfo]] = ...) -> None: ... if sys.version_info >= (3, 5): def extract( self, member: Union[str, TarInfo], path: AnyPath = ..., set_attrs: bool = ..., *, numeric_owner: bool = ... ) -> None: ... else: def extract(self, member: Union[str, TarInfo], path: AnyPath = ...) -> None: ... def extractfile(self, member: Union[str, TarInfo]) -> Optional[IO[bytes]]: ... def makedir(self, tarinfo: TarInfo, targetpath: AnyPath) -> None: ... # undocumented def makefile(self, tarinfo: TarInfo, targetpath: AnyPath) -> None: ... # undocumented def makeunknown(self, tarinfo: TarInfo, targetpath: AnyPath) -> None: ... # undocumented def makefifo(self, tarinfo: TarInfo, targetpath: AnyPath) -> None: ... # undocumented def makedev(self, tarinfo: TarInfo, targetpath: AnyPath) -> None: ... # undocumented def makelink(self, tarinfo: TarInfo, targetpath: AnyPath) -> None: ... # undocumented if sys.version_info >= (3, 5): def chown(self, tarinfo: TarInfo, targetpath: AnyPath, numeric_owner: bool) -> None: ... # undocumented else: def chown(self, tarinfo: TarInfo, targetpath: AnyPath) -> None: ... # undocumented def chmod(self, tarinfo: TarInfo, targetpath: AnyPath) -> None: ... # undocumented def utime(self, tarinfo: TarInfo, targetpath: AnyPath) -> None: ... # undocumented if sys.version_info >= (3, 7): def add( self, name: StrPath, arcname: Optional[StrPath] = ..., recursive: bool = ..., *, filter: Optional[Callable[[TarInfo], Optional[TarInfo]]] = ..., ) -> None: ... elif sys.version_info >= (3,): def add( self, name: StrPath, arcname: Optional[StrPath] = ..., recursive: bool = ..., exclude: Optional[Callable[[str], bool]] = ..., *, filter: Optional[Callable[[TarInfo], Optional[TarInfo]]] = ..., ) -> None: ... else: def add( self, name: str, arcname: Optional[str] = ..., recursive: bool = ..., exclude: Optional[Callable[[str], bool]] = ..., filter: Optional[Callable[[TarInfo], Optional[TarInfo]]] = ..., ) -> None: ... def addfile(self, tarinfo: TarInfo, fileobj: Optional[IO[bytes]] = ...) -> None: ... def gettarinfo( self, name: Optional[str] = ..., arcname: Optional[str] = ..., fileobj: Optional[IO[bytes]] = ... ) -> TarInfo: ... def close(self) -> None: ... if sys.version_info >= (3, 9): def is_tarfile(name: Union[AnyPath, IO[bytes]]) -> bool: ... else: def is_tarfile(name: AnyPath) -> bool: ... if sys.version_info < (3, 8): def filemode(mode: int) -> str: ... # undocumented if sys.version_info < (3,): class TarFileCompat: def __init__(self, filename: str, mode: str = ..., compression: int = ...) -> None: ... class TarError(Exception): ... class ReadError(TarError): ... class CompressionError(TarError): ... class StreamError(TarError): ... class ExtractError(TarError): ... class HeaderError(TarError): ... class TarInfo: name: str size: int mtime: int mode: int type: bytes linkname: str uid: int gid: int uname: str gname: str pax_headers: Mapping[str, str] def __init__(self, name: str = ...) -> None: ... if sys.version_info >= (3,): @classmethod def frombuf(cls, buf: bytes, encoding: str, errors: str) -> TarInfo: ... else: @classmethod def frombuf(cls, buf: bytes) -> TarInfo: ... @classmethod def fromtarfile(cls, tarfile: TarFile) -> TarInfo: ... def tobuf(self, format: Optional[int] = ..., encoding: Optional[str] = ..., errors: str = ...) -> bytes: ... def isfile(self) -> bool: ... def isreg(self) -> bool: ... def isdir(self) -> bool: ... def issym(self) -> bool: ... def islnk(self) -> bool: ... def ischr(self) -> bool: ... def isblk(self) -> bool: ... def isfifo(self) -> bool: ... def isdev(self) -> bool: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/telnetlib.pyi0000664000175000017500000000517000000000000024371 0ustar00davedave00000000000000import socket import sys from typing import Any, Callable, Match, Optional, Pattern, Sequence, Tuple, Union DEBUGLEVEL: int TELNET_PORT: int IAC: bytes DONT: bytes DO: bytes WONT: bytes WILL: bytes theNULL: bytes SE: bytes NOP: bytes DM: bytes BRK: bytes IP: bytes AO: bytes AYT: bytes EC: bytes EL: bytes GA: bytes SB: bytes BINARY: bytes ECHO: bytes RCP: bytes SGA: bytes NAMS: bytes STATUS: bytes TM: bytes RCTE: bytes NAOL: bytes NAOP: bytes NAOCRD: bytes NAOHTS: bytes NAOHTD: bytes NAOFFD: bytes NAOVTS: bytes NAOVTD: bytes NAOLFD: bytes XASCII: bytes LOGOUT: bytes BM: bytes DET: bytes SUPDUP: bytes SUPDUPOUTPUT: bytes SNDLOC: bytes TTYPE: bytes EOR: bytes TUID: bytes OUTMRK: bytes TTYLOC: bytes VT3270REGIME: bytes X3PAD: bytes NAWS: bytes TSPEED: bytes LFLOW: bytes LINEMODE: bytes XDISPLOC: bytes OLD_ENVIRON: bytes AUTHENTICATION: bytes ENCRYPT: bytes NEW_ENVIRON: bytes TN3270E: bytes XAUTH: bytes CHARSET: bytes RSP: bytes COM_PORT_OPTION: bytes SUPPRESS_LOCAL_ECHO: bytes TLS: bytes KERMIT: bytes SEND_URL: bytes FORWARD_X: bytes PRAGMA_LOGON: bytes SSPI_LOGON: bytes PRAGMA_HEARTBEAT: bytes EXOPL: bytes NOOPT: bytes class Telnet: def __init__(self, host: Optional[str] = ..., port: int = ..., timeout: int = ...) -> None: ... def open(self, host: str, port: int = ..., timeout: int = ...) -> None: ... def msg(self, msg: str, *args: Any) -> None: ... def set_debuglevel(self, debuglevel: int) -> None: ... def close(self) -> None: ... def get_socket(self) -> socket.socket: ... def fileno(self) -> int: ... def write(self, buffer: bytes) -> None: ... def read_until(self, match: bytes, timeout: Optional[int] = ...) -> bytes: ... def read_all(self) -> bytes: ... def read_some(self) -> bytes: ... def read_very_eager(self) -> bytes: ... def read_eager(self) -> bytes: ... def read_lazy(self) -> bytes: ... def read_very_lazy(self) -> bytes: ... def read_sb_data(self) -> bytes: ... def set_option_negotiation_callback(self, callback: Optional[Callable[[socket.socket, bytes, bytes], Any]]) -> None: ... def process_rawq(self) -> None: ... def rawq_getchar(self) -> bytes: ... def fill_rawq(self) -> None: ... def sock_avail(self) -> bool: ... def interact(self) -> None: ... def mt_interact(self) -> None: ... def listener(self) -> None: ... def expect( self, list: Sequence[Union[Pattern[bytes], bytes]], timeout: Optional[int] = ... ) -> Tuple[int, Optional[Match[bytes]], bytes]: ... if sys.version_info >= (3, 6): def __enter__(self) -> Telnet: ... def __exit__(self, type: Any, value: Any, traceback: Any) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/termios.pyi0000664000175000017500000000666000000000000024076 0ustar00davedave00000000000000from _typeshed import FileDescriptorLike from typing import Any, List, Union _Attr = List[Union[int, List[Union[bytes, int]]]] # TODO constants not really documented B0: int B1000000: int B110: int B115200: int B1152000: int B1200: int B134: int B150: int B1500000: int B1800: int B19200: int B200: int B2000000: int B230400: int B2400: int B2500000: int B300: int B3000000: int B3500000: int B38400: int B4000000: int B460800: int B4800: int B50: int B500000: int B57600: int B576000: int B600: int B75: int B921600: int B9600: int BRKINT: int BS0: int BS1: int BSDLY: int CBAUD: int CBAUDEX: int CDSUSP: int CEOF: int CEOL: int CEOT: int CERASE: int CFLUSH: int CIBAUD: int CINTR: int CKILL: int CLNEXT: int CLOCAL: int CQUIT: int CR0: int CR1: int CR2: int CR3: int CRDLY: int CREAD: int CRPRNT: int CRTSCTS: int CS5: int CS6: int CS7: int CS8: int CSIZE: int CSTART: int CSTOP: int CSTOPB: int CSUSP: int CWERASE: int ECHO: int ECHOCTL: int ECHOE: int ECHOK: int ECHOKE: int ECHONL: int ECHOPRT: int EXTA: int EXTB: int FF0: int FF1: int FFDLY: int FIOASYNC: int FIOCLEX: int FIONBIO: int FIONCLEX: int FIONREAD: int FLUSHO: int HUPCL: int ICANON: int ICRNL: int IEXTEN: int IGNBRK: int IGNCR: int IGNPAR: int IMAXBEL: int INLCR: int INPCK: int IOCSIZE_MASK: int IOCSIZE_SHIFT: int ISIG: int ISTRIP: int IUCLC: int IXANY: int IXOFF: int IXON: int NCC: int NCCS: int NL0: int NL1: int NLDLY: int NOFLSH: int N_MOUSE: int N_PPP: int N_SLIP: int N_STRIP: int N_TTY: int OCRNL: int OFDEL: int OFILL: int OLCUC: int ONLCR: int ONLRET: int ONOCR: int OPOST: int PARENB: int PARMRK: int PARODD: int PENDIN: int TAB0: int TAB1: int TAB2: int TAB3: int TABDLY: int TCFLSH: int TCGETA: int TCGETS: int TCIFLUSH: int TCIOFF: int TCIOFLUSH: int TCION: int TCOFLUSH: int TCOOFF: int TCOON: int TCSADRAIN: int TCSAFLUSH: int TCSANOW: int TCSBRK: int TCSBRKP: int TCSETA: int TCSETAF: int TCSETAW: int TCSETS: int TCSETSF: int TCSETSW: int TCXONC: int TIOCCONS: int TIOCEXCL: int TIOCGETD: int TIOCGICOUNT: int TIOCGLCKTRMIOS: int TIOCGPGRP: int TIOCGSERIAL: int TIOCGSOFTCAR: int TIOCGWINSZ: int TIOCINQ: int TIOCLINUX: int TIOCMBIC: int TIOCMBIS: int TIOCMGET: int TIOCMIWAIT: int TIOCMSET: int TIOCM_CAR: int TIOCM_CD: int TIOCM_CTS: int TIOCM_DSR: int TIOCM_DTR: int TIOCM_LE: int TIOCM_RI: int TIOCM_RNG: int TIOCM_RTS: int TIOCM_SR: int TIOCM_ST: int TIOCNOTTY: int TIOCNXCL: int TIOCOUTQ: int TIOCPKT: int TIOCPKT_DATA: int TIOCPKT_DOSTOP: int TIOCPKT_FLUSHREAD: int TIOCPKT_FLUSHWRITE: int TIOCPKT_NOSTOP: int TIOCPKT_START: int TIOCPKT_STOP: int TIOCSCTTY: int TIOCSERCONFIG: int TIOCSERGETLSR: int TIOCSERGETMULTI: int TIOCSERGSTRUCT: int TIOCSERGWILD: int TIOCSERSETMULTI: int TIOCSERSWILD: int TIOCSER_TEMT: int TIOCSETD: int TIOCSLCKTRMIOS: int TIOCSPGRP: int TIOCSSERIAL: int TIOCSSOFTCAR: int TIOCSTI: int TIOCSWINSZ: int TOSTOP: int VDISCARD: int VEOF: int VEOL: int VEOL2: int VERASE: int VINTR: int VKILL: int VLNEXT: int VMIN: int VQUIT: int VREPRINT: int VSTART: int VSTOP: int VSUSP: int VSWTC: int VSWTCH: int VT0: int VT1: int VTDLY: int VTIME: int VWERASE: int XCASE: int XTABS: int def tcgetattr(fd: FileDescriptorLike) -> List[Any]: ... def tcsetattr(fd: FileDescriptorLike, when: int, attributes: _Attr) -> None: ... def tcsendbreak(fd: FileDescriptorLike, duration: int) -> None: ... def tcdrain(fd: FileDescriptorLike) -> None: ... def tcflush(fd: FileDescriptorLike, queue: int) -> None: ... def tcflow(fd: FileDescriptorLike, action: int) -> None: ... class error(Exception): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/this.pyi0000664000175000017500000000006200000000000023351 0ustar00davedave00000000000000from typing import Dict s: str d: Dict[str, str] ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/threading.pyi0000664000175000017500000001424500000000000024357 0ustar00davedave00000000000000import sys from types import FrameType, TracebackType from typing import Any, Callable, Iterable, List, Mapping, Optional, Text, Type, TypeVar, Union # TODO recursive type _TF = Callable[[FrameType, str, Any], Optional[Callable[..., Any]]] _PF = Callable[[FrameType, str, Any], None] _T = TypeVar("_T") __all__: List[str] def active_count() -> int: ... if sys.version_info < (3,): def activeCount() -> int: ... def current_thread() -> Thread: ... def currentThread() -> Thread: ... if sys.version_info >= (3,): def get_ident() -> int: ... def enumerate() -> List[Thread]: ... if sys.version_info >= (3, 4): def main_thread() -> Thread: ... if sys.version_info >= (3, 8): from _thread import get_native_id as get_native_id def settrace(func: _TF) -> None: ... def setprofile(func: Optional[_PF]) -> None: ... def stack_size(size: int = ...) -> int: ... if sys.version_info >= (3,): TIMEOUT_MAX: float class ThreadError(Exception): ... class local(object): def __getattribute__(self, name: str) -> Any: ... def __setattr__(self, name: str, value: Any) -> None: ... def __delattr__(self, name: str) -> None: ... class Thread: name: str ident: Optional[int] daemon: bool if sys.version_info >= (3,): def __init__( self, group: None = ..., target: Optional[Callable[..., Any]] = ..., name: Optional[str] = ..., args: Iterable[Any] = ..., kwargs: Mapping[str, Any] = ..., *, daemon: Optional[bool] = ..., ) -> None: ... else: def __init__( self, group: None = ..., target: Optional[Callable[..., Any]] = ..., name: Optional[Text] = ..., args: Iterable[Any] = ..., kwargs: Mapping[Text, Any] = ..., ) -> None: ... def start(self) -> None: ... def run(self) -> None: ... def join(self, timeout: Optional[float] = ...) -> None: ... def getName(self) -> str: ... def setName(self, name: Text) -> None: ... if sys.version_info >= (3, 8): @property def native_id(self) -> Optional[int]: ... # only available on some platforms def is_alive(self) -> bool: ... if sys.version_info < (3, 9): def isAlive(self) -> bool: ... def isDaemon(self) -> bool: ... def setDaemon(self, daemonic: bool) -> None: ... class _DummyThread(Thread): ... class Lock: def __init__(self) -> None: ... def __enter__(self) -> bool: ... def __exit__( self, exc_type: Optional[Type[BaseException]], exc_val: Optional[BaseException], exc_tb: Optional[TracebackType] ) -> Optional[bool]: ... if sys.version_info >= (3,): def acquire(self, blocking: bool = ..., timeout: float = ...) -> bool: ... else: def acquire(self, blocking: bool = ...) -> bool: ... def release(self) -> None: ... def locked(self) -> bool: ... class _RLock: def __init__(self) -> None: ... def __enter__(self) -> bool: ... def __exit__( self, exc_type: Optional[Type[BaseException]], exc_val: Optional[BaseException], exc_tb: Optional[TracebackType] ) -> Optional[bool]: ... if sys.version_info >= (3,): def acquire(self, blocking: bool = ..., timeout: float = ...) -> bool: ... else: def acquire(self, blocking: bool = ...) -> bool: ... def release(self) -> None: ... RLock = _RLock class Condition: def __init__(self, lock: Union[Lock, _RLock, None] = ...) -> None: ... def __enter__(self) -> bool: ... def __exit__( self, exc_type: Optional[Type[BaseException]], exc_val: Optional[BaseException], exc_tb: Optional[TracebackType] ) -> Optional[bool]: ... if sys.version_info >= (3,): def acquire(self, blocking: bool = ..., timeout: float = ...) -> bool: ... else: def acquire(self, blocking: bool = ...) -> bool: ... def release(self) -> None: ... def wait(self, timeout: Optional[float] = ...) -> bool: ... if sys.version_info >= (3,): def wait_for(self, predicate: Callable[[], _T], timeout: Optional[float] = ...) -> _T: ... def notify(self, n: int = ...) -> None: ... def notify_all(self) -> None: ... def notifyAll(self) -> None: ... class Semaphore: def __init__(self, value: int = ...) -> None: ... def __enter__(self) -> bool: ... def __exit__( self, exc_type: Optional[Type[BaseException]], exc_val: Optional[BaseException], exc_tb: Optional[TracebackType] ) -> Optional[bool]: ... if sys.version_info >= (3,): def acquire(self, blocking: bool = ..., timeout: float = ...) -> bool: ... else: def acquire(self, blocking: bool = ...) -> bool: ... if sys.version_info >= (3, 9): def release(self, n: int = ...) -> None: ... else: def release(self) -> None: ... class BoundedSemaphore(Semaphore): ... class Event: def __init__(self) -> None: ... def is_set(self) -> bool: ... if sys.version_info < (3,): def isSet(self) -> bool: ... def set(self) -> None: ... def clear(self) -> None: ... def wait(self, timeout: Optional[float] = ...) -> bool: ... if sys.version_info >= (3, 8): from _thread import _excepthook, _ExceptHookArgs excepthook = _excepthook ExceptHookArgs = _ExceptHookArgs class Timer(Thread): if sys.version_info >= (3,): def __init__( self, interval: float, function: Callable[..., Any], args: Optional[Iterable[Any]] = ..., kwargs: Optional[Mapping[str, Any]] = ..., ) -> None: ... else: def __init__( self, interval: float, function: Callable[..., Any], args: Iterable[Any] = ..., kwargs: Mapping[str, Any] = ... ) -> None: ... def cancel(self) -> None: ... if sys.version_info >= (3,): class Barrier: parties: int n_waiting: int broken: bool def __init__(self, parties: int, action: Optional[Callable[[], None]] = ..., timeout: Optional[float] = ...) -> None: ... def wait(self, timeout: Optional[float] = ...) -> int: ... def reset(self) -> None: ... def abort(self) -> None: ... class BrokenBarrierError(RuntimeError): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/time.pyi0000664000175000017500000000747400000000000023356 0ustar00davedave00000000000000import sys from typing import Any, NamedTuple, Optional, Tuple, Union if sys.version_info >= (3, 3): from types import SimpleNamespace _TimeTuple = Tuple[int, int, int, int, int, int, int, int, int] if sys.version_info < (3, 3): accept2dyear: bool altzone: int daylight: int timezone: int tzname: Tuple[str, str] if sys.version_info >= (3, 7) and sys.platform != "win32": CLOCK_BOOTTIME: int # Linux CLOCK_PROF: int # FreeBSD, NetBSD, OpenBSD CLOCK_UPTIME: int # FreeBSD, OpenBSD if sys.version_info >= (3, 3) and sys.platform != "win32": CLOCK_HIGHRES: int # Solaris only CLOCK_MONOTONIC: int # Unix only CLOCK_MONOTONIC_RAW: int # Linux 2.6.28 or later CLOCK_PROCESS_CPUTIME_ID: int # Unix only CLOCK_REALTIME: int # Unix only CLOCK_THREAD_CPUTIME_ID: int # Unix only if sys.version_info >= (3, 8) and sys.platform == "darwin": CLOCK_UPTIME_RAW: int class _struct_time(NamedTuple): tm_year: int tm_mon: int tm_mday: int tm_hour: int tm_min: int tm_sec: int tm_wday: int tm_yday: int tm_isdst: int @property def n_fields(self) -> int: ... @property def n_sequence_fields(self) -> int: ... @property def n_unnamed_fields(self) -> int: ... if sys.version_info >= (3, 3): class struct_time(_struct_time): def __init__( self, o: Union[ Tuple[int, int, int, int, int, int, int, int, int], Tuple[int, int, int, int, int, int, int, int, int, str], Tuple[int, int, int, int, int, int, int, int, int, str, int], ], _arg: Any = ..., ) -> None: ... def __new__( cls, o: Union[ Tuple[int, int, int, int, int, int, int, int, int], Tuple[int, int, int, int, int, int, int, int, int, str], Tuple[int, int, int, int, int, int, int, int, int, str, int], ], _arg: Any = ..., ) -> struct_time: ... if sys.version_info >= (3, 6) or sys.platform != "win32": @property def tm_zone(self) -> str: ... @property def tm_gmtoff(self) -> int: ... else: class struct_time(_struct_time): def __init__(self, o: _TimeTuple, _arg: Any = ...) -> None: ... def __new__(cls, o: _TimeTuple, _arg: Any = ...) -> struct_time: ... def asctime(t: Union[_TimeTuple, struct_time] = ...) -> str: ... if sys.version_info < (3, 8): def clock() -> float: ... def ctime(secs: Optional[float] = ...) -> str: ... def gmtime(secs: Optional[float] = ...) -> struct_time: ... def localtime(secs: Optional[float] = ...) -> struct_time: ... def mktime(t: Union[_TimeTuple, struct_time]) -> float: ... def sleep(secs: float) -> None: ... def strftime(format: str, t: Union[_TimeTuple, struct_time] = ...) -> str: ... def strptime(string: str, format: str = ...) -> struct_time: ... def time() -> float: ... if sys.platform != "win32": def tzset() -> None: ... # Unix only if sys.version_info >= (3, 3): def get_clock_info(name: str) -> SimpleNamespace: ... def monotonic() -> float: ... def perf_counter() -> float: ... def process_time() -> float: ... if sys.platform != "win32": def clock_getres(clk_id: int) -> float: ... # Unix only def clock_gettime(clk_id: int) -> float: ... # Unix only def clock_settime(clk_id: int, time: float) -> None: ... # Unix only if sys.version_info >= (3, 7): if sys.platform != "win32": def clock_gettime_ns(clock_id: int) -> int: ... def clock_settime_ns(clock_id: int, time: int) -> int: ... def monotonic_ns() -> int: ... def perf_counter_ns() -> int: ... def process_time_ns() -> int: ... def time_ns() -> int: ... def thread_time() -> float: ... def thread_time_ns() -> int: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/timeit.pyi0000664000175000017500000000312700000000000023702 0ustar00davedave00000000000000import sys from typing import IO, Any, Callable, Dict, List, Optional, Sequence, Text, Tuple, Union _str = Union[str, Text] _Timer = Callable[[], float] _stmt = Union[_str, Callable[[], Any]] default_timer: _Timer class Timer: if sys.version_info >= (3, 5): def __init__( self, stmt: _stmt = ..., setup: _stmt = ..., timer: _Timer = ..., globals: Optional[Dict[str, Any]] = ... ) -> None: ... else: def __init__(self, stmt: _stmt = ..., setup: _stmt = ..., timer: _Timer = ...) -> None: ... def print_exc(self, file: Optional[IO[str]] = ...) -> None: ... def timeit(self, number: int = ...) -> float: ... def repeat(self, repeat: int = ..., number: int = ...) -> List[float]: ... if sys.version_info >= (3, 6): def autorange(self, callback: Optional[Callable[[int, float], Any]] = ...) -> Tuple[int, float]: ... if sys.version_info >= (3, 5): def timeit( stmt: _stmt = ..., setup: _stmt = ..., timer: _Timer = ..., number: int = ..., globals: Optional[Dict[str, Any]] = ... ) -> float: ... def repeat( stmt: _stmt = ..., setup: _stmt = ..., timer: _Timer = ..., repeat: int = ..., number: int = ..., globals: Optional[Dict[str, Any]] = ..., ) -> List[float]: ... else: def timeit(stmt: _stmt = ..., setup: _stmt = ..., timer: _Timer = ..., number: int = ...) -> float: ... def repeat( stmt: _stmt = ..., setup: _stmt = ..., timer: _Timer = ..., repeat: int = ..., number: int = ... ) -> List[float]: ... def main(args: Optional[Sequence[str]]) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/token.pyi0000664000175000017500000000267400000000000023535 0ustar00davedave00000000000000import sys from typing import Dict ENDMARKER: int NAME: int NUMBER: int STRING: int NEWLINE: int INDENT: int DEDENT: int LPAR: int RPAR: int LSQB: int RSQB: int COLON: int COMMA: int SEMI: int PLUS: int MINUS: int STAR: int SLASH: int VBAR: int AMPER: int LESS: int GREATER: int EQUAL: int DOT: int PERCENT: int if sys.version_info < (3,): BACKQUOTE: int LBRACE: int RBRACE: int EQEQUAL: int NOTEQUAL: int LESSEQUAL: int GREATEREQUAL: int TILDE: int CIRCUMFLEX: int LEFTSHIFT: int RIGHTSHIFT: int DOUBLESTAR: int PLUSEQUAL: int MINEQUAL: int STAREQUAL: int SLASHEQUAL: int PERCENTEQUAL: int AMPEREQUAL: int VBAREQUAL: int CIRCUMFLEXEQUAL: int LEFTSHIFTEQUAL: int RIGHTSHIFTEQUAL: int DOUBLESTAREQUAL: int DOUBLESLASH: int DOUBLESLASHEQUAL: int AT: int if sys.version_info >= (3,): RARROW: int ELLIPSIS: int if sys.version_info >= (3, 5): ATEQUAL: int if sys.version_info < (3, 7): # These were removed in Python 3.7 but added back in Python 3.8 AWAIT: int ASYNC: int if sys.version_info >= (3, 8): AWAIT: int ASYNC: int OP: int ERRORTOKEN: int N_TOKENS: int NT_OFFSET: int tok_name: Dict[int, str] if sys.version_info >= (3, 7): COMMENT: int NL: int ENCODING: int if sys.version_info >= (3, 8): TYPE_COMMENT: int TYPE_IGNORE: int COLONEQUAL: int EXACT_TOKEN_TYPES: Dict[str, int] def ISTERMINAL(x: int) -> bool: ... def ISNONTERMINAL(x: int) -> bool: ... def ISEOF(x: int) -> bool: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/trace.pyi0000664000175000017500000000376500000000000023515 0ustar00davedave00000000000000import types from _typeshed import StrPath from typing import Any, Callable, Mapping, Optional, Sequence, Tuple, TypeVar, Union _T = TypeVar("_T") _localtrace = Callable[[types.FrameType, str, Any], Callable[..., Any]] class CoverageResults: def update(self, other: CoverageResults) -> None: ... def write_results(self, show_missing: bool = ..., summary: bool = ..., coverdir: Optional[StrPath] = ...) -> None: ... def write_results_file( self, path: StrPath, lines: Sequence[str], lnotab: Any, lines_hit: Mapping[int, int], encoding: Optional[str] = ... ) -> Tuple[int, int]: ... class Trace: def __init__( self, count: int = ..., trace: int = ..., countfuncs: int = ..., countcallers: int = ..., ignoremods: Sequence[str] = ..., ignoredirs: Sequence[str] = ..., infile: Optional[StrPath] = ..., outfile: Optional[StrPath] = ..., timing: bool = ..., ) -> None: ... def run(self, cmd: Union[str, types.CodeType]) -> None: ... def runctx( self, cmd: Union[str, types.CodeType], globals: Optional[Mapping[str, Any]] = ..., locals: Optional[Mapping[str, Any]] = ..., ) -> None: ... def runfunc(self, func: Callable[..., _T], *args: Any, **kw: Any) -> _T: ... def file_module_function_of(self, frame: types.FrameType) -> Tuple[str, Optional[str], str]: ... def globaltrace_trackcallers(self, frame: types.FrameType, why: str, arg: Any) -> None: ... def globaltrace_countfuncs(self, frame: types.FrameType, why: str, arg: Any) -> None: ... def globaltrace_lt(self, frame: types.FrameType, why: str, arg: Any) -> None: ... def localtrace_trace_and_count(self, frame: types.FrameType, why: str, arg: Any) -> _localtrace: ... def localtrace_trace(self, frame: types.FrameType, why: str, arg: Any) -> _localtrace: ... def localtrace_count(self, frame: types.FrameType, why: str, arg: Any) -> _localtrace: ... def results(self) -> CoverageResults: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/traceback.pyi0000664000175000017500000001265100000000000024330 0ustar00davedave00000000000000import sys from _typeshed import SupportsWrite from types import FrameType, TracebackType from typing import IO, Any, Dict, Generator, Iterable, Iterator, List, Mapping, Optional, Tuple, Type _PT = Tuple[str, int, str, Optional[str]] def print_tb(tb: Optional[TracebackType], limit: Optional[int] = ..., file: Optional[IO[str]] = ...) -> None: ... if sys.version_info >= (3,): def print_exception( etype: Optional[Type[BaseException]], value: Optional[BaseException], tb: Optional[TracebackType], limit: Optional[int] = ..., file: Optional[IO[str]] = ..., chain: bool = ..., ) -> None: ... def print_exc(limit: Optional[int] = ..., file: Optional[IO[str]] = ..., chain: bool = ...) -> None: ... def print_last(limit: Optional[int] = ..., file: Optional[IO[str]] = ..., chain: bool = ...) -> None: ... else: def print_exception( etype: Optional[Type[BaseException]], value: Optional[BaseException], tb: Optional[TracebackType], limit: Optional[int] = ..., file: Optional[IO[str]] = ..., ) -> None: ... def print_exc(limit: Optional[int] = ..., file: Optional[IO[str]] = ...) -> None: ... def print_last(limit: Optional[int] = ..., file: Optional[IO[str]] = ...) -> None: ... def print_stack(f: Optional[FrameType] = ..., limit: Optional[int] = ..., file: Optional[IO[str]] = ...) -> None: ... if sys.version_info >= (3, 5): def extract_tb(tb: Optional[TracebackType], limit: Optional[int] = ...) -> StackSummary: ... def extract_stack(f: Optional[FrameType] = ..., limit: Optional[int] = ...) -> StackSummary: ... def format_list(extracted_list: List[FrameSummary]) -> List[str]: ... # undocumented def print_list(extracted_list: List[FrameSummary], file: Optional[SupportsWrite[str]] = ...) -> None: ... else: def extract_tb(tb: Optional[TracebackType], limit: Optional[int] = ...) -> List[_PT]: ... def extract_stack(f: Optional[FrameType] = ..., limit: Optional[int] = ...) -> List[_PT]: ... def format_list(extracted_list: List[_PT]) -> List[str]: ... def format_exception_only(etype: Optional[Type[BaseException]], value: Optional[BaseException]) -> List[str]: ... if sys.version_info >= (3,): def format_exception( etype: Optional[Type[BaseException]], value: Optional[BaseException], tb: Optional[TracebackType], limit: Optional[int] = ..., chain: bool = ..., ) -> List[str]: ... def format_exc(limit: Optional[int] = ..., chain: bool = ...) -> str: ... else: def format_exception( etype: Optional[Type[BaseException]], value: Optional[BaseException], tb: Optional[TracebackType], limit: Optional[int] = ..., ) -> List[str]: ... def format_exc(limit: Optional[int] = ...) -> str: ... def format_tb(tb: Optional[TracebackType], limit: Optional[int] = ...) -> List[str]: ... def format_stack(f: Optional[FrameType] = ..., limit: Optional[int] = ...) -> List[str]: ... if sys.version_info >= (3, 4): def clear_frames(tb: TracebackType) -> None: ... if sys.version_info >= (3, 5): def walk_stack(f: Optional[FrameType]) -> Iterator[Tuple[FrameType, int]]: ... def walk_tb(tb: Optional[TracebackType]) -> Iterator[Tuple[FrameType, int]]: ... if sys.version_info < (3,): def tb_lineno(tb: TracebackType) -> int: ... if sys.version_info >= (3, 5): class TracebackException: __cause__: TracebackException __context__: TracebackException __suppress_context__: bool stack: StackSummary exc_type: Type[BaseException] filename: str lineno: int text: str offset: int msg: str def __init__( self, exc_type: Type[BaseException], exc_value: BaseException, exc_traceback: TracebackType, *, limit: Optional[int] = ..., lookup_lines: bool = ..., capture_locals: bool = ..., ) -> None: ... @classmethod def from_exception( cls, exc: BaseException, *, limit: Optional[int] = ..., lookup_lines: bool = ..., capture_locals: bool = ... ) -> TracebackException: ... def format(self, *, chain: bool = ...) -> Generator[str, None, None]: ... def format_exception_only(self) -> Generator[str, None, None]: ... class FrameSummary(Iterable[Any]): filename: str lineno: int name: str line: str locals: Optional[Dict[str, str]] def __init__( self, filename: str, lineno: int, name: str, lookup_line: bool = ..., locals: Optional[Mapping[str, str]] = ..., line: Optional[str] = ..., ) -> None: ... # TODO: more precise typing for __getitem__ and __iter__, # for a namedtuple-like view on (filename, lineno, name, str). def __getitem__(self, i: int) -> Any: ... def __iter__(self) -> Iterator[Any]: ... class StackSummary(List[FrameSummary]): @classmethod def extract( cls, frame_gen: Generator[Tuple[FrameType, int], None, None], *, limit: Optional[int] = ..., lookup_lines: bool = ..., capture_locals: bool = ..., ) -> StackSummary: ... @classmethod def from_list(cls, a_list: List[_PT]) -> StackSummary: ... def format(self) -> List[str]: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/tty.pyi0000664000175000017500000000042300000000000023223 0ustar00davedave00000000000000from typing import IO, Union _FD = Union[int, IO[str]] # XXX: Undocumented integer constants IFLAG: int OFLAG: int CFLAG: int LFLAG: int ISPEED: int OSPEED: int CC: int def setraw(fd: _FD, when: int = ...) -> None: ... def setcbreak(fd: _FD, when: int = ...) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/turtle.pyi0000664000175000017500000004602400000000000023731 0ustar00davedave00000000000000import sys from typing import Any, Callable, Dict, List, Optional, Sequence, Text, Tuple, TypeVar, Union, overload if sys.version_info >= (3,): from tkinter import Canvas, PhotoImage else: # TODO: Replace these aliases once we have Python 2 stubs for the Tkinter module. Canvas = Any PhotoImage = Any # Note: '_Color' is the alias we use for arguments and _AnyColor is the # alias we use for return types. Really, these two aliases should be the # same, but as per the "no union returns" typeshed policy, we'll return # Any instead. _Color = Union[Text, Tuple[float, float, float]] _AnyColor = Any # TODO: Replace this with a TypedDict once it becomes standardized. _PenState = Dict[str, Any] _Speed = Union[str, float] _PolygonCoords = Sequence[Tuple[float, float]] # TODO: Type this more accurately # Vec2D is actually a custom subclass of 'tuple'. Vec2D = Tuple[float, float] class TurtleScreenBase(object): cv: Canvas = ... canvwidth: int = ... canvheight: int = ... xscale: float = ... yscale: float = ... def __init__(self, cv: Canvas) -> None: ... if sys.version_info >= (3,): def mainloop(self) -> None: ... def textinput(self, title: str, prompt: str) -> Optional[str]: ... def numinput( self, title: str, prompt: str, default: Optional[float] = ..., minval: Optional[float] = ..., maxval: Optional[float] = ..., ) -> Optional[float]: ... class Terminator(Exception): ... class TurtleGraphicsError(Exception): ... class Shape(object): def __init__(self, type_: str, data: Union[_PolygonCoords, PhotoImage, None] = ...) -> None: ... def addcomponent(self, poly: _PolygonCoords, fill: _Color, outline: Optional[_Color] = ...) -> None: ... class TurtleScreen(TurtleScreenBase): def __init__(self, cv: Canvas, mode: str = ..., colormode: float = ..., delay: int = ...) -> None: ... def clear(self) -> None: ... @overload def mode(self, mode: None = ...) -> str: ... @overload def mode(self, mode: str) -> None: ... def setworldcoordinates(self, llx: float, lly: float, urx: float, ury: float) -> None: ... def register_shape(self, name: str, shape: Union[_PolygonCoords, Shape, None] = ...) -> None: ... @overload def colormode(self, cmode: None = ...) -> float: ... @overload def colormode(self, cmode: float) -> None: ... def reset(self) -> None: ... def turtles(self) -> List[Turtle]: ... @overload def bgcolor(self) -> _AnyColor: ... @overload def bgcolor(self, color: _Color) -> None: ... @overload def bgcolor(self, r: float, g: float, b: float) -> None: ... @overload def tracer(self, n: None = ...) -> int: ... @overload def tracer(self, n: int, delay: Optional[int] = ...) -> None: ... @overload def delay(self, delay: None = ...) -> int: ... @overload def delay(self, delay: int) -> None: ... def update(self) -> None: ... def window_width(self) -> int: ... def window_height(self) -> int: ... def getcanvas(self) -> Canvas: ... def getshapes(self) -> List[str]: ... def onclick(self, fun: Callable[[float, float], Any], btn: int = ..., add: Optional[Any] = ...) -> None: ... def onkey(self, fun: Callable[[], Any], key: str) -> None: ... def listen(self, xdummy: Optional[float] = ..., ydummy: Optional[float] = ...) -> None: ... def ontimer(self, fun: Callable[[], Any], t: int = ...) -> None: ... @overload def bgpic(self, picname: None = ...) -> str: ... @overload def bgpic(self, picname: str) -> None: ... @overload def screensize(self, canvwidth: None = ..., canvheight: None = ..., bg: None = ...) -> Tuple[int, int]: ... # Looks like if self.cv is not a ScrolledCanvas, this could return a tuple as well @overload def screensize(self, canvwidth: int, canvheight: int, bg: Optional[_Color] = ...) -> None: ... onscreenclick = onclick resetscreen = reset clearscreen = clear addshape = register_shape if sys.version_info >= (3,): def onkeypress(self, fun: Callable[[], Any], key: Optional[str] = ...) -> None: ... onkeyrelease = onkey class TNavigator(object): START_ORIENTATION: Dict[str, Vec2D] = ... DEFAULT_MODE: str = ... DEFAULT_ANGLEOFFSET: int = ... DEFAULT_ANGLEORIENT: int = ... def __init__(self, mode: str = ...) -> None: ... def reset(self) -> None: ... def degrees(self, fullcircle: float = ...) -> None: ... def radians(self) -> None: ... def forward(self, distance: float) -> None: ... def back(self, distance: float) -> None: ... def right(self, angle: float) -> None: ... def left(self, angle: float) -> None: ... def pos(self) -> Vec2D: ... def xcor(self) -> float: ... def ycor(self) -> float: ... @overload def goto(self, x: Tuple[float, float], y: None = ...) -> None: ... @overload def goto(self, x: float, y: float) -> None: ... def home(self) -> None: ... def setx(self, x: float) -> None: ... def sety(self, y: float) -> None: ... @overload def distance(self, x: Union[TNavigator, Tuple[float, float]], y: None = ...) -> float: ... @overload def distance(self, x: float, y: float) -> float: ... @overload def towards(self, x: Union[TNavigator, Tuple[float, float]], y: None = ...) -> float: ... @overload def towards(self, x: float, y: float) -> float: ... def heading(self) -> float: ... def setheading(self, to_angle: float) -> None: ... def circle(self, radius: float, extent: Optional[float] = ..., steps: Optional[int] = ...) -> None: ... fd = forward bk = back backward = back rt = right lt = left position = pos setpos = goto setposition = goto seth = setheading class TPen(object): def __init__(self, resizemode: str = ...) -> None: ... @overload def resizemode(self, rmode: None = ...) -> str: ... @overload def resizemode(self, rmode: str) -> None: ... @overload def pensize(self, width: None = ...) -> int: ... @overload def pensize(self, width: int) -> None: ... def penup(self) -> None: ... def pendown(self) -> None: ... def isdown(self) -> bool: ... @overload def speed(self, speed: None = ...) -> int: ... @overload def speed(self, speed: _Speed) -> None: ... @overload def pencolor(self) -> _AnyColor: ... @overload def pencolor(self, color: _Color) -> None: ... @overload def pencolor(self, r: float, g: float, b: float) -> None: ... @overload def fillcolor(self) -> _AnyColor: ... @overload def fillcolor(self, color: _Color) -> None: ... @overload def fillcolor(self, r: float, g: float, b: float) -> None: ... @overload def color(self) -> Tuple[_AnyColor, _AnyColor]: ... @overload def color(self, color: _Color) -> None: ... @overload def color(self, r: float, g: float, b: float) -> None: ... @overload def color(self, color1: _Color, color2: _Color) -> None: ... def showturtle(self) -> None: ... def hideturtle(self) -> None: ... def isvisible(self) -> bool: ... # Note: signatures 1 and 2 overlap unsafely when no arguments are provided @overload def pen(self) -> _PenState: ... # type: ignore @overload def pen( self, pen: Optional[_PenState] = ..., *, shown: bool = ..., pendown: bool = ..., pencolor: _Color = ..., fillcolor: _Color = ..., pensize: int = ..., speed: int = ..., resizemode: str = ..., stretchfactor: Tuple[float, float] = ..., outline: int = ..., tilt: float = ..., ) -> None: ... width = pensize up = penup pu = penup pd = pendown down = pendown st = showturtle ht = hideturtle _T = TypeVar("_T") class RawTurtle(TPen, TNavigator): def __init__( self, canvas: Union[Canvas, TurtleScreen, None] = ..., shape: str = ..., undobuffersize: int = ..., visible: bool = ... ) -> None: ... def reset(self) -> None: ... def setundobuffer(self, size: Optional[int]) -> None: ... def undobufferentries(self) -> int: ... def clear(self) -> None: ... def clone(self: _T) -> _T: ... @overload def shape(self, name: None = ...) -> str: ... @overload def shape(self, name: str) -> None: ... # Unsafely overlaps when no arguments are provided @overload def shapesize(self) -> Tuple[float, float, float]: ... # type: ignore @overload def shapesize( self, stretch_wid: Optional[float] = ..., stretch_len: Optional[float] = ..., outline: Optional[float] = ... ) -> None: ... if sys.version_info >= (3,): @overload def shearfactor(self, shear: None = ...) -> float: ... @overload def shearfactor(self, shear: float) -> None: ... # Unsafely overlaps when no arguments are provided @overload def shapetransform(self) -> Tuple[float, float, float, float]: ... # type: ignore @overload def shapetransform( self, t11: Optional[float] = ..., t12: Optional[float] = ..., t21: Optional[float] = ..., t22: Optional[float] = ... ) -> None: ... def get_shapepoly(self) -> Optional[_PolygonCoords]: ... def settiltangle(self, angle: float) -> None: ... @overload def tiltangle(self, angle: None = ...) -> float: ... @overload def tiltangle(self, angle: float) -> None: ... def tilt(self, angle: float) -> None: ... # Can return either 'int' or Tuple[int, ...] based on if the stamp is # a compound stamp or not. So, as per the "no Union return" policy, # we return Any. def stamp(self) -> Any: ... def clearstamp(self, stampid: Union[int, Tuple[int, ...]]) -> None: ... def clearstamps(self, n: Optional[int] = ...) -> None: ... def filling(self) -> bool: ... def begin_fill(self) -> None: ... def end_fill(self) -> None: ... def dot(self, size: Optional[int] = ..., *color: _Color) -> None: ... def write(self, arg: object, move: bool = ..., align: str = ..., font: Tuple[str, int, str] = ...) -> None: ... def begin_poly(self) -> None: ... def end_poly(self) -> None: ... def get_poly(self) -> Optional[_PolygonCoords]: ... def getscreen(self) -> TurtleScreen: ... def getturtle(self: _T) -> _T: ... getpen = getturtle def onclick(self, fun: Callable[[float, float], Any], btn: int = ..., add: Optional[bool] = ...) -> None: ... def onrelease(self, fun: Callable[[float, float], Any], btn: int = ..., add: Optional[bool] = ...) -> None: ... def ondrag(self, fun: Callable[[float, float], Any], btn: int = ..., add: Optional[bool] = ...) -> None: ... def undo(self) -> None: ... turtlesize = shapesize class _Screen(TurtleScreen): def __init__(self) -> None: ... # Note int and float are interpreted differently, hence the Union instead of just float def setup( self, width: Union[int, float] = ..., height: Union[int, float] = ..., startx: Optional[int] = ..., starty: Optional[int] = ..., ) -> None: ... def title(self, titlestring: str) -> None: ... def bye(self) -> None: ... def exitonclick(self) -> None: ... def Screen() -> _Screen: ... class Turtle(RawTurtle): def __init__(self, shape: str = ..., undobuffersize: int = ..., visible: bool = ...) -> None: ... RawPen = RawTurtle Pen = Turtle def write_docstringdict(filename: str = ...) -> None: ... # Note: it's somewhat unfortunate that we have to copy the function signatures. # It would be nice if we could partially reduce the redundancy by doing something # like the following: # # _screen: Screen # clear = _screen.clear # # However, it seems pytype does not support this type of syntax in pyi files. # Functions copied from TurtleScreenBase: # Note: mainloop() was always present in the global scope, but was added to # TurtleScreenBase in Python 3.0 def mainloop() -> None: ... if sys.version_info >= (3,): def textinput(title: str, prompt: str) -> Optional[str]: ... def numinput( title: str, prompt: str, default: Optional[float] = ..., minval: Optional[float] = ..., maxval: Optional[float] = ... ) -> Optional[float]: ... # Functions copied from TurtleScreen: def clear() -> None: ... @overload def mode(mode: None = ...) -> str: ... @overload def mode(mode: str) -> None: ... def setworldcoordinates(llx: float, lly: float, urx: float, ury: float) -> None: ... def register_shape(name: str, shape: Union[_PolygonCoords, Shape, None] = ...) -> None: ... @overload def colormode(cmode: None = ...) -> float: ... @overload def colormode(cmode: float) -> None: ... def reset() -> None: ... def turtles() -> List[Turtle]: ... @overload def bgcolor() -> _AnyColor: ... @overload def bgcolor(color: _Color) -> None: ... @overload def bgcolor(r: float, g: float, b: float) -> None: ... @overload def tracer(n: None = ...) -> int: ... @overload def tracer(n: int, delay: Optional[int] = ...) -> None: ... @overload def delay(delay: None = ...) -> int: ... @overload def delay(delay: int) -> None: ... def update() -> None: ... def window_width() -> int: ... def window_height() -> int: ... def getcanvas() -> Canvas: ... def getshapes() -> List[str]: ... def onclick(fun: Callable[[float, float], Any], btn: int = ..., add: Optional[Any] = ...) -> None: ... def onkey(fun: Callable[[], Any], key: str) -> None: ... def listen(xdummy: Optional[float] = ..., ydummy: Optional[float] = ...) -> None: ... def ontimer(fun: Callable[[], Any], t: int = ...) -> None: ... @overload def bgpic(picname: None = ...) -> str: ... @overload def bgpic(picname: str) -> None: ... @overload def screensize(canvwidth: None = ..., canvheight: None = ..., bg: None = ...) -> Tuple[int, int]: ... @overload def screensize(canvwidth: int, canvheight: int, bg: Optional[_Color] = ...) -> None: ... onscreenclick = onclick resetscreen = reset clearscreen = clear addshape = register_shape if sys.version_info >= (3,): def onkeypress(fun: Callable[[], Any], key: Optional[str] = ...) -> None: ... onkeyrelease = onkey # Functions copied from TNavigator: def degrees(fullcircle: float = ...) -> None: ... def radians() -> None: ... def forward(distance: float) -> None: ... def back(distance: float) -> None: ... def right(angle: float) -> None: ... def left(angle: float) -> None: ... def pos() -> Vec2D: ... def xcor() -> float: ... def ycor() -> float: ... @overload def goto(x: Tuple[float, float], y: None = ...) -> None: ... @overload def goto(x: float, y: float) -> None: ... def home() -> None: ... def setx(x: float) -> None: ... def sety(y: float) -> None: ... @overload def distance(x: Union[TNavigator, Tuple[float, float]], y: None = ...) -> float: ... @overload def distance(x: float, y: float) -> float: ... @overload def towards(x: Union[TNavigator, Tuple[float, float]], y: None = ...) -> float: ... @overload def towards(x: float, y: float) -> float: ... def heading() -> float: ... def setheading(to_angle: float) -> None: ... def circle(radius: float, extent: Optional[float] = ..., steps: Optional[int] = ...) -> None: ... fd = forward bk = back backward = back rt = right lt = left position = pos setpos = goto setposition = goto seth = setheading # Functions copied from TPen: @overload def resizemode(rmode: None = ...) -> str: ... @overload def resizemode(rmode: str) -> None: ... @overload def pensize(width: None = ...) -> int: ... @overload def pensize(width: int) -> None: ... def penup() -> None: ... def pendown() -> None: ... def isdown() -> bool: ... @overload def speed(speed: None = ...) -> int: ... @overload def speed(speed: _Speed) -> None: ... @overload def pencolor() -> _AnyColor: ... @overload def pencolor(color: _Color) -> None: ... @overload def pencolor(r: float, g: float, b: float) -> None: ... @overload def fillcolor() -> _AnyColor: ... @overload def fillcolor(color: _Color) -> None: ... @overload def fillcolor(r: float, g: float, b: float) -> None: ... @overload def color() -> Tuple[_AnyColor, _AnyColor]: ... @overload def color(color: _Color) -> None: ... @overload def color(r: float, g: float, b: float) -> None: ... @overload def color(color1: _Color, color2: _Color) -> None: ... def showturtle() -> None: ... def hideturtle() -> None: ... def isvisible() -> bool: ... # Note: signatures 1 and 2 overlap unsafely when no arguments are provided @overload def pen() -> _PenState: ... # type: ignore @overload def pen( pen: Optional[_PenState] = ..., *, shown: bool = ..., pendown: bool = ..., pencolor: _Color = ..., fillcolor: _Color = ..., pensize: int = ..., speed: int = ..., resizemode: str = ..., stretchfactor: Tuple[float, float] = ..., outline: int = ..., tilt: float = ..., ) -> None: ... width = pensize up = penup pu = penup pd = pendown down = pendown st = showturtle ht = hideturtle # Functions copied from RawTurtle: def setundobuffer(size: Optional[int]) -> None: ... def undobufferentries() -> int: ... @overload def shape(name: None = ...) -> str: ... @overload def shape(name: str) -> None: ... # Unsafely overlaps when no arguments are provided @overload def shapesize() -> Tuple[float, float, float]: ... # type: ignore @overload def shapesize(stretch_wid: Optional[float] = ..., stretch_len: Optional[float] = ..., outline: Optional[float] = ...) -> None: ... if sys.version_info >= (3,): @overload def shearfactor(shear: None = ...) -> float: ... @overload def shearfactor(shear: float) -> None: ... # Unsafely overlaps when no arguments are provided @overload def shapetransform() -> Tuple[float, float, float, float]: ... # type: ignore @overload def shapetransform( t11: Optional[float] = ..., t12: Optional[float] = ..., t21: Optional[float] = ..., t22: Optional[float] = ... ) -> None: ... def get_shapepoly() -> Optional[_PolygonCoords]: ... def settiltangle(angle: float) -> None: ... @overload def tiltangle(angle: None = ...) -> float: ... @overload def tiltangle(angle: float) -> None: ... def tilt(angle: float) -> None: ... # Can return either 'int' or Tuple[int, ...] based on if the stamp is # a compound stamp or not. So, as per the "no Union return" policy, # we return Any. def stamp() -> Any: ... def clearstamp(stampid: Union[int, Tuple[int, ...]]) -> None: ... def clearstamps(n: Optional[int] = ...) -> None: ... def filling() -> bool: ... def begin_fill() -> None: ... def end_fill() -> None: ... def dot(size: Optional[int] = ..., *color: _Color) -> None: ... def write(arg: object, move: bool = ..., align: str = ..., font: Tuple[str, int, str] = ...) -> None: ... def begin_poly() -> None: ... def end_poly() -> None: ... def get_poly() -> Optional[_PolygonCoords]: ... def getscreen() -> TurtleScreen: ... def getturtle() -> Turtle: ... getpen = getturtle def onrelease(fun: Callable[[float, float], Any], btn: int = ..., add: Optional[Any] = ...) -> None: ... def ondrag(fun: Callable[[float, float], Any], btn: int = ..., add: Optional[Any] = ...) -> None: ... def undo() -> None: ... turtlesize = shapesize # Functions copied from RawTurtle with a few tweaks: def clone() -> Turtle: ... # Extra functions present only in the global scope: done = mainloop ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/unicodedata.pyi0000664000175000017500000000355600000000000024675 0ustar00davedave00000000000000import sys from typing import Any, Text, TypeVar, Union ucd_3_2_0: UCD ucnhash_CAPI: Any unidata_version: str _default = TypeVar("_default") def bidirectional(__chr: Text) -> Text: ... def category(__chr: Text) -> Text: ... def combining(__chr: Text) -> int: ... def decimal(__chr: Text, __default: _default = ...) -> Union[int, _default]: ... def decomposition(__chr: Text) -> Text: ... def digit(__chr: Text, __default: _default = ...) -> Union[int, _default]: ... def east_asian_width(__chr: Text) -> Text: ... if sys.version_info >= (3, 8): def is_normalized(__form: str, __unistr: str) -> bool: ... def lookup(__name: Union[Text, bytes]) -> Text: ... def mirrored(__chr: Text) -> int: ... def name(__chr: Text, __default: _default = ...) -> Union[Text, _default]: ... def normalize(__form: Text, __unistr: Text) -> Text: ... def numeric(__chr: Text, __default: _default = ...) -> Union[float, _default]: ... class UCD(object): # The methods below are constructed from the same array in C # (unicodedata_functions) and hence identical to the methods above. unidata_version: str def bidirectional(self, __chr: Text) -> str: ... def category(self, __chr: Text) -> str: ... def combining(self, __chr: Text) -> int: ... def decimal(self, __chr: Text, __default: _default = ...) -> Union[int, _default]: ... def decomposition(self, __chr: Text) -> str: ... def digit(self, __chr: Text, __default: _default = ...) -> Union[int, _default]: ... def east_asian_width(self, __chr: Text) -> str: ... def lookup(self, __name: Union[Text, bytes]) -> Text: ... def mirrored(self, __chr: Text) -> int: ... def name(self, __chr: Text, __default: _default = ...) -> Union[Text, _default]: ... def normalize(self, __form: Text, __unistr: Text) -> Text: ... def numeric(self, __chr: Text, __default: _default = ...) -> Union[float, _default]: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/uu.pyi0000664000175000017500000000104500000000000023035 0ustar00davedave00000000000000import sys from typing import BinaryIO, Optional, Text, Union _File = Union[Text, BinaryIO] class Error(Exception): ... if sys.version_info >= (3, 7): def encode( in_file: _File, out_file: _File, name: Optional[str] = ..., mode: Optional[int] = ..., *, backtick: bool = ... ) -> None: ... else: def encode(in_file: _File, out_file: _File, name: Optional[str] = ..., mode: Optional[int] = ...) -> None: ... def decode(in_file: _File, out_file: Optional[_File] = ..., mode: Optional[int] = ..., quiet: int = ...) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/uuid.pyi0000664000175000017500000000657000000000000023362 0ustar00davedave00000000000000import sys from typing import Any, Optional, Text, Tuple # Because UUID has properties called int and bytes we need to rename these temporarily. _Int = int _Bytes = bytes _FieldsType = Tuple[int, int, int, int, int, int] if sys.version_info >= (3, 7): from enum import Enum class SafeUUID(Enum): safe: int unsafe: int unknown: None class UUID: if sys.version_info >= (3, 7): def __init__( self, hex: Optional[Text] = ..., bytes: Optional[_Bytes] = ..., bytes_le: Optional[_Bytes] = ..., fields: Optional[_FieldsType] = ..., int: Optional[_Int] = ..., version: Optional[_Int] = ..., *, is_safe: SafeUUID = ..., ) -> None: ... @property def is_safe(self) -> SafeUUID: ... else: def __init__( self, hex: Optional[Text] = ..., bytes: Optional[_Bytes] = ..., bytes_le: Optional[_Bytes] = ..., fields: Optional[_FieldsType] = ..., int: Optional[_Int] = ..., version: Optional[_Int] = ..., ) -> None: ... @property def bytes(self) -> _Bytes: ... @property def bytes_le(self) -> _Bytes: ... @property def clock_seq(self) -> _Int: ... @property def clock_seq_hi_variant(self) -> _Int: ... @property def clock_seq_low(self) -> _Int: ... @property def fields(self) -> _FieldsType: ... @property def hex(self) -> str: ... @property def int(self) -> _Int: ... @property def node(self) -> _Int: ... @property def time(self) -> _Int: ... @property def time_hi_version(self) -> _Int: ... @property def time_low(self) -> _Int: ... @property def time_mid(self) -> _Int: ... @property def urn(self) -> str: ... @property def variant(self) -> str: ... @property def version(self) -> Optional[_Int]: ... def __int__(self) -> _Int: ... if sys.version_info >= (3,): def __eq__(self, other: Any) -> bool: ... def __lt__(self, other: Any) -> bool: ... def __le__(self, other: Any) -> bool: ... def __gt__(self, other: Any) -> bool: ... def __ge__(self, other: Any) -> bool: ... else: def get_bytes(self) -> _Bytes: ... def get_bytes_le(self) -> _Bytes: ... def get_clock_seq(self) -> _Int: ... def get_clock_seq_hi_variant(self) -> _Int: ... def get_clock_seq_low(self) -> _Int: ... def get_fields(self) -> _FieldsType: ... def get_hex(self) -> str: ... def get_node(self) -> _Int: ... def get_time(self) -> _Int: ... def get_time_hi_version(self) -> _Int: ... def get_time_low(self) -> _Int: ... def get_time_mid(self) -> _Int: ... def get_urn(self) -> str: ... def get_variant(self) -> str: ... def get_version(self) -> Optional[_Int]: ... def __cmp__(self, other: Any) -> _Int: ... def getnode() -> int: ... def uuid1(node: Optional[_Int] = ..., clock_seq: Optional[_Int] = ...) -> UUID: ... def uuid3(namespace: UUID, name: str) -> UUID: ... def uuid4() -> UUID: ... def uuid5(namespace: UUID, name: str) -> UUID: ... NAMESPACE_DNS: UUID NAMESPACE_URL: UUID NAMESPACE_OID: UUID NAMESPACE_X500: UUID RESERVED_NCS: str RFC_4122: str RESERVED_MICROSOFT: str RESERVED_FUTURE: str ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/warnings.pyi0000664000175000017500000000502700000000000024240 0ustar00davedave00000000000000import sys from types import ModuleType, TracebackType from typing import Any, List, Optional, TextIO, Type, Union, overload from typing_extensions import Literal from _warnings import warn as warn, warn_explicit as warn_explicit def showwarning( message: Union[Warning, str], category: Type[Warning], filename: str, lineno: int, file: Optional[TextIO] = ..., line: Optional[str] = ..., ) -> None: ... def formatwarning( message: Union[Warning, str], category: Type[Warning], filename: str, lineno: int, line: Optional[str] = ... ) -> str: ... def filterwarnings( action: str, message: str = ..., category: Type[Warning] = ..., module: str = ..., lineno: int = ..., append: bool = ... ) -> None: ... def simplefilter(action: str, category: Type[Warning] = ..., lineno: int = ..., append: bool = ...) -> None: ... def resetwarnings() -> None: ... class _OptionError(Exception): ... class WarningMessage: message: Union[Warning, str] category: Type[Warning] filename: str lineno: int file: Optional[TextIO] line: Optional[str] if sys.version_info >= (3, 6): source: Optional[Any] def __init__( self, message: Union[Warning, str], category: Type[Warning], filename: str, lineno: int, file: Optional[TextIO] = ..., line: Optional[str] = ..., source: Optional[Any] = ..., ) -> None: ... else: def __init__( self, message: Union[Warning, str], category: Type[Warning], filename: str, lineno: int, file: Optional[TextIO] = ..., line: Optional[str] = ..., ) -> None: ... class catch_warnings: @overload def __new__(cls, *, record: Literal[False] = ..., module: Optional[ModuleType] = ...) -> _catch_warnings_without_records: ... @overload def __new__(cls, *, record: Literal[True], module: Optional[ModuleType] = ...) -> _catch_warnings_with_records: ... @overload def __new__(cls, *, record: bool, module: Optional[ModuleType] = ...) -> catch_warnings: ... def __enter__(self) -> Optional[List[WarningMessage]]: ... def __exit__( self, exc_type: Optional[Type[BaseException]], exc_val: Optional[BaseException], exc_tb: Optional[TracebackType] ) -> None: ... class _catch_warnings_without_records(catch_warnings): def __enter__(self) -> None: ... class _catch_warnings_with_records(catch_warnings): def __enter__(self) -> List[WarningMessage]: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/wave.pyi0000664000175000017500000000513300000000000023350 0ustar00davedave00000000000000import sys from typing import IO, Any, BinaryIO, NamedTuple, NoReturn, Optional, Text, Tuple, Union _File = Union[Text, IO[bytes]] class Error(Exception): ... WAVE_FORMAT_PCM: int if sys.version_info < (3, 0): _wave_params = Tuple[int, int, int, int, str, str] else: class _wave_params(NamedTuple): nchannels: int sampwidth: int framerate: int nframes: int comptype: str compname: str class Wave_read: def __init__(self, f: _File) -> None: ... if sys.version_info >= (3, 0): def __enter__(self) -> Wave_read: ... def __exit__(self, *args: Any) -> None: ... def getfp(self) -> Optional[BinaryIO]: ... def rewind(self) -> None: ... def close(self) -> None: ... def tell(self) -> int: ... def getnchannels(self) -> int: ... def getnframes(self) -> int: ... def getsampwidth(self) -> int: ... def getframerate(self) -> int: ... def getcomptype(self) -> str: ... def getcompname(self) -> str: ... def getparams(self) -> _wave_params: ... def getmarkers(self) -> None: ... def getmark(self, id: Any) -> NoReturn: ... def setpos(self, pos: int) -> None: ... def readframes(self, nframes: int) -> bytes: ... class Wave_write: def __init__(self, f: _File) -> None: ... if sys.version_info >= (3, 0): def __enter__(self) -> Wave_write: ... def __exit__(self, *args: Any) -> None: ... def setnchannels(self, nchannels: int) -> None: ... def getnchannels(self) -> int: ... def setsampwidth(self, sampwidth: int) -> None: ... def getsampwidth(self) -> int: ... def setframerate(self, framerate: float) -> None: ... def getframerate(self) -> int: ... def setnframes(self, nframes: int) -> None: ... def getnframes(self) -> int: ... def setcomptype(self, comptype: str, compname: str) -> None: ... def getcomptype(self) -> str: ... def getcompname(self) -> str: ... def setparams(self, params: _wave_params) -> None: ... def getparams(self) -> _wave_params: ... def setmark(self, id: Any, pos: Any, name: Any) -> NoReturn: ... def getmark(self, id: Any) -> NoReturn: ... def getmarkers(self) -> None: ... def tell(self) -> int: ... # should be any bytes-like object after 3.4, but we don't have a type for that def writeframesraw(self, data: bytes) -> None: ... def writeframes(self, data: bytes) -> None: ... def close(self) -> None: ... # Returns a Wave_read if mode is rb and Wave_write if mode is wb def open(f: _File, mode: Optional[str] = ...) -> Any: ... if sys.version_info < (3, 9): openfp = open ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/weakref.pyi0000664000175000017500000001052100000000000024027 0ustar00davedave00000000000000import sys import types from _weakrefset import WeakSet as WeakSet from typing import ( Any, Callable, Dict, Generic, Iterable, Iterator, List, Mapping, MutableMapping, Optional, Tuple, Type, TypeVar, Union, overload, ) from _weakref import ( CallableProxyType as CallableProxyType, ProxyType as ProxyType, ReferenceType as ReferenceType, getweakrefcount as getweakrefcount, getweakrefs as getweakrefs, proxy as proxy, ref as ref, ) if sys.version_info < (3, 0): from exceptions import ReferenceError as ReferenceError _S = TypeVar("_S") _T = TypeVar("_T") _KT = TypeVar("_KT") _VT = TypeVar("_VT") ProxyTypes: Tuple[Type[Any], ...] if sys.version_info >= (3, 4): class WeakMethod(ref[types.MethodType]): def __new__(cls, meth: types.MethodType, callback: Optional[Callable[[types.MethodType], Any]] = ...) -> WeakMethod: ... def __call__(self) -> Optional[types.MethodType]: ... class WeakValueDictionary(MutableMapping[_KT, _VT]): @overload def __init__(self) -> None: ... @overload def __init__(self, __other: Union[Mapping[_KT, _VT], Iterable[Tuple[_KT, _VT]]], **kwargs: _VT) -> None: ... def __len__(self) -> int: ... def __getitem__(self, k: _KT) -> _VT: ... def __setitem__(self, k: _KT, v: _VT) -> None: ... def __delitem__(self, v: _KT) -> None: ... if sys.version_info < (3, 0): def has_key(self, key: object) -> bool: ... def __contains__(self, o: object) -> bool: ... def __iter__(self) -> Iterator[_KT]: ... def __str__(self) -> str: ... def copy(self) -> WeakValueDictionary[_KT, _VT]: ... if sys.version_info < (3, 0): def keys(self) -> List[_KT]: ... def values(self) -> List[_VT]: ... def items(self) -> List[Tuple[_KT, _VT]]: ... def iterkeys(self) -> Iterator[_KT]: ... def itervalues(self) -> Iterator[_VT]: ... def iteritems(self) -> Iterator[Tuple[_KT, _VT]]: ... else: # These are incompatible with Mapping def keys(self) -> Iterator[_KT]: ... # type: ignore def values(self) -> Iterator[_VT]: ... # type: ignore def items(self) -> Iterator[Tuple[_KT, _VT]]: ... # type: ignore def itervaluerefs(self) -> Iterator[KeyedRef[_KT, _VT]]: ... def valuerefs(self) -> List[KeyedRef[_KT, _VT]]: ... class KeyedRef(ref[_T], Generic[_KT, _T]): key: _KT def __new__(type, ob: _T, callback: Callable[[_T], Any], key: _KT) -> KeyedRef: ... def __init__(self, ob: _T, callback: Callable[[_T], Any], key: _KT) -> None: ... class WeakKeyDictionary(MutableMapping[_KT, _VT]): @overload def __init__(self, dict: None = ...) -> None: ... @overload def __init__(self, dict: Union[Mapping[_KT, _VT], Iterable[Tuple[_KT, _VT]]]) -> None: ... def __len__(self) -> int: ... def __getitem__(self, k: _KT) -> _VT: ... def __setitem__(self, k: _KT, v: _VT) -> None: ... def __delitem__(self, v: _KT) -> None: ... if sys.version_info < (3, 0): def has_key(self, key: object) -> bool: ... def __contains__(self, o: object) -> bool: ... def __iter__(self) -> Iterator[_KT]: ... def __str__(self) -> str: ... def copy(self) -> WeakKeyDictionary[_KT, _VT]: ... if sys.version_info < (3, 0): def keys(self) -> List[_KT]: ... def values(self) -> List[_VT]: ... def items(self) -> List[Tuple[_KT, _VT]]: ... def iterkeys(self) -> Iterator[_KT]: ... def itervalues(self) -> Iterator[_VT]: ... def iteritems(self) -> Iterator[Tuple[_KT, _VT]]: ... def iterkeyrefs(self) -> Iterator[ref[_KT]]: ... else: # These are incompatible with Mapping def keys(self) -> Iterator[_KT]: ... # type: ignore def values(self) -> Iterator[_VT]: ... # type: ignore def items(self) -> Iterator[Tuple[_KT, _VT]]: ... # type: ignore def keyrefs(self) -> List[ref[_KT]]: ... if sys.version_info >= (3, 4): class finalize: def __init__(self, __obj: _S, __func: Callable[..., _T], *args: Any, **kwargs: Any) -> None: ... def __call__(self, _: Any = ...) -> Optional[_T]: ... def detach(self) -> Optional[Tuple[_S, _T, Tuple[Any, ...], Dict[str, Any]]]: ... def peek(self) -> Optional[Tuple[_S, _T, Tuple[Any, ...], Dict[str, Any]]]: ... alive: bool atexit: bool ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/webbrowser.pyi0000664000175000017500000000633700000000000024576 0ustar00davedave00000000000000import sys from typing import Callable, List, Optional, Sequence, Text, Union class Error(Exception): ... if sys.version_info >= (3, 7): def register( name: Text, klass: Optional[Callable[[], BaseBrowser]], instance: Optional[BaseBrowser] = ..., *, preferred: bool = ... ) -> None: ... else: def register( name: Text, klass: Optional[Callable[[], BaseBrowser]], instance: Optional[BaseBrowser] = ..., update_tryorder: int = ... ) -> None: ... def get(using: Optional[Text] = ...) -> BaseBrowser: ... def open(url: Text, new: int = ..., autoraise: bool = ...) -> bool: ... def open_new(url: Text) -> bool: ... def open_new_tab(url: Text) -> bool: ... class BaseBrowser: args: List[str] name: str basename: str def __init__(self, name: Text = ...) -> None: ... def open(self, url: Text, new: int = ..., autoraise: bool = ...) -> bool: ... def open_new(self, url: Text) -> bool: ... def open_new_tab(self, url: Text) -> bool: ... class GenericBrowser(BaseBrowser): args: List[str] name: str basename: str def __init__(self, name: Union[Text, Sequence[Text]]) -> None: ... def open(self, url: Text, new: int = ..., autoraise: bool = ...) -> bool: ... class BackgroundBrowser(GenericBrowser): def open(self, url: Text, new: int = ..., autoraise: bool = ...) -> bool: ... class UnixBrowser(BaseBrowser): raise_opts: List[str] background: bool redirect_stdout: bool remote_args: List[str] remote_action: str remote_action_newwin: str remote_action_newtab: str def open(self, url: Text, new: int = ..., autoraise: bool = ...) -> bool: ... class Mozilla(UnixBrowser): raise_opts: List[str] remote_args: List[str] remote_action: str remote_action_newwin: str remote_action_newtab: str background: bool class Galeon(UnixBrowser): raise_opts: List[str] remote_args: List[str] remote_action: str remote_action_newwin: str background: bool class Chrome(UnixBrowser): remote_args: List[str] remote_action: str remote_action_newwin: str remote_action_newtab: str background: bool class Opera(UnixBrowser): raise_opts: List[str] remote_args: List[str] remote_action: str remote_action_newwin: str remote_action_newtab: str background: bool class Elinks(UnixBrowser): remote_args: List[str] remote_action: str remote_action_newwin: str remote_action_newtab: str background: bool redirect_stdout: bool class Konqueror(BaseBrowser): def open(self, url: Text, new: int = ..., autoraise: bool = ...) -> bool: ... class Grail(BaseBrowser): def open(self, url: Text, new: int = ..., autoraise: bool = ...) -> bool: ... if sys.platform == "win32": class WindowsDefault(BaseBrowser): def open(self, url: Text, new: int = ..., autoraise: bool = ...) -> bool: ... if sys.platform == "darwin": class MacOSX(BaseBrowser): name: str def __init__(self, name: Text) -> None: ... def open(self, url: Text, new: int = ..., autoraise: bool = ...) -> bool: ... class MacOSXOSAScript(BaseBrowser): def __init__(self, name: Text) -> None: ... def open(self, url: Text, new: int = ..., autoraise: bool = ...) -> bool: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/winsound.pyi0000664000175000017500000000145300000000000024255 0ustar00davedave00000000000000import sys from typing import Optional, Union, overload from typing_extensions import Literal if sys.platform == "win32": SND_FILENAME: int SND_ALIAS: int SND_LOOP: int SND_MEMORY: int SND_PURGE: int SND_ASYNC: int SND_NODEFAULT: int SND_NOSTOP: int SND_NOWAIT: int MB_ICONASTERISK: int MB_ICONEXCLAMATION: int MB_ICONHAND: int MB_ICONQUESTION: int MB_OK: int def Beep(frequency: int, duration: int) -> None: ... # Can actually accept anything ORed with 4, and if not it's definitely str, but that's inexpressible @overload def PlaySound(sound: Optional[bytes], flags: Literal[4]) -> None: ... @overload def PlaySound(sound: Optional[Union[str, bytes]], flags: int) -> None: ... def MessageBeep(type: int = ...) -> None: ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4263792 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/wsgiref/0000775000175000017500000000000000000000000023327 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/wsgiref/__init__.pyi0000664000175000017500000000000000000000000025577 0ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/wsgiref/handlers.pyi0000664000175000017500000000606500000000000025661 0ustar00davedave00000000000000import sys from abc import abstractmethod from types import TracebackType from typing import IO, Callable, Dict, List, MutableMapping, Optional, Text, Tuple, Type from .headers import Headers from .types import ErrorStream, InputStream, StartResponse, WSGIApplication, WSGIEnvironment from .util import FileWrapper _exc_info = Tuple[Optional[Type[BaseException]], Optional[BaseException], Optional[TracebackType]] def format_date_time(timestamp: Optional[float]) -> str: ... # undocumented if sys.version_info >= (3, 2): def read_environ() -> Dict[str, str]: ... class BaseHandler: wsgi_version: Tuple[int, int] # undocumented wsgi_multithread: bool wsgi_multiprocess: bool wsgi_run_once: bool origin_server: bool http_version: str server_software: Optional[str] os_environ: MutableMapping[str, str] wsgi_file_wrapper: Optional[Type[FileWrapper]] headers_class: Type[Headers] # undocumented traceback_limit: Optional[int] error_status: str error_headers: List[Tuple[Text, Text]] error_body: bytes def run(self, application: WSGIApplication) -> None: ... def setup_environ(self) -> None: ... def finish_response(self) -> None: ... def get_scheme(self) -> str: ... def set_content_length(self) -> None: ... def cleanup_headers(self) -> None: ... def start_response( self, status: Text, headers: List[Tuple[Text, Text]], exc_info: Optional[_exc_info] = ... ) -> Callable[[bytes], None]: ... def send_preamble(self) -> None: ... def write(self, data: bytes) -> None: ... def sendfile(self) -> bool: ... def finish_content(self) -> None: ... def close(self) -> None: ... def send_headers(self) -> None: ... def result_is_file(self) -> bool: ... def client_is_modern(self) -> bool: ... def log_exception(self, exc_info: _exc_info) -> None: ... def handle_error(self) -> None: ... def error_output(self, environ: WSGIEnvironment, start_response: StartResponse) -> List[bytes]: ... @abstractmethod def _write(self, data: bytes) -> None: ... @abstractmethod def _flush(self) -> None: ... @abstractmethod def get_stdin(self) -> InputStream: ... @abstractmethod def get_stderr(self) -> ErrorStream: ... @abstractmethod def add_cgi_vars(self) -> None: ... class SimpleHandler(BaseHandler): stdin: InputStream stdout: IO[bytes] stderr: ErrorStream base_env: MutableMapping[str, str] def __init__( self, stdin: InputStream, stdout: IO[bytes], stderr: ErrorStream, environ: MutableMapping[str, str], multithread: bool = ..., multiprocess: bool = ..., ) -> None: ... def get_stdin(self) -> InputStream: ... def get_stderr(self) -> ErrorStream: ... def add_cgi_vars(self) -> None: ... def _write(self, data: bytes) -> None: ... def _flush(self) -> None: ... class BaseCGIHandler(SimpleHandler): ... class CGIHandler(BaseCGIHandler): def __init__(self) -> None: ... class IISCGIHandler(BaseCGIHandler): def __init__(self) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/wsgiref/headers.pyi0000664000175000017500000000234200000000000025466 0ustar00davedave00000000000000import sys from typing import List, Optional, Pattern, Tuple, overload _HeaderList = List[Tuple[str, str]] tspecials: Pattern[str] # undocumented class Headers: if sys.version_info < (3, 5): def __init__(self, headers: _HeaderList) -> None: ... else: def __init__(self, headers: Optional[_HeaderList] = ...) -> None: ... def __len__(self) -> int: ... def __setitem__(self, name: str, val: str) -> None: ... def __delitem__(self, name: str) -> None: ... def __getitem__(self, name: str) -> Optional[str]: ... if sys.version_info < (3,): def has_key(self, name: str) -> bool: ... def __contains__(self, name: str) -> bool: ... def get_all(self, name: str) -> List[str]: ... @overload def get(self, name: str, default: str) -> str: ... @overload def get(self, name: str, default: Optional[str] = ...) -> Optional[str]: ... def keys(self) -> List[str]: ... def values(self) -> List[str]: ... def items(self) -> _HeaderList: ... if sys.version_info >= (3,): def __bytes__(self) -> bytes: ... def setdefault(self, name: str, value: str) -> str: ... def add_header(self, _name: str, _value: Optional[str], **_params: Optional[str]) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/wsgiref/simple_server.pyi0000664000175000017500000000277000000000000026737 0ustar00davedave00000000000000import sys from typing import List, Optional, Type, TypeVar, overload from .handlers import SimpleHandler from .types import ErrorStream, StartResponse, WSGIApplication, WSGIEnvironment if sys.version_info < (3,): from BaseHTTPServer import BaseHTTPRequestHandler, HTTPServer else: from http.server import BaseHTTPRequestHandler, HTTPServer server_version: str # undocumented sys_version: str # undocumented software_version: str # undocumented class ServerHandler(SimpleHandler): # undocumented server_software: str def close(self) -> None: ... class WSGIServer(HTTPServer): application: Optional[WSGIApplication] base_environ: WSGIEnvironment # only available after call to setup_environ() def setup_environ(self) -> None: ... def get_app(self) -> Optional[WSGIApplication]: ... def set_app(self, application: Optional[WSGIApplication]) -> None: ... class WSGIRequestHandler(BaseHTTPRequestHandler): server_version: str def get_environ(self) -> WSGIEnvironment: ... def get_stderr(self) -> ErrorStream: ... def handle(self) -> None: ... def demo_app(environ: WSGIEnvironment, start_response: StartResponse) -> List[bytes]: ... _S = TypeVar("_S", bound=WSGIServer) @overload def make_server(host: str, port: int, app: WSGIApplication, *, handler_class: Type[WSGIRequestHandler] = ...) -> WSGIServer: ... @overload def make_server( host: str, port: int, app: WSGIApplication, server_class: Type[_S], handler_class: Type[WSGIRequestHandler] = ... ) -> _S: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/wsgiref/types.pyi0000664000175000017500000000010700000000000025214 0ustar00davedave00000000000000# Obsolete, use _typeshed.wsgi directly. from _typeshed.wsgi import * ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/wsgiref/util.pyi0000664000175000017500000000157500000000000025037 0ustar00davedave00000000000000import sys from typing import IO, Any, Callable, Optional from .types import WSGIEnvironment class FileWrapper: filelike: IO[bytes] blksize: int close: Callable[[], None] # only exists if filelike.close exists def __init__(self, filelike: IO[bytes], blksize: int = ...) -> None: ... def __getitem__(self, key: Any) -> bytes: ... def __iter__(self) -> FileWrapper: ... if sys.version_info < (3,): def next(self) -> bytes: ... else: def __next__(self) -> bytes: ... def guess_scheme(environ: WSGIEnvironment) -> str: ... def application_uri(environ: WSGIEnvironment) -> str: ... def request_uri(environ: WSGIEnvironment, include_query: bool = ...) -> str: ... def shift_path_info(environ: WSGIEnvironment) -> Optional[str]: ... def setup_testing_defaults(environ: WSGIEnvironment) -> None: ... def is_hop_by_hop(header_name: str) -> bool: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/wsgiref/validate.pyi0000664000175000017500000000350500000000000025646 0ustar00davedave00000000000000import sys from _typeshed.wsgi import ErrorStream, InputStream, WSGIApplication from typing import Any, Callable, Iterable, Iterator, NoReturn, Optional class WSGIWarning(Warning): ... def validator(application: WSGIApplication) -> WSGIApplication: ... class InputWrapper: input: InputStream def __init__(self, wsgi_input: InputStream) -> None: ... if sys.version_info < (3,): def read(self, size: int = ...) -> bytes: ... def readline(self) -> bytes: ... else: def read(self, size: int) -> bytes: ... def readline(self, size: int = ...) -> bytes: ... def readlines(self, hint: int = ...) -> bytes: ... def __iter__(self) -> Iterable[bytes]: ... def close(self) -> NoReturn: ... class ErrorWrapper: errors: ErrorStream def __init__(self, wsgi_errors: ErrorStream) -> None: ... def write(self, s: str) -> None: ... def flush(self) -> None: ... def writelines(self, seq: Iterable[str]) -> None: ... def close(self) -> NoReturn: ... class WriteWrapper: writer: Callable[[bytes], Any] def __init__(self, wsgi_writer: Callable[[bytes], Any]) -> None: ... def __call__(self, s: bytes) -> None: ... class PartialIteratorWrapper: iterator: Iterator[bytes] def __init__(self, wsgi_iterator: Iterator[bytes]) -> None: ... def __iter__(self) -> IteratorWrapper: ... class IteratorWrapper: original_iterator: Iterator[bytes] iterator: Iterator[bytes] closed: bool check_start_response: Optional[bool] def __init__(self, wsgi_iterator: Iterator[bytes], check_start_response: Optional[bool]) -> None: ... def __iter__(self) -> IteratorWrapper: ... if sys.version_info < (3,): def next(self) -> bytes: ... else: def __next__(self) -> bytes: ... def close(self) -> None: ... def __del__(self) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/xdrlib.pyi0000664000175000017500000000441300000000000023672 0ustar00davedave00000000000000from typing import Callable, List, Sequence, TypeVar _T = TypeVar("_T") class Error(Exception): msg: str def __init__(self, msg: str) -> None: ... class ConversionError(Error): ... class Packer: def __init__(self) -> None: ... def reset(self) -> None: ... def get_buffer(self) -> bytes: ... def get_buf(self) -> bytes: ... def pack_uint(self, x: int) -> None: ... def pack_int(self, x: int) -> None: ... def pack_enum(self, x: int) -> None: ... def pack_bool(self, x: bool) -> None: ... def pack_uhyper(self, x: int) -> None: ... def pack_hyper(self, x: int) -> None: ... def pack_float(self, x: float) -> None: ... def pack_double(self, x: float) -> None: ... def pack_fstring(self, n: int, s: bytes) -> None: ... def pack_fopaque(self, n: int, s: bytes) -> None: ... def pack_string(self, s: bytes) -> None: ... def pack_opaque(self, s: bytes) -> None: ... def pack_bytes(self, s: bytes) -> None: ... def pack_list(self, list: Sequence[_T], pack_item: Callable[[_T], None]) -> None: ... def pack_farray(self, n: int, list: Sequence[_T], pack_item: Callable[[_T], None]) -> None: ... def pack_array(self, list: Sequence[_T], pack_item: Callable[[_T], None]) -> None: ... class Unpacker: def __init__(self, data: bytes) -> None: ... def reset(self, data: bytes) -> None: ... def get_position(self) -> int: ... def set_position(self, position: int) -> None: ... def get_buffer(self) -> bytes: ... def done(self) -> None: ... def unpack_uint(self) -> int: ... def unpack_int(self) -> int: ... def unpack_enum(self) -> int: ... def unpack_bool(self) -> bool: ... def unpack_uhyper(self) -> int: ... def unpack_hyper(self) -> int: ... def unpack_float(self) -> float: ... def unpack_double(self) -> float: ... def unpack_fstring(self, n: int) -> bytes: ... def unpack_fopaque(self, n: int) -> bytes: ... def unpack_string(self) -> bytes: ... def unpack_opaque(self) -> bytes: ... def unpack_bytes(self) -> bytes: ... def unpack_list(self, unpack_item: Callable[[], _T]) -> List[_T]: ... def unpack_farray(self, n: int, unpack_item: Callable[[], _T]) -> List[_T]: ... def unpack_array(self, unpack_item: Callable[[], _T]) -> List[_T]: ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4263792 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/xml/0000775000175000017500000000000000000000000022461 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/xml/__init__.pyi0000664000175000017500000000003600000000000024742 0ustar00davedave00000000000000import xml.parsers as parsers ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4263792 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/xml/dom/0000775000175000017500000000000000000000000023240 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/xml/dom/NodeFilter.pyi0000664000175000017500000000071100000000000026015 0ustar00davedave00000000000000class NodeFilter: FILTER_ACCEPT: int FILTER_REJECT: int FILTER_SKIP: int SHOW_ALL: int SHOW_ELEMENT: int SHOW_ATTRIBUTE: int SHOW_TEXT: int SHOW_CDATA_SECTION: int SHOW_ENTITY_REFERENCE: int SHOW_ENTITY: int SHOW_PROCESSING_INSTRUCTION: int SHOW_COMMENT: int SHOW_DOCUMENT: int SHOW_DOCUMENT_TYPE: int SHOW_DOCUMENT_FRAGMENT: int SHOW_NOTATION: int def acceptNode(self, node) -> int: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/xml/dom/__init__.pyi0000664000175000017500000000346400000000000025531 0ustar00davedave00000000000000from typing import Any from .domreg import getDOMImplementation as getDOMImplementation, registerDOMImplementation as registerDOMImplementation class Node: ELEMENT_NODE: int ATTRIBUTE_NODE: int TEXT_NODE: int CDATA_SECTION_NODE: int ENTITY_REFERENCE_NODE: int ENTITY_NODE: int PROCESSING_INSTRUCTION_NODE: int COMMENT_NODE: int DOCUMENT_NODE: int DOCUMENT_TYPE_NODE: int DOCUMENT_FRAGMENT_NODE: int NOTATION_NODE: int # ExceptionCode INDEX_SIZE_ERR: int DOMSTRING_SIZE_ERR: int HIERARCHY_REQUEST_ERR: int WRONG_DOCUMENT_ERR: int INVALID_CHARACTER_ERR: int NO_DATA_ALLOWED_ERR: int NO_MODIFICATION_ALLOWED_ERR: int NOT_FOUND_ERR: int NOT_SUPPORTED_ERR: int INUSE_ATTRIBUTE_ERR: int INVALID_STATE_ERR: int SYNTAX_ERR: int INVALID_MODIFICATION_ERR: int NAMESPACE_ERR: int INVALID_ACCESS_ERR: int VALIDATION_ERR: int class DOMException(Exception): code: int def __init__(self, *args: Any, **kw: Any) -> None: ... def _get_code(self) -> int: ... class IndexSizeErr(DOMException): ... class DomstringSizeErr(DOMException): ... class HierarchyRequestErr(DOMException): ... class WrongDocumentErr(DOMException): ... class NoDataAllowedErr(DOMException): ... class NoModificationAllowedErr(DOMException): ... class NotFoundErr(DOMException): ... class NotSupportedErr(DOMException): ... class InuseAttributeErr(DOMException): ... class InvalidStateErr(DOMException): ... class SyntaxErr(DOMException): ... class InvalidModificationErr(DOMException): ... class NamespaceErr(DOMException): ... class InvalidAccessErr(DOMException): ... class ValidationErr(DOMException): ... class UserDataHandler: NODE_CLONED: int NODE_IMPORTED: int NODE_DELETED: int NODE_RENAMED: int XML_NAMESPACE: str XMLNS_NAMESPACE: str XHTML_NAMESPACE: str EMPTY_NAMESPACE: None EMPTY_PREFIX: None ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/xml/dom/domreg.pyi0000664000175000017500000000071600000000000025244 0ustar00davedave00000000000000from _typeshed.xml import DOMImplementation from typing import Any, Callable, Dict, Iterable, Optional, Tuple, Union well_known_implementations: Dict[str, str] registered: Dict[str, Callable[[], DOMImplementation]] def registerDOMImplementation(name: str, factory: Callable[[], DOMImplementation]) -> None: ... def getDOMImplementation( name: Optional[str] = ..., features: Union[str, Iterable[Tuple[str, Optional[str]]]] = ... ) -> DOMImplementation: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/xml/dom/expatbuilder.pyi0000664000175000017500000000011500000000000026450 0ustar00davedave00000000000000from typing import Any def __getattr__(name: str) -> Any: ... # incomplete ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/xml/dom/minicompat.pyi0000664000175000017500000000011500000000000026120 0ustar00davedave00000000000000from typing import Any def __getattr__(name: str) -> Any: ... # incomplete ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/xml/dom/minidom.pyi0000664000175000017500000000043700000000000025423 0ustar00davedave00000000000000from typing import Any, Optional from xml.sax.xmlreader import XMLReader def parse(file: str, parser: Optional[XMLReader] = ..., bufsize: Optional[int] = ...): ... def parseString(string: str, parser: Optional[XMLReader] = ...): ... def __getattr__(name: str) -> Any: ... # incomplete ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/xml/dom/pulldom.pyi0000664000175000017500000000011500000000000025434 0ustar00davedave00000000000000from typing import Any def __getattr__(name: str) -> Any: ... # incomplete ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/xml/dom/xmlbuilder.pyi0000664000175000017500000000011500000000000026127 0ustar00davedave00000000000000from typing import Any def __getattr__(name: str) -> Any: ... # incomplete ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4263792 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/xml/etree/0000775000175000017500000000000000000000000023565 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/xml/etree/ElementInclude.pyi0000664000175000017500000000155100000000000027207 0ustar00davedave00000000000000import sys from typing import Callable, Optional, Union from xml.etree.ElementTree import Element XINCLUDE: str XINCLUDE_INCLUDE: str XINCLUDE_FALLBACK: str class FatalIncludeError(SyntaxError): ... def default_loader(href: Union[str, bytes, int], parse: str, encoding: Optional[str] = ...) -> Union[str, Element]: ... # TODO: loader is of type default_loader ie it takes a callable that has the # same signature as default_loader. But default_loader has a keyword argument # Which can't be represented using Callable... if sys.version_info >= (3, 9): def include( elem: Element, loader: Optional[Callable[..., Union[str, Element]]] = ..., base_url: Optional[str] = ..., max_depth: Optional[int] = ..., ) -> None: ... else: def include(elem: Element, loader: Optional[Callable[..., Union[str, Element]]] = ...) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/xml/etree/ElementPath.pyi0000664000175000017500000000303100000000000026513 0ustar00davedave00000000000000from typing import Callable, Dict, Generator, List, Optional, Pattern, Tuple, TypeVar, Union from xml.etree.ElementTree import Element xpath_tokenizer_re: Pattern[str] _token = Tuple[str, str] _next = Callable[[], _token] _callback = Callable[[_SelectorContext, List[Element]], Generator[Element, None, None]] def xpath_tokenizer(pattern: str, namespaces: Optional[Dict[str, str]] = ...) -> Generator[_token, None, None]: ... def get_parent_map(context: _SelectorContext) -> Dict[Element, Element]: ... def prepare_child(next: _next, token: _token) -> _callback: ... def prepare_star(next: _next, token: _token) -> _callback: ... def prepare_self(next: _next, token: _token) -> _callback: ... def prepare_descendant(next: _next, token: _token) -> _callback: ... def prepare_parent(next: _next, token: _token) -> _callback: ... def prepare_predicate(next: _next, token: _token) -> _callback: ... ops: Dict[str, Callable[[_next, _token], _callback]] class _SelectorContext: parent_map: Dict[Element, Element] root: Element def __init__(self, root: Element) -> None: ... _T = TypeVar("_T") def iterfind(elem: Element, path: str, namespaces: Optional[Dict[str, str]] = ...) -> List[Element]: ... def find(elem: Element, path: str, namespaces: Optional[Dict[str, str]] = ...) -> Optional[Element]: ... def findall(elem: Element, path: str, namespaces: Optional[Dict[str, str]] = ...) -> List[Element]: ... def findtext( elem: Element, path: str, default: Optional[_T] = ..., namespaces: Optional[Dict[str, str]] = ... ) -> Union[_T, str]: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/xml/etree/ElementTree.pyi0000664000175000017500000003507100000000000026527 0ustar00davedave00000000000000import sys from _typeshed import AnyPath, FileDescriptor, SupportsWrite from typing import ( IO, Any, Callable, Dict, Generator, ItemsView, Iterable, Iterator, KeysView, List, MutableSequence, Optional, Sequence, Text, Tuple, TypeVar, Union, overload, ) from typing_extensions import Literal VERSION: str class ParseError(SyntaxError): code: int position: Tuple[int, int] def iselement(element: object) -> bool: ... _T = TypeVar("_T") # Type for parser inputs. Parser will accept any unicode/str/bytes and coerce, # and this is true in py2 and py3 (even fromstringlist() in python3 can be # called with a heterogeneous list) _parser_input_type = Union[bytes, Text] # Type for individual tag/attr/ns/text values in args to most functions. # In py2, the library accepts str or unicode everywhere and coerces # aggressively. # In py3, bytes is not coerced to str and so use of bytes is probably an error, # so we exclude it. (why? the parser never produces bytes when it parses XML, # so e.g., element.get(b'name') will always return None for parsed XML, even if # there is a 'name' attribute.) _str_argument_type = Union[str, Text] # Type for return values from individual tag/attr/text values if sys.version_info >= (3,): # note: in python3, everything comes out as str, yay: _str_result_type = str else: # in python2, if the tag/attribute/text wasn't decode-able as ascii, it # comes out as a unicode string; otherwise it comes out as str. (see # _fixtext function in the source). Client code knows best: _str_result_type = Any _file_or_filename = Union[AnyPath, FileDescriptor, IO[Any]] if sys.version_info >= (3, 8): @overload def canonicalize( xml_data: Optional[_parser_input_type] = ..., *, out: None = ..., from_file: Optional[_file_or_filename] = ..., with_comments: bool = ..., strip_text: bool = ..., rewrite_prefixes: bool = ..., qname_aware_tags: Optional[Iterable[str]] = ..., qname_aware_attrs: Optional[Iterable[str]] = ..., exclude_attrs: Optional[Iterable[str]] = ..., exclude_tags: Optional[Iterable[str]] = ..., ) -> str: ... @overload def canonicalize( xml_data: Optional[_parser_input_type] = ..., *, out: SupportsWrite[str], from_file: Optional[_file_or_filename] = ..., with_comments: bool = ..., strip_text: bool = ..., rewrite_prefixes: bool = ..., qname_aware_tags: Optional[Iterable[str]] = ..., qname_aware_attrs: Optional[Iterable[str]] = ..., exclude_attrs: Optional[Iterable[str]] = ..., exclude_tags: Optional[Iterable[str]] = ..., ) -> None: ... class Element(MutableSequence[Element]): tag: _str_result_type attrib: Dict[_str_result_type, _str_result_type] text: Optional[_str_result_type] tail: Optional[_str_result_type] def __init__( self, tag: Union[_str_argument_type, Callable[..., Element]], attrib: Dict[_str_argument_type, _str_argument_type] = ..., **extra: _str_argument_type, ) -> None: ... def append(self, __subelement: Element) -> None: ... def clear(self) -> None: ... def extend(self, __elements: Iterable[Element]) -> None: ... def find( self, path: _str_argument_type, namespaces: Optional[Dict[_str_argument_type, _str_argument_type]] = ... ) -> Optional[Element]: ... def findall( self, path: _str_argument_type, namespaces: Optional[Dict[_str_argument_type, _str_argument_type]] = ... ) -> List[Element]: ... @overload def findtext( self, path: _str_argument_type, default: None = ..., namespaces: Optional[Dict[_str_argument_type, _str_argument_type]] = ..., ) -> Optional[_str_result_type]: ... @overload def findtext( self, path: _str_argument_type, default: _T, namespaces: Optional[Dict[_str_argument_type, _str_argument_type]] = ... ) -> Union[_T, _str_result_type]: ... @overload def get(self, key: _str_argument_type, default: None = ...) -> Optional[_str_result_type]: ... @overload def get(self, key: _str_argument_type, default: _T) -> Union[_str_result_type, _T]: ... if sys.version_info >= (3, 2): def insert(self, __index: int, __subelement: Element) -> None: ... else: def insert(self, __index: int, __element: Element) -> None: ... def items(self) -> ItemsView[_str_result_type, _str_result_type]: ... def iter(self, tag: Optional[_str_argument_type] = ...) -> Generator[Element, None, None]: ... def iterfind( self, path: _str_argument_type, namespaces: Optional[Dict[_str_argument_type, _str_argument_type]] = ... ) -> List[Element]: ... def itertext(self) -> Generator[_str_result_type, None, None]: ... def keys(self) -> KeysView[_str_result_type]: ... def makeelement(self, __tag: _str_argument_type, __attrib: Dict[_str_argument_type, _str_argument_type]) -> Element: ... def remove(self, __subelement: Element) -> None: ... def set(self, __key: _str_argument_type, __value: _str_argument_type) -> None: ... def __delitem__(self, i: Union[int, slice]) -> None: ... @overload def __getitem__(self, i: int) -> Element: ... @overload def __getitem__(self, s: slice) -> MutableSequence[Element]: ... def __len__(self) -> int: ... @overload def __setitem__(self, i: int, o: Element) -> None: ... @overload def __setitem__(self, s: slice, o: Iterable[Element]) -> None: ... if sys.version_info < (3, 9): def getchildren(self) -> List[Element]: ... def getiterator(self, tag: Optional[_str_argument_type] = ...) -> List[Element]: ... def SubElement( parent: Element, tag: _str_argument_type, attrib: Dict[_str_argument_type, _str_argument_type] = ..., **extra: _str_argument_type, ) -> Element: ... def Comment(text: Optional[_str_argument_type] = ...) -> Element: ... def ProcessingInstruction(target: _str_argument_type, text: Optional[_str_argument_type] = ...) -> Element: ... PI: Callable[..., Element] class QName: text: str def __init__(self, text_or_uri: _str_argument_type, tag: Optional[_str_argument_type] = ...) -> None: ... class ElementTree: def __init__(self, element: Optional[Element] = ..., file: Optional[_file_or_filename] = ...) -> None: ... def getroot(self) -> Element: ... def parse(self, source: _file_or_filename, parser: Optional[XMLParser] = ...) -> Element: ... def iter(self, tag: Optional[_str_argument_type] = ...) -> Generator[Element, None, None]: ... if sys.version_info < (3, 9): def getiterator(self, tag: Optional[_str_argument_type] = ...) -> List[Element]: ... def find( self, path: _str_argument_type, namespaces: Optional[Dict[_str_argument_type, _str_argument_type]] = ... ) -> Optional[Element]: ... @overload def findtext( self, path: _str_argument_type, default: None = ..., namespaces: Optional[Dict[_str_argument_type, _str_argument_type]] = ..., ) -> Optional[_str_result_type]: ... @overload def findtext( self, path: _str_argument_type, default: _T, namespaces: Optional[Dict[_str_argument_type, _str_argument_type]] = ... ) -> Union[_T, _str_result_type]: ... def findall( self, path: _str_argument_type, namespaces: Optional[Dict[_str_argument_type, _str_argument_type]] = ... ) -> List[Element]: ... def iterfind( self, path: _str_argument_type, namespaces: Optional[Dict[_str_argument_type, _str_argument_type]] = ... ) -> List[Element]: ... if sys.version_info >= (3, 4): def write( self, file_or_filename: _file_or_filename, encoding: Optional[str] = ..., xml_declaration: Optional[bool] = ..., default_namespace: Optional[_str_argument_type] = ..., method: Optional[str] = ..., *, short_empty_elements: bool = ..., ) -> None: ... else: def write( self, file_or_filename: _file_or_filename, encoding: Optional[str] = ..., xml_declaration: Optional[bool] = ..., default_namespace: Optional[_str_argument_type] = ..., method: Optional[str] = ..., ) -> None: ... def write_c14n(self, file: _file_or_filename) -> None: ... def register_namespace(prefix: _str_argument_type, uri: _str_argument_type) -> None: ... if sys.version_info >= (3, 8): @overload def tostring( element: Element, encoding: None = ..., method: Optional[str] = ..., *, xml_declaration: Optional[bool] = ..., default_namespace: Optional[_str_argument_type] = ..., short_empty_elements: bool = ..., ) -> bytes: ... @overload def tostring( element: Element, encoding: Literal["unicode"], method: Optional[str] = ..., *, xml_declaration: Optional[bool] = ..., default_namespace: Optional[_str_argument_type] = ..., short_empty_elements: bool = ..., ) -> str: ... @overload def tostring( element: Element, encoding: str, method: Optional[str] = ..., *, xml_declaration: Optional[bool] = ..., default_namespace: Optional[_str_argument_type] = ..., short_empty_elements: bool = ..., ) -> Any: ... @overload def tostringlist( element: Element, encoding: None = ..., method: Optional[str] = ..., *, xml_declaration: Optional[bool] = ..., default_namespace: Optional[_str_argument_type] = ..., short_empty_elements: bool = ..., ) -> List[bytes]: ... @overload def tostringlist( element: Element, encoding: Literal["unicode"], method: Optional[str] = ..., *, xml_declaration: Optional[bool] = ..., default_namespace: Optional[_str_argument_type] = ..., short_empty_elements: bool = ..., ) -> List[str]: ... @overload def tostringlist( element: Element, encoding: str, method: Optional[str] = ..., *, xml_declaration: Optional[bool] = ..., default_namespace: Optional[_str_argument_type] = ..., short_empty_elements: bool = ..., ) -> List[Any]: ... elif sys.version_info >= (3,): @overload def tostring( element: Element, encoding: None = ..., method: Optional[str] = ..., *, short_empty_elements: bool = ... ) -> bytes: ... @overload def tostring( element: Element, encoding: Literal["unicode"], method: Optional[str] = ..., *, short_empty_elements: bool = ... ) -> str: ... @overload def tostring(element: Element, encoding: str, method: Optional[str] = ..., *, short_empty_elements: bool = ...) -> Any: ... @overload def tostringlist( element: Element, encoding: None = ..., method: Optional[str] = ..., *, short_empty_elements: bool = ... ) -> List[bytes]: ... @overload def tostringlist( element: Element, encoding: Literal["unicode"], method: Optional[str] = ..., *, short_empty_elements: bool = ... ) -> List[str]: ... @overload def tostringlist( element: Element, encoding: str, method: Optional[str] = ..., *, short_empty_elements: bool = ... ) -> List[Any]: ... else: def tostring(element: Element, encoding: Optional[str] = ..., method: Optional[str] = ...) -> bytes: ... def tostringlist(element: Element, encoding: Optional[str] = ..., method: Optional[str] = ...) -> List[bytes]: ... def dump(elem: Element) -> None: ... def parse(source: _file_or_filename, parser: Optional[XMLParser] = ...) -> ElementTree: ... def iterparse( source: _file_or_filename, events: Optional[Sequence[str]] = ..., parser: Optional[XMLParser] = ... ) -> Iterator[Tuple[str, Any]]: ... if sys.version_info >= (3, 4): class XMLPullParser: def __init__(self, events: Optional[Sequence[str]] = ..., *, _parser: Optional[XMLParser] = ...) -> None: ... def feed(self, data: bytes) -> None: ... def close(self) -> None: ... def read_events(self) -> Iterator[Tuple[str, Element]]: ... def XML(text: _parser_input_type, parser: Optional[XMLParser] = ...) -> Element: ... def XMLID(text: _parser_input_type, parser: Optional[XMLParser] = ...) -> Tuple[Element, Dict[_str_result_type, Element]]: ... # This is aliased to XML in the source. fromstring = XML def fromstringlist(sequence: Sequence[_parser_input_type], parser: Optional[XMLParser] = ...) -> Element: ... # This type is both not precise enough and too precise. The TreeBuilder # requires the elementfactory to accept tag and attrs in its args and produce # some kind of object that has .text and .tail properties. # I've chosen to constrain the ElementFactory to always produce an Element # because that is how almost everyone will use it. # Unfortunately, the type of the factory arguments is dependent on how # TreeBuilder is called by client code (they could pass strs, bytes or whatever); # but we don't want to use a too-broad type, or it would be too hard to write # elementfactories. _ElementFactory = Callable[[Any, Dict[Any, Any]], Element] class TreeBuilder: def __init__(self, element_factory: Optional[_ElementFactory] = ...) -> None: ... def close(self) -> Element: ... def data(self, __data: _parser_input_type) -> None: ... def start(self, __tag: _parser_input_type, __attrs: Dict[_parser_input_type, _parser_input_type]) -> Element: ... def end(self, __tag: _parser_input_type) -> Element: ... if sys.version_info >= (3, 8): class C14NWriterTarget: def __init__( self, write: Callable[[str], Any], *, with_comments: bool = ..., strip_text: bool = ..., rewrite_prefixes: bool = ..., qname_aware_tags: Optional[Iterable[str]] = ..., qname_aware_attrs: Optional[Iterable[str]] = ..., exclude_attrs: Optional[Iterable[str]] = ..., exclude_tags: Optional[Iterable[str]] = ..., ) -> None: ... class XMLParser: parser: Any target: Any # TODO-what is entity used for??? entity: Any version: str if sys.version_info >= (3, 8): def __init__(self, *, target: Any = ..., encoding: Optional[str] = ...) -> None: ... else: def __init__(self, html: int = ..., target: Any = ..., encoding: Optional[str] = ...) -> None: ... def doctype(self, __name: str, __pubid: str, __system: str) -> None: ... def close(self) -> Any: ... def feed(self, __data: _parser_input_type) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/xml/etree/__init__.pyi0000664000175000017500000000000000000000000026035 0ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/xml/etree/cElementTree.pyi0000664000175000017500000000006200000000000026662 0ustar00davedave00000000000000from xml.etree.ElementTree import * # noqa: F403 ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4263792 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/xml/parsers/0000775000175000017500000000000000000000000024140 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/xml/parsers/__init__.pyi0000664000175000017500000000004200000000000026416 0ustar00davedave00000000000000import xml.parsers.expat as expat ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4263792 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/xml/parsers/expat/0000775000175000017500000000000000000000000025261 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/xml/parsers/expat/__init__.pyi0000664000175000017500000000002600000000000027541 0ustar00davedave00000000000000from pyexpat import * ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/xml/parsers/expat/errors.pyi0000664000175000017500000000003500000000000027316 0ustar00davedave00000000000000from pyexpat.errors import * ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/xml/parsers/expat/model.pyi0000664000175000017500000000003400000000000027101 0ustar00davedave00000000000000from pyexpat.model import * ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4263792 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/xml/sax/0000775000175000017500000000000000000000000023254 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/xml/sax/__init__.pyi0000664000175000017500000000255500000000000025545 0ustar00davedave00000000000000import sys from typing import IO, Any, Iterable, List, NoReturn, Optional, Text, Union from xml.sax.handler import ContentHandler, ErrorHandler from xml.sax.xmlreader import Locator, XMLReader class SAXException(Exception): def __init__(self, msg: str, exception: Optional[Exception] = ...) -> None: ... def getMessage(self) -> str: ... def getException(self) -> Exception: ... def __getitem__(self, ix: Any) -> NoReturn: ... class SAXParseException(SAXException): def __init__(self, msg: str, exception: Exception, locator: Locator) -> None: ... def getColumnNumber(self) -> int: ... def getLineNumber(self) -> int: ... def getPublicId(self): ... def getSystemId(self): ... class SAXNotRecognizedException(SAXException): ... class SAXNotSupportedException(SAXException): ... class SAXReaderNotAvailable(SAXNotSupportedException): ... default_parser_list: List[str] if sys.version_info >= (3, 8): def make_parser(parser_list: Iterable[str] = ...) -> XMLReader: ... else: def make_parser(parser_list: List[str] = ...) -> XMLReader: ... def parse(source: Union[str, IO[str], IO[bytes]], handler: ContentHandler, errorHandler: ErrorHandler = ...) -> None: ... def parseString(string: Union[bytes, Text], handler: ContentHandler, errorHandler: Optional[ErrorHandler] = ...) -> None: ... def _create_parser(parser_name: str) -> XMLReader: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/xml/sax/handler.pyi0000664000175000017500000000255700000000000025425 0ustar00davedave00000000000000from typing import Any version: Any class ErrorHandler: def error(self, exception): ... def fatalError(self, exception): ... def warning(self, exception): ... class ContentHandler: def __init__(self) -> None: ... def setDocumentLocator(self, locator): ... def startDocument(self): ... def endDocument(self): ... def startPrefixMapping(self, prefix, uri): ... def endPrefixMapping(self, prefix): ... def startElement(self, name, attrs): ... def endElement(self, name): ... def startElementNS(self, name, qname, attrs): ... def endElementNS(self, name, qname): ... def characters(self, content): ... def ignorableWhitespace(self, whitespace): ... def processingInstruction(self, target, data): ... def skippedEntity(self, name): ... class DTDHandler: def notationDecl(self, name, publicId, systemId): ... def unparsedEntityDecl(self, name, publicId, systemId, ndata): ... class EntityResolver: def resolveEntity(self, publicId, systemId): ... feature_namespaces: Any feature_namespace_prefixes: Any feature_string_interning: Any feature_validation: Any feature_external_ges: Any feature_external_pes: Any all_features: Any property_lexical_handler: Any property_declaration_handler: Any property_dom_node: Any property_xml_string: Any property_encoding: Any property_interning_dict: Any all_properties: Any ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/xml/sax/saxutils.pyi0000664000175000017500000000541100000000000025654 0ustar00davedave00000000000000import sys from _typeshed import SupportsWrite from codecs import StreamReaderWriter, StreamWriter from io import RawIOBase, TextIOBase from typing import Mapping, Optional, Text, Union from xml.sax import handler, xmlreader def escape(data: Text, entities: Mapping[Text, Text] = ...) -> Text: ... def unescape(data: Text, entities: Mapping[Text, Text] = ...) -> Text: ... def quoteattr(data: Text, entities: Mapping[Text, Text] = ...) -> Text: ... class XMLGenerator(handler.ContentHandler): if sys.version_info >= (3, 0): def __init__( self, out: Optional[Union[TextIOBase, RawIOBase, StreamWriter, StreamReaderWriter, SupportsWrite[str]]] = ..., encoding: str = ..., short_empty_elements: bool = ..., ) -> None: ... else: def __init__( self, out: Optional[Union[TextIOBase, RawIOBase, StreamWriter, StreamReaderWriter, SupportsWrite[str]]] = ..., encoding: Text = ..., ) -> None: ... def startDocument(self): ... def endDocument(self): ... def startPrefixMapping(self, prefix, uri): ... def endPrefixMapping(self, prefix): ... def startElement(self, name, attrs): ... def endElement(self, name): ... def startElementNS(self, name, qname, attrs): ... def endElementNS(self, name, qname): ... def characters(self, content): ... def ignorableWhitespace(self, content): ... def processingInstruction(self, target, data): ... class XMLFilterBase(xmlreader.XMLReader): def __init__(self, parent: Optional[xmlreader.XMLReader] = ...) -> None: ... def error(self, exception): ... def fatalError(self, exception): ... def warning(self, exception): ... def setDocumentLocator(self, locator): ... def startDocument(self): ... def endDocument(self): ... def startPrefixMapping(self, prefix, uri): ... def endPrefixMapping(self, prefix): ... def startElement(self, name, attrs): ... def endElement(self, name): ... def startElementNS(self, name, qname, attrs): ... def endElementNS(self, name, qname): ... def characters(self, content): ... def ignorableWhitespace(self, chars): ... def processingInstruction(self, target, data): ... def skippedEntity(self, name): ... def notationDecl(self, name, publicId, systemId): ... def unparsedEntityDecl(self, name, publicId, systemId, ndata): ... def resolveEntity(self, publicId, systemId): ... def parse(self, source): ... def setLocale(self, locale): ... def getFeature(self, name): ... def setFeature(self, name, state): ... def getProperty(self, name): ... def setProperty(self, name, value): ... def getParent(self): ... def setParent(self, parent): ... def prepare_input_source(source, base=...): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/xml/sax/xmlreader.pyi0000664000175000017500000000465500000000000025774 0ustar00davedave00000000000000from typing import Mapping, Optional, Tuple class XMLReader: def __init__(self) -> None: ... def parse(self, source): ... def getContentHandler(self): ... def setContentHandler(self, handler): ... def getDTDHandler(self): ... def setDTDHandler(self, handler): ... def getEntityResolver(self): ... def setEntityResolver(self, resolver): ... def getErrorHandler(self): ... def setErrorHandler(self, handler): ... def setLocale(self, locale): ... def getFeature(self, name): ... def setFeature(self, name, state): ... def getProperty(self, name): ... def setProperty(self, name, value): ... class IncrementalParser(XMLReader): def __init__(self, bufsize: int = ...) -> None: ... def parse(self, source): ... def feed(self, data): ... def prepareParser(self, source): ... def close(self): ... def reset(self): ... class Locator: def getColumnNumber(self): ... def getLineNumber(self): ... def getPublicId(self): ... def getSystemId(self): ... class InputSource: def __init__(self, system_id: Optional[str] = ...) -> None: ... def setPublicId(self, public_id): ... def getPublicId(self): ... def setSystemId(self, system_id): ... def getSystemId(self): ... def setEncoding(self, encoding): ... def getEncoding(self): ... def setByteStream(self, bytefile): ... def getByteStream(self): ... def setCharacterStream(self, charfile): ... def getCharacterStream(self): ... class AttributesImpl: def __init__(self, attrs: Mapping[str, str]) -> None: ... def getLength(self): ... def getType(self, name): ... def getValue(self, name): ... def getValueByQName(self, name): ... def getNameByQName(self, name): ... def getQNameByName(self, name): ... def getNames(self): ... def getQNames(self): ... def __len__(self): ... def __getitem__(self, name): ... def keys(self): ... def has_key(self, name): ... def __contains__(self, name): ... def get(self, name, alternative=...): ... def copy(self): ... def items(self): ... def values(self): ... class AttributesNSImpl(AttributesImpl): def __init__(self, attrs: Mapping[Tuple[str, str], str], qnames: Mapping[Tuple[str, str], str]) -> None: ... def getValueByQName(self, name): ... def getNameByQName(self, name): ... def getQNameByName(self, name): ... def getQNames(self): ... def copy(self): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/zipfile.pyi0000664000175000017500000001612100000000000024047 0ustar00davedave00000000000000import io import sys from _typeshed import StrPath from types import TracebackType from typing import ( IO, Any, Callable, Dict, Iterable, Iterator, List, Optional, Pattern, Protocol, Sequence, Text, Tuple, Type, Union, ) _SZI = Union[Text, ZipInfo] _DT = Tuple[int, int, int, int, int, int] if sys.version_info >= (3,): class BadZipFile(Exception): ... BadZipfile = BadZipFile else: class BadZipfile(Exception): ... error = BadZipfile class LargeZipFile(Exception): ... class ZipExtFile(io.BufferedIOBase): MAX_N: int = ... MIN_READ_SIZE: int = ... if sys.version_info < (3, 6): PATTERN: Pattern[str] = ... if sys.version_info >= (3, 7): MAX_SEEK_READ: int = ... newlines: Optional[List[bytes]] mode: str name: str if sys.version_info >= (3, 7): def __init__( self, fileobj: IO[bytes], mode: str, zipinfo: ZipInfo, pwd: Optional[bytes] = ..., close_fileobj: bool = ... ) -> None: ... else: def __init__( self, fileobj: IO[bytes], mode: str, zipinfo: ZipInfo, decrypter: Optional[Callable[[Sequence[int]], bytes]] = ..., close_fileobj: bool = ..., ) -> None: ... def __repr__(self) -> str: ... def peek(self, n: int = ...) -> bytes: ... def read1(self, n: Optional[int]) -> bytes: ... # type: ignore class _Writer(Protocol): def write(self, __s: str) -> Any: ... class ZipFile: filename: Optional[Text] debug: int comment: bytes filelist: List[ZipInfo] fp: Optional[IO[bytes]] NameToInfo: Dict[Text, ZipInfo] start_dir: int # undocumented if sys.version_info >= (3, 8): def __init__( self, file: Union[StrPath, IO[bytes]], mode: str = ..., compression: int = ..., allowZip64: bool = ..., compresslevel: Optional[int] = ..., *, strict_timestamps: bool = ..., ) -> None: ... elif sys.version_info >= (3, 7): def __init__( self, file: Union[StrPath, IO[bytes]], mode: str = ..., compression: int = ..., allowZip64: bool = ..., compresslevel: Optional[int] = ..., ) -> None: ... else: def __init__( self, file: Union[StrPath, IO[bytes]], mode: Text = ..., compression: int = ..., allowZip64: bool = ... ) -> None: ... def __enter__(self) -> ZipFile: ... def __exit__( self, exc_type: Optional[Type[BaseException]], exc_val: Optional[BaseException], exc_tb: Optional[TracebackType] ) -> None: ... def close(self) -> None: ... def getinfo(self, name: Text) -> ZipInfo: ... def infolist(self) -> List[ZipInfo]: ... def namelist(self) -> List[Text]: ... def open(self, name: _SZI, mode: Text = ..., pwd: Optional[bytes] = ..., *, force_zip64: bool = ...) -> IO[bytes]: ... def extract(self, member: _SZI, path: Optional[StrPath] = ..., pwd: Optional[bytes] = ...) -> str: ... def extractall( self, path: Optional[StrPath] = ..., members: Optional[Iterable[Text]] = ..., pwd: Optional[bytes] = ... ) -> None: ... if sys.version_info >= (3,): def printdir(self, file: Optional[_Writer] = ...) -> None: ... else: def printdir(self) -> None: ... def setpassword(self, pwd: bytes) -> None: ... def read(self, name: _SZI, pwd: Optional[bytes] = ...) -> bytes: ... def testzip(self) -> Optional[str]: ... if sys.version_info >= (3, 7): def write( self, filename: StrPath, arcname: Optional[StrPath] = ..., compress_type: Optional[int] = ..., compresslevel: Optional[int] = ..., ) -> None: ... else: def write(self, filename: StrPath, arcname: Optional[StrPath] = ..., compress_type: Optional[int] = ...) -> None: ... if sys.version_info >= (3, 7): def writestr( self, zinfo_or_arcname: _SZI, data: Union[bytes, str], compress_type: Optional[int] = ..., compresslevel: Optional[int] = ..., ) -> None: ... elif sys.version_info >= (3,): def writestr(self, zinfo_or_arcname: _SZI, data: Union[bytes, str], compress_type: Optional[int] = ...) -> None: ... else: def writestr(self, zinfo_or_arcname: _SZI, bytes: bytes, compress_type: Optional[int] = ...) -> None: ... class PyZipFile(ZipFile): if sys.version_info >= (3,): def __init__( self, file: Union[str, IO[bytes]], mode: str = ..., compression: int = ..., allowZip64: bool = ..., optimize: int = ..., ) -> None: ... def writepy(self, pathname: str, basename: str = ..., filterfunc: Optional[Callable[[str], bool]] = ...) -> None: ... else: def writepy(self, pathname: Text, basename: Text = ...) -> None: ... class ZipInfo: filename: Text date_time: _DT compress_type: int comment: bytes extra: bytes create_system: int create_version: int extract_version: int reserved: int flag_bits: int volume: int internal_attr: int external_attr: int header_offset: int CRC: int compress_size: int file_size: int def __init__(self, filename: Optional[Text] = ..., date_time: Optional[_DT] = ...) -> None: ... if sys.version_info >= (3, 8): @classmethod def from_file(cls, filename: StrPath, arcname: Optional[StrPath] = ..., *, strict_timestamps: bool = ...) -> ZipInfo: ... elif sys.version_info >= (3, 6): @classmethod def from_file(cls, filename: StrPath, arcname: Optional[StrPath] = ...) -> ZipInfo: ... if sys.version_info >= (3, 6): def is_dir(self) -> bool: ... def FileHeader(self, zip64: Optional[bool] = ...) -> bytes: ... if sys.version_info >= (3, 8): class Path: @property def name(self) -> str: ... @property def parent(self) -> Path: ... # undocumented def __init__(self, root: Union[ZipFile, StrPath, IO[bytes]], at: str = ...) -> None: ... def open(self, mode: str = ..., pwd: Optional[bytes] = ..., *, force_zip64: bool = ...) -> IO[bytes]: ... def iterdir(self) -> Iterator[Path]: ... def is_dir(self) -> bool: ... def is_file(self) -> bool: ... def exists(self) -> bool: ... def read_text( self, encoding: Optional[str] = ..., errors: Optional[str] = ..., newline: Optional[str] = ..., line_buffering: bool = ..., write_through: bool = ..., ) -> str: ... def read_bytes(self) -> bytes: ... def joinpath(self, add: StrPath) -> Path: ... # undocumented def __truediv__(self, add: StrPath) -> Path: ... def is_zipfile(filename: Union[StrPath, IO[bytes]]) -> bool: ... ZIP_STORED: int ZIP_DEFLATED: int ZIP64_LIMIT: int ZIP_FILECOUNT_LIMIT: int ZIP_MAX_COMMENT: int if sys.version_info >= (3, 3): ZIP_BZIP2: int ZIP_LZMA: int ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/zipimport.pyi0000664000175000017500000000233400000000000024443 0ustar00davedave00000000000000import os import sys from types import CodeType, ModuleType from typing import Any, List, Optional, Tuple, Union if sys.version_info >= (3, 7): from importlib.abc import ResourceReader class ZipImportError(ImportError): ... class zipimporter(object): archive: str prefix: str if sys.version_info >= (3, 6): def __init__(self, path: Union[str, bytes, os.PathLike[Any]]) -> None: ... else: def __init__(self, path: Union[str, bytes]) -> None: ... if sys.version_info >= (3,): def find_loader( self, fullname: str, path: Optional[str] = ... ) -> Tuple[Optional[zipimporter], List[str]]: ... # undocumented def find_module(self, fullname: str, path: Optional[str] = ...) -> Optional[zipimporter]: ... def get_code(self, fullname: str) -> CodeType: ... def get_data(self, pathname: str) -> str: ... def get_filename(self, fullname: str) -> str: ... if sys.version_info >= (3, 7): def get_resource_reader(self, fullname: str) -> Optional[ResourceReader]: ... # undocumented def get_source(self, fullname: str) -> Optional[str]: ... def is_package(self, fullname: str) -> bool: ... def load_module(self, fullname: str) -> ModuleType: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/2and3/zlib.pyi0000664000175000017500000000323400000000000023346 0ustar00davedave00000000000000import sys from array import array from typing import Any, Union DEFLATED: int DEF_MEM_LEVEL: int MAX_WBITS: int ZLIB_VERSION: str Z_BEST_COMPRESSION: int Z_BEST_SPEED: int Z_DEFAULT_COMPRESSION: int Z_DEFAULT_STRATEGY: int Z_FILTERED: int Z_FINISH: int Z_FULL_FLUSH: int Z_HUFFMAN_ONLY: int Z_NO_FLUSH: int Z_SYNC_FLUSH: int if sys.version_info >= (3,): DEF_BUF_SIZE: int ZLIB_RUNTIME_VERSION: str class error(Exception): ... class _Compress: def compress(self, data: bytes) -> bytes: ... def flush(self, mode: int = ...) -> bytes: ... def copy(self) -> _Compress: ... class _Decompress: unused_data: bytes unconsumed_tail: bytes if sys.version_info >= (3,): eof: bool def decompress(self, data: bytes, max_length: int = ...) -> bytes: ... def flush(self, length: int = ...) -> bytes: ... def copy(self) -> _Decompress: ... def adler32(__data: bytes, __value: int = ...) -> int: ... def compress(__data: bytes, level: int = ...) -> bytes: ... if sys.version_info >= (3,): def compressobj( level: int = ..., method: int = ..., wbits: int = ..., memLevel: int = ..., strategy: int = ..., zdict: bytes = ... ) -> _Compress: ... else: def compressobj( level: int = ..., method: int = ..., wbits: int = ..., memlevel: int = ..., strategy: int = ... ) -> _Compress: ... def crc32(__data: Union[array[Any], bytes], __value: int = ...) -> int: ... def decompress(__data: bytes, wbits: int = ..., bufsize: int = ...) -> bytes: ... if sys.version_info >= (3,): def decompressobj(wbits: int = ..., zdict: bytes = ...) -> _Decompress: ... else: def decompressobj(wbits: int = ...) -> _Decompress: ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4303794 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/0000775000175000017500000000000000000000000021114 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/_ast.pyi0000664000175000017500000001725300000000000022575 0ustar00davedave00000000000000import sys import typing from typing import Any, ClassVar, Optional PyCF_ONLY_AST: int if sys.version_info >= (3, 8): PyCF_TYPE_COMMENTS: int PyCF_ALLOW_TOP_LEVEL_AWAIT: int _identifier = str class AST: _attributes: ClassVar[typing.Tuple[str, ...]] _fields: ClassVar[typing.Tuple[str, ...]] def __init__(self, *args: Any, **kwargs: Any) -> None: ... # TODO: Not all nodes have all of the following attributes lineno: int col_offset: int if sys.version_info >= (3, 8): end_lineno: Optional[int] end_col_offset: Optional[int] type_comment: Optional[str] class mod(AST): ... if sys.version_info >= (3, 8): class type_ignore(AST): ... class TypeIgnore(type_ignore): ... class FunctionType(mod): argtypes: typing.List[expr] returns: expr class Module(mod): body: typing.List[stmt] if sys.version_info >= (3, 8): type_ignores: typing.List[TypeIgnore] class Interactive(mod): body: typing.List[stmt] class Expression(mod): body: expr class stmt(AST): ... class FunctionDef(stmt): name: _identifier args: arguments body: typing.List[stmt] decorator_list: typing.List[expr] returns: Optional[expr] class AsyncFunctionDef(stmt): name: _identifier args: arguments body: typing.List[stmt] decorator_list: typing.List[expr] returns: Optional[expr] class ClassDef(stmt): name: _identifier bases: typing.List[expr] keywords: typing.List[keyword] body: typing.List[stmt] decorator_list: typing.List[expr] class Return(stmt): value: Optional[expr] class Delete(stmt): targets: typing.List[expr] class Assign(stmt): targets: typing.List[expr] value: expr class AugAssign(stmt): target: expr op: operator value: expr class AnnAssign(stmt): target: expr annotation: expr value: Optional[expr] simple: int class For(stmt): target: expr iter: expr body: typing.List[stmt] orelse: typing.List[stmt] class AsyncFor(stmt): target: expr iter: expr body: typing.List[stmt] orelse: typing.List[stmt] class While(stmt): test: expr body: typing.List[stmt] orelse: typing.List[stmt] class If(stmt): test: expr body: typing.List[stmt] orelse: typing.List[stmt] class With(stmt): items: typing.List[withitem] body: typing.List[stmt] class AsyncWith(stmt): items: typing.List[withitem] body: typing.List[stmt] class Raise(stmt): exc: Optional[expr] cause: Optional[expr] class Try(stmt): body: typing.List[stmt] handlers: typing.List[ExceptHandler] orelse: typing.List[stmt] finalbody: typing.List[stmt] class Assert(stmt): test: expr msg: Optional[expr] class Import(stmt): names: typing.List[alias] class ImportFrom(stmt): module: Optional[_identifier] names: typing.List[alias] level: int class Global(stmt): names: typing.List[_identifier] class Nonlocal(stmt): names: typing.List[_identifier] class Expr(stmt): value: expr class Pass(stmt): ... class Break(stmt): ... class Continue(stmt): ... class expr(AST): ... class BoolOp(expr): op: boolop values: typing.List[expr] class BinOp(expr): left: expr op: operator right: expr class UnaryOp(expr): op: unaryop operand: expr class Lambda(expr): args: arguments body: expr class IfExp(expr): test: expr body: expr orelse: expr class Dict(expr): keys: typing.List[Optional[expr]] values: typing.List[expr] class Set(expr): elts: typing.List[expr] class ListComp(expr): elt: expr generators: typing.List[comprehension] class SetComp(expr): elt: expr generators: typing.List[comprehension] class DictComp(expr): key: expr value: expr generators: typing.List[comprehension] class GeneratorExp(expr): elt: expr generators: typing.List[comprehension] class Await(expr): value: expr class Yield(expr): value: Optional[expr] class YieldFrom(expr): value: expr class Compare(expr): left: expr ops: typing.List[cmpop] comparators: typing.List[expr] class Call(expr): func: expr args: typing.List[expr] keywords: typing.List[keyword] class FormattedValue(expr): value: expr conversion: Optional[int] format_spec: Optional[expr] class JoinedStr(expr): values: typing.List[expr] if sys.version_info < (3, 8): class Num(expr): # Deprecated in 3.8; use Constant n: complex class Str(expr): # Deprecated in 3.8; use Constant s: str class Bytes(expr): # Deprecated in 3.8; use Constant s: bytes class NameConstant(expr): # Deprecated in 3.8; use Constant value: Any class Ellipsis(expr): ... # Deprecated in 3.8; use Constant class Constant(expr): value: Any # None, str, bytes, bool, int, float, complex, Ellipsis kind: Optional[str] # Aliases for value, for backwards compatibility s: Any n: complex if sys.version_info >= (3, 8): class NamedExpr(expr): target: expr value: expr class Attribute(expr): value: expr attr: _identifier ctx: expr_context if sys.version_info >= (3, 9): _SliceT = expr else: class slice(AST): ... _SliceT = slice class Slice(_SliceT): lower: Optional[expr] upper: Optional[expr] step: Optional[expr] if sys.version_info < (3, 9): class ExtSlice(slice): dims: typing.List[slice] class Index(slice): value: expr class Subscript(expr): value: expr slice: _SliceT ctx: expr_context class Starred(expr): value: expr ctx: expr_context class Name(expr): id: _identifier ctx: expr_context class List(expr): elts: typing.List[expr] ctx: expr_context class Tuple(expr): elts: typing.List[expr] ctx: expr_context class expr_context(AST): ... if sys.version_info < (3, 9): class AugLoad(expr_context): ... class AugStore(expr_context): ... class Param(expr_context): ... class Suite(mod): body: typing.List[stmt] class Del(expr_context): ... class Load(expr_context): ... class Store(expr_context): ... class boolop(AST): ... class And(boolop): ... class Or(boolop): ... class operator(AST): ... class Add(operator): ... class BitAnd(operator): ... class BitOr(operator): ... class BitXor(operator): ... class Div(operator): ... class FloorDiv(operator): ... class LShift(operator): ... class Mod(operator): ... class Mult(operator): ... class MatMult(operator): ... class Pow(operator): ... class RShift(operator): ... class Sub(operator): ... class unaryop(AST): ... class Invert(unaryop): ... class Not(unaryop): ... class UAdd(unaryop): ... class USub(unaryop): ... class cmpop(AST): ... class Eq(cmpop): ... class Gt(cmpop): ... class GtE(cmpop): ... class In(cmpop): ... class Is(cmpop): ... class IsNot(cmpop): ... class Lt(cmpop): ... class LtE(cmpop): ... class NotEq(cmpop): ... class NotIn(cmpop): ... class comprehension(AST): target: expr iter: expr ifs: typing.List[expr] is_async: int class excepthandler(AST): ... class ExceptHandler(excepthandler): type: Optional[expr] name: Optional[_identifier] body: typing.List[stmt] class arguments(AST): if sys.version_info >= (3, 8): posonlyargs: typing.List[arg] args: typing.List[arg] vararg: Optional[arg] kwonlyargs: typing.List[arg] kw_defaults: typing.List[Optional[expr]] kwarg: Optional[arg] defaults: typing.List[expr] class arg(AST): arg: _identifier annotation: Optional[expr] class keyword(AST): arg: Optional[_identifier] value: expr class alias(AST): name: _identifier asname: Optional[_identifier] class withitem(AST): context_expr: expr optional_vars: Optional[expr] ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/_bootlocale.pyi0000664000175000017500000000007700000000000024125 0ustar00davedave00000000000000def getpreferredencoding(do_setlocale: bool = ...) -> str: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/_compat_pickle.pyi0000664000175000017500000000060400000000000024610 0ustar00davedave00000000000000from typing import Dict, Tuple IMPORT_MAPPING: Dict[str, str] NAME_MAPPING: Dict[Tuple[str, str], Tuple[str, str]] PYTHON2_EXCEPTIONS: Tuple[str, ...] MULTIPROCESSING_EXCEPTIONS: Tuple[str, ...] REVERSE_IMPORT_MAPPING: Dict[str, str] REVERSE_NAME_MAPPING: Dict[Tuple[str, str], Tuple[str, str]] PYTHON3_OSERROR_EXCEPTIONS: Tuple[str, ...] PYTHON3_IMPORTERROR_EXCEPTIONS: Tuple[str, ...] ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/_compression.pyi0000664000175000017500000000137100000000000024341 0ustar00davedave00000000000000from _typeshed import WriteableBuffer from io import BufferedIOBase, RawIOBase from typing import Any, Callable, Tuple, Type, Union BUFFER_SIZE: Any class BaseStream(BufferedIOBase): ... class DecompressReader(RawIOBase): def __init__( self, fp: RawIOBase, decomp_factory: Callable[..., object], trailing_error: Union[Type[Exception], Tuple[Type[Exception], ...]] = ..., **decomp_args: Any, ) -> None: ... def readable(self) -> bool: ... def close(self) -> None: ... def seekable(self) -> bool: ... def readinto(self, b: WriteableBuffer) -> int: ... def read(self, size: int = ...) -> bytes: ... def seek(self, offset: int, whence: int = ...) -> int: ... def tell(self) -> int: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/_decimal.pyi0000664000175000017500000000002600000000000023372 0ustar00davedave00000000000000from decimal import * ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/_dummy_thread.pyi0000664000175000017500000000144000000000000024457 0ustar00davedave00000000000000from typing import Any, Callable, Dict, NoReturn, Optional, Tuple TIMEOUT_MAX: int error = RuntimeError def start_new_thread(function: Callable[..., Any], args: Tuple[Any, ...], kwargs: Dict[str, Any] = ...) -> None: ... def exit() -> NoReturn: ... def get_ident() -> int: ... def allocate_lock() -> LockType: ... def stack_size(size: Optional[int] = ...) -> int: ... class LockType(object): locked_status: bool def __init__(self) -> None: ... def acquire(self, waitflag: Optional[bool] = ..., timeout: int = ...) -> bool: ... def __enter__(self, waitflag: Optional[bool] = ..., timeout: int = ...) -> bool: ... def __exit__(self, typ: Any, val: Any, tb: Any) -> None: ... def release(self) -> bool: ... def locked(self) -> bool: ... def interrupt_main() -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/_imp.pyi0000664000175000017500000000130100000000000022556 0ustar00davedave00000000000000import types from importlib.machinery import ModuleSpec from typing import Any, List def create_builtin(__spec: ModuleSpec) -> types.ModuleType: ... def create_dynamic(__spec: ModuleSpec, __file: Any = ...) -> None: ... def acquire_lock() -> None: ... def exec_builtin(__mod: types.ModuleType) -> int: ... def exec_dynamic(__mod: types.ModuleType) -> int: ... def extension_suffixes() -> List[str]: ... def get_frozen_object(__name: str) -> types.CodeType: ... def init_frozen(__name: str) -> types.ModuleType: ... def is_builtin(__name: str) -> int: ... def is_frozen(__name: str) -> bool: ... def is_frozen_package(__name: str) -> bool: ... def lock_held() -> bool: ... def release_lock() -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/_importlib_modulespec.pyi0000664000175000017500000000306200000000000026220 0ustar00davedave00000000000000# ModuleSpec, ModuleType, Loader are part of a dependency cycle. # They are officially defined/exported in other places: # # - ModuleType in types # - Loader in importlib.abc # - ModuleSpec in importlib.machinery (3.4 and later only) # # _Loader is the PEP-451-defined interface for a loader type/object. from abc import ABCMeta from typing import Any, Dict, List, Optional, Protocol class _Loader(Protocol): def load_module(self, fullname: str) -> ModuleType: ... class ModuleSpec: def __init__( self, name: str, loader: Optional[Loader], *, origin: Optional[str] = ..., loader_state: Any = ..., is_package: Optional[bool] = ..., ) -> None: ... name: str loader: Optional[_Loader] origin: Optional[str] submodule_search_locations: Optional[List[str]] loader_state: Any cached: Optional[str] parent: Optional[str] has_location: bool class ModuleType: __name__: str __file__: str __dict__: Dict[str, Any] __loader__: Optional[_Loader] __package__: Optional[str] __spec__: Optional[ModuleSpec] def __init__(self, name: str, doc: Optional[str] = ...) -> None: ... class Loader(metaclass=ABCMeta): def load_module(self, fullname: str) -> ModuleType: ... def module_repr(self, module: ModuleType) -> str: ... def create_module(self, spec: ModuleSpec) -> Optional[ModuleType]: ... # Not defined on the actual class for backwards-compatibility reasons, # but expected in new code. def exec_module(self, module: ModuleType) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/_json.pyi0000664000175000017500000000214400000000000022750 0ustar00davedave00000000000000from typing import Any, Callable, Dict, Optional, Tuple class make_encoder: sort_keys: Any skipkeys: Any key_separator: Any indent: Any markers: Any default: Any encoder: Any item_separator: Any def __init__( self, markers: Optional[Dict[int, Any]], default: Callable[[Any], Any], encoder: Callable[[str], str], indent: Optional[int], key_separator: str, item_separator: str, sort_keys: bool, skipkeys: bool, allow_nan: bool, ) -> None: ... def __call__(self, obj: object, _current_indent_level: int) -> Any: ... class make_scanner: object_hook: Any object_pairs_hook: Any parse_int: Any parse_constant: Any parse_float: Any strict: bool # TODO: 'context' needs the attrs above (ducktype), but not __call__. def __init__(self, context: make_scanner) -> None: ... def __call__(self, string: str, index: int) -> Tuple[Any, int]: ... def encode_basestring_ascii(s: str) -> str: ... def scanstring(string: str, end: int, strict: bool = ...) -> Tuple[str, int]: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/_markupbase.pyi0000664000175000017500000000040000000000000024122 0ustar00davedave00000000000000from typing import Tuple class ParserBase: def __init__(self) -> None: ... def error(self, message: str) -> None: ... def reset(self) -> None: ... def getpos(self) -> Tuple[int, int]: ... def unknown_decl(self, data: str) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/_operator.pyi0000664000175000017500000000243600000000000023636 0ustar00davedave00000000000000# In reality the import is the other way around, but this way we can keep the operator stub in 2and3 from operator import ( abs as abs, add as add, and_ as and_, attrgetter as attrgetter, concat as concat, contains as contains, countOf as countOf, delitem as delitem, eq as eq, floordiv as floordiv, ge as ge, getitem as getitem, gt as gt, iadd as iadd, iand as iand, iconcat as iconcat, ifloordiv as ifloordiv, ilshift as ilshift, imatmul as imatmul, imod as imod, imul as imul, index as index, indexOf as indexOf, inv as inv, invert as invert, ior as ior, ipow as ipow, irshift as irshift, is_ as is_, is_not as is_not, isub as isub, itemgetter as itemgetter, itruediv as itruediv, ixor as ixor, le as le, length_hint as length_hint, lshift as lshift, lt as lt, matmul as matmul, methodcaller as methodcaller, mod as mod, mul as mul, ne as ne, neg as neg, not_ as not_, or_ as or_, pos as pos, pow as pow, rshift as rshift, setitem as setitem, sub as sub, truediv as truediv, truth as truth, xor as xor, ) from typing import AnyStr def _compare_digest(__a: AnyStr, __b: AnyStr) -> bool: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/_osx_support.pyi0000664000175000017500000000340400000000000024404 0ustar00davedave00000000000000from typing import Dict, Iterable, List, Optional, Sequence, Tuple, TypeVar, Union _T = TypeVar("_T") _K = TypeVar("_K") _V = TypeVar("_V") __all__: List[str] _UNIVERSAL_CONFIG_VARS: Tuple[str, ...] # undocumented _COMPILER_CONFIG_VARS: Tuple[str, ...] # undocumented _INITPRE: str # undocumented def _find_executable(executable: str, path: Optional[str] = ...) -> Optional[str]: ... # undocumented def _read_output(commandstring: str) -> Optional[str]: ... # undocumented def _find_build_tool(toolname: str) -> str: ... # undocumented _SYSTEM_VERSION: Optional[str] # undocumented def _get_system_version() -> str: ... # undocumented def _remove_original_values(_config_vars: Dict[str, str]) -> None: ... # undocumented def _save_modified_value(_config_vars: Dict[str, str], cv: str, newvalue: str) -> None: ... # undocumented def _supports_universal_builds() -> bool: ... # undocumented def _find_appropriate_compiler(_config_vars: Dict[str, str]) -> Dict[str, str]: ... # undocumented def _remove_universal_flags(_config_vars: Dict[str, str]) -> Dict[str, str]: ... # undocumented def _remove_unsupported_archs(_config_vars: Dict[str, str]) -> Dict[str, str]: ... # undocumented def _override_all_archs(_config_vars: Dict[str, str]) -> Dict[str, str]: ... # undocumented def _check_for_unavailable_sdk(_config_vars: Dict[str, str]) -> Dict[str, str]: ... # undocumented def compiler_fixup(compiler_so: Iterable[str], cc_args: Sequence[str]) -> List[str]: ... def customize_config_vars(_config_vars: Dict[str, str]) -> Dict[str, str]: ... def customize_compiler(_config_vars: Dict[str, str]) -> Dict[str, str]: ... def get_platform_osx( _config_vars: Dict[str, str], osname: _T, release: _K, machine: _V ) -> Tuple[Union[str, _T], Union[str, _K], Union[str, _V]]: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/_posixsubprocess.pyi0000664000175000017500000000105500000000000025252 0ustar00davedave00000000000000# NOTE: These are incomplete! from typing import Callable, Sequence, Tuple def cloexec_pipe() -> Tuple[int, int]: ... def fork_exec( args: Sequence[str], executable_list: Sequence[bytes], close_fds: bool, fds_to_keep: Sequence[int], cwd: str, env_list: Sequence[bytes], p2cread: int, p2cwrite: int, c2pred: int, c2pwrite: int, errread: int, errwrite: int, errpipe_read: int, errpipe_write: int, restore_signals: int, start_new_session: int, preexec_fn: Callable[[], None], ) -> int: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/_pydecimal.pyi0000664000175000017500000000023500000000000023745 0ustar00davedave00000000000000# This is a slight lie, the implementations aren't exactly identical # However, in all likelihood, the differences are inconsequential from decimal import * ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/_sitebuiltins.pyi0000664000175000017500000000102600000000000024513 0ustar00davedave00000000000000from typing import ClassVar, Iterable, NoReturn, Optional from typing_extensions import Literal class Quitter: name: str eof: str def __init__(self, name: str, eof: str) -> None: ... def __call__(self, code: Optional[int] = ...) -> NoReturn: ... class _Printer: MAXLINES: ClassVar[Literal[23]] def __init__(self, name: str, data: str, files: Iterable[str] = ..., dirs: Iterable[str] = ...) -> None: ... def __call__(self) -> None: ... class _Helper: def __call__(self, request: object) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/_stat.pyi0000664000175000017500000000223300000000000022751 0ustar00davedave00000000000000SF_APPEND: int SF_ARCHIVED: int SF_IMMUTABLE: int SF_NOUNLINK: int SF_SNAPSHOT: int ST_ATIME: int ST_CTIME: int ST_DEV: int ST_GID: int ST_INO: int ST_MODE: int ST_MTIME: int ST_NLINK: int ST_SIZE: int ST_UID: int S_ENFMT: int S_IEXEC: int S_IFBLK: int S_IFCHR: int S_IFDIR: int S_IFDOOR: int S_IFIFO: int S_IFLNK: int S_IFPORT: int S_IFREG: int S_IFSOCK: int S_IFWHT: int S_IREAD: int S_IRGRP: int S_IROTH: int S_IRUSR: int S_IRWXG: int S_IRWXO: int S_IRWXU: int S_ISGID: int S_ISUID: int S_ISVTX: int S_IWGRP: int S_IWOTH: int S_IWRITE: int S_IWUSR: int S_IXGRP: int S_IXOTH: int S_IXUSR: int UF_APPEND: int UF_COMPRESSED: int UF_HIDDEN: int UF_IMMUTABLE: int UF_NODUMP: int UF_NOUNLINK: int UF_OPAQUE: int def S_IMODE(mode: int) -> int: ... def S_IFMT(mode: int) -> int: ... def S_ISBLK(mode: int) -> bool: ... def S_ISCHR(mode: int) -> bool: ... def S_ISDIR(mode: int) -> bool: ... def S_ISDOOR(mode: int) -> bool: ... def S_ISFIFO(mode: int) -> bool: ... def S_ISLNK(mode: int) -> bool: ... def S_ISPORT(mode: int) -> bool: ... def S_ISREG(mode: int) -> bool: ... def S_ISSOCK(mode: int) -> bool: ... def S_ISWHT(mode: int) -> bool: ... def filemode(mode: int) -> str: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/_thread.pyi0000664000175000017500000000265300000000000023253 0ustar00davedave00000000000000import sys from threading import Thread from types import TracebackType from typing import Any, Callable, Dict, NoReturn, Optional, Tuple, Type error = RuntimeError def _count() -> int: ... _dangling: Any class LockType: def acquire(self, blocking: bool = ..., timeout: float = ...) -> bool: ... def release(self) -> None: ... def locked(self) -> bool: ... def __enter__(self) -> bool: ... def __exit__( self, type: Optional[Type[BaseException]], value: Optional[BaseException], traceback: Optional[TracebackType] ) -> None: ... def start_new_thread(function: Callable[..., Any], args: Tuple[Any, ...], kwargs: Dict[str, Any] = ...) -> int: ... def interrupt_main() -> None: ... def exit() -> NoReturn: ... def allocate_lock() -> LockType: ... def get_ident() -> int: ... def stack_size(size: int = ...) -> int: ... TIMEOUT_MAX: float if sys.version_info >= (3, 8): def get_native_id() -> int: ... # only available on some platforms class _ExceptHookArgs(Tuple[Type[BaseException], Optional[BaseException], Optional[TracebackType], Optional[Thread]]): @property def exc_type(self) -> Type[BaseException]: ... @property def exc_value(self) -> Optional[BaseException]: ... @property def exc_traceback(self) -> Optional[TracebackType]: ... @property def thread(self) -> Optional[Thread]: ... _excepthook: Callable[[_ExceptHookArgs], Any] ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/_threading_local.pyi0000664000175000017500000000075200000000000025121 0ustar00davedave00000000000000from typing import Any, Dict, Tuple from weakref import ReferenceType localdict = Dict[Any, Any] class _localimpl: key: str dicts: Dict[int, Tuple[ReferenceType[Any], localdict]] def __init__(self) -> None: ... def get_dict(self) -> localdict: ... def create_dict(self) -> localdict: ... class local: def __getattribute__(self, name: str) -> Any: ... def __setattr__(self, name: str, value: Any) -> None: ... def __delattr__(self, name: str) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/_tkinter.pyi0000664000175000017500000000474300000000000023466 0ustar00davedave00000000000000from typing import Any, Tuple, Union # _tkinter is meant to be only used internally by tkinter, but some tkinter # functions e.g. return _tkinter.Tcl_Obj objects. Tcl_Obj represents a Tcl # object that hasn't been converted to a string. # # There are not many ways to get Tcl_Objs from tkinter, and I'm not sure if the # only existing ways are supposed to return Tcl_Objs as opposed to returning # strings. Here's one of these things that return Tcl_Objs: # # >>> import tkinter # >>> text = tkinter.Text() # >>> text.tag_add('foo', '1.0', 'end') # >>> text.tag_ranges('foo') # (, ) class Tcl_Obj: string: str # str(tclobj) returns this typename: str class TclError(Exception): ... # This class allows running Tcl code. Tkinter uses it internally a lot, and # it's often handy to drop a piece of Tcl code into a tkinter program. Example: # # >>> import tkinter, _tkinter # >>> tkapp = tkinter.Tk().tk # >>> isinstance(tkapp, _tkinter.TkappType) # True # >>> tkapp.call('set', 'foo', (1,2,3)) # (1, 2, 3) # >>> tkapp.eval('return $foo') # '1 2 3' # >>> # # call args can be pretty much anything. Also, call(some_tuple) is same as call(*some_tuple). # # eval always returns str because _tkinter_tkapp_eval_impl in _tkinter.c calls # Tkapp_UnicodeResult, and it returns a string when it succeeds. class TkappType: # Please keep in sync with tkinter.Tk def call(self, __command: Union[str, Tuple[Any, ...]], *args: Any) -> Any: ... def eval(self, __script: str) -> str: ... adderrorinfo: Any createcommand: Any createfilehandler: Any createtimerhandler: Any deletecommand: Any deletefilehandler: Any dooneevent: Any evalfile: Any exprboolean: Any exprdouble: Any exprlong: Any exprstring: Any getboolean: Any getdouble: Any getint: Any getvar: Any globalgetvar: Any globalsetvar: Any globalunsetvar: Any interpaddr: Any loadtk: Any mainloop: Any quit: Any record: Any setvar: Any split: Any splitlist: Any unsetvar: Any wantobjects: Any willdispatch: Any ALL_EVENTS: int FILE_EVENTS: int IDLE_EVENTS: int TIMER_EVENTS: int WINDOW_EVENTS: int DONT_WAIT: int EXCEPTION: int READABLE: int WRITABLE: int TCL_VERSION: str TK_VERSION: str # TODO: figure out what these are (with e.g. help()) and get rid of Any TkttType: Any _flatten: Any create: Any getbusywaitinterval: Any setbusywaitinterval: Any ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/_tracemalloc.pyi0000664000175000017500000000106300000000000024264 0ustar00davedave00000000000000import sys from tracemalloc import _FrameTupleT, _TraceTupleT from typing import Optional, Sequence, Tuple def _get_object_traceback(__obj: object) -> Optional[Sequence[_FrameTupleT]]: ... def _get_traces() -> Sequence[_TraceTupleT]: ... def clear_traces() -> None: ... def get_traceback_limit() -> int: ... def get_traced_memory() -> Tuple[int, int]: ... def get_tracemalloc_memory() -> int: ... def is_tracing() -> bool: ... if sys.version_info >= (3, 9): def reset_peak() -> None: ... def start(__nframe: int = ...) -> None: ... def stop() -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/_winapi.pyi0000664000175000017500000001063300000000000023270 0ustar00davedave00000000000000import sys from typing import Any, Dict, NoReturn, Optional, Sequence, Tuple, Union, overload from typing_extensions import Literal CREATE_NEW_CONSOLE: int CREATE_NEW_PROCESS_GROUP: int DUPLICATE_CLOSE_SOURCE: int DUPLICATE_SAME_ACCESS: int ERROR_ALREADY_EXISTS: int ERROR_BROKEN_PIPE: int ERROR_IO_PENDING: int ERROR_MORE_DATA: int ERROR_NETNAME_DELETED: int ERROR_NO_DATA: int ERROR_NO_SYSTEM_RESOURCES: int ERROR_OPERATION_ABORTED: int ERROR_PIPE_BUSY: int ERROR_PIPE_CONNECTED: int ERROR_SEM_TIMEOUT: int FILE_FLAG_FIRST_PIPE_INSTANCE: int FILE_FLAG_OVERLAPPED: int FILE_GENERIC_READ: int FILE_GENERIC_WRITE: int GENERIC_READ: int GENERIC_WRITE: int INFINITE: int NMPWAIT_WAIT_FOREVER: int NULL: int OPEN_EXISTING: int PIPE_ACCESS_DUPLEX: int PIPE_ACCESS_INBOUND: int PIPE_READMODE_MESSAGE: int PIPE_TYPE_MESSAGE: int PIPE_UNLIMITED_INSTANCES: int PIPE_WAIT: int PROCESS_ALL_ACCESS: int PROCESS_DUP_HANDLE: int STARTF_USESHOWWINDOW: int STARTF_USESTDHANDLES: int STD_ERROR_HANDLE: int STD_INPUT_HANDLE: int STD_OUTPUT_HANDLE: int STILL_ACTIVE: int SW_HIDE: int WAIT_ABANDONED_0: int WAIT_OBJECT_0: int WAIT_TIMEOUT: int def CloseHandle(__handle: int) -> None: ... @overload def ConnectNamedPipe(handle: int, overlapped: Literal[True]) -> Overlapped: ... @overload def ConnectNamedPipe(handle: int, overlapped: Literal[False] = ...) -> None: ... @overload def ConnectNamedPipe(handle: int, overlapped: bool) -> Optional[Overlapped]: ... def CreateFile( __file_name: str, __desired_access: int, __share_mode: int, __security_attributes: int, __creation_disposition: int, __flags_and_attributes: int, __template_file: int, ) -> int: ... def CreateJunction(__src_path: str, __dst_path: str) -> None: ... def CreateNamedPipe( __name: str, __open_mode: int, __pipe_mode: int, __max_instances: int, __out_buffer_size: int, __in_buffer_size: int, __default_timeout: int, __security_attributes: int, ) -> int: ... def CreatePipe(__pipe_attrs: Any, __size: int) -> Tuple[int, int]: ... def CreateProcess( __application_name: Optional[str], __command_line: Optional[str], __proc_attrs: Any, __thread_attrs: Any, __inherit_handles: bool, __creation_flags: int, __env_mapping: Dict[str, str], __current_directory: Optional[str], __startup_info: Any, ) -> Tuple[int, int, int, int]: ... def DuplicateHandle( __source_process_handle: int, __source_handle: int, __target_process_handle: int, __desired_access: int, __inherit_handle: bool, __options: int = ..., ) -> int: ... def ExitProcess(__ExitCode: int) -> NoReturn: ... if sys.version_info >= (3, 7): def GetACP() -> int: ... def GetFileType(handle: int) -> int: ... def GetCurrentProcess() -> int: ... def GetExitCodeProcess(__process: int) -> int: ... def GetLastError() -> int: ... def GetModuleFileName(__module_handle: int) -> str: ... def GetStdHandle(__std_handle: int) -> int: ... def GetVersion() -> int: ... def OpenProcess(__desired_access: int, __inherit_handle: bool, __process_id: int) -> int: ... def PeekNamedPipe(__handle: int, __size: int = ...) -> Union[Tuple[int, int], Tuple[bytes, int, int]]: ... @overload def ReadFile(handle: int, size: int, overlapped: Literal[True]) -> Tuple[Overlapped, int]: ... @overload def ReadFile(handle: int, size: int, overlapped: Literal[False] = ...) -> Tuple[bytes, int]: ... @overload def ReadFile(handle: int, size: int, overlapped: Union[int, bool]) -> Tuple[Any, int]: ... def SetNamedPipeHandleState( __named_pipe: int, __mode: Optional[int], __max_collection_count: Optional[int], __collect_data_timeout: Optional[int] ) -> None: ... def TerminateProcess(__handle: int, __exit_code: int) -> None: ... def WaitForMultipleObjects(__handle_seq: Sequence[int], __wait_flag: bool, __milliseconds: int = ...) -> int: ... def WaitForSingleObject(__handle: int, __milliseconds: int) -> int: ... def WaitNamedPipe(__name: str, __timeout: int) -> None: ... @overload def WriteFile(handle: int, buffer: bytes, overlapped: Literal[True]) -> Tuple[Overlapped, int]: ... @overload def WriteFile(handle: int, buffer: bytes, overlapped: Literal[False] = ...) -> Tuple[int, int]: ... @overload def WriteFile(handle: int, buffer: bytes, overlapped: Union[int, bool]) -> Tuple[Any, int]: ... class Overlapped: event: int = ... def GetOverlappedResult(self, __wait: bool) -> Tuple[int, int]: ... def cancel(self) -> None: ... def getbuffer(self) -> Optional[bytes]: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/abc.pyi0000664000175000017500000000112500000000000022363 0ustar00davedave00000000000000from typing import Any, Callable, Type, TypeVar _T = TypeVar("_T") _FuncT = TypeVar("_FuncT", bound=Callable[..., Any]) # These definitions have special processing in mypy class ABCMeta(type): def register(cls: ABCMeta, subclass: Type[_T]) -> Type[_T]: ... def abstractmethod(callable: _FuncT) -> _FuncT: ... class abstractproperty(property): ... # These two are deprecated and not supported by mypy def abstractstaticmethod(callable: _FuncT) -> _FuncT: ... def abstractclassmethod(callable: _FuncT) -> _FuncT: ... class ABC(metaclass=ABCMeta): ... def get_cache_token() -> object: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/ast.pyi0000664000175000017500000002160200000000000022427 0ustar00davedave00000000000000# Rename typing to _typing, as not to conflict with typing imported # from _ast below when loaded in an unorthodox way by the Dropbox # internal Bazel integration. # The same unorthodox Bazel integration causes issues with sys, which # is imported in both modules. unfortunately we can't just rename sys, # since mypy only supports version checks with a sys that is named # sys. import sys import typing as _typing from typing import Any, Iterator, Optional, TypeVar, Union, overload from typing_extensions import Literal from _ast import * # type: ignore if sys.version_info >= (3, 8): class Num(Constant): value: complex class Str(Constant): value: str # Aliases for value, for backwards compatibility s: str class Bytes(Constant): value: bytes # Aliases for value, for backwards compatibility s: bytes class NameConstant(Constant): ... class Ellipsis(Constant): ... if sys.version_info >= (3, 9): class slice(AST): ... class ExtSlice(slice): ... class Index(slice): ... class Suite(mod): ... class AugLoad(expr_context): ... class AugStore(expr_context): ... class Param(expr_context): ... class NodeVisitor: def visit(self, node: AST) -> Any: ... def generic_visit(self, node: AST) -> Any: ... def visit_Module(self, node: Module) -> Any: ... def visit_Interactive(self, node: Interactive) -> Any: ... def visit_Expression(self, node: Expression) -> Any: ... def visit_FunctionDef(self, node: FunctionDef) -> Any: ... def visit_AsyncFunctionDef(self, node: AsyncFunctionDef) -> Any: ... def visit_ClassDef(self, node: ClassDef) -> Any: ... def visit_Return(self, node: Return) -> Any: ... def visit_Delete(self, node: Delete) -> Any: ... def visit_Assign(self, node: Assign) -> Any: ... def visit_AugAssign(self, node: AugAssign) -> Any: ... def visit_AnnAssign(self, node: AnnAssign) -> Any: ... def visit_For(self, node: For) -> Any: ... def visit_AsyncFor(self, node: AsyncFor) -> Any: ... def visit_While(self, node: While) -> Any: ... def visit_If(self, node: If) -> Any: ... def visit_With(self, node: With) -> Any: ... def visit_AsyncWith(self, node: AsyncWith) -> Any: ... def visit_Raise(self, node: Raise) -> Any: ... def visit_Try(self, node: Try) -> Any: ... def visit_Assert(self, node: Assert) -> Any: ... def visit_Import(self, node: Import) -> Any: ... def visit_ImportFrom(self, node: ImportFrom) -> Any: ... def visit_Global(self, node: Global) -> Any: ... def visit_Nonlocal(self, node: Nonlocal) -> Any: ... def visit_Expr(self, node: Expr) -> Any: ... def visit_Pass(self, node: Pass) -> Any: ... def visit_Break(self, node: Break) -> Any: ... def visit_Continue(self, node: Continue) -> Any: ... def visit_Slice(self, node: Slice) -> Any: ... def visit_BoolOp(self, node: BoolOp) -> Any: ... def visit_BinOp(self, node: BinOp) -> Any: ... def visit_UnaryOp(self, node: UnaryOp) -> Any: ... def visit_Lambda(self, node: Lambda) -> Any: ... def visit_IfExp(self, node: IfExp) -> Any: ... def visit_Dict(self, node: Dict) -> Any: ... def visit_Set(self, node: Set) -> Any: ... def visit_ListComp(self, node: ListComp) -> Any: ... def visit_SetComp(self, node: SetComp) -> Any: ... def visit_DictComp(self, node: DictComp) -> Any: ... def visit_GeneratorExp(self, node: GeneratorExp) -> Any: ... def visit_Await(self, node: Await) -> Any: ... def visit_Yield(self, node: Yield) -> Any: ... def visit_YieldFrom(self, node: YieldFrom) -> Any: ... def visit_Compare(self, node: Compare) -> Any: ... def visit_Call(self, node: Call) -> Any: ... def visit_FormattedValue(self, node: FormattedValue) -> Any: ... def visit_JoinedStr(self, node: JoinedStr) -> Any: ... def visit_Constant(self, node: Constant) -> Any: ... if sys.version_info >= (3, 8): def visit_NamedExpr(self, node: NamedExpr) -> Any: ... def visit_Attribute(self, node: Attribute) -> Any: ... def visit_Subscript(self, node: Subscript) -> Any: ... def visit_Starred(self, node: Starred) -> Any: ... def visit_Name(self, node: Name) -> Any: ... def visit_List(self, node: List) -> Any: ... def visit_Tuple(self, node: Tuple) -> Any: ... def visit_Del(self, node: Del) -> Any: ... def visit_Load(self, node: Load) -> Any: ... def visit_Store(self, node: Store) -> Any: ... def visit_And(self, node: And) -> Any: ... def visit_Or(self, node: Or) -> Any: ... def visit_Add(self, node: Add) -> Any: ... def visit_BitAnd(self, node: BitAnd) -> Any: ... def visit_BitOr(self, node: BitOr) -> Any: ... def visit_BitXor(self, node: BitXor) -> Any: ... def visit_Div(self, node: Div) -> Any: ... def visit_FloorDiv(self, node: FloorDiv) -> Any: ... def visit_LShift(self, node: LShift) -> Any: ... def visit_Mod(self, node: Mod) -> Any: ... def visit_Mult(self, node: Mult) -> Any: ... def visit_MatMult(self, node: MatMult) -> Any: ... def visit_Pow(self, node: Pow) -> Any: ... def visit_RShift(self, node: RShift) -> Any: ... def visit_Sub(self, node: Sub) -> Any: ... def visit_Invert(self, node: Invert) -> Any: ... def visit_Not(self, node: Not) -> Any: ... def visit_UAdd(self, node: UAdd) -> Any: ... def visit_USub(self, node: USub) -> Any: ... def visit_Eq(self, node: Eq) -> Any: ... def visit_Gt(self, node: Gt) -> Any: ... def visit_GtE(self, node: GtE) -> Any: ... def visit_In(self, node: In) -> Any: ... def visit_Is(self, node: Is) -> Any: ... def visit_IsNot(self, node: IsNot) -> Any: ... def visit_Lt(self, node: Lt) -> Any: ... def visit_LtE(self, node: LtE) -> Any: ... def visit_NotEq(self, node: NotEq) -> Any: ... def visit_NotIn(self, node: NotIn) -> Any: ... def visit_comprehension(self, node: comprehension) -> Any: ... def visit_ExceptHandler(self, node: ExceptHandler) -> Any: ... def visit_arguments(self, node: arguments) -> Any: ... def visit_arg(self, node: arg) -> Any: ... def visit_keyword(self, node: keyword) -> Any: ... def visit_alias(self, node: alias) -> Any: ... def visit_withitem(self, node: withitem) -> Any: ... # visit methods for deprecated nodes def visit_ExtSlice(self, node: ExtSlice) -> Any: ... def visit_Index(self, node: Index) -> Any: ... def visit_Suite(self, node: Suite) -> Any: ... def visit_AugLoad(self, node: AugLoad) -> Any: ... def visit_AugStore(self, node: AugStore) -> Any: ... def visit_Param(self, node: Param) -> Any: ... def visit_Num(self, node: Num) -> Any: ... def visit_Str(self, node: Str) -> Any: ... def visit_Bytes(self, node: Bytes) -> Any: ... def visit_NameConstant(self, node: NameConstant) -> Any: ... def visit_Ellipsis(self, node: Ellipsis) -> Any: ... class NodeTransformer(NodeVisitor): def generic_visit(self, node: AST) -> AST: ... # TODO: Override the visit_* methods with better return types. # The usual return type is Optional[AST], but Iterable[AST] # is also allowed in some cases -- this needs to be mapped. _T = TypeVar("_T", bound=AST) if sys.version_info >= (3, 8): @overload def parse( source: Union[str, bytes], filename: Union[str, bytes] = ..., mode: Literal["exec"] = ..., *, type_comments: bool = ..., feature_version: Union[None, int, _typing.Tuple[int, int]] = ..., ) -> Module: ... @overload def parse( source: Union[str, bytes], filename: Union[str, bytes] = ..., mode: str = ..., *, type_comments: bool = ..., feature_version: Union[None, int, _typing.Tuple[int, int]] = ..., ) -> AST: ... else: @overload def parse(source: Union[str, bytes], filename: Union[str, bytes] = ..., mode: Literal["exec"] = ...) -> Module: ... @overload def parse(source: Union[str, bytes], filename: Union[str, bytes] = ..., mode: str = ...) -> AST: ... if sys.version_info >= (3, 9): def unparse(ast_obj: AST) -> str: ... def copy_location(new_node: _T, old_node: AST) -> _T: ... if sys.version_info >= (3, 9): def dump( node: AST, annotate_fields: bool = ..., include_attributes: bool = ..., *, indent: Union[int, str, None] = ... ) -> str: ... else: def dump(node: AST, annotate_fields: bool = ..., include_attributes: bool = ...) -> str: ... def fix_missing_locations(node: _T) -> _T: ... def get_docstring(node: AST, clean: bool = ...) -> Optional[str]: ... def increment_lineno(node: _T, n: int = ...) -> _T: ... def iter_child_nodes(node: AST) -> Iterator[AST]: ... def iter_fields(node: AST) -> Iterator[_typing.Tuple[str, Any]]: ... def literal_eval(node_or_string: Union[str, AST]) -> Any: ... if sys.version_info >= (3, 8): def get_source_segment(source: str, node: AST, *, padded: bool = ...) -> Optional[str]: ... def walk(node: AST) -> Iterator[AST]: ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4303794 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/asyncio/0000775000175000017500000000000000000000000022561 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/asyncio/__init__.pyi0000664000175000017500000001022200000000000025040 0ustar00davedave00000000000000import sys from typing import Type from .base_events import BaseEventLoop as BaseEventLoop from .coroutines import coroutine as coroutine, iscoroutine as iscoroutine, iscoroutinefunction as iscoroutinefunction from .events import ( AbstractEventLoop as AbstractEventLoop, AbstractEventLoopPolicy as AbstractEventLoopPolicy, AbstractServer as AbstractServer, Handle as Handle, TimerHandle as TimerHandle, _get_running_loop as _get_running_loop, _set_running_loop as _set_running_loop, get_child_watcher as get_child_watcher, get_event_loop as get_event_loop, get_event_loop_policy as get_event_loop_policy, new_event_loop as new_event_loop, set_child_watcher as set_child_watcher, set_event_loop as set_event_loop, set_event_loop_policy as set_event_loop_policy, ) from .futures import Future as Future, isfuture as isfuture, wrap_future as wrap_future from .locks import ( BoundedSemaphore as BoundedSemaphore, Condition as Condition, Event as Event, Lock as Lock, Semaphore as Semaphore, ) from .protocols import ( BaseProtocol as BaseProtocol, DatagramProtocol as DatagramProtocol, Protocol as Protocol, SubprocessProtocol as SubprocessProtocol, ) from .queues import ( LifoQueue as LifoQueue, PriorityQueue as PriorityQueue, Queue as Queue, QueueEmpty as QueueEmpty, QueueFull as QueueFull, ) from .streams import ( StreamReader as StreamReader, StreamReaderProtocol as StreamReaderProtocol, StreamWriter as StreamWriter, open_connection as open_connection, start_server as start_server, ) from .subprocess import create_subprocess_exec as create_subprocess_exec, create_subprocess_shell as create_subprocess_shell from .tasks import ( ALL_COMPLETED as ALL_COMPLETED, FIRST_COMPLETED as FIRST_COMPLETED, FIRST_EXCEPTION as FIRST_EXCEPTION, Task as Task, as_completed as as_completed, ensure_future as ensure_future, gather as gather, run_coroutine_threadsafe as run_coroutine_threadsafe, shield as shield, sleep as sleep, wait as wait, wait_for as wait_for, ) from .transports import ( BaseTransport as BaseTransport, DatagramTransport as DatagramTransport, ReadTransport as ReadTransport, SubprocessTransport as SubprocessTransport, Transport as Transport, WriteTransport as WriteTransport, ) if sys.version_info >= (3, 7): from .events import get_running_loop as get_running_loop if sys.version_info >= (3, 8): from .exceptions import ( CancelledError as CancelledError, IncompleteReadError as IncompleteReadError, InvalidStateError as InvalidStateError, LimitOverrunError as LimitOverrunError, SendfileNotAvailableError as SendfileNotAvailableError, TimeoutError as TimeoutError, ) else: if sys.version_info >= (3, 7): from .events import SendfileNotAvailableError as SendfileNotAvailableError from .futures import CancelledError as CancelledError, InvalidStateError as InvalidStateError, TimeoutError as TimeoutError from .streams import IncompleteReadError as IncompleteReadError, LimitOverrunError as LimitOverrunError if sys.version_info >= (3, 7): from .protocols import BufferedProtocol as BufferedProtocol if sys.version_info >= (3, 7): from .runners import run as run if sys.version_info >= (3, 7): from .tasks import all_tasks as all_tasks, create_task as create_task, current_task as current_task if sys.version_info >= (3, 9): from .threads import to_thread as to_thread DefaultEventLoopPolicy: Type[AbstractEventLoopPolicy] if sys.platform == "win32": from .windows_events import * if sys.platform != "win32": from .streams import open_unix_connection as open_unix_connection, start_unix_server as start_unix_server from .unix_events import ( AbstractChildWatcher as AbstractChildWatcher, FastChildWatcher as FastChildWatcher, SafeChildWatcher as SafeChildWatcher, SelectorEventLoop as SelectorEventLoop, ) if sys.version_info >= (3, 8): from .unix_events import MultiLoopChildWatcher as MultiLoopChildWatcher, ThreadedChildWatcher as ThreadedChildWatcher ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/asyncio/base_events.pyi0000664000175000017500000003344000000000000025606 0ustar00davedave00000000000000import ssl import sys from _typeshed import FileDescriptorLike from abc import ABCMeta from asyncio.events import AbstractEventLoop, AbstractServer, Handle, TimerHandle from asyncio.futures import Future from asyncio.protocols import BaseProtocol from asyncio.tasks import Task from asyncio.transports import BaseTransport from socket import AddressFamily, SocketKind, _Address, _RetAddress, socket from typing import IO, Any, Awaitable, Callable, Dict, Generator, List, Optional, Sequence, Tuple, TypeVar, Union, overload from typing_extensions import Literal if sys.version_info >= (3, 7): from contextvars import Context _T = TypeVar("_T") _Context = Dict[str, Any] _ExceptionHandler = Callable[[AbstractEventLoop, _Context], Any] _ProtocolFactory = Callable[[], BaseProtocol] _SSLContext = Union[bool, None, ssl.SSLContext] _TransProtPair = Tuple[BaseTransport, BaseProtocol] class Server(AbstractServer): ... class BaseEventLoop(AbstractEventLoop, metaclass=ABCMeta): def run_forever(self) -> None: ... # Can't use a union, see mypy issue # 1873. @overload def run_until_complete(self, future: Generator[Any, None, _T]) -> _T: ... @overload def run_until_complete(self, future: Awaitable[_T]) -> _T: ... def stop(self) -> None: ... def is_running(self) -> bool: ... def is_closed(self) -> bool: ... def close(self) -> None: ... async def shutdown_asyncgens(self) -> None: ... # Methods scheduling callbacks. All these return Handles. if sys.version_info >= (3, 7): def call_soon(self, callback: Callable[..., Any], *args: Any, context: Optional[Context] = ...) -> Handle: ... def call_later( self, delay: float, callback: Callable[..., Any], *args: Any, context: Optional[Context] = ... ) -> TimerHandle: ... def call_at( self, when: float, callback: Callable[..., Any], *args: Any, context: Optional[Context] = ... ) -> TimerHandle: ... else: def call_soon(self, callback: Callable[..., Any], *args: Any) -> Handle: ... def call_later(self, delay: float, callback: Callable[..., Any], *args: Any) -> TimerHandle: ... def call_at(self, when: float, callback: Callable[..., Any], *args: Any) -> TimerHandle: ... def time(self) -> float: ... # Future methods def create_future(self) -> Future[Any]: ... # Tasks methods if sys.version_info >= (3, 8): def create_task(self, coro: Union[Awaitable[_T], Generator[Any, None, _T]], *, name: Optional[str] = ...) -> Task[_T]: ... else: def create_task(self, coro: Union[Awaitable[_T], Generator[Any, None, _T]]) -> Task[_T]: ... def set_task_factory( self, factory: Optional[Callable[[AbstractEventLoop, Generator[Any, None, _T]], Future[_T]]] ) -> None: ... def get_task_factory(self) -> Optional[Callable[[AbstractEventLoop, Generator[Any, None, _T]], Future[_T]]]: ... # Methods for interacting with threads if sys.version_info >= (3, 7): def call_soon_threadsafe(self, callback: Callable[..., Any], *args: Any, context: Optional[Context] = ...) -> Handle: ... else: def call_soon_threadsafe(self, callback: Callable[..., Any], *args: Any) -> Handle: ... def run_in_executor(self, executor: Any, func: Callable[..., _T], *args: Any) -> Future[_T]: ... def set_default_executor(self, executor: Any) -> None: ... # Network I/O methods returning Futures. async def getaddrinfo( self, host: Optional[str], port: Union[str, int, None], *, family: int = ..., type: int = ..., proto: int = ..., flags: int = ..., ) -> List[Tuple[AddressFamily, SocketKind, int, str, Union[Tuple[str, int], Tuple[str, int, int, int]]]]: ... async def getnameinfo( self, sockaddr: Union[Tuple[str, int], Tuple[str, int, int, int]], flags: int = ... ) -> Tuple[str, str]: ... if sys.version_info >= (3, 8): @overload async def create_connection( self, protocol_factory: _ProtocolFactory, host: str = ..., port: int = ..., *, ssl: _SSLContext = ..., family: int = ..., proto: int = ..., flags: int = ..., sock: None = ..., local_addr: Optional[Tuple[str, int]] = ..., server_hostname: Optional[str] = ..., ssl_handshake_timeout: Optional[float] = ..., happy_eyeballs_delay: Optional[float] = ..., interleave: Optional[int] = ..., ) -> _TransProtPair: ... @overload async def create_connection( self, protocol_factory: _ProtocolFactory, host: None = ..., port: None = ..., *, ssl: _SSLContext = ..., family: int = ..., proto: int = ..., flags: int = ..., sock: socket, local_addr: None = ..., server_hostname: Optional[str] = ..., ssl_handshake_timeout: Optional[float] = ..., happy_eyeballs_delay: Optional[float] = ..., interleave: Optional[int] = ..., ) -> _TransProtPair: ... elif sys.version_info >= (3, 7): @overload async def create_connection( self, protocol_factory: _ProtocolFactory, host: str = ..., port: int = ..., *, ssl: _SSLContext = ..., family: int = ..., proto: int = ..., flags: int = ..., sock: None = ..., local_addr: Optional[Tuple[str, int]] = ..., server_hostname: Optional[str] = ..., ssl_handshake_timeout: Optional[float] = ..., ) -> _TransProtPair: ... @overload async def create_connection( self, protocol_factory: _ProtocolFactory, host: None = ..., port: None = ..., *, ssl: _SSLContext = ..., family: int = ..., proto: int = ..., flags: int = ..., sock: socket, local_addr: None = ..., server_hostname: Optional[str] = ..., ssl_handshake_timeout: Optional[float] = ..., ) -> _TransProtPair: ... else: @overload async def create_connection( self, protocol_factory: _ProtocolFactory, host: str = ..., port: int = ..., *, ssl: _SSLContext = ..., family: int = ..., proto: int = ..., flags: int = ..., sock: None = ..., local_addr: Optional[Tuple[str, int]] = ..., server_hostname: Optional[str] = ..., ) -> _TransProtPair: ... @overload async def create_connection( self, protocol_factory: _ProtocolFactory, host: None = ..., port: None = ..., *, ssl: _SSLContext = ..., family: int = ..., proto: int = ..., flags: int = ..., sock: socket, local_addr: None = ..., server_hostname: Optional[str] = ..., ) -> _TransProtPair: ... if sys.version_info >= (3, 7): async def sock_sendfile( self, sock: socket, file: IO[bytes], offset: int = ..., count: Optional[int] = ..., *, fallback: bool = ... ) -> int: ... @overload async def create_server( self, protocol_factory: _ProtocolFactory, host: Optional[Union[str, Sequence[str]]] = ..., port: int = ..., *, family: int = ..., flags: int = ..., sock: None = ..., backlog: int = ..., ssl: _SSLContext = ..., reuse_address: Optional[bool] = ..., reuse_port: Optional[bool] = ..., ssl_handshake_timeout: Optional[float] = ..., start_serving: bool = ..., ) -> Server: ... @overload async def create_server( self, protocol_factory: _ProtocolFactory, host: None = ..., port: None = ..., *, family: int = ..., flags: int = ..., sock: socket = ..., backlog: int = ..., ssl: _SSLContext = ..., reuse_address: Optional[bool] = ..., reuse_port: Optional[bool] = ..., ssl_handshake_timeout: Optional[float] = ..., start_serving: bool = ..., ) -> Server: ... async def connect_accepted_socket( self, protocol_factory: _ProtocolFactory, sock: socket, *, ssl: _SSLContext = ..., ssl_handshake_timeout: Optional[float] = ..., ) -> _TransProtPair: ... async def sendfile( self, transport: BaseTransport, file: IO[bytes], offset: int = ..., count: Optional[int] = ..., *, fallback: bool = ..., ) -> int: ... async def start_tls( self, transport: BaseTransport, protocol: BaseProtocol, sslcontext: ssl.SSLContext, *, server_side: bool = ..., server_hostname: Optional[str] = ..., ssl_handshake_timeout: Optional[float] = ..., ) -> BaseTransport: ... else: @overload async def create_server( self, protocol_factory: _ProtocolFactory, host: Optional[Union[str, Sequence[str]]] = ..., port: int = ..., *, family: int = ..., flags: int = ..., sock: None = ..., backlog: int = ..., ssl: _SSLContext = ..., reuse_address: Optional[bool] = ..., reuse_port: Optional[bool] = ..., ) -> Server: ... @overload async def create_server( self, protocol_factory: _ProtocolFactory, host: None = ..., port: None = ..., *, family: int = ..., flags: int = ..., sock: socket, backlog: int = ..., ssl: _SSLContext = ..., reuse_address: Optional[bool] = ..., reuse_port: Optional[bool] = ..., ) -> Server: ... async def connect_accepted_socket( self, protocol_factory: _ProtocolFactory, sock: socket, *, ssl: _SSLContext = ... ) -> _TransProtPair: ... async def create_datagram_endpoint( self, protocol_factory: _ProtocolFactory, local_addr: Optional[Tuple[str, int]] = ..., remote_addr: Optional[Tuple[str, int]] = ..., *, family: int = ..., proto: int = ..., flags: int = ..., reuse_address: Optional[bool] = ..., reuse_port: Optional[bool] = ..., allow_broadcast: Optional[bool] = ..., sock: Optional[socket] = ..., ) -> _TransProtPair: ... # Pipes and subprocesses. async def connect_read_pipe(self, protocol_factory: _ProtocolFactory, pipe: Any) -> _TransProtPair: ... async def connect_write_pipe(self, protocol_factory: _ProtocolFactory, pipe: Any) -> _TransProtPair: ... async def subprocess_shell( self, protocol_factory: _ProtocolFactory, cmd: Union[bytes, str], *, stdin: Any = ..., stdout: Any = ..., stderr: Any = ..., universal_newlines: Literal[False] = ..., shell: Literal[True] = ..., bufsize: Literal[0] = ..., encoding: None = ..., errors: None = ..., text: Literal[False, None] = ..., **kwargs: Any, ) -> _TransProtPair: ... async def subprocess_exec( self, protocol_factory: _ProtocolFactory, *args: Any, stdin: Any = ..., stdout: Any = ..., stderr: Any = ..., **kwargs: Any, ) -> _TransProtPair: ... def add_reader(self, fd: FileDescriptorLike, callback: Callable[..., Any], *args: Any) -> None: ... def remove_reader(self, fd: FileDescriptorLike) -> None: ... def add_writer(self, fd: FileDescriptorLike, callback: Callable[..., Any], *args: Any) -> None: ... def remove_writer(self, fd: FileDescriptorLike) -> None: ... # Completion based I/O methods returning Futures prior to 3.7 if sys.version_info >= (3, 7): async def sock_recv(self, sock: socket, nbytes: int) -> bytes: ... async def sock_recv_into(self, sock: socket, buf: bytearray) -> int: ... async def sock_sendall(self, sock: socket, data: bytes) -> None: ... async def sock_connect(self, sock: socket, address: _Address) -> None: ... async def sock_accept(self, sock: socket) -> Tuple[socket, _RetAddress]: ... else: def sock_recv(self, sock: socket, nbytes: int) -> Future[bytes]: ... def sock_sendall(self, sock: socket, data: bytes) -> Future[None]: ... def sock_connect(self, sock: socket, address: _Address) -> Future[None]: ... def sock_accept(self, sock: socket) -> Future[Tuple[socket, _RetAddress]]: ... # Signal handling. def add_signal_handler(self, sig: int, callback: Callable[..., Any], *args: Any) -> None: ... def remove_signal_handler(self, sig: int) -> None: ... # Error handlers. def set_exception_handler(self, handler: Optional[_ExceptionHandler]) -> None: ... def get_exception_handler(self) -> Optional[_ExceptionHandler]: ... def default_exception_handler(self, context: _Context) -> None: ... def call_exception_handler(self, context: _Context) -> None: ... # Debug flag management. def get_debug(self) -> bool: ... def set_debug(self, enabled: bool) -> None: ... if sys.version_info >= (3, 9): async def shutdown_default_executor(self) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/asyncio/base_futures.pyi0000664000175000017500000000133500000000000025775 0ustar00davedave00000000000000import sys from typing import Any, Callable, List, Sequence, Tuple from typing_extensions import Literal if sys.version_info >= (3, 7): from contextvars import Context from . import futures _PENDING: Literal["PENDING"] # undocumented _CANCELLED: Literal["CANCELLED"] # undocumented _FINISHED: Literal["FINISHED"] # undocumented def isfuture(obj: object) -> bool: ... if sys.version_info >= (3, 7): def _format_callbacks(cb: Sequence[Tuple[Callable[[futures.Future[Any]], None], Context]]) -> str: ... # undocumented else: def _format_callbacks(cb: Sequence[Callable[[futures.Future[Any]], None]]) -> str: ... # undocumented def _future_repr_info(future: futures.Future[Any]) -> List[str]: ... # undocumented ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/asyncio/base_subprocess.pyi0000664000175000017500000000624700000000000026477 0ustar00davedave00000000000000import subprocess from typing import IO, Any, Callable, Deque, Dict, List, Optional, Sequence, Tuple, Union from . import events, futures, protocols, transports _File = Optional[Union[int, IO[Any]]] class BaseSubprocessTransport(transports.SubprocessTransport): _closed: bool # undocumented _protocol: protocols.SubprocessProtocol # undocumented _loop: events.AbstractEventLoop # undocumented _proc: Optional[subprocess.Popen[Any]] # undocumented _pid: Optional[int] # undocumented _returncode: Optional[int] # undocumented _exit_waiters: List[futures.Future[Any]] # undocumented _pending_calls: Deque[Tuple[Callable[..., Any], Tuple[Any, ...]]] # undocumented _pipes: Dict[int, _File] # undocumented _finished: bool # undocumented def __init__( self, loop: events.AbstractEventLoop, protocol: protocols.SubprocessProtocol, args: Union[str, bytes, Sequence[Union[str, bytes]]], shell: bool, stdin: _File, stdout: _File, stderr: _File, bufsize: int, waiter: Optional[futures.Future[Any]] = ..., extra: Optional[Any] = ..., **kwargs: Any, ) -> None: ... def _start( self, args: Union[str, bytes, Sequence[Union[str, bytes]]], shell: bool, stdin: _File, stdout: _File, stderr: _File, bufsize: int, **kwargs: Any, ) -> None: ... # undocumented def set_protocol(self, protocol: protocols.BaseProtocol) -> None: ... def get_protocol(self) -> protocols.BaseProtocol: ... def is_closing(self) -> bool: ... def close(self) -> None: ... def get_pid(self) -> Optional[int]: ... # type: ignore def get_returncode(self) -> Optional[int]: ... def get_pipe_transport(self, fd: int) -> _File: ... # type: ignore def _check_proc(self) -> None: ... # undocumented def send_signal(self, signal: int) -> None: ... # type: ignore def terminate(self) -> None: ... def kill(self) -> None: ... async def _connect_pipes(self, waiter: Optional[futures.Future[Any]]) -> None: ... # undocumented def _call(self, cb: Callable[..., Any], *data: Any) -> None: ... # undocumented def _pipe_connection_lost(self, fd: int, exc: Optional[BaseException]) -> None: ... # undocumented def _pipe_data_received(self, fd: int, data: bytes) -> None: ... # undocumented def _process_exited(self, returncode: int) -> None: ... # undocumented async def _wait(self) -> int: ... # undocumented def _try_finish(self) -> None: ... # undocumented def _call_connection_lost(self, exc: Optional[BaseException]) -> None: ... # undocumented class WriteSubprocessPipeProto(protocols.BaseProtocol): # undocumented def __init__(self, proc: BaseSubprocessTransport, fd: int) -> None: ... def connection_made(self, transport: transports.BaseTransport) -> None: ... def connection_lost(self, exc: Optional[BaseException]) -> None: ... def pause_writing(self) -> None: ... def resume_writing(self) -> None: ... class ReadSubprocessPipeProto(WriteSubprocessPipeProto, protocols.Protocol): # undocumented def data_received(self, data: bytes) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/asyncio/base_tasks.pyi0000664000175000017500000000063400000000000025426 0ustar00davedave00000000000000from _typeshed import AnyPath from types import FrameType from typing import Any, List, Optional from . import tasks def _task_repr_info(task: tasks.Task[Any]) -> List[str]: ... # undocumented def _task_get_stack(task: tasks.Task[Any], limit: Optional[int]) -> List[FrameType]: ... # undocumented def _task_print_stack(task: tasks.Task[Any], limit: Optional[int], file: AnyPath) -> None: ... # undocumented ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/asyncio/compat.pyi0000664000175000017500000000026400000000000024571 0ustar00davedave00000000000000import sys from typing import List if sys.version_info < (3, 7): PY34: bool PY35: bool PY352: bool def flatten_list_bytes(list_of_data: List[bytes]) -> bytes: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/asyncio/constants.pyi0000664000175000017500000000050700000000000025322 0ustar00davedave00000000000000import enum import sys LOG_THRESHOLD_FOR_CONNLOST_WRITES: int ACCEPT_RETRY_DELAY: int DEBUG_STACK_DEPTH: int if sys.version_info >= (3, 7): SSL_HANDSHAKE_TIMEOUT: float SENDFILE_FALLBACK_READBUFFER_SIZE: int class _SendfileMode(enum.Enum): UNSUPPORTED: int = ... TRY_NATIVE: int = ... FALLBACK: int = ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/asyncio/coroutines.pyi0000664000175000017500000000034200000000000025475 0ustar00davedave00000000000000from typing import Any, Callable, TypeVar _F = TypeVar("_F", bound=Callable[..., Any]) def coroutine(func: _F) -> _F: ... def iscoroutinefunction(func: Callable[..., Any]) -> bool: ... def iscoroutine(obj: Any) -> bool: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/asyncio/events.pyi0000664000175000017500000004433000000000000024614 0ustar00davedave00000000000000import ssl import sys from _typeshed import FileDescriptorLike from abc import ABCMeta, abstractmethod from asyncio.futures import Future from asyncio.protocols import BaseProtocol from asyncio.tasks import Task from asyncio.transports import BaseTransport from asyncio.unix_events import AbstractChildWatcher from socket import AddressFamily, SocketKind, _Address, _RetAddress, socket from typing import IO, Any, Awaitable, Callable, Dict, Generator, List, Optional, Sequence, Tuple, TypeVar, Union, overload if sys.version_info >= (3, 7): from contextvars import Context _T = TypeVar("_T") _Context = Dict[str, Any] _ExceptionHandler = Callable[[AbstractEventLoop, _Context], Any] _ProtocolFactory = Callable[[], BaseProtocol] _SSLContext = Union[bool, None, ssl.SSLContext] _TransProtPair = Tuple[BaseTransport, BaseProtocol] class Handle: _cancelled = False _args: Sequence[Any] if sys.version_info >= (3, 7): def __init__( self, callback: Callable[..., Any], args: Sequence[Any], loop: AbstractEventLoop, context: Optional[Context] = ... ) -> None: ... else: def __init__(self, callback: Callable[..., Any], args: Sequence[Any], loop: AbstractEventLoop) -> None: ... def __repr__(self) -> str: ... def cancel(self) -> None: ... def _run(self) -> None: ... if sys.version_info >= (3, 7): def cancelled(self) -> bool: ... class TimerHandle(Handle): if sys.version_info >= (3, 7): def __init__( self, when: float, callback: Callable[..., Any], args: Sequence[Any], loop: AbstractEventLoop, context: Optional[Context] = ..., ) -> None: ... else: def __init__(self, when: float, callback: Callable[..., Any], args: Sequence[Any], loop: AbstractEventLoop) -> None: ... def __hash__(self) -> int: ... if sys.version_info >= (3, 7): def when(self) -> float: ... class AbstractServer: sockets: Optional[List[socket]] def close(self) -> None: ... if sys.version_info >= (3, 7): async def __aenter__(self: _T) -> _T: ... async def __aexit__(self, *exc: Any) -> None: ... def get_loop(self) -> AbstractEventLoop: ... def is_serving(self) -> bool: ... async def start_serving(self) -> None: ... async def serve_forever(self) -> None: ... async def wait_closed(self) -> None: ... class AbstractEventLoop(metaclass=ABCMeta): slow_callback_duration: float = ... @abstractmethod def run_forever(self) -> None: ... # Can't use a union, see mypy issue # 1873. @overload @abstractmethod def run_until_complete(self, future: Generator[Any, None, _T]) -> _T: ... @overload @abstractmethod def run_until_complete(self, future: Awaitable[_T]) -> _T: ... @abstractmethod def stop(self) -> None: ... @abstractmethod def is_running(self) -> bool: ... @abstractmethod def is_closed(self) -> bool: ... @abstractmethod def close(self) -> None: ... if sys.version_info >= (3, 6): @abstractmethod async def shutdown_asyncgens(self) -> None: ... # Methods scheduling callbacks. All these return Handles. @abstractmethod def call_soon(self, callback: Callable[..., Any], *args: Any) -> Handle: ... @abstractmethod def call_later(self, delay: float, callback: Callable[..., Any], *args: Any) -> TimerHandle: ... @abstractmethod def call_at(self, when: float, callback: Callable[..., Any], *args: Any) -> TimerHandle: ... @abstractmethod def time(self) -> float: ... # Future methods @abstractmethod def create_future(self) -> Future[Any]: ... # Tasks methods if sys.version_info >= (3, 8): @abstractmethod def create_task(self, coro: Union[Awaitable[_T], Generator[Any, None, _T]], *, name: Optional[str] = ...) -> Task[_T]: ... else: @abstractmethod def create_task(self, coro: Union[Awaitable[_T], Generator[Any, None, _T]]) -> Task[_T]: ... @abstractmethod def set_task_factory( self, factory: Optional[Callable[[AbstractEventLoop, Generator[Any, None, _T]], Future[_T]]] ) -> None: ... @abstractmethod def get_task_factory(self) -> Optional[Callable[[AbstractEventLoop, Generator[Any, None, _T]], Future[_T]]]: ... # Methods for interacting with threads @abstractmethod def call_soon_threadsafe(self, callback: Callable[..., Any], *args: Any) -> Handle: ... @abstractmethod def run_in_executor(self, executor: Any, func: Callable[..., _T], *args: Any) -> Awaitable[_T]: ... @abstractmethod def set_default_executor(self, executor: Any) -> None: ... # Network I/O methods returning Futures. @abstractmethod async def getaddrinfo( self, host: Optional[str], port: Union[str, int, None], *, family: int = ..., type: int = ..., proto: int = ..., flags: int = ..., ) -> List[Tuple[AddressFamily, SocketKind, int, str, Union[Tuple[str, int], Tuple[str, int, int, int]]]]: ... @abstractmethod async def getnameinfo( self, sockaddr: Union[Tuple[str, int], Tuple[str, int, int, int]], flags: int = ... ) -> Tuple[str, str]: ... if sys.version_info >= (3, 8): @overload @abstractmethod async def create_connection( self, protocol_factory: _ProtocolFactory, host: str = ..., port: int = ..., *, ssl: _SSLContext = ..., family: int = ..., proto: int = ..., flags: int = ..., sock: None = ..., local_addr: Optional[Tuple[str, int]] = ..., server_hostname: Optional[str] = ..., ssl_handshake_timeout: Optional[float] = ..., happy_eyeballs_delay: Optional[float] = ..., interleave: Optional[int] = ..., ) -> _TransProtPair: ... @overload @abstractmethod async def create_connection( self, protocol_factory: _ProtocolFactory, host: None = ..., port: None = ..., *, ssl: _SSLContext = ..., family: int = ..., proto: int = ..., flags: int = ..., sock: socket, local_addr: None = ..., server_hostname: Optional[str] = ..., ssl_handshake_timeout: Optional[float] = ..., happy_eyeballs_delay: Optional[float] = ..., interleave: Optional[int] = ..., ) -> _TransProtPair: ... elif sys.version_info >= (3, 7): @overload @abstractmethod async def create_connection( self, protocol_factory: _ProtocolFactory, host: str = ..., port: int = ..., *, ssl: _SSLContext = ..., family: int = ..., proto: int = ..., flags: int = ..., sock: None = ..., local_addr: Optional[Tuple[str, int]] = ..., server_hostname: Optional[str] = ..., ssl_handshake_timeout: Optional[float] = ..., ) -> _TransProtPair: ... @overload @abstractmethod async def create_connection( self, protocol_factory: _ProtocolFactory, host: None = ..., port: None = ..., *, ssl: _SSLContext = ..., family: int = ..., proto: int = ..., flags: int = ..., sock: socket, local_addr: None = ..., server_hostname: Optional[str] = ..., ssl_handshake_timeout: Optional[float] = ..., ) -> _TransProtPair: ... else: @overload @abstractmethod async def create_connection( self, protocol_factory: _ProtocolFactory, host: str = ..., port: int = ..., *, ssl: _SSLContext = ..., family: int = ..., proto: int = ..., flags: int = ..., sock: None = ..., local_addr: Optional[Tuple[str, int]] = ..., server_hostname: Optional[str] = ..., ) -> _TransProtPair: ... @overload @abstractmethod async def create_connection( self, protocol_factory: _ProtocolFactory, host: None = ..., port: None = ..., *, ssl: _SSLContext = ..., family: int = ..., proto: int = ..., flags: int = ..., sock: socket, local_addr: None = ..., server_hostname: Optional[str] = ..., ) -> _TransProtPair: ... if sys.version_info >= (3, 7): @abstractmethod async def sock_sendfile( self, sock: socket, file: IO[bytes], offset: int = ..., count: Optional[int] = ..., *, fallback: bool = ... ) -> int: ... @overload @abstractmethod async def create_server( self, protocol_factory: _ProtocolFactory, host: Optional[Union[str, Sequence[str]]] = ..., port: int = ..., *, family: int = ..., flags: int = ..., sock: None = ..., backlog: int = ..., ssl: _SSLContext = ..., reuse_address: Optional[bool] = ..., reuse_port: Optional[bool] = ..., ssl_handshake_timeout: Optional[float] = ..., start_serving: bool = ..., ) -> AbstractServer: ... @overload @abstractmethod async def create_server( self, protocol_factory: _ProtocolFactory, host: None = ..., port: None = ..., *, family: int = ..., flags: int = ..., sock: socket = ..., backlog: int = ..., ssl: _SSLContext = ..., reuse_address: Optional[bool] = ..., reuse_port: Optional[bool] = ..., ssl_handshake_timeout: Optional[float] = ..., start_serving: bool = ..., ) -> AbstractServer: ... async def create_unix_connection( self, protocol_factory: _ProtocolFactory, path: Optional[str] = ..., *, ssl: _SSLContext = ..., sock: Optional[socket] = ..., server_hostname: Optional[str] = ..., ssl_handshake_timeout: Optional[float] = ..., ) -> _TransProtPair: ... async def create_unix_server( self, protocol_factory: _ProtocolFactory, path: Optional[str] = ..., *, sock: Optional[socket] = ..., backlog: int = ..., ssl: _SSLContext = ..., ssl_handshake_timeout: Optional[float] = ..., start_serving: bool = ..., ) -> AbstractServer: ... @abstractmethod async def sendfile( self, transport: BaseTransport, file: IO[bytes], offset: int = ..., count: Optional[int] = ..., *, fallback: bool = ..., ) -> int: ... @abstractmethod async def start_tls( self, transport: BaseTransport, protocol: BaseProtocol, sslcontext: ssl.SSLContext, *, server_side: bool = ..., server_hostname: Optional[str] = ..., ssl_handshake_timeout: Optional[float] = ..., ) -> BaseTransport: ... else: @overload @abstractmethod async def create_server( self, protocol_factory: _ProtocolFactory, host: Optional[Union[str, Sequence[str]]] = ..., port: int = ..., *, family: int = ..., flags: int = ..., sock: None = ..., backlog: int = ..., ssl: _SSLContext = ..., reuse_address: Optional[bool] = ..., reuse_port: Optional[bool] = ..., ) -> AbstractServer: ... @overload @abstractmethod async def create_server( self, protocol_factory: _ProtocolFactory, host: None = ..., port: None = ..., *, family: int = ..., flags: int = ..., sock: socket, backlog: int = ..., ssl: _SSLContext = ..., reuse_address: Optional[bool] = ..., reuse_port: Optional[bool] = ..., ) -> AbstractServer: ... async def create_unix_connection( self, protocol_factory: _ProtocolFactory, path: str, *, ssl: _SSLContext = ..., sock: Optional[socket] = ..., server_hostname: Optional[str] = ..., ) -> _TransProtPair: ... async def create_unix_server( self, protocol_factory: _ProtocolFactory, path: str, *, sock: Optional[socket] = ..., backlog: int = ..., ssl: _SSLContext = ..., ) -> AbstractServer: ... @abstractmethod async def create_datagram_endpoint( self, protocol_factory: _ProtocolFactory, local_addr: Optional[Tuple[str, int]] = ..., remote_addr: Optional[Tuple[str, int]] = ..., *, family: int = ..., proto: int = ..., flags: int = ..., reuse_address: Optional[bool] = ..., reuse_port: Optional[bool] = ..., allow_broadcast: Optional[bool] = ..., sock: Optional[socket] = ..., ) -> _TransProtPair: ... # Pipes and subprocesses. @abstractmethod async def connect_read_pipe(self, protocol_factory: _ProtocolFactory, pipe: Any) -> _TransProtPair: ... @abstractmethod async def connect_write_pipe(self, protocol_factory: _ProtocolFactory, pipe: Any) -> _TransProtPair: ... @abstractmethod async def subprocess_shell( self, protocol_factory: _ProtocolFactory, cmd: Union[bytes, str], *, stdin: Any = ..., stdout: Any = ..., stderr: Any = ..., **kwargs: Any, ) -> _TransProtPair: ... @abstractmethod async def subprocess_exec( self, protocol_factory: _ProtocolFactory, *args: Any, stdin: Any = ..., stdout: Any = ..., stderr: Any = ..., **kwargs: Any, ) -> _TransProtPair: ... @abstractmethod def add_reader(self, fd: FileDescriptorLike, callback: Callable[..., Any], *args: Any) -> None: ... @abstractmethod def remove_reader(self, fd: FileDescriptorLike) -> None: ... @abstractmethod def add_writer(self, fd: FileDescriptorLike, callback: Callable[..., Any], *args: Any) -> None: ... @abstractmethod def remove_writer(self, fd: FileDescriptorLike) -> None: ... # Completion based I/O methods returning Futures prior to 3.7 if sys.version_info >= (3, 7): @abstractmethod async def sock_recv(self, sock: socket, nbytes: int) -> bytes: ... @abstractmethod async def sock_recv_into(self, sock: socket, buf: bytearray) -> int: ... @abstractmethod async def sock_sendall(self, sock: socket, data: bytes) -> None: ... @abstractmethod async def sock_connect(self, sock: socket, address: _Address) -> None: ... @abstractmethod async def sock_accept(self, sock: socket) -> Tuple[socket, _RetAddress]: ... else: @abstractmethod def sock_recv(self, sock: socket, nbytes: int) -> Future[bytes]: ... @abstractmethod def sock_sendall(self, sock: socket, data: bytes) -> Future[None]: ... @abstractmethod def sock_connect(self, sock: socket, address: _Address) -> Future[None]: ... @abstractmethod def sock_accept(self, sock: socket) -> Future[Tuple[socket, _RetAddress]]: ... # Signal handling. @abstractmethod def add_signal_handler(self, sig: int, callback: Callable[..., Any], *args: Any) -> None: ... @abstractmethod def remove_signal_handler(self, sig: int) -> None: ... # Error handlers. @abstractmethod def set_exception_handler(self, handler: Optional[_ExceptionHandler]) -> None: ... @abstractmethod def get_exception_handler(self) -> Optional[_ExceptionHandler]: ... @abstractmethod def default_exception_handler(self, context: _Context) -> None: ... @abstractmethod def call_exception_handler(self, context: _Context) -> None: ... # Debug flag management. @abstractmethod def get_debug(self) -> bool: ... @abstractmethod def set_debug(self, enabled: bool) -> None: ... if sys.version_info >= (3, 9): @abstractmethod async def shutdown_default_executor(self) -> None: ... class AbstractEventLoopPolicy(metaclass=ABCMeta): @abstractmethod def get_event_loop(self) -> AbstractEventLoop: ... @abstractmethod def set_event_loop(self, loop: Optional[AbstractEventLoop]) -> None: ... @abstractmethod def new_event_loop(self) -> AbstractEventLoop: ... # Child processes handling (Unix only). @abstractmethod def get_child_watcher(self) -> AbstractChildWatcher: ... @abstractmethod def set_child_watcher(self, watcher: AbstractChildWatcher) -> None: ... class BaseDefaultEventLoopPolicy(AbstractEventLoopPolicy, metaclass=ABCMeta): def __init__(self) -> None: ... def get_event_loop(self) -> AbstractEventLoop: ... def set_event_loop(self, loop: Optional[AbstractEventLoop]) -> None: ... def new_event_loop(self) -> AbstractEventLoop: ... def get_event_loop_policy() -> AbstractEventLoopPolicy: ... def set_event_loop_policy(policy: Optional[AbstractEventLoopPolicy]) -> None: ... def get_event_loop() -> AbstractEventLoop: ... def set_event_loop(loop: Optional[AbstractEventLoop]) -> None: ... def new_event_loop() -> AbstractEventLoop: ... def get_child_watcher() -> AbstractChildWatcher: ... def set_child_watcher(watcher: AbstractChildWatcher) -> None: ... def _set_running_loop(__loop: Optional[AbstractEventLoop]) -> None: ... def _get_running_loop() -> AbstractEventLoop: ... if sys.version_info >= (3, 7): def get_running_loop() -> AbstractEventLoop: ... if sys.version_info < (3, 8): class SendfileNotAvailableError(RuntimeError): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/asyncio/exceptions.pyi0000664000175000017500000000106200000000000025464 0ustar00davedave00000000000000import sys from typing import Optional if sys.version_info >= (3, 8): class CancelledError(BaseException): ... class TimeoutError(Exception): ... class InvalidStateError(Exception): ... class SendfileNotAvailableError(RuntimeError): ... class IncompleteReadError(EOFError): expected: Optional[int] partial: bytes def __init__(self, partial: bytes, expected: Optional[int]) -> None: ... class LimitOverrunError(Exception): consumed: int def __init__(self, message: str, consumed: int) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/asyncio/format_helpers.pyi0000664000175000017500000000163100000000000026317 0ustar00davedave00000000000000import functools import sys import traceback from types import FrameType, FunctionType from typing import Any, Dict, Iterable, Optional, Tuple, Union, overload class _HasWrapper: __wrapper__: Union[_HasWrapper, FunctionType] _FuncType = Union[FunctionType, _HasWrapper, functools.partial, functools.partialmethod] if sys.version_info >= (3, 7): @overload def _get_function_source(func: _FuncType) -> Tuple[str, int]: ... @overload def _get_function_source(func: object) -> Optional[Tuple[str, int]]: ... def _format_callback_source(func: object, args: Iterable[Any]) -> str: ... def _format_args_and_kwargs(args: Iterable[Any], kwargs: Dict[str, Any]) -> str: ... def _format_callback(func: object, args: Iterable[Any], kwargs: Dict[str, Any], suffix: str = ...) -> str: ... def extract_stack(f: Optional[FrameType] = ..., limit: Optional[int] = ...) -> traceback.StackSummary: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/asyncio/futures.pyi0000664000175000017500000000502500000000000025003 0ustar00davedave00000000000000import sys from concurrent.futures._base import Error, Future as _ConcurrentFuture from typing import Any, Awaitable, Callable, Generator, Iterable, List, Optional, Tuple, TypeVar, Union from .events import AbstractEventLoop if sys.version_info < (3, 8): from concurrent.futures import CancelledError as CancelledError, TimeoutError as TimeoutError class InvalidStateError(Error): ... if sys.version_info >= (3, 7): from contextvars import Context if sys.version_info >= (3, 9): from types import GenericAlias _T = TypeVar("_T") _S = TypeVar("_S") if sys.version_info < (3, 7): class _TracebackLogger: exc: BaseException tb: List[str] def __init__(self, exc: Any, loop: AbstractEventLoop) -> None: ... def activate(self) -> None: ... def clear(self) -> None: ... def __del__(self) -> None: ... def isfuture(obj: object) -> bool: ... class Future(Awaitable[_T], Iterable[_T]): _state: str _exception: BaseException _blocking = False _log_traceback = False def __init__(self, *, loop: Optional[AbstractEventLoop] = ...) -> None: ... def __repr__(self) -> str: ... def __del__(self) -> None: ... if sys.version_info >= (3, 7): def get_loop(self) -> AbstractEventLoop: ... def _callbacks(self: _S) -> List[Tuple[Callable[[_S], Any], Context]]: ... def add_done_callback(self: _S, __fn: Callable[[_S], Any], *, context: Optional[Context] = ...) -> None: ... else: @property def _callbacks(self: _S) -> List[Callable[[_S], Any]]: ... def add_done_callback(self: _S, __fn: Callable[[_S], Any]) -> None: ... if sys.version_info >= (3, 9): def cancel(self, msg: Optional[str] = ...) -> bool: ... else: def cancel(self) -> bool: ... def cancelled(self) -> bool: ... def done(self) -> bool: ... def result(self) -> _T: ... def exception(self) -> Optional[BaseException]: ... def remove_done_callback(self: _S, __fn: Callable[[_S], Any]) -> int: ... def set_result(self, __result: _T) -> None: ... def set_exception(self, __exception: Union[type, BaseException]) -> None: ... def __iter__(self) -> Generator[Any, None, _T]: ... def __await__(self) -> Generator[Any, None, _T]: ... @property def _loop(self) -> AbstractEventLoop: ... if sys.version_info >= (3, 9): def __class_getitem__(cls, item: Any) -> GenericAlias: ... def wrap_future(future: Union[_ConcurrentFuture[_T], Future[_T]], *, loop: Optional[AbstractEventLoop] = ...) -> Future[_T]: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/asyncio/locks.pyi0000664000175000017500000000536600000000000024431 0ustar00davedave00000000000000import sys from types import TracebackType from typing import Any, Awaitable, Callable, Deque, Generator, Optional, Type, TypeVar, Union from .events import AbstractEventLoop from .futures import Future _T = TypeVar("_T") if sys.version_info >= (3, 9): class _ContextManagerMixin: def __init__(self, lock: Union[Lock, Semaphore]) -> None: ... def __aenter__(self) -> Awaitable[None]: ... def __aexit__( self, exc_type: Optional[Type[BaseException]], exc: Optional[BaseException], tb: Optional[TracebackType] ) -> Awaitable[None]: ... else: class _ContextManager: def __init__(self, lock: Union[Lock, Semaphore]) -> None: ... def __enter__(self) -> object: ... def __exit__(self, *args: Any) -> None: ... class _ContextManagerMixin: def __init__(self, lock: Union[Lock, Semaphore]) -> None: ... # Apparently this exists to *prohibit* use as a context manager. def __enter__(self) -> object: ... def __exit__(self, *args: Any) -> None: ... def __iter__(self) -> Generator[Any, None, _ContextManager]: ... def __await__(self) -> Generator[Any, None, _ContextManager]: ... def __aenter__(self) -> Awaitable[None]: ... def __aexit__( self, exc_type: Optional[Type[BaseException]], exc: Optional[BaseException], tb: Optional[TracebackType] ) -> Awaitable[None]: ... class Lock(_ContextManagerMixin): def __init__(self, *, loop: Optional[AbstractEventLoop] = ...) -> None: ... def locked(self) -> bool: ... async def acquire(self) -> bool: ... def release(self) -> None: ... class Event: def __init__(self, *, loop: Optional[AbstractEventLoop] = ...) -> None: ... def is_set(self) -> bool: ... def set(self) -> None: ... def clear(self) -> None: ... async def wait(self) -> bool: ... class Condition(_ContextManagerMixin): def __init__(self, lock: Optional[Lock] = ..., *, loop: Optional[AbstractEventLoop] = ...) -> None: ... def locked(self) -> bool: ... async def acquire(self) -> bool: ... def release(self) -> None: ... async def wait(self) -> bool: ... async def wait_for(self, predicate: Callable[[], _T]) -> _T: ... def notify(self, n: int = ...) -> None: ... def notify_all(self) -> None: ... class Semaphore(_ContextManagerMixin): _value: int _waiters: Deque[Future[Any]] def __init__(self, value: int = ..., *, loop: Optional[AbstractEventLoop] = ...) -> None: ... def locked(self) -> bool: ... async def acquire(self) -> bool: ... def release(self) -> None: ... def _wake_up_next(self) -> None: ... class BoundedSemaphore(Semaphore): def __init__(self, value: int = ..., *, loop: Optional[AbstractEventLoop] = ...) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/asyncio/log.pyi0000664000175000017500000000004700000000000024066 0ustar00davedave00000000000000import logging logger: logging.Logger ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/asyncio/proactor_events.pyi0000664000175000017500000000533700000000000026531 0ustar00davedave00000000000000from socket import socket from typing import Any, Mapping, Optional from typing_extensions import Literal from . import base_events, constants, events, futures, streams, transports class _ProactorBasePipeTransport(transports._FlowControlMixin, transports.BaseTransport): def __init__( self, loop: events.AbstractEventLoop, sock: socket, protocol: streams.StreamReaderProtocol, waiter: Optional[futures.Future[Any]] = ..., extra: Optional[Mapping[Any, Any]] = ..., server: Optional[events.AbstractServer] = ..., ) -> None: ... def __repr__(self) -> str: ... def __del__(self) -> None: ... def get_write_buffer_size(self) -> int: ... class _ProactorReadPipeTransport(_ProactorBasePipeTransport, transports.ReadTransport): def __init__( self, loop: events.AbstractEventLoop, sock: socket, protocol: streams.StreamReaderProtocol, waiter: Optional[futures.Future[Any]] = ..., extra: Optional[Mapping[Any, Any]] = ..., server: Optional[events.AbstractServer] = ..., ) -> None: ... class _ProactorBaseWritePipeTransport(_ProactorBasePipeTransport, transports.WriteTransport): def __init__( self, loop: events.AbstractEventLoop, sock: socket, protocol: streams.StreamReaderProtocol, waiter: Optional[futures.Future[Any]] = ..., extra: Optional[Mapping[Any, Any]] = ..., server: Optional[events.AbstractServer] = ..., ) -> None: ... class _ProactorWritePipeTransport(_ProactorBaseWritePipeTransport): def __init__( self, loop: events.AbstractEventLoop, sock: socket, protocol: streams.StreamReaderProtocol, waiter: Optional[futures.Future[Any]] = ..., extra: Optional[Mapping[Any, Any]] = ..., server: Optional[events.AbstractServer] = ..., ) -> None: ... class _ProactorDuplexPipeTransport(_ProactorReadPipeTransport, _ProactorBaseWritePipeTransport, transports.Transport): ... class _ProactorSocketTransport(_ProactorReadPipeTransport, _ProactorBaseWritePipeTransport, transports.Transport): _sendfile_compatible: constants._SendfileMode = ... def __init__( self, loop: events.AbstractEventLoop, sock: socket, protocol: streams.StreamReaderProtocol, waiter: Optional[futures.Future[Any]] = ..., extra: Optional[Mapping[Any, Any]] = ..., server: Optional[events.AbstractServer] = ..., ) -> None: ... def _set_extra(self, sock: socket) -> None: ... def can_write_eof(self) -> Literal[True]: ... def write_eof(self) -> None: ... class BaseProactorEventLoop(base_events.BaseEventLoop): def __init__(self, proactor: Any) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/asyncio/protocols.pyi0000664000175000017500000000206000000000000025326 0ustar00davedave00000000000000import sys from asyncio import transports from typing import Optional, Tuple class BaseProtocol: def connection_made(self, transport: transports.BaseTransport) -> None: ... def connection_lost(self, exc: Optional[Exception]) -> None: ... def pause_writing(self) -> None: ... def resume_writing(self) -> None: ... class Protocol(BaseProtocol): def data_received(self, data: bytes) -> None: ... def eof_received(self) -> Optional[bool]: ... if sys.version_info >= (3, 7): class BufferedProtocol(BaseProtocol): def get_buffer(self, sizehint: int) -> bytearray: ... def buffer_updated(self, nbytes: int) -> None: ... class DatagramProtocol(BaseProtocol): def datagram_received(self, data: bytes, addr: Tuple[str, int]) -> None: ... def error_received(self, exc: Exception) -> None: ... class SubprocessProtocol(BaseProtocol): def pipe_data_received(self, fd: int, data: bytes) -> None: ... def pipe_connection_lost(self, fd: int, exc: Optional[Exception]) -> None: ... def process_exited(self) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/asyncio/queues.pyi0000664000175000017500000000221600000000000024614 0ustar00davedave00000000000000import sys from asyncio.events import AbstractEventLoop from typing import Any, Generic, Optional, TypeVar if sys.version_info >= (3, 9): from types import GenericAlias class QueueEmpty(Exception): ... class QueueFull(Exception): ... _T = TypeVar("_T") class Queue(Generic[_T]): def __init__(self, maxsize: int = ..., *, loop: Optional[AbstractEventLoop] = ...) -> None: ... def _init(self, maxsize: int) -> None: ... def _get(self) -> _T: ... def _put(self, item: _T) -> None: ... def __repr__(self) -> str: ... def __str__(self) -> str: ... def _format(self) -> str: ... def qsize(self) -> int: ... @property def maxsize(self) -> int: ... def empty(self) -> bool: ... def full(self) -> bool: ... async def put(self, item: _T) -> None: ... def put_nowait(self, item: _T) -> None: ... async def get(self) -> _T: ... def get_nowait(self) -> _T: ... async def join(self) -> None: ... def task_done(self) -> None: ... if sys.version_info >= (3, 9): def __class_getitem__(cls, type: Any) -> GenericAlias: ... class PriorityQueue(Queue[_T]): ... class LifoQueue(Queue[_T]): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/asyncio/runners.pyi0000664000175000017500000000047200000000000025003 0ustar00davedave00000000000000import sys if sys.version_info >= (3, 7): from typing import Awaitable, Optional, TypeVar _T = TypeVar("_T") if sys.version_info >= (3, 8): def run(main: Awaitable[_T], *, debug: Optional[bool] = ...) -> _T: ... else: def run(main: Awaitable[_T], *, debug: bool = ...) -> _T: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/asyncio/selector_events.pyi0000664000175000017500000000032700000000000026512 0ustar00davedave00000000000000import selectors from typing import Optional from . import base_events class BaseSelectorEventLoop(base_events.BaseEventLoop): def __init__(self, selector: Optional[selectors.BaseSelector] = ...) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/asyncio/sslproto.pyi0000664000175000017500000001244700000000000025201 0ustar00davedave00000000000000import ssl import sys from typing import Any, Callable, ClassVar, Deque, Dict, List, Optional, Tuple from typing_extensions import Literal from . import constants, events, futures, protocols, transports def _create_transport_context(server_side: bool, server_hostname: Optional[str]) -> ssl.SSLContext: ... _UNWRAPPED: Literal["UNWRAPPED"] _DO_HANDSHAKE: Literal["DO_HANDSHAKE"] _WRAPPED: Literal["WRAPPED"] _SHUTDOWN: Literal["SHUTDOWN"] class _SSLPipe: max_size: ClassVar[int] _context: ssl.SSLContext _server_side: bool _server_hostname: Optional[str] _state: str _incoming: ssl.MemoryBIO _outgoing: ssl.MemoryBIO _sslobj: Optional[ssl.SSLObject] _need_ssldata: bool _handshake_cb: Optional[Callable[[Optional[BaseException]], None]] _shutdown_cb: Optional[Callable[[], None]] def __init__(self, context: ssl.SSLContext, server_side: bool, server_hostname: Optional[str] = ...) -> None: ... @property def context(self) -> ssl.SSLContext: ... @property def ssl_object(self) -> Optional[ssl.SSLObject]: ... @property def need_ssldata(self) -> bool: ... @property def wrapped(self) -> bool: ... def do_handshake(self, callback: Optional[Callable[[Optional[BaseException]], None]] = ...) -> List[bytes]: ... def shutdown(self, callback: Optional[Callable[[], None]] = ...) -> List[bytes]: ... def feed_eof(self) -> None: ... def feed_ssldata(self, data: bytes, only_handshake: bool = ...) -> Tuple[List[bytes], List[bytes]]: ... def feed_appdata(self, data: bytes, offset: int = ...) -> Tuple[List[bytes], int]: ... class _SSLProtocolTransport(transports._FlowControlMixin, transports.Transport): _sendfile_compatible: ClassVar[constants._SendfileMode] _loop: events.AbstractEventLoop _ssl_protocol: SSLProtocol _closed: bool def __init__(self, loop: events.AbstractEventLoop, ssl_protocol: SSLProtocol) -> None: ... def get_extra_info(self, name: str, default: Optional[Any] = ...) -> Dict[str, Any]: ... def set_protocol(self, protocol: protocols.BaseProtocol) -> None: ... def get_protocol(self) -> protocols.BaseProtocol: ... def is_closing(self) -> bool: ... def close(self) -> None: ... if sys.version_info >= (3, 7): def is_reading(self) -> bool: ... def pause_reading(self) -> None: ... def resume_reading(self) -> None: ... def set_write_buffer_limits(self, high: Optional[int] = ..., low: Optional[int] = ...) -> None: ... def get_write_buffer_size(self) -> int: ... if sys.version_info >= (3, 7): @property def _protocol_paused(self) -> bool: ... def write(self, data: bytes) -> None: ... def can_write_eof(self) -> Literal[False]: ... def abort(self) -> None: ... class SSLProtocol(protocols.Protocol): _server_side: bool _server_hostname: Optional[str] _sslcontext: ssl.SSLContext _extra: Dict[str, Any] _write_backlog: Deque[Tuple[bytes, int]] _write_buffer_size: int _waiter: futures.Future[Any] _loop: events.AbstractEventLoop _app_transport: _SSLProtocolTransport _sslpipe: Optional[_SSLPipe] _session_established: bool _in_handshake: bool _in_shutdown: bool _transport: Optional[transports.BaseTransport] _call_connection_made: bool _ssl_handshake_timeout: Optional[int] _app_protocol: protocols.BaseProtocol _app_protocol_is_buffer: bool if sys.version_info >= (3, 7): def __init__( self, loop: events.AbstractEventLoop, app_protocol: protocols.BaseProtocol, sslcontext: ssl.SSLContext, waiter: futures.Future[Any], server_side: bool = ..., server_hostname: Optional[str] = ..., call_connection_made: bool = ..., ssl_handshake_timeout: Optional[int] = ..., ) -> None: ... else: def __init__( self, loop: events.AbstractEventLoop, app_protocol: protocols.BaseProtocol, sslcontext: ssl.SSLContext, waiter: futures.Future, server_side: bool = ..., server_hostname: Optional[str] = ..., call_connection_made: bool = ..., ) -> None: ... if sys.version_info >= (3, 7): def _set_app_protocol(self, app_protocol: protocols.BaseProtocol) -> None: ... def _wakeup_waiter(self, exc: Optional[BaseException] = ...) -> None: ... def connection_made(self, transport: transports.BaseTransport) -> None: ... def connection_lost(self, exc: Optional[BaseException]) -> None: ... def pause_writing(self) -> None: ... def resume_writing(self) -> None: ... def data_received(self, data: bytes) -> None: ... def eof_received(self) -> None: ... def _get_extra_info(self, name: str, default: Optional[Any] = ...) -> Any: ... def _start_shutdown(self) -> None: ... def _write_appdata(self, data: bytes) -> None: ... def _start_handshake(self) -> None: ... if sys.version_info >= (3, 7): def _check_handshake_timeout(self) -> None: ... def _on_handshake_complete(self, handshake_exc: Optional[BaseException]) -> None: ... def _process_write_backlog(self) -> None: ... def _fatal_error(self, exc: BaseException, message: str = ...) -> None: ... def _finalize(self) -> None: ... def _abort(self) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/asyncio/staggered.pyi0000664000175000017500000000061400000000000025252 0ustar00davedave00000000000000import sys from typing import Any, Awaitable, Callable, Iterable, List, Optional, Tuple from . import events if sys.version_info >= (3, 8): async def staggered_race( coro_fns: Iterable[Callable[[], Awaitable[Any]]], delay: Optional[float], *, loop: Optional[events.AbstractEventLoop] = ..., ) -> Tuple[Any, Optional[int], List[Optional[Exception]]]: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/asyncio/streams.pyi0000664000175000017500000000754500000000000024775 0ustar00davedave00000000000000import sys from typing import Any, AsyncIterator, Awaitable, Callable, Iterable, Optional, Tuple, Union from . import events, protocols, transports _ClientConnectedCallback = Callable[[StreamReader, StreamWriter], Optional[Awaitable[None]]] if sys.version_info < (3, 8): class IncompleteReadError(EOFError): expected: Optional[int] partial: bytes def __init__(self, partial: bytes, expected: Optional[int]) -> None: ... class LimitOverrunError(Exception): consumed: int def __init__(self, message: str, consumed: int) -> None: ... async def open_connection( host: Optional[str] = ..., port: Optional[Union[int, str]] = ..., *, loop: Optional[events.AbstractEventLoop] = ..., limit: int = ..., ssl_handshake_timeout: Optional[float] = ..., **kwds: Any, ) -> Tuple[StreamReader, StreamWriter]: ... async def start_server( client_connected_cb: _ClientConnectedCallback, host: Optional[str] = ..., port: Optional[Union[int, str]] = ..., *, loop: Optional[events.AbstractEventLoop] = ..., limit: int = ..., ssl_handshake_timeout: Optional[float] = ..., **kwds: Any, ) -> events.AbstractServer: ... if sys.platform != "win32": if sys.version_info >= (3, 7): from os import PathLike _PathType = Union[str, PathLike[str]] else: _PathType = str async def open_unix_connection( path: Optional[_PathType] = ..., *, loop: Optional[events.AbstractEventLoop] = ..., limit: int = ..., **kwds: Any ) -> Tuple[StreamReader, StreamWriter]: ... async def start_unix_server( client_connected_cb: _ClientConnectedCallback, path: Optional[_PathType] = ..., *, loop: Optional[events.AbstractEventLoop] = ..., limit: int = ..., **kwds: Any, ) -> events.AbstractServer: ... class FlowControlMixin(protocols.Protocol): ... class StreamReaderProtocol(FlowControlMixin, protocols.Protocol): def __init__( self, stream_reader: StreamReader, client_connected_cb: Optional[_ClientConnectedCallback] = ..., loop: Optional[events.AbstractEventLoop] = ..., ) -> None: ... def connection_made(self, transport: transports.BaseTransport) -> None: ... def connection_lost(self, exc: Optional[Exception]) -> None: ... def data_received(self, data: bytes) -> None: ... def eof_received(self) -> bool: ... class StreamWriter: def __init__( self, transport: transports.BaseTransport, protocol: protocols.BaseProtocol, reader: Optional[StreamReader], loop: events.AbstractEventLoop, ) -> None: ... @property def transport(self) -> transports.BaseTransport: ... def write(self, data: bytes) -> None: ... def writelines(self, data: Iterable[bytes]) -> None: ... def write_eof(self) -> None: ... def can_write_eof(self) -> bool: ... def close(self) -> None: ... if sys.version_info >= (3, 7): def is_closing(self) -> bool: ... async def wait_closed(self) -> None: ... def get_extra_info(self, name: str, default: Any = ...) -> Any: ... async def drain(self) -> None: ... class StreamReader: def __init__(self, limit: int = ..., loop: Optional[events.AbstractEventLoop] = ...) -> None: ... def exception(self) -> Exception: ... def set_exception(self, exc: Exception) -> None: ... def set_transport(self, transport: transports.BaseTransport) -> None: ... def feed_eof(self) -> None: ... def at_eof(self) -> bool: ... def feed_data(self, data: bytes) -> None: ... async def readline(self) -> bytes: ... async def readuntil(self, separator: bytes = ...) -> bytes: ... async def read(self, n: int = ...) -> bytes: ... async def readexactly(self, n: int) -> bytes: ... def __aiter__(self) -> AsyncIterator[bytes]: ... async def __anext__(self) -> bytes: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/asyncio/subprocess.pyi0000664000175000017500000000433100000000000025475 0ustar00davedave00000000000000import sys from asyncio import events, protocols, streams, transports from typing import IO, Any, Optional, Tuple, Union if sys.version_info >= (3, 8): from os import PathLike _ExecArg = Union[str, bytes, PathLike[str], PathLike[bytes]] else: _ExecArg = Union[str, bytes] # Union used instead of AnyStr due to mypy issue #1236 PIPE: int STDOUT: int DEVNULL: int class SubprocessStreamProtocol(streams.FlowControlMixin, protocols.SubprocessProtocol): stdin: Optional[streams.StreamWriter] stdout: Optional[streams.StreamReader] stderr: Optional[streams.StreamReader] def __init__(self, limit: int, loop: events.AbstractEventLoop) -> None: ... def connection_made(self, transport: transports.BaseTransport) -> None: ... def pipe_data_received(self, fd: int, data: Union[bytes, str]) -> None: ... def pipe_connection_lost(self, fd: int, exc: Optional[Exception]) -> None: ... def process_exited(self) -> None: ... class Process: stdin: Optional[streams.StreamWriter] stdout: Optional[streams.StreamReader] stderr: Optional[streams.StreamReader] pid: int def __init__( self, transport: transports.BaseTransport, protocol: protocols.BaseProtocol, loop: events.AbstractEventLoop ) -> None: ... @property def returncode(self) -> Optional[int]: ... async def wait(self) -> int: ... def send_signal(self, signal: int) -> None: ... def terminate(self) -> None: ... def kill(self) -> None: ... async def communicate(self, input: Optional[bytes] = ...) -> Tuple[bytes, bytes]: ... async def create_subprocess_shell( cmd: Union[str, bytes], # Union used instead of AnyStr due to mypy issue #1236 stdin: Union[int, IO[Any], None] = ..., stdout: Union[int, IO[Any], None] = ..., stderr: Union[int, IO[Any], None] = ..., loop: Optional[events.AbstractEventLoop] = ..., limit: int = ..., **kwds: Any, ) -> Process: ... async def create_subprocess_exec( program: _ExecArg, *args: _ExecArg, stdin: Union[int, IO[Any], None] = ..., stdout: Union[int, IO[Any], None] = ..., stderr: Union[int, IO[Any], None] = ..., loop: Optional[events.AbstractEventLoop] = ..., limit: int = ..., **kwds: Any, ) -> Process: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/asyncio/tasks.pyi0000664000175000017500000001576100000000000024443 0ustar00davedave00000000000000import concurrent.futures import sys from types import FrameType from typing import ( Any, Awaitable, Generator, Generic, Iterable, Iterator, List, Optional, Set, TextIO, Tuple, TypeVar, Union, overload, ) from typing_extensions import Literal from .events import AbstractEventLoop from .futures import Future if sys.version_info >= (3, 9): from types import GenericAlias _T = TypeVar("_T") _T1 = TypeVar("_T1") _T2 = TypeVar("_T2") _T3 = TypeVar("_T3") _T4 = TypeVar("_T4") _T5 = TypeVar("_T5") _FutureT = Union[Future[_T], Generator[Any, None, _T], Awaitable[_T]] FIRST_EXCEPTION: str FIRST_COMPLETED: str ALL_COMPLETED: str def as_completed( fs: Iterable[_FutureT[_T]], *, loop: Optional[AbstractEventLoop] = ..., timeout: Optional[float] = ... ) -> Iterator[Future[_T]]: ... def ensure_future(coro_or_future: _FutureT[_T], *, loop: Optional[AbstractEventLoop] = ...) -> Future[_T]: ... # Prior to Python 3.7 'async' was an alias for 'ensure_future'. # It became a keyword in 3.7. # `gather()` actually returns a list with length equal to the number # of tasks passed; however, Tuple is used similar to the annotation for # zip() because typing does not support variadic type variables. See # typing PR #1550 for discussion. @overload def gather( coro_or_future1: _FutureT[_T1], *, loop: Optional[AbstractEventLoop] = ..., return_exceptions: Literal[False] = ... ) -> Future[Tuple[_T1]]: ... @overload def gather( coro_or_future1: _FutureT[_T1], coro_or_future2: _FutureT[_T2], *, loop: Optional[AbstractEventLoop] = ..., return_exceptions: Literal[False] = ..., ) -> Future[Tuple[_T1, _T2]]: ... @overload def gather( coro_or_future1: _FutureT[_T1], coro_or_future2: _FutureT[_T2], coro_or_future3: _FutureT[_T3], *, loop: Optional[AbstractEventLoop] = ..., return_exceptions: Literal[False] = ..., ) -> Future[Tuple[_T1, _T2, _T3]]: ... @overload def gather( coro_or_future1: _FutureT[_T1], coro_or_future2: _FutureT[_T2], coro_or_future3: _FutureT[_T3], coro_or_future4: _FutureT[_T4], *, loop: Optional[AbstractEventLoop] = ..., return_exceptions: Literal[False] = ..., ) -> Future[Tuple[_T1, _T2, _T3, _T4]]: ... @overload def gather( coro_or_future1: _FutureT[_T1], coro_or_future2: _FutureT[_T2], coro_or_future3: _FutureT[_T3], coro_or_future4: _FutureT[_T4], coro_or_future5: _FutureT[_T5], *, loop: Optional[AbstractEventLoop] = ..., return_exceptions: Literal[False] = ..., ) -> Future[Tuple[_T1, _T2, _T3, _T4, _T5]]: ... @overload def gather( coro_or_future1: _FutureT[Any], coro_or_future2: _FutureT[Any], coro_or_future3: _FutureT[Any], coro_or_future4: _FutureT[Any], coro_or_future5: _FutureT[Any], coro_or_future6: _FutureT[Any], *coros_or_futures: _FutureT[Any], loop: Optional[AbstractEventLoop] = ..., return_exceptions: bool = ..., ) -> Future[List[Any]]: ... @overload def gather( coro_or_future1: _FutureT[_T1], *, loop: Optional[AbstractEventLoop] = ..., return_exceptions: bool = ... ) -> Future[Tuple[Union[_T1, BaseException]]]: ... @overload def gather( coro_or_future1: _FutureT[_T1], coro_or_future2: _FutureT[_T2], *, loop: Optional[AbstractEventLoop] = ..., return_exceptions: bool = ..., ) -> Future[Tuple[Union[_T1, BaseException], Union[_T2, BaseException]]]: ... @overload def gather( coro_or_future1: _FutureT[_T1], coro_or_future2: _FutureT[_T2], coro_or_future3: _FutureT[_T3], *, loop: Optional[AbstractEventLoop] = ..., return_exceptions: bool = ..., ) -> Future[Tuple[Union[_T1, BaseException], Union[_T2, BaseException], Union[_T3, BaseException]]]: ... @overload def gather( coro_or_future1: _FutureT[_T1], coro_or_future2: _FutureT[_T2], coro_or_future3: _FutureT[_T3], coro_or_future4: _FutureT[_T4], *, loop: Optional[AbstractEventLoop] = ..., return_exceptions: bool = ..., ) -> Future[ Tuple[Union[_T1, BaseException], Union[_T2, BaseException], Union[_T3, BaseException], Union[_T4, BaseException]] ]: ... @overload def gather( coro_or_future1: _FutureT[_T1], coro_or_future2: _FutureT[_T2], coro_or_future3: _FutureT[_T3], coro_or_future4: _FutureT[_T4], coro_or_future5: _FutureT[_T5], *, loop: Optional[AbstractEventLoop] = ..., return_exceptions: bool = ..., ) -> Future[ Tuple[ Union[_T1, BaseException], Union[_T2, BaseException], Union[_T3, BaseException], Union[_T4, BaseException], Union[_T5, BaseException], ] ]: ... def run_coroutine_threadsafe(coro: _FutureT[_T], loop: AbstractEventLoop) -> concurrent.futures.Future[_T]: ... def shield(arg: _FutureT[_T], *, loop: Optional[AbstractEventLoop] = ...) -> Future[_T]: ... def sleep(delay: float, result: _T = ..., *, loop: Optional[AbstractEventLoop] = ...) -> Future[_T]: ... def wait( fs: Iterable[_FutureT[_T]], *, loop: Optional[AbstractEventLoop] = ..., timeout: Optional[float] = ..., return_when: str = ... ) -> Future[Tuple[Set[Future[_T]], Set[Future[_T]]]]: ... def wait_for(fut: _FutureT[_T], timeout: Optional[float], *, loop: Optional[AbstractEventLoop] = ...) -> Future[_T]: ... class Task(Future[_T], Generic[_T]): if sys.version_info >= (3, 8): def __init__( self, coro: Union[Generator[Any, None, _T], Awaitable[_T]], *, loop: AbstractEventLoop = ..., name: Optional[str] = ..., ) -> None: ... else: def __init__(self, coro: Union[Generator[Any, None, _T], Awaitable[_T]], *, loop: AbstractEventLoop = ...) -> None: ... def __repr__(self) -> str: ... if sys.version_info >= (3, 8): def get_coro(self) -> Any: ... def get_name(self) -> str: ... def set_name(self, __value: object) -> None: ... def get_stack(self, *, limit: int = ...) -> List[FrameType]: ... def print_stack(self, *, limit: int = ..., file: TextIO = ...) -> None: ... if sys.version_info >= (3, 9): def cancel(self, msg: Optional[str] = ...) -> bool: ... else: def cancel(self) -> bool: ... if sys.version_info < (3, 9): @classmethod def current_task(cls, loop: Optional[AbstractEventLoop] = ...) -> Optional[Task[Any]]: ... @classmethod def all_tasks(cls, loop: Optional[AbstractEventLoop] = ...) -> Set[Task[Any]]: ... if sys.version_info < (3, 7): def _wakeup(self, fut: Future[Any]) -> None: ... if sys.version_info >= (3, 9): def __class_getitem__(cls, item: Any) -> GenericAlias: ... if sys.version_info >= (3, 7): def all_tasks(loop: Optional[AbstractEventLoop] = ...) -> Set[Task[Any]]: ... if sys.version_info >= (3, 8): def create_task(coro: Union[Generator[Any, None, _T], Awaitable[_T]], *, name: Optional[str] = ...) -> Task[_T]: ... else: def create_task(coro: Union[Generator[Any, None, _T], Awaitable[_T]]) -> Task[_T]: ... def current_task(loop: Optional[AbstractEventLoop] = ...) -> Optional[Task[Any]]: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/asyncio/threads.pyi0000664000175000017500000000030200000000000024731 0ustar00davedave00000000000000import sys from typing import Any, Callable, TypeVar _T = TypeVar("_T") if sys.version_info >= (3, 9): async def to_thread(__func: Callable[..., _T], *args: Any, **kwargs: Any) -> _T: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/asyncio/transports.pyi0000664000175000017500000000353600000000000025532 0ustar00davedave00000000000000import sys from asyncio.events import AbstractEventLoop from asyncio.protocols import BaseProtocol from socket import _Address from typing import Any, List, Mapping, Optional, Tuple class BaseTransport: def __init__(self, extra: Optional[Mapping[Any, Any]] = ...) -> None: ... def get_extra_info(self, name: Any, default: Any = ...) -> Any: ... def is_closing(self) -> bool: ... def close(self) -> None: ... def set_protocol(self, protocol: BaseProtocol) -> None: ... def get_protocol(self) -> BaseProtocol: ... class ReadTransport(BaseTransport): if sys.version_info >= (3, 7): def is_reading(self) -> bool: ... def pause_reading(self) -> None: ... def resume_reading(self) -> None: ... class WriteTransport(BaseTransport): def set_write_buffer_limits(self, high: Optional[int] = ..., low: Optional[int] = ...) -> None: ... def get_write_buffer_size(self) -> int: ... def write(self, data: Any) -> None: ... def writelines(self, list_of_data: List[Any]) -> None: ... def write_eof(self) -> None: ... def can_write_eof(self) -> bool: ... def abort(self) -> None: ... class Transport(ReadTransport, WriteTransport): ... class DatagramTransport(BaseTransport): def sendto(self, data: Any, addr: Optional[_Address] = ...) -> None: ... def abort(self) -> None: ... class SubprocessTransport(BaseTransport): def get_pid(self) -> int: ... def get_returncode(self) -> Optional[int]: ... def get_pipe_transport(self, fd: int) -> Optional[BaseTransport]: ... def send_signal(self, signal: int) -> int: ... def terminate(self) -> None: ... def kill(self) -> None: ... class _FlowControlMixin(Transport): def __init__(self, extra: Optional[Mapping[Any, Any]] = ..., loop: Optional[AbstractEventLoop] = ...) -> None: ... def get_write_buffer_limits(self) -> Tuple[int, int]: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/asyncio/trsock.pyi0000664000175000017500000001074600000000000024621 0ustar00davedave00000000000000import socket import sys from types import TracebackType from typing import Any, BinaryIO, Iterable, List, NoReturn, Optional, Tuple, Type, Union, overload if sys.version_info >= (3, 8): # These are based in socket, maybe move them out into _typeshed.pyi or such _Address = Union[tuple, str] _RetAddress = Any _WriteBuffer = Union[bytearray, memoryview] _CMSG = Tuple[int, int, bytes] class TransportSocket: def __init__(self, sock: socket.socket) -> None: ... def _na(self, what: str) -> None: ... @property def family(self) -> int: ... @property def type(self) -> int: ... @property def proto(self) -> int: ... def __getstate__(self) -> NoReturn: ... def fileno(self) -> int: ... def dup(self) -> socket.socket: ... def get_inheritable(self) -> bool: ... def shutdown(self, how: int) -> None: ... @overload def getsockopt(self, level: int, optname: int) -> int: ... @overload def getsockopt(self, level: int, optname: int, buflen: int) -> bytes: ... @overload def setsockopt(self, level: int, optname: int, value: Union[int, bytes]) -> None: ... @overload def setsockopt(self, level: int, optname: int, value: None, optlen: int) -> None: ... def getpeername(self) -> _RetAddress: ... def getsockname(self) -> _RetAddress: ... def getsockbyname(self) -> NoReturn: ... # This method doesn't exist on socket, yet is passed through? def accept(self) -> Tuple[socket.socket, _RetAddress]: ... def connect(self, address: Union[_Address, bytes]) -> None: ... def connect_ex(self, address: Union[_Address, bytes]) -> int: ... def bind(self, address: Union[_Address, bytes]) -> None: ... if sys.platform == "win32": def ioctl(self, control: int, option: Union[int, Tuple[int, int, int], bool]) -> None: ... else: def ioctl(self, control: int, option: Union[int, Tuple[int, int, int], bool]) -> NoReturn: ... def listen(self, __backlog: int = ...) -> None: ... def makefile(self) -> BinaryIO: ... def sendfile(self, file: BinaryIO, offset: int = ..., count: Optional[int] = ...) -> int: ... def close(self) -> None: ... def detach(self) -> int: ... if sys.platform == "linux": def sendmsg_afalg( self, msg: Iterable[bytes] = ..., *, op: int, iv: Any = ..., assoclen: int = ..., flags: int = ... ) -> int: ... else: def sendmsg_afalg( self, msg: Iterable[bytes] = ..., *, op: int, iv: Any = ..., assoclen: int = ..., flags: int = ... ) -> NoReturn: ... def sendmsg( self, __buffers: Iterable[bytes], __ancdata: Iterable[_CMSG] = ..., __flags: int = ..., __address: _Address = ... ) -> int: ... @overload def sendto(self, data: bytes, address: _Address) -> int: ... @overload def sendto(self, data: bytes, flags: int, address: _Address) -> int: ... def send(self, data: bytes, flags: int = ...) -> int: ... def sendall(self, data: bytes, flags: int = ...) -> None: ... def set_inheritable(self, inheritable: bool) -> None: ... if sys.platform == "win32": def share(self, process_id: int) -> bytes: ... else: def share(self, process_id: int) -> NoReturn: ... def recv_into(self, buffer: _WriteBuffer, nbytes: int = ..., flags: int = ...) -> int: ... def recvfrom_into(self, buffer: _WriteBuffer, nbytes: int = ..., flags: int = ...) -> Tuple[int, _RetAddress]: ... def recvmsg_into( self, __buffers: Iterable[_WriteBuffer], __ancbufsize: int = ..., __flags: int = ... ) -> Tuple[int, List[_CMSG], int, Any]: ... def recvmsg(self, __bufsize: int, __ancbufsize: int = ..., __flags: int = ...) -> Tuple[bytes, List[_CMSG], int, Any]: ... def recvfrom(self, bufsize: int, flags: int = ...) -> Tuple[bytes, _RetAddress]: ... def recv(self, bufsize: int, flags: int = ...) -> bytes: ... def settimeout(self, value: Optional[float]) -> None: ... def gettimeout(self) -> Optional[float]: ... def setblocking(self, flag: bool) -> None: ... def __enter__(self) -> socket.socket: ... def __exit__( self, exc_type: Optional[Type[BaseException]], exc_val: Optional[BaseException], exc_tb: Optional[TracebackType] ) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/asyncio/unix_events.pyi0000664000175000017500000000414000000000000025652 0ustar00davedave00000000000000import sys import types from typing import Any, Callable, Optional, Type, TypeVar from .events import AbstractEventLoop, BaseDefaultEventLoopPolicy from .selector_events import BaseSelectorEventLoop _T1 = TypeVar("_T1", bound=AbstractChildWatcher) _T2 = TypeVar("_T2", bound=SafeChildWatcher) _T3 = TypeVar("_T3", bound=FastChildWatcher) class AbstractChildWatcher: def add_child_handler(self, pid: int, callback: Callable[..., Any], *args: Any) -> None: ... def remove_child_handler(self, pid: int) -> bool: ... def attach_loop(self, loop: Optional[AbstractEventLoop]) -> None: ... def close(self) -> None: ... def __enter__(self: _T1) -> _T1: ... def __exit__( self, typ: Optional[Type[BaseException]], exc: Optional[BaseException], tb: Optional[types.TracebackType] ) -> None: ... if sys.version_info >= (3, 8): def is_active(self) -> bool: ... class BaseChildWatcher(AbstractChildWatcher): def __init__(self) -> None: ... class SafeChildWatcher(BaseChildWatcher): def __enter__(self: _T2) -> _T2: ... class FastChildWatcher(BaseChildWatcher): def __enter__(self: _T3) -> _T3: ... class _UnixSelectorEventLoop(BaseSelectorEventLoop): ... class _UnixDefaultEventLoopPolicy(BaseDefaultEventLoopPolicy): def get_child_watcher(self) -> AbstractChildWatcher: ... def set_child_watcher(self, watcher: Optional[AbstractChildWatcher]) -> None: ... SelectorEventLoop = _UnixSelectorEventLoop DefaultEventLoopPolicy = _UnixDefaultEventLoopPolicy if sys.version_info >= (3, 8): from typing import Protocol _T4 = TypeVar("_T4", bound=MultiLoopChildWatcher) _T5 = TypeVar("_T5", bound=ThreadedChildWatcher) class _Warn(Protocol): def __call__( self, message: str, category: Optional[Type[Warning]] = ..., stacklevel: int = ..., source: Optional[Any] = ... ) -> None: ... class MultiLoopChildWatcher(AbstractChildWatcher): def __enter__(self: _T4) -> _T4: ... class ThreadedChildWatcher(AbstractChildWatcher): def __enter__(self: _T5) -> _T5: ... def __del__(self, _warn: _Warn = ...) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/asyncio/windows_events.pyi0000664000175000017500000000674200000000000026373 0ustar00davedave00000000000000import socket import sys from typing import IO, Any, Callable, ClassVar, List, NoReturn, Optional, Tuple, Type from . import events, futures, proactor_events, selector_events, streams, windows_utils __all__ = [ "SelectorEventLoop", "ProactorEventLoop", "IocpProactor", "DefaultEventLoopPolicy", "WindowsSelectorEventLoopPolicy", "WindowsProactorEventLoopPolicy", ] NULL: int INFINITE: int ERROR_CONNECTION_REFUSED: int ERROR_CONNECTION_ABORTED: int CONNECT_PIPE_INIT_DELAY: float CONNECT_PIPE_MAX_DELAY: float class PipeServer: def __init__(self, address: str) -> None: ... def __del__(self) -> None: ... def closed(self) -> bool: ... def close(self) -> None: ... class _WindowsSelectorEventLoop(selector_events.BaseSelectorEventLoop): ... class ProactorEventLoop(proactor_events.BaseProactorEventLoop): def __init__(self, proactor: Optional[IocpProactor] = ...) -> None: ... async def create_pipe_connection( self, protocol_factory: Callable[[], streams.StreamReaderProtocol], address: str ) -> Tuple[proactor_events._ProactorDuplexPipeTransport, streams.StreamReaderProtocol]: ... async def start_serving_pipe( self, protocol_factory: Callable[[], streams.StreamReaderProtocol], address: str ) -> List[PipeServer]: ... class IocpProactor: def __init__(self, concurrency: int = ...) -> None: ... def __repr__(self) -> str: ... def __del__(self) -> None: ... def set_loop(self, loop: events.AbstractEventLoop) -> None: ... def select(self, timeout: Optional[int] = ...) -> List[futures.Future[Any]]: ... def recv(self, conn: socket.socket, nbytes: int, flags: int = ...) -> futures.Future[bytes]: ... if sys.version_info >= (3, 7): def recv_into(self, conn: socket.socket, buf: socket._WriteBuffer, flags: int = ...) -> futures.Future[Any]: ... def send(self, conn: socket.socket, buf: socket._WriteBuffer, flags: int = ...) -> futures.Future[Any]: ... def accept(self, listener: socket.socket) -> futures.Future[Any]: ... def connect(self, conn: socket.socket, address: bytes) -> futures.Future[Any]: ... if sys.version_info >= (3, 7): def sendfile(self, sock: socket.socket, file: IO[bytes], offset: int, count: int) -> futures.Future[Any]: ... def accept_pipe(self, pipe: socket.socket) -> futures.Future[Any]: ... async def connect_pipe(self, address: bytes) -> windows_utils.PipeHandle: ... def wait_for_handle(self, handle: windows_utils.PipeHandle, timeout: Optional[int] = ...) -> bool: ... def close(self) -> None: ... SelectorEventLoop = _WindowsSelectorEventLoop if sys.version_info >= (3, 7): class WindowsSelectorEventLoopPolicy(events.BaseDefaultEventLoopPolicy): _loop_factory: ClassVar[Type[SelectorEventLoop]] def get_child_watcher(self) -> NoReturn: ... def set_child_watcher(self, watcher: Any) -> NoReturn: ... class WindowsProactorEventLoopPolicy(events.BaseDefaultEventLoopPolicy): _loop_factory: ClassVar[Type[ProactorEventLoop]] def get_child_watcher(self) -> NoReturn: ... def set_child_watcher(self, watcher: Any) -> NoReturn: ... DefaultEventLoopPolicy = WindowsSelectorEventLoopPolicy else: class _WindowsDefaultEventLoopPolicy(events.BaseDefaultEventLoopPolicy): _loop_factory: ClassVar[Type[SelectorEventLoop]] def get_child_watcher(self) -> NoReturn: ... def set_child_watcher(self, watcher: Any) -> NoReturn: ... DefaultEventLoopPolicy = _WindowsDefaultEventLoopPolicy ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/asyncio/windows_utils.pyi0000664000175000017500000000172700000000000026225 0ustar00davedave00000000000000import sys from types import TracebackType from typing import Callable, Optional, Protocol, Tuple, Type class _WarnFunction(Protocol): def __call__(self, message: str, category: Type[Warning] = ..., stacklevel: int = ..., source: PipeHandle = ...) -> None: ... BUFSIZE: int PIPE: int STDOUT: int def pipe(*, duplex: bool = ..., overlapped: Tuple[bool, bool] = ..., bufsize: int = ...) -> Tuple[int, int]: ... class PipeHandle: def __init__(self, handle: int) -> None: ... def __repr__(self) -> str: ... if sys.version_info >= (3, 8): def __del__(self, _warn: _WarnFunction = ...) -> None: ... else: def __del__(self) -> None: ... def __enter__(self) -> PipeHandle: ... def __exit__(self, t: Optional[type], v: Optional[BaseException], tb: Optional[TracebackType]) -> None: ... @property def handle(self) -> int: ... def fileno(self) -> int: ... def close(self, *, CloseHandle: Callable[[int], None] = ...) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/atexit.pyi0000664000175000017500000000041700000000000023137 0ustar00davedave00000000000000from typing import Any, Callable def _clear() -> None: ... def _ncallbacks() -> int: ... def _run_exitfuncs() -> None: ... def register(func: Callable[..., Any], *args: Any, **kwargs: Any) -> Callable[..., Any]: ... def unregister(func: Callable[..., Any]) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/builtins.pyi0000664000175000017500000015237400000000000023504 0ustar00davedave00000000000000import sys from _typeshed import ( AnyPath, OpenBinaryMode, OpenBinaryModeReading, OpenBinaryModeUpdating, OpenBinaryModeWriting, OpenTextMode, ReadableBuffer, SupportsKeysAndGetItem, SupportsLessThan, SupportsLessThanT, SupportsWrite, ) from ast import AST, mod from io import BufferedRandom, BufferedReader, BufferedWriter, FileIO, TextIOWrapper from types import CodeType, TracebackType from typing import ( IO, AbstractSet, Any, BinaryIO, ByteString, Callable, Container, Dict, FrozenSet, Generic, ItemsView, Iterable, Iterator, KeysView, List, Mapping, MutableMapping, MutableSequence, MutableSet, NoReturn, Optional, Protocol, Reversible, Sequence, Set, Sized, SupportsAbs, SupportsBytes, SupportsComplex, SupportsFloat, SupportsInt, SupportsRound, Tuple, Type, TypeVar, Union, ValuesView, overload, runtime_checkable, ) from typing_extensions import Literal if sys.version_info >= (3, 9): from types import GenericAlias class _SupportsIndex(Protocol): def __index__(self) -> int: ... class _SupportsTrunc(Protocol): def __trunc__(self) -> int: ... _T = TypeVar("_T") _T_co = TypeVar("_T_co", covariant=True) _KT = TypeVar("_KT") _VT = TypeVar("_VT") _S = TypeVar("_S") _T1 = TypeVar("_T1") _T2 = TypeVar("_T2") _T3 = TypeVar("_T3") _T4 = TypeVar("_T4") _T5 = TypeVar("_T5") _TT = TypeVar("_TT", bound="type") _TBE = TypeVar("_TBE", bound="BaseException") class object: __doc__: Optional[str] __dict__: Dict[str, Any] __slots__: Union[str, Iterable[str]] __module__: str __annotations__: Dict[str, Any] @property def __class__(self: _T) -> Type[_T]: ... @__class__.setter def __class__(self, __type: Type[object]) -> None: ... # noqa: F811 def __init__(self) -> None: ... def __new__(cls) -> Any: ... def __setattr__(self, name: str, value: Any) -> None: ... def __eq__(self, o: object) -> bool: ... def __ne__(self, o: object) -> bool: ... def __str__(self) -> str: ... def __repr__(self) -> str: ... def __hash__(self) -> int: ... def __format__(self, format_spec: str) -> str: ... def __getattribute__(self, name: str) -> Any: ... def __delattr__(self, name: str) -> None: ... def __sizeof__(self) -> int: ... def __reduce__(self) -> Union[str, Tuple[Any, ...]]: ... def __reduce_ex__(self, protocol: int) -> Union[str, Tuple[Any, ...]]: ... def __dir__(self) -> Iterable[str]: ... def __init_subclass__(cls) -> None: ... class staticmethod(object): # Special, only valid as a decorator. __func__: Callable[..., Any] __isabstractmethod__: bool def __init__(self, f: Callable[..., Any]) -> None: ... def __new__(cls: Type[_T], *args: Any, **kwargs: Any) -> _T: ... def __get__(self, obj: _T, type: Optional[Type[_T]] = ...) -> Callable[..., Any]: ... class classmethod(object): # Special, only valid as a decorator. __func__: Callable[..., Any] __isabstractmethod__: bool def __init__(self, f: Callable[..., Any]) -> None: ... def __new__(cls: Type[_T], *args: Any, **kwargs: Any) -> _T: ... def __get__(self, obj: _T, type: Optional[Type[_T]] = ...) -> Callable[..., Any]: ... class type(object): __base__: type __bases__: Tuple[type, ...] __basicsize__: int __dict__: Dict[str, Any] __dictoffset__: int __flags__: int __itemsize__: int __module__: str __mro__: Tuple[type, ...] __name__: str __qualname__: str __text_signature__: Optional[str] __weakrefoffset__: int @overload def __init__(self, o: object) -> None: ... @overload def __init__(self, name: str, bases: Tuple[type, ...], dict: Dict[str, Any]) -> None: ... @overload def __new__(cls, o: object) -> type: ... @overload def __new__(cls, name: str, bases: Tuple[type, ...], namespace: Dict[str, Any]) -> type: ... def __call__(self, *args: Any, **kwds: Any) -> Any: ... def __subclasses__(self: _TT) -> List[_TT]: ... # Note: the documentation doesnt specify what the return type is, the standard # implementation seems to be returning a list. def mro(self) -> List[type]: ... def __instancecheck__(self, instance: Any) -> bool: ... def __subclasscheck__(self, subclass: type) -> bool: ... @classmethod def __prepare__(metacls, __name: str, __bases: Tuple[type, ...], **kwds: Any) -> Mapping[str, Any]: ... class super(object): @overload def __init__(self, t: Any, obj: Any) -> None: ... @overload def __init__(self, t: Any) -> None: ... @overload def __init__(self) -> None: ... class int: @overload def __new__(cls: Type[_T], x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc] = ...) -> _T: ... @overload def __new__(cls: Type[_T], x: Union[str, bytes, bytearray], base: int) -> _T: ... @overload def __init__(self, x: Union[str, bytes, SupportsInt, _SupportsIndex, _SupportsTrunc] = ...) -> _T: ... @overload def __init__(self, x: Union[str, bytes, bytearray], base: int) -> _T: ... if sys.version_info >= (3, 8): def as_integer_ratio(self) -> Tuple[int, Literal[1]]: ... @property def real(self) -> int: ... @property def imag(self) -> int: ... @property def numerator(self) -> int: ... @property def denominator(self) -> int: ... def conjugate(self) -> int: ... def bit_length(self) -> int: ... def to_bytes(self, length: int, byteorder: str, *, signed: bool = ...) -> bytes: ... @classmethod def from_bytes( cls, bytes: Union[Iterable[int], SupportsBytes], byteorder: str, *, signed: bool = ... ) -> int: ... # TODO buffer object argument def __add__(self, x: int) -> int: ... def __sub__(self, x: int) -> int: ... def __mul__(self, x: int) -> int: ... def __floordiv__(self, x: int) -> int: ... def __truediv__(self, x: int) -> float: ... def __mod__(self, x: int) -> int: ... def __divmod__(self, x: int) -> Tuple[int, int]: ... def __radd__(self, x: int) -> int: ... def __rsub__(self, x: int) -> int: ... def __rmul__(self, x: int) -> int: ... def __rfloordiv__(self, x: int) -> int: ... def __rtruediv__(self, x: int) -> float: ... def __rmod__(self, x: int) -> int: ... def __rdivmod__(self, x: int) -> Tuple[int, int]: ... @overload def __pow__(self, __x: Literal[2], __modulo: Optional[int] = ...) -> int: ... @overload def __pow__(self, __x: int, __modulo: Optional[int] = ...) -> Any: ... # Return type can be int or float, depending on x. def __rpow__(self, x: int, mod: Optional[int] = ...) -> Any: ... def __and__(self, n: int) -> int: ... def __or__(self, n: int) -> int: ... def __xor__(self, n: int) -> int: ... def __lshift__(self, n: int) -> int: ... def __rshift__(self, n: int) -> int: ... def __rand__(self, n: int) -> int: ... def __ror__(self, n: int) -> int: ... def __rxor__(self, n: int) -> int: ... def __rlshift__(self, n: int) -> int: ... def __rrshift__(self, n: int) -> int: ... def __neg__(self) -> int: ... def __pos__(self) -> int: ... def __invert__(self) -> int: ... def __trunc__(self) -> int: ... def __ceil__(self) -> int: ... def __floor__(self) -> int: ... def __round__(self, ndigits: Optional[int] = ...) -> int: ... def __getnewargs__(self) -> Tuple[int]: ... def __eq__(self, x: object) -> bool: ... def __ne__(self, x: object) -> bool: ... def __lt__(self, x: int) -> bool: ... def __le__(self, x: int) -> bool: ... def __gt__(self, x: int) -> bool: ... def __ge__(self, x: int) -> bool: ... def __str__(self) -> str: ... def __float__(self) -> float: ... def __int__(self) -> int: ... def __abs__(self) -> int: ... def __hash__(self) -> int: ... def __bool__(self) -> bool: ... def __index__(self) -> int: ... class float: def __new__(cls: Type[_T], x: Union[SupportsFloat, _SupportsIndex, str, bytes, bytearray] = ...) -> _T: ... def as_integer_ratio(self) -> Tuple[int, int]: ... def hex(self) -> str: ... def is_integer(self) -> bool: ... @classmethod def fromhex(cls, __s: str) -> float: ... @property def real(self) -> float: ... @property def imag(self) -> float: ... def conjugate(self) -> float: ... def __add__(self, x: float) -> float: ... def __sub__(self, x: float) -> float: ... def __mul__(self, x: float) -> float: ... def __floordiv__(self, x: float) -> float: ... def __truediv__(self, x: float) -> float: ... def __mod__(self, x: float) -> float: ... def __divmod__(self, x: float) -> Tuple[float, float]: ... def __pow__( self, x: float, mod: None = ... ) -> float: ... # In Python 3, returns complex if self is negative and x is not whole def __radd__(self, x: float) -> float: ... def __rsub__(self, x: float) -> float: ... def __rmul__(self, x: float) -> float: ... def __rfloordiv__(self, x: float) -> float: ... def __rtruediv__(self, x: float) -> float: ... def __rmod__(self, x: float) -> float: ... def __rdivmod__(self, x: float) -> Tuple[float, float]: ... def __rpow__(self, x: float, mod: None = ...) -> float: ... def __getnewargs__(self) -> Tuple[float]: ... def __trunc__(self) -> int: ... if sys.version_info >= (3, 9): def __ceil__(self) -> int: ... def __floor__(self) -> int: ... @overload def __round__(self, ndigits: None = ...) -> int: ... @overload def __round__(self, ndigits: int) -> float: ... def __eq__(self, x: object) -> bool: ... def __ne__(self, x: object) -> bool: ... def __lt__(self, x: float) -> bool: ... def __le__(self, x: float) -> bool: ... def __gt__(self, x: float) -> bool: ... def __ge__(self, x: float) -> bool: ... def __neg__(self) -> float: ... def __pos__(self) -> float: ... def __str__(self) -> str: ... def __int__(self) -> int: ... def __float__(self) -> float: ... def __abs__(self) -> float: ... def __hash__(self) -> int: ... def __bool__(self) -> bool: ... class complex: @overload def __new__(cls: Type[_T], real: float = ..., imag: float = ...) -> _T: ... @overload def __new__(cls: Type[_T], real: Union[str, SupportsComplex, _SupportsIndex]) -> _T: ... @property def real(self) -> float: ... @property def imag(self) -> float: ... def conjugate(self) -> complex: ... def __add__(self, x: complex) -> complex: ... def __sub__(self, x: complex) -> complex: ... def __mul__(self, x: complex) -> complex: ... def __pow__(self, x: complex, mod: None = ...) -> complex: ... def __truediv__(self, x: complex) -> complex: ... def __radd__(self, x: complex) -> complex: ... def __rsub__(self, x: complex) -> complex: ... def __rmul__(self, x: complex) -> complex: ... def __rpow__(self, x: complex, mod: None = ...) -> complex: ... def __rtruediv__(self, x: complex) -> complex: ... def __eq__(self, x: object) -> bool: ... def __ne__(self, x: object) -> bool: ... def __neg__(self) -> complex: ... def __pos__(self) -> complex: ... def __str__(self) -> str: ... def __complex__(self) -> complex: ... def __abs__(self) -> float: ... def __hash__(self) -> int: ... def __bool__(self) -> bool: ... class _FormatMapMapping(Protocol): def __getitem__(self, __key: str) -> Any: ... class str(Sequence[str]): @overload def __new__(cls: Type[_T], o: object = ...) -> _T: ... @overload def __new__(cls: Type[_T], o: bytes, encoding: str = ..., errors: str = ...) -> _T: ... @overload def __init__(self, o: object = ...) -> _T: ... @overload def __init__(self, o: bytes, encoding: str = ..., errors: str = ...) -> _T: ... def capitalize(self) -> str: ... def casefold(self) -> str: ... def center(self, __width: int, __fillchar: str = ...) -> str: ... def count(self, x: str, __start: Optional[int] = ..., __end: Optional[int] = ...) -> int: ... def encode(self, encoding: str = ..., errors: str = ...) -> bytes: ... def endswith(self, suffix: Union[str, Tuple[str, ...]], start: Optional[int] = ..., end: Optional[int] = ...) -> bool: ... def expandtabs(self, tabsize: int = ...) -> str: ... def find(self, sub: str, __start: Optional[int] = ..., __end: Optional[int] = ...) -> int: ... def format(self, *args: object, **kwargs: object) -> str: ... def format_map(self, map: _FormatMapMapping) -> str: ... def index(self, sub: str, __start: Optional[int] = ..., __end: Optional[int] = ...) -> int: ... def isalnum(self) -> bool: ... def isalpha(self) -> bool: ... if sys.version_info >= (3, 7): def isascii(self) -> bool: ... def isdecimal(self) -> bool: ... def isdigit(self) -> bool: ... def isidentifier(self) -> bool: ... def islower(self) -> bool: ... def isnumeric(self) -> bool: ... def isprintable(self) -> bool: ... def isspace(self) -> bool: ... def istitle(self) -> bool: ... def isupper(self) -> bool: ... def join(self, __iterable: Iterable[str]) -> str: ... def ljust(self, __width: int, __fillchar: str = ...) -> str: ... def lower(self) -> str: ... def lstrip(self, __chars: Optional[str] = ...) -> str: ... def partition(self, __sep: str) -> Tuple[str, str, str]: ... def replace(self, __old: str, __new: str, __count: int = ...) -> str: ... if sys.version_info >= (3, 9): def removeprefix(self, __prefix: str) -> str: ... def removesuffix(self, __suffix: str) -> str: ... def rfind(self, sub: str, __start: Optional[int] = ..., __end: Optional[int] = ...) -> int: ... def rindex(self, sub: str, __start: Optional[int] = ..., __end: Optional[int] = ...) -> int: ... def rjust(self, __width: int, __fillchar: str = ...) -> str: ... def rpartition(self, __sep: str) -> Tuple[str, str, str]: ... def rsplit(self, sep: Optional[str] = ..., maxsplit: int = ...) -> List[str]: ... def rstrip(self, __chars: Optional[str] = ...) -> str: ... def split(self, sep: Optional[str] = ..., maxsplit: int = ...) -> List[str]: ... def splitlines(self, keepends: bool = ...) -> List[str]: ... def startswith(self, prefix: Union[str, Tuple[str, ...]], start: Optional[int] = ..., end: Optional[int] = ...) -> bool: ... def strip(self, __chars: Optional[str] = ...) -> str: ... def swapcase(self) -> str: ... def title(self) -> str: ... def translate(self, __table: Union[Mapping[int, Union[int, str, None]], Sequence[Union[int, str, None]]]) -> str: ... def upper(self) -> str: ... def zfill(self, __width: int) -> str: ... @staticmethod @overload def maketrans(__x: Union[Dict[int, _T], Dict[str, _T], Dict[Union[str, int], _T]]) -> Dict[int, _T]: ... @staticmethod @overload def maketrans(__x: str, __y: str, __z: Optional[str] = ...) -> Dict[int, Union[int, None]]: ... def __add__(self, s: str) -> str: ... # Incompatible with Sequence.__contains__ def __contains__(self, o: str) -> bool: ... # type: ignore def __eq__(self, x: object) -> bool: ... def __ge__(self, x: str) -> bool: ... def __getitem__(self, i: Union[int, slice]) -> str: ... def __gt__(self, x: str) -> bool: ... def __hash__(self) -> int: ... def __iter__(self) -> Iterator[str]: ... def __le__(self, x: str) -> bool: ... def __len__(self) -> int: ... def __lt__(self, x: str) -> bool: ... def __mod__(self, x: Any) -> str: ... def __mul__(self, n: int) -> str: ... def __ne__(self, x: object) -> bool: ... def __repr__(self) -> str: ... def __rmul__(self, n: int) -> str: ... def __str__(self) -> str: ... def __getnewargs__(self) -> Tuple[str]: ... class bytes(ByteString): @overload def __new__(cls: Type[_T], ints: Iterable[int]) -> _T: ... @overload def __new__(cls: Type[_T], string: str, encoding: str, errors: str = ...) -> _T: ... @overload def __new__(cls: Type[_T], length: int) -> _T: ... @overload def __new__(cls: Type[_T]) -> _T: ... @overload def __new__(cls: Type[_T], o: SupportsBytes) -> _T: ... def capitalize(self) -> bytes: ... def center(self, __width: int, __fillchar: bytes = ...) -> bytes: ... def count(self, sub: Union[bytes, int], start: Optional[int] = ..., end: Optional[int] = ...) -> int: ... def decode(self, encoding: str = ..., errors: str = ...) -> str: ... def endswith(self, suffix: Union[bytes, Tuple[bytes, ...]]) -> bool: ... def expandtabs(self, tabsize: int = ...) -> bytes: ... def find(self, sub: Union[bytes, int], start: Optional[int] = ..., end: Optional[int] = ...) -> int: ... if sys.version_info >= (3, 8): def hex(self, sep: Union[str, bytes] = ..., bytes_per_sep: int = ...) -> str: ... else: def hex(self) -> str: ... def index(self, sub: Union[bytes, int], start: Optional[int] = ..., end: Optional[int] = ...) -> int: ... def isalnum(self) -> bool: ... def isalpha(self) -> bool: ... if sys.version_info >= (3, 7): def isascii(self) -> bool: ... def isdigit(self) -> bool: ... def islower(self) -> bool: ... def isspace(self) -> bool: ... def istitle(self) -> bool: ... def isupper(self) -> bool: ... def join(self, __iterable_of_bytes: Iterable[Union[ByteString, memoryview]]) -> bytes: ... def ljust(self, __width: int, __fillchar: bytes = ...) -> bytes: ... def lower(self) -> bytes: ... def lstrip(self, __bytes: Optional[bytes] = ...) -> bytes: ... def partition(self, __sep: bytes) -> Tuple[bytes, bytes, bytes]: ... def replace(self, __old: bytes, __new: bytes, __count: int = ...) -> bytes: ... if sys.version_info >= (3, 9): def removeprefix(self, __prefix: bytes) -> bytes: ... def removesuffix(self, __suffix: bytes) -> bytes: ... def rfind(self, sub: Union[bytes, int], start: Optional[int] = ..., end: Optional[int] = ...) -> int: ... def rindex(self, sub: Union[bytes, int], start: Optional[int] = ..., end: Optional[int] = ...) -> int: ... def rjust(self, __width: int, __fillchar: bytes = ...) -> bytes: ... def rpartition(self, __sep: bytes) -> Tuple[bytes, bytes, bytes]: ... def rsplit(self, sep: Optional[bytes] = ..., maxsplit: int = ...) -> List[bytes]: ... def rstrip(self, __bytes: Optional[bytes] = ...) -> bytes: ... def split(self, sep: Optional[bytes] = ..., maxsplit: int = ...) -> List[bytes]: ... def splitlines(self, keepends: bool = ...) -> List[bytes]: ... def startswith( self, prefix: Union[bytes, Tuple[bytes, ...]], start: Optional[int] = ..., end: Optional[int] = ... ) -> bool: ... def strip(self, __bytes: Optional[bytes] = ...) -> bytes: ... def swapcase(self) -> bytes: ... def title(self) -> bytes: ... def translate(self, __table: Optional[bytes], delete: bytes = ...) -> bytes: ... def upper(self) -> bytes: ... def zfill(self, __width: int) -> bytes: ... @classmethod def fromhex(cls, __s: str) -> bytes: ... @classmethod def maketrans(cls, frm: bytes, to: bytes) -> bytes: ... def __len__(self) -> int: ... def __iter__(self) -> Iterator[int]: ... def __str__(self) -> str: ... def __repr__(self) -> str: ... def __int__(self) -> int: ... def __float__(self) -> float: ... def __hash__(self) -> int: ... @overload def __getitem__(self, i: int) -> int: ... @overload def __getitem__(self, s: slice) -> bytes: ... def __add__(self, s: bytes) -> bytes: ... def __mul__(self, n: int) -> bytes: ... def __rmul__(self, n: int) -> bytes: ... def __mod__(self, value: Any) -> bytes: ... # Incompatible with Sequence.__contains__ def __contains__(self, o: Union[int, bytes]) -> bool: ... # type: ignore def __eq__(self, x: object) -> bool: ... def __ne__(self, x: object) -> bool: ... def __lt__(self, x: bytes) -> bool: ... def __le__(self, x: bytes) -> bool: ... def __gt__(self, x: bytes) -> bool: ... def __ge__(self, x: bytes) -> bool: ... def __getnewargs__(self) -> Tuple[bytes]: ... class bytearray(MutableSequence[int], ByteString): @overload def __init__(self) -> None: ... @overload def __init__(self, ints: Iterable[int]) -> None: ... @overload def __init__(self, string: str, encoding: str, errors: str = ...) -> None: ... @overload def __init__(self, length: int) -> None: ... def capitalize(self) -> bytearray: ... def center(self, __width: int, __fillchar: bytes = ...) -> bytearray: ... def count(self, __sub: Union[bytes, int], __start: Optional[int] = ..., __end: Optional[int] = ...) -> int: ... def copy(self) -> bytearray: ... def decode(self, encoding: str = ..., errors: str = ...) -> str: ... def endswith(self, __suffix: Union[bytes, Tuple[bytes, ...]]) -> bool: ... def expandtabs(self, tabsize: int = ...) -> bytearray: ... def find(self, __sub: Union[bytes, int], __start: Optional[int] = ..., __end: Optional[int] = ...) -> int: ... def hex(self) -> str: ... def index(self, __sub: Union[bytes, int], __start: Optional[int] = ..., __end: Optional[int] = ...) -> int: ... def insert(self, __index: int, __item: int) -> None: ... def isalnum(self) -> bool: ... def isalpha(self) -> bool: ... if sys.version_info >= (3, 7): def isascii(self) -> bool: ... def isdigit(self) -> bool: ... def islower(self) -> bool: ... def isspace(self) -> bool: ... def istitle(self) -> bool: ... def isupper(self) -> bool: ... def join(self, __iterable_of_bytes: Iterable[Union[ByteString, memoryview]]) -> bytearray: ... def ljust(self, __width: int, __fillchar: bytes = ...) -> bytearray: ... def lower(self) -> bytearray: ... def lstrip(self, __bytes: Optional[bytes] = ...) -> bytearray: ... def partition(self, __sep: bytes) -> Tuple[bytearray, bytearray, bytearray]: ... if sys.version_info >= (3, 9): def removeprefix(self, __prefix: bytes) -> bytearray: ... def removesuffix(self, __suffix: bytes) -> bytearray: ... def replace(self, __old: bytes, __new: bytes, __count: int = ...) -> bytearray: ... def rfind(self, __sub: Union[bytes, int], __start: Optional[int] = ..., __end: Optional[int] = ...) -> int: ... def rindex(self, __sub: Union[bytes, int], __start: Optional[int] = ..., __end: Optional[int] = ...) -> int: ... def rjust(self, __width: int, __fillchar: bytes = ...) -> bytearray: ... def rpartition(self, __sep: bytes) -> Tuple[bytearray, bytearray, bytearray]: ... def rsplit(self, sep: Optional[bytes] = ..., maxsplit: int = ...) -> List[bytearray]: ... def rstrip(self, __bytes: Optional[bytes] = ...) -> bytearray: ... def split(self, sep: Optional[bytes] = ..., maxsplit: int = ...) -> List[bytearray]: ... def splitlines(self, keepends: bool = ...) -> List[bytearray]: ... def startswith( self, __prefix: Union[bytes, Tuple[bytes, ...]], __start: Optional[int] = ..., __end: Optional[int] = ... ) -> bool: ... def strip(self, __bytes: Optional[bytes] = ...) -> bytearray: ... def swapcase(self) -> bytearray: ... def title(self) -> bytearray: ... def translate(self, __table: Optional[bytes], delete: bytes = ...) -> bytearray: ... def upper(self) -> bytearray: ... def zfill(self, __width: int) -> bytearray: ... @classmethod def fromhex(cls, __string: str) -> bytearray: ... @classmethod def maketrans(cls, __frm: bytes, __to: bytes) -> bytes: ... def __len__(self) -> int: ... def __iter__(self) -> Iterator[int]: ... def __str__(self) -> str: ... def __repr__(self) -> str: ... def __int__(self) -> int: ... def __float__(self) -> float: ... __hash__: None # type: ignore @overload def __getitem__(self, i: int) -> int: ... @overload def __getitem__(self, s: slice) -> bytearray: ... @overload def __setitem__(self, i: int, x: int) -> None: ... @overload def __setitem__(self, s: slice, x: Union[Iterable[int], bytes]) -> None: ... def __delitem__(self, i: Union[int, slice]) -> None: ... def __add__(self, s: bytes) -> bytearray: ... def __iadd__(self, s: Iterable[int]) -> bytearray: ... def __mul__(self, n: int) -> bytearray: ... def __rmul__(self, n: int) -> bytearray: ... def __imul__(self, n: int) -> bytearray: ... def __mod__(self, value: Any) -> bytes: ... # Incompatible with Sequence.__contains__ def __contains__(self, o: Union[int, bytes]) -> bool: ... # type: ignore def __eq__(self, x: object) -> bool: ... def __ne__(self, x: object) -> bool: ... def __lt__(self, x: bytes) -> bool: ... def __le__(self, x: bytes) -> bool: ... def __gt__(self, x: bytes) -> bool: ... def __ge__(self, x: bytes) -> bool: ... class memoryview(Sized, Container[int]): format: str itemsize: int shape: Optional[Tuple[int, ...]] strides: Optional[Tuple[int, ...]] suboffsets: Optional[Tuple[int, ...]] readonly: bool ndim: int obj: Union[bytes, bytearray] c_contiguous: bool f_contiguous: bool contiguous: bool nbytes: int def __init__(self, obj: ReadableBuffer) -> None: ... def __enter__(self) -> memoryview: ... def __exit__( self, exc_type: Optional[Type[BaseException]], exc_val: Optional[BaseException], exc_tb: Optional[TracebackType] ) -> None: ... def cast(self, format: str, shape: Union[List[int], Tuple[int]] = ...) -> memoryview: ... @overload def __getitem__(self, i: int) -> int: ... @overload def __getitem__(self, s: slice) -> memoryview: ... def __contains__(self, x: object) -> bool: ... def __iter__(self) -> Iterator[int]: ... def __len__(self) -> int: ... @overload def __setitem__(self, s: slice, o: memoryview) -> None: ... @overload def __setitem__(self, i: int, o: bytes) -> None: ... @overload def __setitem__(self, s: slice, o: Sequence[bytes]) -> None: ... if sys.version_info >= (3, 8): def tobytes(self, order: Optional[Literal["C", "F", "A"]] = ...) -> bytes: ... else: def tobytes(self) -> bytes: ... def tolist(self) -> List[int]: ... if sys.version_info >= (3, 8): def toreadonly(self) -> memoryview: ... def release(self) -> None: ... def hex(self) -> str: ... class bool(int): def __new__(cls: Type[_T], __o: object = ...) -> _T: ... def __init__(self, o: object = ...): ... @overload def __and__(self, x: bool) -> bool: ... @overload def __and__(self, x: int) -> int: ... @overload def __or__(self, x: bool) -> bool: ... @overload def __or__(self, x: int) -> int: ... @overload def __xor__(self, x: bool) -> bool: ... @overload def __xor__(self, x: int) -> int: ... @overload def __rand__(self, x: bool) -> bool: ... @overload def __rand__(self, x: int) -> int: ... @overload def __ror__(self, x: bool) -> bool: ... @overload def __ror__(self, x: int) -> int: ... @overload def __rxor__(self, x: bool) -> bool: ... @overload def __rxor__(self, x: int) -> int: ... def __getnewargs__(self) -> Tuple[int]: ... class slice(object): start: Any step: Any stop: Any @overload def __init__(self, stop: Any) -> None: ... @overload def __init__(self, start: Any, stop: Any, step: Any = ...) -> None: ... __hash__: None # type: ignore def indices(self, len: int) -> Tuple[int, int, int]: ... class tuple(Sequence[_T_co], Generic[_T_co]): def __new__(cls: Type[_T], iterable: Iterable[_T_co] = ...) -> _T: ... def __init__(self, iterable: Iterable[_T_co] = ...): ... def __len__(self) -> int: ... def __contains__(self, x: object) -> bool: ... @overload def __getitem__(self, x: int) -> _T_co: ... @overload def __getitem__(self, x: slice) -> Tuple[_T_co, ...]: ... def __iter__(self) -> Iterator[_T_co]: ... def __lt__(self, x: Tuple[_T_co, ...]) -> bool: ... def __le__(self, x: Tuple[_T_co, ...]) -> bool: ... def __gt__(self, x: Tuple[_T_co, ...]) -> bool: ... def __ge__(self, x: Tuple[_T_co, ...]) -> bool: ... @overload def __add__(self, x: Tuple[_T_co, ...]) -> Tuple[_T_co, ...]: ... @overload def __add__(self, x: Tuple[Any, ...]) -> Tuple[Any, ...]: ... def __mul__(self, n: int) -> Tuple[_T_co, ...]: ... def __rmul__(self, n: int) -> Tuple[_T_co, ...]: ... def count(self, __value: Any) -> int: ... def index(self, __value: Any, __start: int = ..., __stop: int = ...) -> int: ... if sys.version_info >= (3, 9): def __class_getitem__(cls, item: Any) -> GenericAlias: ... class list(MutableSequence[_T], Generic[_T]): @overload def __init__(self) -> None: ... @overload def __init__(self, iterable: Iterable[_T]) -> None: ... def clear(self) -> None: ... def copy(self) -> List[_T]: ... def append(self, __object: _T) -> None: ... def extend(self, __iterable: Iterable[_T]) -> None: ... def pop(self, __index: int = ...) -> _T: ... def index(self, __value: _T, __start: int = ..., __stop: int = ...) -> int: ... def count(self, __value: _T) -> int: ... def insert(self, __index: int, __object: _T) -> None: ... def remove(self, __value: _T) -> None: ... def reverse(self) -> None: ... @overload def sort(self: List[SupportsLessThanT], *, key: None = ..., reverse: bool = ...) -> None: ... @overload def sort(self, *, key: Callable[[_T], SupportsLessThan], reverse: bool = ...) -> None: ... def __len__(self) -> int: ... def __iter__(self) -> Iterator[_T]: ... def __str__(self) -> str: ... __hash__: None # type: ignore @overload def __getitem__(self, i: int) -> _T: ... @overload def __getitem__(self, s: slice) -> List[_T]: ... @overload def __setitem__(self, i: int, o: _T) -> None: ... @overload def __setitem__(self, s: slice, o: Iterable[_T]) -> None: ... def __delitem__(self, i: Union[int, slice]) -> None: ... def __add__(self, x: List[_T]) -> List[_T]: ... def __iadd__(self: _S, x: Iterable[_T]) -> _S: ... def __mul__(self, n: int) -> List[_T]: ... def __rmul__(self, n: int) -> List[_T]: ... def __imul__(self: _S, n: int) -> _S: ... def __contains__(self, o: object) -> bool: ... def __reversed__(self) -> Iterator[_T]: ... def __gt__(self, x: List[_T]) -> bool: ... def __ge__(self, x: List[_T]) -> bool: ... def __lt__(self, x: List[_T]) -> bool: ... def __le__(self, x: List[_T]) -> bool: ... if sys.version_info >= (3, 9): def __class_getitem__(cls, item: Any) -> GenericAlias: ... class dict(MutableMapping[_KT, _VT], Generic[_KT, _VT]): # NOTE: Keyword arguments are special. If they are used, _KT must include # str, but we have no way of enforcing it here. @overload def __init__(self, **kwargs: _VT) -> None: ... @overload def __init__(self, map: Mapping[_KT, _VT], **kwargs: _VT) -> None: ... @overload def __init__(self, iterable: Iterable[Tuple[_KT, _VT]], **kwargs: _VT) -> None: ... def __new__(cls: Type[_T1], *args: Any, **kwargs: Any) -> _T1: ... def clear(self) -> None: ... def copy(self) -> Dict[_KT, _VT]: ... def popitem(self) -> Tuple[_KT, _VT]: ... def setdefault(self, __key: _KT, __default: _VT = ...) -> _VT: ... @overload def update(self, __m: Mapping[_KT, _VT], **kwargs: _VT) -> None: ... @overload def update(self, __m: Iterable[Tuple[_KT, _VT]], **kwargs: _VT) -> None: ... @overload def update(self, **kwargs: _VT) -> None: ... def keys(self) -> KeysView[_KT]: ... def values(self) -> ValuesView[_VT]: ... def items(self) -> ItemsView[_KT, _VT]: ... @classmethod @overload def fromkeys(cls, __iterable: Iterable[_T]) -> Dict[_T, Any]: ... @classmethod @overload def fromkeys(cls, __iterable: Iterable[_T], __value: _S) -> Dict[_T, _S]: ... def __len__(self) -> int: ... def __getitem__(self, k: _KT) -> _VT: ... def __setitem__(self, k: _KT, v: _VT) -> None: ... def __delitem__(self, v: _KT) -> None: ... def __iter__(self) -> Iterator[_KT]: ... if sys.version_info >= (3, 8): def __reversed__(self) -> Iterator[_KT]: ... def __str__(self) -> str: ... __hash__: None # type: ignore if sys.version_info >= (3, 9): def __class_getitem__(cls, item: Any) -> GenericAlias: ... def __or__(self, __value: Mapping[_KT, _VT]) -> Dict[_KT, _VT]: ... def __ior__(self, __value: Mapping[_KT, _VT]) -> Dict[_KT, _VT]: ... class set(MutableSet[_T], Generic[_T]): def __init__(self, iterable: Iterable[_T] = ...) -> None: ... def add(self, element: _T) -> None: ... def clear(self) -> None: ... def copy(self) -> Set[_T]: ... def difference(self, *s: Iterable[Any]) -> Set[_T]: ... def difference_update(self, *s: Iterable[Any]) -> None: ... def discard(self, element: _T) -> None: ... def intersection(self, *s: Iterable[Any]) -> Set[_T]: ... def intersection_update(self, *s: Iterable[Any]) -> None: ... def isdisjoint(self, s: Iterable[Any]) -> bool: ... def issubset(self, s: Iterable[Any]) -> bool: ... def issuperset(self, s: Iterable[Any]) -> bool: ... def pop(self) -> _T: ... def remove(self, element: _T) -> None: ... def symmetric_difference(self, s: Iterable[_T]) -> Set[_T]: ... def symmetric_difference_update(self, s: Iterable[_T]) -> None: ... def union(self, *s: Iterable[_T]) -> Set[_T]: ... def update(self, *s: Iterable[_T]) -> None: ... def __len__(self) -> int: ... def __contains__(self, o: object) -> bool: ... def __iter__(self) -> Iterator[_T]: ... def __str__(self) -> str: ... def __and__(self, s: AbstractSet[object]) -> Set[_T]: ... def __iand__(self, s: AbstractSet[object]) -> Set[_T]: ... def __or__(self, s: AbstractSet[_S]) -> Set[Union[_T, _S]]: ... def __ior__(self, s: AbstractSet[_S]) -> Set[Union[_T, _S]]: ... def __sub__(self, s: AbstractSet[Optional[_T]]) -> Set[_T]: ... def __isub__(self, s: AbstractSet[Optional[_T]]) -> Set[_T]: ... def __xor__(self, s: AbstractSet[_S]) -> Set[Union[_T, _S]]: ... def __ixor__(self, s: AbstractSet[_S]) -> Set[Union[_T, _S]]: ... def __le__(self, s: AbstractSet[object]) -> bool: ... def __lt__(self, s: AbstractSet[object]) -> bool: ... def __ge__(self, s: AbstractSet[object]) -> bool: ... def __gt__(self, s: AbstractSet[object]) -> bool: ... __hash__: None # type: ignore if sys.version_info >= (3, 9): def __class_getitem__(cls, item: Any) -> GenericAlias: ... class frozenset(AbstractSet[_T_co], Generic[_T_co]): def __init__(self, iterable: Iterable[_T_co] = ...) -> None: ... def copy(self) -> FrozenSet[_T_co]: ... def difference(self, *s: Iterable[object]) -> FrozenSet[_T_co]: ... def intersection(self, *s: Iterable[object]) -> FrozenSet[_T_co]: ... def isdisjoint(self, s: Iterable[_T_co]) -> bool: ... def issubset(self, s: Iterable[object]) -> bool: ... def issuperset(self, s: Iterable[object]) -> bool: ... def symmetric_difference(self, s: Iterable[_T_co]) -> FrozenSet[_T_co]: ... def union(self, *s: Iterable[_T_co]) -> FrozenSet[_T_co]: ... def __len__(self) -> int: ... def __contains__(self, o: object) -> bool: ... def __iter__(self) -> Iterator[_T_co]: ... def __str__(self) -> str: ... def __and__(self, s: AbstractSet[_T_co]) -> FrozenSet[_T_co]: ... def __or__(self, s: AbstractSet[_S]) -> FrozenSet[Union[_T_co, _S]]: ... def __sub__(self, s: AbstractSet[_T_co]) -> FrozenSet[_T_co]: ... def __xor__(self, s: AbstractSet[_S]) -> FrozenSet[Union[_T_co, _S]]: ... def __le__(self, s: AbstractSet[object]) -> bool: ... def __lt__(self, s: AbstractSet[object]) -> bool: ... def __ge__(self, s: AbstractSet[object]) -> bool: ... def __gt__(self, s: AbstractSet[object]) -> bool: ... if sys.version_info >= (3, 9): def __class_getitem__(cls, item: Any) -> GenericAlias: ... class enumerate(Iterator[Tuple[int, _T]], Generic[_T]): def __init__(self, iterable: Iterable[_T], start: int = ...) -> None: ... def __iter__(self) -> Iterator[Tuple[int, _T]]: ... def __next__(self) -> Tuple[int, _T]: ... if sys.version_info >= (3, 9): def __class_getitem__(cls, item: Any) -> GenericAlias: ... class range(Sequence[int]): start: int stop: int step: int @overload def __init__(self, stop: int) -> None: ... @overload def __init__(self, start: int, stop: int, step: int = ...) -> None: ... def count(self, value: int) -> int: ... def index(self, value: int) -> int: ... # type: ignore def __len__(self) -> int: ... def __contains__(self, o: object) -> bool: ... def __iter__(self) -> Iterator[int]: ... @overload def __getitem__(self, i: int) -> int: ... @overload def __getitem__(self, s: slice) -> range: ... def __repr__(self) -> str: ... def __reversed__(self) -> Iterator[int]: ... class property(object): def __init__( self, fget: Optional[Callable[[Any], Any]] = ..., fset: Optional[Callable[[Any, Any], None]] = ..., fdel: Optional[Callable[[Any], None]] = ..., doc: Optional[str] = ..., ) -> None: ... def getter(self, fget: Callable[[Any], Any]) -> property: ... def setter(self, fset: Callable[[Any, Any], None]) -> property: ... def deleter(self, fdel: Callable[[Any], None]) -> property: ... def __get__(self, obj: Any, type: Optional[type] = ...) -> Any: ... def __set__(self, obj: Any, value: Any) -> None: ... def __delete__(self, obj: Any) -> None: ... def fget(self) -> Any: ... def fset(self, value: Any) -> None: ... def fdel(self) -> None: ... class _NotImplementedType(Any): # type: ignore # A little weird, but typing the __call__ as NotImplemented makes the error message # for NotImplemented() much better pass NotImplemented: _NotImplementedType def abs(__x: SupportsAbs[_T]) -> _T: ... def all(__iterable: Iterable[object]) -> bool: ... def any(__iterable: Iterable[object]) -> bool: ... def ascii(__obj: object) -> str: ... def bin(__number: Union[int, _SupportsIndex]) -> str: ... if sys.version_info >= (3, 7): def breakpoint(*args: Any, **kws: Any) -> None: ... def callable(__obj: object) -> bool: ... def chr(__i: int) -> str: ... # This class is to be exported as PathLike from os, # but we define it here as _PathLike to avoid import cycle issues. # See https://github.com/python/typeshed/pull/991#issuecomment-288160993 _AnyStr_co = TypeVar("_AnyStr_co", str, bytes, covariant=True) @runtime_checkable class _PathLike(Protocol[_AnyStr_co]): def __fspath__(self) -> _AnyStr_co: ... if sys.version_info >= (3, 8): def compile( source: Union[str, bytes, mod, AST], filename: Union[str, bytes, _PathLike[Any]], mode: str, flags: int = ..., dont_inherit: int = ..., optimize: int = ..., *, _feature_version: int = ..., ) -> Any: ... else: def compile( source: Union[str, bytes, mod, AST], filename: Union[str, bytes, _PathLike[Any]], mode: str, flags: int = ..., dont_inherit: int = ..., optimize: int = ..., ) -> Any: ... def copyright() -> None: ... def credits() -> None: ... def delattr(__obj: Any, __name: str) -> None: ... def dir(__o: object = ...) -> List[str]: ... _N2 = TypeVar("_N2", int, float) def divmod(__x: _N2, __y: _N2) -> Tuple[_N2, _N2]: ... def eval( __source: Union[str, bytes, CodeType], __globals: Optional[Dict[str, Any]] = ..., __locals: Optional[Mapping[str, Any]] = ... ) -> Any: ... def exec( __source: Union[str, bytes, CodeType], __globals: Optional[Dict[str, Any]] = ..., __locals: Optional[Mapping[str, Any]] = ..., ) -> Any: ... def exit(code: object = ...) -> NoReturn: ... @overload def filter(__function: None, __iterable: Iterable[Optional[_T]]) -> Iterator[_T]: ... @overload def filter(__function: Callable[[_T], Any], __iterable: Iterable[_T]) -> Iterator[_T]: ... def format(__value: object, __format_spec: str = ...) -> str: ... # TODO unicode def getattr(__o: Any, name: str, __default: Any = ...) -> Any: ... def globals() -> Dict[str, Any]: ... def hasattr(__obj: Any, __name: str) -> bool: ... def hash(__obj: object) -> int: ... def help(*args: Any, **kwds: Any) -> None: ... def hex(__number: Union[int, _SupportsIndex]) -> str: ... def id(__obj: object) -> int: ... def input(__prompt: Any = ...) -> str: ... @overload def iter(__iterable: Iterable[_T]) -> Iterator[_T]: ... @overload def iter(__function: Callable[[], Optional[_T]], __sentinel: None) -> Iterator[_T]: ... @overload def iter(__function: Callable[[], _T], __sentinel: Any) -> Iterator[_T]: ... def isinstance(__obj: object, __class_or_tuple: Union[type, Tuple[Union[type, Tuple[Any, ...]], ...]]) -> bool: ... def issubclass(__cls: type, __class_or_tuple: Union[type, Tuple[Union[type, Tuple[Any, ...]], ...]]) -> bool: ... def len(__obj: Sized) -> int: ... def license() -> None: ... def locals() -> Dict[str, Any]: ... @overload def map(__func: Callable[[_T1], _S], __iter1: Iterable[_T1]) -> Iterator[_S]: ... @overload def map(__func: Callable[[_T1, _T2], _S], __iter1: Iterable[_T1], __iter2: Iterable[_T2]) -> Iterator[_S]: ... @overload def map( __func: Callable[[_T1, _T2, _T3], _S], __iter1: Iterable[_T1], __iter2: Iterable[_T2], __iter3: Iterable[_T3] ) -> Iterator[_S]: ... @overload def map( __func: Callable[[_T1, _T2, _T3, _T4], _S], __iter1: Iterable[_T1], __iter2: Iterable[_T2], __iter3: Iterable[_T3], __iter4: Iterable[_T4], ) -> Iterator[_S]: ... @overload def map( __func: Callable[[_T1, _T2, _T3, _T4, _T5], _S], __iter1: Iterable[_T1], __iter2: Iterable[_T2], __iter3: Iterable[_T3], __iter4: Iterable[_T4], __iter5: Iterable[_T5], ) -> Iterator[_S]: ... @overload def map( __func: Callable[..., _S], __iter1: Iterable[Any], __iter2: Iterable[Any], __iter3: Iterable[Any], __iter4: Iterable[Any], __iter5: Iterable[Any], __iter6: Iterable[Any], *iterables: Iterable[Any], ) -> Iterator[_S]: ... @overload def max( __arg1: SupportsLessThanT, __arg2: SupportsLessThanT, *_args: SupportsLessThanT, key: None = ... ) -> SupportsLessThanT: ... @overload def max(__arg1: _T, __arg2: _T, *_args: _T, key: Callable[[_T], SupportsLessThanT]) -> _T: ... @overload def max(__iterable: Iterable[SupportsLessThanT], *, key: None = ...) -> SupportsLessThanT: ... @overload def max(__iterable: Iterable[_T], *, key: Callable[[_T], SupportsLessThanT]) -> _T: ... @overload def max(__iterable: Iterable[SupportsLessThanT], *, key: None = ..., default: _T) -> Union[SupportsLessThanT, _T]: ... @overload def max(__iterable: Iterable[_T1], *, key: Callable[[_T1], SupportsLessThanT], default: _T2) -> Union[_T1, _T2]: ... @overload def min( __arg1: SupportsLessThanT, __arg2: SupportsLessThanT, *_args: SupportsLessThanT, key: None = ... ) -> SupportsLessThanT: ... @overload def min(__arg1: _T, __arg2: _T, *_args: _T, key: Callable[[_T], SupportsLessThanT]) -> _T: ... @overload def min(__iterable: Iterable[SupportsLessThanT], *, key: None = ...) -> SupportsLessThanT: ... @overload def min(__iterable: Iterable[_T], *, key: Callable[[_T], SupportsLessThanT]) -> _T: ... @overload def min(__iterable: Iterable[SupportsLessThanT], *, key: None = ..., default: _T) -> Union[SupportsLessThanT, _T]: ... @overload def min(__iterable: Iterable[_T1], *, key: Callable[[_T1], SupportsLessThanT], default: _T2) -> Union[_T1, _T2]: ... @overload def next(__i: Iterator[_T]) -> _T: ... @overload def next(__i: Iterator[_T], default: _VT) -> Union[_T, _VT]: ... def oct(__number: Union[int, _SupportsIndex]) -> str: ... _OpenFile = Union[AnyPath, int] _Opener = Callable[[str, int], int] # Text mode: always returns a TextIOWrapper @overload def open( file: _OpenFile, mode: OpenTextMode = ..., buffering: int = ..., encoding: Optional[str] = ..., errors: Optional[str] = ..., newline: Optional[str] = ..., closefd: bool = ..., opener: Optional[_Opener] = ..., ) -> TextIOWrapper: ... # Unbuffered binary mode: returns a FileIO @overload def open( file: _OpenFile, mode: OpenBinaryMode, buffering: Literal[0], encoding: None = ..., errors: None = ..., newline: None = ..., closefd: bool = ..., opener: Optional[_Opener] = ..., ) -> FileIO: ... # Buffering is on: return BufferedRandom, BufferedReader, or BufferedWriter @overload def open( file: _OpenFile, mode: OpenBinaryModeUpdating, buffering: Literal[-1, 1] = ..., encoding: None = ..., errors: None = ..., newline: None = ..., closefd: bool = ..., opener: Optional[_Opener] = ..., ) -> BufferedRandom: ... @overload def open( file: _OpenFile, mode: OpenBinaryModeWriting, buffering: Literal[-1, 1] = ..., encoding: None = ..., errors: None = ..., newline: None = ..., closefd: bool = ..., opener: Optional[_Opener] = ..., ) -> BufferedWriter: ... @overload def open( file: _OpenFile, mode: OpenBinaryModeReading, buffering: Literal[-1, 1] = ..., encoding: None = ..., errors: None = ..., newline: None = ..., closefd: bool = ..., opener: Optional[_Opener] = ..., ) -> BufferedReader: ... # Buffering cannot be determined: fall back to BinaryIO @overload def open( file: _OpenFile, mode: OpenBinaryMode, buffering: int, encoding: None = ..., errors: None = ..., newline: None = ..., closefd: bool = ..., opener: Optional[_Opener] = ..., ) -> BinaryIO: ... # Fallback if mode is not specified @overload def open( file: _OpenFile, mode: str, buffering: int = ..., encoding: Optional[str] = ..., errors: Optional[str] = ..., newline: Optional[str] = ..., closefd: bool = ..., opener: Optional[_Opener] = ..., ) -> IO[Any]: ... def ord(__c: Union[str, bytes]) -> int: ... def print( *values: object, sep: Optional[str] = ..., end: Optional[str] = ..., file: Optional[SupportsWrite[str]] = ..., flush: bool = ..., ) -> None: ... _E = TypeVar("_E", contravariant=True) _M = TypeVar("_M", contravariant=True) class _SupportsPow2(Protocol[_E, _T_co]): def __pow__(self, __other: _E) -> _T_co: ... class _SupportsPow3(Protocol[_E, _M, _T_co]): def __pow__(self, __other: _E, __modulo: _M) -> _T_co: ... if sys.version_info >= (3, 8): @overload def pow(base: int, exp: int, mod: None = ...) -> Any: ... # returns int or float depending on whether exp is non-negative @overload def pow(base: int, exp: int, mod: int) -> int: ... @overload def pow(base: float, exp: float, mod: None = ...) -> float: ... @overload def pow(base: _SupportsPow2[_E, _T_co], exp: _E) -> _T_co: ... @overload def pow(base: _SupportsPow3[_E, _M, _T_co], exp: _E, mod: _M) -> _T_co: ... else: @overload def pow( __base: int, __exp: int, __mod: None = ... ) -> Any: ... # returns int or float depending on whether exp is non-negative @overload def pow(__base: int, __exp: int, __mod: int) -> int: ... @overload def pow(__base: float, __exp: float, __mod: None = ...) -> float: ... @overload def pow(__base: _SupportsPow2[_E, _T_co], __exp: _E) -> _T_co: ... @overload def pow(__base: _SupportsPow3[_E, _M, _T_co], __exp: _E, __mod: _M) -> _T_co: ... def quit(code: object = ...) -> NoReturn: ... @overload def reversed(__sequence: Sequence[_T]) -> Iterator[_T]: ... @overload def reversed(__sequence: Reversible[_T]) -> Iterator[_T]: ... def repr(__obj: object) -> str: ... @overload def round(number: float) -> int: ... @overload def round(number: float, ndigits: None) -> int: ... @overload def round(number: float, ndigits: int) -> float: ... @overload def round(number: SupportsRound[_T]) -> int: ... @overload def round(number: SupportsRound[_T], ndigits: None) -> int: ... @overload def round(number: SupportsRound[_T], ndigits: int) -> _T: ... def setattr(__obj: Any, __name: str, __value: Any) -> None: ... @overload def sorted(__iterable: Iterable[SupportsLessThanT], *, key: None = ..., reverse: bool = ...) -> List[SupportsLessThanT]: ... @overload def sorted(__iterable: Iterable[_T], *, key: Callable[[_T], SupportsLessThan], reverse: bool = ...) -> List[_T]: ... if sys.version_info >= (3, 8): @overload def sum(__iterable: Iterable[_T]) -> Union[_T, int]: ... @overload def sum(__iterable: Iterable[_T], start: _S) -> Union[_T, _S]: ... else: @overload def sum(__iterable: Iterable[_T]) -> Union[_T, int]: ... @overload def sum(__iterable: Iterable[_T], __start: _S) -> Union[_T, _S]: ... def vars(__object: Any = ...) -> Dict[str, Any]: ... @overload def zip(__iter1: Iterable[_T1]) -> Iterator[Tuple[_T1]]: ... @overload def zip(__iter1: Iterable[_T1], __iter2: Iterable[_T2]) -> Iterator[Tuple[_T1, _T2]]: ... @overload def zip(__iter1: Iterable[_T1], __iter2: Iterable[_T2], __iter3: Iterable[_T3]) -> Iterator[Tuple[_T1, _T2, _T3]]: ... @overload def zip( __iter1: Iterable[_T1], __iter2: Iterable[_T2], __iter3: Iterable[_T3], __iter4: Iterable[_T4] ) -> Iterator[Tuple[_T1, _T2, _T3, _T4]]: ... @overload def zip( __iter1: Iterable[_T1], __iter2: Iterable[_T2], __iter3: Iterable[_T3], __iter4: Iterable[_T4], __iter5: Iterable[_T5] ) -> Iterator[Tuple[_T1, _T2, _T3, _T4, _T5]]: ... @overload def zip( __iter1: Iterable[Any], __iter2: Iterable[Any], __iter3: Iterable[Any], __iter4: Iterable[Any], __iter5: Iterable[Any], __iter6: Iterable[Any], *iterables: Iterable[Any], ) -> Iterator[Tuple[Any, ...]]: ... def __import__( name: str, globals: Optional[Mapping[str, Any]] = ..., locals: Optional[Mapping[str, Any]] = ..., fromlist: Sequence[str] = ..., level: int = ..., ) -> Any: ... # Actually the type of Ellipsis is , but since it's # not exposed anywhere under that name, we make it private here. class ellipsis: ... Ellipsis: ellipsis class BaseException(object): args: Tuple[Any, ...] __cause__: Optional[BaseException] __context__: Optional[BaseException] __suppress_context__: bool __traceback__: Optional[TracebackType] def __init__(self, *args: object) -> None: ... def __str__(self) -> str: ... def __repr__(self) -> str: ... def with_traceback(self: _TBE, tb: Optional[TracebackType]) -> _TBE: ... class GeneratorExit(BaseException): ... class KeyboardInterrupt(BaseException): ... class SystemExit(BaseException): code: int class Exception(BaseException): ... class StopIteration(Exception): value: Any _StandardError = Exception class OSError(Exception): errno: int strerror: str # filename, filename2 are actually Union[str, bytes, None] filename: Any filename2: Any EnvironmentError = OSError IOError = OSError class ArithmeticError(_StandardError): ... class AssertionError(_StandardError): ... class AttributeError(_StandardError): ... class BufferError(_StandardError): ... class EOFError(_StandardError): ... class ImportError(_StandardError): def __init__(self, *args: object, name: Optional[str] = ..., path: Optional[str] = ...) -> None: ... name: Optional[str] path: Optional[str] class LookupError(_StandardError): ... class MemoryError(_StandardError): ... class NameError(_StandardError): ... class ReferenceError(_StandardError): ... class RuntimeError(_StandardError): ... class StopAsyncIteration(Exception): value: Any class SyntaxError(_StandardError): msg: str lineno: Optional[int] offset: Optional[int] text: Optional[str] filename: Optional[str] class SystemError(_StandardError): ... class TypeError(_StandardError): ... class ValueError(_StandardError): ... class FloatingPointError(ArithmeticError): ... class OverflowError(ArithmeticError): ... class ZeroDivisionError(ArithmeticError): ... class ModuleNotFoundError(ImportError): ... class IndexError(LookupError): ... class KeyError(LookupError): ... class UnboundLocalError(NameError): ... class WindowsError(OSError): winerror: int class BlockingIOError(OSError): characters_written: int class ChildProcessError(OSError): ... class ConnectionError(OSError): ... class BrokenPipeError(ConnectionError): ... class ConnectionAbortedError(ConnectionError): ... class ConnectionRefusedError(ConnectionError): ... class ConnectionResetError(ConnectionError): ... class FileExistsError(OSError): ... class FileNotFoundError(OSError): ... class InterruptedError(OSError): ... class IsADirectoryError(OSError): ... class NotADirectoryError(OSError): ... class PermissionError(OSError): ... class ProcessLookupError(OSError): ... class TimeoutError(OSError): ... class NotImplementedError(RuntimeError): ... class RecursionError(RuntimeError): ... class IndentationError(SyntaxError): ... class TabError(IndentationError): ... class UnicodeError(ValueError): ... class UnicodeDecodeError(UnicodeError): encoding: str object: bytes start: int end: int reason: str def __init__(self, __encoding: str, __object: bytes, __start: int, __end: int, __reason: str) -> None: ... class UnicodeEncodeError(UnicodeError): encoding: str object: str start: int end: int reason: str def __init__(self, __encoding: str, __object: str, __start: int, __end: int, __reason: str) -> None: ... class UnicodeTranslateError(UnicodeError): ... class Warning(Exception): ... class UserWarning(Warning): ... class DeprecationWarning(Warning): ... class SyntaxWarning(Warning): ... class RuntimeWarning(Warning): ... class FutureWarning(Warning): ... class PendingDeprecationWarning(Warning): ... class ImportWarning(Warning): ... class UnicodeWarning(Warning): ... class BytesWarning(Warning): ... class ResourceWarning(Warning): ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4303794 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/collections/0000775000175000017500000000000000000000000023432 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/collections/__init__.pyi0000664000175000017500000003424600000000000025725 0ustar00davedave00000000000000import sys import typing from typing import ( AbstractSet, Any, AsyncGenerator as AsyncGenerator, AsyncIterable as AsyncIterable, AsyncIterator as AsyncIterator, Awaitable as Awaitable, ByteString as ByteString, Callable as Callable, Collection as Collection, Container as Container, Coroutine as Coroutine, Dict, Generator as Generator, Generic, Hashable as Hashable, ItemsView as ItemsView, Iterable as Iterable, Iterator as Iterator, KeysView as KeysView, List, Mapping as Mapping, MappingView as MappingView, MutableMapping as MutableMapping, MutableSequence as MutableSequence, MutableSet as MutableSet, Optional, Reversible as Reversible, Sequence as Sequence, Sized as Sized, Tuple, Type, TypeVar, Union, ValuesView as ValuesView, overload, ) Set = AbstractSet _S = TypeVar("_S") _T = TypeVar("_T") _KT = TypeVar("_KT") _VT = TypeVar("_VT") # namedtuple is special-cased in the type checker; the initializer is ignored. if sys.version_info >= (3, 7): def namedtuple( typename: str, field_names: Union[str, Iterable[str]], *, rename: bool = ..., module: Optional[str] = ..., defaults: Optional[Iterable[Any]] = ..., ) -> Type[Tuple[Any, ...]]: ... else: def namedtuple( typename: str, field_names: Union[str, Iterable[str]], *, verbose: bool = ..., rename: bool = ..., module: Optional[str] = ..., ) -> Type[Tuple[Any, ...]]: ... class UserDict(MutableMapping[_KT, _VT]): data: Dict[_KT, _VT] def __init__(self, __dict: Optional[Mapping[_KT, _VT]] = ..., **kwargs: _VT) -> None: ... def __len__(self) -> int: ... def __getitem__(self, key: _KT) -> _VT: ... def __setitem__(self, key: _KT, item: _VT) -> None: ... def __delitem__(self, key: _KT) -> None: ... def __iter__(self) -> Iterator[_KT]: ... def __contains__(self, key: object) -> bool: ... def copy(self: _S) -> _S: ... @classmethod def fromkeys(cls: Type[_S], iterable: Iterable[_KT], value: Optional[_VT] = ...) -> _S: ... class UserList(MutableSequence[_T]): data: List[_T] def __init__(self, initlist: Optional[Iterable[_T]] = ...) -> None: ... def __lt__(self, other: object) -> bool: ... def __le__(self, other: object) -> bool: ... def __gt__(self, other: object) -> bool: ... def __ge__(self, other: object) -> bool: ... def __contains__(self, item: object) -> bool: ... def __len__(self) -> int: ... @overload def __getitem__(self, i: int) -> _T: ... @overload def __getitem__(self, i: slice) -> MutableSequence[_T]: ... @overload def __setitem__(self, i: int, o: _T) -> None: ... @overload def __setitem__(self, i: slice, o: Iterable[_T]) -> None: ... def __delitem__(self, i: Union[int, slice]) -> None: ... def __add__(self: _S, other: Iterable[_T]) -> _S: ... def __iadd__(self: _S, other: Iterable[_T]) -> _S: ... def __mul__(self: _S, n: int) -> _S: ... def __imul__(self: _S, n: int) -> _S: ... def append(self, item: _T) -> None: ... def insert(self, i: int, item: _T) -> None: ... def pop(self, i: int = ...) -> _T: ... def remove(self, item: _T) -> None: ... def clear(self) -> None: ... def copy(self: _S) -> _S: ... def count(self, item: _T) -> int: ... def index(self, item: _T, *args: Any) -> int: ... def reverse(self) -> None: ... def sort(self, *args: Any, **kwds: Any) -> None: ... def extend(self, other: Iterable[_T]) -> None: ... _UserStringT = TypeVar("_UserStringT", bound=UserString) class UserString(Sequence[str]): data: str def __init__(self, seq: object) -> None: ... def __int__(self) -> int: ... def __float__(self) -> float: ... def __complex__(self) -> complex: ... def __getnewargs__(self) -> Tuple[str]: ... def __lt__(self, string: Union[str, UserString]) -> bool: ... def __le__(self, string: Union[str, UserString]) -> bool: ... def __gt__(self, string: Union[str, UserString]) -> bool: ... def __ge__(self, string: Union[str, UserString]) -> bool: ... def __contains__(self, char: object) -> bool: ... def __len__(self) -> int: ... # It should return a str to implement Sequence correctly, but it doesn't. def __getitem__(self: _UserStringT, i: Union[int, slice]) -> _UserStringT: ... # type: ignore def __add__(self: _UserStringT, other: object) -> _UserStringT: ... def __mul__(self: _UserStringT, n: int) -> _UserStringT: ... def __mod__(self: _UserStringT, args: Any) -> _UserStringT: ... def capitalize(self: _UserStringT) -> _UserStringT: ... def casefold(self: _UserStringT) -> _UserStringT: ... def center(self: _UserStringT, width: int, *args: Any) -> _UserStringT: ... def count(self, sub: Union[str, UserString], start: int = ..., end: int = ...) -> int: ... if sys.version_info >= (3, 8): def encode(self: _UserStringT, encoding: Optional[str] = ..., errors: Optional[str] = ...) -> bytes: ... else: def encode(self: _UserStringT, encoding: Optional[str] = ..., errors: Optional[str] = ...) -> _UserStringT: ... def endswith(self, suffix: Union[str, Tuple[str, ...]], start: int = ..., end: int = ...) -> bool: ... def expandtabs(self: _UserStringT, tabsize: int = ...) -> _UserStringT: ... def find(self, sub: Union[str, UserString], start: int = ..., end: int = ...) -> int: ... def format(self, *args: Any, **kwds: Any) -> str: ... def format_map(self, mapping: Mapping[str, Any]) -> str: ... def index(self, sub: str, start: int = ..., end: int = ...) -> int: ... def isalpha(self) -> bool: ... def isalnum(self) -> bool: ... def isdecimal(self) -> bool: ... def isdigit(self) -> bool: ... def isidentifier(self) -> bool: ... def islower(self) -> bool: ... def isnumeric(self) -> bool: ... def isprintable(self) -> bool: ... def isspace(self) -> bool: ... def istitle(self) -> bool: ... def isupper(self) -> bool: ... def join(self, seq: Iterable[str]) -> str: ... def ljust(self: _UserStringT, width: int, *args: Any) -> _UserStringT: ... def lower(self: _UserStringT) -> _UserStringT: ... def lstrip(self: _UserStringT, chars: Optional[str] = ...) -> _UserStringT: ... @staticmethod @overload def maketrans(x: Union[Dict[int, _T], Dict[str, _T], Dict[Union[str, int], _T]]) -> Dict[int, _T]: ... @staticmethod @overload def maketrans(x: str, y: str, z: str = ...) -> Dict[int, Union[int, None]]: ... def partition(self, sep: str) -> Tuple[str, str, str]: ... if sys.version_info >= (3, 9): def removeprefix(self: _UserStringT, __prefix: Union[str, UserString]) -> _UserStringT: ... def removesuffix(self: _UserStringT, __suffix: Union[str, UserString]) -> _UserStringT: ... def replace( self: _UserStringT, old: Union[str, UserString], new: Union[str, UserString], maxsplit: int = ... ) -> _UserStringT: ... def rfind(self, sub: Union[str, UserString], start: int = ..., end: int = ...) -> int: ... def rindex(self, sub: Union[str, UserString], start: int = ..., end: int = ...) -> int: ... def rjust(self: _UserStringT, width: int, *args: Any) -> _UserStringT: ... def rpartition(self, sep: str) -> Tuple[str, str, str]: ... def rstrip(self: _UserStringT, chars: Optional[str] = ...) -> _UserStringT: ... def split(self, sep: Optional[str] = ..., maxsplit: int = ...) -> List[str]: ... def rsplit(self, sep: Optional[str] = ..., maxsplit: int = ...) -> List[str]: ... def splitlines(self, keepends: bool = ...) -> List[str]: ... def startswith(self, prefix: Union[str, Tuple[str, ...]], start: int = ..., end: int = ...) -> bool: ... def strip(self: _UserStringT, chars: Optional[str] = ...) -> _UserStringT: ... def swapcase(self: _UserStringT) -> _UserStringT: ... def title(self: _UserStringT) -> _UserStringT: ... def translate(self: _UserStringT, *args: Any) -> _UserStringT: ... def upper(self: _UserStringT) -> _UserStringT: ... def zfill(self: _UserStringT, width: int) -> _UserStringT: ... class deque(MutableSequence[_T], Generic[_T]): @property def maxlen(self) -> Optional[int]: ... def __init__(self, iterable: Iterable[_T] = ..., maxlen: Optional[int] = ...) -> None: ... def append(self, x: _T) -> None: ... def appendleft(self, x: _T) -> None: ... def clear(self) -> None: ... def copy(self) -> deque[_T]: ... def count(self, x: _T) -> int: ... def extend(self, iterable: Iterable[_T]) -> None: ... def extendleft(self, iterable: Iterable[_T]) -> None: ... def insert(self, i: int, x: _T) -> None: ... def index(self, x: _T, start: int = ..., stop: int = ...) -> int: ... def pop(self) -> _T: ... # type: ignore def popleft(self) -> _T: ... def remove(self, value: _T) -> None: ... def reverse(self) -> None: ... def rotate(self, n: int = ...) -> None: ... def __len__(self) -> int: ... def __iter__(self) -> Iterator[_T]: ... def __str__(self) -> str: ... def __hash__(self) -> int: ... # These methods of deque don't really take slices, but we need to # define them as taking a slice to satisfy MutableSequence. @overload def __getitem__(self, index: int) -> _T: ... @overload def __getitem__(self, s: slice) -> MutableSequence[_T]: ... @overload def __setitem__(self, i: int, x: _T) -> None: ... @overload def __setitem__(self, s: slice, o: Iterable[_T]) -> None: ... @overload def __delitem__(self, i: int) -> None: ... @overload def __delitem__(self, s: slice) -> None: ... def __contains__(self, o: object) -> bool: ... def __reversed__(self) -> Iterator[_T]: ... def __iadd__(self: _S, iterable: Iterable[_T]) -> _S: ... def __add__(self, other: deque[_T]) -> deque[_T]: ... def __mul__(self, other: int) -> deque[_T]: ... def __imul__(self, other: int) -> None: ... class Counter(Dict[_T, int], Generic[_T]): @overload def __init__(self, __iterable: None = ..., **kwargs: int) -> None: ... @overload def __init__(self, __mapping: Mapping[_T, int]) -> None: ... @overload def __init__(self, __iterable: Iterable[_T]) -> None: ... def copy(self: _S) -> _S: ... def elements(self) -> Iterator[_T]: ... def most_common(self, n: Optional[int] = ...) -> List[Tuple[_T, int]]: ... @overload def subtract(self, __iterable: None = ...) -> None: ... @overload def subtract(self, __mapping: Mapping[_T, int]) -> None: ... @overload def subtract(self, __iterable: Iterable[_T]) -> None: ... # The Iterable[Tuple[...]] argument type is not actually desirable # (the tuples will be added as keys, breaking type safety) but # it's included so that the signature is compatible with # Dict.update. Not sure if we should use '# type: ignore' instead # and omit the type from the union. @overload def update(self, __m: Mapping[_T, int], **kwargs: int) -> None: ... @overload def update(self, __m: Union[Iterable[_T], Iterable[Tuple[_T, int]]], **kwargs: int) -> None: ... @overload def update(self, __m: None = ..., **kwargs: int) -> None: ... def __add__(self, other: Counter[_T]) -> Counter[_T]: ... def __sub__(self, other: Counter[_T]) -> Counter[_T]: ... def __and__(self, other: Counter[_T]) -> Counter[_T]: ... def __or__(self, other: Counter[_T]) -> Counter[_T]: ... # type: ignore def __pos__(self) -> Counter[_T]: ... def __neg__(self) -> Counter[_T]: ... def __iadd__(self, other: Counter[_T]) -> Counter[_T]: ... def __isub__(self, other: Counter[_T]) -> Counter[_T]: ... def __iand__(self, other: Counter[_T]) -> Counter[_T]: ... def __ior__(self, other: Counter[_T]) -> Counter[_T]: ... # type: ignore class _OrderedDictKeysView(KeysView[_KT], Reversible[_KT]): def __reversed__(self) -> Iterator[_KT]: ... class _OrderedDictItemsView(ItemsView[_KT, _VT], Reversible[Tuple[_KT, _VT]]): def __reversed__(self) -> Iterator[Tuple[_KT, _VT]]: ... class _OrderedDictValuesView(ValuesView[_VT], Reversible[_VT]): def __reversed__(self) -> Iterator[_VT]: ... class OrderedDict(Dict[_KT, _VT], Reversible[_KT], Generic[_KT, _VT]): def popitem(self, last: bool = ...) -> Tuple[_KT, _VT]: ... def move_to_end(self, key: _KT, last: bool = ...) -> None: ... def copy(self: _S) -> _S: ... def __reversed__(self) -> Iterator[_KT]: ... def keys(self) -> _OrderedDictKeysView[_KT]: ... def items(self) -> _OrderedDictItemsView[_KT, _VT]: ... def values(self) -> _OrderedDictValuesView[_VT]: ... class defaultdict(Dict[_KT, _VT], Generic[_KT, _VT]): default_factory: Optional[Callable[[], _VT]] @overload def __init__(self, **kwargs: _VT) -> None: ... @overload def __init__(self, default_factory: Optional[Callable[[], _VT]]) -> None: ... @overload def __init__(self, default_factory: Optional[Callable[[], _VT]], **kwargs: _VT) -> None: ... @overload def __init__(self, default_factory: Optional[Callable[[], _VT]], map: Mapping[_KT, _VT]) -> None: ... @overload def __init__(self, default_factory: Optional[Callable[[], _VT]], map: Mapping[_KT, _VT], **kwargs: _VT) -> None: ... @overload def __init__(self, default_factory: Optional[Callable[[], _VT]], iterable: Iterable[Tuple[_KT, _VT]]) -> None: ... @overload def __init__( self, default_factory: Optional[Callable[[], _VT]], iterable: Iterable[Tuple[_KT, _VT]], **kwargs: _VT ) -> None: ... def __missing__(self, key: _KT) -> _VT: ... # TODO __reversed__ def copy(self: _S) -> _S: ... class ChainMap(MutableMapping[_KT, _VT], Generic[_KT, _VT]): def __init__(self, *maps: Mapping[_KT, _VT]) -> None: ... @property def maps(self) -> List[Mapping[_KT, _VT]]: ... def new_child(self, m: Mapping[_KT, _VT] = ...) -> typing.ChainMap[_KT, _VT]: ... @property def parents(self) -> typing.ChainMap[_KT, _VT]: ... def __setitem__(self, k: _KT, v: _VT) -> None: ... def __delitem__(self, v: _KT) -> None: ... def __getitem__(self, k: _KT) -> _VT: ... def __iter__(self) -> Iterator[_KT]: ... def __len__(self) -> int: ... def __missing__(self, key: _KT) -> _VT: ... # undocumented ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/collections/abc.pyi0000664000175000017500000000135000000000000024701 0ustar00davedave00000000000000from . import ( AsyncGenerator as AsyncGenerator, AsyncIterable as AsyncIterable, AsyncIterator as AsyncIterator, Awaitable as Awaitable, ByteString as ByteString, Callable as Callable, Collection as Collection, Container as Container, Coroutine as Coroutine, Generator as Generator, Hashable as Hashable, ItemsView as ItemsView, Iterable as Iterable, Iterator as Iterator, KeysView as KeysView, Mapping as Mapping, MappingView as MappingView, MutableMapping as MutableMapping, MutableSequence as MutableSequence, MutableSet as MutableSet, Reversible as Reversible, Sequence as Sequence, Set as Set, Sized as Sized, ValuesView as ValuesView, ) ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/compileall.pyi0000664000175000017500000000644700000000000023773 0ustar00davedave00000000000000import sys from _typeshed import AnyPath from typing import Any, Optional, Pattern if sys.version_info >= (3, 7): from py_compile import PycInvalidationMode if sys.version_info >= (3, 9): def compile_dir( dir: AnyPath, maxlevels: Optional[int] = ..., ddir: Optional[AnyPath] = ..., force: bool = ..., rx: Optional[Pattern[Any]] = ..., quiet: int = ..., legacy: bool = ..., optimize: int = ..., workers: int = ..., invalidation_mode: Optional[PycInvalidationMode] = ..., *, stripdir: Optional[str] = ..., # TODO: change to Optional[AnyPath] once https://bugs.python.org/issue40447 is resolved prependdir: Optional[AnyPath] = ..., limit_sl_dest: Optional[AnyPath] = ..., hardlink_dupes: bool = ..., ) -> int: ... def compile_file( fullname: AnyPath, ddir: Optional[AnyPath] = ..., force: bool = ..., rx: Optional[Pattern[Any]] = ..., quiet: int = ..., legacy: bool = ..., optimize: int = ..., invalidation_mode: Optional[PycInvalidationMode] = ..., *, stripdir: Optional[str] = ..., # TODO: change to Optional[AnyPath] once https://bugs.python.org/issue40447 is resolved prependdir: Optional[AnyPath] = ..., limit_sl_dest: Optional[AnyPath] = ..., hardlink_dupes: bool = ..., ) -> int: ... elif sys.version_info >= (3, 7): def compile_dir( dir: AnyPath, maxlevels: int = ..., ddir: Optional[AnyPath] = ..., force: bool = ..., rx: Optional[Pattern[Any]] = ..., quiet: int = ..., legacy: bool = ..., optimize: int = ..., workers: int = ..., invalidation_mode: Optional[PycInvalidationMode] = ..., ) -> int: ... def compile_file( fullname: AnyPath, ddir: Optional[AnyPath] = ..., force: bool = ..., rx: Optional[Pattern[Any]] = ..., quiet: int = ..., legacy: bool = ..., optimize: int = ..., invalidation_mode: Optional[PycInvalidationMode] = ..., ) -> int: ... else: # rx can be any object with a 'search' method; once we have Protocols we can change the type def compile_dir( dir: AnyPath, maxlevels: int = ..., ddir: Optional[AnyPath] = ..., force: bool = ..., rx: Optional[Pattern[Any]] = ..., quiet: int = ..., legacy: bool = ..., optimize: int = ..., workers: int = ..., ) -> int: ... def compile_file( fullname: AnyPath, ddir: Optional[AnyPath] = ..., force: bool = ..., rx: Optional[Pattern[Any]] = ..., quiet: int = ..., legacy: bool = ..., optimize: int = ..., ) -> int: ... if sys.version_info >= (3, 7): def compile_path( skip_curdir: bool = ..., maxlevels: int = ..., force: bool = ..., quiet: int = ..., legacy: bool = ..., optimize: int = ..., invalidation_mode: Optional[PycInvalidationMode] = ..., ) -> int: ... else: def compile_path( skip_curdir: bool = ..., maxlevels: int = ..., force: bool = ..., quiet: int = ..., legacy: bool = ..., optimize: int = ..., ) -> int: ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4303794 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/concurrent/0000775000175000017500000000000000000000000023276 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/concurrent/__init__.pyi0000664000175000017500000000000000000000000025546 0ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4303794 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/concurrent/futures/0000775000175000017500000000000000000000000024773 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/concurrent/futures/__init__.pyi0000664000175000017500000000116500000000000027260 0ustar00davedave00000000000000import sys from ._base import ( ALL_COMPLETED as ALL_COMPLETED, FIRST_COMPLETED as FIRST_COMPLETED, FIRST_EXCEPTION as FIRST_EXCEPTION, CancelledError as CancelledError, Executor as Executor, Future as Future, TimeoutError as TimeoutError, as_completed as as_completed, wait as wait, ) from .process import ProcessPoolExecutor as ProcessPoolExecutor from .thread import ThreadPoolExecutor as ThreadPoolExecutor if sys.version_info >= (3, 8): from ._base import InvalidStateError as InvalidStateError if sys.version_info >= (3, 7): from ._base import BrokenExecutor as BrokenExecutor ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/concurrent/futures/_base.pyi0000664000175000017500000001110400000000000026564 0ustar00davedave00000000000000import sys import threading from abc import abstractmethod from logging import Logger from typing import ( Any, Callable, Container, Generic, Iterable, Iterator, List, Optional, Protocol, Sequence, Set, TypeVar, overload, ) if sys.version_info >= (3, 9): from types import GenericAlias FIRST_COMPLETED: str FIRST_EXCEPTION: str ALL_COMPLETED: str PENDING: str RUNNING: str CANCELLED: str CANCELLED_AND_NOTIFIED: str FINISHED: str LOGGER: Logger class Error(Exception): ... class CancelledError(Error): ... class TimeoutError(Error): ... if sys.version_info >= (3, 8): class InvalidStateError(Error): ... if sys.version_info >= (3, 7): class BrokenExecutor(RuntimeError): ... _T = TypeVar("_T") _T_co = TypeVar("_T_co", covariant=True) # Copied over Collection implementation as it does not exist in Python 2 and <3.6. # Also to solve pytype issues with _Collection. class _Collection(Iterable[_T_co], Container[_T_co], Protocol[_T_co]): # Implement Sized (but don't have it as a base class). @abstractmethod def __len__(self) -> int: ... class Future(Generic[_T]): def __init__(self) -> None: ... def cancel(self) -> bool: ... def cancelled(self) -> bool: ... def running(self) -> bool: ... def done(self) -> bool: ... def add_done_callback(self, fn: Callable[[Future[_T]], Any]) -> None: ... def result(self, timeout: Optional[float] = ...) -> _T: ... def set_running_or_notify_cancel(self) -> bool: ... def set_result(self, result: _T) -> None: ... def exception(self, timeout: Optional[float] = ...) -> Optional[BaseException]: ... def set_exception(self, exception: Optional[BaseException]) -> None: ... if sys.version_info >= (3, 9): def __class_getitem__(cls, item: Any) -> GenericAlias: ... class Executor: if sys.version_info >= (3, 9): def submit(self, __fn: Callable[..., _T], *args: Any, **kwargs: Any) -> Future[_T]: ... else: def submit(self, fn: Callable[..., _T], *args: Any, **kwargs: Any) -> Future[_T]: ... def map( self, fn: Callable[..., _T], *iterables: Iterable[Any], timeout: Optional[float] = ..., chunksize: int = ... ) -> Iterator[_T]: ... if sys.version_info >= (3, 9): def shutdown(self, wait: bool = ..., *, cancel_futures: bool = ...) -> None: ... else: def shutdown(self, wait: bool = ...) -> None: ... def __enter__(self: _T) -> _T: ... def __exit__(self, exc_type: Any, exc_val: Any, exc_tb: Any) -> Optional[bool]: ... def as_completed(fs: Iterable[Future[_T]], timeout: Optional[float] = ...) -> Iterator[Future[_T]]: ... # Ideally this would be a namedtuple, but mypy doesn't support generic tuple types. See #1976 class DoneAndNotDoneFutures(Sequence[_T]): done: Set[Future[_T]] not_done: Set[Future[_T]] def __new__(_cls, done: Set[Future[_T]], not_done: Set[Future[_T]]) -> DoneAndNotDoneFutures[_T]: ... def __len__(self) -> int: ... @overload def __getitem__(self, i: int) -> _T: ... @overload def __getitem__(self, s: slice) -> DoneAndNotDoneFutures[_T]: ... def wait(fs: Iterable[Future[_T]], timeout: Optional[float] = ..., return_when: str = ...) -> DoneAndNotDoneFutures[_T]: ... class _Waiter: event: threading.Event finished_futures: List[Future[Any]] def __init__(self) -> None: ... def add_result(self, future: Future[Any]) -> None: ... def add_exception(self, future: Future[Any]) -> None: ... def add_cancelled(self, future: Future[Any]) -> None: ... class _AsCompletedWaiter(_Waiter): lock: threading.Lock def __init__(self) -> None: ... def add_result(self, future: Future[Any]) -> None: ... def add_exception(self, future: Future[Any]) -> None: ... def add_cancelled(self, future: Future[Any]) -> None: ... class _FirstCompletedWaiter(_Waiter): def add_result(self, future: Future[Any]) -> None: ... def add_exception(self, future: Future[Any]) -> None: ... def add_cancelled(self, future: Future[Any]) -> None: ... class _AllCompletedWaiter(_Waiter): num_pending_calls: int stop_on_exception: bool lock: threading.Lock def __init__(self, num_pending_calls: int, stop_on_exception: bool) -> None: ... def add_result(self, future: Future[Any]) -> None: ... def add_exception(self, future: Future[Any]) -> None: ... def add_cancelled(self, future: Future[Any]) -> None: ... class _AcquireFutures: futures: Iterable[Future[Any]] def __init__(self, futures: Iterable[Future[Any]]) -> None: ... def __enter__(self) -> None: ... def __exit__(self, *args: Any) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/concurrent/futures/process.pyi0000664000175000017500000000144400000000000027177 0ustar00davedave00000000000000import sys from typing import Any, Callable, Optional, Tuple from ._base import Executor EXTRA_QUEUED_CALLS: Any if sys.version_info >= (3, 7): from ._base import BrokenExecutor class BrokenProcessPool(BrokenExecutor): ... else: class BrokenProcessPool(RuntimeError): ... if sys.version_info >= (3, 7): from multiprocessing.context import BaseContext class ProcessPoolExecutor(Executor): def __init__( self, max_workers: Optional[int] = ..., mp_context: Optional[BaseContext] = ..., initializer: Optional[Callable[..., None]] = ..., initargs: Tuple[Any, ...] = ..., ) -> None: ... else: class ProcessPoolExecutor(Executor): def __init__(self, max_workers: Optional[int] = ...) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/concurrent/futures/thread.pyi0000664000175000017500000000261500000000000026771 0ustar00davedave00000000000000import queue import sys from typing import Any, Callable, Generic, Iterable, Mapping, Optional, Tuple, TypeVar from ._base import Executor, Future if sys.version_info >= (3, 7): from ._base import BrokenExecutor class BrokenThreadPool(BrokenExecutor): ... if sys.version_info >= (3, 9): from types import GenericAlias _S = TypeVar("_S") class ThreadPoolExecutor(Executor): if sys.version_info >= (3, 7): _work_queue: queue.SimpleQueue else: _work_queue: queue.Queue if sys.version_info >= (3, 7): def __init__( self, max_workers: Optional[int] = ..., thread_name_prefix: str = ..., initializer: Optional[Callable[..., None]] = ..., initargs: Tuple[Any, ...] = ..., ) -> None: ... elif sys.version_info >= (3, 6): def __init__(self, max_workers: Optional[int] = ..., thread_name_prefix: str = ...) -> None: ... else: def __init__(self, max_workers: Optional[int] = ...) -> None: ... class _WorkItem(Generic[_S]): future: Future[_S] fn: Callable[..., _S] args: Iterable[Any] kwargs: Mapping[str, Any] def __init__(self, future: Future[_S], fn: Callable[..., _S], args: Iterable[Any], kwargs: Mapping[str, Any]) -> None: ... def run(self) -> None: ... if sys.version_info >= (3, 9): def __class_getitem__(cls, item: Any) -> GenericAlias: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/configparser.pyi0000664000175000017500000002355700000000000024335 0ustar00davedave00000000000000import sys from _typeshed import AnyPath, StrPath, SupportsWrite from typing import ( AbstractSet, Any, Callable, ClassVar, Dict, Iterable, Iterator, List, Mapping, MutableMapping, Optional, Pattern, Sequence, Tuple, Type, TypeVar, Union, overload, ) from typing_extensions import Literal # Internal type aliases _section = Mapping[str, str] _parser = MutableMapping[str, _section] _converter = Callable[[str], Any] _converters = Dict[str, _converter] _T = TypeVar("_T") if sys.version_info >= (3, 7): _Path = AnyPath else: _Path = StrPath DEFAULTSECT: str MAX_INTERPOLATION_DEPTH: int class Interpolation: def before_get(self, parser: _parser, section: str, option: str, value: str, defaults: _section) -> str: ... def before_set(self, parser: _parser, section: str, option: str, value: str) -> str: ... def before_read(self, parser: _parser, section: str, option: str, value: str) -> str: ... def before_write(self, parser: _parser, section: str, option: str, value: str) -> str: ... class BasicInterpolation(Interpolation): ... class ExtendedInterpolation(Interpolation): ... class LegacyInterpolation(Interpolation): ... class RawConfigParser(_parser): _SECT_TMPL: ClassVar[str] = ... # Undocumented _OPT_TMPL: ClassVar[str] = ... # Undocumented _OPT_NV_TMPL: ClassVar[str] = ... # Undocumented SECTCRE: Pattern[str] = ... OPTCRE: ClassVar[Pattern[str]] = ... OPTCRE_NV: ClassVar[Pattern[str]] = ... # Undocumented NONSPACECRE: ClassVar[Pattern[str]] = ... # Undocumented BOOLEAN_STATES: ClassVar[Mapping[str, bool]] = ... # Undocumented default_section: str @overload def __init__( self, defaults: Optional[Mapping[str, Optional[str]]] = ..., dict_type: Type[Mapping[str, str]] = ..., allow_no_value: Literal[True] = ..., *, delimiters: Sequence[str] = ..., comment_prefixes: Sequence[str] = ..., inline_comment_prefixes: Optional[Sequence[str]] = ..., strict: bool = ..., empty_lines_in_values: bool = ..., default_section: str = ..., interpolation: Optional[Interpolation] = ..., converters: _converters = ..., ) -> None: ... @overload def __init__( self, defaults: Optional[_section] = ..., dict_type: Type[Mapping[str, str]] = ..., allow_no_value: bool = ..., *, delimiters: Sequence[str] = ..., comment_prefixes: Sequence[str] = ..., inline_comment_prefixes: Optional[Sequence[str]] = ..., strict: bool = ..., empty_lines_in_values: bool = ..., default_section: str = ..., interpolation: Optional[Interpolation] = ..., converters: _converters = ..., ) -> None: ... def __len__(self) -> int: ... def __getitem__(self, section: str) -> SectionProxy: ... def __setitem__(self, section: str, options: _section) -> None: ... def __delitem__(self, section: str) -> None: ... def __iter__(self) -> Iterator[str]: ... def defaults(self) -> _section: ... def sections(self) -> List[str]: ... def add_section(self, section: str) -> None: ... def has_section(self, section: str) -> bool: ... def options(self, section: str) -> List[str]: ... def has_option(self, section: str, option: str) -> bool: ... def read(self, filenames: Union[_Path, Iterable[_Path]], encoding: Optional[str] = ...) -> List[str]: ... def read_file(self, f: Iterable[str], source: Optional[str] = ...) -> None: ... def read_string(self, string: str, source: str = ...) -> None: ... def read_dict(self, dictionary: Mapping[str, Mapping[str, Any]], source: str = ...) -> None: ... def readfp(self, fp: Iterable[str], filename: Optional[str] = ...) -> None: ... # These get* methods are partially applied (with the same names) in # SectionProxy; the stubs should be kept updated together @overload def getint(self, section: str, option: str, *, raw: bool = ..., vars: Optional[_section] = ...) -> int: ... @overload def getint( self, section: str, option: str, *, raw: bool = ..., vars: Optional[_section] = ..., fallback: _T = ... ) -> Union[int, _T]: ... @overload def getfloat(self, section: str, option: str, *, raw: bool = ..., vars: Optional[_section] = ...) -> float: ... @overload def getfloat( self, section: str, option: str, *, raw: bool = ..., vars: Optional[_section] = ..., fallback: _T = ... ) -> Union[float, _T]: ... @overload def getboolean(self, section: str, option: str, *, raw: bool = ..., vars: Optional[_section] = ...) -> bool: ... @overload def getboolean( self, section: str, option: str, *, raw: bool = ..., vars: Optional[_section] = ..., fallback: _T = ... ) -> Union[bool, _T]: ... def _get_conv( self, section: str, option: str, conv: Callable[[str], _T], *, raw: bool = ..., vars: Optional[_section] = ..., fallback: _T = ..., ) -> _T: ... # This is incompatible with MutableMapping so we ignore the type @overload # type: ignore def get(self, section: str, option: str, *, raw: bool = ..., vars: Optional[_section] = ...) -> str: ... @overload def get( self, section: str, option: str, *, raw: bool = ..., vars: Optional[_section] = ..., fallback: _T ) -> Union[str, _T]: ... @overload def items(self, *, raw: bool = ..., vars: Optional[_section] = ...) -> AbstractSet[Tuple[str, SectionProxy]]: ... @overload def items(self, section: str, raw: bool = ..., vars: Optional[_section] = ...) -> List[Tuple[str, str]]: ... def set(self, section: str, option: str, value: Optional[str] = ...) -> None: ... def write(self, fp: SupportsWrite[str], space_around_delimiters: bool = ...) -> None: ... def remove_option(self, section: str, option: str) -> bool: ... def remove_section(self, section: str) -> bool: ... def optionxform(self, optionstr: str) -> str: ... class ConfigParser(RawConfigParser): ... class SafeConfigParser(ConfigParser): ... class SectionProxy(MutableMapping[str, str]): def __init__(self, parser: RawConfigParser, name: str) -> None: ... def __getitem__(self, key: str) -> str: ... def __setitem__(self, key: str, value: str) -> None: ... def __delitem__(self, key: str) -> None: ... def __contains__(self, key: object) -> bool: ... def __len__(self) -> int: ... def __iter__(self) -> Iterator[str]: ... @property def parser(self) -> RawConfigParser: ... @property def name(self) -> str: ... def get(self, option: str, fallback: Optional[str] = ..., *, raw: bool = ..., vars: Optional[_section] = ..., _impl: Optional[Any] = ..., **kwargs: Any) -> str: ... # type: ignore # These are partially-applied version of the methods with the same names in # RawConfigParser; the stubs should be kept updated together @overload def getint(self, option: str, *, raw: bool = ..., vars: Optional[_section] = ...) -> int: ... @overload def getint(self, option: str, *, raw: bool = ..., vars: Optional[_section] = ..., fallback: _T = ...) -> Union[int, _T]: ... @overload def getfloat(self, option: str, *, raw: bool = ..., vars: Optional[_section] = ...) -> float: ... @overload def getfloat( self, option: str, *, raw: bool = ..., vars: Optional[_section] = ..., fallback: _T = ... ) -> Union[float, _T]: ... @overload def getboolean(self, option: str, *, raw: bool = ..., vars: Optional[_section] = ...) -> bool: ... @overload def getboolean( self, option: str, *, raw: bool = ..., vars: Optional[_section] = ..., fallback: _T = ... ) -> Union[bool, _T]: ... # SectionProxy can have arbitrary attributes when custon converters are used def __getattr__(self, key: str) -> Callable[..., Any]: ... class ConverterMapping(MutableMapping[str, Optional[_converter]]): GETTERCRE: Pattern[Any] def __init__(self, parser: RawConfigParser) -> None: ... def __getitem__(self, key: str) -> _converter: ... def __setitem__(self, key: str, value: Optional[_converter]) -> None: ... def __delitem__(self, key: str) -> None: ... def __iter__(self) -> Iterator[str]: ... def __len__(self) -> int: ... class Error(Exception): message: str def __init__(self, msg: str = ...) -> None: ... class NoSectionError(Error): section: str def __init__(self, section: str) -> None: ... class DuplicateSectionError(Error): section: str source: Optional[str] lineno: Optional[int] def __init__(self, section: str, source: Optional[str] = ..., lineno: Optional[int] = ...) -> None: ... class DuplicateOptionError(Error): section: str option: str source: Optional[str] lineno: Optional[int] def __init__(self, section: str, option: str, source: Optional[str] = ..., lineno: Optional[str] = ...) -> None: ... class NoOptionError(Error): section: str option: str def __init__(self, option: str, section: str) -> None: ... class InterpolationError(Error): section: str option: str def __init__(self, option: str, section: str, msg: str) -> None: ... class InterpolationDepthError(InterpolationError): def __init__(self, option: str, section: str, rawval: object) -> None: ... class InterpolationMissingOptionError(InterpolationError): reference: str def __init__(self, option: str, section: str, rawval: object, reference: str) -> None: ... class InterpolationSyntaxError(InterpolationError): ... class ParsingError(Error): source: str errors: List[Tuple[int, str]] def __init__(self, source: Optional[str] = ..., filename: Optional[str] = ...) -> None: ... def append(self, lineno: int, line: str) -> None: ... class MissingSectionHeaderError(ParsingError): lineno: int line: str def __init__(self, filename: str, lineno: int, line: str) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/copyreg.pyi0000664000175000017500000000134300000000000023310 0ustar00davedave00000000000000from typing import Any, Callable, Hashable, List, Optional, SupportsInt, Tuple, TypeVar, Union _Type = TypeVar("_Type", bound=type) _Reduce = Union[Tuple[Callable[..., _Type], Tuple[Any, ...]], Tuple[Callable[..., _Type], Tuple[Any, ...], Optional[Any]]] __all__: List[str] def pickle( ob_type: _Type, pickle_function: Callable[[_Type], Union[str, _Reduce[_Type]]], constructor_ob: Optional[Callable[[_Reduce[_Type]], _Type]] = ..., ) -> None: ... def constructor(object: Callable[[_Reduce[_Type]], _Type]) -> None: ... def add_extension(module: Hashable, name: Hashable, code: SupportsInt) -> None: ... def remove_extension(module: Hashable, name: Hashable, code: int) -> None: ... def clear_extension_cache() -> None: ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4303794 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/dbm/0000775000175000017500000000000000000000000021656 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/dbm/__init__.pyi0000664000175000017500000000166100000000000024144 0ustar00davedave00000000000000from types import TracebackType from typing import Iterator, MutableMapping, Optional, Type, Union from typing_extensions import Literal _KeyType = Union[str, bytes] _ValueType = Union[str, bytes] class _Database(MutableMapping[_KeyType, bytes]): def close(self) -> None: ... def __getitem__(self, key: _KeyType) -> bytes: ... def __setitem__(self, key: _KeyType, value: _ValueType) -> None: ... def __delitem__(self, key: _KeyType) -> None: ... def __iter__(self) -> Iterator[bytes]: ... def __len__(self) -> int: ... def __del__(self) -> None: ... def __enter__(self) -> _Database: ... def __exit__( self, exc_type: Optional[Type[BaseException]], exc_val: Optional[BaseException], exc_tb: Optional[TracebackType] ) -> None: ... class error(Exception): ... def whichdb(filename: str) -> str: ... def open(file: str, flag: Literal["r", "w", "c", "n"] = ..., mode: int = ...) -> _Database: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/dbm/dumb.pyi0000664000175000017500000000176200000000000023336 0ustar00davedave00000000000000from types import TracebackType from typing import Iterator, MutableMapping, Optional, Type, Union _KeyType = Union[str, bytes] _ValueType = Union[str, bytes] error = OSError class _Database(MutableMapping[_KeyType, bytes]): def __init__(self, filebasename: str, mode: str, flag: str = ...) -> None: ... def sync(self) -> None: ... def iterkeys(self) -> Iterator[bytes]: ... # undocumented def close(self) -> None: ... def __getitem__(self, key: _KeyType) -> bytes: ... def __setitem__(self, key: _KeyType, value: _ValueType) -> None: ... def __delitem__(self, key: _KeyType) -> None: ... def __iter__(self) -> Iterator[bytes]: ... def __len__(self) -> int: ... def __del__(self) -> None: ... def __enter__(self) -> _Database: ... def __exit__( self, exc_type: Optional[Type[BaseException]], exc_val: Optional[BaseException], exc_tb: Optional[TracebackType] ) -> None: ... def open(file: str, flag: str = ..., mode: int = ...) -> _Database: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/dbm/gnu.pyi0000664000175000017500000000252300000000000023174 0ustar00davedave00000000000000from types import TracebackType from typing import List, Optional, Type, TypeVar, Union, overload _T = TypeVar("_T") _KeyType = Union[str, bytes] _ValueType = Union[str, bytes] class error(OSError): ... # Actual typename gdbm, not exposed by the implementation class _gdbm: def firstkey(self) -> Optional[bytes]: ... def nextkey(self, key: _KeyType) -> Optional[bytes]: ... def reorganize(self) -> None: ... def sync(self) -> None: ... def close(self) -> None: ... def __getitem__(self, item: _KeyType) -> bytes: ... def __setitem__(self, key: _KeyType, value: _ValueType) -> None: ... def __delitem__(self, key: _KeyType) -> None: ... def __len__(self) -> int: ... def __enter__(self) -> _gdbm: ... def __exit__( self, exc_type: Optional[Type[BaseException]], exc_val: Optional[BaseException], exc_tb: Optional[TracebackType] ) -> None: ... @overload def get(self, k: _KeyType) -> Optional[bytes]: ... @overload def get(self, k: _KeyType, default: Union[bytes, _T]) -> Union[bytes, _T]: ... def keys(self) -> List[bytes]: ... def setdefault(self, k: _KeyType, default: _ValueType = ...) -> bytes: ... # Don't exist at runtime __new__: None # type: ignore __init__: None # type: ignore def open(__filename: str, __flags: str = ..., __mode: int = ...) -> _gdbm: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/dbm/ndbm.pyi0000664000175000017500000000232400000000000023322 0ustar00davedave00000000000000from types import TracebackType from typing import List, Optional, Type, TypeVar, Union, overload _T = TypeVar("_T") _KeyType = Union[str, bytes] _ValueType = Union[str, bytes] class error(OSError): ... library: str = ... # Actual typename dbm, not exposed by the implementation class _dbm: def close(self) -> None: ... def __getitem__(self, item: _KeyType) -> bytes: ... def __setitem__(self, key: _KeyType, value: _ValueType) -> None: ... def __delitem__(self, key: _KeyType) -> None: ... def __len__(self) -> int: ... def __del__(self) -> None: ... def __enter__(self) -> _dbm: ... def __exit__( self, exc_type: Optional[Type[BaseException]], exc_val: Optional[BaseException], exc_tb: Optional[TracebackType] ) -> None: ... @overload def get(self, k: _KeyType) -> Optional[bytes]: ... @overload def get(self, k: _KeyType, default: Union[bytes, _T]) -> Union[bytes, _T]: ... def keys(self) -> List[bytes]: ... def setdefault(self, k: _KeyType, default: _ValueType = ...) -> bytes: ... # Don't exist at runtime __new__: None # type: ignore __init__: None # type: ignore def open(__filename: str, __flags: str = ..., __mode: int = ...) -> _dbm: ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4303794 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/distutils/0000775000175000017500000000000000000000000023140 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/distutils/__init__.pyi0000664000175000017500000000000000000000000025410 0ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/distutils/archive_util.pyi0000664000175000017500000000067700000000000026353 0ustar00davedave00000000000000from typing import Optional def make_archive( base_name: str, format: str, root_dir: Optional[str] = ..., base_dir: Optional[str] = ..., verbose: int = ..., dry_run: int = ..., ) -> str: ... def make_tarball(base_name: str, base_dir: str, compress: Optional[str] = ..., verbose: int = ..., dry_run: int = ...) -> str: ... def make_zipfile(base_name: str, base_dir: str, verbose: int = ..., dry_run: int = ...) -> str: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/distutils/bcppcompiler.pyi0000664000175000017500000000011600000000000026340 0ustar00davedave00000000000000from distutils.ccompiler import CCompiler class BCPPCompiler(CCompiler): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/distutils/ccompiler.pyi0000664000175000017500000001446100000000000025646 0ustar00davedave00000000000000from typing import Any, Callable, List, Optional, Tuple, Union _Macro = Union[Tuple[str], Tuple[str, Optional[str]]] def gen_lib_options( compiler: CCompiler, library_dirs: List[str], runtime_library_dirs: List[str], libraries: List[str] ) -> List[str]: ... def gen_preprocess_options(macros: List[_Macro], include_dirs: List[str]) -> List[str]: ... def get_default_compiler(osname: Optional[str] = ..., platform: Optional[str] = ...) -> str: ... def new_compiler( plat: Optional[str] = ..., compiler: Optional[str] = ..., verbose: int = ..., dry_run: int = ..., force: int = ... ) -> CCompiler: ... def show_compilers() -> None: ... class CCompiler: dry_run: bool force: bool verbose: bool output_dir: Optional[str] macros: List[_Macro] include_dirs: List[str] libraries: List[str] library_dirs: List[str] runtime_library_dirs: List[str] objects: List[str] def __init__(self, verbose: int = ..., dry_run: int = ..., force: int = ...) -> None: ... def add_include_dir(self, dir: str) -> None: ... def set_include_dirs(self, dirs: List[str]) -> None: ... def add_library(self, libname: str) -> None: ... def set_libraries(self, libnames: List[str]) -> None: ... def add_library_dir(self, dir: str) -> None: ... def set_library_dirs(self, dirs: List[str]) -> None: ... def add_runtime_library_dir(self, dir: str) -> None: ... def set_runtime_library_dirs(self, dirs: List[str]) -> None: ... def define_macro(self, name: str, value: Optional[str] = ...) -> None: ... def undefine_macro(self, name: str) -> None: ... def add_link_object(self, object: str) -> None: ... def set_link_objects(self, objects: List[str]) -> None: ... def detect_language(self, sources: Union[str, List[str]]) -> Optional[str]: ... def find_library_file(self, dirs: List[str], lib: str, debug: bool = ...) -> Optional[str]: ... def has_function( self, funcname: str, includes: Optional[List[str]] = ..., include_dirs: Optional[List[str]] = ..., libraries: Optional[List[str]] = ..., library_dirs: Optional[List[str]] = ..., ) -> bool: ... def library_dir_option(self, dir: str) -> str: ... def library_option(self, lib: str) -> str: ... def runtime_library_dir_option(self, dir: str) -> str: ... def set_executables(self, **args: str) -> None: ... def compile( self, sources: List[str], output_dir: Optional[str] = ..., macros: Optional[_Macro] = ..., include_dirs: Optional[List[str]] = ..., debug: bool = ..., extra_preargs: Optional[List[str]] = ..., extra_postargs: Optional[List[str]] = ..., depends: Optional[List[str]] = ..., ) -> List[str]: ... def create_static_lib( self, objects: List[str], output_libname: str, output_dir: Optional[str] = ..., debug: bool = ..., target_lang: Optional[str] = ..., ) -> None: ... def link( self, target_desc: str, objects: List[str], output_filename: str, output_dir: Optional[str] = ..., libraries: Optional[List[str]] = ..., library_dirs: Optional[List[str]] = ..., runtime_library_dirs: Optional[List[str]] = ..., export_symbols: Optional[List[str]] = ..., debug: bool = ..., extra_preargs: Optional[List[str]] = ..., extra_postargs: Optional[List[str]] = ..., build_temp: Optional[str] = ..., target_lang: Optional[str] = ..., ) -> None: ... def link_executable( self, objects: List[str], output_progname: str, output_dir: Optional[str] = ..., libraries: Optional[List[str]] = ..., library_dirs: Optional[List[str]] = ..., runtime_library_dirs: Optional[List[str]] = ..., debug: bool = ..., extra_preargs: Optional[List[str]] = ..., extra_postargs: Optional[List[str]] = ..., target_lang: Optional[str] = ..., ) -> None: ... def link_shared_lib( self, objects: List[str], output_libname: str, output_dir: Optional[str] = ..., libraries: Optional[List[str]] = ..., library_dirs: Optional[List[str]] = ..., runtime_library_dirs: Optional[List[str]] = ..., export_symbols: Optional[List[str]] = ..., debug: bool = ..., extra_preargs: Optional[List[str]] = ..., extra_postargs: Optional[List[str]] = ..., build_temp: Optional[str] = ..., target_lang: Optional[str] = ..., ) -> None: ... def link_shared_object( self, objects: List[str], output_filename: str, output_dir: Optional[str] = ..., libraries: Optional[List[str]] = ..., library_dirs: Optional[List[str]] = ..., runtime_library_dirs: Optional[List[str]] = ..., export_symbols: Optional[List[str]] = ..., debug: bool = ..., extra_preargs: Optional[List[str]] = ..., extra_postargs: Optional[List[str]] = ..., build_temp: Optional[str] = ..., target_lang: Optional[str] = ..., ) -> None: ... def preprocess( self, source: str, output_file: Optional[str] = ..., macros: Optional[List[_Macro]] = ..., include_dirs: Optional[List[str]] = ..., extra_preargs: Optional[List[str]] = ..., extra_postargs: Optional[List[str]] = ..., ) -> None: ... def executable_filename(self, basename: str, strip_dir: int = ..., output_dir: str = ...) -> str: ... def library_filename(self, libname: str, lib_type: str = ..., strip_dir: int = ..., output_dir: str = ...) -> str: ... def object_filenames(self, source_filenames: List[str], strip_dir: int = ..., output_dir: str = ...) -> List[str]: ... def shared_object_filename(self, basename: str, strip_dir: int = ..., output_dir: str = ...) -> str: ... def execute(self, func: Callable[..., None], args: Tuple[Any, ...], msg: Optional[str] = ..., level: int = ...) -> None: ... def spawn(self, cmd: List[str]) -> None: ... def mkpath(self, name: str, mode: int = ...) -> None: ... def move_file(self, src: str, dst: str) -> str: ... def announce(self, msg: str, level: int = ...) -> None: ... def warn(self, msg: str) -> None: ... def debug_print(self, msg: str) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/distutils/cmd.pyi0000664000175000017500000000536300000000000024435 0ustar00davedave00000000000000from abc import abstractmethod from distutils.dist import Distribution from typing import Any, Callable, Iterable, List, Optional, Tuple, Union class Command: sub_commands: List[Tuple[str, Optional[Callable[[Command], bool]]]] def __init__(self, dist: Distribution) -> None: ... @abstractmethod def initialize_options(self) -> None: ... @abstractmethod def finalize_options(self) -> None: ... @abstractmethod def run(self) -> None: ... def announce(self, msg: str, level: int = ...) -> None: ... def debug_print(self, msg: str) -> None: ... def ensure_string(self, option: str, default: Optional[str] = ...) -> None: ... def ensure_string_list(self, option: Union[str, List[str]]) -> None: ... def ensure_filename(self, option: str) -> None: ... def ensure_dirname(self, option: str) -> None: ... def get_command_name(self) -> str: ... def set_undefined_options(self, src_cmd: str, *option_pairs: Tuple[str, str]) -> None: ... def get_finalized_command(self, command: str, create: int = ...) -> Command: ... def reinitialize_command(self, command: Union[Command, str], reinit_subcommands: int = ...) -> Command: ... def run_command(self, command: str) -> None: ... def get_sub_commands(self) -> List[str]: ... def warn(self, msg: str) -> None: ... def execute(self, func: Callable[..., Any], args: Iterable[Any], msg: Optional[str] = ..., level: int = ...) -> None: ... def mkpath(self, name: str, mode: int = ...) -> None: ... def copy_file( self, infile: str, outfile: str, preserve_mode: int = ..., preserve_times: int = ..., link: Optional[str] = ..., level: Any = ..., ) -> Tuple[str, bool]: ... # level is not used def copy_tree( self, infile: str, outfile: str, preserve_mode: int = ..., preserve_times: int = ..., preserve_symlinks: int = ..., level: Any = ..., ) -> List[str]: ... # level is not used def move_file(self, src: str, dst: str, level: Any = ...) -> str: ... # level is not used def spawn(self, cmd: Iterable[str], search_path: int = ..., level: Any = ...) -> None: ... # level is not used def make_archive( self, base_name: str, format: str, root_dir: Optional[str] = ..., base_dir: Optional[str] = ..., owner: Optional[str] = ..., group: Optional[str] = ..., ) -> str: ... def make_file( self, infiles: Union[str, List[str], Tuple[str]], outfile: str, func: Callable[..., Any], args: List[Any], exec_msg: Optional[str] = ..., skip_msg: Optional[str] = ..., level: Any = ..., ) -> None: ... # level is not used ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4303794 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/distutils/command/0000775000175000017500000000000000000000000024556 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/distutils/command/__init__.pyi0000664000175000017500000000000000000000000027026 0ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/distutils/command/bdist.pyi0000664000175000017500000000000000000000000026374 0ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/distutils/command/bdist_dumb.pyi0000664000175000017500000000000000000000000027403 0ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/distutils/command/bdist_msi.pyi0000664000175000017500000000026600000000000027262 0ustar00davedave00000000000000from distutils.cmd import Command class bdist_msi(Command): def initialize_options(self) -> None: ... def finalize_options(self) -> None: ... def run(self) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/distutils/command/bdist_packager.pyi0000664000175000017500000000000000000000000030231 0ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/distutils/command/bdist_rpm.pyi0000664000175000017500000000000000000000000027252 0ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/distutils/command/bdist_wininst.pyi0000664000175000017500000000000000000000000030147 0ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/distutils/command/build.pyi0000664000175000017500000000000000000000000026366 0ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/distutils/command/build_clib.pyi0000664000175000017500000000000000000000000027357 0ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/distutils/command/build_ext.pyi0000664000175000017500000000000000000000000027246 0ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/distutils/command/build_py.pyi0000664000175000017500000000033100000000000027105 0ustar00davedave00000000000000from distutils.cmd import Command class build_py(Command): def initialize_options(self) -> None: ... def finalize_options(self) -> None: ... def run(self) -> None: ... class build_py_2to3(build_py): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/distutils/command/build_scripts.pyi0000664000175000017500000000000000000000000030135 0ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/distutils/command/check.pyi0000664000175000017500000000000000000000000026344 0ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/distutils/command/clean.pyi0000664000175000017500000000000000000000000026351 0ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/distutils/command/config.pyi0000664000175000017500000000576300000000000026561 0ustar00davedave00000000000000from distutils import log as log from distutils.ccompiler import CCompiler from distutils.core import Command as Command from distutils.errors import DistutilsExecError as DistutilsExecError from distutils.sysconfig import customize_compiler as customize_compiler from typing import Dict, List, Optional, Pattern, Sequence, Tuple, Union LANG_EXT: Dict[str, str] class config(Command): description: str = ... # Tuple is full name, short name, description user_options: Sequence[Tuple[str, Optional[str], str]] = ... compiler: Optional[Union[str, CCompiler]] = ... cc: Optional[str] = ... include_dirs: Optional[Sequence[str]] = ... libraries: Optional[Sequence[str]] = ... library_dirs: Optional[Sequence[str]] = ... noisy: int = ... dump_source: int = ... temp_files: Sequence[str] = ... def initialize_options(self) -> None: ... def finalize_options(self) -> None: ... def run(self) -> None: ... def try_cpp( self, body: Optional[str] = ..., headers: Optional[Sequence[str]] = ..., include_dirs: Optional[Sequence[str]] = ..., lang: str = ..., ) -> bool: ... def search_cpp( self, pattern: Union[Pattern[str], str], body: Optional[str] = ..., headers: Optional[Sequence[str]] = ..., include_dirs: Optional[Sequence[str]] = ..., lang: str = ..., ) -> bool: ... def try_compile( self, body: str, headers: Optional[Sequence[str]] = ..., include_dirs: Optional[Sequence[str]] = ..., lang: str = ... ) -> bool: ... def try_link( self, body: str, headers: Optional[Sequence[str]] = ..., include_dirs: Optional[Sequence[str]] = ..., libraries: Optional[Sequence[str]] = ..., library_dirs: Optional[Sequence[str]] = ..., lang: str = ..., ) -> bool: ... def try_run( self, body: str, headers: Optional[Sequence[str]] = ..., include_dirs: Optional[Sequence[str]] = ..., libraries: Optional[Sequence[str]] = ..., library_dirs: Optional[Sequence[str]] = ..., lang: str = ..., ) -> bool: ... def check_func( self, func: str, headers: Optional[Sequence[str]] = ..., include_dirs: Optional[Sequence[str]] = ..., libraries: Optional[Sequence[str]] = ..., library_dirs: Optional[Sequence[str]] = ..., decl: int = ..., call: int = ..., ) -> bool: ... def check_lib( self, library: str, library_dirs: Optional[Sequence[str]] = ..., headers: Optional[Sequence[str]] = ..., include_dirs: Optional[Sequence[str]] = ..., other_libraries: List[str] = ..., ) -> bool: ... def check_header( self, header: str, include_dirs: Optional[Sequence[str]] = ..., library_dirs: Optional[Sequence[str]] = ..., lang: str = ..., ) -> bool: ... def dump_file(filename: str, head: Optional[str] = ...) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/distutils/command/install.pyi0000664000175000017500000000055500000000000026754 0ustar00davedave00000000000000from distutils.cmd import Command from typing import Optional, Tuple SCHEME_KEYS: Tuple[str, ...] class install(Command): user: bool prefix: Optional[str] home: Optional[str] root: Optional[str] install_lib: Optional[str] def initialize_options(self) -> None: ... def finalize_options(self) -> None: ... def run(self) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/distutils/command/install_data.pyi0000664000175000017500000000000000000000000027726 0ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/distutils/command/install_egg_info.pyi0000664000175000017500000000057400000000000030612 0ustar00davedave00000000000000from distutils.cmd import Command from typing import ClassVar, List, Optional, Tuple class install_egg_info(Command): description: ClassVar[str] user_options: ClassVar[List[Tuple[str, Optional[str], str]]] def initialize_options(self) -> None: ... def finalize_options(self) -> None: ... def run(self) -> None: ... def get_outputs(self) -> List[str]: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/distutils/command/install_headers.pyi0000664000175000017500000000000000000000000030430 0ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/distutils/command/install_lib.pyi0000664000175000017500000000000000000000000027563 0ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/distutils/command/install_scripts.pyi0000664000175000017500000000000000000000000030504 0ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/distutils/command/register.pyi0000664000175000017500000000000000000000000027113 0ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/distutils/command/sdist.pyi0000664000175000017500000000000000000000000026415 0ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/distutils/command/upload.pyi0000664000175000017500000000042700000000000026570 0ustar00davedave00000000000000from distutils.config import PyPIRCCommand from typing import ClassVar, List class upload(PyPIRCCommand): description: ClassVar[str] boolean_options: ClassVar[List[str]] def run(self) -> None: ... def upload_file(self, command, pyversion, filename) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/distutils/config.pyi0000664000175000017500000000101300000000000025123 0ustar00davedave00000000000000from abc import abstractmethod from distutils.cmd import Command from typing import ClassVar, List, Optional, Tuple DEFAULT_PYPIRC: str class PyPIRCCommand(Command): DEFAULT_REPOSITORY: ClassVar[str] DEFAULT_REALM: ClassVar[str] repository: None realm: None user_options: ClassVar[List[Tuple[str, Optional[str], str]]] boolean_options: ClassVar[List[str]] def initialize_options(self) -> None: ... def finalize_options(self) -> None: ... @abstractmethod def run(self) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/distutils/core.pyi0000664000175000017500000000323000000000000024611 0ustar00davedave00000000000000from distutils.cmd import Command as Command from distutils.dist import Distribution as Distribution from distutils.extension import Extension as Extension from typing import Any, List, Mapping, Optional, Tuple, Type, Union def setup( *, name: str = ..., version: str = ..., description: str = ..., long_description: str = ..., author: str = ..., author_email: str = ..., maintainer: str = ..., maintainer_email: str = ..., url: str = ..., download_url: str = ..., packages: List[str] = ..., py_modules: List[str] = ..., scripts: List[str] = ..., ext_modules: List[Extension] = ..., classifiers: List[str] = ..., distclass: Type[Distribution] = ..., script_name: str = ..., script_args: List[str] = ..., options: Mapping[str, Any] = ..., license: str = ..., keywords: Union[List[str], str] = ..., platforms: Union[List[str], str] = ..., cmdclass: Mapping[str, Type[Command]] = ..., data_files: List[Tuple[str, List[str]]] = ..., package_dir: Mapping[str, str] = ..., obsoletes: List[str] = ..., provides: List[str] = ..., requires: List[str] = ..., command_packages: List[str] = ..., command_options: Mapping[str, Mapping[str, Tuple[Any, Any]]] = ..., package_data: Mapping[str, List[str]] = ..., include_package_data: bool = ..., libraries: List[str] = ..., headers: List[str] = ..., ext_package: str = ..., include_dirs: List[str] = ..., password: str = ..., fullname: str = ..., **attrs: Any, ) -> None: ... def run_setup(script_name: str, script_args: Optional[List[str]] = ..., stop_after: str = ...) -> Distribution: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/distutils/cygwinccompiler.pyi0000664000175000017500000000021200000000000027054 0ustar00davedave00000000000000from distutils.unixccompiler import UnixCCompiler class CygwinCCompiler(UnixCCompiler): ... class Mingw32CCompiler(CygwinCCompiler): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/distutils/debug.pyi0000664000175000017500000000001400000000000024744 0ustar00davedave00000000000000DEBUG: bool ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/distutils/dep_util.pyi0000664000175000017500000000037400000000000025474 0ustar00davedave00000000000000from typing import List, Tuple def newer(source: str, target: str) -> bool: ... def newer_pairwise(sources: List[str], targets: List[str]) -> List[Tuple[str, str]]: ... def newer_group(sources: List[str], target: str, missing: str = ...) -> bool: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/distutils/dir_util.pyi0000664000175000017500000000105300000000000025475 0ustar00davedave00000000000000from typing import List def mkpath(name: str, mode: int = ..., verbose: int = ..., dry_run: int = ...) -> List[str]: ... def create_tree(base_dir: str, files: List[str], mode: int = ..., verbose: int = ..., dry_run: int = ...) -> None: ... def copy_tree( src: str, dst: str, preserve_mode: int = ..., preserve_times: int = ..., preserve_symlinks: int = ..., update: int = ..., verbose: int = ..., dry_run: int = ..., ) -> List[str]: ... def remove_tree(directory: str, verbose: int = ..., dry_run: int = ...) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/distutils/dist.pyi0000664000175000017500000000477500000000000024643 0ustar00davedave00000000000000from _typeshed import AnyPath, SupportsWrite from distutils.cmd import Command from typing import IO, Any, Dict, Iterable, List, Mapping, Optional, Tuple, Type, Union class DistributionMetadata: def __init__(self, path: Optional[Union[int, AnyPath]] = ...) -> None: ... name: Optional[str] version: Optional[str] author: Optional[str] author_email: Optional[str] maintainer: Optional[str] maintainer_email: Optional[str] url: Optional[str] license: Optional[str] description: Optional[str] long_description: Optional[str] keywords: Optional[Union[str, List[str]]] platforms: Optional[Union[str, List[str]]] classifiers: Optional[Union[str, List[str]]] download_url: Optional[str] provides: Optional[List[str]] requires: Optional[List[str]] obsoletes: Optional[List[str]] def read_pkg_file(self, file: IO[str]) -> None: ... def write_pkg_info(self, base_dir: str) -> None: ... def write_pkg_file(self, file: SupportsWrite[str]) -> None: ... def get_name(self) -> str: ... def get_version(self) -> str: ... def get_fullname(self) -> str: ... def get_author(self) -> str: ... def get_author_email(self) -> str: ... def get_maintainer(self) -> str: ... def get_maintainer_email(self) -> str: ... def get_contact(self) -> str: ... def get_contact_email(self) -> str: ... def get_url(self) -> str: ... def get_license(self) -> str: ... def get_licence(self) -> str: ... def get_description(self) -> str: ... def get_long_description(self) -> str: ... def get_keywords(self) -> Union[str, List[str]]: ... def get_platforms(self) -> Union[str, List[str]]: ... def get_classifiers(self) -> Union[str, List[str]]: ... def get_download_url(self) -> str: ... def get_requires(self) -> List[str]: ... def set_requires(self, value: Iterable[str]) -> None: ... def get_provides(self) -> List[str]: ... def set_provides(self, value: Iterable[str]) -> None: ... def get_obsoletes(self) -> List[str]: ... def set_obsoletes(self, value: Iterable[str]) -> None: ... class Distribution: cmdclass: Dict[str, Type[Command]] metadata: DistributionMetadata def __init__(self, attrs: Optional[Mapping[str, Any]] = ...) -> None: ... def get_option_dict(self, command: str) -> Dict[str, Tuple[str, str]]: ... def parse_config_files(self, filenames: Optional[Iterable[str]] = ...) -> None: ... def get_command_obj(self, command: str, create: bool = ...) -> Optional[Command]: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/distutils/errors.pyi0000664000175000017500000000152400000000000025201 0ustar00davedave00000000000000class DistutilsError(Exception): ... class DistutilsModuleError(DistutilsError): ... class DistutilsClassError(DistutilsError): ... class DistutilsGetoptError(DistutilsError): ... class DistutilsArgError(DistutilsError): ... class DistutilsFileError(DistutilsError): ... class DistutilsOptionError(DistutilsError): ... class DistutilsSetupError(DistutilsError): ... class DistutilsPlatformError(DistutilsError): ... class DistutilsExecError(DistutilsError): ... class DistutilsInternalError(DistutilsError): ... class DistutilsTemplateError(DistutilsError): ... class DistutilsByteCompileError(DistutilsError): ... class CCompilerError(Exception): ... class PreprocessError(CCompilerError): ... class CompileError(CCompilerError): ... class LibError(CCompilerError): ... class LinkError(CCompilerError): ... class UnknownFileError(CCompilerError): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/distutils/extension.pyi0000664000175000017500000000134000000000000025675 0ustar00davedave00000000000000from typing import List, Optional, Tuple class Extension: def __init__( self, name: str, sources: List[str], include_dirs: List[str] = ..., define_macros: List[Tuple[str, Optional[str]]] = ..., undef_macros: List[str] = ..., library_dirs: List[str] = ..., libraries: List[str] = ..., runtime_library_dirs: List[str] = ..., extra_objects: List[str] = ..., extra_compile_args: List[str] = ..., extra_link_args: List[str] = ..., export_symbols: List[str] = ..., swig_opts: Optional[str] = ..., # undocumented depends: List[str] = ..., language: str = ..., optional: bool = ..., ) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/distutils/fancy_getopt.pyi0000664000175000017500000000153300000000000026347 0ustar00davedave00000000000000from typing import Any, List, Mapping, Optional, Tuple, Union, overload _Option = Tuple[str, Optional[str], str] _GR = Tuple[List[str], OptionDummy] def fancy_getopt( options: List[_Option], negative_opt: Mapping[_Option, _Option], object: Any, args: Optional[List[str]] ) -> Union[List[str], _GR]: ... def wrap_text(text: str, width: int) -> List[str]: ... class FancyGetopt: def __init__(self, option_table: Optional[List[_Option]] = ...) -> None: ... # TODO kinda wrong, `getopt(object=object())` is invalid @overload def getopt(self, args: Optional[List[str]] = ...) -> _GR: ... @overload def getopt(self, args: Optional[List[str]], object: Any) -> List[str]: ... def get_option_order(self) -> List[Tuple[str, str]]: ... def generate_help(self, header: Optional[str] = ...) -> List[str]: ... class OptionDummy: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/distutils/file_util.pyi0000664000175000017500000000066700000000000025650 0ustar00davedave00000000000000from typing import Optional, Sequence, Tuple def copy_file( src: str, dst: str, preserve_mode: bool = ..., preserve_times: bool = ..., update: bool = ..., link: Optional[str] = ..., verbose: bool = ..., dry_run: bool = ..., ) -> Tuple[str, str]: ... def move_file(src: str, dst: str, verbose: bool = ..., dry_run: bool = ...) -> str: ... def write_file(filename: str, contents: Sequence[str]) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/distutils/filelist.pyi0000664000175000017500000000002400000000000025472 0ustar00davedave00000000000000class FileList: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/distutils/log.pyi0000664000175000017500000000151500000000000024446 0ustar00davedave00000000000000from typing import Any DEBUG: int INFO: int WARN: int ERROR: int FATAL: int class Log: def __init__(self, threshold: int = ...) -> None: ... def log(self, level: int, msg: str, *args: Any) -> None: ... def debug(self, msg: str, *args: Any) -> None: ... def info(self, msg: str, *args: Any) -> None: ... def warn(self, msg: str, *args: Any) -> None: ... def error(self, msg: str, *args: Any) -> None: ... def fatal(self, msg: str, *args: Any) -> None: ... def log(level: int, msg: str, *args: Any) -> None: ... def debug(msg: str, *args: Any) -> None: ... def info(msg: str, *args: Any) -> None: ... def warn(msg: str, *args: Any) -> None: ... def error(msg: str, *args: Any) -> None: ... def fatal(msg: str, *args: Any) -> None: ... def set_threshold(level: int) -> int: ... def set_verbosity(v: int) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/distutils/msvccompiler.pyi0000664000175000017500000000011600000000000026364 0ustar00davedave00000000000000from distutils.ccompiler import CCompiler class MSVCCompiler(CCompiler): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/distutils/spawn.pyi0000664000175000017500000000034300000000000025013 0ustar00davedave00000000000000from typing import List, Optional def spawn(cmd: List[str], search_path: bool = ..., verbose: bool = ..., dry_run: bool = ...) -> None: ... def find_executable(executable: str, path: Optional[str] = ...) -> Optional[str]: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/distutils/sysconfig.pyi0000664000175000017500000000115400000000000025670 0ustar00davedave00000000000000from distutils.ccompiler import CCompiler from typing import Mapping, Optional, Union PREFIX: str EXEC_PREFIX: str def get_config_var(name: str) -> Union[int, str, None]: ... def get_config_vars(*args: str) -> Mapping[str, Union[int, str]]: ... def get_config_h_filename() -> str: ... def get_makefile_filename() -> str: ... def get_python_inc(plat_specific: bool = ..., prefix: Optional[str] = ...) -> str: ... def get_python_lib(plat_specific: bool = ..., standard_lib: bool = ..., prefix: Optional[str] = ...) -> str: ... def customize_compiler(compiler: CCompiler) -> None: ... def set_python_build() -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/distutils/text_file.pyi0000664000175000017500000000131400000000000025645 0ustar00davedave00000000000000from typing import IO, List, Optional, Tuple, Union class TextFile: def __init__( self, filename: Optional[str] = ..., file: Optional[IO[str]] = ..., *, strip_comments: bool = ..., lstrip_ws: bool = ..., rstrip_ws: bool = ..., skip_blanks: bool = ..., join_lines: bool = ..., collapse_join: bool = ..., ) -> None: ... def open(self, filename: str) -> None: ... def close(self) -> None: ... def warn(self, msg: str, line: Union[List[int], Tuple[int, int], int] = ...) -> None: ... def readline(self) -> Optional[str]: ... def readlines(self) -> List[str]: ... def unreadline(self, line: str) -> str: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/distutils/unixccompiler.pyi0000664000175000017500000000011700000000000026543 0ustar00davedave00000000000000from distutils.ccompiler import CCompiler class UnixCCompiler(CCompiler): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/distutils/util.pyi0000664000175000017500000000147500000000000024647 0ustar00davedave00000000000000from typing import Any, Callable, List, Mapping, Optional, Tuple def get_platform() -> str: ... def convert_path(pathname: str) -> str: ... def change_root(new_root: str, pathname: str) -> str: ... def check_environ() -> None: ... def subst_vars(s: str, local_vars: Mapping[str, str]) -> None: ... def split_quoted(s: str) -> List[str]: ... def execute( func: Callable[..., None], args: Tuple[Any, ...], msg: Optional[str] = ..., verbose: bool = ..., dry_run: bool = ... ) -> None: ... def strtobool(val: str) -> bool: ... def byte_compile( py_files: List[str], optimize: int = ..., force: bool = ..., prefix: Optional[str] = ..., base_dir: Optional[str] = ..., verbose: bool = ..., dry_run: bool = ..., direct: Optional[bool] = ..., ) -> None: ... def rfc822_escape(header: str) -> str: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/distutils/version.pyi0000664000175000017500000000262500000000000025355 0ustar00davedave00000000000000from abc import abstractmethod from typing import Optional, Pattern, Tuple, TypeVar, Union _T = TypeVar("_T", bound=Version) class Version: def __repr__(self) -> str: ... def __eq__(self, other: object) -> bool: ... def __lt__(self: _T, other: Union[_T, str]) -> bool: ... def __le__(self: _T, other: Union[_T, str]) -> bool: ... def __gt__(self: _T, other: Union[_T, str]) -> bool: ... def __ge__(self: _T, other: Union[_T, str]) -> bool: ... @abstractmethod def __init__(self, vstring: Optional[str] = ...) -> None: ... @abstractmethod def parse(self: _T, vstring: str) -> _T: ... @abstractmethod def __str__(self) -> str: ... @abstractmethod def _cmp(self: _T, other: Union[_T, str]) -> bool: ... class StrictVersion(Version): version_re: Pattern[str] version: Tuple[int, int, int] prerelease: Optional[Tuple[str, int]] def __init__(self, vstring: Optional[str] = ...) -> None: ... def parse(self: _T, vstring: str) -> _T: ... def __str__(self) -> str: ... def _cmp(self: _T, other: Union[_T, str]) -> bool: ... class LooseVersion(Version): component_re: Pattern[str] vstring: str version: Tuple[Union[str, int], ...] def __init__(self, vstring: Optional[str] = ...) -> None: ... def parse(self: _T, vstring: str) -> _T: ... def __str__(self) -> str: ... def _cmp(self: _T, other: Union[_T, str]) -> bool: ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4343793 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/email/0000775000175000017500000000000000000000000022203 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/email/__init__.pyi0000664000175000017500000000136500000000000024472 0ustar00davedave00000000000000from email.message import Message from email.policy import Policy from typing import IO, Callable def message_from_string(s: str, _class: Callable[[], Message] = ..., *, policy: Policy = ...) -> Message: ... def message_from_bytes(s: bytes, _class: Callable[[], Message] = ..., *, policy: Policy = ...) -> Message: ... def message_from_file(fp: IO[str], _class: Callable[[], Message] = ..., *, policy: Policy = ...) -> Message: ... def message_from_binary_file(fp: IO[bytes], _class: Callable[[], Message] = ..., *, policy: Policy = ...) -> Message: ... # Names in __all__ with no definition: # base64mime # charset # encoders # errors # feedparser # generator # header # iterators # message # mime # parser # quoprimime # utils ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/email/charset.pyi0000664000175000017500000000204600000000000024361 0ustar00davedave00000000000000from typing import Any, Iterator, List, Optional QP: int # undocumented BASE64: int # undocumented SHORTEST: int # undocumented class Charset: input_charset: str header_encoding: int body_encoding: int output_charset: Optional[str] input_codec: Optional[str] output_codec: Optional[str] def __init__(self, input_charset: str = ...) -> None: ... def get_body_encoding(self) -> str: ... def get_output_charset(self) -> Optional[str]: ... def header_encode(self, string: str) -> str: ... def header_encode_lines(self, string: str, maxlengths: Iterator[int]) -> List[str]: ... def body_encode(self, string: str) -> str: ... def __str__(self) -> str: ... def __eq__(self, other: Any) -> bool: ... def __ne__(self, other: Any) -> bool: ... def add_charset( charset: str, header_enc: Optional[int] = ..., body_enc: Optional[int] = ..., output_charset: Optional[str] = ... ) -> None: ... def add_alias(alias: str, canonical: str) -> None: ... def add_codec(charset: str, codecname: str) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/email/contentmanager.pyi0000664000175000017500000000075100000000000025736 0ustar00davedave00000000000000from email.message import Message from typing import Any, Callable class ContentManager: def __init__(self) -> None: ... def get_content(self, msg: Message, *args: Any, **kw: Any) -> Any: ... def set_content(self, msg: Message, obj: Any, *args: Any, **kw: Any) -> Any: ... def add_get_handler(self, key: str, handler: Callable[..., Any]) -> None: ... def add_set_handler(self, typekey: type, handler: Callable[..., Any]) -> None: ... raw_data_manager: ContentManager ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/email/encoders.pyi0000664000175000017500000000032600000000000024531 0ustar00davedave00000000000000from email.message import Message def encode_base64(msg: Message) -> None: ... def encode_quopri(msg: Message) -> None: ... def encode_7or8bit(msg: Message) -> None: ... def encode_noop(msg: Message) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/email/errors.pyi0000664000175000017500000000150100000000000024237 0ustar00davedave00000000000000class MessageError(Exception): ... class MessageParseError(MessageError): ... class HeaderParseError(MessageParseError): ... class BoundaryError(MessageParseError): ... class MultipartConversionError(MessageError, TypeError): ... class MessageDefect(ValueError): ... class NoBoundaryInMultipartDefect(MessageDefect): ... class StartBoundaryNotFoundDefect(MessageDefect): ... class FirstHeaderLineIsContinuationDefect(MessageDefect): ... class MisplacedEnvelopeHeaderDefect(MessageDefect): ... class MultipartInvariantViolationDefect(MessageDefect): ... class InvalidBase64PaddingDefect(MessageDefect): ... class InvalidBase64CharactersDefect(MessageDefect): ... class CloseBoundaryNotFoundDefect(MessageDefect): ... class MissingHeaderBodySeparatorDefect(MessageDefect): ... MalformedHeaderDefect = MissingHeaderBodySeparatorDefect ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/email/feedparser.pyi0000664000175000017500000000146700000000000025056 0ustar00davedave00000000000000from email.message import Message from email.policy import Policy from typing import Callable, Generic, TypeVar, overload _M = TypeVar("_M", bound=Message) class FeedParser(Generic[_M]): @overload def __init__(self: FeedParser[Message], _factory: None = ..., *, policy: Policy = ...) -> None: ... @overload def __init__(self, _factory: Callable[[], _M], *, policy: Policy = ...) -> None: ... def feed(self, data: str) -> None: ... def close(self) -> _M: ... class BytesFeedParser(Generic[_M]): @overload def __init__(self: BytesFeedParser[Message], _factory: None = ..., *, policy: Policy = ...) -> None: ... @overload def __init__(self, _factory: Callable[[], _M], *, policy: Policy = ...) -> None: ... def feed(self, data: bytes) -> None: ... def close(self) -> _M: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/email/generator.pyi0000664000175000017500000000170700000000000024721 0ustar00davedave00000000000000from email.message import Message from email.policy import Policy from typing import BinaryIO, Optional, TextIO class Generator: def clone(self, fp: TextIO) -> Generator: ... def write(self, s: str) -> None: ... def __init__(self, outfp: TextIO, mangle_from_: bool = ..., maxheaderlen: int = ..., *, policy: Policy = ...) -> None: ... def flatten(self, msg: Message, unixfrom: bool = ..., linesep: Optional[str] = ...) -> None: ... class BytesGenerator: def clone(self, fp: BinaryIO) -> BytesGenerator: ... def write(self, s: str) -> None: ... def __init__(self, outfp: BinaryIO, mangle_from_: bool = ..., maxheaderlen: int = ..., *, policy: Policy = ...) -> None: ... def flatten(self, msg: Message, unixfrom: bool = ..., linesep: Optional[str] = ...) -> None: ... class DecodedGenerator(Generator): def __init__(self, outfp: TextIO, mangle_from_: bool = ..., maxheaderlen: int = ..., *, fmt: Optional[str] = ...) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/email/header.pyi0000664000175000017500000000200100000000000024147 0ustar00davedave00000000000000from email.charset import Charset from typing import Any, List, Optional, Tuple, Union class Header: def __init__( self, s: Union[bytes, str, None] = ..., charset: Union[Charset, str, None] = ..., maxlinelen: Optional[int] = ..., header_name: Optional[str] = ..., continuation_ws: str = ..., errors: str = ..., ) -> None: ... def append(self, s: Union[bytes, str], charset: Union[Charset, str, None] = ..., errors: str = ...) -> None: ... def encode(self, splitchars: str = ..., maxlinelen: Optional[int] = ..., linesep: str = ...) -> str: ... def __str__(self) -> str: ... def __eq__(self, other: Any) -> bool: ... def __ne__(self, other: Any) -> bool: ... def decode_header(header: Union[Header, str]) -> List[Tuple[bytes, Optional[str]]]: ... def make_header( decoded_seq: List[Tuple[bytes, Optional[str]]], maxlinelen: Optional[int] = ..., header_name: Optional[str] = ..., continuation_ws: str = ..., ) -> Header: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/email/headerregistry.pyi0000664000175000017500000000541400000000000025753 0ustar00davedave00000000000000from datetime import datetime as _datetime from email.errors import MessageDefect from email.policy import Policy from typing import Any, Dict, Mapping, Optional, Tuple, Union class BaseHeader(str): @property def name(self) -> str: ... @property def defects(self) -> Tuple[MessageDefect, ...]: ... @property def max_count(self) -> Optional[int]: ... def __new__(cls, name: str, value: Any) -> BaseHeader: ... def init(self, *args: Any, **kw: Any) -> None: ... def fold(self, *, policy: Policy) -> str: ... class UnstructuredHeader: @classmethod def parse(cls, string: str, kwds: Dict[str, Any]) -> None: ... class UniqueUnstructuredHeader(UnstructuredHeader): ... class DateHeader: datetime: _datetime @classmethod def parse(cls, string: Union[str, _datetime], kwds: Dict[str, Any]) -> None: ... class UniqueDateHeader(DateHeader): ... class AddressHeader: groups: Tuple[Group, ...] addresses: Tuple[Address, ...] @classmethod def parse(cls, string: str, kwds: Dict[str, Any]) -> None: ... class UniqueAddressHeader(AddressHeader): ... class SingleAddressHeader(AddressHeader): @property def address(self) -> Address: ... class UniqueSingleAddressHeader(SingleAddressHeader): ... class MIMEVersionHeader: version: Optional[str] major: Optional[int] minor: Optional[int] @classmethod def parse(cls, string: str, kwds: Dict[str, Any]) -> None: ... class ParameterizedMIMEHeader: params: Mapping[str, Any] @classmethod def parse(cls, string: str, kwds: Dict[str, Any]) -> None: ... class ContentTypeHeader(ParameterizedMIMEHeader): content_type: str maintype: str subtype: str class ContentDispositionHeader(ParameterizedMIMEHeader): content_disposition: str class ContentTransferEncodingHeader: cte: str @classmethod def parse(cls, string: str, kwds: Dict[str, Any]) -> None: ... class HeaderRegistry: def __init__(self, base_class: BaseHeader = ..., default_class: BaseHeader = ..., use_default_map: bool = ...) -> None: ... def map_to_type(self, name: str, cls: BaseHeader) -> None: ... def __getitem__(self, name: str) -> BaseHeader: ... def __call__(self, name: str, value: Any) -> BaseHeader: ... class Address: display_name: str username: str domain: str @property def addr_spec(self) -> str: ... def __init__( self, display_name: str = ..., username: Optional[str] = ..., domain: Optional[str] = ..., addr_spec: Optional[str] = ... ) -> None: ... def __str__(self) -> str: ... class Group: display_name: Optional[str] addresses: Tuple[Address, ...] def __init__(self, display_name: Optional[str] = ..., addresses: Optional[Tuple[Address, ...]] = ...) -> None: ... def __str__(self) -> str: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/email/iterators.pyi0000664000175000017500000000041200000000000024737 0ustar00davedave00000000000000from email.message import Message from typing import Iterator, Optional def body_line_iterator(msg: Message, decode: bool = ...) -> Iterator[str]: ... def typed_subpart_iterator(msg: Message, maintype: str = ..., subtype: Optional[str] = ...) -> Iterator[str]: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/email/message.pyi0000664000175000017500000001111100000000000024345 0ustar00davedave00000000000000from email.charset import Charset from email.contentmanager import ContentManager from email.errors import MessageDefect from email.policy import Policy from typing import Any, Generator, Iterator, List, Optional, Sequence, Tuple, TypeVar, Union _T = TypeVar("_T") _PayloadType = Union[List[Message], str, bytes] _CharsetType = Union[Charset, str, None] _ParamsType = Union[str, None, Tuple[str, Optional[str], str]] _ParamType = Union[str, Tuple[Optional[str], Optional[str], str]] _HeaderType = Any class Message: preamble: Optional[str] epilogue: Optional[str] defects: List[MessageDefect] def __str__(self) -> str: ... def is_multipart(self) -> bool: ... def set_unixfrom(self, unixfrom: str) -> None: ... def get_unixfrom(self) -> Optional[str]: ... def attach(self, payload: Message) -> None: ... def get_payload(self, i: int = ..., decode: bool = ...) -> Any: ... # returns Optional[_PayloadType] def set_payload(self, payload: _PayloadType, charset: _CharsetType = ...) -> None: ... def set_charset(self, charset: _CharsetType) -> None: ... def get_charset(self) -> _CharsetType: ... def __len__(self) -> int: ... def __contains__(self, name: str) -> bool: ... def __getitem__(self, name: str) -> _HeaderType: ... def __setitem__(self, name: str, val: _HeaderType) -> None: ... def __delitem__(self, name: str) -> None: ... def keys(self) -> List[str]: ... def values(self) -> List[_HeaderType]: ... def items(self) -> List[Tuple[str, _HeaderType]]: ... def get(self, name: str, failobj: _T = ...) -> Union[_HeaderType, _T]: ... def get_all(self, name: str, failobj: _T = ...) -> Union[List[_HeaderType], _T]: ... def add_header(self, _name: str, _value: str, **_params: _ParamsType) -> None: ... def replace_header(self, _name: str, _value: _HeaderType) -> None: ... def get_content_type(self) -> str: ... def get_content_maintype(self) -> str: ... def get_content_subtype(self) -> str: ... def get_default_type(self) -> str: ... def set_default_type(self, ctype: str) -> None: ... def get_params(self, failobj: _T = ..., header: str = ..., unquote: bool = ...) -> Union[List[Tuple[str, str]], _T]: ... def get_param(self, param: str, failobj: _T = ..., header: str = ..., unquote: bool = ...) -> Union[_T, _ParamType]: ... def del_param(self, param: str, header: str = ..., requote: bool = ...) -> None: ... def set_type(self, type: str, header: str = ..., requote: bool = ...) -> None: ... def get_filename(self, failobj: _T = ...) -> Union[_T, str]: ... def get_boundary(self, failobj: _T = ...) -> Union[_T, str]: ... def set_boundary(self, boundary: str) -> None: ... def get_content_charset(self, failobj: _T = ...) -> Union[_T, str]: ... def get_charsets(self, failobj: _T = ...) -> Union[_T, List[str]]: ... def walk(self) -> Generator[Message, None, None]: ... def get_content_disposition(self) -> Optional[str]: ... def as_string(self, unixfrom: bool = ..., maxheaderlen: int = ..., policy: Optional[Policy] = ...) -> str: ... def as_bytes(self, unixfrom: bool = ..., policy: Optional[Policy] = ...) -> bytes: ... def __bytes__(self) -> bytes: ... def set_param( self, param: str, value: str, header: str = ..., requote: bool = ..., charset: str = ..., language: str = ..., replace: bool = ..., ) -> None: ... def __init__(self, policy: Policy = ...) -> None: ... class MIMEPart(Message): def get_body(self, preferencelist: Sequence[str] = ...) -> Optional[Message]: ... def iter_attachments(self) -> Iterator[Message]: ... def iter_parts(self) -> Iterator[Message]: ... def get_content(self, *args: Any, content_manager: Optional[ContentManager] = ..., **kw: Any) -> Any: ... def set_content(self, *args: Any, content_manager: Optional[ContentManager] = ..., **kw: Any) -> None: ... def make_related(self, boundary: Optional[str] = ...) -> None: ... def make_alternative(self, boundary: Optional[str] = ...) -> None: ... def make_mixed(self, boundary: Optional[str] = ...) -> None: ... def add_related(self, *args: Any, content_manager: Optional[ContentManager] = ..., **kw: Any) -> None: ... def add_alternative(self, *args: Any, content_manager: Optional[ContentManager] = ..., **kw: Any) -> None: ... def add_attachment(self, *args: Any, content_manager: Optional[ContentManager] = ..., **kw: Any) -> None: ... def clear(self) -> None: ... def clear_content(self) -> None: ... def is_attachment(self) -> bool: ... class EmailMessage(MIMEPart): ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4343793 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/email/mime/0000775000175000017500000000000000000000000023132 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/email/mime/__init__.pyi0000664000175000017500000000000000000000000025402 0ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/email/mime/application.pyi0000664000175000017500000000076300000000000026166 0ustar00davedave00000000000000from email.mime.nonmultipart import MIMENonMultipart from email.policy import Policy from typing import Callable, Optional, Tuple, Union _ParamsType = Union[str, None, Tuple[str, Optional[str], str]] class MIMEApplication(MIMENonMultipart): def __init__( self, _data: Union[str, bytes], _subtype: str = ..., _encoder: Callable[[MIMEApplication], None] = ..., *, policy: Optional[Policy] = ..., **_params: _ParamsType, ) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/email/mime/audio.pyi0000664000175000017500000000076600000000000024767 0ustar00davedave00000000000000from email.mime.nonmultipart import MIMENonMultipart from email.policy import Policy from typing import Callable, Optional, Tuple, Union _ParamsType = Union[str, None, Tuple[str, Optional[str], str]] class MIMEAudio(MIMENonMultipart): def __init__( self, _audiodata: Union[str, bytes], _subtype: Optional[str] = ..., _encoder: Callable[[MIMEAudio], None] = ..., *, policy: Optional[Policy] = ..., **_params: _ParamsType, ) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/email/mime/base.pyi0000664000175000017500000000050500000000000024567 0ustar00davedave00000000000000import email.message from email.policy import Policy from typing import Optional, Tuple, Union _ParamsType = Union[str, None, Tuple[str, Optional[str], str]] class MIMEBase(email.message.Message): def __init__(self, _maintype: str, _subtype: str, *, policy: Optional[Policy] = ..., **_params: _ParamsType) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/email/mime/image.pyi0000664000175000017500000000076600000000000024750 0ustar00davedave00000000000000from email.mime.nonmultipart import MIMENonMultipart from email.policy import Policy from typing import Callable, Optional, Tuple, Union _ParamsType = Union[str, None, Tuple[str, Optional[str], str]] class MIMEImage(MIMENonMultipart): def __init__( self, _imagedata: Union[str, bytes], _subtype: Optional[str] = ..., _encoder: Callable[[MIMEImage], None] = ..., *, policy: Optional[Policy] = ..., **_params: _ParamsType, ) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/email/mime/message.pyi0000664000175000017500000000044400000000000025303 0ustar00davedave00000000000000from email.message import Message from email.mime.nonmultipart import MIMENonMultipart from email.policy import Policy from typing import Optional class MIMEMessage(MIMENonMultipart): def __init__(self, _msg: Message, _subtype: str = ..., *, policy: Optional[Policy] = ...) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/email/mime/multipart.pyi0000664000175000017500000000077300000000000025705 0ustar00davedave00000000000000from email.message import Message from email.mime.base import MIMEBase from email.policy import Policy from typing import Optional, Sequence, Tuple, Union _ParamsType = Union[str, None, Tuple[str, Optional[str], str]] class MIMEMultipart(MIMEBase): def __init__( self, _subtype: str = ..., boundary: Optional[str] = ..., _subparts: Optional[Sequence[Message]] = ..., *, policy: Optional[Policy] = ..., **_params: _ParamsType, ) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/email/mime/nonmultipart.pyi0000664000175000017500000000011400000000000026405 0ustar00davedave00000000000000from email.mime.base import MIMEBase class MIMENonMultipart(MIMEBase): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/email/mime/text.pyi0000664000175000017500000000045100000000000024641 0ustar00davedave00000000000000from email.mime.nonmultipart import MIMENonMultipart from email.policy import Policy from typing import Optional class MIMEText(MIMENonMultipart): def __init__( self, _text: str, _subtype: str = ..., _charset: Optional[str] = ..., *, policy: Optional[Policy] = ... ) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/email/parser.pyi0000664000175000017500000000246000000000000024224 0ustar00davedave00000000000000import email.feedparser from email.message import Message from email.policy import Policy from typing import BinaryIO, Callable, TextIO FeedParser = email.feedparser.FeedParser BytesFeedParser = email.feedparser.BytesFeedParser class Parser: def __init__(self, _class: Callable[[], Message] = ..., *, policy: Policy = ...) -> None: ... def parse(self, fp: TextIO, headersonly: bool = ...) -> Message: ... def parsestr(self, text: str, headersonly: bool = ...) -> Message: ... class HeaderParser(Parser): def __init__(self, _class: Callable[[], Message] = ..., *, policy: Policy = ...) -> None: ... def parse(self, fp: TextIO, headersonly: bool = ...) -> Message: ... def parsestr(self, text: str, headersonly: bool = ...) -> Message: ... class BytesHeaderParser(BytesParser): def __init__(self, _class: Callable[[], Message] = ..., *, policy: Policy = ...) -> None: ... def parse(self, fp: BinaryIO, headersonly: bool = ...) -> Message: ... def parsebytes(self, text: bytes, headersonly: bool = ...) -> Message: ... class BytesParser: def __init__(self, _class: Callable[[], Message] = ..., *, policy: Policy = ...) -> None: ... def parse(self, fp: BinaryIO, headersonly: bool = ...) -> Message: ... def parsebytes(self, text: bytes, headersonly: bool = ...) -> Message: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/email/policy.pyi0000664000175000017500000000415700000000000024234 0ustar00davedave00000000000000from abc import abstractmethod from email.contentmanager import ContentManager from email.errors import MessageDefect from email.header import Header from email.message import Message from typing import Any, Callable, List, Optional, Tuple, Union class Policy: max_line_length: Optional[int] linesep: str cte_type: str raise_on_defect: bool mange_from: bool def __init__(self, **kw: Any) -> None: ... def clone(self, **kw: Any) -> Policy: ... def handle_defect(self, obj: Message, defect: MessageDefect) -> None: ... def register_defect(self, obj: Message, defect: MessageDefect) -> None: ... def header_max_count(self, name: str) -> Optional[int]: ... @abstractmethod def header_source_parse(self, sourcelines: List[str]) -> Tuple[str, str]: ... @abstractmethod def header_store_parse(self, name: str, value: str) -> Tuple[str, str]: ... @abstractmethod def header_fetch_parse(self, name: str, value: str) -> str: ... @abstractmethod def fold(self, name: str, value: str) -> str: ... @abstractmethod def fold_binary(self, name: str, value: str) -> bytes: ... class Compat32(Policy): def header_source_parse(self, sourcelines: List[str]) -> Tuple[str, str]: ... def header_store_parse(self, name: str, value: str) -> Tuple[str, str]: ... def header_fetch_parse(self, name: str, value: str) -> Union[str, Header]: ... # type: ignore def fold(self, name: str, value: str) -> str: ... def fold_binary(self, name: str, value: str) -> bytes: ... compat32: Compat32 class EmailPolicy(Policy): utf8: bool refold_source: str header_factory: Callable[[str, str], str] content_manager: ContentManager def header_source_parse(self, sourcelines: List[str]) -> Tuple[str, str]: ... def header_store_parse(self, name: str, value: str) -> Tuple[str, str]: ... def header_fetch_parse(self, name: str, value: str) -> str: ... def fold(self, name: str, value: str) -> str: ... def fold_binary(self, name: str, value: str) -> bytes: ... default: EmailPolicy SMTP: EmailPolicy SMTPUTF8: EmailPolicy HTTP: EmailPolicy strict: EmailPolicy ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/email/utils.pyi0000664000175000017500000000345000000000000024070 0ustar00davedave00000000000000import datetime import sys from email.charset import Charset from typing import List, Optional, Tuple, Union, overload _ParamType = Union[str, Tuple[Optional[str], Optional[str], str]] _PDTZ = Tuple[int, int, int, int, int, int, int, int, int, Optional[int]] def quote(str: str) -> str: ... def unquote(str: str) -> str: ... def parseaddr(address: Optional[str]) -> Tuple[str, str]: ... def formataddr(pair: Tuple[Optional[str], str], charset: Union[str, Charset] = ...) -> str: ... def getaddresses(fieldvalues: List[str]) -> List[Tuple[str, str]]: ... @overload def parsedate(date: None) -> None: ... @overload def parsedate(date: str) -> Optional[Tuple[int, int, int, int, int, int, int, int, int]]: ... @overload def parsedate_tz(date: None) -> None: ... @overload def parsedate_tz(date: str) -> Optional[_PDTZ]: ... if sys.version_info >= (3, 10): @overload def parsedate_to_datetime(date: None) -> None: ... @overload def parsedate_to_datetime(date: str) -> datetime.datetime: ... else: def parsedate_to_datetime(date: str) -> datetime.datetime: ... def mktime_tz(tuple: _PDTZ) -> int: ... def formatdate(timeval: Optional[float] = ..., localtime: bool = ..., usegmt: bool = ...) -> str: ... def format_datetime(dt: datetime.datetime, usegmt: bool = ...) -> str: ... def localtime(dt: Optional[datetime.datetime] = ...) -> datetime.datetime: ... def make_msgid(idstring: Optional[str] = ..., domain: Optional[str] = ...) -> str: ... def decode_rfc2231(s: str) -> Tuple[Optional[str], Optional[str], str]: ... def encode_rfc2231(s: str, charset: Optional[str] = ..., language: Optional[str] = ...) -> str: ... def collapse_rfc2231_value(value: _ParamType, errors: str = ..., fallback_charset: str = ...) -> str: ... def decode_params(params: List[Tuple[str, str]]) -> List[Tuple[str, _ParamType]]: ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4343793 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/encodings/0000775000175000017500000000000000000000000023065 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/encodings/__init__.pyi0000664000175000017500000000027000000000000025346 0ustar00davedave00000000000000import codecs from typing import Any def search_function(encoding: str) -> codecs.CodecInfo: ... # Explicitly mark this package as incomplete. def __getattr__(name: str) -> Any: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/encodings/utf_8.pyi0000664000175000017500000000106100000000000024633 0ustar00davedave00000000000000import codecs from typing import Tuple class IncrementalEncoder(codecs.IncrementalEncoder): def encode(self, input: str, final: bool = ...) -> bytes: ... class IncrementalDecoder(codecs.BufferedIncrementalDecoder): def _buffer_decode(self, input: bytes, errors: str, final: bool) -> Tuple[str, int]: ... class StreamWriter(codecs.StreamWriter): ... class StreamReader(codecs.StreamReader): ... def getregentry() -> codecs.CodecInfo: ... def encode(input: str, errors: str = ...) -> bytes: ... def decode(input: bytes, errors: str = ...) -> str: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/enum.pyi0000664000175000017500000000512300000000000022604 0ustar00davedave00000000000000import sys from abc import ABCMeta from typing import Any, Dict, Iterator, List, Mapping, Type, TypeVar, Union _T = TypeVar("_T") _S = TypeVar("_S", bound=Type[Enum]) # Note: EnumMeta actually subclasses type directly, not ABCMeta. # This is a temporary workaround to allow multiple creation of enums with builtins # such as str as mixins, which due to the handling of ABCs of builtin types, cause # spurious inconsistent metaclass structure. See #1595. # Structurally: Iterable[T], Reversible[T], Container[T] where T is the enum itself class EnumMeta(ABCMeta): def __iter__(self: Type[_T]) -> Iterator[_T]: ... def __reversed__(self: Type[_T]) -> Iterator[_T]: ... def __contains__(self: Type[_T], member: object) -> bool: ... def __getitem__(self: Type[_T], name: str) -> _T: ... @property def __members__(self: Type[_T]) -> Mapping[str, _T]: ... def __len__(self) -> int: ... class Enum(metaclass=EnumMeta): name: str value: Any _name_: str _value_: Any _member_names_: List[str] # undocumented _member_map_: Dict[str, Enum] # undocumented _value2member_map_: Dict[int, Enum] # undocumented if sys.version_info >= (3, 7): _ignore_: Union[str, List[str]] _order_: str __order__: str @classmethod def _missing_(cls, value: object) -> Any: ... @staticmethod def _generate_next_value_(name: str, start: int, count: int, last_values: List[Any]) -> Any: ... def __new__(cls: Type[_T], value: object) -> _T: ... def __repr__(self) -> str: ... def __str__(self) -> str: ... def __dir__(self) -> List[str]: ... def __format__(self, format_spec: str) -> str: ... def __hash__(self) -> Any: ... def __reduce_ex__(self, proto: object) -> Any: ... class IntEnum(int, Enum): value: int def unique(enumeration: _S) -> _S: ... _auto_null: Any # subclassing IntFlag so it picks up all implemented base functions, best modeling behavior of enum.auto() class auto(IntFlag): value: Any class Flag(Enum): def __contains__(self: _T, other: _T) -> bool: ... def __repr__(self) -> str: ... def __str__(self) -> str: ... def __bool__(self) -> bool: ... def __or__(self: _T, other: _T) -> _T: ... def __and__(self: _T, other: _T) -> _T: ... def __xor__(self: _T, other: _T) -> _T: ... def __invert__(self: _T) -> _T: ... class IntFlag(int, Flag): def __or__(self: _T, other: Union[int, _T]) -> _T: ... def __and__(self: _T, other: Union[int, _T]) -> _T: ... def __xor__(self: _T, other: Union[int, _T]) -> _T: ... __ror__ = __or__ __rand__ = __and__ __rxor__ = __xor__ ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/faulthandler.pyi0000664000175000017500000000120400000000000024305 0ustar00davedave00000000000000import sys from _typeshed import FileDescriptorLike def cancel_dump_traceback_later() -> None: ... def disable() -> None: ... def dump_traceback(file: FileDescriptorLike = ..., all_threads: bool = ...) -> None: ... def dump_traceback_later(timeout: float, repeat: bool = ..., file: FileDescriptorLike = ..., exit: bool = ...) -> None: ... def enable(file: FileDescriptorLike = ..., all_threads: bool = ...) -> None: ... def is_enabled() -> bool: ... if sys.platform != "win32": def register(signum: int, file: FileDescriptorLike = ..., all_threads: bool = ..., chain: bool = ...) -> None: ... def unregister(signum: int) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/fcntl.pyi0000664000175000017500000000430400000000000022746 0ustar00davedave00000000000000import sys from _typeshed import FileDescriptorLike from array import array from typing import Any, Union, overload from typing_extensions import Literal FASYNC: int FD_CLOEXEC: int DN_ACCESS: int DN_ATTRIB: int DN_CREATE: int DN_DELETE: int DN_MODIFY: int DN_MULTISHOT: int DN_RENAME: int F_DUPFD: int F_DUPFD_CLOEXEC: int F_FULLFSYNC: int F_EXLCK: int F_GETFD: int F_GETFL: int F_GETLEASE: int F_GETLK: int F_GETLK64: int F_GETOWN: int F_NOCACHE: int F_GETSIG: int F_NOTIFY: int F_RDLCK: int F_SETFD: int F_SETFL: int F_SETLEASE: int F_SETLK: int F_SETLK64: int F_SETLKW: int F_SETLKW64: int if sys.version_info >= (3, 9) and sys.platform == "linux": F_OFD_GETLK: int F_OFD_SETLK: int F_OFD_SETLKW: int F_SETOWN: int F_SETSIG: int F_SHLCK: int F_UNLCK: int F_WRLCK: int I_ATMARK: int I_CANPUT: int I_CKBAND: int I_FDINSERT: int I_FIND: int I_FLUSH: int I_FLUSHBAND: int I_GETBAND: int I_GETCLTIME: int I_GETSIG: int I_GRDOPT: int I_GWROPT: int I_LINK: int I_LIST: int I_LOOK: int I_NREAD: int I_PEEK: int I_PLINK: int I_POP: int I_PUNLINK: int I_PUSH: int I_RECVFD: int I_SENDFD: int I_SETCLTIME: int I_SETSIG: int I_SRDOPT: int I_STR: int I_SWROPT: int I_UNLINK: int LOCK_EX: int LOCK_MAND: int LOCK_NB: int LOCK_READ: int LOCK_RW: int LOCK_SH: int LOCK_UN: int LOCK_WRITE: int @overload def fcntl(__fd: FileDescriptorLike, __cmd: int, __arg: int = ...) -> int: ... @overload def fcntl(__fd: FileDescriptorLike, __cmd: int, __arg: bytes) -> bytes: ... _ReadOnlyBuffer = bytes _WritableBuffer = Union[bytearray, memoryview, array] @overload def ioctl(__fd: FileDescriptorLike, __request: int, __arg: int = ..., __mutate_flag: bool = ...) -> int: ... @overload def ioctl(__fd: FileDescriptorLike, __request: int, __arg: _WritableBuffer, __mutate_flag: Literal[True] = ...) -> int: ... @overload def ioctl(__fd: FileDescriptorLike, __request: int, __arg: _WritableBuffer, __mutate_flag: Literal[False]) -> bytes: ... @overload def ioctl(__fd: FileDescriptorLike, __request: int, __arg: _ReadOnlyBuffer, __mutate_flag: bool = ...) -> bytes: ... def flock(__fd: FileDescriptorLike, __operation: int) -> None: ... def lockf(__fd: FileDescriptorLike, __cmd: int, __len: int = ..., __start: int = ..., __whence: int = ...) -> Any: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/fnmatch.pyi0000664000175000017500000000040100000000000023252 0ustar00davedave00000000000000from typing import AnyStr, Iterable, List def fnmatch(name: AnyStr, pat: AnyStr) -> bool: ... def fnmatchcase(name: AnyStr, pat: AnyStr) -> bool: ... def filter(names: Iterable[AnyStr], pat: AnyStr) -> List[AnyStr]: ... def translate(pat: str) -> str: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/functools.pyi0000664000175000017500000001100500000000000023650 0ustar00davedave00000000000000import sys from _typeshed import SupportsLessThan from typing import ( Any, Callable, Dict, Generic, Hashable, Iterable, Mapping, NamedTuple, Optional, Sequence, Tuple, Type, TypeVar, Union, overload, ) if sys.version_info >= (3, 9): from types import GenericAlias _AnyCallable = Callable[..., Any] _T = TypeVar("_T") _S = TypeVar("_S") @overload def reduce(function: Callable[[_T, _S], _T], sequence: Iterable[_S], initial: _T) -> _T: ... @overload def reduce(function: Callable[[_T, _T], _T], sequence: Iterable[_T]) -> _T: ... class _CacheInfo(NamedTuple): hits: int misses: int maxsize: int currsize: int class _lru_cache_wrapper(Generic[_T]): __wrapped__: Callable[..., _T] def __call__(self, *args: Hashable, **kwargs: Hashable) -> _T: ... def cache_info(self) -> _CacheInfo: ... def cache_clear(self) -> None: ... if sys.version_info >= (3, 8): @overload def lru_cache(maxsize: Optional[int] = ..., typed: bool = ...) -> Callable[[Callable[..., _T]], _lru_cache_wrapper[_T]]: ... @overload def lru_cache(maxsize: Callable[..., _T], typed: bool = ...) -> _lru_cache_wrapper[_T]: ... else: def lru_cache(maxsize: Optional[int] = ..., typed: bool = ...) -> Callable[[Callable[..., _T]], _lru_cache_wrapper[_T]]: ... WRAPPER_ASSIGNMENTS: Sequence[str] WRAPPER_UPDATES: Sequence[str] def update_wrapper(wrapper: _T, wrapped: _AnyCallable, assigned: Sequence[str] = ..., updated: Sequence[str] = ...) -> _T: ... def wraps(wrapped: _AnyCallable, assigned: Sequence[str] = ..., updated: Sequence[str] = ...) -> Callable[[_T], _T]: ... def total_ordering(cls: Type[_T]) -> Type[_T]: ... def cmp_to_key(mycmp: Callable[[_T, _T], int]) -> Callable[[_T], SupportsLessThan]: ... class partial(Generic[_T]): func: Callable[..., _T] args: Tuple[Any, ...] keywords: Dict[str, Any] def __init__(self, func: Callable[..., _T], *args: Any, **kwargs: Any) -> None: ... def __call__(self, *args: Any, **kwargs: Any) -> _T: ... if sys.version_info >= (3, 9): def __class_getitem__(cls, item: Any) -> GenericAlias: ... # With protocols, this could change into a generic protocol that defines __get__ and returns _T _Descriptor = Any class partialmethod(Generic[_T]): func: Union[Callable[..., _T], _Descriptor] args: Tuple[Any, ...] keywords: Dict[str, Any] @overload def __init__(self, __func: Callable[..., _T], *args: Any, **keywords: Any) -> None: ... @overload def __init__(self, __func: _Descriptor, *args: Any, **keywords: Any) -> None: ... def __get__(self, obj: Any, cls: Type[Any]) -> Callable[..., _T]: ... @property def __isabstractmethod__(self) -> bool: ... if sys.version_info >= (3, 9): def __class_getitem__(cls, item: Any) -> GenericAlias: ... class _SingleDispatchCallable(Generic[_T]): registry: Mapping[Any, Callable[..., _T]] def dispatch(self, cls: Any) -> Callable[..., _T]: ... @overload def register(self, cls: Any) -> Callable[[Callable[..., _T]], Callable[..., _T]]: ... @overload def register(self, cls: Any, func: Callable[..., _T]) -> Callable[..., _T]: ... def _clear_cache(self) -> None: ... def __call__(self, *args: Any, **kwargs: Any) -> _T: ... def singledispatch(func: Callable[..., _T]) -> _SingleDispatchCallable[_T]: ... if sys.version_info >= (3, 8): class singledispatchmethod(Generic[_T]): dispatcher: _SingleDispatchCallable[_T] func: Callable[..., _T] def __init__(self, func: Callable[..., _T]) -> None: ... @overload def register(self, cls: Any, method: None = ...) -> Callable[[Callable[..., _T]], Callable[..., _T]]: ... @overload def register(self, cls: Any, method: Callable[..., _T]) -> Callable[..., _T]: ... def __call__(self, *args: Any, **kwargs: Any) -> _T: ... class cached_property(Generic[_T]): func: Callable[[Any], _T] attrname: Optional[str] def __init__(self, func: Callable[[Any], _T]) -> None: ... @overload def __get__(self, instance: None, owner: Optional[Type[Any]] = ...) -> cached_property[_T]: ... @overload def __get__(self, instance: _S, owner: Optional[Type[Any]] = ...) -> _T: ... def __set_name__(self, owner: Type[Any], name: str) -> None: ... if sys.version_info >= (3, 9): def __class_getitem__(cls, item: Any) -> GenericAlias: ... if sys.version_info >= (3, 9): def cache(__user_function: Callable[..., _T]) -> _lru_cache_wrapper[_T]: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/gc.pyi0000664000175000017500000000215700000000000022235 0ustar00davedave00000000000000import sys from typing import Any, Dict, List, Optional, Tuple DEBUG_COLLECTABLE: int DEBUG_LEAK: int DEBUG_SAVEALL: int DEBUG_STATS: int DEBUG_UNCOLLECTABLE: int callbacks: List[Any] garbage: List[Any] def collect(generation: int = ...) -> int: ... def disable() -> None: ... def enable() -> None: ... def get_count() -> Tuple[int, int, int]: ... def get_debug() -> int: ... if sys.version_info >= (3, 8): def get_objects(generation: Optional[int] = ...) -> List[Any]: ... else: def get_objects() -> List[Any]: ... if sys.version_info >= (3, 7): def freeze() -> None: ... def unfreeze() -> None: ... def get_freeze_count() -> int: ... def get_referents(*objs: Any) -> List[Any]: ... def get_referrers(*objs: Any) -> List[Any]: ... def get_stats() -> List[Dict[str, Any]]: ... def get_threshold() -> Tuple[int, int, int]: ... def is_tracked(__obj: Any) -> bool: ... if sys.version_info >= (3, 9): def is_finalized(__obj: Any) -> bool: ... def isenabled() -> bool: ... def set_debug(__flags: int) -> None: ... def set_threshold(threshold0: int, threshold1: int = ..., threshold2: int = ...) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/getopt.pyi0000664000175000017500000000054000000000000023140 0ustar00davedave00000000000000from typing import List, Tuple def getopt(args: List[str], shortopts: str, longopts: List[str] = ...) -> Tuple[List[Tuple[str, str]], List[str]]: ... def gnu_getopt(args: List[str], shortopts: str, longopts: List[str] = ...) -> Tuple[List[Tuple[str, str]], List[str]]: ... class GetoptError(Exception): msg: str opt: str error = GetoptError ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/getpass.pyi0000664000175000017500000000026200000000000023305 0ustar00davedave00000000000000from typing import Optional, TextIO def getpass(prompt: str = ..., stream: Optional[TextIO] = ...) -> str: ... def getuser() -> str: ... class GetPassWarning(UserWarning): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/gettext.pyi0000664000175000017500000000621000000000000023322 0ustar00davedave00000000000000import sys from _typeshed import StrPath from typing import IO, Any, Container, Iterable, Optional, Sequence, Type, TypeVar, overload from typing_extensions import Literal class NullTranslations: def __init__(self, fp: Optional[IO[str]] = ...) -> None: ... def _parse(self, fp: IO[str]) -> None: ... def add_fallback(self, fallback: NullTranslations) -> None: ... def gettext(self, message: str) -> str: ... def lgettext(self, message: str) -> str: ... def ngettext(self, msgid1: str, msgid2: str, n: int) -> str: ... def lngettext(self, msgid1: str, msgid2: str, n: int) -> str: ... if sys.version_info >= (3, 8): def pgettext(self, context: str, message: str) -> str: ... def npgettext(self, context: str, msgid1: str, msgid2: str, n: int) -> str: ... def info(self) -> Any: ... def charset(self) -> Any: ... def output_charset(self) -> Any: ... def set_output_charset(self, charset: str) -> None: ... def install(self, names: Optional[Container[str]] = ...) -> None: ... class GNUTranslations(NullTranslations): LE_MAGIC: int BE_MAGIC: int CONTEXT: str VERSIONS: Sequence[int] def find(domain: str, localedir: Optional[StrPath] = ..., languages: Optional[Iterable[str]] = ..., all: bool = ...) -> Any: ... _T = TypeVar("_T") @overload def translation( domain: str, localedir: Optional[StrPath] = ..., languages: Optional[Iterable[str]] = ..., class_: None = ..., fallback: bool = ..., codeset: Optional[str] = ..., ) -> NullTranslations: ... @overload def translation( domain: str, localedir: Optional[StrPath] = ..., languages: Optional[Iterable[str]] = ..., class_: Type[_T] = ..., fallback: Literal[False] = ..., codeset: Optional[str] = ..., ) -> _T: ... @overload def translation( domain: str, localedir: Optional[StrPath] = ..., languages: Optional[Iterable[str]] = ..., class_: Type[_T] = ..., fallback: Literal[True] = ..., codeset: Optional[str] = ..., ) -> Any: ... def install( domain: str, localedir: Optional[StrPath] = ..., codeset: Optional[str] = ..., names: Optional[Container[str]] = ... ) -> None: ... def textdomain(domain: Optional[str] = ...) -> str: ... def bindtextdomain(domain: str, localedir: Optional[StrPath] = ...) -> str: ... def bind_textdomain_codeset(domain: str, codeset: Optional[str] = ...) -> str: ... def dgettext(domain: str, message: str) -> str: ... def ldgettext(domain: str, message: str) -> str: ... def dngettext(domain: str, msgid1: str, msgid2: str, n: int) -> str: ... def ldngettext(domain: str, msgid1: str, msgid2: str, n: int) -> str: ... def gettext(message: str) -> str: ... def lgettext(message: str) -> str: ... def ngettext(msgid1: str, msgid2: str, n: int) -> str: ... def lngettext(msgid1: str, msgid2: str, n: int) -> str: ... if sys.version_info >= (3, 8): def pgettext(context: str, message: str) -> str: ... def dpgettext(domain: str, context: str, message: str) -> str: ... def npgettext(context: str, msgid1: str, msgid2: str, n: int) -> str: ... def dnpgettext(domain: str, context: str, msgid1: str, msgid2: str, n: int) -> str: ... Catalog = translation ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/glob.pyi0000664000175000017500000000067200000000000022567 0ustar00davedave00000000000000from typing import AnyStr, Iterator, List, Union def glob0(dirname: AnyStr, pattern: AnyStr) -> List[AnyStr]: ... def glob1(dirname: AnyStr, pattern: AnyStr) -> List[AnyStr]: ... def glob(pathname: AnyStr, *, recursive: bool = ...) -> List[AnyStr]: ... def iglob(pathname: AnyStr, *, recursive: bool = ...) -> Iterator[AnyStr]: ... def escape(pathname: AnyStr) -> AnyStr: ... def has_magic(s: Union[str, bytes]) -> bool: ... # undocumented ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/gzip.pyi0000664000175000017500000000553500000000000022620 0ustar00davedave00000000000000import _compression import sys import zlib from _typeshed import AnyPath, ReadableBuffer from typing import IO, Optional, TextIO, Union, overload from typing_extensions import Literal _OpenBinaryMode = Literal["r", "rb", "a", "ab", "w", "wb", "x", "xb"] _OpenTextMode = Literal["rt", "at", "wt", "xt"] @overload def open( filename: Union[AnyPath, IO[bytes]], mode: _OpenBinaryMode = ..., compresslevel: int = ..., encoding: None = ..., errors: None = ..., newline: None = ..., ) -> GzipFile: ... @overload def open( filename: AnyPath, mode: _OpenTextMode, compresslevel: int = ..., encoding: Optional[str] = ..., errors: Optional[str] = ..., newline: Optional[str] = ..., ) -> TextIO: ... @overload def open( filename: Union[AnyPath, IO[bytes]], mode: str, compresslevel: int = ..., encoding: Optional[str] = ..., errors: Optional[str] = ..., newline: Optional[str] = ..., ) -> Union[GzipFile, TextIO]: ... class _PaddedFile: file: IO[bytes] def __init__(self, f: IO[bytes], prepend: bytes = ...) -> None: ... def read(self, size: int) -> bytes: ... def prepend(self, prepend: bytes = ...) -> None: ... def seek(self, off: int) -> int: ... def seekable(self) -> bool: ... if sys.version_info >= (3, 8): class BadGzipFile(OSError): ... class GzipFile(_compression.BaseStream): myfileobj: Optional[IO[bytes]] mode: str name: str compress: zlib._Compress fileobj: IO[bytes] def __init__( self, filename: Optional[AnyPath] = ..., mode: Optional[str] = ..., compresslevel: int = ..., fileobj: Optional[IO[bytes]] = ..., mtime: Optional[float] = ..., ) -> None: ... @property def filename(self) -> str: ... @property def mtime(self) -> Optional[int]: ... crc: int def write(self, data: ReadableBuffer) -> int: ... def read(self, size: Optional[int] = ...) -> bytes: ... def read1(self, size: int = ...) -> bytes: ... def peek(self, n: int) -> bytes: ... @property def closed(self) -> bool: ... def close(self) -> None: ... def flush(self, zlib_mode: int = ...) -> None: ... def fileno(self) -> int: ... def rewind(self) -> None: ... def readable(self) -> bool: ... def writable(self) -> bool: ... def seekable(self) -> bool: ... def seek(self, offset: int, whence: int = ...) -> int: ... def readline(self, size: Optional[int] = ...) -> bytes: ... class _GzipReader(_compression.DecompressReader): def __init__(self, fp: IO[bytes]) -> None: ... def read(self, size: int = ...) -> bytes: ... if sys.version_info >= (3, 8): def compress(data: bytes, compresslevel: int = ..., *, mtime: Optional[float] = ...) -> bytes: ... else: def compress(data: bytes, compresslevel: int = ...) -> bytes: ... def decompress(data: bytes) -> bytes: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/hashlib.pyi0000664000175000017500000001014300000000000023250 0ustar00davedave00000000000000import sys from _typeshed import ReadableBuffer from typing import AbstractSet, Optional class _Hash(object): digest_size: int block_size: int # [Python documentation note] Changed in version 3.4: The name attribute has # been present in CPython since its inception, but until Python 3.4 was not # formally specified, so may not exist on some platforms name: str def __init__(self, data: ReadableBuffer = ...) -> None: ... def copy(self) -> _Hash: ... def digest(self) -> bytes: ... def hexdigest(self) -> str: ... def update(self, __data: ReadableBuffer) -> None: ... if sys.version_info >= (3, 9): def md5(string: ReadableBuffer = ..., *, usedforsecurity: bool = ...) -> _Hash: ... def sha1(string: ReadableBuffer = ..., *, usedforsecurity: bool = ...) -> _Hash: ... def sha224(string: ReadableBuffer = ..., *, usedforsecurity: bool = ...) -> _Hash: ... def sha256(string: ReadableBuffer = ..., *, usedforsecurity: bool = ...) -> _Hash: ... def sha384(string: ReadableBuffer = ..., *, usedforsecurity: bool = ...) -> _Hash: ... def sha512(string: ReadableBuffer = ..., *, usedforsecurity: bool = ...) -> _Hash: ... elif sys.version_info >= (3, 8): def md5(string: ReadableBuffer = ...) -> _Hash: ... def sha1(string: ReadableBuffer = ...) -> _Hash: ... def sha224(string: ReadableBuffer = ...) -> _Hash: ... def sha256(string: ReadableBuffer = ...) -> _Hash: ... def sha384(string: ReadableBuffer = ...) -> _Hash: ... def sha512(string: ReadableBuffer = ...) -> _Hash: ... else: def md5(__string: ReadableBuffer = ...) -> _Hash: ... def sha1(__string: ReadableBuffer = ...) -> _Hash: ... def sha224(__string: ReadableBuffer = ...) -> _Hash: ... def sha256(__string: ReadableBuffer = ...) -> _Hash: ... def sha384(__string: ReadableBuffer = ...) -> _Hash: ... def sha512(__string: ReadableBuffer = ...) -> _Hash: ... def new(name: str, data: ReadableBuffer = ...) -> _Hash: ... algorithms_guaranteed: AbstractSet[str] algorithms_available: AbstractSet[str] def pbkdf2_hmac( hash_name: str, password: ReadableBuffer, salt: ReadableBuffer, iterations: int, dklen: Optional[int] = ... ) -> bytes: ... class _VarLenHash(object): digest_size: int block_size: int name: str def __init__(self, data: ReadableBuffer = ...) -> None: ... def copy(self) -> _VarLenHash: ... def digest(self, __length: int) -> bytes: ... def hexdigest(self, __length: int) -> str: ... def update(self, __data: ReadableBuffer) -> None: ... sha3_224 = _Hash sha3_256 = _Hash sha3_384 = _Hash sha3_512 = _Hash shake_128 = _VarLenHash shake_256 = _VarLenHash def scrypt( password: ReadableBuffer, *, salt: Optional[ReadableBuffer] = ..., n: Optional[int] = ..., r: Optional[int] = ..., p: Optional[int] = ..., maxmem: int = ..., dklen: int = ..., ) -> bytes: ... class _BlakeHash(_Hash): MAX_DIGEST_SIZE: int MAX_KEY_SIZE: int PERSON_SIZE: int SALT_SIZE: int if sys.version_info >= (3, 9): def __init__( self, __data: ReadableBuffer = ..., *, digest_size: int = ..., key: ReadableBuffer = ..., salt: ReadableBuffer = ..., person: ReadableBuffer = ..., fanout: int = ..., depth: int = ..., leaf_size: int = ..., node_offset: int = ..., node_depth: int = ..., inner_size: int = ..., last_node: bool = ..., usedforsecurity: bool = ..., ) -> None: ... else: def __init__( self, __data: ReadableBuffer = ..., *, digest_size: int = ..., key: ReadableBuffer = ..., salt: ReadableBuffer = ..., person: ReadableBuffer = ..., fanout: int = ..., depth: int = ..., leaf_size: int = ..., node_offset: int = ..., node_depth: int = ..., inner_size: int = ..., last_node: bool = ..., ) -> None: ... blake2b = _BlakeHash blake2s = _BlakeHash ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/heapq.pyi0000664000175000017500000000143600000000000022741 0ustar00davedave00000000000000from _typeshed import SupportsLessThan from typing import Any, Callable, Iterable, List, Optional, TypeVar _T = TypeVar("_T") def heappush(__heap: List[_T], __item: _T) -> None: ... def heappop(__heap: List[_T]) -> _T: ... def heappushpop(__heap: List[_T], __item: _T) -> _T: ... def heapify(__heap: List[_T]) -> None: ... def heapreplace(__heap: List[_T], __item: _T) -> _T: ... def merge(*iterables: Iterable[_T], key: Optional[Callable[[_T], Any]] = ..., reverse: bool = ...) -> Iterable[_T]: ... def nlargest(n: int, iterable: Iterable[_T], key: Optional[Callable[[_T], SupportsLessThan]] = ...) -> List[_T]: ... def nsmallest(n: int, iterable: Iterable[_T], key: Optional[Callable[[_T], SupportsLessThan]] = ...) -> List[_T]: ... def _heapify_max(__x: List[_T]) -> None: ... # undocumented ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4343793 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/html/0000775000175000017500000000000000000000000022060 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/html/__init__.pyi0000664000175000017500000000017200000000000024342 0ustar00davedave00000000000000from typing import AnyStr def escape(s: AnyStr, quote: bool = ...) -> AnyStr: ... def unescape(s: AnyStr) -> AnyStr: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/html/entities.pyi0000664000175000017500000000021000000000000024420 0ustar00davedave00000000000000from typing import Dict name2codepoint: Dict[str, int] html5: Dict[str, str] codepoint2name: Dict[int, str] entitydefs: Dict[str, str] ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/html/parser.pyi0000664000175000017500000000173000000000000024100 0ustar00davedave00000000000000from _markupbase import ParserBase from typing import List, Optional, Tuple class HTMLParser(ParserBase): def __init__(self, *, convert_charrefs: bool = ...) -> None: ... def feed(self, feed: str) -> None: ... def close(self) -> None: ... def reset(self) -> None: ... def getpos(self) -> Tuple[int, int]: ... def get_starttag_text(self) -> Optional[str]: ... def handle_starttag(self, tag: str, attrs: List[Tuple[str, Optional[str]]]) -> None: ... def handle_endtag(self, tag: str) -> None: ... def handle_startendtag(self, tag: str, attrs: List[Tuple[str, Optional[str]]]) -> None: ... def handle_data(self, data: str) -> None: ... def handle_entityref(self, name: str) -> None: ... def handle_charref(self, name: str) -> None: ... def handle_comment(self, data: str) -> None: ... def handle_decl(self, decl: str) -> None: ... def handle_pi(self, data: str) -> None: ... def unknown_decl(self, data: str) -> None: ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4343793 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/http/0000775000175000017500000000000000000000000022073 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/http/__init__.pyi0000664000175000017500000000362400000000000024362 0ustar00davedave00000000000000import sys from enum import IntEnum from typing_extensions import Literal class HTTPStatus(IntEnum): @property def phrase(self) -> str: ... @property def description(self) -> str: ... CONTINUE: int SWITCHING_PROTOCOLS: int PROCESSING: int OK: int CREATED: int ACCEPTED: int NON_AUTHORITATIVE_INFORMATION: int NO_CONTENT: int RESET_CONTENT: int PARTIAL_CONTENT: int MULTI_STATUS: int ALREADY_REPORTED: int IM_USED: int MULTIPLE_CHOICES: int MOVED_PERMANENTLY: int FOUND: int SEE_OTHER: int NOT_MODIFIED: int USE_PROXY: int TEMPORARY_REDIRECT: int PERMANENT_REDIRECT: int BAD_REQUEST: int UNAUTHORIZED: int PAYMENT_REQUIRED: int FORBIDDEN: int NOT_FOUND: int METHOD_NOT_ALLOWED: int NOT_ACCEPTABLE: int PROXY_AUTHENTICATION_REQUIRED: int REQUEST_TIMEOUT: int CONFLICT: int GONE: int LENGTH_REQUIRED: int PRECONDITION_FAILED: int REQUEST_ENTITY_TOO_LARGE: int REQUEST_URI_TOO_LONG: int UNSUPPORTED_MEDIA_TYPE: int REQUESTED_RANGE_NOT_SATISFIABLE: int EXPECTATION_FAILED: int UNPROCESSABLE_ENTITY: int LOCKED: int FAILED_DEPENDENCY: int UPGRADE_REQUIRED: int PRECONDITION_REQUIRED: int TOO_MANY_REQUESTS: int REQUEST_HEADER_FIELDS_TOO_LARGE: int INTERNAL_SERVER_ERROR: int NOT_IMPLEMENTED: int BAD_GATEWAY: int SERVICE_UNAVAILABLE: int GATEWAY_TIMEOUT: int HTTP_VERSION_NOT_SUPPORTED: int VARIANT_ALSO_NEGOTIATES: int INSUFFICIENT_STORAGE: int LOOP_DETECTED: int NOT_EXTENDED: int NETWORK_AUTHENTICATION_REQUIRED: int if sys.version_info >= (3, 7): MISDIRECTED_REQUEST: int if sys.version_info >= (3, 8): UNAVAILABLE_FOR_LEGAL_REASONS: int if sys.version_info >= (3, 9): EARLY_HINTS: Literal[103] IM_A_TEAPOT: Literal[418] TOO_EARLY: Literal[425] ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/http/client.pyi0000664000175000017500000001362200000000000024100 0ustar00davedave00000000000000import email.message import io import ssl import sys import types from socket import socket from typing import ( IO, Any, BinaryIO, Callable, Dict, Iterable, Iterator, List, Mapping, Optional, Protocol, Tuple, Type, TypeVar, Union, overload, ) _DataType = Union[bytes, IO[Any], Iterable[bytes], str] _T = TypeVar("_T") HTTP_PORT: int HTTPS_PORT: int CONTINUE: int SWITCHING_PROTOCOLS: int PROCESSING: int OK: int CREATED: int ACCEPTED: int NON_AUTHORITATIVE_INFORMATION: int NO_CONTENT: int RESET_CONTENT: int PARTIAL_CONTENT: int MULTI_STATUS: int IM_USED: int MULTIPLE_CHOICES: int MOVED_PERMANENTLY: int FOUND: int SEE_OTHER: int NOT_MODIFIED: int USE_PROXY: int TEMPORARY_REDIRECT: int BAD_REQUEST: int UNAUTHORIZED: int PAYMENT_REQUIRED: int FORBIDDEN: int NOT_FOUND: int METHOD_NOT_ALLOWED: int NOT_ACCEPTABLE: int PROXY_AUTHENTICATION_REQUIRED: int REQUEST_TIMEOUT: int CONFLICT: int GONE: int LENGTH_REQUIRED: int PRECONDITION_FAILED: int REQUEST_ENTITY_TOO_LARGE: int REQUEST_URI_TOO_LONG: int UNSUPPORTED_MEDIA_TYPE: int REQUESTED_RANGE_NOT_SATISFIABLE: int EXPECTATION_FAILED: int UNPROCESSABLE_ENTITY: int LOCKED: int FAILED_DEPENDENCY: int UPGRADE_REQUIRED: int PRECONDITION_REQUIRED: int TOO_MANY_REQUESTS: int REQUEST_HEADER_FIELDS_TOO_LARGE: int INTERNAL_SERVER_ERROR: int NOT_IMPLEMENTED: int BAD_GATEWAY: int SERVICE_UNAVAILABLE: int GATEWAY_TIMEOUT: int HTTP_VERSION_NOT_SUPPORTED: int INSUFFICIENT_STORAGE: int NOT_EXTENDED: int NETWORK_AUTHENTICATION_REQUIRED: int responses: Dict[int, str] class HTTPMessage(email.message.Message): ... def parse_headers(fp: io.BufferedIOBase, _class: Callable[[], email.message.Message] = ...) -> HTTPMessage: ... class HTTPResponse(io.BufferedIOBase, BinaryIO): msg: HTTPMessage headers: HTTPMessage version: int debuglevel: int closed: bool status: int reason: str def __init__(self, sock: socket, debuglevel: int = ..., method: Optional[str] = ..., url: Optional[str] = ...) -> None: ... def read(self, amt: Optional[int] = ...) -> bytes: ... @overload def getheader(self, name: str) -> Optional[str]: ... @overload def getheader(self, name: str, default: _T) -> Union[str, _T]: ... def getheaders(self) -> List[Tuple[str, str]]: ... def fileno(self) -> int: ... def isclosed(self) -> bool: ... def __iter__(self) -> Iterator[bytes]: ... def __enter__(self) -> HTTPResponse: ... def __exit__( self, exc_type: Optional[Type[BaseException]], exc_val: Optional[BaseException], exc_tb: Optional[types.TracebackType] ) -> Optional[bool]: ... def info(self) -> email.message.Message: ... def geturl(self) -> str: ... def getcode(self) -> int: ... def begin(self) -> None: ... # This is an API stub only for the class below, not a class itself. # urllib.request uses it for a parameter. class _HTTPConnectionProtocol(Protocol): if sys.version_info >= (3, 7): def __call__( self, host: str, port: Optional[int] = ..., timeout: float = ..., source_address: Optional[Tuple[str, int]] = ..., blocksize: int = ..., ) -> HTTPConnection: ... else: def __call__( self, host: str, port: Optional[int] = ..., timeout: float = ..., source_address: Optional[Tuple[str, int]] = ... ) -> HTTPConnection: ... class HTTPConnection: timeout: Optional[float] host: str port: int sock: Any if sys.version_info >= (3, 7): def __init__( self, host: str, port: Optional[int] = ..., timeout: Optional[float] = ..., source_address: Optional[Tuple[str, int]] = ..., blocksize: int = ..., ) -> None: ... else: def __init__( self, host: str, port: Optional[int] = ..., timeout: Optional[float] = ..., source_address: Optional[Tuple[str, int]] = ..., ) -> None: ... def request( self, method: str, url: str, body: Optional[_DataType] = ..., headers: Mapping[str, str] = ..., *, encode_chunked: bool = ..., ) -> None: ... def getresponse(self) -> HTTPResponse: ... def set_debuglevel(self, level: int) -> None: ... def set_tunnel(self, host: str, port: Optional[int] = ..., headers: Optional[Mapping[str, str]] = ...) -> None: ... def connect(self) -> None: ... def close(self) -> None: ... def putrequest(self, method: str, url: str, skip_host: bool = ..., skip_accept_encoding: bool = ...) -> None: ... def putheader(self, header: str, *argument: str) -> None: ... def endheaders(self, message_body: Optional[_DataType] = ..., *, encode_chunked: bool = ...) -> None: ... def send(self, data: _DataType) -> None: ... class HTTPSConnection(HTTPConnection): def __init__( self, host: str, port: Optional[int] = ..., key_file: Optional[str] = ..., cert_file: Optional[str] = ..., timeout: Optional[float] = ..., source_address: Optional[Tuple[str, int]] = ..., *, context: Optional[ssl.SSLContext] = ..., check_hostname: Optional[bool] = ..., ) -> None: ... class HTTPException(Exception): ... error = HTTPException class NotConnected(HTTPException): ... class InvalidURL(HTTPException): ... class UnknownProtocol(HTTPException): ... class UnknownTransferEncoding(HTTPException): ... class UnimplementedFileMode(HTTPException): ... class IncompleteRead(HTTPException): ... class ImproperConnectionState(HTTPException): ... class CannotSendRequest(ImproperConnectionState): ... class CannotSendHeader(ImproperConnectionState): ... class ResponseNotReady(ImproperConnectionState): ... class BadStatusLine(HTTPException): ... class LineTooLong(HTTPException): ... class RemoteDisconnected(ConnectionResetError, BadStatusLine): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/http/cookiejar.pyi0000664000175000017500000001157700000000000024577 0ustar00davedave00000000000000import sys from http.client import HTTPResponse from os import PathLike from typing import Dict, Iterable, Iterator, Optional, Sequence, Tuple, TypeVar, Union, overload from urllib.request import Request _T = TypeVar("_T") class LoadError(OSError): ... class CookieJar(Iterable[Cookie]): def __init__(self, policy: Optional[CookiePolicy] = ...) -> None: ... def add_cookie_header(self, request: Request) -> None: ... def extract_cookies(self, response: HTTPResponse, request: Request) -> None: ... def set_policy(self, policy: CookiePolicy) -> None: ... def make_cookies(self, response: HTTPResponse, request: Request) -> Sequence[Cookie]: ... def set_cookie(self, cookie: Cookie) -> None: ... def set_cookie_if_ok(self, cookie: Cookie, request: Request) -> None: ... def clear(self, domain: str = ..., path: str = ..., name: str = ...) -> None: ... def clear_session_cookies(self) -> None: ... def __iter__(self) -> Iterator[Cookie]: ... def __len__(self) -> int: ... class FileCookieJar(CookieJar): filename: str delayload: bool if sys.version_info >= (3, 8): def __init__( self, filename: Union[str, PathLike[str]] = ..., delayload: bool = ..., policy: Optional[CookiePolicy] = ... ) -> None: ... else: def __init__(self, filename: str = ..., delayload: bool = ..., policy: Optional[CookiePolicy] = ...) -> None: ... def save(self, filename: Optional[str] = ..., ignore_discard: bool = ..., ignore_expires: bool = ...) -> None: ... def load(self, filename: Optional[str] = ..., ignore_discard: bool = ..., ignore_expires: bool = ...) -> None: ... def revert(self, filename: Optional[str] = ..., ignore_discard: bool = ..., ignore_expires: bool = ...) -> None: ... class MozillaCookieJar(FileCookieJar): ... class LWPCookieJar(FileCookieJar): def as_lwp_str(self, ignore_discard: bool = ..., ignore_expires: bool = ...) -> str: ... # undocumented class CookiePolicy: netscape: bool rfc2965: bool hide_cookie2: bool def set_ok(self, cookie: Cookie, request: Request) -> bool: ... def return_ok(self, cookie: Cookie, request: Request) -> bool: ... def domain_return_ok(self, domain: str, request: Request) -> bool: ... def path_return_ok(self, path: str, request: Request) -> bool: ... class DefaultCookiePolicy(CookiePolicy): rfc2109_as_netscape: bool strict_domain: bool strict_rfc2965_unverifiable: bool strict_ns_unverifiable: bool strict_ns_domain: int strict_ns_set_initial_dollar: bool strict_ns_set_path: bool DomainStrictNoDots: int DomainStrictNonDomain: int DomainRFC2965Match: int DomainLiberal: int DomainStrict: int def __init__( self, blocked_domains: Optional[Sequence[str]] = ..., allowed_domains: Optional[Sequence[str]] = ..., netscape: bool = ..., rfc2965: bool = ..., rfc2109_as_netscape: Optional[bool] = ..., hide_cookie2: bool = ..., strict_domain: bool = ..., strict_rfc2965_unverifiable: bool = ..., strict_ns_unverifiable: bool = ..., strict_ns_domain: int = ..., strict_ns_set_initial_dollar: bool = ..., strict_ns_set_path: bool = ..., ) -> None: ... def blocked_domains(self) -> Tuple[str, ...]: ... def set_blocked_domains(self, blocked_domains: Sequence[str]) -> None: ... def is_blocked(self, domain: str) -> bool: ... def allowed_domains(self) -> Optional[Tuple[str, ...]]: ... def set_allowed_domains(self, allowed_domains: Optional[Sequence[str]]) -> None: ... def is_not_allowed(self, domain: str) -> bool: ... class Cookie: version: Optional[int] name: str value: Optional[str] port: Optional[str] path: str path_specified: bool secure: bool expires: Optional[int] discard: bool comment: Optional[str] comment_url: Optional[str] rfc2109: bool port_specified: bool domain: str # undocumented domain_specified: bool domain_initial_dot: bool def __init__( self, version: Optional[int], name: str, value: Optional[str], # undocumented port: Optional[str], port_specified: bool, domain: str, domain_specified: bool, domain_initial_dot: bool, path: str, path_specified: bool, secure: bool, expires: Optional[int], discard: bool, comment: Optional[str], comment_url: Optional[str], rest: Dict[str, str], rfc2109: bool = ..., ) -> None: ... def has_nonstandard_attr(self, name: str) -> bool: ... @overload def get_nonstandard_attr(self, name: str) -> Optional[str]: ... @overload def get_nonstandard_attr(self, name: str, default: _T = ...) -> Union[str, _T]: ... def set_nonstandard_attr(self, name: str, value: str) -> None: ... def is_expired(self, now: int = ...) -> bool: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/http/cookies.pyi0000664000175000017500000000252400000000000024255 0ustar00davedave00000000000000import sys from typing import Any, Dict, Generic, List, Mapping, Optional, TypeVar, Union _DataType = Union[str, Mapping[str, Union[str, Morsel[Any]]]] _T = TypeVar("_T") class CookieError(Exception): ... class Morsel(Dict[str, Any], Generic[_T]): value: str coded_value: _T key: str if sys.version_info >= (3, 7): def set(self, key: str, val: str, coded_val: _T) -> None: ... else: def set(self, key: str, val: str, coded_val: _T, LegalChars: str = ...) -> None: ... def isReservedKey(self, K: str) -> bool: ... def output(self, attrs: Optional[List[str]] = ..., header: str = ...) -> str: ... def js_output(self, attrs: Optional[List[str]] = ...) -> str: ... def OutputString(self, attrs: Optional[List[str]] = ...) -> str: ... class BaseCookie(Dict[str, Morsel[_T]], Generic[_T]): def __init__(self, input: Optional[_DataType] = ...) -> None: ... def value_decode(self, val: str) -> _T: ... def value_encode(self, val: _T) -> str: ... def output(self, attrs: Optional[List[str]] = ..., header: str = ..., sep: str = ...) -> str: ... def js_output(self, attrs: Optional[List[str]] = ...) -> str: ... def load(self, rawdata: _DataType) -> None: ... def __setitem__(self, key: str, value: Union[str, Morsel[_T]]) -> None: ... class SimpleCookie(BaseCookie[_T], Generic[_T]): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/http/server.pyi0000664000175000017500000000573400000000000024135 0ustar00davedave00000000000000import email.message import socketserver import sys from typing import Any, Callable, ClassVar, Dict, List, Mapping, Optional, Sequence, Tuple, Union if sys.version_info >= (3, 7): from builtins import _PathLike class HTTPServer(socketserver.TCPServer): server_name: str server_port: int def __init__(self, server_address: Tuple[str, int], RequestHandlerClass: Callable[..., BaseHTTPRequestHandler]) -> None: ... if sys.version_info >= (3, 7): class ThreadingHTTPServer(socketserver.ThreadingMixIn, HTTPServer): daemon_threads: bool # undocumented class BaseHTTPRequestHandler(socketserver.StreamRequestHandler): client_address: Tuple[str, int] server: socketserver.BaseServer close_connection: bool requestline: str command: str path: str request_version: str headers: email.message.Message server_version: str sys_version: str error_message_format: str error_content_type: str protocol_version: str MessageClass: type responses: Mapping[int, Tuple[str, str]] weekdayname: ClassVar[Sequence[str]] = ... # Undocumented monthname: ClassVar[Sequence[Optional[str]]] = ... # Undocumented def __init__(self, request: bytes, client_address: Tuple[str, int], server: socketserver.BaseServer) -> None: ... def handle(self) -> None: ... def handle_one_request(self) -> None: ... def handle_expect_100(self) -> bool: ... def send_error(self, code: int, message: Optional[str] = ..., explain: Optional[str] = ...) -> None: ... def send_response(self, code: int, message: Optional[str] = ...) -> None: ... def send_header(self, keyword: str, value: str) -> None: ... def send_response_only(self, code: int, message: Optional[str] = ...) -> None: ... def end_headers(self) -> None: ... def flush_headers(self) -> None: ... def log_request(self, code: Union[int, str] = ..., size: Union[int, str] = ...) -> None: ... def log_error(self, format: str, *args: Any) -> None: ... def log_message(self, format: str, *args: Any) -> None: ... def version_string(self) -> str: ... def date_time_string(self, timestamp: Optional[int] = ...) -> str: ... def log_date_time_string(self) -> str: ... def address_string(self) -> str: ... def parse_request(self) -> bool: ... # Undocumented class SimpleHTTPRequestHandler(BaseHTTPRequestHandler): extensions_map: Dict[str, str] if sys.version_info >= (3, 7): def __init__( self, request: bytes, client_address: Tuple[str, int], server: socketserver.BaseServer, directory: Optional[Union[str, _PathLike[str]]] = ..., ) -> None: ... else: def __init__(self, request: bytes, client_address: Tuple[str, int], server: socketserver.BaseServer) -> None: ... def do_GET(self) -> None: ... def do_HEAD(self) -> None: ... class CGIHTTPRequestHandler(SimpleHTTPRequestHandler): cgi_directories: List[str] def do_POST(self) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/imp.pyi0000664000175000017500000000444700000000000022435 0ustar00davedave00000000000000import os import types from _typeshed import StrPath from typing import IO, Any, List, Optional, Protocol, Tuple, TypeVar, Union from _imp import ( acquire_lock as acquire_lock, create_dynamic as create_dynamic, get_frozen_object as get_frozen_object, init_frozen as init_frozen, is_builtin as is_builtin, is_frozen as is_frozen, is_frozen_package as is_frozen_package, lock_held as lock_held, release_lock as release_lock, ) _T = TypeVar("_T") SEARCH_ERROR: int PY_SOURCE: int PY_COMPILED: int C_EXTENSION: int PY_RESOURCE: int PKG_DIRECTORY: int C_BUILTIN: int PY_FROZEN: int PY_CODERESOURCE: int IMP_HOOK: int def new_module(name: str) -> types.ModuleType: ... def get_magic() -> bytes: ... def get_tag() -> str: ... def cache_from_source(path: StrPath, debug_override: Optional[bool] = ...) -> str: ... def source_from_cache(path: StrPath) -> str: ... def get_suffixes() -> List[Tuple[str, str, int]]: ... class NullImporter: def __init__(self, path: StrPath) -> None: ... def find_module(self, fullname: Any) -> None: ... # Technically, a text file has to support a slightly different set of operations than a binary file, # but we ignore that here. class _FileLike(Protocol): closed: bool mode: str def read(self) -> Union[str, bytes]: ... def close(self) -> Any: ... def __enter__(self) -> Any: ... def __exit__(self, *args: Any) -> Any: ... # PathLike doesn't work for the pathname argument here def load_source(name: str, pathname: str, file: Optional[_FileLike] = ...) -> types.ModuleType: ... def load_compiled(name: str, pathname: str, file: Optional[_FileLike] = ...) -> types.ModuleType: ... def load_package(name: str, path: StrPath) -> types.ModuleType: ... def load_module(name: str, file: Optional[_FileLike], filename: str, details: Tuple[str, str, int]) -> types.ModuleType: ... # IO[Any] is a TextIOWrapper if name is a .py file, and a FileIO otherwise. def find_module( name: str, path: Union[None, List[str], List[os.PathLike[str]], List[StrPath]] = ... ) -> Tuple[IO[Any], str, Tuple[str, str, int]]: ... def reload(module: types.ModuleType) -> types.ModuleType: ... def init_builtin(name: str) -> Optional[types.ModuleType]: ... def load_dynamic(name: str, path: str, file: Any = ...) -> types.ModuleType: ... # file argument is ignored ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4343793 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/importlib/0000775000175000017500000000000000000000000023115 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/importlib/__init__.pyi0000664000175000017500000000107300000000000025400 0ustar00davedave00000000000000import types from importlib.abc import Loader from typing import Any, Mapping, Optional, Sequence def __import__( name: str, globals: Optional[Mapping[str, Any]] = ..., locals: Optional[Mapping[str, Any]] = ..., fromlist: Sequence[str] = ..., level: int = ..., ) -> types.ModuleType: ... def import_module(name: str, package: Optional[str] = ...) -> types.ModuleType: ... def find_loader(name: str, path: Optional[str] = ...) -> Optional[Loader]: ... def invalidate_caches() -> None: ... def reload(module: types.ModuleType) -> types.ModuleType: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/importlib/abc.pyi0000664000175000017500000000757000000000000024376 0ustar00davedave00000000000000import os import sys import types from abc import ABCMeta, abstractmethod from typing import IO, Any, Iterator, Mapping, Optional, Sequence, Tuple, Union from typing_extensions import Literal # Loader is exported from this module, but for circular import reasons # exists in its own stub file (with ModuleSpec and ModuleType). from _importlib_modulespec import Loader as Loader, ModuleSpec # Exported _Path = Union[bytes, str] class Finder(metaclass=ABCMeta): ... class ResourceLoader(Loader): @abstractmethod def get_data(self, path: _Path) -> bytes: ... class InspectLoader(Loader): def is_package(self, fullname: str) -> bool: ... def get_code(self, fullname: str) -> Optional[types.CodeType]: ... def load_module(self, fullname: str) -> types.ModuleType: ... @abstractmethod def get_source(self, fullname: str) -> Optional[str]: ... def exec_module(self, module: types.ModuleType) -> None: ... @staticmethod def source_to_code(data: Union[bytes, str], path: str = ...) -> types.CodeType: ... class ExecutionLoader(InspectLoader): @abstractmethod def get_filename(self, fullname: str) -> _Path: ... def get_code(self, fullname: str) -> Optional[types.CodeType]: ... class SourceLoader(ResourceLoader, ExecutionLoader, metaclass=ABCMeta): def path_mtime(self, path: _Path) -> float: ... def set_data(self, path: _Path, data: bytes) -> None: ... def get_source(self, fullname: str) -> Optional[str]: ... def path_stats(self, path: _Path) -> Mapping[str, Any]: ... class MetaPathFinder(Finder): def find_module(self, fullname: str, path: Optional[Sequence[_Path]]) -> Optional[Loader]: ... def invalidate_caches(self) -> None: ... # Not defined on the actual class, but expected to exist. def find_spec( self, fullname: str, path: Optional[Sequence[_Path]], target: Optional[types.ModuleType] = ... ) -> Optional[ModuleSpec]: ... class PathEntryFinder(Finder): def find_module(self, fullname: str) -> Optional[Loader]: ... def find_loader(self, fullname: str) -> Tuple[Optional[Loader], Sequence[_Path]]: ... def invalidate_caches(self) -> None: ... # Not defined on the actual class, but expected to exist. def find_spec(self, fullname: str, target: Optional[types.ModuleType] = ...) -> Optional[ModuleSpec]: ... class FileLoader(ResourceLoader, ExecutionLoader, metaclass=ABCMeta): name: str path: _Path def __init__(self, fullname: str, path: _Path) -> None: ... def get_data(self, path: _Path) -> bytes: ... def get_filename(self, fullname: str) -> _Path: ... if sys.version_info >= (3, 7): _PathLike = Union[bytes, str, os.PathLike[Any]] class ResourceReader(metaclass=ABCMeta): @abstractmethod def open_resource(self, resource: _PathLike) -> IO[bytes]: ... @abstractmethod def resource_path(self, resource: _PathLike) -> str: ... @abstractmethod def is_resource(self, name: str) -> bool: ... @abstractmethod def contents(self) -> Iterator[str]: ... if sys.version_info >= (3, 9): from typing import Protocol, runtime_checkable @runtime_checkable class Traversable(Protocol): @abstractmethod def iterdir(self) -> Iterator[Traversable]: ... @abstractmethod def read_bytes(self) -> bytes: ... @abstractmethod def read_text(self, encoding: Optional[str] = ...) -> str: ... @abstractmethod def is_dir(self) -> bool: ... @abstractmethod def is_file(self) -> bool: ... @abstractmethod def joinpath(self, child: Traversable) -> Traversable: ... @abstractmethod def __truediv__(self, child: Traversable) -> Traversable: ... @abstractmethod def open(self, mode: Literal["r", "rb"] = ..., *args: Any, **kwargs: Any) -> IO: ... @property @abstractmethod def name(self) -> str: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/importlib/machinery.pyi0000664000175000017500000000764600000000000025634 0ustar00davedave00000000000000import importlib.abc import types from typing import Callable, List, Optional, Sequence, Tuple, Union # ModuleSpec is exported from this module, but for circular import # reasons exists in its own stub file (with Loader and ModuleType). from _importlib_modulespec import Loader, ModuleSpec as ModuleSpec # Exported class BuiltinImporter(importlib.abc.MetaPathFinder, importlib.abc.InspectLoader): # MetaPathFinder @classmethod def find_module(cls, fullname: str, path: Optional[Sequence[importlib.abc._Path]]) -> Optional[importlib.abc.Loader]: ... @classmethod def find_spec( cls, fullname: str, path: Optional[Sequence[importlib.abc._Path]], target: Optional[types.ModuleType] = ... ) -> Optional[ModuleSpec]: ... # InspectLoader @classmethod def is_package(cls, fullname: str) -> bool: ... @classmethod def load_module(cls, fullname: str) -> types.ModuleType: ... @classmethod def get_code(cls, fullname: str) -> None: ... @classmethod def get_source(cls, fullname: str) -> None: ... # Loader @staticmethod def module_repr(module: types.ModuleType) -> str: ... @classmethod def create_module(cls, spec: ModuleSpec) -> Optional[types.ModuleType]: ... @classmethod def exec_module(cls, module: types.ModuleType) -> None: ... class FrozenImporter(importlib.abc.MetaPathFinder, importlib.abc.InspectLoader): # MetaPathFinder @classmethod def find_module(cls, fullname: str, path: Optional[Sequence[importlib.abc._Path]]) -> Optional[importlib.abc.Loader]: ... @classmethod def find_spec( cls, fullname: str, path: Optional[Sequence[importlib.abc._Path]], target: Optional[types.ModuleType] = ... ) -> Optional[ModuleSpec]: ... # InspectLoader @classmethod def is_package(cls, fullname: str) -> bool: ... @classmethod def load_module(cls, fullname: str) -> types.ModuleType: ... @classmethod def get_code(cls, fullname: str) -> None: ... @classmethod def get_source(cls, fullname: str) -> None: ... # Loader @staticmethod def module_repr(module: types.ModuleType) -> str: ... @classmethod def create_module(cls, spec: ModuleSpec) -> Optional[types.ModuleType]: ... @staticmethod def exec_module(module: types.ModuleType) -> None: ... class WindowsRegistryFinder(importlib.abc.MetaPathFinder): @classmethod def find_module(cls, fullname: str, path: Optional[Sequence[importlib.abc._Path]]) -> Optional[importlib.abc.Loader]: ... @classmethod def find_spec( cls, fullname: str, path: Optional[Sequence[importlib.abc._Path]], target: Optional[types.ModuleType] = ... ) -> Optional[ModuleSpec]: ... class PathFinder: @classmethod def invalidate_caches(cls) -> None: ... @classmethod def find_spec( cls, fullname: str, path: Optional[Sequence[Union[bytes, str]]] = ..., target: Optional[types.ModuleType] = ... ) -> Optional[ModuleSpec]: ... @classmethod def find_module(cls, fullname: str, path: Optional[Sequence[Union[bytes, str]]] = ...) -> Optional[Loader]: ... SOURCE_SUFFIXES: List[str] DEBUG_BYTECODE_SUFFIXES: List[str] OPTIMIZED_BYTECODE_SUFFIXES: List[str] BYTECODE_SUFFIXES: List[str] EXTENSION_SUFFIXES: List[str] def all_suffixes() -> List[str]: ... class FileFinder(importlib.abc.PathEntryFinder): path: str def __init__(self, path: str, *loader_details: Tuple[importlib.abc.Loader, List[str]]) -> None: ... @classmethod def path_hook( cls, *loader_details: Tuple[importlib.abc.Loader, List[str]] ) -> Callable[[str], importlib.abc.PathEntryFinder]: ... class SourceFileLoader(importlib.abc.FileLoader, importlib.abc.SourceLoader): ... class SourcelessFileLoader(importlib.abc.FileLoader, importlib.abc.SourceLoader): ... class ExtensionFileLoader(importlib.abc.ExecutionLoader): def get_filename(self, fullname: str) -> importlib.abc._Path: ... def get_source(self, fullname: str) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/importlib/metadata.pyi0000664000175000017500000000731200000000000025423 0ustar00davedave00000000000000import abc import os import pathlib import sys from email.message import Message from importlib.abc import MetaPathFinder from pathlib import Path from typing import Any, Dict, Iterable, List, NamedTuple, Optional, Tuple, Union, overload if sys.version_info >= (3, 8): class PackageNotFoundError(ModuleNotFoundError): ... class EntryPointBase(NamedTuple): name: str value: str group: str class EntryPoint(EntryPointBase): def load(self) -> Any: ... # Callable[[], Any] or an importable module @property def extras(self) -> List[str]: ... class PackagePath(pathlib.PurePosixPath): def read_text(self, encoding: str = ...) -> str: ... def read_binary(self) -> bytes: ... def locate(self) -> os.PathLike[str]: ... # The following attributes are not defined on PackagePath, but are dynamically added by Distribution.files: hash: Optional[FileHash] size: Optional[int] dist: Distribution class FileHash: mode: str value: str def __init__(self, spec: str) -> None: ... class Distribution: @abc.abstractmethod def read_text(self, filename: str) -> Optional[str]: ... @abc.abstractmethod def locate_file(self, path: Union[os.PathLike[str], str]) -> os.PathLike[str]: ... @classmethod def from_name(cls, name: str) -> Distribution: ... @overload @classmethod def discover(cls, *, context: DistributionFinder.Context) -> Iterable[Distribution]: ... @overload @classmethod def discover( cls, *, context: None = ..., name: Optional[str] = ..., path: List[str] = ..., **kwargs: Any ) -> Iterable[Distribution]: ... @staticmethod def at(path: Union[str, os.PathLike[str]]) -> PathDistribution: ... @property def metadata(self) -> Message: ... @property def version(self) -> str: ... @property def entry_points(self) -> List[EntryPoint]: ... @property def files(self) -> Optional[List[PackagePath]]: ... @property def requires(self) -> Optional[List[str]]: ... class DistributionFinder(MetaPathFinder): class Context: name: Optional[str] def __init__(self, *, name: Optional[str] = ..., path: List[str] = ..., **kwargs: Any) -> None: ... @property def path(self) -> List[str]: ... @property def pattern(self) -> str: ... @abc.abstractmethod def find_distributions(self, context: Context = ...) -> Iterable[Distribution]: ... class MetadataPathFinder(DistributionFinder): @classmethod def find_distributions(cls, context: DistributionFinder.Context = ...) -> Iterable[PathDistribution]: ... class PathDistribution(Distribution): def __init__(self, path: Path) -> None: ... def read_text(self, filename: Union[str, os.PathLike[str]]) -> str: ... def locate_file(self, path: Union[str, os.PathLike[str]]) -> os.PathLike[str]: ... def distribution(distribution_name: str) -> Distribution: ... @overload def distributions(*, context: DistributionFinder.Context) -> Iterable[Distribution]: ... @overload def distributions( *, context: None = ..., name: Optional[str] = ..., path: List[str] = ..., **kwargs: Any ) -> Iterable[Distribution]: ... def metadata(distribution_name: str) -> Message: ... def version(distribution_name: str) -> str: ... def entry_points() -> Dict[str, Tuple[EntryPoint, ...]]: ... def files(distribution_name: str) -> Optional[List[PackagePath]]: ... def requires(distribution_name: str) -> Optional[List[str]]: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/importlib/resources.pyi0000664000175000017500000000200200000000000025644 0ustar00davedave00000000000000import sys # This is a >=3.7 module, so we conditionally include its source. if sys.version_info >= (3, 7): import os from pathlib import Path from types import ModuleType from typing import BinaryIO, ContextManager, Iterator, TextIO, Union Package = Union[str, ModuleType] Resource = Union[str, os.PathLike] def open_binary(package: Package, resource: Resource) -> BinaryIO: ... def open_text(package: Package, resource: Resource, encoding: str = ..., errors: str = ...) -> TextIO: ... def read_binary(package: Package, resource: Resource) -> bytes: ... def read_text(package: Package, resource: Resource, encoding: str = ..., errors: str = ...) -> str: ... def path(package: Package, resource: Resource) -> ContextManager[Path]: ... def is_resource(package: Package, name: str) -> bool: ... def contents(package: Package) -> Iterator[str]: ... if sys.version_info >= (3, 9): from importlib.abc import Traversable def files(package: Package) -> Traversable: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/importlib/util.pyi0000664000175000017500000000336600000000000024625 0ustar00davedave00000000000000import importlib.abc import importlib.machinery import os import types from typing import Any, Callable, List, Optional, Union def module_for_loader(fxn: Callable[..., types.ModuleType]) -> Callable[..., types.ModuleType]: ... def set_loader(fxn: Callable[..., types.ModuleType]) -> Callable[..., types.ModuleType]: ... def set_package(fxn: Callable[..., types.ModuleType]) -> Callable[..., types.ModuleType]: ... def resolve_name(name: str, package: str) -> str: ... MAGIC_NUMBER: bytes def cache_from_source(path: str, debug_override: Optional[bool] = ..., *, optimization: Optional[Any] = ...) -> str: ... def source_from_cache(path: str) -> str: ... def decode_source(source_bytes: bytes) -> str: ... def find_spec(name: str, package: Optional[str] = ...) -> Optional[importlib.machinery.ModuleSpec]: ... def spec_from_loader( name: str, loader: Optional[importlib.abc.Loader], *, origin: Optional[str] = ..., loader_state: Optional[Any] = ..., is_package: Optional[bool] = ..., ) -> importlib.machinery.ModuleSpec: ... def spec_from_file_location( name: str, location: Union[str, bytes, os.PathLike[str], os.PathLike[bytes]], *, loader: Optional[importlib.abc.Loader] = ..., submodule_search_locations: Optional[List[str]] = ..., ) -> importlib.machinery.ModuleSpec: ... def module_from_spec(spec: importlib.machinery.ModuleSpec) -> types.ModuleType: ... class LazyLoader(importlib.abc.Loader): def __init__(self, loader: importlib.abc.Loader) -> None: ... @classmethod def factory(cls, loader: importlib.abc.Loader) -> Callable[..., LazyLoader]: ... def create_module(self, spec: importlib.machinery.ModuleSpec) -> Optional[types.ModuleType]: ... def exec_module(self, module: types.ModuleType) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/inspect.pyi0000664000175000017500000002331100000000000023304 0ustar00davedave00000000000000import enum import sys from collections import OrderedDict from types import CodeType, FrameType, FunctionType, MethodType, ModuleType, TracebackType from typing import ( AbstractSet, Any, Callable, ClassVar, Dict, Generator, List, Mapping, NamedTuple, Optional, Sequence, Tuple, Type, Union, ) from typing_extensions import Literal # # Types and members # class EndOfBlock(Exception): ... class BlockFinder: indent: int islambda: bool started: bool passline: bool indecorator: bool decoratorhasargs: bool last: int def tokeneater(self, type: int, token: str, srowcol: Tuple[int, int], erowcol: Tuple[int, int], line: str) -> None: ... CO_OPTIMIZED: int CO_NEWLOCALS: int CO_VARARGS: int CO_VARKEYWORDS: int CO_NESTED: int CO_GENERATOR: int CO_NOFREE: int CO_COROUTINE: int CO_ITERABLE_COROUTINE: int CO_ASYNC_GENERATOR: int TPFLAGS_IS_ABSTRACT: int def getmembers(object: object, predicate: Optional[Callable[[Any], bool]] = ...) -> List[Tuple[str, Any]]: ... def getmodulename(path: str) -> Optional[str]: ... def ismodule(object: object) -> bool: ... def isclass(object: object) -> bool: ... def ismethod(object: object) -> bool: ... def isfunction(object: object) -> bool: ... if sys.version_info >= (3, 8): def isgeneratorfunction(obj: object) -> bool: ... def iscoroutinefunction(obj: object) -> bool: ... else: def isgeneratorfunction(object: object) -> bool: ... def iscoroutinefunction(object: object) -> bool: ... def isgenerator(object: object) -> bool: ... def iscoroutine(object: object) -> bool: ... def isawaitable(object: object) -> bool: ... if sys.version_info >= (3, 8): def isasyncgenfunction(obj: object) -> bool: ... else: def isasyncgenfunction(object: object) -> bool: ... def isasyncgen(object: object) -> bool: ... def istraceback(object: object) -> bool: ... def isframe(object: object) -> bool: ... def iscode(object: object) -> bool: ... def isbuiltin(object: object) -> bool: ... def isroutine(object: object) -> bool: ... def isabstract(object: object) -> bool: ... def ismethoddescriptor(object: object) -> bool: ... def isdatadescriptor(object: object) -> bool: ... def isgetsetdescriptor(object: object) -> bool: ... def ismemberdescriptor(object: object) -> bool: ... # # Retrieving source code # _SourceObjectType = Union[ModuleType, Type[Any], MethodType, FunctionType, TracebackType, FrameType, CodeType, Callable[..., Any]] def findsource(object: _SourceObjectType) -> Tuple[List[str], int]: ... def getabsfile(object: _SourceObjectType, _filename: Optional[str] = ...) -> str: ... def getblock(lines: Sequence[str]) -> Sequence[str]: ... def getdoc(object: object) -> Optional[str]: ... def getcomments(object: object) -> Optional[str]: ... def getfile(object: _SourceObjectType) -> str: ... def getmodule(object: object, _filename: Optional[str] = ...) -> Optional[ModuleType]: ... def getsourcefile(object: _SourceObjectType) -> Optional[str]: ... def getsourcelines(object: _SourceObjectType) -> Tuple[List[str], int]: ... def getsource(object: _SourceObjectType) -> str: ... def cleandoc(doc: str) -> str: ... def indentsize(line: str) -> int: ... # # Introspecting callables with the Signature object # def signature(obj: Callable[..., Any], *, follow_wrapped: bool = ...) -> Signature: ... class Signature: def __init__(self, parameters: Optional[Sequence[Parameter]] = ..., *, return_annotation: Any = ...) -> None: ... # TODO: can we be more specific here? empty: object = ... parameters: Mapping[str, Parameter] # TODO: can we be more specific here? return_annotation: Any def bind(self, *args: Any, **kwargs: Any) -> BoundArguments: ... def bind_partial(self, *args: Any, **kwargs: Any) -> BoundArguments: ... def replace(self, *, parameters: Optional[Sequence[Parameter]] = ..., return_annotation: Any = ...) -> Signature: ... @classmethod def from_callable(cls, obj: Callable[..., Any], *, follow_wrapped: bool = ...) -> Signature: ... # The name is the same as the enum's name in CPython class _ParameterKind(enum.IntEnum): POSITIONAL_ONLY: int POSITIONAL_OR_KEYWORD: int VAR_POSITIONAL: int KEYWORD_ONLY: int VAR_KEYWORD: int if sys.version_info >= (3, 8): description: str class Parameter: def __init__(self, name: str, kind: _ParameterKind, *, default: Any = ..., annotation: Any = ...) -> None: ... empty: Any = ... name: str default: Any annotation: Any kind: _ParameterKind POSITIONAL_ONLY: ClassVar[Literal[_ParameterKind.POSITIONAL_ONLY]] POSITIONAL_OR_KEYWORD: ClassVar[Literal[_ParameterKind.POSITIONAL_OR_KEYWORD]] VAR_POSITIONAL: ClassVar[Literal[_ParameterKind.VAR_POSITIONAL]] KEYWORD_ONLY: ClassVar[Literal[_ParameterKind.KEYWORD_ONLY]] VAR_KEYWORD: ClassVar[Literal[_ParameterKind.VAR_KEYWORD]] def replace( self, *, name: Optional[str] = ..., kind: Optional[_ParameterKind] = ..., default: Any = ..., annotation: Any = ... ) -> Parameter: ... class BoundArguments: arguments: OrderedDict[str, Any] args: Tuple[Any, ...] kwargs: Dict[str, Any] signature: Signature def __init__(self, signature: Signature, arguments: OrderedDict[str, Any]) -> None: ... def apply_defaults(self) -> None: ... # # Classes and functions # # TODO: The actual return type should be List[_ClassTreeItem] but mypy doesn't # seem to be supporting this at the moment: # _ClassTreeItem = Union[List[_ClassTreeItem], Tuple[type, Tuple[type, ...]]] def getclasstree(classes: List[type], unique: bool = ...) -> Any: ... class ArgSpec(NamedTuple): args: List[str] varargs: Optional[str] keywords: Optional[str] defaults: Tuple[Any, ...] class Arguments(NamedTuple): args: List[str] varargs: Optional[str] varkw: Optional[str] def getargs(co: CodeType) -> Arguments: ... def getargspec(func: object) -> ArgSpec: ... class FullArgSpec(NamedTuple): args: List[str] varargs: Optional[str] varkw: Optional[str] defaults: Optional[Tuple[Any, ...]] kwonlyargs: List[str] kwonlydefaults: Optional[Dict[str, Any]] annotations: Dict[str, Any] def getfullargspec(func: object) -> FullArgSpec: ... class ArgInfo(NamedTuple): args: List[str] varargs: Optional[str] keywords: Optional[str] locals: Dict[str, Any] def getargvalues(frame: FrameType) -> ArgInfo: ... def formatannotation(annotation: object, base_module: Optional[str] = ...) -> str: ... def formatannotationrelativeto(object: object) -> Callable[[object], str]: ... def formatargspec( args: List[str], varargs: Optional[str] = ..., varkw: Optional[str] = ..., defaults: Optional[Tuple[Any, ...]] = ..., kwonlyargs: Optional[Sequence[str]] = ..., kwonlydefaults: Optional[Dict[str, Any]] = ..., annotations: Dict[str, Any] = ..., formatarg: Callable[[str], str] = ..., formatvarargs: Callable[[str], str] = ..., formatvarkw: Callable[[str], str] = ..., formatvalue: Callable[[Any], str] = ..., formatreturns: Callable[[Any], str] = ..., formatannotation: Callable[[Any], str] = ..., ) -> str: ... def formatargvalues( args: List[str], varargs: Optional[str], varkw: Optional[str], locals: Optional[Dict[str, Any]], formatarg: Optional[Callable[[str], str]] = ..., formatvarargs: Optional[Callable[[str], str]] = ..., formatvarkw: Optional[Callable[[str], str]] = ..., formatvalue: Optional[Callable[[Any], str]] = ..., ) -> str: ... def getmro(cls: type) -> Tuple[type, ...]: ... def getcallargs(__func: Callable[..., Any], *args: Any, **kwds: Any) -> Dict[str, Any]: ... class ClosureVars(NamedTuple): nonlocals: Mapping[str, Any] globals: Mapping[str, Any] builtins: Mapping[str, Any] unbound: AbstractSet[str] def getclosurevars(func: Callable[..., Any]) -> ClosureVars: ... def unwrap(func: Callable[..., Any], *, stop: Optional[Callable[[Any], Any]] = ...) -> Any: ... # # The interpreter stack # class Traceback(NamedTuple): filename: str lineno: int function: str code_context: Optional[List[str]] index: Optional[int] # type: ignore class FrameInfo(NamedTuple): frame: FrameType filename: str lineno: int function: str code_context: Optional[List[str]] index: Optional[int] # type: ignore def getframeinfo(frame: Union[FrameType, TracebackType], context: int = ...) -> Traceback: ... def getouterframes(frame: Any, context: int = ...) -> List[FrameInfo]: ... def getinnerframes(tb: TracebackType, context: int = ...) -> List[FrameInfo]: ... def getlineno(frame: FrameType) -> int: ... def currentframe() -> Optional[FrameType]: ... def stack(context: int = ...) -> List[FrameInfo]: ... def trace(context: int = ...) -> List[FrameInfo]: ... # # Fetching attributes statically # def getattr_static(obj: object, attr: str, default: Optional[Any] = ...) -> Any: ... # # Current State of Generators and Coroutines # # TODO In the next two blocks of code, can we be more specific regarding the # type of the "enums"? GEN_CREATED: str GEN_RUNNING: str GEN_SUSPENDED: str GEN_CLOSED: str def getgeneratorstate(generator: Generator[Any, Any, Any]) -> str: ... CORO_CREATED: str CORO_RUNNING: str CORO_SUSPENDED: str CORO_CLOSED: str # TODO can we be more specific than "object"? def getcoroutinestate(coroutine: object) -> str: ... def getgeneratorlocals(generator: Generator[Any, Any, Any]) -> Dict[str, Any]: ... # TODO can we be more specific than "object"? def getcoroutinelocals(coroutine: object) -> Dict[str, Any]: ... # Create private type alias to avoid conflict with symbol of same # name created in Attribute class. _Object = object class Attribute(NamedTuple): name: str kind: str defining_class: type object: _Object def classify_class_attrs(cls: type) -> List[Attribute]: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/io.pyi0000664000175000017500000001651300000000000022254 0ustar00davedave00000000000000import builtins import codecs import sys from _typeshed import ReadableBuffer, WriteableBuffer from types import TracebackType from typing import IO, Any, BinaryIO, Callable, Iterable, Iterator, List, Optional, TextIO, Tuple, Type, TypeVar, Union DEFAULT_BUFFER_SIZE: int SEEK_SET: int SEEK_CUR: int SEEK_END: int _T = TypeVar("_T", bound=IOBase) open = builtins.open if sys.version_info >= (3, 8): def open_code(path: str) -> IO[bytes]: ... BlockingIOError = builtins.BlockingIOError class UnsupportedOperation(OSError, ValueError): ... class IOBase: def __iter__(self) -> Iterator[bytes]: ... def __next__(self) -> bytes: ... def __enter__(self: _T) -> _T: ... def __exit__( self, exc_type: Optional[Type[BaseException]], exc_val: Optional[BaseException], exc_tb: Optional[TracebackType] ) -> Optional[bool]: ... def close(self) -> None: ... def fileno(self) -> int: ... def flush(self) -> None: ... def isatty(self) -> bool: ... def readable(self) -> bool: ... def readlines(self, __hint: int = ...) -> List[bytes]: ... def seek(self, __offset: int, __whence: int = ...) -> int: ... def seekable(self) -> bool: ... def tell(self) -> int: ... def truncate(self, __size: Optional[int] = ...) -> int: ... def writable(self) -> bool: ... def writelines(self, __lines: Iterable[ReadableBuffer]) -> None: ... def readline(self, __size: Optional[int] = ...) -> bytes: ... def __del__(self) -> None: ... @property def closed(self) -> bool: ... def _checkClosed(self, msg: Optional[str] = ...) -> None: ... # undocumented class RawIOBase(IOBase): def readall(self) -> bytes: ... def readinto(self, __buffer: WriteableBuffer) -> Optional[int]: ... def write(self, __b: ReadableBuffer) -> Optional[int]: ... def read(self, __size: int = ...) -> Optional[bytes]: ... class BufferedIOBase(IOBase): raw: RawIOBase # This is not part of the BufferedIOBase API and may not exist on some implementations. def detach(self) -> RawIOBase: ... def readinto(self, __buffer: WriteableBuffer) -> int: ... def write(self, __buffer: ReadableBuffer) -> int: ... def readinto1(self, __buffer: WriteableBuffer) -> int: ... def read(self, __size: Optional[int] = ...) -> bytes: ... def read1(self, __size: int = ...) -> bytes: ... class FileIO(RawIOBase, BinaryIO): mode: str # Technically this is whatever is passed in as file, either a str, a bytes, or an int. name: Union[int, str] # type: ignore def __init__( self, file: Union[str, bytes, int], mode: str = ..., closefd: bool = ..., opener: Optional[Callable[[Union[int, str], str], int]] = ..., ) -> None: ... @property def closefd(self) -> bool: ... def write(self, __b: ReadableBuffer) -> int: ... def read(self, __size: int = ...) -> bytes: ... def __enter__(self: _T) -> _T: ... class BytesIO(BufferedIOBase, BinaryIO): def __init__(self, initial_bytes: bytes = ...) -> None: ... # BytesIO does not contain a "name" field. This workaround is necessary # to allow BytesIO sub-classes to add this field, as it is defined # as a read-only property on IO[]. name: Any def __enter__(self: _T) -> _T: ... def getvalue(self) -> bytes: ... def getbuffer(self) -> memoryview: ... if sys.version_info >= (3, 7): def read1(self, __size: Optional[int] = ...) -> bytes: ... else: def read1(self, __size: Optional[int]) -> bytes: ... # type: ignore class BufferedReader(BufferedIOBase, BinaryIO): def __enter__(self: _T) -> _T: ... def __init__(self, raw: RawIOBase, buffer_size: int = ...) -> None: ... def peek(self, __size: int = ...) -> bytes: ... if sys.version_info >= (3, 7): def read1(self, __size: int = ...) -> bytes: ... else: def read1(self, __size: int) -> bytes: ... # type: ignore class BufferedWriter(BufferedIOBase, BinaryIO): def __enter__(self: _T) -> _T: ... def __init__(self, raw: RawIOBase, buffer_size: int = ...) -> None: ... def write(self, __buffer: ReadableBuffer) -> int: ... class BufferedRandom(BufferedReader, BufferedWriter): def __enter__(self: _T) -> _T: ... def __init__(self, raw: RawIOBase, buffer_size: int = ...) -> None: ... def seek(self, __target: int, __whence: int = ...) -> int: ... if sys.version_info >= (3, 7): def read1(self, __size: int = ...) -> bytes: ... else: def read1(self, __size: int) -> bytes: ... # type: ignore class BufferedRWPair(BufferedIOBase): def __init__(self, reader: RawIOBase, writer: RawIOBase, buffer_size: int = ...) -> None: ... def peek(self, __size: int = ...) -> bytes: ... class TextIOBase(IOBase): encoding: str errors: Optional[str] newlines: Union[str, Tuple[str, ...], None] def __iter__(self) -> Iterator[str]: ... # type: ignore def __next__(self) -> str: ... # type: ignore def detach(self) -> BinaryIO: ... def write(self, __s: str) -> int: ... def writelines(self, __lines: Iterable[str]) -> None: ... # type: ignore def readline(self, __size: int = ...) -> str: ... # type: ignore def readlines(self, __hint: int = ...) -> List[str]: ... # type: ignore def read(self, __size: Optional[int] = ...) -> str: ... def tell(self) -> int: ... class TextIOWrapper(TextIOBase, TextIO): def __init__( self, buffer: IO[bytes], encoding: Optional[str] = ..., errors: Optional[str] = ..., newline: Optional[str] = ..., line_buffering: bool = ..., write_through: bool = ..., ) -> None: ... @property def buffer(self) -> BinaryIO: ... @property def closed(self) -> bool: ... @property def line_buffering(self) -> bool: ... if sys.version_info >= (3, 7): @property def write_through(self) -> bool: ... def reconfigure( self, *, encoding: Optional[str] = ..., errors: Optional[str] = ..., newline: Optional[str] = ..., line_buffering: Optional[bool] = ..., write_through: Optional[bool] = ..., ) -> None: ... # These are inherited from TextIOBase, but must exist in the stub to satisfy mypy. def __enter__(self: _T) -> _T: ... def __iter__(self) -> Iterator[str]: ... # type: ignore def __next__(self) -> str: ... # type: ignore def writelines(self, __lines: Iterable[str]) -> None: ... # type: ignore def readline(self, __size: int = ...) -> str: ... # type: ignore def readlines(self, __hint: int = ...) -> List[str]: ... # type: ignore def seek(self, __cookie: int, __whence: int = ...) -> int: ... class StringIO(TextIOWrapper): def __init__(self, initial_value: Optional[str] = ..., newline: Optional[str] = ...) -> None: ... # StringIO does not contain a "name" field. This workaround is necessary # to allow StringIO sub-classes to add this field, as it is defined # as a read-only property on IO[]. name: Any def getvalue(self) -> str: ... class IncrementalNewlineDecoder(codecs.IncrementalDecoder): def __init__(self, decoder: Optional[codecs.IncrementalDecoder], translate: bool, errors: str = ...) -> None: ... def decode(self, input: Union[bytes, str], final: bool = ...) -> str: ... @property def newlines(self) -> Optional[Union[str, Tuple[str, ...]]]: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/ipaddress.pyi0000664000175000017500000001220400000000000023614 0ustar00davedave00000000000000import sys from typing import Any, Container, Generic, Iterable, Iterator, Optional, SupportsInt, Tuple, TypeVar, overload # Undocumented length constants IPV4LENGTH: int IPV6LENGTH: int _A = TypeVar("_A", IPv4Address, IPv6Address) _N = TypeVar("_N", IPv4Network, IPv6Network) _T = TypeVar("_T") def ip_address(address: object) -> Any: ... # morally Union[IPv4Address, IPv6Address] def ip_network(address: object, strict: bool = ...) -> Any: ... # morally Union[IPv4Network, IPv6Network] def ip_interface(address: object) -> Any: ... # morally Union[IPv4Interface, IPv6Interface] class _IPAddressBase: def __eq__(self, other: Any) -> bool: ... def __ge__(self: _T, other: _T) -> bool: ... def __gt__(self: _T, other: _T) -> bool: ... def __le__(self: _T, other: _T) -> bool: ... def __lt__(self: _T, other: _T) -> bool: ... def __ne__(self, other: Any) -> bool: ... @property def compressed(self) -> str: ... @property def exploded(self) -> str: ... @property def reverse_pointer(self) -> str: ... @property def version(self) -> int: ... class _BaseAddress(_IPAddressBase, SupportsInt): def __init__(self, address: object) -> None: ... def __add__(self: _T, other: int) -> _T: ... def __hash__(self) -> int: ... def __int__(self) -> int: ... def __sub__(self: _T, other: int) -> _T: ... @property def is_global(self) -> bool: ... @property def is_link_local(self) -> bool: ... @property def is_loopback(self) -> bool: ... @property def is_multicast(self) -> bool: ... @property def is_private(self) -> bool: ... @property def is_reserved(self) -> bool: ... @property def is_unspecified(self) -> bool: ... @property def max_prefixlen(self) -> int: ... @property def packed(self) -> bytes: ... class _BaseNetwork(_IPAddressBase, Container[_A], Iterable[_A], Generic[_A]): network_address: _A netmask: _A def __init__(self, address: object, strict: bool = ...) -> None: ... def __contains__(self, other: Any) -> bool: ... def __getitem__(self, n: int) -> _A: ... def __iter__(self) -> Iterator[_A]: ... def address_exclude(self: _T, other: _T) -> Iterator[_T]: ... @property def broadcast_address(self) -> _A: ... def compare_networks(self: _T, other: _T) -> int: ... def hosts(self) -> Iterator[_A]: ... @property def is_global(self) -> bool: ... @property def is_link_local(self) -> bool: ... @property def is_loopback(self) -> bool: ... @property def is_multicast(self) -> bool: ... @property def is_private(self) -> bool: ... @property def is_reserved(self) -> bool: ... @property def is_unspecified(self) -> bool: ... @property def max_prefixlen(self) -> int: ... @property def num_addresses(self) -> int: ... def overlaps(self, other: _BaseNetwork[_A]) -> bool: ... @property def prefixlen(self) -> int: ... if sys.version_info >= (3, 7): def subnet_of(self: _T, other: _T) -> bool: ... def supernet_of(self: _T, other: _T) -> bool: ... def subnets(self: _T, prefixlen_diff: int = ..., new_prefix: Optional[int] = ...) -> Iterator[_T]: ... def supernet(self: _T, prefixlen_diff: int = ..., new_prefix: Optional[int] = ...) -> _T: ... @property def with_hostmask(self) -> str: ... @property def with_netmask(self) -> str: ... @property def with_prefixlen(self) -> str: ... @property def hostmask(self) -> _A: ... class _BaseInterface(_BaseAddress, Generic[_A, _N]): hostmask: _A netmask: _A network: _N @property def ip(self) -> _A: ... @property def with_hostmask(self) -> str: ... @property def with_netmask(self) -> str: ... @property def with_prefixlen(self) -> str: ... class IPv4Address(_BaseAddress): ... class IPv4Network(_BaseNetwork[IPv4Address]): ... class IPv4Interface(IPv4Address, _BaseInterface[IPv4Address, IPv4Network]): ... class IPv6Address(_BaseAddress): @property def ipv4_mapped(self) -> Optional[IPv4Address]: ... @property def is_site_local(self) -> bool: ... @property def sixtofour(self) -> Optional[IPv4Address]: ... @property def teredo(self) -> Optional[Tuple[IPv4Address, IPv4Address]]: ... class IPv6Network(_BaseNetwork[IPv6Address]): @property def is_site_local(self) -> bool: ... class IPv6Interface(IPv6Address, _BaseInterface[IPv6Address, IPv6Network]): ... def v4_int_to_packed(address: int) -> bytes: ... def v6_int_to_packed(address: int) -> bytes: ... @overload def summarize_address_range(first: IPv4Address, last: IPv4Address) -> Iterator[IPv4Network]: ... @overload def summarize_address_range(first: IPv6Address, last: IPv6Address) -> Iterator[IPv6Network]: ... def collapse_addresses(addresses: Iterable[_N]) -> Iterator[_N]: ... @overload def get_mixed_type_key(obj: _A) -> Tuple[int, _A]: ... @overload def get_mixed_type_key(obj: IPv4Network) -> Tuple[int, IPv4Address, IPv4Address]: ... @overload def get_mixed_type_key(obj: IPv6Network) -> Tuple[int, IPv6Address, IPv6Address]: ... class AddressValueError(ValueError): ... class NetmaskValueError(ValueError): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/itertools.pyi0000664000175000017500000001065400000000000023671 0ustar00davedave00000000000000import sys from typing import Any, Callable, Generic, Iterable, Iterator, Optional, Tuple, TypeVar, overload from typing_extensions import Literal _T = TypeVar("_T") _S = TypeVar("_S") _N = TypeVar("_N", int, float) Predicate = Callable[[_T], object] def count(start: _N = ..., step: _N = ...) -> Iterator[_N]: ... # more general types? class cycle(Iterator[_T], Generic[_T]): def __init__(self, iterable: Iterable[_T]) -> None: ... def __next__(self) -> _T: ... def __iter__(self) -> Iterator[_T]: ... @overload def repeat(object: _T) -> Iterator[_T]: ... @overload def repeat(object: _T, times: int) -> Iterator[_T]: ... if sys.version_info >= (3, 8): @overload def accumulate(iterable: Iterable[_T], func: Callable[[_T, _T], _T] = ...) -> Iterator[_T]: ... @overload def accumulate(iterable: Iterable[_T], func: Callable[[_S, _T], _S], initial: Optional[_S]) -> Iterator[_S]: ... else: def accumulate(iterable: Iterable[_T], func: Callable[[_T, _T], _T] = ...) -> Iterator[_T]: ... class chain(Iterator[_T], Generic[_T]): def __init__(self, *iterables: Iterable[_T]) -> None: ... def __next__(self) -> _T: ... def __iter__(self) -> Iterator[_T]: ... @staticmethod def from_iterable(iterable: Iterable[Iterable[_S]]) -> Iterator[_S]: ... def compress(data: Iterable[_T], selectors: Iterable[Any]) -> Iterator[_T]: ... def dropwhile(predicate: Predicate[_T], iterable: Iterable[_T]) -> Iterator[_T]: ... def filterfalse(predicate: Optional[Predicate[_T]], iterable: Iterable[_T]) -> Iterator[_T]: ... @overload def groupby(iterable: Iterable[_T], key: None = ...) -> Iterator[Tuple[_T, Iterator[_T]]]: ... @overload def groupby(iterable: Iterable[_T], key: Callable[[_T], _S]) -> Iterator[Tuple[_S, Iterator[_T]]]: ... @overload def islice(iterable: Iterable[_T], stop: Optional[int]) -> Iterator[_T]: ... @overload def islice(iterable: Iterable[_T], start: Optional[int], stop: Optional[int], step: Optional[int] = ...) -> Iterator[_T]: ... def starmap(func: Callable[..., _S], iterable: Iterable[Iterable[Any]]) -> Iterator[_S]: ... def takewhile(predicate: Predicate[_T], iterable: Iterable[_T]) -> Iterator[_T]: ... def tee(iterable: Iterable[_T], n: int = ...) -> Tuple[Iterator[_T], ...]: ... def zip_longest(*p: Iterable[Any], fillvalue: Any = ...) -> Iterator[Any]: ... _T1 = TypeVar("_T1") _T2 = TypeVar("_T2") _T3 = TypeVar("_T3") _T4 = TypeVar("_T4") _T5 = TypeVar("_T5") _T6 = TypeVar("_T6") @overload def product(iter1: Iterable[_T1]) -> Iterator[Tuple[_T1]]: ... @overload def product(iter1: Iterable[_T1], iter2: Iterable[_T2]) -> Iterator[Tuple[_T1, _T2]]: ... @overload def product(iter1: Iterable[_T1], iter2: Iterable[_T2], iter3: Iterable[_T3]) -> Iterator[Tuple[_T1, _T2, _T3]]: ... @overload def product( iter1: Iterable[_T1], iter2: Iterable[_T2], iter3: Iterable[_T3], iter4: Iterable[_T4] ) -> Iterator[Tuple[_T1, _T2, _T3, _T4]]: ... @overload def product( iter1: Iterable[_T1], iter2: Iterable[_T2], iter3: Iterable[_T3], iter4: Iterable[_T4], iter5: Iterable[_T5] ) -> Iterator[Tuple[_T1, _T2, _T3, _T4, _T5]]: ... @overload def product( iter1: Iterable[_T1], iter2: Iterable[_T2], iter3: Iterable[_T3], iter4: Iterable[_T4], iter5: Iterable[_T5], iter6: Iterable[_T6], ) -> Iterator[Tuple[_T1, _T2, _T3, _T4, _T5, _T6]]: ... @overload def product( iter1: Iterable[Any], iter2: Iterable[Any], iter3: Iterable[Any], iter4: Iterable[Any], iter5: Iterable[Any], iter6: Iterable[Any], iter7: Iterable[Any], *iterables: Iterable[Any], ) -> Iterator[Tuple[Any, ...]]: ... @overload def product(*iterables: Iterable[_T1], repeat: int) -> Iterator[Tuple[_T1, ...]]: ... @overload def product(*iterables: Iterable[Any], repeat: int = ...) -> Iterator[Tuple[Any, ...]]: ... def permutations(iterable: Iterable[_T], r: Optional[int] = ...) -> Iterator[Tuple[_T, ...]]: ... @overload def combinations(iterable: Iterable[_T], r: Literal[2]) -> Iterator[Tuple[_T, _T]]: ... @overload def combinations(iterable: Iterable[_T], r: Literal[3]) -> Iterator[Tuple[_T, _T, _T]]: ... @overload def combinations(iterable: Iterable[_T], r: Literal[4]) -> Iterator[Tuple[_T, _T, _T, _T]]: ... @overload def combinations(iterable: Iterable[_T], r: Literal[5]) -> Iterator[Tuple[_T, _T, _T, _T, _T]]: ... @overload def combinations(iterable: Iterable[_T], r: int) -> Iterator[Tuple[_T, ...]]: ... def combinations_with_replacement(iterable: Iterable[_T], r: int) -> Iterator[Tuple[_T, ...]]: ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4343793 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/json/0000775000175000017500000000000000000000000022065 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/json/__init__.pyi0000664000175000017500000000357700000000000024363 0ustar00davedave00000000000000from _typeshed import SupportsRead from typing import IO, Any, Callable, Dict, List, Optional, Tuple, Type, Union from .decoder import JSONDecodeError as JSONDecodeError, JSONDecoder as JSONDecoder from .encoder import JSONEncoder as JSONEncoder def dumps( obj: Any, *, skipkeys: bool = ..., ensure_ascii: bool = ..., check_circular: bool = ..., allow_nan: bool = ..., cls: Optional[Type[JSONEncoder]] = ..., indent: Union[None, int, str] = ..., separators: Optional[Tuple[str, str]] = ..., default: Optional[Callable[[Any], Any]] = ..., sort_keys: bool = ..., **kwds: Any, ) -> str: ... def dump( obj: Any, fp: IO[str], *, skipkeys: bool = ..., ensure_ascii: bool = ..., check_circular: bool = ..., allow_nan: bool = ..., cls: Optional[Type[JSONEncoder]] = ..., indent: Union[None, int, str] = ..., separators: Optional[Tuple[str, str]] = ..., default: Optional[Callable[[Any], Any]] = ..., sort_keys: bool = ..., **kwds: Any, ) -> None: ... def loads( s: Union[str, bytes], *, cls: Optional[Type[JSONDecoder]] = ..., object_hook: Optional[Callable[[Dict[Any, Any]], Any]] = ..., parse_float: Optional[Callable[[str], Any]] = ..., parse_int: Optional[Callable[[str], Any]] = ..., parse_constant: Optional[Callable[[str], Any]] = ..., object_pairs_hook: Optional[Callable[[List[Tuple[Any, Any]]], Any]] = ..., **kwds: Any, ) -> Any: ... def load( fp: SupportsRead[Union[str, bytes]], *, cls: Optional[Type[JSONDecoder]] = ..., object_hook: Optional[Callable[[Dict[Any, Any]], Any]] = ..., parse_float: Optional[Callable[[str], Any]] = ..., parse_int: Optional[Callable[[str], Any]] = ..., parse_constant: Optional[Callable[[str], Any]] = ..., object_pairs_hook: Optional[Callable[[List[Tuple[Any, Any]]], Any]] = ..., **kwds: Any, ) -> Any: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/json/decoder.pyi0000664000175000017500000000210200000000000024210 0ustar00davedave00000000000000from typing import Any, Callable, Dict, List, Optional, Tuple class JSONDecodeError(ValueError): msg: str doc: str pos: int lineno: int colno: int def __init__(self, msg: str, doc: str, pos: int) -> None: ... class JSONDecoder: object_hook: Callable[[Dict[str, Any]], Any] parse_float: Callable[[str], Any] parse_int: Callable[[str], Any] parse_constant: Callable[[str], Any] = ... strict: bool object_pairs_hook: Callable[[List[Tuple[str, Any]]], Any] def __init__( self, *, object_hook: Optional[Callable[[Dict[str, Any]], Any]] = ..., parse_float: Optional[Callable[[str], Any]] = ..., parse_int: Optional[Callable[[str], Any]] = ..., parse_constant: Optional[Callable[[str], Any]] = ..., strict: bool = ..., object_pairs_hook: Optional[Callable[[List[Tuple[str, Any]]], Any]] = ..., ) -> None: ... def decode(self, s: str, _w: Callable[..., Any] = ...) -> Any: ... # _w is undocumented def raw_decode(self, s: str, idx: int = ...) -> Tuple[Any, int]: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/json/encoder.pyi0000664000175000017500000000141300000000000024226 0ustar00davedave00000000000000from typing import Any, Callable, Iterator, Optional, Tuple class JSONEncoder: item_separator: str key_separator: str skipkeys: bool ensure_ascii: bool check_circular: bool allow_nan: bool sort_keys: bool indent: int def __init__( self, *, skipkeys: bool = ..., ensure_ascii: bool = ..., check_circular: bool = ..., allow_nan: bool = ..., sort_keys: bool = ..., indent: Optional[int] = ..., separators: Optional[Tuple[str, str]] = ..., default: Optional[Callable[..., Any]] = ..., ) -> None: ... def default(self, o: Any) -> Any: ... def encode(self, o: Any) -> str: ... def iterencode(self, o: Any, _one_shot: bool = ...) -> Iterator[str]: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/json/tool.pyi0000664000175000017500000000003000000000000023556 0ustar00davedave00000000000000def main() -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/lzma.pyi0000664000175000017500000001074400000000000022610 0ustar00davedave00000000000000import io from _typeshed import AnyPath, ReadableBuffer from typing import IO, Any, Mapping, Optional, Sequence, TextIO, TypeVar, Union, overload from typing_extensions import Literal _OpenBinaryWritingMode = Literal["w", "wb", "x", "xb", "a", "ab"] _OpenTextWritingMode = Literal["wt", "xt", "at"] _PathOrFile = Union[AnyPath, IO[bytes]] _FilterChain = Sequence[Mapping[str, Any]] _T = TypeVar("_T") FORMAT_AUTO: int FORMAT_XZ: int FORMAT_ALONE: int FORMAT_RAW: int CHECK_NONE: int CHECK_CRC32: int CHECK_CRC64: int CHECK_SHA256: int CHECK_ID_MAX: int CHECK_UNKNOWN: int FILTER_LZMA1: int FILTER_LZMA2: int FILTER_DELTA: int FILTER_X86: int FILTER_IA64: int FILTER_ARM: int FILTER_ARMTHUMB: int FILTER_SPARC: int FILTER_POWERPC: int MF_HC3: int MF_HC4: int MF_BT2: int MF_BT3: int MF_BT4: int MODE_FAST: int MODE_NORMAL: int PRESET_DEFAULT: int PRESET_EXTREME: int # from _lzma.c class LZMADecompressor(object): def __init__( self, format: Optional[int] = ..., memlimit: Optional[int] = ..., filters: Optional[_FilterChain] = ... ) -> None: ... def decompress(self, data: bytes, max_length: int = ...) -> bytes: ... @property def check(self) -> int: ... @property def eof(self) -> bool: ... @property def unused_data(self) -> bytes: ... @property def needs_input(self) -> bool: ... # from _lzma.c class LZMACompressor(object): def __init__( self, format: Optional[int] = ..., check: int = ..., preset: Optional[int] = ..., filters: Optional[_FilterChain] = ... ) -> None: ... def compress(self, data: bytes) -> bytes: ... def flush(self) -> bytes: ... class LZMAError(Exception): ... class LZMAFile(io.BufferedIOBase, IO[bytes]): def __init__( self, filename: Optional[_PathOrFile] = ..., mode: str = ..., *, format: Optional[int] = ..., check: int = ..., preset: Optional[int] = ..., filters: Optional[_FilterChain] = ..., ) -> None: ... def __enter__(self: _T) -> _T: ... def close(self) -> None: ... @property def closed(self) -> bool: ... def fileno(self) -> int: ... def seekable(self) -> bool: ... def readable(self) -> bool: ... def writable(self) -> bool: ... def peek(self, size: int = ...) -> bytes: ... def read(self, size: Optional[int] = ...) -> bytes: ... def read1(self, size: int = ...) -> bytes: ... def readline(self, size: Optional[int] = ...) -> bytes: ... def write(self, data: ReadableBuffer) -> int: ... def seek(self, offset: int, whence: int = ...) -> int: ... def tell(self) -> int: ... @overload def open( filename: _PathOrFile, mode: Literal["r", "rb"] = ..., *, format: Optional[int] = ..., check: Literal[-1] = ..., preset: None = ..., filters: Optional[_FilterChain] = ..., encoding: None = ..., errors: None = ..., newline: None = ..., ) -> LZMAFile: ... @overload def open( filename: _PathOrFile, mode: _OpenBinaryWritingMode, *, format: Optional[int] = ..., check: int = ..., preset: Optional[int] = ..., filters: Optional[_FilterChain] = ..., encoding: None = ..., errors: None = ..., newline: None = ..., ) -> LZMAFile: ... @overload def open( filename: AnyPath, mode: Literal["rt"], *, format: Optional[int] = ..., check: Literal[-1] = ..., preset: None = ..., filters: Optional[_FilterChain] = ..., encoding: Optional[str] = ..., errors: Optional[str] = ..., newline: Optional[str] = ..., ) -> TextIO: ... @overload def open( filename: AnyPath, mode: _OpenTextWritingMode, *, format: Optional[int] = ..., check: int = ..., preset: Optional[int] = ..., filters: Optional[_FilterChain] = ..., encoding: Optional[str] = ..., errors: Optional[str] = ..., newline: Optional[str] = ..., ) -> TextIO: ... @overload def open( filename: _PathOrFile, mode: str, *, format: Optional[int] = ..., check: int = ..., preset: Optional[int] = ..., filters: Optional[_FilterChain] = ..., encoding: Optional[str] = ..., errors: Optional[str] = ..., newline: Optional[str] = ..., ) -> Union[LZMAFile, TextIO]: ... def compress( data: bytes, format: int = ..., check: int = ..., preset: Optional[int] = ..., filters: Optional[_FilterChain] = ... ) -> bytes: ... def decompress(data: bytes, format: int = ..., memlimit: Optional[int] = ..., filters: Optional[_FilterChain] = ...) -> bytes: ... def is_check_supported(check: int) -> bool: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/macurl2path.pyi0000664000175000017500000000034100000000000024057 0ustar00davedave00000000000000import sys from typing import Union if sys.version_info < (3, 7): def url2pathname(pathname: str) -> str: ... def pathname2url(pathname: str) -> str: ... def _pncomp2url(component: Union[str, bytes]) -> str: ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4343793 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/multiprocessing/0000775000175000017500000000000000000000000024343 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/multiprocessing/__init__.pyi0000664000175000017500000000733200000000000026632 0ustar00davedave00000000000000import sys from logging import Logger from multiprocessing import connection, pool, sharedctypes, synchronize from multiprocessing.context import ( AuthenticationError as AuthenticationError, BaseContext, BufferTooShort as BufferTooShort, DefaultContext, Process as Process, ProcessError as ProcessError, SpawnContext, TimeoutError as TimeoutError, ) from multiprocessing.managers import SyncManager from multiprocessing.process import active_children as active_children, current_process as current_process # These are technically functions that return instances of these Queue classes. See #4313 for discussion from multiprocessing.queues import JoinableQueue as JoinableQueue, Queue as Queue, SimpleQueue as SimpleQueue from multiprocessing.spawn import freeze_support as freeze_support from typing import Any, Callable, Iterable, List, Optional, Sequence, Tuple, Union, overload from typing_extensions import Literal if sys.version_info >= (3, 8): from multiprocessing.process import parent_process as parent_process if sys.platform != "win32": from multiprocessing.context import ForkContext, ForkServerContext # N.B. The functions below are generated at runtime by partially applying # multiprocessing.context.BaseContext's methods, so the two signatures should # be identical (modulo self). # Sychronization primitives _LockLike = Union[synchronize.Lock, synchronize.RLock] def Barrier(parties: int, action: Optional[Callable[..., Any]] = ..., timeout: Optional[float] = ...) -> synchronize.Barrier: ... def BoundedSemaphore(value: int = ...) -> synchronize.BoundedSemaphore: ... def Condition(lock: Optional[_LockLike] = ...) -> synchronize.Condition: ... def Event() -> synchronize.Event: ... def Lock() -> synchronize.Lock: ... def RLock() -> synchronize.RLock: ... def Semaphore(value: int = ...) -> synchronize.Semaphore: ... def Pipe(duplex: bool = ...) -> Tuple[connection.Connection, connection.Connection]: ... def Pool( processes: Optional[int] = ..., initializer: Optional[Callable[..., Any]] = ..., initargs: Iterable[Any] = ..., maxtasksperchild: Optional[int] = ..., ) -> pool.Pool: ... # Functions Array and Value are copied from context.pyi. # See https://github.com/python/typeshed/blob/ac234f25927634e06d9c96df98d72d54dd80dfc4/stdlib/2and3/turtle.pyi#L284-L291 # for rationale def Array(typecode_or_type: Any, size_or_initializer: Union[int, Sequence[Any]], *, lock: bool = ...) -> sharedctypes._Array: ... def Value(typecode_or_type: Any, *args: Any, lock: bool = ...) -> sharedctypes._Value: ... # ----- multiprocessing function stubs ----- def allow_connection_pickling() -> None: ... def cpu_count() -> int: ... def get_logger() -> Logger: ... def log_to_stderr(level: Optional[Union[str, int]] = ...) -> Logger: ... def Manager() -> SyncManager: ... def set_executable(executable: str) -> None: ... def set_forkserver_preload(module_names: List[str]) -> None: ... def get_all_start_methods() -> List[str]: ... def get_start_method(allow_none: bool = ...) -> Optional[str]: ... def set_start_method(method: str, force: Optional[bool] = ...) -> None: ... if sys.platform != "win32": @overload def get_context(method: None = ...) -> DefaultContext: ... @overload def get_context(method: Literal["spawn"]) -> SpawnContext: ... @overload def get_context(method: Literal["fork"]) -> ForkContext: ... @overload def get_context(method: Literal["forkserver"]) -> ForkServerContext: ... @overload def get_context(method: str) -> BaseContext: ... else: @overload def get_context(method: None = ...) -> DefaultContext: ... @overload def get_context(method: Literal["spawn"]) -> SpawnContext: ... @overload def get_context(method: str) -> BaseContext: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/multiprocessing/connection.pyi0000664000175000017500000000505200000000000027227 0ustar00davedave00000000000000import socket import sys import types from typing import Any, Iterable, List, Optional, Tuple, Type, Union if sys.version_info >= (3, 8): from typing import SupportsIndex # https://docs.python.org/3/library/multiprocessing.html#address-formats _Address = Union[str, Tuple[str, int]] class _ConnectionBase: if sys.version_info >= (3, 8): def __init__(self, handle: SupportsIndex, readable: bool = ..., writable: bool = ...) -> None: ... else: def __init__(self, handle: int, readable: bool = ..., writable: bool = ...) -> None: ... @property def closed(self) -> bool: ... # undocumented @property def readable(self) -> bool: ... # undocumented @property def writable(self) -> bool: ... # undocumented def fileno(self) -> int: ... def close(self) -> None: ... def send_bytes(self, buf: bytes, offset: int = ..., size: Optional[int] = ...) -> None: ... def send(self, obj: Any) -> None: ... def recv_bytes(self, maxlength: Optional[int] = ...) -> bytes: ... def recv_bytes_into(self, buf: Any, offset: int = ...) -> int: ... def recv(self) -> Any: ... def poll(self, timeout: Optional[float] = ...) -> bool: ... def __enter__(self) -> _ConnectionBase: ... def __exit__( self, exc_type: Optional[Type[BaseException]], exc_value: Optional[BaseException], exc_tb: Optional[types.TracebackType] ) -> None: ... class Connection(_ConnectionBase): ... if sys.platform == "win32": class PipeConnection(_ConnectionBase): ... class Listener: def __init__( self, address: Optional[_Address] = ..., family: Optional[str] = ..., backlog: int = ..., authkey: Optional[bytes] = ... ) -> None: ... def accept(self) -> Connection: ... def close(self) -> None: ... @property def address(self) -> _Address: ... @property def last_accepted(self) -> Optional[_Address]: ... def __enter__(self) -> Listener: ... def __exit__( self, exc_type: Optional[Type[BaseException]], exc_value: Optional[BaseException], exc_tb: Optional[types.TracebackType] ) -> None: ... def deliver_challenge(connection: Connection, authkey: bytes) -> None: ... def answer_challenge(connection: Connection, authkey: bytes) -> None: ... def wait( object_list: Iterable[Union[Connection, socket.socket, int]], timeout: Optional[float] = ... ) -> List[Union[Connection, socket.socket, int]]: ... def Client(address: _Address, family: Optional[str] = ..., authkey: Optional[bytes] = ...) -> Connection: ... def Pipe(duplex: bool = ...) -> Tuple[Connection, Connection]: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/multiprocessing/context.pyi0000664000175000017500000001505200000000000026555 0ustar00davedave00000000000000import multiprocessing import sys from logging import Logger from multiprocessing import queues, sharedctypes, synchronize from multiprocessing.process import BaseProcess from typing import Any, Callable, Iterable, List, Optional, Sequence, Type, Union, overload from typing_extensions import Literal _LockLike = Union[synchronize.Lock, synchronize.RLock] class ProcessError(Exception): ... class BufferTooShort(ProcessError): ... class TimeoutError(ProcessError): ... class AuthenticationError(ProcessError): ... class BaseContext(object): Process: Type[BaseProcess] ProcessError: Type[Exception] BufferTooShort: Type[Exception] TimeoutError: Type[Exception] AuthenticationError: Type[Exception] # N.B. The methods below are applied at runtime to generate # multiprocessing.*, so the signatures should be identical (modulo self). @staticmethod def current_process() -> BaseProcess: ... if sys.version_info >= (3, 8): @staticmethod def parent_process() -> Optional[BaseProcess]: ... @staticmethod def active_children() -> List[BaseProcess]: ... def cpu_count(self) -> int: ... # TODO: change return to SyncManager once a stub exists in multiprocessing.managers def Manager(self) -> Any: ... # TODO: change return to Pipe once a stub exists in multiprocessing.connection def Pipe(self, duplex: bool = ...) -> Any: ... def Barrier( self, parties: int, action: Optional[Callable[..., Any]] = ..., timeout: Optional[float] = ... ) -> synchronize.Barrier: ... def BoundedSemaphore(self, value: int = ...) -> synchronize.BoundedSemaphore: ... def Condition(self, lock: Optional[_LockLike] = ...) -> synchronize.Condition: ... def Event(self) -> synchronize.Event: ... def Lock(self) -> synchronize.Lock: ... def RLock(self) -> synchronize.RLock: ... def Semaphore(self, value: int = ...) -> synchronize.Semaphore: ... def Queue(self, maxsize: int = ...) -> queues.Queue[Any]: ... def JoinableQueue(self, maxsize: int = ...) -> queues.JoinableQueue[Any]: ... def SimpleQueue(self) -> queues.SimpleQueue[Any]: ... def Pool( self, processes: Optional[int] = ..., initializer: Optional[Callable[..., Any]] = ..., initargs: Iterable[Any] = ..., maxtasksperchild: Optional[int] = ..., ) -> multiprocessing.pool.Pool: ... # TODO: typecode_or_type param is a ctype with a base class of _SimpleCData or array.typecode Need to figure out # how to handle the ctype # TODO: change return to RawValue once a stub exists in multiprocessing.sharedctypes def RawValue(self, typecode_or_type: Any, *args: Any) -> Any: ... # TODO: typecode_or_type param is a ctype with a base class of _SimpleCData or array.typecode Need to figure out # how to handle the ctype # TODO: change return to RawArray once a stub exists in multiprocessing.sharedctypes def RawArray(self, typecode_or_type: Any, size_or_initializer: Union[int, Sequence[Any]]) -> Any: ... # TODO: typecode_or_type param is a ctype with a base class of _SimpleCData or array.typecode Need to figure out # how to handle the ctype def Value(self, typecode_or_type: Any, *args: Any, lock: bool = ...) -> sharedctypes._Value: ... # TODO: typecode_or_type param is a ctype with a base class of _SimpleCData or array.typecode Need to figure out # how to handle the ctype def Array( self, typecode_or_type: Any, size_or_initializer: Union[int, Sequence[Any]], *, lock: bool = ... ) -> sharedctypes._Array: ... def freeze_support(self) -> None: ... def get_logger(self) -> Logger: ... def log_to_stderr(self, level: Optional[str] = ...) -> Logger: ... def allow_connection_pickling(self) -> None: ... def set_executable(self, executable: str) -> None: ... def set_forkserver_preload(self, module_names: List[str]) -> None: ... if sys.platform != "win32": @overload def get_context(self, method: None = ...) -> DefaultContext: ... @overload def get_context(self, method: Literal["spawn"]) -> SpawnContext: ... @overload def get_context(self, method: Literal["fork"]) -> ForkContext: ... @overload def get_context(self, method: Literal["forkserver"]) -> ForkServerContext: ... @overload def get_context(self, method: str) -> BaseContext: ... else: @overload def get_context(self, method: None = ...) -> DefaultContext: ... @overload def get_context(self, method: Literal["spawn"]) -> SpawnContext: ... @overload def get_context(self, method: str) -> BaseContext: ... def get_start_method(self, allow_none: bool = ...) -> str: ... def set_start_method(self, method: Optional[str], force: bool = ...) -> None: ... @property def reducer(self) -> str: ... @reducer.setter def reducer(self, reduction: str) -> None: ... def _check_available(self) -> None: ... class Process(BaseProcess): _start_method: Optional[str] @staticmethod def _Popen(process_obj: BaseProcess) -> DefaultContext: ... class DefaultContext(BaseContext): Process: Type[multiprocessing.Process] def __init__(self, context: BaseContext) -> None: ... def set_start_method(self, method: Optional[str], force: bool = ...) -> None: ... def get_start_method(self, allow_none: bool = ...) -> str: ... def get_all_start_methods(self) -> List[str]: ... if sys.platform != "win32": class ForkProcess(BaseProcess): _start_method: str @staticmethod def _Popen(process_obj: BaseProcess) -> Any: ... class SpawnProcess(BaseProcess): _start_method: str @staticmethod def _Popen(process_obj: BaseProcess) -> SpawnProcess: ... class ForkServerProcess(BaseProcess): _start_method: str @staticmethod def _Popen(process_obj: BaseProcess) -> Any: ... class ForkContext(BaseContext): _name: str Process: Type[ForkProcess] class SpawnContext(BaseContext): _name: str Process: Type[SpawnProcess] class ForkServerContext(BaseContext): _name: str Process: Type[ForkServerProcess] else: class SpawnProcess(BaseProcess): _start_method: str @staticmethod def _Popen(process_obj: BaseProcess) -> Any: ... class SpawnContext(BaseContext): _name: str Process: Type[SpawnProcess] def _force_start_method(method: str) -> None: ... def get_spawning_popen() -> Optional[Any]: ... def set_spawning_popen(popen: Any) -> None: ... def assert_spawning(obj: Any) -> None: ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4343793 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/multiprocessing/dummy/0000775000175000017500000000000000000000000025476 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/multiprocessing/dummy/__init__.pyi0000664000175000017500000000304400000000000027761 0ustar00davedave00000000000000import array import threading import weakref from queue import Queue as Queue from typing import Any, Callable, Iterable, List, Mapping, Optional, Sequence JoinableQueue = Queue Barrier = threading.Barrier BoundedSemaphore = threading.BoundedSemaphore Condition = threading.Condition Event = threading.Event Lock = threading.Lock RLock = threading.RLock Semaphore = threading.Semaphore class DummyProcess(threading.Thread): _children: weakref.WeakKeyDictionary[Any, Any] _parent: threading.Thread _pid: None _start_called: int exitcode: Optional[int] def __init__( self, group: Any = ..., target: Optional[Callable[..., Any]] = ..., name: Optional[str] = ..., args: Iterable[Any] = ..., kwargs: Mapping[str, Any] = ..., ) -> None: ... Process = DummyProcess class Namespace: def __init__(self, **kwds: Any) -> None: ... def __getattr__(self, __name: str) -> Any: ... def __setattr__(self, __name: str, __value: Any) -> None: ... class Value: _typecode: Any _value: Any value: Any def __init__(self, typecode: Any, value: Any, lock: Any = ...) -> None: ... def Array(typecode: Any, sequence: Sequence[Any], lock: Any = ...) -> array.array[Any]: ... def Manager() -> Any: ... def Pool( processes: Optional[int] = ..., initializer: Optional[Callable[..., Any]] = ..., initargs: Iterable[Any] = ... ) -> Any: ... def active_children() -> List[Any]: ... def current_process() -> threading.Thread: ... def freeze_support() -> None: ... def shutdown() -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/multiprocessing/dummy/connection.pyi0000664000175000017500000000262700000000000030367 0ustar00davedave00000000000000from queue import Queue from types import TracebackType from typing import Any, List, Optional, Tuple, Type, TypeVar, Union families: List[None] _TConnection = TypeVar("_TConnection", bound=Connection) _TListener = TypeVar("_TListener", bound=Listener) _Address = Union[str, Tuple[str, int]] class Connection(object): _in: Any _out: Any recv: Any recv_bytes: Any send: Any send_bytes: Any def __enter__(self: _TConnection) -> _TConnection: ... def __exit__( self, exc_type: Optional[Type[BaseException]], exc_val: Optional[BaseException], exc_tb: Optional[TracebackType] ) -> None: ... def __init__(self, _in: Any, _out: Any) -> None: ... def close(self) -> None: ... def poll(self, timeout: float = ...) -> bool: ... class Listener(object): _backlog_queue: Optional[Queue[Any]] @property def address(self) -> Optional[Queue[Any]]: ... def __enter__(self: _TListener) -> _TListener: ... def __exit__( self, exc_type: Optional[Type[BaseException]], exc_val: Optional[BaseException], exc_tb: Optional[TracebackType] ) -> None: ... def __init__(self, address: Optional[_Address] = ..., family: Optional[int] = ..., backlog: int = ...) -> None: ... def accept(self) -> Connection: ... def close(self) -> None: ... def Client(address: _Address) -> Connection: ... def Pipe(duplex: bool = ...) -> Tuple[Connection, Connection]: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/multiprocessing/managers.pyi0000664000175000017500000001075000000000000026666 0ustar00davedave00000000000000# NOTE: These are incomplete! import queue import sys import threading from typing import ( Any, AnyStr, Callable, ContextManager, Dict, Generic, Iterable, List, Mapping, Optional, Sequence, Tuple, TypeVar, Union, ) from .context import BaseContext if sys.version_info >= (3, 8): from .shared_memory import _SLT, ShareableList, SharedMemory _SharedMemory = SharedMemory _ShareableList = ShareableList if sys.version_info >= (3, 9): from types import GenericAlias _T = TypeVar("_T") _KT = TypeVar("_KT") _VT = TypeVar("_VT") class Namespace: def __init__(self, **kwds: Any) -> None: ... def __getattr__(self, __name: str) -> Any: ... def __setattr__(self, __name: str, __value: Any) -> None: ... _Namespace = Namespace class Token(object): typeid: Optional[Union[str, bytes]] address: Tuple[Union[str, bytes], int] id: Optional[Union[str, bytes, int]] def __init__( self, typeid: Optional[Union[bytes, str]], address: Tuple[Union[str, bytes], int], id: Optional[Union[str, bytes, int]] ) -> None: ... def __repr__(self) -> str: ... def __getstate__( self, ) -> Tuple[Optional[Union[str, bytes]], Tuple[Union[str, bytes], int], Optional[Union[str, bytes, int]]]: ... def __setstate__( self, state: Tuple[Optional[Union[str, bytes]], Tuple[Union[str, bytes], int], Optional[Union[str, bytes, int]]] ) -> None: ... class BaseProxy(object): _address_to_local: Dict[Any, Any] _mutex: Any def __init__( self, token: Any, serializer: str, manager: Any = ..., authkey: Optional[AnyStr] = ..., exposed: Any = ..., incref: bool = ..., manager_owned: bool = ..., ) -> None: ... def __deepcopy__(self, memo: Optional[Any]) -> Any: ... def _callmethod(self, methodname: str, args: Tuple[Any, ...] = ..., kwds: Dict[Any, Any] = ...) -> None: ... def _getvalue(self) -> Any: ... def __reduce__(self) -> Tuple[Any, Tuple[Any, Any, str, Dict[Any, Any]]]: ... class ValueProxy(BaseProxy, Generic[_T]): def get(self) -> _T: ... def set(self, value: _T) -> None: ... value: _T if sys.version_info >= (3, 9): def __class_getitem__(cls, item: Any) -> GenericAlias: ... # Returned by BaseManager.get_server() class Server: address: Any def serve_forever(self) -> None: ... class BaseManager(ContextManager[BaseManager]): def __init__( self, address: Optional[Any] = ..., authkey: Optional[bytes] = ..., serializer: str = ..., ctx: Optional[BaseContext] = ..., ) -> None: ... def get_server(self) -> Server: ... def connect(self) -> None: ... def start(self, initializer: Optional[Callable[..., Any]] = ..., initargs: Iterable[Any] = ...) -> None: ... def shutdown(self) -> None: ... # only available after start() was called def join(self, timeout: Optional[float] = ...) -> None: ... # undocumented @property def address(self) -> Any: ... @classmethod def register( cls, typeid: str, callable: Optional[Callable[..., Any]] = ..., proxytype: Any = ..., exposed: Optional[Sequence[str]] = ..., method_to_typeid: Optional[Mapping[str, str]] = ..., create_method: bool = ..., ) -> None: ... class SyncManager(BaseManager, ContextManager[SyncManager]): def BoundedSemaphore(self, value: Any = ...) -> threading.BoundedSemaphore: ... def Condition(self, lock: Any = ...) -> threading.Condition: ... def Event(self) -> threading.Event: ... def Lock(self) -> threading.Lock: ... def Namespace(self) -> _Namespace: ... def Queue(self, maxsize: int = ...) -> queue.Queue[Any]: ... def RLock(self) -> threading.RLock: ... def Semaphore(self, value: Any = ...) -> threading.Semaphore: ... def Array(self, typecode: Any, sequence: Sequence[_T]) -> Sequence[_T]: ... def Value(self, typecode: Any, value: _T) -> ValueProxy[_T]: ... def dict(self, sequence: Mapping[_KT, _VT] = ...) -> Dict[_KT, _VT]: ... def list(self, sequence: Sequence[_T] = ...) -> List[_T]: ... class RemoteError(Exception): ... if sys.version_info >= (3, 8): class SharedMemoryServer(Server): ... class SharedMemoryManager(BaseManager): def get_server(self) -> SharedMemoryServer: ... def SharedMemory(self, size: int) -> _SharedMemory: ... def ShareableList(self, sequence: Optional[Iterable[_SLT]]) -> _ShareableList[_SLT]: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/multiprocessing/pool.pyi0000664000175000017500000000623000000000000026040 0ustar00davedave00000000000000import sys from typing import Any, Callable, ContextManager, Generic, Iterable, Iterator, List, Mapping, Optional, TypeVar if sys.version_info >= (3, 9): from types import GenericAlias _PT = TypeVar("_PT", bound=Pool) _S = TypeVar("_S") _T = TypeVar("_T") class ApplyResult(Generic[_T]): def get(self, timeout: Optional[float] = ...) -> _T: ... def wait(self, timeout: Optional[float] = ...) -> None: ... def ready(self) -> bool: ... def successful(self) -> bool: ... if sys.version_info >= (3, 9): def __class_getitem__(cls, item: Any) -> GenericAlias: ... # alias created during issue #17805 AsyncResult = ApplyResult class MapResult(ApplyResult[List[_T]]): ... class IMapIterator(Iterator[_T]): def __iter__(self: _S) -> _S: ... def next(self, timeout: Optional[float] = ...) -> _T: ... def __next__(self, timeout: Optional[float] = ...) -> _T: ... class IMapUnorderedIterator(IMapIterator[_T]): ... class Pool(ContextManager[Pool]): def __init__( self, processes: Optional[int] = ..., initializer: Optional[Callable[..., None]] = ..., initargs: Iterable[Any] = ..., maxtasksperchild: Optional[int] = ..., context: Optional[Any] = ..., ) -> None: ... def apply(self, func: Callable[..., _T], args: Iterable[Any] = ..., kwds: Mapping[str, Any] = ...) -> _T: ... def apply_async( self, func: Callable[..., _T], args: Iterable[Any] = ..., kwds: Mapping[str, Any] = ..., callback: Optional[Callable[[_T], None]] = ..., error_callback: Optional[Callable[[BaseException], None]] = ..., ) -> AsyncResult[_T]: ... def map(self, func: Callable[[_S], _T], iterable: Iterable[_S], chunksize: Optional[int] = ...) -> List[_T]: ... def map_async( self, func: Callable[[_S], _T], iterable: Iterable[_S], chunksize: Optional[int] = ..., callback: Optional[Callable[[_T], None]] = ..., error_callback: Optional[Callable[[BaseException], None]] = ..., ) -> MapResult[_T]: ... def imap(self, func: Callable[[_S], _T], iterable: Iterable[_S], chunksize: Optional[int] = ...) -> IMapIterator[_T]: ... def imap_unordered( self, func: Callable[[_S], _T], iterable: Iterable[_S], chunksize: Optional[int] = ... ) -> IMapIterator[_T]: ... def starmap(self, func: Callable[..., _T], iterable: Iterable[Iterable[Any]], chunksize: Optional[int] = ...) -> List[_T]: ... def starmap_async( self, func: Callable[..., _T], iterable: Iterable[Iterable[Any]], chunksize: Optional[int] = ..., callback: Optional[Callable[[_T], None]] = ..., error_callback: Optional[Callable[[BaseException], None]] = ..., ) -> AsyncResult[List[_T]]: ... def close(self) -> None: ... def terminate(self) -> None: ... def join(self) -> None: ... def __enter__(self: _PT) -> _PT: ... class ThreadPool(Pool, ContextManager[ThreadPool]): def __init__( self, processes: Optional[int] = ..., initializer: Optional[Callable[..., Any]] = ..., initargs: Iterable[Any] = ... ) -> None: ... # undocumented RUN: int CLOSE: int TERMINATE: int ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/multiprocessing/process.pyi0000664000175000017500000000216700000000000026552 0ustar00davedave00000000000000import sys from typing import Any, Callable, List, Mapping, Optional, Tuple class BaseProcess: name: str daemon: bool authkey: bytes def __init__( self, group: None = ..., target: Optional[Callable[..., Any]] = ..., name: Optional[str] = ..., args: Tuple[Any, ...] = ..., kwargs: Mapping[str, Any] = ..., *, daemon: Optional[bool] = ..., ) -> None: ... def run(self) -> None: ... def start(self) -> None: ... def terminate(self) -> None: ... if sys.version_info >= (3, 7): def kill(self) -> None: ... def close(self) -> None: ... def join(self, timeout: Optional[float] = ...) -> None: ... def is_alive(self) -> bool: ... @property def exitcode(self) -> Optional[int]: ... @property def ident(self) -> Optional[int]: ... @property def pid(self) -> Optional[int]: ... @property def sentinel(self) -> int: ... def current_process() -> BaseProcess: ... def active_children() -> List[BaseProcess]: ... if sys.version_info >= (3, 8): def parent_process() -> Optional[BaseProcess]: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/multiprocessing/queues.pyi0000664000175000017500000000241000000000000026372 0ustar00davedave00000000000000import queue import sys from typing import Any, Generic, Optional, TypeVar if sys.version_info >= (3, 9): from types import GenericAlias _T = TypeVar("_T") class Queue(queue.Queue[_T]): # FIXME: `ctx` is a circular dependency and it's not actually optional. # It's marked as such to be able to use the generic Queue in __init__.pyi. def __init__(self, maxsize: int = ..., *, ctx: Any = ...) -> None: ... def get(self, block: bool = ..., timeout: Optional[float] = ...) -> _T: ... def put(self, obj: _T, block: bool = ..., timeout: Optional[float] = ...) -> None: ... def qsize(self) -> int: ... def empty(self) -> bool: ... def full(self) -> bool: ... def put_nowait(self, item: _T) -> None: ... def get_nowait(self) -> _T: ... def close(self) -> None: ... def join_thread(self) -> None: ... def cancel_join_thread(self) -> None: ... class JoinableQueue(Queue[_T]): def task_done(self) -> None: ... def join(self) -> None: ... class SimpleQueue(Generic[_T]): def __init__(self, *, ctx: Any = ...) -> None: ... def empty(self) -> bool: ... def get(self) -> _T: ... def put(self, item: _T) -> None: ... if sys.version_info >= (3, 9): def __class_getitem__(cls, item: Any) -> GenericAlias: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/multiprocessing/shared_memory.pyi0000664000175000017500000000242600000000000027730 0ustar00davedave00000000000000import sys from typing import Any, Generic, Iterable, Optional, Tuple, TypeVar if sys.version_info >= (3, 9): from types import GenericAlias _S = TypeVar("_S") _SLT = TypeVar("_SLT", int, float, bool, str, bytes, None) if sys.version_info >= (3, 8): class SharedMemory: def __init__(self, name: Optional[str] = ..., create: bool = ..., size: int = ...) -> None: ... @property def buf(self) -> memoryview: ... @property def name(self) -> str: ... @property def size(self) -> int: ... def close(self) -> None: ... def unlink(self) -> None: ... class ShareableList(Generic[_SLT]): shm: SharedMemory def __init__(self, sequence: Optional[Iterable[_SLT]] = ..., *, name: Optional[str] = ...) -> None: ... def __getitem__(self, position: int) -> _SLT: ... def __setitem__(self, position: int, value: _SLT) -> None: ... def __reduce__(self: _S) -> Tuple[_S, Tuple[_SLT, ...]]: ... def __len__(self) -> int: ... @property def format(self) -> str: ... def count(self, value: _SLT) -> int: ... def index(self, value: _SLT) -> int: ... if sys.version_info >= (3, 9): def __class_getitem__(cls, item: Any) -> GenericAlias: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/multiprocessing/sharedctypes.pyi0000664000175000017500000000276600000000000027577 0ustar00davedave00000000000000from ctypes import _CData from multiprocessing.context import BaseContext from multiprocessing.synchronize import _LockLike from typing import Any, List, Optional, Sequence, Type, Union, overload class _Array: value: Any = ... def __init__( self, typecode_or_type: Union[str, Type[_CData]], size_or_initializer: Union[int, Sequence[Any]], *, lock: Union[bool, _LockLike] = ..., ) -> None: ... def acquire(self) -> bool: ... def release(self) -> bool: ... def get_lock(self) -> _LockLike: ... def get_obj(self) -> Any: ... @overload def __getitem__(self, key: int) -> Any: ... @overload def __getitem__(self, key: slice) -> List[Any]: ... def __getslice__(self, start: int, stop: int) -> Any: ... def __setitem__(self, key: int, value: Any) -> None: ... class _Value: value: Any = ... def __init__(self, typecode_or_type: Union[str, Type[_CData]], *args: Any, lock: Union[bool, _LockLike] = ...) -> None: ... def get_lock(self) -> _LockLike: ... def get_obj(self) -> Any: ... def acquire(self) -> bool: ... def release(self) -> bool: ... def Array( typecode_or_type: Union[str, Type[_CData]], size_or_initializer: Union[int, Sequence[Any]], *, lock: Union[bool, _LockLike] = ..., ctx: Optional[BaseContext] = ..., ) -> _Array: ... def Value( typecode_or_type: Union[str, Type[_CData]], *args: Any, lock: Union[bool, _LockLike] = ..., ctx: Optional[BaseContext] = ... ) -> _Value: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/multiprocessing/spawn.pyi0000664000175000017500000000126200000000000026217 0ustar00davedave00000000000000from types import ModuleType from typing import Any, Dict, List, Mapping, Optional, Sequence WINEXE: bool WINSERVICE: bool def set_executable(exe: str) -> None: ... def get_executable() -> str: ... def is_forking(argv: Sequence[str]) -> bool: ... def freeze_support() -> None: ... def get_command_line(**kwds: Any) -> List[str]: ... def spawn_main(pipe_handle: int, parent_pid: Optional[int] = ..., tracker_fd: Optional[int] = ...) -> None: ... # undocumented def _main(fd: int) -> Any: ... def get_preparation_data(name: str) -> Dict[str, Any]: ... old_main_modules: List[ModuleType] def prepare(data: Mapping[str, Any]) -> None: ... def import_main_path(main_path: str) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/multiprocessing/synchronize.pyi0000664000175000017500000000340700000000000027445 0ustar00davedave00000000000000import sys import threading from multiprocessing.context import BaseContext from typing import Any, Callable, ContextManager, Optional, Union _LockLike = Union[Lock, RLock] class Barrier(threading.Barrier): def __init__( self, parties: int, action: Optional[Callable[..., Any]] = ..., timeout: Optional[float] = ..., *ctx: BaseContext ) -> None: ... class BoundedSemaphore(Semaphore): def __init__(self, value: int = ..., *, ctx: BaseContext) -> None: ... class Condition(ContextManager[bool]): def __init__(self, lock: Optional[_LockLike] = ..., *, ctx: BaseContext) -> None: ... if sys.version_info >= (3, 7): def notify(self, n: int = ...) -> None: ... else: def notify(self) -> None: ... def notify_all(self) -> None: ... def wait(self, timeout: Optional[float] = ...) -> bool: ... def wait_for(self, predicate: Callable[[], bool], timeout: Optional[float] = ...) -> bool: ... def acquire(self, block: bool = ..., timeout: Optional[float] = ...) -> bool: ... def release(self) -> None: ... class Event(ContextManager[bool]): def __init__(self, lock: Optional[_LockLike] = ..., *, ctx: BaseContext) -> None: ... def is_set(self) -> bool: ... def set(self) -> None: ... def clear(self) -> None: ... def wait(self, timeout: Optional[float] = ...) -> bool: ... class Lock(SemLock): def __init__(self, *, ctx: BaseContext) -> None: ... class RLock(SemLock): def __init__(self, *, ctx: BaseContext) -> None: ... class Semaphore(SemLock): def __init__(self, value: int = ..., *, ctx: BaseContext) -> None: ... # Not part of public API class SemLock(ContextManager[bool]): def acquire(self, block: bool = ..., timeout: Optional[float] = ...) -> bool: ... def release(self) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/nntplib.pyi0000664000175000017500000001034500000000000023310 0ustar00davedave00000000000000import datetime import socket import ssl import sys from typing import IO, Any, Dict, Iterable, List, NamedTuple, Optional, Tuple, TypeVar, Union _SelfT = TypeVar("_SelfT", bound=_NNTPBase) _File = Union[IO[bytes], bytes, str, None] class NNTPError(Exception): response: str class NNTPReplyError(NNTPError): ... class NNTPTemporaryError(NNTPError): ... class NNTPPermanentError(NNTPError): ... class NNTPProtocolError(NNTPError): ... class NNTPDataError(NNTPError): ... NNTP_PORT: int NNTP_SSL_PORT: int class GroupInfo(NamedTuple): group: str last: str first: str flag: str class ArticleInfo(NamedTuple): number: int message_id: str lines: List[bytes] def decode_header(header_str: str) -> str: ... class _NNTPBase: encoding: str errors: str host: str file: IO[bytes] debugging: int welcome: str readermode_afterauth: bool tls_on: bool authenticated: bool nntp_implementation: str nntp_version: int def __init__(self, file: IO[bytes], host: str, readermode: Optional[bool] = ..., timeout: float = ...) -> None: ... def __enter__(self: _SelfT) -> _SelfT: ... def __exit__(self, *args: Any) -> None: ... def getwelcome(self) -> str: ... def getcapabilities(self) -> Dict[str, List[str]]: ... def set_debuglevel(self, level: int) -> None: ... def debug(self, level: int) -> None: ... def capabilities(self) -> Tuple[str, Dict[str, List[str]]]: ... def newgroups(self, date: Union[datetime.date, datetime.datetime], *, file: _File = ...) -> Tuple[str, List[str]]: ... def newnews( self, group: str, date: Union[datetime.date, datetime.datetime], *, file: _File = ... ) -> Tuple[str, List[str]]: ... def list(self, group_pattern: Optional[str] = ..., *, file: _File = ...) -> Tuple[str, List[str]]: ... def description(self, group: str) -> str: ... def descriptions(self, group_pattern: str) -> Tuple[str, Dict[str, str]]: ... def group(self, name: str) -> Tuple[str, int, int, int, str]: ... def help(self, *, file: _File = ...) -> Tuple[str, List[str]]: ... def stat(self, message_spec: Any = ...) -> Tuple[str, int, str]: ... def next(self) -> Tuple[str, int, str]: ... def last(self) -> Tuple[str, int, str]: ... def head(self, message_spec: Any = ..., *, file: _File = ...) -> Tuple[str, ArticleInfo]: ... def body(self, message_spec: Any = ..., *, file: _File = ...) -> Tuple[str, ArticleInfo]: ... def article(self, message_spec: Any = ..., *, file: _File = ...) -> Tuple[str, ArticleInfo]: ... def slave(self) -> str: ... def xhdr(self, hdr: str, str: Any, *, file: _File = ...) -> Tuple[str, List[str]]: ... def xover(self, start: int, end: int, *, file: _File = ...) -> Tuple[str, List[Tuple[int, Dict[str, str]]]]: ... def over( self, message_spec: Union[None, str, List[Any], Tuple[Any, ...]], *, file: _File = ... ) -> Tuple[str, List[Tuple[int, Dict[str, str]]]]: ... if sys.version_info < (3, 9): def xgtitle(self, group: str, *, file: _File = ...) -> Tuple[str, List[Tuple[str, str]]]: ... def xpath(self, id: Any) -> Tuple[str, str]: ... def date(self) -> Tuple[str, datetime.datetime]: ... def post(self, data: Union[bytes, Iterable[bytes]]) -> str: ... def ihave(self, message_id: Any, data: Union[bytes, Iterable[bytes]]) -> str: ... def quit(self) -> str: ... def login(self, user: Optional[str] = ..., password: Optional[str] = ..., usenetrc: bool = ...) -> None: ... def starttls(self, ssl_context: Optional[ssl.SSLContext] = ...) -> None: ... class NNTP(_NNTPBase): port: int sock: socket.socket def __init__( self, host: str, port: int = ..., user: Optional[str] = ..., password: Optional[str] = ..., readermode: Optional[bool] = ..., usenetrc: bool = ..., timeout: float = ..., ) -> None: ... class NNTP_SSL(_NNTPBase): sock: socket.socket def __init__( self, host: str, port: int = ..., user: Optional[str] = ..., password: Optional[str] = ..., ssl_context: Optional[ssl.SSLContext] = ..., readermode: Optional[bool] = ..., usenetrc: bool = ..., timeout: float = ..., ) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/ntpath.pyi0000664000175000017500000001116100000000000023135 0ustar00davedave00000000000000import os import sys from _typeshed import AnyPath, BytesPath, StrPath from genericpath import exists as exists from typing import Any, AnyStr, Optional, Sequence, Tuple, TypeVar, overload _T = TypeVar("_T") if sys.version_info >= (3, 6): from builtins import _PathLike # ----- os.path variables ----- supports_unicode_filenames: bool # aliases (also in os) curdir: str pardir: str sep: str if sys.platform == "win32": altsep: str else: altsep: Optional[str] extsep: str pathsep: str defpath: str devnull: str # ----- os.path function stubs ----- if sys.version_info >= (3, 6): # Overloads are necessary to work around python/mypy#3644. @overload def abspath(path: _PathLike[AnyStr]) -> AnyStr: ... @overload def abspath(path: AnyStr) -> AnyStr: ... @overload def basename(p: _PathLike[AnyStr]) -> AnyStr: ... @overload def basename(p: AnyStr) -> AnyStr: ... @overload def dirname(p: _PathLike[AnyStr]) -> AnyStr: ... @overload def dirname(p: AnyStr) -> AnyStr: ... @overload def expanduser(path: _PathLike[AnyStr]) -> AnyStr: ... @overload def expanduser(path: AnyStr) -> AnyStr: ... @overload def expandvars(path: _PathLike[AnyStr]) -> AnyStr: ... @overload def expandvars(path: AnyStr) -> AnyStr: ... @overload def normcase(s: _PathLike[AnyStr]) -> AnyStr: ... @overload def normcase(s: AnyStr) -> AnyStr: ... @overload def normpath(path: _PathLike[AnyStr]) -> AnyStr: ... @overload def normpath(path: AnyStr) -> AnyStr: ... if sys.platform == "win32": @overload def realpath(path: _PathLike[AnyStr]) -> AnyStr: ... @overload def realpath(path: AnyStr) -> AnyStr: ... else: @overload def realpath(filename: _PathLike[AnyStr]) -> AnyStr: ... @overload def realpath(filename: AnyStr) -> AnyStr: ... else: def abspath(path: AnyStr) -> AnyStr: ... def basename(p: AnyStr) -> AnyStr: ... def dirname(p: AnyStr) -> AnyStr: ... def expanduser(path: AnyStr) -> AnyStr: ... def expandvars(path: AnyStr) -> AnyStr: ... def normcase(s: AnyStr) -> AnyStr: ... def normpath(path: AnyStr) -> AnyStr: ... if sys.platform == "win32": def realpath(path: AnyStr) -> AnyStr: ... else: def realpath(filename: AnyStr) -> AnyStr: ... if sys.version_info >= (3, 6): # In reality it returns str for sequences of StrPath and bytes for sequences # of BytesPath, but mypy does not accept such a signature. def commonpath(paths: Sequence[AnyPath]) -> Any: ... elif sys.version_info >= (3, 5): def commonpath(paths: Sequence[AnyStr]) -> AnyStr: ... # NOTE: Empty lists results in '' (str) regardless of contained type. # So, fall back to Any def commonprefix(m: Sequence[AnyPath]) -> Any: ... def lexists(path: AnyPath) -> bool: ... # These return float if os.stat_float_times() == True, # but int is a subclass of float. def getatime(filename: AnyPath) -> float: ... def getmtime(filename: AnyPath) -> float: ... def getctime(filename: AnyPath) -> float: ... def getsize(filename: AnyPath) -> int: ... def isabs(s: AnyPath) -> bool: ... def isfile(path: AnyPath) -> bool: ... def isdir(s: AnyPath) -> bool: ... def islink(path: AnyPath) -> bool: ... def ismount(path: AnyPath) -> bool: ... if sys.version_info >= (3, 6): @overload def join(a: StrPath, *paths: StrPath) -> str: ... @overload def join(a: BytesPath, *paths: BytesPath) -> bytes: ... else: def join(a: AnyStr, *paths: AnyStr) -> AnyStr: ... @overload def relpath(path: BytesPath, start: Optional[BytesPath] = ...) -> bytes: ... @overload def relpath(path: StrPath, start: Optional[StrPath] = ...) -> str: ... def samefile(f1: AnyPath, f2: AnyPath) -> bool: ... def sameopenfile(fp1: int, fp2: int) -> bool: ... def samestat(s1: os.stat_result, s2: os.stat_result) -> bool: ... if sys.version_info >= (3, 6): @overload def split(p: _PathLike[AnyStr]) -> Tuple[AnyStr, AnyStr]: ... @overload def split(p: AnyStr) -> Tuple[AnyStr, AnyStr]: ... @overload def splitdrive(p: _PathLike[AnyStr]) -> Tuple[AnyStr, AnyStr]: ... @overload def splitdrive(p: AnyStr) -> Tuple[AnyStr, AnyStr]: ... @overload def splitext(p: _PathLike[AnyStr]) -> Tuple[AnyStr, AnyStr]: ... @overload def splitext(p: AnyStr) -> Tuple[AnyStr, AnyStr]: ... else: def split(p: AnyStr) -> Tuple[AnyStr, AnyStr]: ... def splitdrive(p: AnyStr) -> Tuple[AnyStr, AnyStr]: ... def splitext(p: AnyStr) -> Tuple[AnyStr, AnyStr]: ... if sys.version_info < (3, 7) and sys.platform == "win32": def splitunc(p: AnyStr) -> Tuple[AnyStr, AnyStr]: ... # deprecated ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/nturl2path.pyi0000664000175000017500000000011400000000000023736 0ustar00davedave00000000000000def url2pathname(url: str) -> str: ... def pathname2url(p: str) -> str: ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4343793 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/os/0000775000175000017500000000000000000000000021535 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/os/__init__.pyi0000664000175000017500000007025600000000000024031 0ustar00davedave00000000000000import sys from _typeshed import ( AnyPath, FileDescriptorLike, OpenBinaryMode, OpenBinaryModeReading, OpenBinaryModeUpdating, OpenBinaryModeWriting, OpenTextMode, ) from builtins import OSError, _PathLike from io import BufferedRandom, BufferedReader, BufferedWriter, FileIO, TextIOWrapper as _TextIOWrapper from posix import listdir as listdir, times_result from typing import ( IO, Any, AnyStr, BinaryIO, Callable, ContextManager, Dict, Generic, Iterable, Iterator, List, Mapping, MutableMapping, NoReturn, Optional, Sequence, Set, Tuple, TypeVar, Union, overload, ) from typing_extensions import Literal from . import path as path if sys.version_info >= (3, 9): from types import GenericAlias # We need to use something from path, or flake8 and pytype get unhappy _supports_unicode_filenames = path.supports_unicode_filenames _T = TypeVar("_T") # ----- os variables ----- error = OSError supports_bytes_environ: bool supports_dir_fd: Set[Callable[..., Any]] supports_fd: Set[Callable[..., Any]] supports_effective_ids: Set[Callable[..., Any]] supports_follow_symlinks: Set[Callable[..., Any]] if sys.platform != "win32": # Unix only PRIO_PROCESS: int PRIO_PGRP: int PRIO_USER: int F_LOCK: int F_TLOCK: int F_ULOCK: int F_TEST: int if sys.platform != "darwin": POSIX_FADV_NORMAL: int POSIX_FADV_SEQUENTIAL: int POSIX_FADV_RANDOM: int POSIX_FADV_NOREUSE: int POSIX_FADV_WILLNEED: int POSIX_FADV_DONTNEED: int SF_NODISKIO: int SF_MNOWAIT: int SF_SYNC: int if sys.platform == "linux": XATTR_SIZE_MAX: int XATTR_CREATE: int XATTR_REPLACE: int P_PID: int P_PGID: int P_ALL: int WEXITED: int WSTOPPED: int WNOWAIT: int CLD_EXITED: int CLD_DUMPED: int CLD_TRAPPED: int CLD_CONTINUED: int SCHED_OTHER: int # some flavors of Unix SCHED_BATCH: int # some flavors of Unix SCHED_IDLE: int # some flavors of Unix SCHED_SPORADIC: int # some flavors of Unix SCHED_FIFO: int # some flavors of Unix SCHED_RR: int # some flavors of Unix SCHED_RESET_ON_FORK: int # some flavors of Unix if sys.platform != "win32": RTLD_LAZY: int RTLD_NOW: int RTLD_GLOBAL: int RTLD_LOCAL: int RTLD_NODELETE: int RTLD_NOLOAD: int RTLD_DEEPBIND: int SEEK_SET: int SEEK_CUR: int SEEK_END: int if sys.platform != "win32": SEEK_DATA: int # some flavors of Unix SEEK_HOLE: int # some flavors of Unix O_RDONLY: int O_WRONLY: int O_RDWR: int O_APPEND: int O_CREAT: int O_EXCL: int O_TRUNC: int # We don't use sys.platform for O_* flags to denote platform-dependent APIs because some codes, # including tests for mypy, use a more finer way than sys.platform before using these APIs # See https://github.com/python/typeshed/pull/2286 for discussions O_DSYNC: int # Unix only O_RSYNC: int # Unix only O_SYNC: int # Unix only O_NDELAY: int # Unix only O_NONBLOCK: int # Unix only O_NOCTTY: int # Unix only O_CLOEXEC: int # Unix only O_SHLOCK: int # Unix only O_EXLOCK: int # Unix only O_BINARY: int # Windows only O_NOINHERIT: int # Windows only O_SHORT_LIVED: int # Windows only O_TEMPORARY: int # Windows only O_RANDOM: int # Windows only O_SEQUENTIAL: int # Windows only O_TEXT: int # Windows only O_ASYNC: int # Gnu extension if in C library O_DIRECT: int # Gnu extension if in C library O_DIRECTORY: int # Gnu extension if in C library O_NOFOLLOW: int # Gnu extension if in C library O_NOATIME: int # Gnu extension if in C library O_PATH: int # Gnu extension if in C library O_TMPFILE: int # Gnu extension if in C library O_LARGEFILE: int # Gnu extension if in C library curdir: str pardir: str sep: str if sys.platform == "win32": altsep: str else: altsep: Optional[str] extsep: str pathsep: str defpath: str linesep: str devnull: str name: str F_OK: int R_OK: int W_OK: int X_OK: int class _Environ(MutableMapping[AnyStr, AnyStr], Generic[AnyStr]): def copy(self) -> Dict[AnyStr, AnyStr]: ... def __delitem__(self, key: AnyStr) -> None: ... def __getitem__(self, key: AnyStr) -> AnyStr: ... def __setitem__(self, key: AnyStr, value: AnyStr) -> None: ... def __iter__(self) -> Iterator[AnyStr]: ... def __len__(self) -> int: ... environ: _Environ[str] if sys.platform != "win32": environb: _Environ[bytes] if sys.platform != "win32": confstr_names: Dict[str, int] pathconf_names: Dict[str, int] sysconf_names: Dict[str, int] EX_OK: int EX_USAGE: int EX_DATAERR: int EX_NOINPUT: int EX_NOUSER: int EX_NOHOST: int EX_UNAVAILABLE: int EX_SOFTWARE: int EX_OSERR: int EX_OSFILE: int EX_CANTCREAT: int EX_IOERR: int EX_TEMPFAIL: int EX_PROTOCOL: int EX_NOPERM: int EX_CONFIG: int EX_NOTFOUND: int P_NOWAIT: int P_NOWAITO: int P_WAIT: int if sys.platform == "win32": P_DETACH: int P_OVERLAY: int # wait()/waitpid() options if sys.platform != "win32": WNOHANG: int # Unix only WCONTINUED: int # some Unix systems WUNTRACED: int # Unix only TMP_MAX: int # Undocumented, but used by tempfile # ----- os classes (structures) ----- class stat_result: # For backward compatibility, the return value of stat() is also # accessible as a tuple of at least 10 integers giving the most important # (and portable) members of the stat structure, in the order st_mode, # st_ino, st_dev, st_nlink, st_uid, st_gid, st_size, st_atime, st_mtime, # st_ctime. More items may be added at the end by some implementations. st_mode: int # protection bits, st_ino: int # inode number, st_dev: int # device, st_nlink: int # number of hard links, st_uid: int # user id of owner, st_gid: int # group id of owner, st_size: int # size of file, in bytes, st_atime: float # time of most recent access, st_mtime: float # time of most recent content modification, st_ctime: float # platform dependent (time of most recent metadata change on Unix, or the time of creation on Windows) st_atime_ns: int # time of most recent access, in nanoseconds st_mtime_ns: int # time of most recent content modification in nanoseconds st_ctime_ns: int # platform dependent (time of most recent metadata change on Unix, or the time of creation on Windows) in nanoseconds if sys.version_info >= (3, 8) and sys.platform == "win32": st_reparse_tag: int if sys.platform == "win32": st_file_attributes: int def __getitem__(self, i: int) -> int: ... # not documented def __init__(self, tuple: Tuple[int, ...]) -> None: ... # On some Unix systems (such as Linux), the following attributes may also # be available: st_blocks: int # number of blocks allocated for file st_blksize: int # filesystem blocksize st_rdev: int # type of device if an inode device st_flags: int # user defined flags for file # On other Unix systems (such as FreeBSD), the following attributes may be # available (but may be only filled out if root tries to use them): st_gen: int # file generation number st_birthtime: int # time of file creation # On Mac OS systems, the following attributes may also be available: st_rsize: int st_creator: int st_type: int PathLike = _PathLike # See comment in builtins _FdOrAnyPath = Union[int, AnyPath] class DirEntry(Generic[AnyStr]): # This is what the scandir interator yields # The constructor is hidden name: AnyStr path: AnyStr def inode(self) -> int: ... def is_dir(self, *, follow_symlinks: bool = ...) -> bool: ... def is_file(self, *, follow_symlinks: bool = ...) -> bool: ... def is_symlink(self) -> bool: ... def stat(self, *, follow_symlinks: bool = ...) -> stat_result: ... def __fspath__(self) -> AnyStr: ... if sys.version_info >= (3, 9): def __class_getitem__(cls, item: Any) -> GenericAlias: ... if sys.platform != "win32": _Tuple10Int = Tuple[int, int, int, int, int, int, int, int, int, int] _Tuple11Int = Tuple[int, int, int, int, int, int, int, int, int, int, int] if sys.version_info >= (3, 7): # f_fsid was added in https://github.com/python/cpython/pull/4571 class statvfs_result(_Tuple10Int): # Unix only def __new__(cls, seq: Union[_Tuple10Int, _Tuple11Int], dict: Dict[str, int] = ...) -> statvfs_result: ... n_fields: int n_sequence_fields: int n_unnamed_fields: int f_bsize: int f_frsize: int f_blocks: int f_bfree: int f_bavail: int f_files: int f_ffree: int f_favail: int f_flag: int f_namemax: int f_fsid: int = ... else: class statvfs_result(_Tuple10Int): # Unix only n_fields: int n_sequence_fields: int n_unnamed_fields: int f_bsize: int f_frsize: int f_blocks: int f_bfree: int f_bavail: int f_files: int f_ffree: int f_favail: int f_flag: int f_namemax: int # ----- os function stubs ----- def fsencode(filename: Union[str, bytes, PathLike[Any]]) -> bytes: ... def fsdecode(filename: Union[str, bytes, PathLike[Any]]) -> str: ... @overload def fspath(path: str) -> str: ... @overload def fspath(path: bytes) -> bytes: ... @overload def fspath(path: PathLike[AnyStr]) -> AnyStr: ... def get_exec_path(env: Optional[Mapping[str, str]] = ...) -> List[str]: ... # NOTE: get_exec_path(): returns List[bytes] when env not None def getlogin() -> str: ... def getpid() -> int: ... def getppid() -> int: ... def strerror(__code: int) -> str: ... def umask(__mask: int) -> int: ... if sys.platform != "win32": # Unix only def ctermid() -> str: ... def getegid() -> int: ... def geteuid() -> int: ... def getgid() -> int: ... def getgrouplist(user: str, gid: int) -> List[int]: ... def getgroups() -> List[int]: ... # Unix only, behaves differently on Mac def initgroups(username: str, gid: int) -> None: ... def getpgid(pid: int) -> int: ... def getpgrp() -> int: ... def getpriority(which: int, who: int) -> int: ... def setpriority(which: int, who: int, priority: int) -> None: ... if sys.platform != "darwin": def getresuid() -> Tuple[int, int, int]: ... def getresgid() -> Tuple[int, int, int]: ... def getuid() -> int: ... def setegid(__egid: int) -> None: ... def seteuid(__euid: int) -> None: ... def setgid(__gid: int) -> None: ... def setgroups(__groups: Sequence[int]) -> None: ... def setpgrp() -> None: ... def setpgid(__pid: int, __pgrp: int) -> None: ... def setregid(__rgid: int, __egid: int) -> None: ... if sys.platform != "darwin": def setresgid(rgid: int, egid: int, sgid: int) -> None: ... def setresuid(ruid: int, euid: int, suid: int) -> None: ... def setreuid(__ruid: int, __euid: int) -> None: ... def getsid(__pid: int) -> int: ... def setsid() -> None: ... def setuid(__uid: int) -> None: ... from posix import uname_result def uname() -> uname_result: ... @overload def getenv(key: str) -> Optional[str]: ... @overload def getenv(key: str, default: _T) -> Union[str, _T]: ... if sys.platform != "win32": @overload def getenvb(key: bytes) -> Optional[bytes]: ... @overload def getenvb(key: bytes, default: _T = ...) -> Union[bytes, _T]: ... def putenv(__name: Union[bytes, str], __value: Union[bytes, str]) -> None: ... if sys.platform != "win32": def unsetenv(__name: Union[bytes, str]) -> None: ... _Opener = Callable[[str, int], int] @overload def fdopen( fd: int, mode: OpenTextMode = ..., buffering: int = ..., encoding: Optional[str] = ..., errors: Optional[str] = ..., newline: Optional[str] = ..., closefd: bool = ..., opener: Optional[_Opener] = ..., ) -> _TextIOWrapper: ... @overload def fdopen( fd: int, mode: OpenBinaryMode, buffering: Literal[0], encoding: None = ..., errors: None = ..., newline: None = ..., closefd: bool = ..., opener: Optional[_Opener] = ..., ) -> FileIO: ... @overload def fdopen( fd: int, mode: OpenBinaryModeUpdating, buffering: Literal[-1, 1] = ..., encoding: None = ..., errors: None = ..., newline: None = ..., closefd: bool = ..., opener: Optional[_Opener] = ..., ) -> BufferedRandom: ... @overload def fdopen( fd: int, mode: OpenBinaryModeWriting, buffering: Literal[-1, 1] = ..., encoding: None = ..., errors: None = ..., newline: None = ..., closefd: bool = ..., opener: Optional[_Opener] = ..., ) -> BufferedWriter: ... @overload def fdopen( fd: int, mode: OpenBinaryModeReading, buffering: Literal[-1, 1] = ..., encoding: None = ..., errors: None = ..., newline: None = ..., closefd: bool = ..., opener: Optional[_Opener] = ..., ) -> BufferedReader: ... @overload def fdopen( fd: int, mode: OpenBinaryMode, buffering: int, encoding: None = ..., errors: None = ..., newline: None = ..., closefd: bool = ..., opener: Optional[_Opener] = ..., ) -> BinaryIO: ... @overload def fdopen( fd: int, mode: str, buffering: int = ..., encoding: Optional[str] = ..., errors: Optional[str] = ..., newline: Optional[str] = ..., closefd: bool = ..., opener: Optional[_Opener] = ..., ) -> IO[Any]: ... def close(fd: int) -> None: ... def closerange(__fd_low: int, __fd_high: int) -> None: ... def device_encoding(fd: int) -> Optional[str]: ... def dup(__fd: int) -> int: ... if sys.version_info >= (3, 7): def dup2(fd: int, fd2: int, inheritable: bool = ...) -> int: ... else: def dup2(fd: int, fd2: int, inheritable: bool = ...) -> None: ... def fstat(fd: int) -> stat_result: ... def fsync(fd: FileDescriptorLike) -> None: ... def lseek(__fd: int, __position: int, __how: int) -> int: ... def open(path: AnyPath, flags: int, mode: int = ..., *, dir_fd: Optional[int] = ...) -> int: ... def pipe() -> Tuple[int, int]: ... def read(__fd: int, __length: int) -> bytes: ... if sys.platform != "win32": # Unix only def fchmod(fd: int, mode: int) -> None: ... def fchown(fd: int, uid: int, gid: int) -> None: ... if sys.platform != "darwin": def fdatasync(fd: FileDescriptorLike) -> None: ... # Unix only, not Mac def fpathconf(__fd: int, __name: Union[str, int]) -> int: ... def fstatvfs(__fd: int) -> statvfs_result: ... def ftruncate(__fd: int, __length: int) -> None: ... def get_blocking(__fd: int) -> bool: ... def set_blocking(__fd: int, __blocking: bool) -> None: ... def isatty(__fd: int) -> bool: ... def lockf(__fd: int, __command: int, __length: int) -> None: ... def openpty() -> Tuple[int, int]: ... # some flavors of Unix if sys.platform != "darwin": def pipe2(flags: int) -> Tuple[int, int]: ... # some flavors of Unix def posix_fallocate(fd: int, offset: int, length: int) -> None: ... def posix_fadvise(fd: int, offset: int, length: int, advice: int) -> None: ... def pread(__fd: int, __length: int, __offset: int) -> bytes: ... def pwrite(__fd: int, __buffer: bytes, __offset: int) -> int: ... @overload def sendfile(__out_fd: int, __in_fd: int, offset: Optional[int], count: int) -> int: ... @overload def sendfile( __out_fd: int, __in_fd: int, offset: int, count: int, headers: Sequence[bytes] = ..., trailers: Sequence[bytes] = ..., flags: int = ..., ) -> int: ... # FreeBSD and Mac OS X only def readv(__fd: int, __buffers: Sequence[bytearray]) -> int: ... def writev(__fd: int, __buffers: Sequence[bytes]) -> int: ... class terminal_size(Tuple[int, int]): columns: int lines: int def get_terminal_size(fd: int = ...) -> terminal_size: ... def get_inheritable(__fd: int) -> bool: ... def set_inheritable(__fd: int, __inheritable: bool) -> None: ... if sys.platform != "win32": # Unix only def tcgetpgrp(__fd: int) -> int: ... def tcsetpgrp(__fd: int, __pgid: int) -> None: ... def ttyname(__fd: int) -> str: ... def write(__fd: int, __data: bytes) -> int: ... def access( path: _FdOrAnyPath, mode: int, *, dir_fd: Optional[int] = ..., effective_ids: bool = ..., follow_symlinks: bool = ... ) -> bool: ... def chdir(path: _FdOrAnyPath) -> None: ... if sys.platform != "win32": def fchdir(fd: FileDescriptorLike) -> None: ... def getcwd() -> str: ... def getcwdb() -> bytes: ... def chmod(path: _FdOrAnyPath, mode: int, *, dir_fd: Optional[int] = ..., follow_symlinks: bool = ...) -> None: ... if sys.platform != "win32": def chflags(path: AnyPath, flags: int, follow_symlinks: bool = ...) -> None: ... # some flavors of Unix def chown( path: _FdOrAnyPath, uid: int, gid: int, *, dir_fd: Optional[int] = ..., follow_symlinks: bool = ... ) -> None: ... # Unix only if sys.platform != "win32": # Unix only def chroot(path: AnyPath) -> None: ... def lchflags(path: AnyPath, flags: int) -> None: ... def lchmod(path: AnyPath, mode: int) -> None: ... def lchown(path: AnyPath, uid: int, gid: int) -> None: ... def link( src: AnyPath, dst: AnyPath, *, src_dir_fd: Optional[int] = ..., dst_dir_fd: Optional[int] = ..., follow_symlinks: bool = ... ) -> None: ... def lstat(path: AnyPath, *, dir_fd: Optional[int] = ...) -> stat_result: ... def mkdir(path: AnyPath, mode: int = ..., *, dir_fd: Optional[int] = ...) -> None: ... if sys.platform != "win32": def mkfifo(path: AnyPath, mode: int = ..., *, dir_fd: Optional[int] = ...) -> None: ... # Unix only def makedirs(name: AnyPath, mode: int = ..., exist_ok: bool = ...) -> None: ... if sys.platform != "win32": def mknod(path: AnyPath, mode: int = ..., device: int = ..., *, dir_fd: Optional[int] = ...) -> None: ... def major(__device: int) -> int: ... def minor(__device: int) -> int: ... def makedev(__major: int, __minor: int) -> int: ... def pathconf(path: _FdOrAnyPath, name: Union[str, int]) -> int: ... # Unix only def readlink(path: Union[AnyStr, PathLike[AnyStr]], *, dir_fd: Optional[int] = ...) -> AnyStr: ... def remove(path: AnyPath, *, dir_fd: Optional[int] = ...) -> None: ... def removedirs(name: AnyPath) -> None: ... def rename(src: AnyPath, dst: AnyPath, *, src_dir_fd: Optional[int] = ..., dst_dir_fd: Optional[int] = ...) -> None: ... def renames(old: AnyPath, new: AnyPath) -> None: ... def replace(src: AnyPath, dst: AnyPath, *, src_dir_fd: Optional[int] = ..., dst_dir_fd: Optional[int] = ...) -> None: ... def rmdir(path: AnyPath, *, dir_fd: Optional[int] = ...) -> None: ... class _ScandirIterator(Iterator[DirEntry[AnyStr]], ContextManager[_ScandirIterator[AnyStr]]): def __next__(self) -> DirEntry[AnyStr]: ... def close(self) -> None: ... if sys.version_info >= (3, 7): @overload def scandir(path: None = ...) -> _ScandirIterator[str]: ... @overload def scandir(path: int) -> _ScandirIterator[str]: ... @overload def scandir(path: Union[AnyStr, PathLike[AnyStr]]) -> _ScandirIterator[AnyStr]: ... else: @overload def scandir(path: None = ...) -> _ScandirIterator[str]: ... @overload def scandir(path: Union[AnyStr, PathLike[AnyStr]]) -> _ScandirIterator[AnyStr]: ... def stat(path: _FdOrAnyPath, *, dir_fd: Optional[int] = ..., follow_symlinks: bool = ...) -> stat_result: ... if sys.version_info < (3, 7): @overload def stat_float_times() -> bool: ... @overload def stat_float_times(__newvalue: bool) -> None: ... if sys.platform != "win32": def statvfs(path: _FdOrAnyPath) -> statvfs_result: ... # Unix only def symlink(src: AnyPath, dst: AnyPath, target_is_directory: bool = ..., *, dir_fd: Optional[int] = ...) -> None: ... if sys.platform != "win32": def sync() -> None: ... # Unix only def truncate(path: _FdOrAnyPath, length: int) -> None: ... # Unix only up to version 3.4 def unlink(path: AnyPath, *, dir_fd: Optional[int] = ...) -> None: ... def utime( path: _FdOrAnyPath, times: Optional[Union[Tuple[int, int], Tuple[float, float]]] = ..., *, ns: Tuple[int, int] = ..., dir_fd: Optional[int] = ..., follow_symlinks: bool = ..., ) -> None: ... _OnError = Callable[[OSError], Any] def walk( top: Union[AnyStr, PathLike[AnyStr]], topdown: bool = ..., onerror: Optional[_OnError] = ..., followlinks: bool = ... ) -> Iterator[Tuple[AnyStr, List[AnyStr], List[AnyStr]]]: ... if sys.platform != "win32": if sys.version_info >= (3, 7): @overload def fwalk( top: Union[str, PathLike[str]] = ..., topdown: bool = ..., onerror: Optional[_OnError] = ..., *, follow_symlinks: bool = ..., dir_fd: Optional[int] = ..., ) -> Iterator[Tuple[str, List[str], List[str], int]]: ... @overload def fwalk( top: bytes, topdown: bool = ..., onerror: Optional[_OnError] = ..., *, follow_symlinks: bool = ..., dir_fd: Optional[int] = ..., ) -> Iterator[Tuple[bytes, List[bytes], List[bytes], int]]: ... else: def fwalk( top: Union[str, PathLike[str]] = ..., topdown: bool = ..., onerror: Optional[_OnError] = ..., *, follow_symlinks: bool = ..., dir_fd: Optional[int] = ..., ) -> Iterator[Tuple[str, List[str], List[str], int]]: ... if sys.platform == "linux": def getxattr(path: _FdOrAnyPath, attribute: AnyPath, *, follow_symlinks: bool = ...) -> bytes: ... def listxattr(path: _FdOrAnyPath, *, follow_symlinks: bool = ...) -> List[str]: ... def removexattr(path: _FdOrAnyPath, attribute: AnyPath, *, follow_symlinks: bool = ...) -> None: ... def setxattr( path: _FdOrAnyPath, attribute: AnyPath, value: bytes, flags: int = ..., *, follow_symlinks: bool = ... ) -> None: ... def abort() -> NoReturn: ... # These are defined as execl(file, *args) but the first *arg is mandatory. def execl(file: AnyPath, __arg0: AnyPath, *args: AnyPath) -> NoReturn: ... def execlp(file: AnyPath, __arg0: AnyPath, *args: AnyPath) -> NoReturn: ... # These are: execle(file, *args, env) but env is pulled from the last element of the args. def execle(file: AnyPath, __arg0: AnyPath, *args: Any) -> NoReturn: ... def execlpe(file: AnyPath, __arg0: AnyPath, *args: Any) -> NoReturn: ... # The docs say `args: tuple or list of strings` # The implementation enforces tuple or list so we can't use Sequence. # Not separating out PathLike[str] and PathLike[bytes] here because it doesn't make much difference # in practice, and doing so would explode the number of combinations in this already long union. # All these combinations are necessary due to List being invariant. _ExecVArgs = Union[ Tuple[AnyPath, ...], List[bytes], List[str], List[PathLike[Any]], List[Union[bytes, str]], List[Union[bytes, PathLike[Any]]], List[Union[str, PathLike[Any]]], List[Union[bytes, str, PathLike[Any]]], ] _ExecEnv = Union[Mapping[bytes, Union[bytes, str]], Mapping[str, Union[bytes, str]]] def execv(__path: AnyPath, __argv: _ExecVArgs) -> NoReturn: ... def execve(path: _FdOrAnyPath, argv: _ExecVArgs, env: _ExecEnv) -> NoReturn: ... def execvp(file: AnyPath, args: _ExecVArgs) -> NoReturn: ... def execvpe(file: AnyPath, args: _ExecVArgs, env: _ExecEnv) -> NoReturn: ... def _exit(status: int) -> NoReturn: ... def kill(__pid: int, __signal: int) -> None: ... if sys.platform != "win32": # Unix only def fork() -> int: ... def forkpty() -> Tuple[int, int]: ... # some flavors of Unix def killpg(__pgid: int, __signal: int) -> None: ... def nice(__increment: int) -> int: ... if sys.platform != "darwin": def plock(op: int) -> None: ... # ???op is int? class _wrap_close(_TextIOWrapper): def close(self) -> Optional[int]: ... # type: ignore def popen(cmd: str, mode: str = ..., buffering: int = ...) -> _wrap_close: ... def spawnl(mode: int, file: AnyPath, arg0: AnyPath, *args: AnyPath) -> int: ... def spawnle(mode: int, file: AnyPath, arg0: AnyPath, *args: Any) -> int: ... # Imprecise sig if sys.platform != "win32": def spawnv(mode: int, file: AnyPath, args: _ExecVArgs) -> int: ... def spawnve(mode: int, file: AnyPath, args: _ExecVArgs, env: _ExecEnv) -> int: ... else: def spawnv(__mode: int, __path: AnyPath, __argv: _ExecVArgs) -> int: ... def spawnve(__mode: int, __path: AnyPath, __argv: _ExecVArgs, __env: _ExecEnv) -> int: ... def system(command: AnyPath) -> int: ... def times() -> times_result: ... def waitpid(__pid: int, __options: int) -> Tuple[int, int]: ... if sys.platform == "win32": def startfile(path: AnyPath, operation: Optional[str] = ...) -> None: ... else: # Unix only def spawnlp(mode: int, file: AnyPath, arg0: AnyPath, *args: AnyPath) -> int: ... def spawnlpe(mode: int, file: AnyPath, arg0: AnyPath, *args: Any) -> int: ... # Imprecise signature def spawnvp(mode: int, file: AnyPath, args: _ExecVArgs) -> int: ... def spawnvpe(mode: int, file: AnyPath, args: _ExecVArgs, env: _ExecEnv) -> int: ... def wait() -> Tuple[int, int]: ... # Unix only from posix import waitid_result def waitid(idtype: int, ident: int, options: int) -> waitid_result: ... def wait3(options: int) -> Tuple[int, int, Any]: ... def wait4(pid: int, options: int) -> Tuple[int, int, Any]: ... def WCOREDUMP(__status: int) -> bool: ... def WIFCONTINUED(status: int) -> bool: ... def WIFSTOPPED(status: int) -> bool: ... def WIFSIGNALED(status: int) -> bool: ... def WIFEXITED(status: int) -> bool: ... def WEXITSTATUS(status: int) -> int: ... def WSTOPSIG(status: int) -> int: ... def WTERMSIG(status: int) -> int: ... if sys.platform != "win32": from posix import sched_param def sched_get_priority_min(policy: int) -> int: ... # some flavors of Unix def sched_get_priority_max(policy: int) -> int: ... # some flavors of Unix def sched_setscheduler(pid: int, policy: int, param: sched_param) -> None: ... # some flavors of Unix def sched_getscheduler(pid: int) -> int: ... # some flavors of Unix def sched_setparam(pid: int, param: sched_param) -> None: ... # some flavors of Unix def sched_getparam(pid: int) -> sched_param: ... # some flavors of Unix def sched_rr_get_interval(pid: int) -> float: ... # some flavors of Unix def sched_yield() -> None: ... # some flavors of Unix def sched_setaffinity(pid: int, mask: Iterable[int]) -> None: ... # some flavors of Unix def sched_getaffinity(pid: int) -> Set[int]: ... # some flavors of Unix def cpu_count() -> Optional[int]: ... if sys.platform != "win32": # Unix only def confstr(__name: Union[str, int]) -> Optional[str]: ... def getloadavg() -> Tuple[float, float, float]: ... def sysconf(__name: Union[str, int]) -> int: ... if sys.platform == "linux": def getrandom(size: int, flags: int = ...) -> bytes: ... def urandom(__size: int) -> bytes: ... if sys.version_info >= (3, 7) and sys.platform != "win32": def register_at_fork( *, before: Optional[Callable[..., Any]] = ..., after_in_parent: Optional[Callable[..., Any]] = ..., after_in_child: Optional[Callable[..., Any]] = ..., ) -> None: ... if sys.version_info >= (3, 8): if sys.platform == "win32": class _AddedDllDirectory: path: Optional[str] def __init__(self, path: Optional[str], cookie: _T, remove_dll_directory: Callable[[_T], Any]) -> None: ... def close(self) -> None: ... def __enter__(self: _T) -> _T: ... def __exit__(self, *args: Any) -> None: ... def add_dll_directory(path: str) -> _AddedDllDirectory: ... if sys.platform == "linux": MFD_CLOEXEC: int MFD_ALLOW_SEALING: int MFD_HUGETLB: int MFD_HUGE_SHIFT: int MFD_HUGE_MASK: int MFD_HUGE_64KB: int MFD_HUGE_512KB: int MFD_HUGE_1MB: int MFD_HUGE_2MB: int MFD_HUGE_8MB: int MFD_HUGE_16MB: int MFD_HUGE_32MB: int MFD_HUGE_256MB: int MFD_HUGE_512MB: int MFD_HUGE_1GB: int MFD_HUGE_2GB: int MFD_HUGE_16GB: int def memfd_create(name: str, flags: int = ...) -> int: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/os/path.pyi0000664000175000017500000001116100000000000023214 0ustar00davedave00000000000000import os import sys from _typeshed import AnyPath, BytesPath, StrPath from genericpath import exists as exists from typing import Any, AnyStr, Optional, Sequence, Tuple, TypeVar, overload _T = TypeVar("_T") if sys.version_info >= (3, 6): from builtins import _PathLike # ----- os.path variables ----- supports_unicode_filenames: bool # aliases (also in os) curdir: str pardir: str sep: str if sys.platform == "win32": altsep: str else: altsep: Optional[str] extsep: str pathsep: str defpath: str devnull: str # ----- os.path function stubs ----- if sys.version_info >= (3, 6): # Overloads are necessary to work around python/mypy#3644. @overload def abspath(path: _PathLike[AnyStr]) -> AnyStr: ... @overload def abspath(path: AnyStr) -> AnyStr: ... @overload def basename(p: _PathLike[AnyStr]) -> AnyStr: ... @overload def basename(p: AnyStr) -> AnyStr: ... @overload def dirname(p: _PathLike[AnyStr]) -> AnyStr: ... @overload def dirname(p: AnyStr) -> AnyStr: ... @overload def expanduser(path: _PathLike[AnyStr]) -> AnyStr: ... @overload def expanduser(path: AnyStr) -> AnyStr: ... @overload def expandvars(path: _PathLike[AnyStr]) -> AnyStr: ... @overload def expandvars(path: AnyStr) -> AnyStr: ... @overload def normcase(s: _PathLike[AnyStr]) -> AnyStr: ... @overload def normcase(s: AnyStr) -> AnyStr: ... @overload def normpath(path: _PathLike[AnyStr]) -> AnyStr: ... @overload def normpath(path: AnyStr) -> AnyStr: ... if sys.platform == "win32": @overload def realpath(path: _PathLike[AnyStr]) -> AnyStr: ... @overload def realpath(path: AnyStr) -> AnyStr: ... else: @overload def realpath(filename: _PathLike[AnyStr]) -> AnyStr: ... @overload def realpath(filename: AnyStr) -> AnyStr: ... else: def abspath(path: AnyStr) -> AnyStr: ... def basename(p: AnyStr) -> AnyStr: ... def dirname(p: AnyStr) -> AnyStr: ... def expanduser(path: AnyStr) -> AnyStr: ... def expandvars(path: AnyStr) -> AnyStr: ... def normcase(s: AnyStr) -> AnyStr: ... def normpath(path: AnyStr) -> AnyStr: ... if sys.platform == "win32": def realpath(path: AnyStr) -> AnyStr: ... else: def realpath(filename: AnyStr) -> AnyStr: ... if sys.version_info >= (3, 6): # In reality it returns str for sequences of StrPath and bytes for sequences # of BytesPath, but mypy does not accept such a signature. def commonpath(paths: Sequence[AnyPath]) -> Any: ... elif sys.version_info >= (3, 5): def commonpath(paths: Sequence[AnyStr]) -> AnyStr: ... # NOTE: Empty lists results in '' (str) regardless of contained type. # So, fall back to Any def commonprefix(m: Sequence[AnyPath]) -> Any: ... def lexists(path: AnyPath) -> bool: ... # These return float if os.stat_float_times() == True, # but int is a subclass of float. def getatime(filename: AnyPath) -> float: ... def getmtime(filename: AnyPath) -> float: ... def getctime(filename: AnyPath) -> float: ... def getsize(filename: AnyPath) -> int: ... def isabs(s: AnyPath) -> bool: ... def isfile(path: AnyPath) -> bool: ... def isdir(s: AnyPath) -> bool: ... def islink(path: AnyPath) -> bool: ... def ismount(path: AnyPath) -> bool: ... if sys.version_info >= (3, 6): @overload def join(a: StrPath, *paths: StrPath) -> str: ... @overload def join(a: BytesPath, *paths: BytesPath) -> bytes: ... else: def join(a: AnyStr, *paths: AnyStr) -> AnyStr: ... @overload def relpath(path: BytesPath, start: Optional[BytesPath] = ...) -> bytes: ... @overload def relpath(path: StrPath, start: Optional[StrPath] = ...) -> str: ... def samefile(f1: AnyPath, f2: AnyPath) -> bool: ... def sameopenfile(fp1: int, fp2: int) -> bool: ... def samestat(s1: os.stat_result, s2: os.stat_result) -> bool: ... if sys.version_info >= (3, 6): @overload def split(p: _PathLike[AnyStr]) -> Tuple[AnyStr, AnyStr]: ... @overload def split(p: AnyStr) -> Tuple[AnyStr, AnyStr]: ... @overload def splitdrive(p: _PathLike[AnyStr]) -> Tuple[AnyStr, AnyStr]: ... @overload def splitdrive(p: AnyStr) -> Tuple[AnyStr, AnyStr]: ... @overload def splitext(p: _PathLike[AnyStr]) -> Tuple[AnyStr, AnyStr]: ... @overload def splitext(p: AnyStr) -> Tuple[AnyStr, AnyStr]: ... else: def split(p: AnyStr) -> Tuple[AnyStr, AnyStr]: ... def splitdrive(p: AnyStr) -> Tuple[AnyStr, AnyStr]: ... def splitext(p: AnyStr) -> Tuple[AnyStr, AnyStr]: ... if sys.version_info < (3, 7) and sys.platform == "win32": def splitunc(p: AnyStr) -> Tuple[AnyStr, AnyStr]: ... # deprecated ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/pathlib.pyi0000664000175000017500000001536300000000000023272 0ustar00davedave00000000000000import os import sys from _typeshed import OpenBinaryMode, OpenBinaryModeReading, OpenBinaryModeUpdating, OpenBinaryModeWriting, OpenTextMode from io import BufferedRandom, BufferedReader, BufferedWriter, FileIO, TextIOWrapper from types import TracebackType from typing import IO, Any, BinaryIO, Generator, List, Optional, Sequence, Tuple, Type, TypeVar, Union, overload from typing_extensions import Literal if sys.version_info >= (3, 9): from types import GenericAlias _P = TypeVar("_P", bound=PurePath) if sys.version_info >= (3, 6): _PurePathBase = os.PathLike[str] _PathLike = os.PathLike[str] else: _PurePathBase = object _PathLike = PurePath class PurePath(_PurePathBase): parts: Tuple[str, ...] drive: str root: str anchor: str name: str suffix: str suffixes: List[str] stem: str def __new__(cls: Type[_P], *args: Union[str, _PathLike]) -> _P: ... def __hash__(self) -> int: ... def __lt__(self, other: PurePath) -> bool: ... def __le__(self, other: PurePath) -> bool: ... def __gt__(self, other: PurePath) -> bool: ... def __ge__(self, other: PurePath) -> bool: ... def __truediv__(self: _P, key: Union[str, _PathLike]) -> _P: ... def __rtruediv__(self: _P, key: Union[str, _PathLike]) -> _P: ... def __bytes__(self) -> bytes: ... def as_posix(self) -> str: ... def as_uri(self) -> str: ... def is_absolute(self) -> bool: ... def is_reserved(self) -> bool: ... if sys.version_info >= (3, 9): def is_relative_to(self, *other: Union[str, os.PathLike[str]]) -> bool: ... def match(self, path_pattern: str) -> bool: ... def relative_to(self: _P, *other: Union[str, _PathLike]) -> _P: ... def with_name(self: _P, name: str) -> _P: ... if sys.version_info >= (3, 9): def with_stem(self: _P, stem: str) -> _P: ... def with_suffix(self: _P, suffix: str) -> _P: ... def joinpath(self: _P, *other: Union[str, _PathLike]) -> _P: ... @property def parents(self: _P) -> Sequence[_P]: ... @property def parent(self: _P) -> _P: ... if sys.version_info >= (3, 9): def __class_getitem__(cls, type: Any) -> GenericAlias: ... class PurePosixPath(PurePath): ... class PureWindowsPath(PurePath): ... class Path(PurePath): def __new__(cls: Type[_P], *args: Union[str, _PathLike], **kwargs: Any) -> _P: ... def __enter__(self: _P) -> _P: ... def __exit__( self, exc_type: Optional[Type[BaseException]], exc_value: Optional[BaseException], traceback: Optional[TracebackType] ) -> Optional[bool]: ... @classmethod def cwd(cls: Type[_P]) -> _P: ... def stat(self) -> os.stat_result: ... def chmod(self, mode: int) -> None: ... def exists(self) -> bool: ... def glob(self: _P, pattern: str) -> Generator[_P, None, None]: ... def group(self) -> str: ... def is_dir(self) -> bool: ... def is_file(self) -> bool: ... if sys.version_info >= (3, 7): def is_mount(self) -> bool: ... def is_symlink(self) -> bool: ... def is_socket(self) -> bool: ... def is_fifo(self) -> bool: ... def is_block_device(self) -> bool: ... def is_char_device(self) -> bool: ... def iterdir(self: _P) -> Generator[_P, None, None]: ... def lchmod(self, mode: int) -> None: ... def lstat(self) -> os.stat_result: ... def mkdir(self, mode: int = ..., parents: bool = ..., exist_ok: bool = ...) -> None: ... # Adapted from builtins.open # Text mode: always returns a TextIOWrapper @overload def open( self, mode: OpenTextMode = ..., buffering: int = ..., encoding: Optional[str] = ..., errors: Optional[str] = ..., newline: Optional[str] = ..., ) -> TextIOWrapper: ... # Unbuffered binary mode: returns a FileIO @overload def open( self, mode: OpenBinaryMode, buffering: Literal[0], encoding: None = ..., errors: None = ..., newline: None = ... ) -> FileIO: ... # Buffering is on: return BufferedRandom, BufferedReader, or BufferedWriter @overload def open( self, mode: OpenBinaryModeUpdating, buffering: Literal[-1, 1] = ..., encoding: None = ..., errors: None = ..., newline: None = ..., ) -> BufferedRandom: ... @overload def open( self, mode: OpenBinaryModeWriting, buffering: Literal[-1, 1] = ..., encoding: None = ..., errors: None = ..., newline: None = ..., ) -> BufferedWriter: ... @overload def open( self, mode: OpenBinaryModeReading, buffering: Literal[-1, 1] = ..., encoding: None = ..., errors: None = ..., newline: None = ..., ) -> BufferedReader: ... # Buffering cannot be determined: fall back to BinaryIO @overload def open( self, mode: OpenBinaryMode, buffering: int, encoding: None = ..., errors: None = ..., newline: None = ... ) -> BinaryIO: ... # Fallback if mode is not specified @overload def open( self, mode: str, buffering: int = ..., encoding: Optional[str] = ..., errors: Optional[str] = ..., newline: Optional[str] = ..., ) -> IO[Any]: ... def owner(self) -> str: ... if sys.version_info >= (3, 9): def readlink(self: _P) -> _P: ... if sys.version_info >= (3, 8): def rename(self: _P, target: Union[str, PurePath]) -> _P: ... def replace(self: _P, target: Union[str, PurePath]) -> _P: ... else: def rename(self, target: Union[str, PurePath]) -> None: ... def replace(self, target: Union[str, PurePath]) -> None: ... def resolve(self: _P, strict: bool = ...) -> _P: ... def rglob(self: _P, pattern: str) -> Generator[_P, None, None]: ... def rmdir(self) -> None: ... def symlink_to(self, target: Union[str, Path], target_is_directory: bool = ...) -> None: ... def touch(self, mode: int = ..., exist_ok: bool = ...) -> None: ... if sys.version_info >= (3, 8): def unlink(self, missing_ok: bool = ...) -> None: ... else: def unlink(self) -> None: ... @classmethod def home(cls: Type[_P]) -> _P: ... def absolute(self: _P) -> _P: ... def expanduser(self: _P) -> _P: ... def read_bytes(self) -> bytes: ... def read_text(self, encoding: Optional[str] = ..., errors: Optional[str] = ...) -> str: ... def samefile(self, other_path: Union[str, bytes, int, Path]) -> bool: ... def write_bytes(self, data: bytes) -> int: ... def write_text(self, data: str, encoding: Optional[str] = ..., errors: Optional[str] = ...) -> int: ... if sys.version_info >= (3, 8): def link_to(self, target: Union[str, bytes, os.PathLike[str]]) -> None: ... class PosixPath(Path, PurePosixPath): ... class WindowsPath(Path, PureWindowsPath): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/pipes.pyi0000664000175000017500000000100600000000000022754 0ustar00davedave00000000000000import os class Template: def __init__(self) -> None: ... def reset(self) -> None: ... def clone(self) -> Template: ... def debug(self, flag: bool) -> None: ... def append(self, cmd: str, kind: str) -> None: ... def prepend(self, cmd: str, kind: str) -> None: ... def open(self, file: str, rw: str) -> os._wrap_close: ... def copy(self, file: str, rw: str) -> os._wrap_close: ... # Not documented, but widely used. # Documented as shlex.quote since 3.3. def quote(s: str) -> str: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/platform.pyi0000664000175000017500000000434000000000000023464 0ustar00davedave00000000000000import sys if sys.version_info < (3, 9): import os DEV_NULL = os.devnull from typing import NamedTuple, Optional, Tuple if sys.version_info >= (3, 8): def libc_ver( executable: Optional[str] = ..., lib: str = ..., version: str = ..., chunksize: int = ... ) -> Tuple[str, str]: ... else: def libc_ver(executable: str = ..., lib: str = ..., version: str = ..., chunksize: int = ...) -> Tuple[str, str]: ... if sys.version_info < (3, 8): def linux_distribution( distname: str = ..., version: str = ..., id: str = ..., supported_dists: Tuple[str, ...] = ..., full_distribution_name: bool = ..., ) -> Tuple[str, str, str]: ... def dist( distname: str = ..., version: str = ..., id: str = ..., supported_dists: Tuple[str, ...] = ... ) -> Tuple[str, str, str]: ... def win32_ver(release: str = ..., version: str = ..., csd: str = ..., ptype: str = ...) -> Tuple[str, str, str, str]: ... if sys.version_info >= (3, 8): def win32_edition() -> str: ... def win32_is_iot() -> bool: ... def mac_ver( release: str = ..., versioninfo: Tuple[str, str, str] = ..., machine: str = ... ) -> Tuple[str, Tuple[str, str, str], str]: ... def java_ver( release: str = ..., vendor: str = ..., vminfo: Tuple[str, str, str] = ..., osinfo: Tuple[str, str, str] = ... ) -> Tuple[str, str, Tuple[str, str, str], Tuple[str, str, str]]: ... def system_alias(system: str, release: str, version: str) -> Tuple[str, str, str]: ... def architecture(executable: str = ..., bits: str = ..., linkage: str = ...) -> Tuple[str, str]: ... class uname_result(NamedTuple): system: str node: str release: str version: str machine: str processor: str def uname() -> uname_result: ... def system() -> str: ... def node() -> str: ... def release() -> str: ... def version() -> str: ... def machine() -> str: ... def processor() -> str: ... def python_implementation() -> str: ... def python_version() -> str: ... def python_version_tuple() -> Tuple[str, str, str]: ... def python_branch() -> str: ... def python_revision() -> str: ... def python_build() -> Tuple[str, str]: ... def python_compiler() -> str: ... def platform(aliased: bool = ..., terse: bool = ...) -> str: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/posix.pyi0000664000175000017500000000537200000000000023010 0ustar00davedave00000000000000import sys from builtins import _PathLike # See comment in builtins from os import stat_result as stat_result from typing import Dict, List, NamedTuple, Optional, overload class uname_result(NamedTuple): sysname: str nodename: str release: str version: str machine: str class times_result(NamedTuple): user: float system: float children_user: float children_system: float elapsed: float class waitid_result(NamedTuple): si_pid: int si_uid: int si_signo: int si_status: int si_code: int class sched_param(NamedTuple): sched_priority: int CLD_CONTINUED: int CLD_DUMPED: int CLD_EXITED: int CLD_TRAPPED: int EX_CANTCREAT: int EX_CONFIG: int EX_DATAERR: int EX_IOERR: int EX_NOHOST: int EX_NOINPUT: int EX_NOPERM: int EX_NOTFOUND: int EX_NOUSER: int EX_OK: int EX_OSERR: int EX_OSFILE: int EX_PROTOCOL: int EX_SOFTWARE: int EX_TEMPFAIL: int EX_UNAVAILABLE: int EX_USAGE: int F_OK: int R_OK: int W_OK: int X_OK: int F_LOCK: int F_TEST: int F_TLOCK: int F_ULOCK: int GRND_NONBLOCK: int GRND_RANDOM: int NGROUPS_MAX: int O_APPEND: int O_ACCMODE: int O_ASYNC: int O_CREAT: int O_DIRECT: int O_DIRECTORY: int O_DSYNC: int O_EXCL: int O_LARGEFILE: int O_NDELAY: int O_NOATIME: int O_NOCTTY: int O_NOFOLLOW: int O_NONBLOCK: int O_RDONLY: int O_RDWR: int O_RSYNC: int O_SYNC: int O_TRUNC: int O_WRONLY: int POSIX_FADV_DONTNEED: int POSIX_FADV_NOREUSE: int POSIX_FADV_NORMAL: int POSIX_FADV_RANDOM: int POSIX_FADV_SEQUENTIAL: int POSIX_FADV_WILLNEED: int PRIO_PGRP: int PRIO_PROCESS: int PRIO_USER: int P_ALL: int P_PGID: int P_PID: int RTLD_DEEPBIND: int RTLD_GLOBAL: int RTLD_LAZY: int RTLD_LOCAL: int RTLD_NODELETE: int RTLD_NOLOAD: int RTLD_NOW: int SCHED_BATCH: int SCHED_FIFO: int SCHED_IDLE: int SCHED_OTHER: int SCHED_RESET_ON_FORK: int SCHED_RR: int SEEK_DATA: int SEEK_HOLE: int ST_APPEND: int ST_MANDLOCK: int ST_NOATIME: int ST_NODEV: int ST_NODIRATIME: int ST_NOEXEC: int ST_NOSUID: int ST_RDONLY: int ST_RELATIME: int ST_SYNCHRONOUS: int ST_WRITE: int TMP_MAX: int WCONTINUED: int def WCOREDUMP(__status: int) -> bool: ... def WEXITSTATUS(status: int) -> int: ... def WIFCONTINUED(status: int) -> bool: ... def WIFEXITED(status: int) -> bool: ... def WIFSIGNALED(status: int) -> bool: ... def WIFSTOPPED(status: int) -> bool: ... WNOHANG: int def WSTOPSIG(status: int) -> int: ... def WTERMSIG(status: int) -> int: ... WUNTRACED: int XATTR_CREATE: int XATTR_REPLACE: int XATTR_SIZE_MAX: int @overload def listdir(path: Optional[str] = ...) -> List[str]: ... @overload def listdir(path: bytes) -> List[bytes]: ... @overload def listdir(path: int) -> List[str]: ... @overload def listdir(path: _PathLike[str]) -> List[str]: ... if sys.platform == "win32": environ: Dict[str, str] else: environ: Dict[bytes, bytes] ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/posixpath.pyi0000664000175000017500000001116100000000000023656 0ustar00davedave00000000000000import os import sys from _typeshed import AnyPath, BytesPath, StrPath from genericpath import exists as exists from typing import Any, AnyStr, Optional, Sequence, Tuple, TypeVar, overload _T = TypeVar("_T") if sys.version_info >= (3, 6): from builtins import _PathLike # ----- os.path variables ----- supports_unicode_filenames: bool # aliases (also in os) curdir: str pardir: str sep: str if sys.platform == "win32": altsep: str else: altsep: Optional[str] extsep: str pathsep: str defpath: str devnull: str # ----- os.path function stubs ----- if sys.version_info >= (3, 6): # Overloads are necessary to work around python/mypy#3644. @overload def abspath(path: _PathLike[AnyStr]) -> AnyStr: ... @overload def abspath(path: AnyStr) -> AnyStr: ... @overload def basename(p: _PathLike[AnyStr]) -> AnyStr: ... @overload def basename(p: AnyStr) -> AnyStr: ... @overload def dirname(p: _PathLike[AnyStr]) -> AnyStr: ... @overload def dirname(p: AnyStr) -> AnyStr: ... @overload def expanduser(path: _PathLike[AnyStr]) -> AnyStr: ... @overload def expanduser(path: AnyStr) -> AnyStr: ... @overload def expandvars(path: _PathLike[AnyStr]) -> AnyStr: ... @overload def expandvars(path: AnyStr) -> AnyStr: ... @overload def normcase(s: _PathLike[AnyStr]) -> AnyStr: ... @overload def normcase(s: AnyStr) -> AnyStr: ... @overload def normpath(path: _PathLike[AnyStr]) -> AnyStr: ... @overload def normpath(path: AnyStr) -> AnyStr: ... if sys.platform == "win32": @overload def realpath(path: _PathLike[AnyStr]) -> AnyStr: ... @overload def realpath(path: AnyStr) -> AnyStr: ... else: @overload def realpath(filename: _PathLike[AnyStr]) -> AnyStr: ... @overload def realpath(filename: AnyStr) -> AnyStr: ... else: def abspath(path: AnyStr) -> AnyStr: ... def basename(p: AnyStr) -> AnyStr: ... def dirname(p: AnyStr) -> AnyStr: ... def expanduser(path: AnyStr) -> AnyStr: ... def expandvars(path: AnyStr) -> AnyStr: ... def normcase(s: AnyStr) -> AnyStr: ... def normpath(path: AnyStr) -> AnyStr: ... if sys.platform == "win32": def realpath(path: AnyStr) -> AnyStr: ... else: def realpath(filename: AnyStr) -> AnyStr: ... if sys.version_info >= (3, 6): # In reality it returns str for sequences of StrPath and bytes for sequences # of BytesPath, but mypy does not accept such a signature. def commonpath(paths: Sequence[AnyPath]) -> Any: ... elif sys.version_info >= (3, 5): def commonpath(paths: Sequence[AnyStr]) -> AnyStr: ... # NOTE: Empty lists results in '' (str) regardless of contained type. # So, fall back to Any def commonprefix(m: Sequence[AnyPath]) -> Any: ... def lexists(path: AnyPath) -> bool: ... # These return float if os.stat_float_times() == True, # but int is a subclass of float. def getatime(filename: AnyPath) -> float: ... def getmtime(filename: AnyPath) -> float: ... def getctime(filename: AnyPath) -> float: ... def getsize(filename: AnyPath) -> int: ... def isabs(s: AnyPath) -> bool: ... def isfile(path: AnyPath) -> bool: ... def isdir(s: AnyPath) -> bool: ... def islink(path: AnyPath) -> bool: ... def ismount(path: AnyPath) -> bool: ... if sys.version_info >= (3, 6): @overload def join(a: StrPath, *paths: StrPath) -> str: ... @overload def join(a: BytesPath, *paths: BytesPath) -> bytes: ... else: def join(a: AnyStr, *paths: AnyStr) -> AnyStr: ... @overload def relpath(path: BytesPath, start: Optional[BytesPath] = ...) -> bytes: ... @overload def relpath(path: StrPath, start: Optional[StrPath] = ...) -> str: ... def samefile(f1: AnyPath, f2: AnyPath) -> bool: ... def sameopenfile(fp1: int, fp2: int) -> bool: ... def samestat(s1: os.stat_result, s2: os.stat_result) -> bool: ... if sys.version_info >= (3, 6): @overload def split(p: _PathLike[AnyStr]) -> Tuple[AnyStr, AnyStr]: ... @overload def split(p: AnyStr) -> Tuple[AnyStr, AnyStr]: ... @overload def splitdrive(p: _PathLike[AnyStr]) -> Tuple[AnyStr, AnyStr]: ... @overload def splitdrive(p: AnyStr) -> Tuple[AnyStr, AnyStr]: ... @overload def splitext(p: _PathLike[AnyStr]) -> Tuple[AnyStr, AnyStr]: ... @overload def splitext(p: AnyStr) -> Tuple[AnyStr, AnyStr]: ... else: def split(p: AnyStr) -> Tuple[AnyStr, AnyStr]: ... def splitdrive(p: AnyStr) -> Tuple[AnyStr, AnyStr]: ... def splitext(p: AnyStr) -> Tuple[AnyStr, AnyStr]: ... if sys.version_info < (3, 7) and sys.platform == "win32": def splitunc(p: AnyStr) -> Tuple[AnyStr, AnyStr]: ... # deprecated ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/queue.pyi0000664000175000017500000000353400000000000022770 0ustar00davedave00000000000000import sys from threading import Condition, Lock from typing import Any, Generic, Optional, TypeVar if sys.version_info >= (3, 9): from types import GenericAlias _T = TypeVar("_T") class Empty(Exception): ... class Full(Exception): ... class Queue(Generic[_T]): maxsize: int mutex: Lock # undocumented not_empty: Condition # undocumented not_full: Condition # undocumented all_tasks_done: Condition # undocumented unfinished_tasks: int # undocumented queue: Any # undocumented def __init__(self, maxsize: int = ...) -> None: ... def _init(self, maxsize: int) -> None: ... def empty(self) -> bool: ... def full(self) -> bool: ... def get(self, block: bool = ..., timeout: Optional[float] = ...) -> _T: ... def get_nowait(self) -> _T: ... def _get(self) -> _T: ... def put(self, item: _T, block: bool = ..., timeout: Optional[float] = ...) -> None: ... def put_nowait(self, item: _T) -> None: ... def _put(self, item: _T) -> None: ... def join(self) -> None: ... def qsize(self) -> int: ... def _qsize(self) -> int: ... def task_done(self) -> None: ... if sys.version_info >= (3, 9): def __class_getitem__(cls, item: Any) -> GenericAlias: ... class PriorityQueue(Queue[_T]): ... class LifoQueue(Queue[_T]): ... if sys.version_info >= (3, 7): class SimpleQueue(Generic[_T]): def __init__(self) -> None: ... def empty(self) -> bool: ... def get(self, block: bool = ..., timeout: Optional[float] = ...) -> _T: ... def get_nowait(self) -> _T: ... def put(self, item: _T, block: bool = ..., timeout: Optional[float] = ...) -> None: ... def put_nowait(self, item: _T) -> None: ... def qsize(self) -> int: ... if sys.version_info >= (3, 9): def __class_getitem__(cls, item: Any) -> GenericAlias: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/random.pyi0000664000175000017500000000747500000000000023134 0ustar00davedave00000000000000import _random import sys from typing import AbstractSet, Any, Callable, Iterable, List, MutableSequence, Optional, Sequence, Tuple, TypeVar, Union _T = TypeVar("_T") class Random(_random.Random): def __init__(self, x: Any = ...) -> None: ... def seed(self, a: Any = ..., version: int = ...) -> None: ... def getstate(self) -> Tuple[Any, ...]: ... def setstate(self, state: Tuple[Any, ...]) -> None: ... def getrandbits(self, __k: int) -> int: ... def randrange(self, start: int, stop: Optional[int] = ..., step: int = ...) -> int: ... def randint(self, a: int, b: int) -> int: ... if sys.version_info >= (3, 9): def randbytes(self, n: int) -> bytes: ... def choice(self, seq: Sequence[_T]) -> _T: ... def choices( self, population: Sequence[_T], weights: Optional[Sequence[float]] = ..., *, cum_weights: Optional[Sequence[float]] = ..., k: int = ..., ) -> List[_T]: ... def shuffle(self, x: MutableSequence[Any], random: Optional[Callable[[], float]] = ...) -> None: ... if sys.version_info >= (3, 9): def sample( self, population: Union[Sequence[_T], AbstractSet[_T]], k: int, *, counts: Optional[Iterable[_T]] = ... ) -> List[_T]: ... else: def sample(self, population: Union[Sequence[_T], AbstractSet[_T]], k: int) -> List[_T]: ... def random(self) -> float: ... def uniform(self, a: float, b: float) -> float: ... def triangular(self, low: float = ..., high: float = ..., mode: Optional[float] = ...) -> float: ... def betavariate(self, alpha: float, beta: float) -> float: ... def expovariate(self, lambd: float) -> float: ... def gammavariate(self, alpha: float, beta: float) -> float: ... def gauss(self, mu: float, sigma: float) -> float: ... def lognormvariate(self, mu: float, sigma: float) -> float: ... def normalvariate(self, mu: float, sigma: float) -> float: ... def vonmisesvariate(self, mu: float, kappa: float) -> float: ... def paretovariate(self, alpha: float) -> float: ... def weibullvariate(self, alpha: float, beta: float) -> float: ... # SystemRandom is not implemented for all OS's; good on Windows & Linux class SystemRandom(Random): ... # ----- random function stubs ----- def seed(a: Any = ..., version: int = ...) -> None: ... def getstate() -> object: ... def setstate(state: object) -> None: ... def getrandbits(__k: int) -> int: ... def randrange(start: int, stop: Union[None, int] = ..., step: int = ...) -> int: ... def randint(a: int, b: int) -> int: ... if sys.version_info >= (3, 9): def randbytes(n: int) -> bytes: ... def choice(seq: Sequence[_T]) -> _T: ... def choices( population: Sequence[_T], weights: Optional[Sequence[float]] = ..., *, cum_weights: Optional[Sequence[float]] = ..., k: int = ..., ) -> List[_T]: ... def shuffle(x: MutableSequence[Any], random: Optional[Callable[[], float]] = ...) -> None: ... if sys.version_info >= (3, 9): def sample(population: Union[Sequence[_T], AbstractSet[_T]], k: int, *, counts: Optional[Iterable[_T]] = ...) -> List[_T]: ... else: def sample(population: Union[Sequence[_T], AbstractSet[_T]], k: int) -> List[_T]: ... def random() -> float: ... def uniform(a: float, b: float) -> float: ... def triangular(low: float = ..., high: float = ..., mode: Optional[float] = ...) -> float: ... def betavariate(alpha: float, beta: float) -> float: ... def expovariate(lambd: float) -> float: ... def gammavariate(alpha: float, beta: float) -> float: ... def gauss(mu: float, sigma: float) -> float: ... def lognormvariate(mu: float, sigma: float) -> float: ... def normalvariate(mu: float, sigma: float) -> float: ... def vonmisesvariate(mu: float, kappa: float) -> float: ... def paretovariate(alpha: float) -> float: ... def weibullvariate(alpha: float, beta: float) -> float: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/re.pyi0000664000175000017500000001053200000000000022246 0ustar00davedave00000000000000import enum import sys from typing import Any, AnyStr, Callable, Iterator, List, Optional, Tuple, Union, overload # ----- re variables and constants ----- if sys.version_info >= (3, 7): from typing import Match as Match, Pattern as Pattern else: from typing import Match, Pattern class RegexFlag(enum.IntFlag): A: int ASCII: int DEBUG: int I: int IGNORECASE: int L: int LOCALE: int M: int MULTILINE: int S: int DOTALL: int X: int VERBOSE: int U: int UNICODE: int T: int TEMPLATE: int A = RegexFlag.A ASCII = RegexFlag.ASCII DEBUG = RegexFlag.DEBUG I = RegexFlag.I IGNORECASE = RegexFlag.IGNORECASE L = RegexFlag.L LOCALE = RegexFlag.LOCALE M = RegexFlag.M MULTILINE = RegexFlag.MULTILINE S = RegexFlag.S DOTALL = RegexFlag.DOTALL X = RegexFlag.X VERBOSE = RegexFlag.VERBOSE U = RegexFlag.U UNICODE = RegexFlag.UNICODE T = RegexFlag.T TEMPLATE = RegexFlag.TEMPLATE _FlagsType = Union[int, RegexFlag] if sys.version_info < (3, 7): # undocumented _pattern_type: type class error(Exception): msg: str pattern: str pos: Optional[int] lineno: Optional[int] colno: Optional[int] @overload def compile(pattern: AnyStr, flags: _FlagsType = ...) -> Pattern[AnyStr]: ... @overload def compile(pattern: Pattern[AnyStr], flags: _FlagsType = ...) -> Pattern[AnyStr]: ... @overload def search(pattern: AnyStr, string: AnyStr, flags: _FlagsType = ...) -> Optional[Match[AnyStr]]: ... @overload def search(pattern: Pattern[AnyStr], string: AnyStr, flags: _FlagsType = ...) -> Optional[Match[AnyStr]]: ... @overload def match(pattern: AnyStr, string: AnyStr, flags: _FlagsType = ...) -> Optional[Match[AnyStr]]: ... @overload def match(pattern: Pattern[AnyStr], string: AnyStr, flags: _FlagsType = ...) -> Optional[Match[AnyStr]]: ... # New in Python 3.4 @overload def fullmatch(pattern: AnyStr, string: AnyStr, flags: _FlagsType = ...) -> Optional[Match[AnyStr]]: ... @overload def fullmatch(pattern: Pattern[AnyStr], string: AnyStr, flags: _FlagsType = ...) -> Optional[Match[AnyStr]]: ... @overload def split(pattern: AnyStr, string: AnyStr, maxsplit: int = ..., flags: _FlagsType = ...) -> List[AnyStr]: ... @overload def split(pattern: Pattern[AnyStr], string: AnyStr, maxsplit: int = ..., flags: _FlagsType = ...) -> List[AnyStr]: ... @overload def findall(pattern: AnyStr, string: AnyStr, flags: _FlagsType = ...) -> List[Any]: ... @overload def findall(pattern: Pattern[AnyStr], string: AnyStr, flags: _FlagsType = ...) -> List[Any]: ... # Return an iterator yielding match objects over all non-overlapping matches # for the RE pattern in string. The string is scanned left-to-right, and # matches are returned in the order found. Empty matches are included in the # result unless they touch the beginning of another match. @overload def finditer(pattern: AnyStr, string: AnyStr, flags: _FlagsType = ...) -> Iterator[Match[AnyStr]]: ... @overload def finditer(pattern: Pattern[AnyStr], string: AnyStr, flags: _FlagsType = ...) -> Iterator[Match[AnyStr]]: ... @overload def sub(pattern: AnyStr, repl: AnyStr, string: AnyStr, count: int = ..., flags: _FlagsType = ...) -> AnyStr: ... @overload def sub( pattern: AnyStr, repl: Callable[[Match[AnyStr]], AnyStr], string: AnyStr, count: int = ..., flags: _FlagsType = ... ) -> AnyStr: ... @overload def sub(pattern: Pattern[AnyStr], repl: AnyStr, string: AnyStr, count: int = ..., flags: _FlagsType = ...) -> AnyStr: ... @overload def sub( pattern: Pattern[AnyStr], repl: Callable[[Match[AnyStr]], AnyStr], string: AnyStr, count: int = ..., flags: _FlagsType = ... ) -> AnyStr: ... @overload def subn(pattern: AnyStr, repl: AnyStr, string: AnyStr, count: int = ..., flags: _FlagsType = ...) -> Tuple[AnyStr, int]: ... @overload def subn( pattern: AnyStr, repl: Callable[[Match[AnyStr]], AnyStr], string: AnyStr, count: int = ..., flags: _FlagsType = ... ) -> Tuple[AnyStr, int]: ... @overload def subn( pattern: Pattern[AnyStr], repl: AnyStr, string: AnyStr, count: int = ..., flags: _FlagsType = ... ) -> Tuple[AnyStr, int]: ... @overload def subn( pattern: Pattern[AnyStr], repl: Callable[[Match[AnyStr]], AnyStr], string: AnyStr, count: int = ..., flags: _FlagsType = ... ) -> Tuple[AnyStr, int]: ... def escape(pattern: AnyStr) -> AnyStr: ... def purge() -> None: ... def template(pattern: Union[AnyStr, Pattern[AnyStr]], flags: _FlagsType = ...) -> Pattern[AnyStr]: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/reprlib.pyi0000664000175000017500000000231400000000000023276 0ustar00davedave00000000000000from array import array from typing import Any, Callable, Deque, Dict, FrozenSet, List, Set, Tuple _ReprFunc = Callable[[Any], str] def recursive_repr(fillvalue: str = ...) -> Callable[[_ReprFunc], _ReprFunc]: ... class Repr: maxlevel: int maxdict: int maxlist: int maxtuple: int maxset: int maxfrozenset: int maxdeque: int maxarray: int maxlong: int maxstring: int maxother: int def __init__(self) -> None: ... def repr(self, x: Any) -> str: ... def repr1(self, x: Any, level: int) -> str: ... def repr_tuple(self, x: Tuple[Any, ...], level: int) -> str: ... def repr_list(self, x: List[Any], level: int) -> str: ... def repr_array(self, x: array[Any], level: int) -> str: ... def repr_set(self, x: Set[Any], level: int) -> str: ... def repr_frozenset(self, x: FrozenSet[Any], level: int) -> str: ... def repr_deque(self, x: Deque[Any], level: int) -> str: ... def repr_dict(self, x: Dict[Any, Any], level: int) -> str: ... def repr_str(self, x: str, level: int) -> str: ... def repr_int(self, x: int, level: int) -> str: ... def repr_instance(self, x: Any, level: int) -> str: ... aRepr: Repr def repr(x: object) -> str: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/resource.pyi0000664000175000017500000000233300000000000023467 0ustar00davedave00000000000000import sys from typing import NamedTuple, Tuple, overload RLIMIT_AS: int RLIMIT_CORE: int RLIMIT_CPU: int RLIMIT_DATA: int RLIMIT_FSIZE: int RLIMIT_MEMLOCK: int RLIMIT_NOFILE: int RLIMIT_NPROC: int RLIMIT_RSS: int RLIMIT_STACK: int RLIM_INFINITY: int RUSAGE_CHILDREN: int RUSAGE_SELF: int if sys.platform == "linux": RLIMIT_MSGQUEUE: int RLIMIT_NICE: int RLIMIT_OFILE: int RLIMIT_RTPRIO: int RLIMIT_RTTIME: int RLIMIT_SIGPENDING: int RUSAGE_THREAD: int class _RUsage(NamedTuple): ru_utime: float ru_stime: float ru_maxrss: int ru_ixrss: int ru_idrss: int ru_isrss: int ru_minflt: int ru_majflt: int ru_nswap: int ru_inblock: int ru_oublock: int ru_msgsnd: int ru_msgrcv: int ru_nsignals: int ru_nvcsw: int ru_nivcsw: int def getpagesize() -> int: ... def getrlimit(__resource: int) -> Tuple[int, int]: ... def getrusage(__who: int) -> _RUsage: ... def setrlimit(__resource: int, __limits: Tuple[int, int]) -> None: ... if sys.platform == "linux": @overload def prlimit(pid: int, resource: int, limits: Tuple[int, int]) -> Tuple[int, int]: ... @overload def prlimit(pid: int, resource: int) -> Tuple[int, int]: ... error = OSError ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/runpy.pyi0000664000175000017500000000135200000000000023015 0ustar00davedave00000000000000from types import ModuleType from typing import Any, Dict, Optional, TypeVar _T = TypeVar("_T") class _TempModule: mod_name: str = ... module: ModuleType = ... def __init__(self, mod_name: str) -> None: ... def __enter__(self: _T) -> _T: ... def __exit__(self, *args: Any) -> None: ... class _ModifiedArgv0: value: Any = ... def __init__(self, value: Any) -> None: ... def __enter__(self: _T) -> _T: ... def __exit__(self, *args: Any) -> None: ... def run_module( mod_name: str, init_globals: Optional[Dict[str, Any]] = ..., run_name: Optional[str] = ..., alter_sys: bool = ... ) -> None: ... def run_path(path_name: str, init_globals: Optional[Dict[str, Any]] = ..., run_name: str = ...) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/secrets.pyi0000664000175000017500000000072300000000000023311 0ustar00davedave00000000000000from hmac import compare_digest as compare_digest from random import SystemRandom as SystemRandom from typing import Optional, Sequence, TypeVar _T = TypeVar("_T") def randbelow(exclusive_upper_bound: int) -> int: ... def randbits(k: int) -> int: ... def choice(seq: Sequence[_T]) -> _T: ... def token_bytes(nbytes: Optional[int] = ...) -> bytes: ... def token_hex(nbytes: Optional[int] = ...) -> str: ... def token_urlsafe(nbytes: Optional[int] = ...) -> str: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/selectors.pyi0000664000175000017500000000707400000000000023652 0ustar00davedave00000000000000import sys from _typeshed import FileDescriptor, FileDescriptorLike from abc import ABCMeta, abstractmethod from typing import Any, List, Mapping, NamedTuple, Optional, Tuple _EventMask = int EVENT_READ: _EventMask EVENT_WRITE: _EventMask class SelectorKey(NamedTuple): fileobj: FileDescriptorLike fd: FileDescriptor events: _EventMask data: Any class BaseSelector(metaclass=ABCMeta): @abstractmethod def register(self, fileobj: FileDescriptorLike, events: _EventMask, data: Any = ...) -> SelectorKey: ... @abstractmethod def unregister(self, fileobj: FileDescriptorLike) -> SelectorKey: ... def modify(self, fileobj: FileDescriptorLike, events: _EventMask, data: Any = ...) -> SelectorKey: ... @abstractmethod def select(self, timeout: Optional[float] = ...) -> List[Tuple[SelectorKey, _EventMask]]: ... def close(self) -> None: ... def get_key(self, fileobj: FileDescriptorLike) -> SelectorKey: ... @abstractmethod def get_map(self) -> Mapping[FileDescriptorLike, SelectorKey]: ... def __enter__(self) -> BaseSelector: ... def __exit__(self, *args: Any) -> None: ... class SelectSelector(BaseSelector): def register(self, fileobj: FileDescriptorLike, events: _EventMask, data: Any = ...) -> SelectorKey: ... def unregister(self, fileobj: FileDescriptorLike) -> SelectorKey: ... def select(self, timeout: Optional[float] = ...) -> List[Tuple[SelectorKey, _EventMask]]: ... def get_map(self) -> Mapping[FileDescriptorLike, SelectorKey]: ... if sys.platform != "win32": class PollSelector(BaseSelector): def register(self, fileobj: FileDescriptorLike, events: _EventMask, data: Any = ...) -> SelectorKey: ... def unregister(self, fileobj: FileDescriptorLike) -> SelectorKey: ... def select(self, timeout: Optional[float] = ...) -> List[Tuple[SelectorKey, _EventMask]]: ... def get_map(self) -> Mapping[FileDescriptorLike, SelectorKey]: ... class EpollSelector(BaseSelector): def fileno(self) -> int: ... def register(self, fileobj: FileDescriptorLike, events: _EventMask, data: Any = ...) -> SelectorKey: ... def unregister(self, fileobj: FileDescriptorLike) -> SelectorKey: ... def select(self, timeout: Optional[float] = ...) -> List[Tuple[SelectorKey, _EventMask]]: ... def get_map(self) -> Mapping[FileDescriptorLike, SelectorKey]: ... class DevpollSelector(BaseSelector): def fileno(self) -> int: ... def register(self, fileobj: FileDescriptorLike, events: _EventMask, data: Any = ...) -> SelectorKey: ... def unregister(self, fileobj: FileDescriptorLike) -> SelectorKey: ... def select(self, timeout: Optional[float] = ...) -> List[Tuple[SelectorKey, _EventMask]]: ... def get_map(self) -> Mapping[FileDescriptorLike, SelectorKey]: ... class KqueueSelector(BaseSelector): def fileno(self) -> int: ... def register(self, fileobj: FileDescriptorLike, events: _EventMask, data: Any = ...) -> SelectorKey: ... def unregister(self, fileobj: FileDescriptorLike) -> SelectorKey: ... def select(self, timeout: Optional[float] = ...) -> List[Tuple[SelectorKey, _EventMask]]: ... def get_map(self) -> Mapping[FileDescriptorLike, SelectorKey]: ... class DefaultSelector(BaseSelector): def register(self, fileobj: FileDescriptorLike, events: _EventMask, data: Any = ...) -> SelectorKey: ... def unregister(self, fileobj: FileDescriptorLike) -> SelectorKey: ... def select(self, timeout: Optional[float] = ...) -> List[Tuple[SelectorKey, _EventMask]]: ... def get_map(self) -> Mapping[FileDescriptorLike, SelectorKey]: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/shelve.pyi0000664000175000017500000000310500000000000023124 0ustar00davedave00000000000000import collections from typing import Any, Dict, Iterator, Optional, Tuple class Shelf(collections.MutableMapping[Any, Any]): def __init__( self, dict: Dict[bytes, Any], protocol: Optional[int] = ..., writeback: bool = ..., keyencoding: str = ... ) -> None: ... def __iter__(self) -> Iterator[str]: ... def __len__(self) -> int: ... def __contains__(self, key: Any) -> bool: ... # key should be str, but it would conflict with superclass's type signature def get(self, key: str, default: Any = ...) -> Any: ... def __getitem__(self, key: str) -> Any: ... def __setitem__(self, key: str, value: Any) -> None: ... def __delitem__(self, key: str) -> None: ... def __enter__(self) -> Shelf: ... def __exit__(self, type: Any, value: Any, traceback: Any) -> None: ... def close(self) -> None: ... def __del__(self) -> None: ... def sync(self) -> None: ... class BsdDbShelf(Shelf): def __init__( self, dict: Dict[bytes, Any], protocol: Optional[int] = ..., writeback: bool = ..., keyencoding: str = ... ) -> None: ... def set_location(self, key: Any) -> Tuple[str, Any]: ... def next(self) -> Tuple[str, Any]: ... def previous(self) -> Tuple[str, Any]: ... def first(self) -> Tuple[str, Any]: ... def last(self) -> Tuple[str, Any]: ... class DbfilenameShelf(Shelf): def __init__(self, filename: str, flag: str = ..., protocol: Optional[int] = ..., writeback: bool = ...) -> None: ... def open(filename: str, flag: str = ..., protocol: Optional[int] = ..., writeback: bool = ...) -> DbfilenameShelf: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/shlex.pyi0000664000175000017500000000245500000000000022770 0ustar00davedave00000000000000import sys from typing import Any, Iterable, List, Optional, TextIO, Tuple, TypeVar, Union def split(s: str, comments: bool = ..., posix: bool = ...) -> List[str]: ... if sys.version_info >= (3, 8): def join(split_command: Iterable[str]) -> str: ... def quote(s: str) -> str: ... _SLT = TypeVar("_SLT", bound=shlex) class shlex(Iterable[str]): commenters: str wordchars: str whitespace: str escape: str quotes: str escapedquotes: str whitespace_split: bool infile: str instream: TextIO source: str debug: int lineno: int token: str eof: str punctuation_chars: str def __init__( self, instream: Union[str, TextIO] = ..., infile: Optional[str] = ..., posix: bool = ..., punctuation_chars: Union[bool, str] = ..., ) -> None: ... def get_token(self) -> str: ... def push_token(self, tok: str) -> None: ... def read_token(self) -> str: ... def sourcehook(self, filename: str) -> Tuple[str, TextIO]: ... # TODO argument types def push_source(self, newstream: Any, newfile: Any = ...) -> None: ... def pop_source(self) -> None: ... def error_leader(self, infile: str = ..., lineno: int = ...) -> None: ... def __iter__(self: _SLT) -> _SLT: ... def __next__(self) -> str: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/signal.pyi0000664000175000017500000001213100000000000023112 0ustar00davedave00000000000000import sys from enum import IntEnum from types import FrameType from typing import Any, Callable, Iterable, Optional, Set, Tuple, Union if sys.platform != "win32": class ItimerError(IOError): ... ITIMER_PROF: int ITIMER_REAL: int ITIMER_VIRTUAL: int NSIG: int class Signals(IntEnum): SIGABRT: int if sys.platform != "win32": SIGALRM: int if sys.platform == "win32": SIGBREAK: int if sys.platform != "win32": SIGBUS: int SIGCHLD: int if sys.platform != "darwin" and sys.platform != "win32": SIGCLD: int if sys.platform != "win32": SIGCONT: int SIGEMT: int SIGFPE: int if sys.platform != "win32": SIGHUP: int SIGILL: int SIGINFO: int SIGINT: int if sys.platform != "win32": SIGIO: int SIGIOT: int SIGKILL: int SIGPIPE: int if sys.platform != "darwin" and sys.platform != "win32": SIGPOLL: int SIGPWR: int if sys.platform != "win32": SIGPROF: int SIGQUIT: int if sys.platform != "darwin" and sys.platform != "win32": SIGRTMAX: int SIGRTMIN: int SIGSEGV: int if sys.platform != "win32": SIGSTOP: int SIGSYS: int SIGTERM: int if sys.platform != "win32": SIGTRAP: int SIGTSTP: int SIGTTIN: int SIGTTOU: int SIGURG: int SIGUSR1: int SIGUSR2: int SIGVTALRM: int SIGWINCH: int SIGXCPU: int SIGXFSZ: int class Handlers(IntEnum): SIG_DFL: int SIG_IGN: int SIG_DFL = Handlers.SIG_DFL SIG_IGN = Handlers.SIG_IGN if sys.platform != "win32": class Sigmasks(IntEnum): SIG_BLOCK: int SIG_UNBLOCK: int SIG_SETMASK: int SIG_BLOCK = Sigmasks.SIG_BLOCK SIG_UNBLOCK = Sigmasks.SIG_UNBLOCK SIG_SETMASK = Sigmasks.SIG_SETMASK _SIGNUM = Union[int, Signals] _HANDLER = Union[Callable[[Signals, FrameType], Any], int, Handlers, None] SIGABRT: Signals if sys.platform != "win32": SIGALRM: Signals if sys.platform == "win32": SIGBREAK: Signals if sys.platform != "win32": SIGBUS: Signals SIGCHLD: Signals if sys.platform != "darwin" and sys.platform != "win32": SIGCLD: Signals if sys.platform != "win32": SIGCONT: Signals SIGEMT: Signals SIGFPE: Signals if sys.platform != "win32": SIGHUP: Signals SIGILL: Signals SIGINFO: Signals SIGINT: Signals if sys.platform != "win32": SIGIO: Signals SIGIOT: Signals SIGKILL: Signals SIGPIPE: Signals if sys.platform != "darwin" and sys.platform != "win32": SIGPOLL: Signals SIGPWR: Signals if sys.platform != "win32": SIGPROF: Signals SIGQUIT: Signals if sys.platform != "darwin" and sys.platform != "win32": SIGRTMAX: Signals SIGRTMIN: Signals SIGSEGV: Signals if sys.platform != "win32": SIGSTOP: Signals SIGSYS: Signals SIGTERM: Signals if sys.platform != "win32": SIGTRAP: Signals SIGTSTP: Signals SIGTTIN: Signals SIGTTOU: Signals SIGURG: Signals SIGUSR1: Signals SIGUSR2: Signals SIGVTALRM: Signals SIGWINCH: Signals SIGXCPU: Signals SIGXFSZ: Signals if sys.platform == "win32": CTRL_C_EVENT: int CTRL_BREAK_EVENT: int if sys.platform != "win32": class struct_siginfo(Tuple[int, int, int, int, int, int, int]): def __init__(self, sequence: Iterable[int]) -> None: ... @property def si_signo(self) -> int: ... @property def si_code(self) -> int: ... @property def si_errno(self) -> int: ... @property def si_pid(self) -> int: ... @property def si_uid(self) -> int: ... @property def si_status(self) -> int: ... @property def si_band(self) -> int: ... if sys.platform != "win32": def alarm(__seconds: int) -> int: ... def default_int_handler(signum: int, frame: FrameType) -> None: ... if sys.platform != "win32": def getitimer(__which: int) -> Tuple[float, float]: ... def getsignal(__signalnum: _SIGNUM) -> _HANDLER: ... if sys.version_info >= (3, 8): def strsignal(__signalnum: _SIGNUM) -> Optional[str]: ... def valid_signals() -> Set[Signals]: ... def raise_signal(__signalnum: _SIGNUM) -> None: ... if sys.platform != "win32": def pause() -> None: ... def pthread_kill(__thread_id: int, __signalnum: int) -> None: ... def pthread_sigmask(__how: int, __mask: Iterable[int]) -> Set[_SIGNUM]: ... if sys.version_info >= (3, 7): def set_wakeup_fd(fd: int, *, warn_on_full_buffer: bool = ...) -> int: ... else: def set_wakeup_fd(fd: int) -> int: ... if sys.platform != "win32": def setitimer(__which: int, __seconds: float, __interval: float = ...) -> Tuple[float, float]: ... def siginterrupt(__signalnum: int, __flag: bool) -> None: ... def signal(__signalnum: _SIGNUM, __handler: _HANDLER) -> _HANDLER: ... if sys.platform != "win32": def sigpending() -> Any: ... def sigtimedwait(sigset: Iterable[int], timeout: float) -> Optional[struct_siginfo]: ... def sigwait(__sigset: Iterable[int]) -> _SIGNUM: ... def sigwaitinfo(sigset: Iterable[int]) -> struct_siginfo: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/smtplib.pyi0000664000175000017500000001274600000000000023323 0ustar00davedave00000000000000from email.message import Message as _Message from socket import socket from ssl import SSLContext from types import TracebackType from typing import Any, Dict, List, Optional, Pattern, Protocol, Sequence, Tuple, Type, Union, overload _Reply = Tuple[int, bytes] _SendErrs = Dict[str, _Reply] # Should match source_address for socket.create_connection _SourceAddress = Tuple[Union[bytearray, bytes, str], int] SMTP_PORT: int SMTP_SSL_PORT: int CRLF: str bCRLF: bytes OLDSTYLE_AUTH: Pattern[str] class SMTPException(OSError): ... class SMTPNotSupportedError(SMTPException): ... class SMTPServerDisconnected(SMTPException): ... class SMTPResponseException(SMTPException): smtp_code: int smtp_error: Union[bytes, str] args: Union[Tuple[int, Union[bytes, str]], Tuple[int, bytes, str]] def __init__(self, code: int, msg: Union[bytes, str]) -> None: ... class SMTPSenderRefused(SMTPResponseException): smtp_code: int smtp_error: bytes sender: str args: Tuple[int, bytes, str] def __init__(self, code: int, msg: bytes, sender: str) -> None: ... class SMTPRecipientsRefused(SMTPException): recipients: _SendErrs args: Tuple[_SendErrs] def __init__(self, recipients: _SendErrs) -> None: ... class SMTPDataError(SMTPResponseException): ... class SMTPConnectError(SMTPResponseException): ... class SMTPHeloError(SMTPResponseException): ... class SMTPAuthenticationError(SMTPResponseException): ... def quoteaddr(addrstring: str) -> str: ... def quotedata(data: str) -> str: ... class _AuthObject(Protocol): @overload def __call__(self, challenge: None = ...) -> Optional[str]: ... @overload def __call__(self, challenge: bytes) -> str: ... class SMTP: debuglevel: int = ... sock: Optional[socket] = ... # Type of file should match what socket.makefile() returns file: Optional[Any] = ... helo_resp: Optional[bytes] = ... ehlo_msg: str = ... ehlo_resp: Optional[bytes] = ... does_esmtp: bool = ... default_port: int = ... timeout: float esmtp_features: Dict[str, str] command_encoding: str source_address: Optional[_SourceAddress] local_hostname: str def __init__( self, host: str = ..., port: int = ..., local_hostname: Optional[str] = ..., timeout: float = ..., source_address: Optional[_SourceAddress] = ..., ) -> None: ... def __enter__(self) -> SMTP: ... def __exit__( self, exc_type: Optional[Type[BaseException]], exc_value: Optional[BaseException], tb: Optional[TracebackType] ) -> None: ... def set_debuglevel(self, debuglevel: int) -> None: ... def connect(self, host: str = ..., port: int = ..., source_address: Optional[_SourceAddress] = ...) -> _Reply: ... def send(self, s: Union[bytes, str]) -> None: ... def putcmd(self, cmd: str, args: str = ...) -> None: ... def getreply(self) -> _Reply: ... def docmd(self, cmd: str, args: str = ...) -> _Reply: ... def helo(self, name: str = ...) -> _Reply: ... def ehlo(self, name: str = ...) -> _Reply: ... def has_extn(self, opt: str) -> bool: ... def help(self, args: str = ...) -> bytes: ... def rset(self) -> _Reply: ... def noop(self) -> _Reply: ... def mail(self, sender: str, options: Sequence[str] = ...) -> _Reply: ... def rcpt(self, recip: str, options: Sequence[str] = ...) -> _Reply: ... def data(self, msg: Union[bytes, str]) -> _Reply: ... def verify(self, address: str) -> _Reply: ... vrfy = verify def expn(self, address: str) -> _Reply: ... def ehlo_or_helo_if_needed(self) -> None: ... user: str password: str def auth(self, mechanism: str, authobject: _AuthObject, *, initial_response_ok: bool = ...) -> _Reply: ... @overload def auth_cram_md5(self, challenge: None = ...) -> None: ... @overload def auth_cram_md5(self, challenge: bytes) -> str: ... def auth_plain(self, challenge: Optional[bytes] = ...) -> str: ... def auth_login(self, challenge: Optional[bytes] = ...) -> str: ... def login(self, user: str, password: str, *, initial_response_ok: bool = ...) -> _Reply: ... def starttls( self, keyfile: Optional[str] = ..., certfile: Optional[str] = ..., context: Optional[SSLContext] = ... ) -> _Reply: ... def sendmail( self, from_addr: str, to_addrs: Union[str, Sequence[str]], msg: Union[bytes, str], mail_options: Sequence[str] = ..., rcpt_options: List[str] = ..., ) -> _SendErrs: ... def send_message( self, msg: _Message, from_addr: Optional[str] = ..., to_addrs: Optional[Union[str, Sequence[str]]] = ..., mail_options: List[str] = ..., rcpt_options: Sequence[str] = ..., ) -> _SendErrs: ... def close(self) -> None: ... def quit(self) -> _Reply: ... class SMTP_SSL(SMTP): default_port: int = ... keyfile: Optional[str] certfile: Optional[str] context: SSLContext def __init__( self, host: str = ..., port: int = ..., local_hostname: Optional[str] = ..., keyfile: Optional[str] = ..., certfile: Optional[str] = ..., timeout: float = ..., source_address: Optional[_SourceAddress] = ..., context: Optional[SSLContext] = ..., ) -> None: ... LMTP_PORT: int class LMTP(SMTP): def __init__( self, host: str = ..., port: int = ..., local_hostname: Optional[str] = ..., source_address: Optional[_SourceAddress] = ..., ) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/socketserver.pyi0000664000175000017500000001236700000000000024367 0ustar00davedave00000000000000import sys import types from socket import SocketType from typing import Any, BinaryIO, Callable, ClassVar, List, Optional, Tuple, Type, Union class BaseServer: address_family: int RequestHandlerClass: Callable[..., BaseRequestHandler] server_address: Tuple[str, int] socket: SocketType allow_reuse_address: bool request_queue_size: int socket_type: int timeout: Optional[float] def __init__(self, server_address: Any, RequestHandlerClass: Callable[..., BaseRequestHandler]) -> None: ... def fileno(self) -> int: ... def handle_request(self) -> None: ... def serve_forever(self, poll_interval: float = ...) -> None: ... def shutdown(self) -> None: ... def server_close(self) -> None: ... def finish_request(self, request: bytes, client_address: Tuple[str, int]) -> None: ... def get_request(self) -> Tuple[SocketType, Tuple[str, int]]: ... def handle_error(self, request: bytes, client_address: Tuple[str, int]) -> None: ... def handle_timeout(self) -> None: ... def process_request(self, request: bytes, client_address: Tuple[str, int]) -> None: ... def server_activate(self) -> None: ... def server_bind(self) -> None: ... def verify_request(self, request: bytes, client_address: Tuple[str, int]) -> bool: ... if sys.version_info >= (3, 6): def __enter__(self) -> BaseServer: ... def __exit__( self, exc_type: Optional[Type[BaseException]], exc_val: Optional[BaseException], exc_tb: Optional[types.TracebackType] ) -> None: ... def service_actions(self) -> None: ... class TCPServer(BaseServer): def __init__( self, server_address: Tuple[str, int], RequestHandlerClass: Callable[..., BaseRequestHandler], bind_and_activate: bool = ..., ) -> None: ... class UDPServer(BaseServer): def __init__( self, server_address: Tuple[str, int], RequestHandlerClass: Callable[..., BaseRequestHandler], bind_and_activate: bool = ..., ) -> None: ... if sys.platform != "win32": class UnixStreamServer(BaseServer): def __init__( self, server_address: Union[str, bytes], RequestHandlerClass: Callable[..., BaseRequestHandler], bind_and_activate: bool = ..., ) -> None: ... class UnixDatagramServer(BaseServer): def __init__( self, server_address: Union[str, bytes], RequestHandlerClass: Callable[..., BaseRequestHandler], bind_and_activate: bool = ..., ) -> None: ... if sys.platform != "win32": class ForkingMixIn: timeout: Optional[float] # undocumented active_children: Optional[List[int]] # undocumented max_children: int # undocumented if sys.version_info >= (3, 7): block_on_close: bool if sys.version_info >= (3, 6): def collect_children(self, *, blocking: bool = ...) -> None: ... # undocumented else: def collect_children(self) -> None: ... # undocumented def handle_timeout(self) -> None: ... # undocumented def service_actions(self) -> None: ... # undocumented def process_request(self, request: bytes, client_address: Tuple[str, int]) -> None: ... if sys.version_info >= (3, 6): def server_close(self) -> None: ... class ThreadingMixIn: daemon_threads: bool if sys.version_info >= (3, 7): block_on_close: bool def process_request_thread(self, request: bytes, client_address: Tuple[str, int]) -> None: ... # undocumented def process_request(self, request: bytes, client_address: Tuple[str, int]) -> None: ... if sys.version_info >= (3, 6): def server_close(self) -> None: ... if sys.platform != "win32": class ForkingTCPServer(ForkingMixIn, TCPServer): ... class ForkingUDPServer(ForkingMixIn, UDPServer): ... class ThreadingTCPServer(ThreadingMixIn, TCPServer): ... class ThreadingUDPServer(ThreadingMixIn, UDPServer): ... if sys.platform != "win32": class ThreadingUnixStreamServer(ThreadingMixIn, UnixStreamServer): ... class ThreadingUnixDatagramServer(ThreadingMixIn, UnixDatagramServer): ... class BaseRequestHandler: # Those are technically of types, respectively: # * Union[SocketType, Tuple[bytes, SocketType]] # * Union[Tuple[str, int], str] # But there are some concerns that having unions here would cause # too much inconvenience to people using it (see # https://github.com/python/typeshed/pull/384#issuecomment-234649696) request: Any client_address: Any server: BaseServer def __init__(self, request: Any, client_address: Any, server: BaseServer) -> None: ... def setup(self) -> None: ... def handle(self) -> None: ... def finish(self) -> None: ... class StreamRequestHandler(BaseRequestHandler): rbufsize: ClassVar[int] # Undocumented wbufsize: ClassVar[int] # Undocumented timeout: ClassVar[Optional[float]] # Undocumented disable_nagle_algorithm: ClassVar[bool] # Undocumented connection: SocketType # Undocumented rfile: BinaryIO wfile: BinaryIO class DatagramRequestHandler(BaseRequestHandler): packet: SocketType # Undocumented socket: SocketType # Undocumented rfile: BinaryIO wfile: BinaryIO ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/spwd.pyi0000664000175000017500000000046600000000000022622 0ustar00davedave00000000000000from typing import List, NamedTuple class struct_spwd(NamedTuple): sp_namp: str sp_pwdp: str sp_lstchg: int sp_min: int sp_max: int sp_warn: int sp_inact: int sp_expire: int sp_flag: int def getspall() -> List[struct_spwd]: ... def getspnam(name: str) -> struct_spwd: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/sre_constants.pyi0000664000175000017500000000642400000000000024532 0ustar00davedave00000000000000from typing import Any, Dict, List, Optional, Union MAGIC: int class error(Exception): msg: str pattern: Optional[Union[str, bytes]] pos: Optional[int] lineno: int colno: int def __init__(self, msg: str, pattern: Union[str, bytes] = ..., pos: int = ...) -> None: ... class _NamedIntConstant(int): name: Any def __new__(cls, value: int, name: str) -> _NamedIntConstant: ... MAXREPEAT: _NamedIntConstant OPCODES: List[_NamedIntConstant] ATCODES: List[_NamedIntConstant] CHCODES: List[_NamedIntConstant] OP_IGNORE: Dict[_NamedIntConstant, _NamedIntConstant] AT_MULTILINE: Dict[_NamedIntConstant, _NamedIntConstant] AT_LOCALE: Dict[_NamedIntConstant, _NamedIntConstant] AT_UNICODE: Dict[_NamedIntConstant, _NamedIntConstant] CH_LOCALE: Dict[_NamedIntConstant, _NamedIntConstant] CH_UNICODE: Dict[_NamedIntConstant, _NamedIntConstant] SRE_FLAG_TEMPLATE: int SRE_FLAG_IGNORECASE: int SRE_FLAG_LOCALE: int SRE_FLAG_MULTILINE: int SRE_FLAG_DOTALL: int SRE_FLAG_UNICODE: int SRE_FLAG_VERBOSE: int SRE_FLAG_DEBUG: int SRE_FLAG_ASCII: int SRE_INFO_PREFIX: int SRE_INFO_LITERAL: int SRE_INFO_CHARSET: int # Stubgen above; manually defined constants below (dynamic at runtime) # from OPCODES FAILURE: _NamedIntConstant SUCCESS: _NamedIntConstant ANY: _NamedIntConstant ANY_ALL: _NamedIntConstant ASSERT: _NamedIntConstant ASSERT_NOT: _NamedIntConstant AT: _NamedIntConstant BRANCH: _NamedIntConstant CALL: _NamedIntConstant CATEGORY: _NamedIntConstant CHARSET: _NamedIntConstant BIGCHARSET: _NamedIntConstant GROUPREF: _NamedIntConstant GROUPREF_EXISTS: _NamedIntConstant GROUPREF_IGNORE: _NamedIntConstant IN: _NamedIntConstant IN_IGNORE: _NamedIntConstant INFO: _NamedIntConstant JUMP: _NamedIntConstant LITERAL: _NamedIntConstant LITERAL_IGNORE: _NamedIntConstant MARK: _NamedIntConstant MAX_UNTIL: _NamedIntConstant MIN_UNTIL: _NamedIntConstant NOT_LITERAL: _NamedIntConstant NOT_LITERAL_IGNORE: _NamedIntConstant NEGATE: _NamedIntConstant RANGE: _NamedIntConstant REPEAT: _NamedIntConstant REPEAT_ONE: _NamedIntConstant SUBPATTERN: _NamedIntConstant MIN_REPEAT_ONE: _NamedIntConstant RANGE_IGNORE: _NamedIntConstant MIN_REPEAT: _NamedIntConstant MAX_REPEAT: _NamedIntConstant # from ATCODES AT_BEGINNING: _NamedIntConstant AT_BEGINNING_LINE: _NamedIntConstant AT_BEGINNING_STRING: _NamedIntConstant AT_BOUNDARY: _NamedIntConstant AT_NON_BOUNDARY: _NamedIntConstant AT_END: _NamedIntConstant AT_END_LINE: _NamedIntConstant AT_END_STRING: _NamedIntConstant AT_LOC_BOUNDARY: _NamedIntConstant AT_LOC_NON_BOUNDARY: _NamedIntConstant AT_UNI_BOUNDARY: _NamedIntConstant AT_UNI_NON_BOUNDARY: _NamedIntConstant # from CHCODES CATEGORY_DIGIT: _NamedIntConstant CATEGORY_NOT_DIGIT: _NamedIntConstant CATEGORY_SPACE: _NamedIntConstant CATEGORY_NOT_SPACE: _NamedIntConstant CATEGORY_WORD: _NamedIntConstant CATEGORY_NOT_WORD: _NamedIntConstant CATEGORY_LINEBREAK: _NamedIntConstant CATEGORY_NOT_LINEBREAK: _NamedIntConstant CATEGORY_LOC_WORD: _NamedIntConstant CATEGORY_LOC_NOT_WORD: _NamedIntConstant CATEGORY_UNI_DIGIT: _NamedIntConstant CATEGORY_UNI_NOT_DIGIT: _NamedIntConstant CATEGORY_UNI_SPACE: _NamedIntConstant CATEGORY_UNI_NOT_SPACE: _NamedIntConstant CATEGORY_UNI_WORD: _NamedIntConstant CATEGORY_UNI_NOT_WORD: _NamedIntConstant CATEGORY_UNI_LINEBREAK: _NamedIntConstant CATEGORY_UNI_NOT_LINEBREAK: _NamedIntConstant ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/sre_parse.pyi0000664000175000017500000000735400000000000023633 0ustar00davedave00000000000000import sys from sre_constants import _NamedIntConstant as _NIC, error as _Error from typing import Any, Dict, FrozenSet, Iterable, List, Match, Optional, Pattern as _Pattern, Tuple, Union, overload SPECIAL_CHARS: str REPEAT_CHARS: str DIGITS: FrozenSet[str] OCTDIGITS: FrozenSet[str] HEXDIGITS: FrozenSet[str] ASCIILETTERS: FrozenSet[str] WHITESPACE: FrozenSet[str] ESCAPES: Dict[str, Tuple[_NIC, int]] CATEGORIES: Dict[str, Union[Tuple[_NIC, _NIC], Tuple[_NIC, List[Tuple[_NIC, _NIC]]]]] FLAGS: Dict[str, int] GLOBAL_FLAGS: int class Verbose(Exception): ... class _State: flags: int groupdict: Dict[str, int] groupwidths: List[Optional[int]] lookbehindgroups: Optional[int] def __init__(self) -> None: ... @property def groups(self) -> int: ... def opengroup(self, name: str = ...) -> int: ... def closegroup(self, gid: int, p: SubPattern) -> None: ... def checkgroup(self, gid: int) -> bool: ... def checklookbehindgroup(self, gid: int, source: Tokenizer) -> None: ... if sys.version_info >= (3, 8): State = _State else: Pattern = _State _OpSubpatternType = Tuple[Optional[int], int, int, SubPattern] _OpGroupRefExistsType = Tuple[int, SubPattern, SubPattern] _OpInType = List[Tuple[_NIC, int]] _OpBranchType = Tuple[None, List[SubPattern]] _AvType = Union[_OpInType, _OpBranchType, Iterable[SubPattern], _OpGroupRefExistsType, _OpSubpatternType] _CodeType = Tuple[_NIC, _AvType] class SubPattern: data: List[_CodeType] width: Optional[int] if sys.version_info >= (3, 8): state: State def __init__(self, state: State, data: Optional[List[_CodeType]] = ...) -> None: ... else: pattern: Pattern def __init__(self, pattern: Pattern, data: Optional[List[_CodeType]] = ...) -> None: ... def dump(self, level: int = ...) -> None: ... def __len__(self) -> int: ... def __delitem__(self, index: Union[int, slice]) -> None: ... def __getitem__(self, index: Union[int, slice]) -> Union[SubPattern, _CodeType]: ... def __setitem__(self, index: Union[int, slice], code: _CodeType) -> None: ... def insert(self, index: int, code: _CodeType) -> None: ... def append(self, code: _CodeType) -> None: ... def getwidth(self) -> int: ... class Tokenizer: istext: bool string: Any decoded_string: str index: int next: Optional[str] def __init__(self, string: Any) -> None: ... def match(self, char: str) -> bool: ... def get(self) -> Optional[str]: ... def getwhile(self, n: int, charset: Iterable[str]) -> str: ... if sys.version_info >= (3, 8): def getuntil(self, terminator: str, name: str) -> str: ... else: def getuntil(self, terminator: str) -> str: ... @property def pos(self) -> int: ... def tell(self) -> int: ... def seek(self, index: int) -> None: ... def error(self, msg: str, offset: int = ...) -> _Error: ... def fix_flags(src: Union[str, bytes], flags: int) -> int: ... _TemplateType = Tuple[List[Tuple[int, int]], List[Optional[str]]] _TemplateByteType = Tuple[List[Tuple[int, int]], List[Optional[bytes]]] if sys.version_info >= (3, 8): def parse(str: str, flags: int = ..., state: Optional[State] = ...) -> SubPattern: ... @overload def parse_template(source: str, state: _Pattern[Any]) -> _TemplateType: ... @overload def parse_template(source: bytes, state: _Pattern[Any]) -> _TemplateByteType: ... else: def parse(str: str, flags: int = ..., pattern: Optional[Pattern] = ...) -> SubPattern: ... @overload def parse_template(source: str, pattern: _Pattern[Any]) -> _TemplateType: ... @overload def parse_template(source: bytes, pattern: _Pattern[Any]) -> _TemplateByteType: ... def expand_template(template: _TemplateType, match: Match[Any]) -> str: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/stat.pyi0000664000175000017500000000341500000000000022615 0ustar00davedave00000000000000import sys def S_ISDIR(mode: int) -> bool: ... def S_ISCHR(mode: int) -> bool: ... def S_ISBLK(mode: int) -> bool: ... def S_ISREG(mode: int) -> bool: ... def S_ISFIFO(mode: int) -> bool: ... def S_ISLNK(mode: int) -> bool: ... def S_ISSOCK(mode: int) -> bool: ... def S_IMODE(mode: int) -> int: ... def S_IFMT(mode: int) -> int: ... def filemode(mode: int) -> str: ... ST_MODE: int ST_INO: int ST_DEV: int ST_NLINK: int ST_UID: int ST_GID: int ST_SIZE: int ST_ATIME: int ST_MTIME: int ST_CTIME: int S_IFSOCK: int S_IFLNK: int S_IFREG: int S_IFBLK: int S_IFDIR: int S_IFCHR: int S_IFIFO: int S_ISUID: int S_ISGID: int S_ISVTX: int S_IRWXU: int S_IRUSR: int S_IWUSR: int S_IXUSR: int S_IRWXG: int S_IRGRP: int S_IWGRP: int S_IXGRP: int S_IRWXO: int S_IROTH: int S_IWOTH: int S_IXOTH: int S_ENFMT: int S_IREAD: int S_IWRITE: int S_IEXEC: int UF_NODUMP: int UF_IMMUTABLE: int UF_APPEND: int UF_OPAQUE: int UF_NOUNLINK: int if sys.platform == "darwin": UF_COMPRESSED: int # OS X 10.6+ only UF_HIDDEN: int # OX X 10.5+ only SF_ARCHIVED: int SF_IMMUTABLE: int SF_APPEND: int SF_NOUNLINK: int SF_SNAPSHOT: int FILE_ATTRIBUTE_ARCHIVE: int FILE_ATTRIBUTE_COMPRESSED: int FILE_ATTRIBUTE_DEVICE: int FILE_ATTRIBUTE_DIRECTORY: int FILE_ATTRIBUTE_ENCRYPTED: int FILE_ATTRIBUTE_HIDDEN: int FILE_ATTRIBUTE_INTEGRITY_STREAM: int FILE_ATTRIBUTE_NORMAL: int FILE_ATTRIBUTE_NOT_CONTENT_INDEXED: int FILE_ATTRIBUTE_NO_SCRUB_DATA: int FILE_ATTRIBUTE_OFFLINE: int FILE_ATTRIBUTE_READONLY: int FILE_ATTRIBUTE_REPARSE_POINT: int FILE_ATTRIBUTE_SPARSE_FILE: int FILE_ATTRIBUTE_SYSTEM: int FILE_ATTRIBUTE_TEMPORARY: int FILE_ATTRIBUTE_VIRTUAL: int if sys.platform == "win32" and sys.version_info >= (3, 8): IO_REPARSE_TAG_SYMLINK: int IO_REPARSE_TAG_MOUNT_POINT: int IO_REPARSE_TAG_APPEXECLINK: int ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/statistics.pyi0000664000175000017500000000611500000000000024034 0ustar00davedave00000000000000import sys from _typeshed import SupportsLessThanT from decimal import Decimal from fractions import Fraction from typing import Any, Hashable, Iterable, List, Optional, SupportsFloat, Type, TypeVar, Union _T = TypeVar("_T") # Most functions in this module accept homogeneous collections of one of these types _Number = TypeVar("_Number", float, Decimal, Fraction) # Used in mode, multimode _HashableT = TypeVar("_HashableT", bound=Hashable) class StatisticsError(ValueError): ... if sys.version_info >= (3, 8): def fmean(data: Iterable[SupportsFloat]) -> float: ... def geometric_mean(data: Iterable[SupportsFloat]) -> float: ... def mean(data: Iterable[_Number]) -> _Number: ... def harmonic_mean(data: Iterable[_Number]) -> _Number: ... def median(data: Iterable[_Number]) -> _Number: ... def median_low(data: Iterable[SupportsLessThanT]) -> SupportsLessThanT: ... def median_high(data: Iterable[SupportsLessThanT]) -> SupportsLessThanT: ... def median_grouped(data: Iterable[_Number], interval: _Number = ...) -> _Number: ... def mode(data: Iterable[_HashableT]) -> _HashableT: ... if sys.version_info >= (3, 8): def multimode(data: Iterable[_HashableT]) -> List[_HashableT]: ... def pstdev(data: Iterable[_Number], mu: Optional[_Number] = ...) -> _Number: ... def pvariance(data: Iterable[_Number], mu: Optional[_Number] = ...) -> _Number: ... if sys.version_info >= (3, 8): def quantiles(data: Iterable[_Number], *, n: int = ..., method: str = ...) -> List[_Number]: ... def stdev(data: Iterable[_Number], xbar: Optional[_Number] = ...) -> _Number: ... def variance(data: Iterable[_Number], xbar: Optional[_Number] = ...) -> _Number: ... if sys.version_info >= (3, 8): class NormalDist: def __init__(self, mu: float = ..., sigma: float = ...) -> None: ... @property def mean(self) -> float: ... @property def median(self) -> float: ... @property def mode(self) -> float: ... @property def stdev(self) -> float: ... @property def variance(self) -> float: ... @classmethod def from_samples(cls: Type[_T], data: Iterable[SupportsFloat]) -> _T: ... def samples(self, n: int, *, seed: Optional[Any] = ...) -> List[float]: ... def pdf(self, x: float) -> float: ... def cdf(self, x: float) -> float: ... def inv_cdf(self, p: float) -> float: ... def overlap(self, other: NormalDist) -> float: ... def quantiles(self, n: int = ...) -> List[float]: ... if sys.version_info >= (3, 9): def zscore(self, x: float) -> float: ... def __add__(self, x2: Union[float, NormalDist]) -> NormalDist: ... def __sub__(self, x2: Union[float, NormalDist]) -> NormalDist: ... def __mul__(self, x2: float) -> NormalDist: ... def __truediv__(self, x2: float) -> NormalDist: ... def __pos__(self) -> NormalDist: ... def __neg__(self) -> NormalDist: ... __radd__ = __add__ def __rsub__(self, x2: Union[float, NormalDist]) -> NormalDist: ... __rmul__ = __mul__ def __hash__(self) -> int: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/string.pyi0000664000175000017500000000261700000000000023153 0ustar00davedave00000000000000from typing import Any, Iterable, Mapping, Optional, Sequence, Tuple, Union ascii_letters: str ascii_lowercase: str ascii_uppercase: str digits: str hexdigits: str octdigits: str punctuation: str printable: str whitespace: str def capwords(s: str, sep: Optional[str] = ...) -> str: ... class Template: template: str def __init__(self, template: str) -> None: ... def substitute(self, __mapping: Mapping[str, object] = ..., **kwds: object) -> str: ... def safe_substitute(self, __mapping: Mapping[str, object] = ..., **kwds: object) -> str: ... # TODO(MichalPokorny): This is probably badly and/or loosely typed. class Formatter: def format(self, __format_string: str, *args: Any, **kwargs: Any) -> str: ... def vformat(self, format_string: str, args: Sequence[Any], kwargs: Mapping[str, Any]) -> str: ... def parse(self, format_string: str) -> Iterable[Tuple[str, Optional[str], Optional[str], Optional[str]]]: ... def get_field(self, field_name: str, args: Sequence[Any], kwargs: Mapping[str, Any]) -> Any: ... def get_value(self, key: Union[int, str], args: Sequence[Any], kwargs: Mapping[str, Any]) -> Any: ... def check_unused_args(self, used_args: Sequence[Union[int, str]], args: Sequence[Any], kwargs: Mapping[str, Any]) -> None: ... def format_field(self, value: Any, format_spec: str) -> Any: ... def convert_field(self, value: Any, conversion: str) -> Any: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/subprocess.pyi0000664000175000017500000010302000000000000024023 0ustar00davedave00000000000000import sys from _typeshed import AnyPath from types import TracebackType from typing import IO, Any, AnyStr, Callable, Generic, Mapping, Optional, Sequence, Tuple, Type, TypeVar, Union, overload from typing_extensions import Literal if sys.version_info >= (3, 9): from types import GenericAlias # We prefer to annotate inputs to methods (eg subprocess.check_call) with these # union types. # For outputs we use laborious literal based overloads to try to determine # which specific return types to use, and prefer to fall back to Any when # this does not work, so the caller does not have to use an assertion to confirm # which type. # # For example: # # try: # x = subprocess.check_output(["ls", "-l"]) # reveal_type(x) # bytes, based on the overloads # except TimeoutError as e: # reveal_type(e.cmd) # Any, but morally is _CMD _FILE = Union[None, int, IO[Any]] _TXT = Union[bytes, str] # Python 3.6 does't support _CMD being a single PathLike. # See: https://bugs.python.org/issue31961 _CMD = Union[_TXT, Sequence[AnyPath]] _ENV = Union[Mapping[bytes, _TXT], Mapping[str, _TXT]] _S = TypeVar("_S") _T = TypeVar("_T") class CompletedProcess(Generic[_T]): # morally: _CMD args: Any returncode: int # These are really both Optional, but requiring checks would be tedious # and writing all the overloads would be horrific. stdout: _T stderr: _T def __init__(self, args: _CMD, returncode: int, stdout: Optional[_T] = ..., stderr: Optional[_T] = ...) -> None: ... def check_returncode(self) -> None: ... if sys.version_info >= (3, 9): def __class_getitem__(cls, item: Any) -> GenericAlias: ... if sys.version_info >= (3, 7): # Nearly the same args as for 3.6, except for capture_output and text @overload def run( args: _CMD, bufsize: int = ..., executable: Optional[AnyPath] = ..., stdin: _FILE = ..., stdout: _FILE = ..., stderr: _FILE = ..., preexec_fn: Callable[[], Any] = ..., close_fds: bool = ..., shell: bool = ..., cwd: Optional[AnyPath] = ..., env: Optional[_ENV] = ..., universal_newlines: bool = ..., startupinfo: Any = ..., creationflags: int = ..., restore_signals: bool = ..., start_new_session: bool = ..., pass_fds: Any = ..., *, capture_output: bool = ..., check: bool = ..., encoding: Optional[str] = ..., errors: Optional[str] = ..., input: Optional[str] = ..., text: Literal[True], timeout: Optional[float] = ..., ) -> CompletedProcess[str]: ... @overload def run( args: _CMD, bufsize: int = ..., executable: Optional[AnyPath] = ..., stdin: _FILE = ..., stdout: _FILE = ..., stderr: _FILE = ..., preexec_fn: Callable[[], Any] = ..., close_fds: bool = ..., shell: bool = ..., cwd: Optional[AnyPath] = ..., env: Optional[_ENV] = ..., universal_newlines: bool = ..., startupinfo: Any = ..., creationflags: int = ..., restore_signals: bool = ..., start_new_session: bool = ..., pass_fds: Any = ..., *, capture_output: bool = ..., check: bool = ..., encoding: str, errors: Optional[str] = ..., input: Optional[str] = ..., text: Optional[bool] = ..., timeout: Optional[float] = ..., ) -> CompletedProcess[str]: ... @overload def run( args: _CMD, bufsize: int = ..., executable: Optional[AnyPath] = ..., stdin: _FILE = ..., stdout: _FILE = ..., stderr: _FILE = ..., preexec_fn: Callable[[], Any] = ..., close_fds: bool = ..., shell: bool = ..., cwd: Optional[AnyPath] = ..., env: Optional[_ENV] = ..., universal_newlines: bool = ..., startupinfo: Any = ..., creationflags: int = ..., restore_signals: bool = ..., start_new_session: bool = ..., pass_fds: Any = ..., *, capture_output: bool = ..., check: bool = ..., encoding: Optional[str] = ..., errors: str, input: Optional[str] = ..., text: Optional[bool] = ..., timeout: Optional[float] = ..., ) -> CompletedProcess[str]: ... @overload def run( args: _CMD, bufsize: int = ..., executable: Optional[AnyPath] = ..., stdin: _FILE = ..., stdout: _FILE = ..., stderr: _FILE = ..., preexec_fn: Callable[[], Any] = ..., close_fds: bool = ..., shell: bool = ..., cwd: Optional[AnyPath] = ..., env: Optional[_ENV] = ..., *, universal_newlines: Literal[True], startupinfo: Any = ..., creationflags: int = ..., restore_signals: bool = ..., start_new_session: bool = ..., pass_fds: Any = ..., # where the *real* keyword only args start capture_output: bool = ..., check: bool = ..., encoding: Optional[str] = ..., errors: Optional[str] = ..., input: Optional[str] = ..., text: Optional[bool] = ..., timeout: Optional[float] = ..., ) -> CompletedProcess[str]: ... @overload def run( args: _CMD, bufsize: int = ..., executable: Optional[AnyPath] = ..., stdin: _FILE = ..., stdout: _FILE = ..., stderr: _FILE = ..., preexec_fn: Callable[[], Any] = ..., close_fds: bool = ..., shell: bool = ..., cwd: Optional[AnyPath] = ..., env: Optional[_ENV] = ..., universal_newlines: Literal[False] = ..., startupinfo: Any = ..., creationflags: int = ..., restore_signals: bool = ..., start_new_session: bool = ..., pass_fds: Any = ..., *, capture_output: bool = ..., check: bool = ..., encoding: None = ..., errors: None = ..., input: Optional[bytes] = ..., text: Literal[None, False] = ..., timeout: Optional[float] = ..., ) -> CompletedProcess[bytes]: ... @overload def run( args: _CMD, bufsize: int = ..., executable: Optional[AnyPath] = ..., stdin: _FILE = ..., stdout: _FILE = ..., stderr: _FILE = ..., preexec_fn: Callable[[], Any] = ..., close_fds: bool = ..., shell: bool = ..., cwd: Optional[AnyPath] = ..., env: Optional[_ENV] = ..., universal_newlines: bool = ..., startupinfo: Any = ..., creationflags: int = ..., restore_signals: bool = ..., start_new_session: bool = ..., pass_fds: Any = ..., *, capture_output: bool = ..., check: bool = ..., encoding: Optional[str] = ..., errors: Optional[str] = ..., input: Optional[_TXT] = ..., text: Optional[bool] = ..., timeout: Optional[float] = ..., ) -> CompletedProcess[Any]: ... else: # Nearly same args as Popen.__init__ except for timeout, input, and check @overload def run( args: _CMD, bufsize: int = ..., executable: Optional[AnyPath] = ..., stdin: _FILE = ..., stdout: _FILE = ..., stderr: _FILE = ..., preexec_fn: Callable[[], Any] = ..., close_fds: bool = ..., shell: bool = ..., cwd: Optional[AnyPath] = ..., env: Optional[_ENV] = ..., universal_newlines: bool = ..., startupinfo: Any = ..., creationflags: int = ..., restore_signals: bool = ..., start_new_session: bool = ..., pass_fds: Any = ..., *, check: bool = ..., encoding: str, errors: Optional[str] = ..., input: Optional[str] = ..., timeout: Optional[float] = ..., ) -> CompletedProcess[str]: ... @overload def run( args: _CMD, bufsize: int = ..., executable: Optional[AnyPath] = ..., stdin: _FILE = ..., stdout: _FILE = ..., stderr: _FILE = ..., preexec_fn: Callable[[], Any] = ..., close_fds: bool = ..., shell: bool = ..., cwd: Optional[AnyPath] = ..., env: Optional[_ENV] = ..., universal_newlines: bool = ..., startupinfo: Any = ..., creationflags: int = ..., restore_signals: bool = ..., start_new_session: bool = ..., pass_fds: Any = ..., *, check: bool = ..., encoding: Optional[str] = ..., errors: str, input: Optional[str] = ..., timeout: Optional[float] = ..., ) -> CompletedProcess[str]: ... @overload def run( args: _CMD, bufsize: int = ..., executable: Optional[AnyPath] = ..., stdin: _FILE = ..., stdout: _FILE = ..., stderr: _FILE = ..., preexec_fn: Callable[[], Any] = ..., close_fds: bool = ..., shell: bool = ..., cwd: Optional[AnyPath] = ..., env: Optional[_ENV] = ..., *, universal_newlines: Literal[True], startupinfo: Any = ..., creationflags: int = ..., restore_signals: bool = ..., start_new_session: bool = ..., pass_fds: Any = ..., # where the *real* keyword only args start check: bool = ..., encoding: Optional[str] = ..., errors: Optional[str] = ..., input: Optional[str] = ..., timeout: Optional[float] = ..., ) -> CompletedProcess[str]: ... @overload def run( args: _CMD, bufsize: int = ..., executable: Optional[AnyPath] = ..., stdin: _FILE = ..., stdout: _FILE = ..., stderr: _FILE = ..., preexec_fn: Callable[[], Any] = ..., close_fds: bool = ..., shell: bool = ..., cwd: Optional[AnyPath] = ..., env: Optional[_ENV] = ..., universal_newlines: Literal[False] = ..., startupinfo: Any = ..., creationflags: int = ..., restore_signals: bool = ..., start_new_session: bool = ..., pass_fds: Any = ..., *, check: bool = ..., encoding: None = ..., errors: None = ..., input: Optional[bytes] = ..., timeout: Optional[float] = ..., ) -> CompletedProcess[bytes]: ... @overload def run( args: _CMD, bufsize: int = ..., executable: Optional[AnyPath] = ..., stdin: _FILE = ..., stdout: _FILE = ..., stderr: _FILE = ..., preexec_fn: Callable[[], Any] = ..., close_fds: bool = ..., shell: bool = ..., cwd: Optional[AnyPath] = ..., env: Optional[_ENV] = ..., universal_newlines: bool = ..., startupinfo: Any = ..., creationflags: int = ..., restore_signals: bool = ..., start_new_session: bool = ..., pass_fds: Any = ..., *, check: bool = ..., encoding: Optional[str] = ..., errors: Optional[str] = ..., input: Optional[_TXT] = ..., timeout: Optional[float] = ..., ) -> CompletedProcess[Any]: ... # Same args as Popen.__init__ def call( args: _CMD, bufsize: int = ..., executable: Optional[AnyPath] = ..., stdin: _FILE = ..., stdout: _FILE = ..., stderr: _FILE = ..., preexec_fn: Callable[[], Any] = ..., close_fds: bool = ..., shell: bool = ..., cwd: Optional[AnyPath] = ..., env: Optional[_ENV] = ..., universal_newlines: bool = ..., startupinfo: Any = ..., creationflags: int = ..., restore_signals: bool = ..., start_new_session: bool = ..., pass_fds: Any = ..., *, timeout: Optional[float] = ..., ) -> int: ... # Same args as Popen.__init__ def check_call( args: _CMD, bufsize: int = ..., executable: AnyPath = ..., stdin: _FILE = ..., stdout: _FILE = ..., stderr: _FILE = ..., preexec_fn: Callable[[], Any] = ..., close_fds: bool = ..., shell: bool = ..., cwd: Optional[AnyPath] = ..., env: Optional[_ENV] = ..., universal_newlines: bool = ..., startupinfo: Any = ..., creationflags: int = ..., restore_signals: bool = ..., start_new_session: bool = ..., pass_fds: Any = ..., timeout: Optional[float] = ..., ) -> int: ... if sys.version_info >= (3, 7): # 3.7 added text @overload def check_output( args: _CMD, bufsize: int = ..., executable: Optional[AnyPath] = ..., stdin: _FILE = ..., stderr: _FILE = ..., preexec_fn: Callable[[], Any] = ..., close_fds: bool = ..., shell: bool = ..., cwd: Optional[AnyPath] = ..., env: Optional[_ENV] = ..., universal_newlines: bool = ..., startupinfo: Any = ..., creationflags: int = ..., restore_signals: bool = ..., start_new_session: bool = ..., pass_fds: Any = ..., *, timeout: Optional[float] = ..., input: _TXT = ..., encoding: Optional[str] = ..., errors: Optional[str] = ..., text: Literal[True], ) -> str: ... @overload def check_output( args: _CMD, bufsize: int = ..., executable: Optional[AnyPath] = ..., stdin: _FILE = ..., stderr: _FILE = ..., preexec_fn: Callable[[], Any] = ..., close_fds: bool = ..., shell: bool = ..., cwd: Optional[AnyPath] = ..., env: Optional[_ENV] = ..., universal_newlines: bool = ..., startupinfo: Any = ..., creationflags: int = ..., restore_signals: bool = ..., start_new_session: bool = ..., pass_fds: Any = ..., *, timeout: Optional[float] = ..., input: _TXT = ..., encoding: str, errors: Optional[str] = ..., text: Optional[bool] = ..., ) -> str: ... @overload def check_output( args: _CMD, bufsize: int = ..., executable: Optional[AnyPath] = ..., stdin: _FILE = ..., stderr: _FILE = ..., preexec_fn: Callable[[], Any] = ..., close_fds: bool = ..., shell: bool = ..., cwd: Optional[AnyPath] = ..., env: Optional[_ENV] = ..., universal_newlines: bool = ..., startupinfo: Any = ..., creationflags: int = ..., restore_signals: bool = ..., start_new_session: bool = ..., pass_fds: Any = ..., *, timeout: Optional[float] = ..., input: _TXT = ..., encoding: Optional[str] = ..., errors: str, text: Optional[bool] = ..., ) -> str: ... @overload def check_output( args: _CMD, bufsize: int = ..., executable: Optional[AnyPath] = ..., stdin: _FILE = ..., stderr: _FILE = ..., preexec_fn: Callable[[], Any] = ..., close_fds: bool = ..., shell: bool = ..., cwd: Optional[AnyPath] = ..., env: Optional[_ENV] = ..., *, universal_newlines: Literal[True], startupinfo: Any = ..., creationflags: int = ..., restore_signals: bool = ..., start_new_session: bool = ..., pass_fds: Any = ..., # where the real keyword only ones start timeout: Optional[float] = ..., input: _TXT = ..., encoding: Optional[str] = ..., errors: Optional[str] = ..., text: Optional[bool] = ..., ) -> str: ... @overload def check_output( args: _CMD, bufsize: int = ..., executable: Optional[AnyPath] = ..., stdin: _FILE = ..., stderr: _FILE = ..., preexec_fn: Callable[[], Any] = ..., close_fds: bool = ..., shell: bool = ..., cwd: Optional[AnyPath] = ..., env: Optional[_ENV] = ..., universal_newlines: Literal[False] = ..., startupinfo: Any = ..., creationflags: int = ..., restore_signals: bool = ..., start_new_session: bool = ..., pass_fds: Any = ..., *, timeout: Optional[float] = ..., input: _TXT = ..., encoding: None = ..., errors: None = ..., text: Literal[None, False] = ..., ) -> bytes: ... @overload def check_output( args: _CMD, bufsize: int = ..., executable: Optional[AnyPath] = ..., stdin: _FILE = ..., stderr: _FILE = ..., preexec_fn: Callable[[], Any] = ..., close_fds: bool = ..., shell: bool = ..., cwd: Optional[AnyPath] = ..., env: Optional[_ENV] = ..., universal_newlines: bool = ..., startupinfo: Any = ..., creationflags: int = ..., restore_signals: bool = ..., start_new_session: bool = ..., pass_fds: Any = ..., *, timeout: Optional[float] = ..., input: _TXT = ..., encoding: Optional[str] = ..., errors: Optional[str] = ..., text: Optional[bool] = ..., ) -> Any: ... # morally: -> _TXT else: @overload def check_output( args: _CMD, bufsize: int = ..., executable: Optional[AnyPath] = ..., stdin: _FILE = ..., stderr: _FILE = ..., preexec_fn: Callable[[], Any] = ..., close_fds: bool = ..., shell: bool = ..., cwd: Optional[AnyPath] = ..., env: Optional[_ENV] = ..., universal_newlines: bool = ..., startupinfo: Any = ..., creationflags: int = ..., restore_signals: bool = ..., start_new_session: bool = ..., pass_fds: Any = ..., *, timeout: Optional[float] = ..., input: _TXT = ..., encoding: str, errors: Optional[str] = ..., ) -> str: ... @overload def check_output( args: _CMD, bufsize: int = ..., executable: Optional[AnyPath] = ..., stdin: _FILE = ..., stderr: _FILE = ..., preexec_fn: Callable[[], Any] = ..., close_fds: bool = ..., shell: bool = ..., cwd: Optional[AnyPath] = ..., env: Optional[_ENV] = ..., universal_newlines: bool = ..., startupinfo: Any = ..., creationflags: int = ..., restore_signals: bool = ..., start_new_session: bool = ..., pass_fds: Any = ..., *, timeout: Optional[float] = ..., input: _TXT = ..., encoding: Optional[str] = ..., errors: str, ) -> str: ... @overload def check_output( args: _CMD, bufsize: int = ..., executable: Optional[AnyPath] = ..., stdin: _FILE = ..., stderr: _FILE = ..., preexec_fn: Callable[[], Any] = ..., close_fds: bool = ..., shell: bool = ..., cwd: Optional[AnyPath] = ..., env: Optional[_ENV] = ..., startupinfo: Any = ..., creationflags: int = ..., restore_signals: bool = ..., start_new_session: bool = ..., pass_fds: Any = ..., *, universal_newlines: Literal[True], timeout: Optional[float] = ..., input: _TXT = ..., encoding: Optional[str] = ..., errors: Optional[str] = ..., ) -> str: ... @overload def check_output( args: _CMD, bufsize: int = ..., executable: Optional[AnyPath] = ..., stdin: _FILE = ..., stderr: _FILE = ..., preexec_fn: Callable[[], Any] = ..., close_fds: bool = ..., shell: bool = ..., cwd: Optional[AnyPath] = ..., env: Optional[_ENV] = ..., universal_newlines: Literal[False] = ..., startupinfo: Any = ..., creationflags: int = ..., restore_signals: bool = ..., start_new_session: bool = ..., pass_fds: Any = ..., *, timeout: Optional[float] = ..., input: _TXT = ..., encoding: None = ..., errors: None = ..., ) -> bytes: ... @overload def check_output( args: _CMD, bufsize: int = ..., executable: Optional[AnyPath] = ..., stdin: _FILE = ..., stderr: _FILE = ..., preexec_fn: Callable[[], Any] = ..., close_fds: bool = ..., shell: bool = ..., cwd: Optional[AnyPath] = ..., env: Optional[_ENV] = ..., universal_newlines: bool = ..., startupinfo: Any = ..., creationflags: int = ..., restore_signals: bool = ..., start_new_session: bool = ..., pass_fds: Any = ..., *, timeout: Optional[float] = ..., input: _TXT = ..., encoding: Optional[str] = ..., errors: Optional[str] = ..., ) -> Any: ... # morally: -> _TXT PIPE: int STDOUT: int DEVNULL: int class SubprocessError(Exception): ... class TimeoutExpired(SubprocessError): def __init__(self, cmd: _CMD, timeout: float, output: Optional[_TXT] = ..., stderr: Optional[_TXT] = ...) -> None: ... # morally: _CMD cmd: Any timeout: float # morally: Optional[_TXT] output: Any stdout: Any stderr: Any class CalledProcessError(SubprocessError): returncode: int # morally: _CMD cmd: Any # morally: Optional[_TXT] output: Any # morally: Optional[_TXT] stdout: Any stderr: Any def __init__(self, returncode: int, cmd: _CMD, output: Optional[_TXT] = ..., stderr: Optional[_TXT] = ...) -> None: ... class Popen(Generic[AnyStr]): args: _CMD stdin: Optional[IO[AnyStr]] stdout: Optional[IO[AnyStr]] stderr: Optional[IO[AnyStr]] pid: int returncode: int universal_newlines: bool # Technically it is wrong that Popen provides __new__ instead of __init__ # but this shouldn't come up hopefully? if sys.version_info >= (3, 7): # text is added in 3.7 @overload def __new__( cls, args: _CMD, bufsize: int = ..., executable: Optional[AnyPath] = ..., stdin: Optional[_FILE] = ..., stdout: Optional[_FILE] = ..., stderr: Optional[_FILE] = ..., preexec_fn: Optional[Callable[[], Any]] = ..., close_fds: bool = ..., shell: bool = ..., cwd: Optional[AnyPath] = ..., env: Optional[_ENV] = ..., universal_newlines: bool = ..., startupinfo: Optional[Any] = ..., creationflags: int = ..., restore_signals: bool = ..., start_new_session: bool = ..., pass_fds: Any = ..., *, text: Optional[bool] = ..., encoding: str, errors: Optional[str] = ..., ) -> Popen[str]: ... @overload def __new__( cls, args: _CMD, bufsize: int = ..., executable: Optional[AnyPath] = ..., stdin: Optional[_FILE] = ..., stdout: Optional[_FILE] = ..., stderr: Optional[_FILE] = ..., preexec_fn: Optional[Callable[[], Any]] = ..., close_fds: bool = ..., shell: bool = ..., cwd: Optional[AnyPath] = ..., env: Optional[_ENV] = ..., universal_newlines: bool = ..., startupinfo: Optional[Any] = ..., creationflags: int = ..., restore_signals: bool = ..., start_new_session: bool = ..., pass_fds: Any = ..., *, text: Optional[bool] = ..., encoding: Optional[str] = ..., errors: str, ) -> Popen[str]: ... @overload def __new__( cls, args: _CMD, bufsize: int = ..., executable: Optional[AnyPath] = ..., stdin: Optional[_FILE] = ..., stdout: Optional[_FILE] = ..., stderr: Optional[_FILE] = ..., preexec_fn: Optional[Callable[[], Any]] = ..., close_fds: bool = ..., shell: bool = ..., cwd: Optional[AnyPath] = ..., env: Optional[_ENV] = ..., *, universal_newlines: Literal[True], startupinfo: Optional[Any] = ..., creationflags: int = ..., restore_signals: bool = ..., start_new_session: bool = ..., pass_fds: Any = ..., # where the *real* keyword only args start text: Optional[bool] = ..., encoding: Optional[str] = ..., errors: Optional[str] = ..., ) -> Popen[str]: ... @overload def __new__( cls, args: _CMD, bufsize: int = ..., executable: Optional[AnyPath] = ..., stdin: Optional[_FILE] = ..., stdout: Optional[_FILE] = ..., stderr: Optional[_FILE] = ..., preexec_fn: Optional[Callable[[], Any]] = ..., close_fds: bool = ..., shell: bool = ..., cwd: Optional[AnyPath] = ..., env: Optional[_ENV] = ..., universal_newlines: bool = ..., startupinfo: Optional[Any] = ..., creationflags: int = ..., restore_signals: bool = ..., start_new_session: bool = ..., pass_fds: Any = ..., *, text: Literal[True], encoding: Optional[str] = ..., errors: Optional[str] = ..., ) -> Popen[str]: ... @overload def __new__( cls, args: _CMD, bufsize: int = ..., executable: Optional[AnyPath] = ..., stdin: Optional[_FILE] = ..., stdout: Optional[_FILE] = ..., stderr: Optional[_FILE] = ..., preexec_fn: Optional[Callable[[], Any]] = ..., close_fds: bool = ..., shell: bool = ..., cwd: Optional[AnyPath] = ..., env: Optional[_ENV] = ..., universal_newlines: Literal[False] = ..., startupinfo: Optional[Any] = ..., creationflags: int = ..., restore_signals: bool = ..., start_new_session: bool = ..., pass_fds: Any = ..., *, text: Literal[None, False] = ..., encoding: None = ..., errors: None = ..., ) -> Popen[bytes]: ... @overload def __new__( cls, args: _CMD, bufsize: int = ..., executable: Optional[AnyPath] = ..., stdin: Optional[_FILE] = ..., stdout: Optional[_FILE] = ..., stderr: Optional[_FILE] = ..., preexec_fn: Optional[Callable[[], Any]] = ..., close_fds: bool = ..., shell: bool = ..., cwd: Optional[AnyPath] = ..., env: Optional[_ENV] = ..., universal_newlines: bool = ..., startupinfo: Optional[Any] = ..., creationflags: int = ..., restore_signals: bool = ..., start_new_session: bool = ..., pass_fds: Any = ..., *, text: Optional[bool] = ..., encoding: Optional[str] = ..., errors: Optional[str] = ..., ) -> Popen[Any]: ... else: @overload def __new__( cls, args: _CMD, bufsize: int = ..., executable: Optional[AnyPath] = ..., stdin: Optional[_FILE] = ..., stdout: Optional[_FILE] = ..., stderr: Optional[_FILE] = ..., preexec_fn: Optional[Callable[[], Any]] = ..., close_fds: bool = ..., shell: bool = ..., cwd: Optional[AnyPath] = ..., env: Optional[_ENV] = ..., universal_newlines: bool = ..., startupinfo: Optional[Any] = ..., creationflags: int = ..., restore_signals: bool = ..., start_new_session: bool = ..., pass_fds: Any = ..., *, encoding: str, errors: Optional[str] = ..., ) -> Popen[str]: ... @overload def __new__( cls, args: _CMD, bufsize: int = ..., executable: Optional[AnyPath] = ..., stdin: Optional[_FILE] = ..., stdout: Optional[_FILE] = ..., stderr: Optional[_FILE] = ..., preexec_fn: Optional[Callable[[], Any]] = ..., close_fds: bool = ..., shell: bool = ..., cwd: Optional[AnyPath] = ..., env: Optional[_ENV] = ..., universal_newlines: bool = ..., startupinfo: Optional[Any] = ..., creationflags: int = ..., restore_signals: bool = ..., start_new_session: bool = ..., pass_fds: Any = ..., *, encoding: Optional[str] = ..., errors: str, ) -> Popen[str]: ... @overload def __new__( cls, args: _CMD, bufsize: int = ..., executable: Optional[AnyPath] = ..., stdin: Optional[_FILE] = ..., stdout: Optional[_FILE] = ..., stderr: Optional[_FILE] = ..., preexec_fn: Optional[Callable[[], Any]] = ..., close_fds: bool = ..., shell: bool = ..., cwd: Optional[AnyPath] = ..., env: Optional[_ENV] = ..., *, universal_newlines: Literal[True], startupinfo: Optional[Any] = ..., creationflags: int = ..., restore_signals: bool = ..., start_new_session: bool = ..., pass_fds: Any = ..., # where the *real* keyword only args start encoding: Optional[str] = ..., errors: Optional[str] = ..., ) -> Popen[str]: ... @overload def __new__( cls, args: _CMD, bufsize: int = ..., executable: Optional[AnyPath] = ..., stdin: Optional[_FILE] = ..., stdout: Optional[_FILE] = ..., stderr: Optional[_FILE] = ..., preexec_fn: Optional[Callable[[], Any]] = ..., close_fds: bool = ..., shell: bool = ..., cwd: Optional[AnyPath] = ..., env: Optional[_ENV] = ..., universal_newlines: Literal[False] = ..., startupinfo: Optional[Any] = ..., creationflags: int = ..., restore_signals: bool = ..., start_new_session: bool = ..., pass_fds: Any = ..., *, encoding: None = ..., errors: None = ..., ) -> Popen[bytes]: ... @overload def __new__( cls, args: _CMD, bufsize: int = ..., executable: Optional[AnyPath] = ..., stdin: Optional[_FILE] = ..., stdout: Optional[_FILE] = ..., stderr: Optional[_FILE] = ..., preexec_fn: Optional[Callable[[], Any]] = ..., close_fds: bool = ..., shell: bool = ..., cwd: Optional[AnyPath] = ..., env: Optional[_ENV] = ..., universal_newlines: bool = ..., startupinfo: Optional[Any] = ..., creationflags: int = ..., restore_signals: bool = ..., start_new_session: bool = ..., pass_fds: Any = ..., *, encoding: Optional[str] = ..., errors: Optional[str] = ..., ) -> Popen[Any]: ... def poll(self) -> Optional[int]: ... if sys.version_info >= (3, 7): def wait(self, timeout: Optional[float] = ...) -> int: ... else: def wait(self, timeout: Optional[float] = ..., endtime: Optional[float] = ...) -> int: ... # Return str/bytes def communicate( self, input: Optional[AnyStr] = ..., timeout: Optional[float] = ..., # morally this should be optional ) -> Tuple[AnyStr, AnyStr]: ... def send_signal(self, sig: int) -> None: ... def terminate(self) -> None: ... def kill(self) -> None: ... def __enter__(self: _S) -> _S: ... def __exit__( self, type: Optional[Type[BaseException]], value: Optional[BaseException], traceback: Optional[TracebackType] ) -> None: ... if sys.version_info >= (3, 9): def __class_getitem__(cls, item: Any) -> GenericAlias: ... # The result really is always a str. def getstatusoutput(cmd: _TXT) -> Tuple[int, str]: ... def getoutput(cmd: _TXT) -> str: ... def list2cmdline(seq: Sequence[str]) -> str: ... # undocumented if sys.platform == "win32": class STARTUPINFO: if sys.version_info >= (3, 7): def __init__( self, *, dwFlags: int = ..., hStdInput: Optional[Any] = ..., hStdOutput: Optional[Any] = ..., hStdError: Optional[Any] = ..., wShowWindow: int = ..., lpAttributeList: Optional[Mapping[str, Any]] = ..., ) -> None: ... dwFlags: int hStdInput: Optional[Any] hStdOutput: Optional[Any] hStdError: Optional[Any] wShowWindow: int if sys.version_info >= (3, 7): lpAttributeList: Mapping[str, Any] STD_INPUT_HANDLE: Any STD_OUTPUT_HANDLE: Any STD_ERROR_HANDLE: Any SW_HIDE: int STARTF_USESTDHANDLES: int STARTF_USESHOWWINDOW: int CREATE_NEW_CONSOLE: int CREATE_NEW_PROCESS_GROUP: int if sys.version_info >= (3, 7): ABOVE_NORMAL_PRIORITY_CLASS: int BELOW_NORMAL_PRIORITY_CLASS: int HIGH_PRIORITY_CLASS: int IDLE_PRIORITY_CLASS: int NORMAL_PRIORITY_CLASS: int REALTIME_PRIORITY_CLASS: int CREATE_NO_WINDOW: int DETACHED_PROCESS: int CREATE_DEFAULT_ERROR_MODE: int CREATE_BREAKAWAY_FROM_JOB: int ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/symbol.pyi0000664000175000017500000000254700000000000023154 0ustar00davedave00000000000000from typing import Dict single_input: int file_input: int eval_input: int decorator: int decorators: int decorated: int async_funcdef: int funcdef: int parameters: int typedargslist: int tfpdef: int varargslist: int vfpdef: int stmt: int simple_stmt: int small_stmt: int expr_stmt: int annassign: int testlist_star_expr: int augassign: int del_stmt: int pass_stmt: int flow_stmt: int break_stmt: int continue_stmt: int return_stmt: int yield_stmt: int raise_stmt: int import_stmt: int import_name: int import_from: int import_as_name: int dotted_as_name: int import_as_names: int dotted_as_names: int dotted_name: int global_stmt: int nonlocal_stmt: int assert_stmt: int compound_stmt: int async_stmt: int if_stmt: int while_stmt: int for_stmt: int try_stmt: int with_stmt: int with_item: int except_clause: int suite: int test: int test_nocond: int lambdef: int lambdef_nocond: int or_test: int and_test: int not_test: int comparison: int comp_op: int star_expr: int expr: int xor_expr: int and_expr: int shift_expr: int arith_expr: int term: int factor: int power: int atom_expr: int atom: int testlist_comp: int trailer: int subscriptlist: int subscript: int sliceop: int exprlist: int testlist: int dictorsetmaker: int classdef: int arglist: int argument: int comp_iter: int comp_for: int comp_if: int encoding_decl: int yield_expr: int yield_arg: int sym_name: Dict[int, str] ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/sys.pyi0000664000175000017500000001430100000000000022454 0ustar00davedave00000000000000import sys from builtins import object as _object from importlib.abc import MetaPathFinder, PathEntryFinder from types import FrameType, ModuleType, TracebackType from typing import ( Any, AsyncGenerator, Callable, Dict, List, NoReturn, Optional, Sequence, TextIO, Tuple, Type, TypeVar, Union, overload, ) _T = TypeVar("_T") # The following type alias are stub-only and do not exist during runtime _ExcInfo = Tuple[Type[BaseException], BaseException, TracebackType] _OptExcInfo = Union[_ExcInfo, Tuple[None, None, None]] # ----- sys variables ----- if sys.platform != "win32": abiflags: str argv: List[str] base_exec_prefix: str base_prefix: str byteorder: str builtin_module_names: Sequence[str] # actually a tuple of strings copyright: str if sys.platform == "win32": dllhandle: int dont_write_bytecode: bool displayhook: Callable[[object], Any] excepthook: Callable[[Type[BaseException], BaseException, TracebackType], Any] exec_prefix: str executable: str float_repr_style: str hexversion: int last_type: Optional[Type[BaseException]] last_value: Optional[BaseException] last_traceback: Optional[TracebackType] maxsize: int maxunicode: int meta_path: List[MetaPathFinder] modules: Dict[str, ModuleType] path: List[str] path_hooks: List[Any] # TODO precise type; function, path to finder path_importer_cache: Dict[str, Optional[PathEntryFinder]] platform: str if sys.version_info >= (3, 9): platlibdir: str prefix: str if sys.version_info >= (3, 8): pycache_prefix: Optional[str] ps1: str ps2: str stdin: TextIO stdout: TextIO stderr: TextIO __stdin__: TextIO __stdout__: TextIO __stderr__: TextIO tracebacklimit: int version: str api_version: int warnoptions: Any # Each entry is a tuple of the form (action, message, category, module, # lineno) if sys.platform == "win32": winver: str _xoptions: Dict[Any, Any] flags: _flags class _flags: debug: int division_warning: int inspect: int interactive: int optimize: int dont_write_bytecode: int no_user_site: int no_site: int ignore_environment: int verbose: int bytes_warning: int quiet: int hash_randomization: int if sys.version_info >= (3, 7): dev_mode: int utf8_mode: int float_info: _float_info class _float_info: epsilon: float # DBL_EPSILON dig: int # DBL_DIG mant_dig: int # DBL_MANT_DIG max: float # DBL_MAX max_exp: int # DBL_MAX_EXP max_10_exp: int # DBL_MAX_10_EXP min: float # DBL_MIN min_exp: int # DBL_MIN_EXP min_10_exp: int # DBL_MIN_10_EXP radix: int # FLT_RADIX rounds: int # FLT_ROUNDS hash_info: _hash_info class _hash_info: width: int modulus: int inf: int nan: int imag: int implementation: _implementation class _implementation: name: str version: _version_info hexversion: int cache_tag: str int_info: _int_info class _int_info: bits_per_digit: int sizeof_digit: int class _version_info(Tuple[int, int, int, str, int]): major: int minor: int micro: int releaselevel: str serial: int version_info: _version_info def call_tracing(__func: Callable[..., _T], __args: Any) -> _T: ... def _clear_type_cache() -> None: ... def _current_frames() -> Dict[int, Any]: ... def _debugmallocstats() -> None: ... def __displayhook__(value: object) -> None: ... def __excepthook__(type_: Type[BaseException], value: BaseException, traceback: TracebackType) -> None: ... def exc_info() -> _OptExcInfo: ... # sys.exit() accepts an optional argument of anything printable def exit(__status: object = ...) -> NoReturn: ... def getdefaultencoding() -> str: ... if sys.platform != "win32": def getdlopenflags() -> int: ... def getfilesystemencoding() -> str: ... def getfilesystemencodeerrors() -> str: ... def getrefcount(__object: Any) -> int: ... def getrecursionlimit() -> int: ... @overload def getsizeof(obj: object) -> int: ... @overload def getsizeof(obj: object, default: int) -> int: ... def getswitchinterval() -> float: ... def _getframe(__depth: int = ...) -> FrameType: ... _ProfileFunc = Callable[[FrameType, str, Any], Any] def getprofile() -> Optional[_ProfileFunc]: ... def setprofile(profilefunc: Optional[_ProfileFunc]) -> None: ... _TraceFunc = Callable[[FrameType, str, Any], Optional[Callable[[FrameType, str, Any], Any]]] def gettrace() -> Optional[_TraceFunc]: ... def settrace(tracefunc: Optional[_TraceFunc]) -> None: ... class _WinVersion(Tuple[int, int, int, int, str, int, int, int, int, Tuple[int, int, int]]): major: int minor: int build: int platform: int service_pack: str service_pack_minor: int service_pack_major: int suite_mast: int product_type: int platform_version: Tuple[int, int, int] if sys.platform == "win32": def getwindowsversion() -> _WinVersion: ... def intern(__string: str) -> str: ... def is_finalizing() -> bool: ... if sys.version_info >= (3, 7): __breakpointhook__: Any # contains the original value of breakpointhook def breakpointhook(*args: Any, **kwargs: Any) -> Any: ... if sys.platform != "win32": def setdlopenflags(__flags: int) -> None: ... def setrecursionlimit(__limit: int) -> None: ... def setswitchinterval(__interval: float) -> None: ... def gettotalrefcount() -> int: ... # Debug builds only if sys.version_info < (3, 9): def getcheckinterval() -> int: ... # deprecated def setcheckinterval(__n: int) -> None: ... # deprecated if sys.version_info >= (3, 8): # not exported by sys class UnraisableHookArgs: exc_type: Type[BaseException] exc_value: Optional[BaseException] exc_traceback: Optional[TracebackType] err_msg: Optional[str] object: Optional[_object] unraisablehook: Callable[[UnraisableHookArgs], Any] def addaudithook(hook: Callable[[str, Tuple[Any, ...]], Any]) -> None: ... def audit(__event: str, *args: Any) -> None: ... _AsyncgenHook = Optional[Callable[[AsyncGenerator[Any, Any]], None]] class _asyncgen_hooks(Tuple[_AsyncgenHook, _AsyncgenHook]): firstiter: _AsyncgenHook finalizer: _AsyncgenHook def get_asyncgen_hooks() -> _asyncgen_hooks: ... def set_asyncgen_hooks(firstiter: _AsyncgenHook = ..., finalizer: _AsyncgenHook = ...) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/tempfile.pyi0000664000175000017500000002615300000000000023453 0ustar00davedave00000000000000import os import sys from types import TracebackType from typing import IO, Any, AnyStr, Generic, Iterable, Iterator, List, Optional, Tuple, Type, TypeVar, Union, overload from typing_extensions import Literal if sys.version_info >= (3, 9): from types import GenericAlias # global variables TMP_MAX: int tempdir: Optional[str] template: str _S = TypeVar("_S") _T = TypeVar("_T") # for pytype, define typevar in same file as alias _DirT = Union[_T, os.PathLike[_T]] if sys.version_info >= (3, 8): @overload def NamedTemporaryFile( mode: Literal["r", "w", "a", "x", "r+", "w+", "a+", "x+", "rt", "wt", "at", "xt", "r+t", "w+t", "a+t", "x+t"], buffering: int = ..., encoding: Optional[str] = ..., newline: Optional[str] = ..., suffix: Optional[AnyStr] = ..., prefix: Optional[AnyStr] = ..., dir: Optional[_DirT[AnyStr]] = ..., delete: bool = ..., *, errors: Optional[str] = ..., ) -> IO[str]: ... @overload def NamedTemporaryFile( mode: Literal["rb", "wb", "ab", "xb", "r+b", "w+b", "a+b", "x+b"] = ..., buffering: int = ..., encoding: Optional[str] = ..., newline: Optional[str] = ..., suffix: Optional[AnyStr] = ..., prefix: Optional[AnyStr] = ..., dir: Optional[_DirT[AnyStr]] = ..., delete: bool = ..., *, errors: Optional[str] = ..., ) -> IO[bytes]: ... @overload def NamedTemporaryFile( mode: str = ..., buffering: int = ..., encoding: Optional[str] = ..., newline: Optional[str] = ..., suffix: Optional[AnyStr] = ..., prefix: Optional[AnyStr] = ..., dir: Optional[_DirT[AnyStr]] = ..., delete: bool = ..., *, errors: Optional[str] = ..., ) -> IO[Any]: ... else: @overload def NamedTemporaryFile( mode: Literal["r", "w", "a", "x", "r+", "w+", "a+", "x+", "rt", "wt", "at", "xt", "r+t", "w+t", "a+t", "x+t"], buffering: int = ..., encoding: Optional[str] = ..., newline: Optional[str] = ..., suffix: Optional[AnyStr] = ..., prefix: Optional[AnyStr] = ..., dir: Optional[_DirT[AnyStr]] = ..., delete: bool = ..., ) -> IO[str]: ... @overload def NamedTemporaryFile( mode: Literal["rb", "wb", "ab", "xb", "r+b", "w+b", "a+b", "x+b"] = ..., buffering: int = ..., encoding: Optional[str] = ..., newline: Optional[str] = ..., suffix: Optional[AnyStr] = ..., prefix: Optional[AnyStr] = ..., dir: Optional[_DirT[AnyStr]] = ..., delete: bool = ..., ) -> IO[bytes]: ... @overload def NamedTemporaryFile( mode: str = ..., buffering: int = ..., encoding: Optional[str] = ..., newline: Optional[str] = ..., suffix: Optional[AnyStr] = ..., prefix: Optional[AnyStr] = ..., dir: Optional[_DirT[AnyStr]] = ..., delete: bool = ..., ) -> IO[Any]: ... if sys.platform == "win32": TemporaryFile = NamedTemporaryFile else: if sys.version_info >= (3, 8): @overload def TemporaryFile( mode: Literal["r", "w", "a", "x", "r+", "w+", "a+", "x+", "rt", "wt", "at", "xt", "r+t", "w+t", "a+t", "x+t"], buffering: int = ..., encoding: Optional[str] = ..., newline: Optional[str] = ..., suffix: Optional[AnyStr] = ..., prefix: Optional[AnyStr] = ..., dir: Optional[_DirT[AnyStr]] = ..., *, errors: Optional[str] = ..., ) -> IO[str]: ... @overload def TemporaryFile( mode: Literal["rb", "wb", "ab", "xb", "r+b", "w+b", "a+b", "x+b"] = ..., buffering: int = ..., encoding: Optional[str] = ..., newline: Optional[str] = ..., suffix: Optional[AnyStr] = ..., prefix: Optional[AnyStr] = ..., dir: Optional[_DirT[AnyStr]] = ..., *, errors: Optional[str] = ..., ) -> IO[bytes]: ... @overload def TemporaryFile( mode: str = ..., buffering: int = ..., encoding: Optional[str] = ..., newline: Optional[str] = ..., suffix: Optional[AnyStr] = ..., prefix: Optional[AnyStr] = ..., dir: Optional[_DirT[AnyStr]] = ..., *, errors: Optional[str] = ..., ) -> IO[Any]: ... else: @overload def TemporaryFile( mode: Literal["r", "w", "a", "x", "r+", "w+", "a+", "x+", "rt", "wt", "at", "xt", "r+t", "w+t", "a+t", "x+t"], buffering: int = ..., encoding: Optional[str] = ..., newline: Optional[str] = ..., suffix: Optional[AnyStr] = ..., prefix: Optional[AnyStr] = ..., dir: Optional[_DirT[AnyStr]] = ..., ) -> IO[str]: ... @overload def TemporaryFile( mode: Literal["rb", "wb", "ab", "xb", "r+b", "w+b", "a+b", "x+b"] = ..., buffering: int = ..., encoding: Optional[str] = ..., newline: Optional[str] = ..., suffix: Optional[AnyStr] = ..., prefix: Optional[AnyStr] = ..., dir: Optional[_DirT[AnyStr]] = ..., ) -> IO[bytes]: ... @overload def TemporaryFile( mode: str = ..., buffering: int = ..., encoding: Optional[str] = ..., newline: Optional[str] = ..., suffix: Optional[AnyStr] = ..., prefix: Optional[AnyStr] = ..., dir: Optional[_DirT[AnyStr]] = ..., ) -> IO[Any]: ... # It does not actually derive from IO[AnyStr], but it does implement the # protocol. class SpooledTemporaryFile(IO[AnyStr]): # bytes needs to go first, as default mode is to open as bytes if sys.version_info >= (3, 8): @overload def __init__( self: SpooledTemporaryFile[bytes], max_size: int = ..., mode: Literal["rb", "wb", "ab", "xb", "r+b", "w+b", "a+b", "x+b"] = ..., buffering: int = ..., encoding: Optional[str] = ..., newline: Optional[str] = ..., suffix: Optional[str] = ..., prefix: Optional[str] = ..., dir: Optional[str] = ..., *, errors: Optional[str] = ..., ) -> None: ... @overload def __init__( self: SpooledTemporaryFile[str], max_size: int = ..., mode: Literal["r", "w", "a", "x", "r+", "w+", "a+", "x+", "rt", "wt", "at", "xt", "r+t", "w+t", "a+t", "x+t"] = ..., buffering: int = ..., encoding: Optional[str] = ..., newline: Optional[str] = ..., suffix: Optional[str] = ..., prefix: Optional[str] = ..., dir: Optional[str] = ..., *, errors: Optional[str] = ..., ) -> None: ... @overload def __init__( self, max_size: int = ..., mode: str = ..., buffering: int = ..., encoding: Optional[str] = ..., newline: Optional[str] = ..., suffix: Optional[str] = ..., prefix: Optional[str] = ..., dir: Optional[str] = ..., *, errors: Optional[str] = ..., ) -> None: ... @property def errors(self) -> Optional[str]: ... else: @overload def __init__( self: SpooledTemporaryFile[bytes], max_size: int = ..., mode: Literal["rb", "wb", "ab", "xb", "r+b", "w+b", "a+b", "x+b"] = ..., buffering: int = ..., encoding: Optional[str] = ..., newline: Optional[str] = ..., suffix: Optional[str] = ..., prefix: Optional[str] = ..., dir: Optional[str] = ..., ) -> None: ... @overload def __init__( self: SpooledTemporaryFile[str], max_size: int = ..., mode: Literal["r", "w", "a", "x", "r+", "w+", "a+", "x+", "rt", "wt", "at", "xt", "r+t", "w+t", "a+t", "x+t"] = ..., buffering: int = ..., encoding: Optional[str] = ..., newline: Optional[str] = ..., suffix: Optional[str] = ..., prefix: Optional[str] = ..., dir: Optional[str] = ..., ) -> None: ... @overload def __init__( self, max_size: int = ..., mode: str = ..., buffering: int = ..., encoding: Optional[str] = ..., newline: Optional[str] = ..., suffix: Optional[str] = ..., prefix: Optional[str] = ..., dir: Optional[str] = ..., ) -> None: ... def rollover(self) -> None: ... def __enter__(self: _S) -> _S: ... def __exit__( self, exc_type: Optional[Type[BaseException]], exc_val: Optional[BaseException], exc_tb: Optional[TracebackType] ) -> Optional[bool]: ... # These methods are copied from the abstract methods of IO, because # SpooledTemporaryFile implements IO. # See also https://github.com/python/typeshed/pull/2452#issuecomment-420657918. def close(self) -> None: ... def fileno(self) -> int: ... def flush(self) -> None: ... def isatty(self) -> bool: ... def read(self, n: int = ...) -> AnyStr: ... def readline(self, limit: int = ...) -> AnyStr: ... def readlines(self, hint: int = ...) -> List[AnyStr]: ... def seek(self, offset: int, whence: int = ...) -> int: ... def tell(self) -> int: ... def truncate(self, size: Optional[int] = ...) -> int: ... def write(self, s: AnyStr) -> int: ... def writelines(self, iterable: Iterable[AnyStr]) -> None: ... def __iter__(self) -> Iterator[AnyStr]: ... # Other than the following methods, which do not exist on SpooledTemporaryFile def readable(self) -> bool: ... def seekable(self) -> bool: ... def writable(self) -> bool: ... def __next__(self) -> AnyStr: ... class TemporaryDirectory(Generic[AnyStr]): name: str def __init__( self, suffix: Optional[AnyStr] = ..., prefix: Optional[AnyStr] = ..., dir: Optional[_DirT[AnyStr]] = ... ) -> None: ... def cleanup(self) -> None: ... def __enter__(self) -> AnyStr: ... def __exit__( self, exc_type: Optional[Type[BaseException]], exc_val: Optional[BaseException], exc_tb: Optional[TracebackType] ) -> None: ... if sys.version_info >= (3, 9): def __class_getitem__(cls, item: Any) -> GenericAlias: ... def mkstemp( suffix: Optional[AnyStr] = ..., prefix: Optional[AnyStr] = ..., dir: Optional[_DirT[AnyStr]] = ..., text: bool = ... ) -> Tuple[int, AnyStr]: ... @overload def mkdtemp() -> str: ... @overload def mkdtemp(suffix: Optional[AnyStr] = ..., prefix: Optional[AnyStr] = ..., dir: Optional[_DirT[AnyStr]] = ...) -> AnyStr: ... def mktemp(suffix: Optional[AnyStr] = ..., prefix: Optional[AnyStr] = ..., dir: Optional[_DirT[AnyStr]] = ...) -> AnyStr: ... def gettempdirb() -> bytes: ... def gettempprefixb() -> bytes: ... def gettempdir() -> str: ... def gettempprefix() -> str: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/textwrap.pyi0000664000175000017500000000624200000000000023521 0ustar00davedave00000000000000from typing import Callable, Dict, List, Optional, Pattern class TextWrapper: width: int = ... initial_indent: str = ... subsequent_indent: str = ... expand_tabs: bool = ... replace_whitespace: bool = ... fix_sentence_endings: bool = ... drop_whitespace: bool = ... break_long_words: bool = ... break_on_hyphens: bool = ... tabsize: int = ... max_lines: Optional[int] = ... placeholder: str = ... # Attributes not present in documentation sentence_end_re: Pattern[str] = ... wordsep_re: Pattern[str] = ... wordsep_simple_re: Pattern[str] = ... whitespace_trans: str = ... unicode_whitespace_trans: Dict[int, int] = ... uspace: int = ... x: str = ... # leaked loop variable def __init__( self, width: int = ..., initial_indent: str = ..., subsequent_indent: str = ..., expand_tabs: bool = ..., replace_whitespace: bool = ..., fix_sentence_endings: bool = ..., break_long_words: bool = ..., drop_whitespace: bool = ..., break_on_hyphens: bool = ..., tabsize: int = ..., *, max_lines: Optional[int] = ..., placeholder: str = ..., ) -> None: ... # Private methods *are* part of the documented API for subclasses. def _munge_whitespace(self, text: str) -> str: ... def _split(self, text: str) -> List[str]: ... def _fix_sentence_endings(self, chunks: List[str]) -> None: ... def _handle_long_word(self, reversed_chunks: List[str], cur_line: List[str], cur_len: int, width: int) -> None: ... def _wrap_chunks(self, chunks: List[str]) -> List[str]: ... def _split_chunks(self, text: str) -> List[str]: ... def wrap(self, text: str) -> List[str]: ... def fill(self, text: str) -> str: ... def wrap( text: str, width: int = ..., *, initial_indent: str = ..., subsequent_indent: str = ..., expand_tabs: bool = ..., tabsize: int = ..., replace_whitespace: bool = ..., fix_sentence_endings: bool = ..., break_long_words: bool = ..., break_on_hyphens: bool = ..., drop_whitespace: bool = ..., max_lines: int = ..., placeholder: str = ..., ) -> List[str]: ... def fill( text: str, width: int = ..., *, initial_indent: str = ..., subsequent_indent: str = ..., expand_tabs: bool = ..., tabsize: int = ..., replace_whitespace: bool = ..., fix_sentence_endings: bool = ..., break_long_words: bool = ..., break_on_hyphens: bool = ..., drop_whitespace: bool = ..., max_lines: int = ..., placeholder: str = ..., ) -> str: ... def shorten( text: str, width: int, *, initial_indent: str = ..., subsequent_indent: str = ..., expand_tabs: bool = ..., tabsize: int = ..., replace_whitespace: bool = ..., fix_sentence_endings: bool = ..., break_long_words: bool = ..., break_on_hyphens: bool = ..., drop_whitespace: bool = ..., # Omit `max_lines: int = None`, it is forced to 1 here. placeholder: str = ..., ) -> str: ... def dedent(text: str) -> str: ... def indent(text: str, prefix: str, predicate: Optional[Callable[[str], bool]] = ...) -> str: ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4343793 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/tkinter/0000775000175000017500000000000000000000000022574 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/tkinter/__init__.pyi0000664000175000017500000033050700000000000025066 0ustar00davedave00000000000000import _tkinter import sys from enum import Enum from tkinter.constants import * # comment this out to find undefined identifier names with flake8 from tkinter.font import _FontDescription from types import TracebackType from typing import Any, Callable, Dict, Generic, List, Mapping, Optional, Protocol, Tuple, Type, TypeVar, Union, overload from typing_extensions import Literal, TypedDict # Using anything from tkinter.font in this file means that 'import tkinter' # seems to also load tkinter.font. That's not how it actually works, but # unfortunately not much can be done about it. https://github.com/python/typeshed/pull/4346 TclError = _tkinter.TclError wantobjects: Any TkVersion: Any TclVersion: Any READABLE = _tkinter.READABLE WRITABLE = _tkinter.WRITABLE EXCEPTION = _tkinter.EXCEPTION # Quick guide for figuring out which widget class to choose: # - Misc: any widget (don't use BaseWidget because Tk doesn't inherit from BaseWidget) # - Widget: anything that is meant to be put into another widget with e.g. pack or grid # - Wm: a toplevel window, Tk or Toplevel # # Instructions for figuring out the correct type of each widget option: # - See discussion on #4363. # # - Find the option from the manual page of the widget. Usually the manual # page of a non-ttk widget has the same name as the tkinter class, in the # 3tk section: # # $ sudo apt install tk-doc # $ man 3tk label # # Ttk manual pages tend to have ttk_ prefixed names: # # $ man 3tk ttk_label # # Non-GUI things like the .after() method are often in the 3tcl section: # # $ sudo apt install tcl-doc # $ man 3tcl after # # If you don't have man or apt, you can read these manual pages online: # # https://www.tcl.tk/doc/ # # Every option has '-' in front of its name in the manual page (and in Tcl). # For example, there's an option named '-text' in the label manual page. # # - Tkinter has some options documented in docstrings, but don't rely on them. # They aren't updated when a new version of Tk comes out, so the latest Tk # manual pages (see above) are much more likely to actually contain all # possible options. # # Also, reading tkinter's source code typically won't help much because it # uses a lot of **kwargs and duck typing. Typically every argument goes into # self.tk.call, which is _tkinter.TkappType.call, and the return value is # whatever that returns. The type of that depends on how the Tcl interpreter # represents the return value of the executed Tcl code. # # - If you think that int is an appropriate type for something, then you may # actually want _ScreenUnits instead. # # - If you think that Callable[something] is an appropriate type for # something, then you may actually want Union[Callable[something], str], # because it's often possible to specify a string of Tcl code. # # - Some options can be set only in __init__, but all options are available # when getting their values with configure's return value or cget. # # - Asks other tkinter users if you haven't worked much with tkinter. # _TkinterSequence[T] represents a sequence that tkinter understands. It # differs from typing.Sequence[T]. For example, collections.deque a valid # Sequence but not a valid _TkinterSequence: # # >>> tkinter.Label(font=('Helvetica', 12, collections.deque(['bold']))) # Traceback (most recent call last): # ... # _tkinter.TclError: unknown font style "deque(['bold'])" _T = TypeVar("_T") _TkinterSequence = Union[List[_T], Tuple[_T, ...]] # Some widgets have an option named -compound that accepts different values # than the _Compound defined here. Many other options have similar things. _Anchor = Literal["nw", "n", "ne", "w", "center", "e", "sw", "s", "se"] # manual page: Tk_GetAnchor _Bitmap = str # manual page: Tk_GetBitmap _ButtonCommand = Union[str, Callable[[], Any]] # return value is returned from Button.invoke() _Color = str # typically '#rrggbb', '#rgb' or color names. _Compound = Literal["top", "left", "center", "right", "bottom", "none"] # -compound in manual page named 'options' _Cursor = Union[str, Tuple[str], Tuple[str, str], Tuple[str, str, str], Tuple[str, str, str, str]] # manual page: Tk_GetCursor _EntryValidateCommand = Union[ Callable[[], bool], str, _TkinterSequence[str] ] # example when it's sequence: entry['invalidcommand'] = [entry.register(print), '%P'] _ImageSpec = Union[_Image, str] # str can be from e.g. tkinter.image_names() _Padding = Union[ _ScreenUnits, Tuple[_ScreenUnits], Tuple[_ScreenUnits, _ScreenUnits], Tuple[_ScreenUnits, _ScreenUnits, _ScreenUnits], Tuple[_ScreenUnits, _ScreenUnits, _ScreenUnits, _ScreenUnits], ] _Relief = Literal["raised", "sunken", "flat", "ridge", "solid", "groove"] # manual page: Tk_GetRelief _ScreenUnits = Union[str, float] # manual page: Tk_GetPixels _XYScrollCommand = Union[str, Callable[[float, float], Any]] # -xscrollcommand and -yscrollcommand in 'options' manual page _TakeFocusValue = Union[int, Literal[""], Callable[[str], Optional[bool]]] # -takefocus in manual page named 'options' class EventType(str, Enum): Activate: str = ... ButtonPress: str = ... ButtonRelease: str = ... Circulate: str = ... CirculateRequest: str = ... ClientMessage: str = ... Colormap: str = ... Configure: str = ... ConfigureRequest: str = ... Create: str = ... Deactivate: str = ... Destroy: str = ... Enter: str = ... Expose: str = ... FocusIn: str = ... FocusOut: str = ... GraphicsExpose: str = ... Gravity: str = ... KeyPress: str = ... KeyRelease: str = ... Keymap: str = ... Leave: str = ... Map: str = ... MapRequest: str = ... Mapping: str = ... Motion: str = ... MouseWheel: str = ... NoExpose: str = ... Property: str = ... Reparent: str = ... ResizeRequest: str = ... Selection: str = ... SelectionClear: str = ... SelectionRequest: str = ... Unmap: str = ... VirtualEvent: str = ... Visibility: str = ... # Events considered covariant because you should never assign to event.widget. _W = TypeVar("_W", covariant=True, bound="Misc") class Event(Generic[_W]): serial: int num: int focus: bool height: int width: int keycode: int state: Union[int, str] time: int x: int y: int x_root: int y_root: int char: str send_event: bool keysym: str keysym_num: int type: EventType widget: _W delta: int def NoDefaultRoot(): ... _TraceMode = Literal["array", "read", "write", "unset"] class Variable: def __init__(self, master: Optional[Misc] = ..., value: Optional[Any] = ..., name: Optional[str] = ...) -> None: ... def set(self, value: Any) -> None: ... initialize = set def get(self) -> Any: ... def trace_add(self, mode: _TraceMode, callback: Callable[[str, str, str], Any]) -> str: ... def trace_remove(self, mode: _TraceMode, cbname: str) -> None: ... def trace_info(self) -> List[Tuple[Tuple[_TraceMode, ...], str]]: ... def trace_variable(self, mode, callback): ... # deprecated def trace_vdelete(self, mode, cbname): ... # deprecated def trace_vinfo(self): ... # deprecated trace = trace_variable # deprecated class StringVar(Variable): def __init__(self, master: Optional[Misc] = ..., value: Optional[str] = ..., name: Optional[str] = ...) -> None: ... def set(self, value: str) -> None: ... initialize = set def get(self) -> str: ... class IntVar(Variable): def __init__(self, master: Optional[Misc] = ..., value: Optional[int] = ..., name: Optional[str] = ...) -> None: ... def set(self, value: int) -> None: ... initialize = set def get(self) -> int: ... class DoubleVar(Variable): def __init__(self, master: Optional[Misc] = ..., value: Optional[float] = ..., name: Optional[str] = ...) -> None: ... def set(self, value: float) -> None: ... initialize = set def get(self) -> float: ... class BooleanVar(Variable): def __init__(self, master: Optional[Misc] = ..., value: Optional[bool] = ..., name: Optional[str] = ...) -> None: ... def set(self, value: bool) -> None: ... initialize = set def get(self) -> bool: ... def mainloop(n: int = ...): ... getint: Any getdouble: Any def getboolean(s): ... class Misc: master: Optional[Misc] tk: _tkinter.TkappType def destroy(self): ... def deletecommand(self, name): ... def tk_strictMotif(self, boolean: Optional[Any] = ...): ... def tk_bisque(self): ... def tk_setPalette(self, *args, **kw): ... def wait_variable(self, name: Union[str, Variable] = ...): ... waitvar: Any def wait_window(self, window: Optional[Any] = ...): ... def wait_visibility(self, window: Optional[Any] = ...): ... def setvar(self, name: str = ..., value: str = ...): ... def getvar(self, name: str = ...): ... def getint(self, s): ... def getdouble(self, s): ... def getboolean(self, s): ... def focus_set(self): ... focus: Any def focus_force(self): ... def focus_get(self): ... def focus_displayof(self): ... def focus_lastfor(self): ... def tk_focusFollowsMouse(self): ... def tk_focusNext(self): ... def tk_focusPrev(self): ... @overload def after(self, ms: int, func: None = ...) -> None: ... @overload def after(self, ms: Union[int, Literal["idle"]], func: Callable[..., Any], *args: Any) -> str: ... # after_idle is essentially partialmethod(after, "idle") def after_idle(self, func: Callable[..., Any], *args: Any) -> str: ... def after_cancel(self, id: str) -> None: ... def bell(self, displayof: int = ...): ... def clipboard_get(self, **kw): ... def clipboard_clear(self, **kw): ... def clipboard_append(self, string, **kw): ... def grab_current(self): ... def grab_release(self): ... def grab_set(self): ... def grab_set_global(self): ... def grab_status(self): ... def option_add(self, pattern, value, priority: Optional[Any] = ...): ... def option_clear(self): ... def option_get(self, name, className): ... def option_readfile(self, fileName, priority: Optional[Any] = ...): ... def selection_clear(self, **kw): ... def selection_get(self, **kw): ... def selection_handle(self, command, **kw): ... def selection_own(self, **kw): ... def selection_own_get(self, **kw): ... def send(self, interp, cmd, *args): ... def lower(self, belowThis: Optional[Any] = ...): ... def tkraise(self, aboveThis: Optional[Any] = ...): ... lift: Any def winfo_atom(self, name, displayof: int = ...): ... def winfo_atomname(self, id, displayof: int = ...): ... def winfo_cells(self): ... def winfo_children(self): ... def winfo_class(self): ... def winfo_colormapfull(self): ... def winfo_containing(self, rootX, rootY, displayof: int = ...): ... def winfo_depth(self): ... def winfo_exists(self): ... def winfo_fpixels(self, number): ... def winfo_geometry(self): ... def winfo_height(self): ... def winfo_id(self): ... def winfo_interps(self, displayof: int = ...): ... def winfo_ismapped(self): ... def winfo_manager(self): ... def winfo_name(self): ... def winfo_parent(self): ... def winfo_pathname(self, id, displayof: int = ...): ... def winfo_pixels(self, number): ... def winfo_pointerx(self): ... def winfo_pointerxy(self): ... def winfo_pointery(self): ... def winfo_reqheight(self): ... def winfo_reqwidth(self): ... def winfo_rgb(self, color): ... def winfo_rootx(self): ... def winfo_rooty(self): ... def winfo_screen(self): ... def winfo_screencells(self): ... def winfo_screendepth(self): ... def winfo_screenheight(self): ... def winfo_screenmmheight(self): ... def winfo_screenmmwidth(self): ... def winfo_screenvisual(self): ... def winfo_screenwidth(self): ... def winfo_server(self): ... def winfo_toplevel(self): ... def winfo_viewable(self): ... def winfo_visual(self): ... def winfo_visualid(self): ... def winfo_visualsavailable(self, includeids: int = ...): ... def winfo_vrootheight(self): ... def winfo_vrootwidth(self): ... def winfo_vrootx(self): ... def winfo_vrooty(self): ... def winfo_width(self): ... def winfo_x(self): ... def winfo_y(self): ... def update(self): ... def update_idletasks(self): ... def bindtags(self, tagList: Optional[Any] = ...): ... # bind with isinstance(func, str) doesn't return anything, but all other # binds do. The default value of func is not str. @overload def bind( self, sequence: Optional[str] = ..., func: Optional[Callable[[Event[Misc]], Optional[Literal["break"]]]] = ..., add: Optional[bool] = ..., ) -> str: ... @overload def bind(self, sequence: Optional[str], func: str, add: Optional[bool] = ...) -> None: ... @overload def bind(self, *, func: str, add: Optional[bool] = ...) -> None: ... # There's no way to know what type of widget bind_all and bind_class # callbacks will get, so those are Misc. @overload def bind_all( self, sequence: Optional[str] = ..., func: Optional[Callable[[Event[Misc]], Optional[Literal["break"]]]] = ..., add: Optional[bool] = ..., ) -> str: ... @overload def bind_all(self, sequence: Optional[str], func: str, add: Optional[bool] = ...) -> None: ... @overload def bind_all(self, *, func: str, add: Optional[bool] = ...) -> None: ... @overload def bind_class( self, className: str, sequence: Optional[str] = ..., func: Optional[Callable[[Event[Misc]], Optional[Literal["break"]]]] = ..., add: Optional[bool] = ..., ) -> str: ... @overload def bind_class(self, className: str, sequence: Optional[str], func: str, add: Optional[bool] = ...) -> None: ... @overload def bind_class(self, className: str, *, func: str, add: Optional[bool] = ...) -> None: ... def unbind(self, sequence: str, funcid: Optional[str] = ...) -> None: ... def unbind_all(self, sequence: str) -> None: ... def unbind_class(self, className: str, sequence: str) -> None: ... def mainloop(self, n: int = ...): ... def quit(self): ... def nametowidget(self, name): ... register: Any def keys(self) -> List[str]: ... @overload def pack_propagate(self, flag: bool) -> Optional[bool]: ... @overload def pack_propagate(self) -> None: ... propagate = pack_propagate def grid_anchor(self, anchor: Optional[_Anchor] = ...) -> None: ... anchor = grid_anchor @overload def grid_bbox( self, column: None = ..., row: None = ..., col2: None = ..., row2: None = ... ) -> Optional[Tuple[int, int, int, int]]: ... @overload def grid_bbox(self, column: int, row: int, col2: None = ..., row2: None = ...) -> Optional[Tuple[int, int, int, int]]: ... @overload def grid_bbox(self, column: int, row: int, col2: int, row2: int) -> Optional[Tuple[int, int, int, int]]: ... # commented out to avoid conflicting with other bbox methods # bbox = grid_bbox def grid_columnconfigure(self, index, cnf=..., **kw): ... # TODO def grid_rowconfigure(self, index, cnf=..., **kw): ... # TODO columnconfigure = grid_columnconfigure rowconfigure = grid_rowconfigure def grid_location(self, x: _ScreenUnits, y: _ScreenUnits) -> Tuple[int, int]: ... @overload def grid_propagate(self, flag: bool) -> None: ... @overload def grid_propagate(self) -> bool: ... def grid_size(self) -> Tuple[int, int]: ... size = grid_size # Widget because Toplevel or Tk is never a slave def pack_slaves(self) -> List[Widget]: ... def grid_slaves(self, row: Optional[int] = ..., column: Optional[int] = ...) -> List[Widget]: ... def place_slaves(self) -> List[Widget]: ... slaves = pack_slaves def event_add(self, virtual, *sequences): ... def event_delete(self, virtual, *sequences): ... def event_generate(self, sequence, **kw): ... def event_info(self, virtual: Optional[Any] = ...): ... def image_names(self): ... def image_types(self): ... # See #4363 def __setitem__(self, key: str, value: Any) -> None: ... def __getitem__(self, key: str) -> Any: ... class CallWrapper: func: Any subst: Any widget: Any def __init__(self, func, subst, widget): ... def __call__(self, *args): ... class XView: def xview(self, *args): ... def xview_moveto(self, fraction): ... def xview_scroll(self, number, what): ... class YView: def yview(self, *args): ... def yview_moveto(self, fraction): ... def yview_scroll(self, number, what): ... class Wm: def wm_aspect( self, minNumer: Optional[Any] = ..., minDenom: Optional[Any] = ..., maxNumer: Optional[Any] = ..., maxDenom: Optional[Any] = ..., ): ... aspect: Any def wm_attributes(self, *args): ... attributes: Any def wm_client(self, name: Optional[Any] = ...): ... client: Any def wm_colormapwindows(self, *wlist): ... colormapwindows: Any def wm_command(self, value: Optional[Any] = ...): ... command: Any def wm_deiconify(self): ... deiconify: Any def wm_focusmodel(self, model: Optional[Any] = ...): ... focusmodel: Any def wm_forget(self, window): ... forget: Any def wm_frame(self): ... frame: Any def wm_geometry(self, newGeometry: Optional[Any] = ...): ... geometry: Any def wm_grid( self, baseWidth: Optional[Any] = ..., baseHeight: Optional[Any] = ..., widthInc: Optional[Any] = ..., heightInc: Optional[Any] = ..., ): ... grid: Any def wm_group(self, pathName: Optional[Any] = ...): ... group: Any def wm_iconbitmap(self, bitmap: Optional[Any] = ..., default: Optional[Any] = ...): ... iconbitmap: Any def wm_iconify(self): ... iconify: Any def wm_iconmask(self, bitmap: Optional[Any] = ...): ... iconmask: Any def wm_iconname(self, newName: Optional[Any] = ...): ... iconname: Any def wm_iconphoto(self, default: bool = ..., *args): ... iconphoto: Any def wm_iconposition(self, x: Optional[Any] = ..., y: Optional[Any] = ...): ... iconposition: Any def wm_iconwindow(self, pathName: Optional[Any] = ...): ... iconwindow: Any def wm_manage(self, widget): ... manage: Any def wm_maxsize(self, width: Optional[Any] = ..., height: Optional[Any] = ...): ... maxsize: Any def wm_minsize(self, width: Optional[Any] = ..., height: Optional[Any] = ...): ... minsize: Any def wm_overrideredirect(self, boolean: Optional[Any] = ...): ... overrideredirect: Any def wm_positionfrom(self, who: Optional[Any] = ...): ... positionfrom: Any def wm_protocol(self, name: Optional[Any] = ..., func: Optional[Any] = ...): ... protocol: Any def wm_resizable(self, width: Optional[Any] = ..., height: Optional[Any] = ...): ... resizable: Any def wm_sizefrom(self, who: Optional[Any] = ...): ... sizefrom: Any def wm_state(self, newstate: Optional[Any] = ...): ... state: Any def wm_title(self, string: Optional[Any] = ...): ... title: Any def wm_transient(self, master: Optional[Any] = ...): ... transient: Any def wm_withdraw(self): ... withdraw: Any _TkOptionName = Literal[ "background", "bd", "bg", "border", "borderwidth", "class", "colormap", "container", "cursor", "height", "highlightbackground", "highlightcolor", "highlightthickness", "menu", "padx", "pady", "relief", "screen", # can't be changed after creating widget "takefocus", "use", "visual", "width", ] class _ExceptionReportingCallback(Protocol): def __call__(self, __exc: Type[BaseException], __val: BaseException, __tb: TracebackType) -> Any: ... class Tk(Misc, Wm): master: None children: Dict[str, Any] def __init__( self, screenName: Optional[str] = ..., baseName: Optional[str] = ..., className: str = ..., useTk: bool = ..., sync: bool = ..., use: Optional[str] = ..., ) -> None: ... @overload def configure( self: Union[Tk, Toplevel], cnf: Optional[Dict[str, Any]] = ..., *, background: _Color = ..., bd: _ScreenUnits = ..., bg: _Color = ..., border: _ScreenUnits = ..., borderwidth: _ScreenUnits = ..., cursor: _Cursor = ..., height: _ScreenUnits = ..., highlightbackground: _Color = ..., highlightcolor: _Color = ..., highlightthickness: _ScreenUnits = ..., menu: Menu = ..., padx: _ScreenUnits = ..., pady: _ScreenUnits = ..., relief: _Relief = ..., takefocus: _TakeFocusValue = ..., width: _ScreenUnits = ..., ) -> Optional[Dict[str, Tuple[str, str, str, Any, Any]]]: ... @overload def configure(self, cnf: _TkOptionName) -> Tuple[str, str, str, Any, Any]: ... config = configure def cget(self, key: _TkOptionName) -> Any: ... def loadtk(self) -> None: ... # differs from _tkinter.TkappType.loadtk def destroy(self) -> None: ... def readprofile(self, baseName: str, className: str) -> None: ... report_callback_exception: _ExceptionReportingCallback # Tk has __getattr__ so that tk_instance.foo falls back to tk_instance.tk.foo # Please keep in sync with _tkinter.TkappType call: Callable[..., Any] eval: Callable[[str], str] adderrorinfo: Any createcommand: Any createfilehandler: Any createtimerhandler: Any deletecommand: Any deletefilehandler: Any dooneevent: Any evalfile: Any exprboolean: Any exprdouble: Any exprlong: Any exprstring: Any getboolean: Any getdouble: Any getint: Any getvar: Any globalgetvar: Any globalsetvar: Any globalunsetvar: Any interpaddr: Any mainloop: Any quit: Any record: Any setvar: Any split: Any splitlist: Any unsetvar: Any wantobjects: Any willdispatch: Any def Tcl(screenName: Optional[Any] = ..., baseName: Optional[Any] = ..., className: str = ..., useTk: bool = ...): ... _InMiscTotal = TypedDict("_InMiscTotal", {"in": Misc}) _InMiscNonTotal = TypedDict("_InMiscNonTotal", {"in": Misc}, total=False) class _PackInfo(_InMiscTotal): # 'before' and 'after' never appear in _PackInfo anchor: _Anchor expand: Literal[0, 1] fill: Literal["none", "x", "y", "both"] side: Literal["left", "right", "top", "bottom"] # Paddings come out as int or tuple of int, even though any _ScreenUnits # can be specified in pack(). ipadx: int ipady: int padx: Union[int, Tuple[int, int]] pady: Union[int, Tuple[int, int]] class Pack: # _PackInfo is not the valid type for cnf because pad stuff accepts any # _ScreenUnits instead of int only. I didn't bother to create another # TypedDict for cnf because it appears to be a legacy thing that was # replaced by **kwargs. def pack_configure( self, cnf: Optional[Mapping[str, Any]] = ..., *, after: Misc = ..., anchor: _Anchor = ..., before: Misc = ..., expand: int = ..., fill: Literal["none", "x", "y", "both"] = ..., side: Literal["left", "right", "top", "bottom"] = ..., ipadx: _ScreenUnits = ..., ipady: _ScreenUnits = ..., padx: Union[_ScreenUnits, Tuple[_ScreenUnits, _ScreenUnits]] = ..., pady: Union[_ScreenUnits, Tuple[_ScreenUnits, _ScreenUnits]] = ..., in_: Misc = ..., ) -> None: ... def pack_forget(self) -> None: ... def pack_info(self) -> _PackInfo: ... # errors if widget hasn't been packed pack = pack_configure forget = pack_forget propagate = Misc.pack_propagate # commented out to avoid mypy getting confused with multiple # inheritance and how things get overrided with different things # info = pack_info # pack_propagate = Misc.pack_propagate # configure = pack_configure # config = pack_configure # slaves = Misc.pack_slaves # pack_slaves = Misc.pack_slaves class _PlaceInfo(_InMiscNonTotal): # empty dict if widget hasn't been placed anchor: _Anchor bordermode: Literal["inside", "outside", "ignore"] width: str # can be int()ed (even after e.g. widget.place(height='2.3c') or similar) height: str # can be int()ed x: str # can be int()ed y: str # can be int()ed relheight: str # can be float()ed if not empty string relwidth: str # can be float()ed if not empty string relx: float # can be float()ed if not empty string rely: float # can be float()ed if not empty string class Place: def place_configure( self, cnf: Optional[Mapping[str, Any]] = ..., *, anchor: _Anchor = ..., bordermode: Literal["inside", "outside", "ignore"] = ..., width: _ScreenUnits = ..., height: _ScreenUnits = ..., x: _ScreenUnits = ..., y: _ScreenUnits = ..., relheight: float = ..., relwidth: float = ..., relx: float = ..., rely: float = ..., in_: Misc = ..., ) -> None: ... def place_forget(self) -> None: ... def place_info(self) -> _PlaceInfo: ... place = place_configure info = place_info # commented out to avoid mypy getting confused with multiple # inheritance and how things get overrided with different things # config = place_configure # configure = place_configure # forget = place_forget # slaves = Misc.place_slaves # place_slaves = Misc.place_slaves class _GridInfo(_InMiscNonTotal): # empty dict if widget hasn't been gridded column: int columnspan: int row: int rowspan: int ipadx: int ipady: int padx: Union[int, Tuple[int, int]] pady: Union[int, Tuple[int, int]] sticky: str # consists of letters 'n', 's', 'w', 'e', no repeats, may be empty class Grid: def grid_configure( self, cnf: Optional[Mapping[str, Any]] = ..., *, column: int = ..., columnspan: int = ..., row: int = ..., rowspan: int = ..., ipadx: _ScreenUnits = ..., ipady: _ScreenUnits = ..., padx: Union[_ScreenUnits, Tuple[_ScreenUnits, _ScreenUnits]] = ..., pady: Union[_ScreenUnits, Tuple[_ScreenUnits, _ScreenUnits]] = ..., sticky: str = ..., # consists of letters 'n', 's', 'w', 'e', may contain repeats, may be empty in_: Misc = ..., ) -> None: ... def grid_forget(self) -> None: ... def grid_remove(self) -> None: ... def grid_info(self) -> _GridInfo: ... grid = grid_configure location = Misc.grid_location size = Misc.grid_size # commented out to avoid mypy getting confused with multiple # inheritance and how things get overrided with different things # bbox = Misc.grid_bbox # grid_bbox = Misc.grid_bbox # forget = grid_forget # info = grid_info # grid_location = Misc.grid_location # grid_propagate = Misc.grid_propagate # grid_size = Misc.grid_size # rowconfigure = Misc.grid_rowconfigure # grid_rowconfigure = Misc.grid_rowconfigure # grid_columnconfigure = Misc.grid_columnconfigure # columnconfigure = Misc.grid_columnconfigure # config = grid_configure # configure = grid_configure # propagate = Misc.grid_propagate # slaves = Misc.grid_slaves # grid_slaves = Misc.grid_slaves class BaseWidget(Misc): master: Misc widgetName: Any def __init__(self, master, widgetName, cnf=..., kw=..., extra=...): ... def destroy(self): ... # This class represents any widget except Toplevel or Tk. class Widget(BaseWidget, Pack, Place, Grid): # Allow bind callbacks to take e.g. Event[Label] instead of Event[Misc]. # Tk and Toplevel get notified for their child widgets' events, but other # widgets don't. @overload def bind( self: _W, sequence: Optional[str] = ..., func: Optional[Callable[[Event[_W]], Optional[Literal["break"]]]] = ..., add: Optional[bool] = ..., ) -> str: ... @overload def bind(self, sequence: Optional[str], func: str, add: Optional[bool] = ...) -> None: ... @overload def bind(self, *, func: str, add: Optional[bool] = ...) -> None: ... class Toplevel(BaseWidget, Wm): def __init__( self, master: Optional[Misc] = ..., cnf: Optional[Dict[str, Any]] = ..., *, background: _Color = ..., bd: _ScreenUnits = ..., bg: _Color = ..., border: _ScreenUnits = ..., borderwidth: _ScreenUnits = ..., class_: str = ..., colormap: Union[Literal["new", ""], Misc] = ..., container: bool = ..., cursor: _Cursor = ..., height: _ScreenUnits = ..., highlightbackground: _Color = ..., highlightcolor: _Color = ..., highlightthickness: _ScreenUnits = ..., menu: Menu = ..., padx: _ScreenUnits = ..., pady: _ScreenUnits = ..., relief: _Relief = ..., screen: str = ..., takefocus: _TakeFocusValue = ..., use: int = ..., visual: Union[str, Tuple[str, int]] = ..., width: _ScreenUnits = ..., ) -> None: ... # Toplevel and Tk have the same options because they correspond to the same # Tcl/Tk toplevel widget. configure = Tk.configure config = Tk.config cget = Tk.cget _ButtonOptionName = Literal[ "activebackground", "activeforeground", "anchor", "background", "bd", # same as borderwidth "bg", # same as background "bitmap", "border", # same as borderwidth "borderwidth", "command", "compound", "cursor", "default", "disabledforeground", "fg", # same as foreground "font", "foreground", "height", "highlightbackground", "highlightcolor", "highlightthickness", "image", "justify", "overrelief", "padx", "pady", "relief", "repeatdelay", "repeatinterval", "state", "takefocus", "text", "textvariable", "underline", "width", "wraplength", ] class Button(Widget): def __init__( self, master: Optional[Misc] = ..., cnf: Optional[Dict[str, Any]] = ..., *, activebackground: _Color = ..., activeforeground: _Color = ..., anchor: _Anchor = ..., background: _Color = ..., bd: _ScreenUnits = ..., bg: _Color = ..., bitmap: _Bitmap = ..., border: _ScreenUnits = ..., borderwidth: _ScreenUnits = ..., command: _ButtonCommand = ..., compound: _Compound = ..., cursor: _Cursor = ..., default: Literal["normal", "active", "disabled"] = ..., disabledforeground: _Color = ..., fg: _Color = ..., font: _FontDescription = ..., foreground: _Color = ..., # width and height must be int for buttons containing just text, but # ints are also valid _ScreenUnits height: _ScreenUnits = ..., highlightbackground: _Color = ..., highlightcolor: _Color = ..., highlightthickness: _ScreenUnits = ..., image: _ImageSpec = ..., justify: Literal["left", "center", "right"] = ..., name: str = ..., overrelief: _Relief = ..., padx: _ScreenUnits = ..., pady: _ScreenUnits = ..., relief: _Relief = ..., repeatdelay: int = ..., repeatinterval: int = ..., state: Literal["normal", "active", "disabled"] = ..., takefocus: _TakeFocusValue = ..., text: str = ..., # We allow the textvariable to be any Variable, not necessarly # StringVar. This is useful for e.g. a button that displays the value # of an IntVar. textvariable: Variable = ..., underline: int = ..., width: _ScreenUnits = ..., wraplength: _ScreenUnits = ..., ) -> None: ... @overload def configure( self, cnf: Optional[Dict[str, Any]] = ..., *, activebackground: _Color = ..., activeforeground: _Color = ..., anchor: _Anchor = ..., background: _Color = ..., bd: _ScreenUnits = ..., bg: _Color = ..., bitmap: _Bitmap = ..., border: _ScreenUnits = ..., borderwidth: _ScreenUnits = ..., command: _ButtonCommand = ..., compound: _Compound = ..., cursor: _Cursor = ..., default: Literal["normal", "active", "disabled"] = ..., disabledforeground: _Color = ..., fg: _Color = ..., font: _FontDescription = ..., foreground: _Color = ..., height: _ScreenUnits = ..., highlightbackground: _Color = ..., highlightcolor: _Color = ..., highlightthickness: _ScreenUnits = ..., image: _ImageSpec = ..., justify: Literal["left", "center", "right"] = ..., overrelief: _Relief = ..., padx: _ScreenUnits = ..., pady: _ScreenUnits = ..., relief: _Relief = ..., repeatdelay: int = ..., repeatinterval: int = ..., state: Literal["normal", "active", "disabled"] = ..., takefocus: _TakeFocusValue = ..., text: str = ..., textvariable: Variable = ..., underline: int = ..., width: _ScreenUnits = ..., wraplength: _ScreenUnits = ..., ) -> Optional[Dict[str, Tuple[str, str, str, Any, Any]]]: ... @overload def configure(self, cnf: _ButtonOptionName) -> Tuple[str, str, str, Any, Any]: ... config = configure def cget(self, key: _ButtonOptionName) -> Any: ... def flash(self): ... def invoke(self): ... _CanvasOptionName = Literal[ "background", "bd", "bg", "border", "borderwidth", "closeenough", "confine", "cursor", "height", "highlightbackground", "highlightcolor", "highlightthickness", "insertbackground", "insertborderwidth", "insertofftime", "insertontime", "insertwidth", "offset", "relief", "scrollregion", "selectbackground", "selectborderwidth", "selectforeground", "state", "takefocus", "width", "xscrollcommand", "xscrollincrement", "yscrollcommand", "yscrollincrement", ] class Canvas(Widget, XView, YView): def __init__( self, master: Optional[Misc] = ..., cnf: Optional[Dict[str, Any]] = ..., *, background: _Color = ..., bd: _ScreenUnits = ..., bg: _Color = ..., border: _ScreenUnits = ..., borderwidth: _ScreenUnits = ..., closeenough: float = ..., confine: bool = ..., cursor: _Cursor = ..., # canvas manual page has a section named COORDINATES, and the first # part of it describes _ScreenUnits. height: _ScreenUnits = ..., highlightbackground: _Color = ..., highlightcolor: _Color = ..., highlightthickness: _ScreenUnits = ..., insertbackground: _Color = ..., insertborderwidth: _ScreenUnits = ..., insertofftime: int = ..., insertontime: int = ..., insertwidth: _ScreenUnits = ..., name: str = ..., offset: Any = ..., # undocumented relief: _Relief = ..., # Setting scrollregion to None doesn't reset it back to empty, # but setting it to () does. scrollregion: Union[Tuple[_ScreenUnits, _ScreenUnits, _ScreenUnits, _ScreenUnits], Tuple[()]] = ..., selectbackground: _Color = ..., selectborderwidth: _ScreenUnits = ..., selectforeground: _Color = ..., # man page says that state can be 'hidden', but it can't state: Literal["normal", "disabled"] = ..., takefocus: _TakeFocusValue = ..., width: _ScreenUnits = ..., xscrollcommand: _XYScrollCommand = ..., xscrollincrement: _ScreenUnits = ..., yscrollcommand: _XYScrollCommand = ..., yscrollincrement: _ScreenUnits = ..., ) -> None: ... @overload def configure( self, cnf: Optional[Dict[str, Any]] = ..., *, background: _Color = ..., bd: _ScreenUnits = ..., bg: _Color = ..., border: _ScreenUnits = ..., borderwidth: _ScreenUnits = ..., closeenough: float = ..., confine: bool = ..., cursor: _Cursor = ..., height: _ScreenUnits = ..., highlightbackground: _Color = ..., highlightcolor: _Color = ..., highlightthickness: _ScreenUnits = ..., insertbackground: _Color = ..., insertborderwidth: _ScreenUnits = ..., insertofftime: int = ..., insertontime: int = ..., insertwidth: _ScreenUnits = ..., offset: Any = ..., # undocumented relief: _Relief = ..., scrollregion: Union[Tuple[_ScreenUnits, _ScreenUnits, _ScreenUnits, _ScreenUnits], Tuple[()]] = ..., selectbackground: _Color = ..., selectborderwidth: _ScreenUnits = ..., selectforeground: _Color = ..., state: Literal["normal", "disabled"] = ..., takefocus: _TakeFocusValue = ..., width: _ScreenUnits = ..., xscrollcommand: _XYScrollCommand = ..., xscrollincrement: _ScreenUnits = ..., yscrollcommand: _XYScrollCommand = ..., yscrollincrement: _ScreenUnits = ..., ) -> Optional[Dict[str, Tuple[str, str, str, Any, Any]]]: ... @overload def configure(self, cnf: _CanvasOptionName) -> Tuple[str, str, str, Any, Any]: ... config = configure def cget(self, key: _CanvasOptionName) -> Any: ... def addtag(self, *args): ... def addtag_above(self, newtag, tagOrId): ... def addtag_all(self, newtag): ... def addtag_below(self, newtag, tagOrId): ... def addtag_closest(self, newtag, x, y, halo: Optional[Any] = ..., start: Optional[Any] = ...): ... def addtag_enclosed(self, newtag, x1, y1, x2, y2): ... def addtag_overlapping(self, newtag, x1, y1, x2, y2): ... def addtag_withtag(self, newtag, tagOrId): ... def bbox(self, *args): ... @overload def tag_bind( self, tagOrId: Union[str, int], sequence: Optional[str] = ..., func: Optional[Callable[[Event[Canvas]], Optional[Literal["break"]]]] = ..., add: Optional[bool] = ..., ) -> str: ... @overload def tag_bind(self, tagOrId: Union[str, int], sequence: Optional[str], func: str, add: Optional[bool] = ...) -> None: ... @overload def tag_bind(self, tagOrId: Union[str, int], *, func: str, add: Optional[bool] = ...) -> None: ... def tag_unbind(self, tagOrId: Union[str, int], sequence: str, funcid: Optional[str] = ...) -> None: ... def canvasx(self, screenx, gridspacing: Optional[Any] = ...): ... def canvasy(self, screeny, gridspacing: Optional[Any] = ...): ... def coords(self, *args): ... def create_arc(self, *args, **kw): ... def create_bitmap(self, *args, **kw): ... def create_image(self, *args, **kw): ... def create_line(self, *args, **kw): ... def create_oval(self, *args, **kw): ... def create_polygon(self, *args, **kw): ... def create_rectangle(self, *args, **kw): ... def create_text(self, *args, **kw): ... def create_window(self, *args, **kw): ... def dchars(self, *args): ... def delete(self, *args): ... def dtag(self, *args): ... def find(self, *args): ... def find_above(self, tagOrId): ... def find_all(self): ... def find_below(self, tagOrId): ... def find_closest(self, x, y, halo: Optional[Any] = ..., start: Optional[Any] = ...): ... def find_enclosed(self, x1, y1, x2, y2): ... def find_overlapping(self, x1, y1, x2, y2): ... def find_withtag(self, tagOrId): ... def focus(self, *args): ... def gettags(self, *args): ... def icursor(self, *args): ... def index(self, *args): ... def insert(self, *args): ... def itemcget(self, tagOrId, option): ... def itemconfigure(self, tagOrId, cnf: Optional[Any] = ..., **kw): ... itemconfig: Any def tag_lower(self, *args): ... lower: Any def move(self, *args): ... if sys.version_info >= (3, 8): def moveto(self, tagOrId: Union[int, str], x: str = ..., y: str = ...) -> None: ... def postscript(self, cnf=..., **kw): ... def tag_raise(self, *args): ... lift: Any def scale(self, *args): ... def scan_mark(self, x, y): ... def scan_dragto(self, x, y, gain: int = ...): ... def select_adjust(self, tagOrId, index): ... def select_clear(self): ... def select_from(self, tagOrId, index): ... def select_item(self): ... def select_to(self, tagOrId, index): ... def type(self, tagOrId): ... _CheckbuttonOptionName = Literal[ "activebackground", "activeforeground", "anchor", "background", "bd", "bg", "bitmap", "border", "borderwidth", "command", "compound", "cursor", "disabledforeground", "fg", "font", "foreground", "height", "highlightbackground", "highlightcolor", "highlightthickness", "image", "indicatoron", "justify", "offrelief", "offvalue", "onvalue", "overrelief", "padx", "pady", "relief", "selectcolor", "selectimage", "state", "takefocus", "text", "textvariable", "tristateimage", "tristatevalue", "underline", "variable", "width", "wraplength", ] class Checkbutton(Widget): def __init__( self, master: Optional[Misc] = ..., cnf: Optional[Dict[str, Any]] = ..., *, activebackground: _Color = ..., activeforeground: _Color = ..., anchor: _Anchor = ..., background: _Color = ..., bd: _ScreenUnits = ..., bg: _Color = ..., bitmap: _Bitmap = ..., border: _ScreenUnits = ..., borderwidth: _ScreenUnits = ..., command: _ButtonCommand = ..., compound: _Compound = ..., cursor: _Cursor = ..., disabledforeground: _Color = ..., fg: _Color = ..., font: _FontDescription = ..., foreground: _Color = ..., height: _ScreenUnits = ..., highlightbackground: _Color = ..., highlightcolor: _Color = ..., highlightthickness: _ScreenUnits = ..., image: _ImageSpec = ..., indicatoron: bool = ..., justify: Literal["left", "center", "right"] = ..., name: str = ..., offrelief: _Relief = ..., # The checkbutton puts a value to its variable when it's checked or # unchecked. We don't restrict the type of that value here, so # Any-typing is fine. # # I think Checkbutton shouldn't be generic, because then specifying # "any checkbutton regardless of what variable it uses" would be # difficult, and we might run into issues just like how List[float] # and List[int] are incompatible. Also, we would need a way to # specify "Checkbutton not associated with any variable", which is # done by setting variable to empty string (the default). offvalue: Any = ..., onvalue: Any = ..., overrelief: _Relief = ..., padx: _ScreenUnits = ..., pady: _ScreenUnits = ..., relief: _Relief = ..., selectcolor: _Color = ..., selectimage: _ImageSpec = ..., state: Literal["normal", "active", "disabled"] = ..., takefocus: _TakeFocusValue = ..., text: str = ..., textvariable: Variable = ..., tristateimage: _ImageSpec = ..., tristatevalue: Any = ..., underline: int = ..., variable: Union[Variable, Literal[""]] = ..., width: _ScreenUnits = ..., wraplength: _ScreenUnits = ..., ) -> None: ... @overload def configure( self, cnf: Optional[Dict[str, Any]] = ..., *, activebackground: _Color = ..., activeforeground: _Color = ..., anchor: _Anchor = ..., background: _Color = ..., bd: _ScreenUnits = ..., bg: _Color = ..., bitmap: _Bitmap = ..., border: _ScreenUnits = ..., borderwidth: _ScreenUnits = ..., command: _ButtonCommand = ..., compound: _Compound = ..., cursor: _Cursor = ..., disabledforeground: _Color = ..., fg: _Color = ..., font: _FontDescription = ..., foreground: _Color = ..., height: _ScreenUnits = ..., highlightbackground: _Color = ..., highlightcolor: _Color = ..., highlightthickness: _ScreenUnits = ..., image: _ImageSpec = ..., indicatoron: bool = ..., justify: Literal["left", "center", "right"] = ..., offrelief: _Relief = ..., offvalue: Any = ..., onvalue: Any = ..., overrelief: _Relief = ..., padx: _ScreenUnits = ..., pady: _ScreenUnits = ..., relief: _Relief = ..., selectcolor: _Color = ..., selectimage: _ImageSpec = ..., state: Literal["normal", "active", "disabled"] = ..., takefocus: _TakeFocusValue = ..., text: str = ..., textvariable: Variable = ..., tristateimage: _ImageSpec = ..., tristatevalue: Any = ..., underline: int = ..., variable: Union[Variable, Literal[""]] = ..., width: _ScreenUnits = ..., wraplength: _ScreenUnits = ..., ) -> Optional[Dict[str, Tuple[str, str, str, Any, Any]]]: ... @overload def configure(self, cnf: _CheckbuttonOptionName) -> Tuple[str, str, str, Any, Any]: ... config = configure def cget(self, key: _CheckbuttonOptionName) -> Any: ... def deselect(self): ... def flash(self): ... def invoke(self): ... def select(self): ... def toggle(self): ... _EntryOptionName = Literal[ "background", "bd", "bg", "border", "borderwidth", "cursor", "disabledbackground", "disabledforeground", "exportselection", "fg", "font", "foreground", "highlightbackground", "highlightcolor", "highlightthickness", "insertbackground", "insertborderwidth", "insertofftime", "insertontime", "insertwidth", "invalidcommand", "invcmd", # same as invalidcommand "justify", "readonlybackground", "relief", "selectbackground", "selectborderwidth", "selectforeground", "show", "state", "takefocus", "textvariable", "validate", "validatecommand", "vcmd", # same as validatecommand "width", "xscrollcommand", ] class Entry(Widget, XView): def __init__( self, master: Optional[Misc] = ..., cnf: Optional[Dict[str, Any]] = ..., *, background: _Color = ..., bd: _ScreenUnits = ..., bg: _Color = ..., border: _ScreenUnits = ..., borderwidth: _ScreenUnits = ..., cursor: _Cursor = ..., disabledbackground: _Color = ..., disabledforeground: _Color = ..., exportselection: bool = ..., fg: _Color = ..., font: _FontDescription = ..., foreground: _Color = ..., highlightbackground: _Color = ..., highlightcolor: _Color = ..., highlightthickness: _ScreenUnits = ..., insertbackground: _Color = ..., insertborderwidth: _ScreenUnits = ..., insertofftime: int = ..., insertontime: int = ..., insertwidth: _ScreenUnits = ..., invalidcommand: _EntryValidateCommand = ..., invcmd: _EntryValidateCommand = ..., justify: Literal["left", "center", "right"] = ..., name: str = ..., readonlybackground: _Color = ..., relief: _Relief = ..., selectbackground: _Color = ..., selectborderwidth: _ScreenUnits = ..., selectforeground: _Color = ..., show: str = ..., state: Literal["normal", "disabled", "readonly"] = ..., takefocus: _TakeFocusValue = ..., textvariable: Variable = ..., validate: Literal["none", "focus", "focusin", "focusout", "key", "all"] = ..., validatecommand: _EntryValidateCommand = ..., vcmd: _EntryValidateCommand = ..., width: int = ..., xscrollcommand: _XYScrollCommand = ..., ) -> None: ... @overload def configure( self, cnf: Optional[Dict[str, Any]] = ..., *, background: _Color = ..., bd: _ScreenUnits = ..., bg: _Color = ..., border: _ScreenUnits = ..., borderwidth: _ScreenUnits = ..., cursor: _Cursor = ..., disabledbackground: _Color = ..., disabledforeground: _Color = ..., exportselection: bool = ..., fg: _Color = ..., font: _FontDescription = ..., foreground: _Color = ..., highlightbackground: _Color = ..., highlightcolor: _Color = ..., highlightthickness: _ScreenUnits = ..., insertbackground: _Color = ..., insertborderwidth: _ScreenUnits = ..., insertofftime: int = ..., insertontime: int = ..., insertwidth: _ScreenUnits = ..., invalidcommand: _EntryValidateCommand = ..., invcmd: _EntryValidateCommand = ..., justify: Literal["left", "center", "right"] = ..., readonlybackground: _Color = ..., relief: _Relief = ..., selectbackground: _Color = ..., selectborderwidth: _ScreenUnits = ..., selectforeground: _Color = ..., show: str = ..., state: Literal["normal", "disabled", "readonly"] = ..., takefocus: _TakeFocusValue = ..., textvariable: Variable = ..., validate: Literal["none", "focus", "focusin", "focusout", "key", "all"] = ..., validatecommand: _EntryValidateCommand = ..., vcmd: _EntryValidateCommand = ..., width: int = ..., xscrollcommand: _XYScrollCommand = ..., ) -> Optional[Dict[str, Tuple[str, str, str, Any, Any]]]: ... @overload def configure(self, cnf: _EntryOptionName) -> Tuple[str, str, str, Any, Any]: ... config = configure def cget(self, key: _EntryOptionName) -> Any: ... def delete(self, first, last: Optional[Any] = ...): ... def get(self): ... def icursor(self, index): ... def index(self, index): ... def insert(self, index, string): ... def scan_mark(self, x): ... def scan_dragto(self, x): ... def selection_adjust(self, index): ... select_adjust: Any def selection_clear(self): ... select_clear: Any def selection_from(self, index): ... select_from: Any def selection_present(self): ... select_present: Any def selection_range(self, start, end): ... select_range: Any def selection_to(self, index): ... select_to: Any _FrameOptionName = Literal[ "background", "bd", "bg", "border", "borderwidth", "class", "colormap", "container", "cursor", "height", "highlightbackground", "highlightcolor", "highlightthickness", "padx", "pady", "relief", "takefocus", "visual", "width", ] class Frame(Widget): def __init__( self, master: Optional[Misc] = ..., cnf: Optional[Dict[str, Any]] = ..., *, background: _Color = ..., bd: _ScreenUnits = ..., bg: _Color = ..., border: _ScreenUnits = ..., borderwidth: _ScreenUnits = ..., class_: str = ..., colormap: Union[Literal["new", ""], Misc] = ..., container: bool = ..., cursor: _Cursor = ..., height: _ScreenUnits = ..., highlightbackground: _Color = ..., highlightcolor: _Color = ..., highlightthickness: _ScreenUnits = ..., name: str = ..., padx: _ScreenUnits = ..., pady: _ScreenUnits = ..., relief: _Relief = ..., takefocus: _TakeFocusValue = ..., visual: Union[str, Tuple[str, int]] = ..., width: _ScreenUnits = ..., ) -> None: ... @overload def configure( self, cnf: Optional[Dict[str, Any]] = ..., *, background: _Color = ..., bd: _ScreenUnits = ..., bg: _Color = ..., border: _ScreenUnits = ..., borderwidth: _ScreenUnits = ..., cursor: _Cursor = ..., height: _ScreenUnits = ..., highlightbackground: _Color = ..., highlightcolor: _Color = ..., highlightthickness: _ScreenUnits = ..., padx: _ScreenUnits = ..., pady: _ScreenUnits = ..., relief: _Relief = ..., takefocus: _TakeFocusValue = ..., width: _ScreenUnits = ..., ) -> Optional[Dict[str, Tuple[str, str, str, Any, Any]]]: ... @overload def configure(self, cnf: _FrameOptionName) -> Tuple[str, str, str, Any, Any]: ... config = configure def cget(self, key: _FrameOptionName) -> Any: ... _LabelOptionName = Literal[ "activebackground", "activeforeground", "anchor", "background", "bd", "bg", "bitmap", "border", "borderwidth", "compound", "cursor", "disabledforeground", "fg", "font", "foreground", "height", "highlightbackground", "highlightcolor", "highlightthickness", "image", "justify", "padx", "pady", "relief", "state", "takefocus", "text", "textvariable", "underline", "width", "wraplength", ] class Label(Widget): def __init__( self, master: Optional[Misc] = ..., cnf: Optional[Dict[str, Any]] = ..., *, activebackground: _Color = ..., activeforeground: _Color = ..., anchor: _Anchor = ..., background: _Color = ..., bd: _ScreenUnits = ..., bg: _Color = ..., bitmap: _Bitmap = ..., border: _ScreenUnits = ..., borderwidth: _ScreenUnits = ..., compound: _Compound = ..., cursor: _Cursor = ..., disabledforeground: _Color = ..., fg: _Color = ..., font: _FontDescription = ..., foreground: _Color = ..., height: _ScreenUnits = ..., highlightbackground: _Color = ..., highlightcolor: _Color = ..., highlightthickness: _ScreenUnits = ..., image: _ImageSpec = ..., justify: Literal["left", "center", "right"] = ..., name: str = ..., padx: _ScreenUnits = ..., pady: _ScreenUnits = ..., relief: _Relief = ..., state: Literal["normal", "active", "disabled"] = ..., takefocus: _TakeFocusValue = ..., text: str = ..., textvariable: Variable = ..., underline: int = ..., width: _ScreenUnits = ..., wraplength: _ScreenUnits = ..., ) -> None: ... @overload def configure( self, cnf: Optional[Dict[str, Any]] = ..., *, activebackground: _Color = ..., activeforeground: _Color = ..., anchor: _Anchor = ..., background: _Color = ..., bd: _ScreenUnits = ..., bg: _Color = ..., bitmap: _Bitmap = ..., border: _ScreenUnits = ..., borderwidth: _ScreenUnits = ..., compound: _Compound = ..., cursor: _Cursor = ..., disabledforeground: _Color = ..., fg: _Color = ..., font: _FontDescription = ..., foreground: _Color = ..., height: _ScreenUnits = ..., highlightbackground: _Color = ..., highlightcolor: _Color = ..., highlightthickness: _ScreenUnits = ..., image: _ImageSpec = ..., justify: Literal["left", "center", "right"] = ..., padx: _ScreenUnits = ..., pady: _ScreenUnits = ..., relief: _Relief = ..., state: Literal["normal", "active", "disabled"] = ..., takefocus: _TakeFocusValue = ..., text: str = ..., textvariable: Variable = ..., underline: int = ..., width: _ScreenUnits = ..., wraplength: _ScreenUnits = ..., ) -> Optional[Dict[str, Tuple[str, str, str, Any, Any]]]: ... @overload def configure(self, cnf: _LabelOptionName) -> Tuple[str, str, str, Any, Any]: ... config = configure def cget(self, key: _LabelOptionName) -> Any: ... _ListboxOptionName = Literal[ "activestyle", "background", "bd", "bg", "border", "borderwidth", "cursor", "disabledforeground", "exportselection", "fg", "font", "foreground", "height", "highlightbackground", "highlightcolor", "highlightthickness", "justify", "listvariable", "relief", "selectbackground", "selectborderwidth", "selectforeground", "selectmode", "setgrid", "state", "takefocus", "width", "xscrollcommand", "yscrollcommand", ] class Listbox(Widget, XView, YView): def __init__( self, master: Optional[Misc] = ..., cnf: Optional[Dict[str, Any]] = ..., *, activestyle: Literal["dotbox", "none", "underline"] = ..., background: _Color = ..., bd: _ScreenUnits = ..., bg: _Color = ..., border: _ScreenUnits = ..., borderwidth: _ScreenUnits = ..., cursor: _Cursor = ..., disabledforeground: _Color = ..., exportselection: int = ..., fg: _Color = ..., font: _FontDescription = ..., foreground: _Color = ..., height: int = ..., highlightbackground: _Color = ..., highlightcolor: _Color = ..., highlightthickness: _ScreenUnits = ..., justify: Literal["left", "center", "right"] = ..., # There's no tkinter.ListVar, but seems like bare tkinter.Variable # actually works for this: # # >>> import tkinter # >>> lb = tkinter.Listbox() # >>> var = lb['listvariable'] = tkinter.Variable() # >>> var.set(['foo', 'bar', 'baz']) # >>> lb.get(0, 'end') # ('foo', 'bar', 'baz') listvariable: Variable = ..., name: str = ..., relief: _Relief = ..., selectbackground: _Color = ..., selectborderwidth: _ScreenUnits = ..., selectforeground: _Color = ..., # from listbox man page: "The value of the [selectmode] option may be # arbitrary, but the default bindings expect it to be ..." # # I have never seen anyone setting this to something else than what # "the default bindings expect", but let's support it anyway. selectmode: str = ..., setgrid: bool = ..., state: Literal["normal", "disabled"] = ..., takefocus: _TakeFocusValue = ..., width: int = ..., xscrollcommand: _XYScrollCommand = ..., yscrollcommand: _XYScrollCommand = ..., ) -> None: ... @overload def configure( self, cnf: Optional[Dict[str, Any]] = ..., *, activestyle: Literal["dotbox", "none", "underline"] = ..., background: _Color = ..., bd: _ScreenUnits = ..., bg: _Color = ..., border: _ScreenUnits = ..., borderwidth: _ScreenUnits = ..., cursor: _Cursor = ..., disabledforeground: _Color = ..., exportselection: bool = ..., fg: _Color = ..., font: _FontDescription = ..., foreground: _Color = ..., height: int = ..., highlightbackground: _Color = ..., highlightcolor: _Color = ..., highlightthickness: _ScreenUnits = ..., justify: Literal["left", "center", "right"] = ..., listvariable: Variable = ..., relief: _Relief = ..., selectbackground: _Color = ..., selectborderwidth: _ScreenUnits = ..., selectforeground: _Color = ..., selectmode: str = ..., setgrid: bool = ..., state: Literal["normal", "disabled"] = ..., takefocus: _TakeFocusValue = ..., width: int = ..., xscrollcommand: _XYScrollCommand = ..., yscrollcommand: _XYScrollCommand = ..., ) -> Optional[Dict[str, Tuple[str, str, str, Any, Any]]]: ... @overload def configure(self, cnf: _ListboxOptionName) -> Tuple[str, str, str, Any, Any]: ... config = configure def cget(self, key: _ListboxOptionName) -> Any: ... def activate(self, index): ... def bbox(self, index): ... def curselection(self): ... def delete(self, first, last: Optional[Any] = ...): ... def get(self, first, last: Optional[Any] = ...): ... def index(self, index): ... def insert(self, index, *elements): ... def nearest(self, y): ... def scan_mark(self, x, y): ... def scan_dragto(self, x, y): ... def see(self, index): ... def selection_anchor(self, index): ... select_anchor: Any def selection_clear(self, first, last: Optional[Any] = ...): ... # type: ignore select_clear: Any def selection_includes(self, index): ... select_includes: Any def selection_set(self, first, last: Optional[Any] = ...): ... select_set: Any def size(self): ... def itemcget(self, index, option): ... def itemconfigure(self, index, cnf: Optional[Any] = ..., **kw): ... itemconfig: Any _MenuOptionName = Literal[ "activebackground", "activeborderwidth", "activeforeground", "background", "bd", "bg", "border", "borderwidth", "cursor", "disabledforeground", "fg", "font", "foreground", "postcommand", "relief", "selectcolor", "takefocus", "tearoff", "tearoffcommand", "title", "type", ] class Menu(Widget): def __init__( self, master: Optional[Misc] = ..., cnf: Optional[Dict[str, Any]] = ..., *, activebackground: _Color = ..., activeborderwidth: _ScreenUnits = ..., activeforeground: _Color = ..., background: _Color = ..., bd: _ScreenUnits = ..., bg: _Color = ..., border: _ScreenUnits = ..., borderwidth: _ScreenUnits = ..., cursor: _Cursor = ..., disabledforeground: _Color = ..., fg: _Color = ..., font: _FontDescription = ..., foreground: _Color = ..., name: str = ..., postcommand: Union[Callable[[], Any], str] = ..., relief: _Relief = ..., selectcolor: _Color = ..., takefocus: _TakeFocusValue = ..., tearoff: int = ..., # I guess tearoffcommand arguments are supposed to be widget objects, # but they are widget name strings. Use nametowidget() to handle the # arguments of tearoffcommand. tearoffcommand: Union[Callable[[str, str], Any], str] = ..., title: str = ..., type: Literal["menubar", "tearoff", "normal"] = ..., ) -> None: ... @overload def configure( self, cnf: Optional[Dict[str, Any]] = ..., *, activebackground: _Color = ..., activeborderwidth: _ScreenUnits = ..., activeforeground: _Color = ..., background: _Color = ..., bd: _ScreenUnits = ..., bg: _Color = ..., border: _ScreenUnits = ..., borderwidth: _ScreenUnits = ..., cursor: _Cursor = ..., disabledforeground: _Color = ..., fg: _Color = ..., font: _FontDescription = ..., foreground: _Color = ..., postcommand: Union[Callable[[], Any], str] = ..., relief: _Relief = ..., selectcolor: _Color = ..., takefocus: _TakeFocusValue = ..., tearoff: bool = ..., tearoffcommand: Union[Callable[[str, str], Any], str] = ..., title: str = ..., type: Literal["menubar", "tearoff", "normal"] = ..., ) -> Optional[Dict[str, Tuple[str, str, str, Any, Any]]]: ... @overload def configure(self, cnf: _MenuOptionName) -> Tuple[str, str, str, Any, Any]: ... config = configure def cget(self, key: _MenuOptionName) -> Any: ... def tk_popup(self, x, y, entry: str = ...): ... def activate(self, index): ... def add(self, itemType, cnf=..., **kw): ... def add_cascade(self, cnf=..., **kw): ... def add_checkbutton(self, cnf=..., **kw): ... def add_command(self, cnf=..., **kw): ... def add_radiobutton(self, cnf=..., **kw): ... def add_separator(self, cnf=..., **kw): ... def insert(self, index, itemType, cnf=..., **kw): ... def insert_cascade(self, index, cnf=..., **kw): ... def insert_checkbutton(self, index, cnf=..., **kw): ... def insert_command(self, index, cnf=..., **kw): ... def insert_radiobutton(self, index, cnf=..., **kw): ... def insert_separator(self, index, cnf=..., **kw): ... def delete(self, index1, index2: Optional[Any] = ...): ... def entrycget(self, index, option): ... def entryconfigure(self, index, cnf: Optional[Any] = ..., **kw): ... entryconfig: Any def index(self, index): ... def invoke(self, index): ... def post(self, x, y): ... def type(self, index): ... def unpost(self): ... def xposition(self, index): ... def yposition(self, index): ... _MenubuttonOptionName = Literal[ "activebackground", "activeforeground", "anchor", "background", "bd", "bg", "bitmap", "border", "borderwidth", "compound", "cursor", "direction", "disabledforeground", "fg", "font", "foreground", "height", "highlightbackground", "highlightcolor", "highlightthickness", "image", "indicatoron", "justify", "menu", "padx", "pady", "relief", "state", "takefocus", "text", "textvariable", "underline", "width", "wraplength", ] class Menubutton(Widget): def __init__( self, master: Optional[Misc] = ..., cnf: Optional[Dict[str, Any]] = ..., *, activebackground: _Color = ..., activeforeground: _Color = ..., anchor: _Anchor = ..., background: _Color = ..., bd: _ScreenUnits = ..., bg: _Color = ..., bitmap: _Bitmap = ..., border: _ScreenUnits = ..., borderwidth: _ScreenUnits = ..., compound: _Compound = ..., cursor: _Cursor = ..., direction: Literal["above", "below", "left", "right", "flush"] = ..., disabledforeground: _Color = ..., fg: _Color = ..., font: _FontDescription = ..., foreground: _Color = ..., height: _ScreenUnits = ..., highlightbackground: _Color = ..., highlightcolor: _Color = ..., highlightthickness: _ScreenUnits = ..., image: _ImageSpec = ..., indicatoron: bool = ..., justify: Literal["left", "center", "right"] = ..., menu: Menu = ..., name: str = ..., padx: _ScreenUnits = ..., pady: _ScreenUnits = ..., relief: _Relief = ..., state: Literal["normal", "active", "disabled"] = ..., takefocus: _TakeFocusValue = ..., text: str = ..., textvariable: Variable = ..., underline: int = ..., width: _ScreenUnits = ..., wraplength: _ScreenUnits = ..., ) -> None: ... @overload def configure( self, cnf: Optional[Dict[str, Any]] = ..., *, activebackground: _Color = ..., activeforeground: _Color = ..., anchor: _Anchor = ..., background: _Color = ..., bd: _ScreenUnits = ..., bg: _Color = ..., bitmap: _Bitmap = ..., border: _ScreenUnits = ..., borderwidth: _ScreenUnits = ..., compound: _Compound = ..., cursor: _Cursor = ..., direction: Literal["above", "below", "left", "right", "flush"] = ..., disabledforeground: _Color = ..., fg: _Color = ..., font: _FontDescription = ..., foreground: _Color = ..., height: _ScreenUnits = ..., highlightbackground: _Color = ..., highlightcolor: _Color = ..., highlightthickness: _ScreenUnits = ..., image: _ImageSpec = ..., indicatoron: bool = ..., justify: Literal["left", "center", "right"] = ..., menu: Menu = ..., padx: _ScreenUnits = ..., pady: _ScreenUnits = ..., relief: _Relief = ..., state: Literal["normal", "active", "disabled"] = ..., takefocus: _TakeFocusValue = ..., text: str = ..., textvariable: Variable = ..., underline: int = ..., width: _ScreenUnits = ..., wraplength: _ScreenUnits = ..., ) -> Optional[Dict[str, Tuple[str, str, str, Any, Any]]]: ... @overload def configure(self, cnf: _MenubuttonOptionName) -> Tuple[str, str, str, Any, Any]: ... config = configure def cget(self, key: _MenubuttonOptionName) -> Any: ... _MessageOptionName = Literal[ "anchor", "aspect", "background", "bd", "bg", "border", "borderwidth", "cursor", "fg", "font", "foreground", "highlightbackground", "highlightcolor", "highlightthickness", "justify", "padx", "pady", "relief", "takefocus", "text", "textvariable", "width", ] class Message(Widget): def __init__( self, master: Optional[Misc] = ..., cnf: Optional[Dict[str, Any]] = ..., *, anchor: _Anchor = ..., aspect: int = ..., background: _Color = ..., bd: _ScreenUnits = ..., bg: _Color = ..., border: _ScreenUnits = ..., borderwidth: _ScreenUnits = ..., cursor: _Cursor = ..., fg: _Color = ..., font: _FontDescription = ..., foreground: _Color = ..., highlightbackground: _Color = ..., highlightcolor: _Color = ..., highlightthickness: _ScreenUnits = ..., justify: Literal["left", "center", "right"] = ..., name: str = ..., padx: _ScreenUnits = ..., pady: _ScreenUnits = ..., relief: _Relief = ..., takefocus: _TakeFocusValue = ..., text: str = ..., textvariable: Variable = ..., # there's width but no height width: _ScreenUnits = ..., ) -> None: ... @overload def configure( self, cnf: Optional[Dict[str, Any]] = ..., *, anchor: _Anchor = ..., aspect: int = ..., background: _Color = ..., bd: _ScreenUnits = ..., bg: _Color = ..., border: _ScreenUnits = ..., borderwidth: _ScreenUnits = ..., cursor: _Cursor = ..., fg: _Color = ..., font: _FontDescription = ..., foreground: _Color = ..., highlightbackground: _Color = ..., highlightcolor: _Color = ..., highlightthickness: _ScreenUnits = ..., justify: Literal["left", "center", "right"] = ..., padx: _ScreenUnits = ..., pady: _ScreenUnits = ..., relief: _Relief = ..., takefocus: _TakeFocusValue = ..., text: str = ..., textvariable: Variable = ..., width: _ScreenUnits = ..., ) -> Optional[Dict[str, Tuple[str, str, str, Any, Any]]]: ... @overload def configure(self, cnf: _MessageOptionName) -> Tuple[str, str, str, Any, Any]: ... config = configure def cget(self, key: _MessageOptionName) -> Any: ... _RadiobuttonOptionName = Literal[ "activebackground", "activeforeground", "anchor", "background", "bd", "bg", "bitmap", "border", "borderwidth", "command", "compound", "cursor", "disabledforeground", "fg", "font", "foreground", "height", "highlightbackground", "highlightcolor", "highlightthickness", "image", "indicatoron", "justify", "offrelief", "overrelief", "padx", "pady", "relief", "selectcolor", "selectimage", "state", "takefocus", "text", "textvariable", "tristateimage", "tristatevalue", "underline", "value", "variable", "width", "wraplength", ] class Radiobutton(Widget): def __init__( self, master: Optional[Misc] = ..., cnf: Optional[Dict[str, Any]] = ..., *, activebackground: _Color = ..., activeforeground: _Color = ..., anchor: _Anchor = ..., background: _Color = ..., bd: _ScreenUnits = ..., bg: _Color = ..., bitmap: _Bitmap = ..., border: _ScreenUnits = ..., borderwidth: _ScreenUnits = ..., command: _ButtonCommand = ..., compound: _Compound = ..., cursor: _Cursor = ..., disabledforeground: _Color = ..., fg: _Color = ..., font: _FontDescription = ..., foreground: _Color = ..., height: _ScreenUnits = ..., highlightbackground: _Color = ..., highlightcolor: _Color = ..., highlightthickness: _ScreenUnits = ..., image: _ImageSpec = ..., indicatoron: bool = ..., justify: Literal["left", "center", "right"] = ..., name: str = ..., offrelief: _Relief = ..., overrelief: _Relief = ..., padx: _ScreenUnits = ..., pady: _ScreenUnits = ..., relief: _Relief = ..., selectcolor: _Color = ..., selectimage: _ImageSpec = ..., state: Literal["normal", "active", "disabled"] = ..., takefocus: _TakeFocusValue = ..., text: str = ..., textvariable: Variable = ..., tristateimage: _ImageSpec = ..., tristatevalue: Any = ..., underline: int = ..., value: Any = ..., variable: Union[Variable, Literal[""]] = ..., width: _ScreenUnits = ..., wraplength: _ScreenUnits = ..., ) -> None: ... @overload def configure( self, cnf: Optional[Dict[str, Any]] = ..., *, activebackground: _Color = ..., activeforeground: _Color = ..., anchor: _Anchor = ..., background: _Color = ..., bd: _ScreenUnits = ..., bg: _Color = ..., bitmap: _Bitmap = ..., border: _ScreenUnits = ..., borderwidth: _ScreenUnits = ..., command: _ButtonCommand = ..., compound: _Compound = ..., cursor: _Cursor = ..., disabledforeground: _Color = ..., fg: _Color = ..., font: _FontDescription = ..., foreground: _Color = ..., height: _ScreenUnits = ..., highlightbackground: _Color = ..., highlightcolor: _Color = ..., highlightthickness: _ScreenUnits = ..., image: _ImageSpec = ..., indicatoron: bool = ..., justify: Literal["left", "center", "right"] = ..., offrelief: _Relief = ..., overrelief: _Relief = ..., padx: _ScreenUnits = ..., pady: _ScreenUnits = ..., relief: _Relief = ..., selectcolor: _Color = ..., selectimage: _ImageSpec = ..., state: Literal["normal", "active", "disabled"] = ..., takefocus: _TakeFocusValue = ..., text: str = ..., textvariable: Variable = ..., tristateimage: _ImageSpec = ..., tristatevalue: Any = ..., underline: int = ..., value: Any = ..., variable: Union[Variable, Literal[""]] = ..., width: _ScreenUnits = ..., wraplength: _ScreenUnits = ..., ) -> Optional[Dict[str, Tuple[str, str, str, Any, Any]]]: ... @overload def configure(self, cnf: _RadiobuttonOptionName) -> Tuple[str, str, str, Any, Any]: ... config = configure def cget(self, key: _RadiobuttonOptionName) -> Any: ... def deselect(self): ... def flash(self): ... def invoke(self): ... def select(self): ... _ScaleOptionName = Literal[ "activebackground", "background", "bd", "bg", "bigincrement", "border", "borderwidth", "command", "cursor", "digits", "fg", "font", "foreground", "from", "highlightbackground", "highlightcolor", "highlightthickness", "label", "length", "orient", "relief", "repeatdelay", "repeatinterval", "resolution", "showvalue", "sliderlength", "sliderrelief", "state", "takefocus", "tickinterval", "to", "troughcolor", "variable", "width", ] class Scale(Widget): def __init__( self, master: Optional[Misc] = ..., cnf: Optional[Dict[str, Any]] = ..., *, activebackground: _Color = ..., background: _Color = ..., bd: _ScreenUnits = ..., bg: _Color = ..., bigincrement: float = ..., border: _ScreenUnits = ..., borderwidth: _ScreenUnits = ..., # don't know why the callback gets string instead of float command: Union[str, Callable[[str], Any]] = ..., cursor: _Cursor = ..., digits: int = ..., fg: _Color = ..., font: _FontDescription = ..., foreground: _Color = ..., from_: float = ..., highlightbackground: _Color = ..., highlightcolor: _Color = ..., highlightthickness: _ScreenUnits = ..., label: str = ..., length: _ScreenUnits = ..., name: str = ..., orient: Literal["horizontal", "vertical"] = ..., relief: _Relief = ..., repeatdelay: int = ..., repeatinterval: int = ..., resolution: float = ..., showvalue: bool = ..., sliderlength: _ScreenUnits = ..., sliderrelief: _Relief = ..., state: Literal["normal", "active", "disabled"] = ..., takefocus: _TakeFocusValue = ..., tickinterval: float = ..., to: float = ..., troughcolor: _Color = ..., variable: DoubleVar = ..., width: _ScreenUnits = ..., ) -> None: ... @overload def configure( self, cnf: Optional[Dict[str, Any]] = ..., *, activebackground: _Color = ..., background: _Color = ..., bd: _ScreenUnits = ..., bg: _Color = ..., bigincrement: float = ..., border: _ScreenUnits = ..., borderwidth: _ScreenUnits = ..., command: Union[str, Callable[[str], Any]] = ..., cursor: _Cursor = ..., digits: int = ..., fg: _Color = ..., font: _FontDescription = ..., foreground: _Color = ..., from_: float = ..., highlightbackground: _Color = ..., highlightcolor: _Color = ..., highlightthickness: _ScreenUnits = ..., label: str = ..., length: _ScreenUnits = ..., orient: Literal["horizontal", "vertical"] = ..., relief: _Relief = ..., repeatdelay: int = ..., repeatinterval: int = ..., resolution: float = ..., showvalue: bool = ..., sliderlength: _ScreenUnits = ..., sliderrelief: _Relief = ..., state: Literal["normal", "active", "disabled"] = ..., takefocus: _TakeFocusValue = ..., tickinterval: float = ..., to: float = ..., troughcolor: _Color = ..., variable: DoubleVar = ..., width: _ScreenUnits = ..., ) -> Optional[Dict[str, Tuple[str, str, str, Any, Any]]]: ... @overload def configure(self, cnf: _ScaleOptionName) -> Tuple[str, str, str, Any, Any]: ... config = configure def cget(self, key: _ScaleOptionName) -> Any: ... def get(self): ... def set(self, value): ... def coords(self, value: Optional[Any] = ...): ... def identify(self, x, y): ... _ScrollbarOptionName = Literal[ "activebackground", "activerelief", "background", "bd", "bg", "border", "borderwidth", "command", "cursor", "elementborderwidth", "highlightbackground", "highlightcolor", "highlightthickness", "jump", "orient", "relief", "repeatdelay", "repeatinterval", "takefocus", "troughcolor", "width", ] class Scrollbar(Widget): def __init__( self, master: Optional[Misc] = ..., cnf: Optional[Dict[str, Any]] = ..., *, activebackground: _Color = ..., activerelief: _Relief = ..., background: _Color = ..., bd: _ScreenUnits = ..., bg: _Color = ..., border: _ScreenUnits = ..., borderwidth: _ScreenUnits = ..., # There are many ways how the command may get called. Search for # 'SCROLLING COMMANDS' in scrollbar man page. There doesn't seem to # be any way to specify an overloaded callback function, so we say # that it can take any args while it can't in reality. command: Union[Callable[..., Optional[Tuple[float, float]]], str] = ..., cursor: _Cursor = ..., elementborderwidth: _ScreenUnits = ..., highlightbackground: _Color = ..., highlightcolor: _Color = ..., highlightthickness: _ScreenUnits = ..., jump: bool = ..., name: str = ..., orient: Literal["horizontal", "vertical"] = ..., relief: _Relief = ..., repeatdelay: int = ..., repeatinterval: int = ..., takefocus: _TakeFocusValue = ..., troughcolor: _Color = ..., width: _ScreenUnits = ..., ) -> None: ... @overload def configure( self, cnf: Optional[Dict[str, Any]] = ..., *, activebackground: _Color = ..., activerelief: _Relief = ..., background: _Color = ..., bd: _ScreenUnits = ..., bg: _Color = ..., border: _ScreenUnits = ..., borderwidth: _ScreenUnits = ..., command: Union[Callable[..., Optional[Tuple[float, float]]], str] = ..., cursor: _Cursor = ..., elementborderwidth: _ScreenUnits = ..., highlightbackground: _Color = ..., highlightcolor: _Color = ..., highlightthickness: _ScreenUnits = ..., jump: bool = ..., orient: Literal["horizontal", "vertical"] = ..., relief: _Relief = ..., repeatdelay: int = ..., repeatinterval: int = ..., takefocus: _TakeFocusValue = ..., troughcolor: _Color = ..., width: _ScreenUnits = ..., ) -> Optional[Dict[str, Tuple[str, str, str, Any, Any]]]: ... @overload def configure(self, cnf: _ScrollbarOptionName) -> Tuple[str, str, str, Any, Any]: ... config = configure def cget(self, key: _ScrollbarOptionName) -> Any: ... def activate(self, index: Optional[Any] = ...): ... def delta(self, deltax, deltay): ... def fraction(self, x, y): ... def identify(self, x, y): ... def get(self): ... def set(self, first, last): ... _TextIndex = Union[_tkinter.Tcl_Obj, str, float] _TextOptionName = Literal[ "autoseparators", "background", "bd", "bg", "blockcursor", "border", "borderwidth", "cursor", "endline", "exportselection", "fg", "font", "foreground", "height", "highlightbackground", "highlightcolor", "highlightthickness", "inactiveselectbackground", "insertbackground", "insertborderwidth", "insertofftime", "insertontime", "insertunfocussed", "insertwidth", "maxundo", "padx", "pady", "relief", "selectbackground", "selectborderwidth", "selectforeground", "setgrid", "spacing1", "spacing2", "spacing3", "startline", "state", "tabs", "tabstyle", "takefocus", "undo", "width", "wrap", "xscrollcommand", "yscrollcommand", ] class Text(Widget, XView, YView): def __init__( self, master: Optional[Misc] = ..., cnf: Optional[Dict[str, Any]] = ..., *, autoseparators: bool = ..., background: _Color = ..., bd: _ScreenUnits = ..., bg: _Color = ..., blockcursor: bool = ..., border: _ScreenUnits = ..., borderwidth: _ScreenUnits = ..., cursor: _Cursor = ..., endline: Union[int, Literal[""]] = ..., exportselection: bool = ..., fg: _Color = ..., font: _FontDescription = ..., foreground: _Color = ..., # width is always int, but height is allowed to be ScreenUnits. # This doesn't make any sense to me, and this isn't documented. # The docs seem to say that both should be integers. height: _ScreenUnits = ..., highlightbackground: _Color = ..., highlightcolor: _Color = ..., highlightthickness: _ScreenUnits = ..., inactiveselectbackground: _Color = ..., insertbackground: _Color = ..., insertborderwidth: _ScreenUnits = ..., insertofftime: int = ..., insertontime: int = ..., insertunfocussed: Literal["none", "hollow", "solid"] = ..., insertwidth: _ScreenUnits = ..., maxundo: int = ..., name: str = ..., padx: _ScreenUnits = ..., pady: _ScreenUnits = ..., relief: _Relief = ..., selectbackground: _Color = ..., selectborderwidth: _ScreenUnits = ..., selectforeground: _Color = ..., setgrid: bool = ..., spacing1: _ScreenUnits = ..., spacing2: _ScreenUnits = ..., spacing3: _ScreenUnits = ..., startline: Union[int, Literal[""]] = ..., state: Literal["normal", "disabled"] = ..., # Literal inside Tuple doesn't actually work tabs: Union[_ScreenUnits, str, Tuple[Union[_ScreenUnits, str], ...]] = ..., tabstyle: Literal["tabular", "wordprocessor"] = ..., takefocus: _TakeFocusValue = ..., undo: bool = ..., width: int = ..., wrap: Literal["none", "char", "word"] = ..., xscrollcommand: _XYScrollCommand = ..., yscrollcommand: _XYScrollCommand = ..., ) -> None: ... @overload def configure( self, cnf: Optional[Dict[str, Any]] = ..., *, autoseparators: bool = ..., background: _Color = ..., bd: _ScreenUnits = ..., bg: _Color = ..., blockcursor: bool = ..., border: _ScreenUnits = ..., borderwidth: _ScreenUnits = ..., cursor: _Cursor = ..., endline: Union[int, Literal[""]] = ..., exportselection: bool = ..., fg: _Color = ..., font: _FontDescription = ..., foreground: _Color = ..., height: _ScreenUnits = ..., highlightbackground: _Color = ..., highlightcolor: _Color = ..., highlightthickness: _ScreenUnits = ..., inactiveselectbackground: _Color = ..., insertbackground: _Color = ..., insertborderwidth: _ScreenUnits = ..., insertofftime: int = ..., insertontime: int = ..., insertunfocussed: Literal["none", "hollow", "solid"] = ..., insertwidth: _ScreenUnits = ..., maxundo: int = ..., padx: _ScreenUnits = ..., pady: _ScreenUnits = ..., relief: _Relief = ..., selectbackground: _Color = ..., selectborderwidth: _ScreenUnits = ..., selectforeground: _Color = ..., setgrid: bool = ..., spacing1: _ScreenUnits = ..., spacing2: _ScreenUnits = ..., spacing3: _ScreenUnits = ..., startline: Union[int, Literal[""]] = ..., state: Literal["normal", "disabled"] = ..., tabs: Union[_ScreenUnits, str, Tuple[Union[_ScreenUnits, str], ...]] = ..., tabstyle: Literal["tabular", "wordprocessor"] = ..., takefocus: _TakeFocusValue = ..., undo: bool = ..., width: int = ..., wrap: Literal["none", "char", "word"] = ..., xscrollcommand: _XYScrollCommand = ..., yscrollcommand: _XYScrollCommand = ..., ) -> Optional[Dict[str, Tuple[str, str, str, Any, Any]]]: ... @overload def configure(self, cnf: _TextOptionName) -> Tuple[str, str, str, Any, Any]: ... config = configure def cget(self, key: _TextOptionName) -> Any: ... def bbox(self, index: _TextIndex) -> Optional[Tuple[int, int, int, int]]: ... def compare(self, index1: _TextIndex, op: Literal["<", "<=", "==", ">=", ">", "!="], index2: _TextIndex) -> bool: ... def count(self, index1, index2, *args): ... # TODO @overload def debug(self, boolean: None = ...) -> bool: ... @overload def debug(self, boolean: bool) -> None: ... def delete(self, index1: _TextIndex, index2: Optional[_TextIndex] = ...) -> None: ... def dlineinfo(self, index: _TextIndex) -> Optional[Tuple[int, int, int, int, int]]: ... @overload def dump( self, index1: _TextIndex, index2: Optional[_TextIndex] = ..., command: None = ..., *, all: bool = ..., image: bool = ..., mark: bool = ..., tag: bool = ..., text: bool = ..., window: bool = ..., ) -> List[Tuple[str, str, str]]: ... @overload def dump( self, index1: _TextIndex, index2: Optional[_TextIndex], command: Union[Callable[[str, str, str], Any], str], *, all: bool = ..., image: bool = ..., mark: bool = ..., tag: bool = ..., text: bool = ..., window: bool = ..., ) -> None: ... @overload def dump( self, index1: _TextIndex, index2: Optional[_TextIndex] = ..., *, command: Union[Callable[[str, str, str], Any], str], all: bool = ..., image: bool = ..., mark: bool = ..., tag: bool = ..., text: bool = ..., window: bool = ..., ) -> None: ... def edit(self, *args): ... # docstring says "Internal method" @overload def edit_modified(self, arg: None = ...) -> bool: ... # actually returns Literal[0, 1] @overload def edit_modified(self, arg: bool) -> None: ... # actually returns empty string def edit_redo(self) -> None: ... # actually returns empty string def edit_reset(self) -> None: ... # actually returns empty string def edit_separator(self) -> None: ... # actually returns empty string def edit_undo(self) -> None: ... # actually returns empty string def get(self, index1: _TextIndex, index2: Optional[_TextIndex] = ...) -> str: ... # TODO: image_* methods def image_cget(self, index, option): ... def image_configure(self, index, cnf: Optional[Any] = ..., **kw): ... def image_create(self, index, cnf=..., **kw): ... def image_names(self): ... def index(self, index: _TextIndex) -> str: ... def insert(self, index: _TextIndex, chars: str, *args: Union[_TextIndex, str, _TkinterSequence[str]]) -> None: ... @overload def mark_gravity(self, markName: str, direction: None = ...) -> Literal["left", "right"]: ... @overload def mark_gravity(self, markName: str, direction: Literal["left", "right"]) -> None: ... # actually returns empty string def mark_names(self) -> Tuple[str, ...]: ... def mark_set(self, markName: str, index: _TextIndex) -> None: ... def mark_unset(self, *markNames: str) -> None: ... def mark_next(self, index: _TextIndex) -> Optional[str]: ... def mark_previous(self, index: _TextIndex): ... # **kw of peer_create is same as the kwargs of Text.__init__ def peer_create(self, newPathName: Union[str, Text], cnf: Dict[str, Any] = ..., **kw: Any) -> None: ... def peer_names(self) -> Tuple[_tkinter.Tcl_Obj, ...]: ... def replace( self, index1: _TextIndex, index2: _TextIndex, chars: str, *args: Union[_TextIndex, str, _TkinterSequence[str]] ) -> None: ... def scan_mark(self, x: int, y: int) -> None: ... def scan_dragto(self, x: int, y: int) -> None: ... def search( self, pattern: str, index: _TextIndex, stopindex: Optional[_TextIndex] = ..., forwards: Optional[bool] = ..., backwards: Optional[bool] = ..., exact: Optional[bool] = ..., regexp: Optional[bool] = ..., nocase: Optional[bool] = ..., count: Optional[Variable] = ..., elide: Optional[bool] = ..., ) -> str: ... # returns empty string for not found def see(self, index: _TextIndex) -> None: ... def tag_add(self, tagName: str, index1: _TextIndex, *args: _TextIndex) -> None: ... # tag_bind stuff is very similar to Canvas @overload def tag_bind( self, tagName: str, sequence: Optional[str], func: Optional[Callable[[Event[Text]], Optional[Literal["break"]]]], add: Optional[bool] = ..., ) -> str: ... @overload def tag_bind(self, tagName: str, sequence: Optional[str], func: str, add: Optional[bool] = ...) -> None: ... def tag_unbind(self, tagName: str, sequence: str, funcid: Optional[str] = ...) -> None: ... # allowing any string for cget instead of just Literals because there's no other way to look up tag options def tag_cget(self, tagName: str, option: str) -> Any: ... @overload def tag_configure( self, tagName: str, cnf: Optional[Dict[str, Any]] = ..., *, background: _Color = ..., bgstipple: _Bitmap = ..., borderwidth: _ScreenUnits = ..., border: _ScreenUnits = ..., # alias for borderwidth elide: bool = ..., fgstipple: _Bitmap = ..., font: _FontDescription = ..., foreground: _Color = ..., justify: Literal["left", "right", "center"] = ..., lmargin1: _ScreenUnits = ..., lmargin2: _ScreenUnits = ..., lmargincolor: _Color = ..., offset: _ScreenUnits = ..., overstrike: bool = ..., overstrikefg: _Color = ..., relief: _Relief = ..., rmargin: _ScreenUnits = ..., rmargincolor: _Color = ..., selectbackground: _Color = ..., selectforeground: _Color = ..., spacing1: _ScreenUnits = ..., spacing2: _ScreenUnits = ..., spacing3: _ScreenUnits = ..., tabs: Any = ..., # the exact type is kind of complicated, see manual page tabstyle: Literal["tabular", "wordprocessor"] = ..., underline: bool = ..., underlinefg: _Color = ..., wrap: Literal["none", "char", "word"] = ..., # be careful with "none" vs None ) -> Optional[Dict[str, Tuple[str, str, str, Any, Any]]]: ... @overload def tag_configure(self, tagName: str, cnf: str) -> Tuple[str, str, str, Any, Any]: ... tag_config = tag_configure def tag_delete(self, __first_tag_name: str, *tagNames: str) -> None: ... # error if no tag names given def tag_lower(self, tagName: str, belowThis: Optional[str] = ...) -> None: ... def tag_names(self, index: Optional[_TextIndex] = ...) -> Tuple[str, ...]: ... def tag_nextrange( self, tagName: str, index1: _TextIndex, index2: Optional[_TextIndex] = ... ) -> Union[Tuple[str, str], Tuple[()]]: ... def tag_prevrange( self, tagName: str, index1: _TextIndex, index2: Optional[_TextIndex] = ... ) -> Union[Tuple[str, str], Tuple[()]]: ... def tag_raise(self, tagName: str, aboveThis: Optional[str] = ...) -> None: ... def tag_ranges(self, tagName: str) -> Tuple[_tkinter.Tcl_Obj, ...]: ... # tag_remove and tag_delete are different def tag_remove(self, tagName: str, index1: _TextIndex, index2: Optional[_TextIndex] = ...) -> None: ... # TODO: window_* methods def window_cget(self, index, option): ... def window_configure(self, index, cnf: Optional[Any] = ..., **kw): ... window_config = window_configure def window_create(self, index, cnf=..., **kw): ... def window_names(self): ... def yview_pickplace(self, *what): ... # deprecated class _setit: def __init__(self, var, value, callback: Optional[Any] = ...): ... def __call__(self, *args): ... # manual page: tk_optionMenu class OptionMenu(Menubutton): widgetName: Any menuname: Any def __init__( # differs from other widgets self, master: Optional[Misc], variable: StringVar, value: str, *values: str, # kwarg only from now on command: Optional[Callable[[StringVar], Any]] = ..., ) -> None: ... # configure, config, cget are inherited from Menubutton # destroy and __getitem__ are overrided, signature does not change class _Image(Protocol): tk: _tkinter.TkappType def __del__(self) -> None: ... def height(self) -> int: ... def width(self) -> int: ... class Image: name: Any tk: _tkinter.TkappType def __init__( self, imgtype, name: Optional[Any] = ..., cnf=..., master: Optional[Union[Misc, _tkinter.TkappType]] = ..., **kw ): ... def __del__(self): ... def __setitem__(self, key, value): ... def __getitem__(self, key): ... def configure(self, **kw): ... config: Any def height(self): ... def type(self): ... def width(self): ... class PhotoImage(Image): def __init__(self, name: Optional[Any] = ..., cnf=..., master: Optional[Any] = ..., **kw): ... def blank(self): ... def cget(self, option): ... def __getitem__(self, key): ... def copy(self): ... def zoom(self, x, y: str = ...): ... def subsample(self, x, y: str = ...): ... def get(self, x, y): ... def put(self, data, to: Optional[Any] = ...): ... def write(self, filename, format: Optional[Any] = ..., from_coords: Optional[Any] = ...): ... if sys.version_info >= (3, 8): def transparency_get(self, x: int, y: int) -> bool: ... def transparency_set(self, x: int, y: int, boolean: bool) -> None: ... class BitmapImage(Image): def __init__(self, name: Optional[Any] = ..., cnf=..., master: Optional[Any] = ..., **kw): ... def image_names(): ... def image_types(): ... _SpinboxOptionName = Literal[ "activebackground", "background", "bd", "bg", "border", "borderwidth", "buttonbackground", "buttoncursor", "buttondownrelief", "buttonuprelief", "command", "cursor", "disabledbackground", "disabledforeground", "exportselection", "fg", "font", "foreground", "format", "from", "highlightbackground", "highlightcolor", "highlightthickness", "increment", "insertbackground", "insertborderwidth", "insertofftime", "insertontime", "insertwidth", "invalidcommand", "invcmd", "justify", "readonlybackground", "relief", "repeatdelay", "repeatinterval", "selectbackground", "selectborderwidth", "selectforeground", "state", "takefocus", "textvariable", "to", "validate", "validatecommand", "vcmd", "values", "width", "wrap", "xscrollcommand", ] class Spinbox(Widget, XView): def __init__( self, master: Optional[Misc] = ..., cnf: Optional[Dict[str, Any]] = ..., *, activebackground: _Color = ..., background: _Color = ..., bd: _ScreenUnits = ..., bg: _Color = ..., border: _ScreenUnits = ..., borderwidth: _ScreenUnits = ..., buttonbackground: _Color = ..., buttoncursor: _Cursor = ..., buttondownrelief: _Relief = ..., buttonuprelief: _Relief = ..., # percent substitutions don't seem to be supported, it's similar to Entry's validion stuff command: Union[Callable[[], Any], str, _TkinterSequence[str]] = ..., cursor: _Cursor = ..., disabledbackground: _Color = ..., disabledforeground: _Color = ..., exportselection: bool = ..., fg: _Color = ..., font: _FontDescription = ..., foreground: _Color = ..., format: str = ..., from_: float = ..., highlightbackground: _Color = ..., highlightcolor: _Color = ..., highlightthickness: _ScreenUnits = ..., increment: float = ..., insertbackground: _Color = ..., insertborderwidth: _ScreenUnits = ..., insertofftime: int = ..., insertontime: int = ..., insertwidth: _ScreenUnits = ..., invalidcommand: _EntryValidateCommand = ..., invcmd: _EntryValidateCommand = ..., justify: Literal["left", "center", "right"] = ..., name: str = ..., readonlybackground: _Color = ..., relief: _Relief = ..., repeatdelay: int = ..., repeatinterval: int = ..., selectbackground: _Color = ..., selectborderwidth: _ScreenUnits = ..., selectforeground: _Color = ..., state: Literal["normal", "disabled", "readonly"] = ..., takefocus: _TakeFocusValue = ..., textvariable: Variable = ..., to: float = ..., validate: Literal["none", "focus", "focusin", "focusout", "key", "all"] = ..., validatecommand: _EntryValidateCommand = ..., vcmd: _EntryValidateCommand = ..., values: _TkinterSequence[str] = ..., width: int = ..., wrap: bool = ..., xscrollcommand: _XYScrollCommand = ..., ) -> None: ... @overload def configure( self, cnf: Optional[Dict[str, Any]] = ..., *, activebackground: _Color = ..., background: _Color = ..., bd: _ScreenUnits = ..., bg: _Color = ..., border: _ScreenUnits = ..., borderwidth: _ScreenUnits = ..., buttonbackground: _Color = ..., buttoncursor: _Cursor = ..., buttondownrelief: _Relief = ..., buttonuprelief: _Relief = ..., command: Union[Callable[[], Any], str, _TkinterSequence[str]] = ..., cursor: _Cursor = ..., disabledbackground: _Color = ..., disabledforeground: _Color = ..., exportselection: bool = ..., fg: _Color = ..., font: _FontDescription = ..., foreground: _Color = ..., format: str = ..., from_: float = ..., highlightbackground: _Color = ..., highlightcolor: _Color = ..., highlightthickness: _ScreenUnits = ..., increment: float = ..., insertbackground: _Color = ..., insertborderwidth: _ScreenUnits = ..., insertofftime: int = ..., insertontime: int = ..., insertwidth: _ScreenUnits = ..., invalidcommand: _EntryValidateCommand = ..., invcmd: _EntryValidateCommand = ..., justify: Literal["left", "center", "right"] = ..., readonlybackground: _Color = ..., relief: _Relief = ..., repeatdelay: int = ..., repeatinterval: int = ..., selectbackground: _Color = ..., selectborderwidth: _ScreenUnits = ..., selectforeground: _Color = ..., state: Literal["normal", "disabled", "readonly"] = ..., takefocus: _TakeFocusValue = ..., textvariable: Variable = ..., to: float = ..., validate: Literal["none", "focus", "focusin", "focusout", "key", "all"] = ..., validatecommand: _EntryValidateCommand = ..., vcmd: _EntryValidateCommand = ..., values: _TkinterSequence[str] = ..., width: int = ..., wrap: bool = ..., xscrollcommand: _XYScrollCommand = ..., ) -> Optional[Dict[str, Tuple[str, str, str, Any, Any]]]: ... @overload def configure(self, cnf: _SpinboxOptionName) -> Tuple[str, str, str, Any, Any]: ... config = configure def cget(self, key: _SpinboxOptionName) -> Any: ... def bbox(self, index): ... def delete(self, first, last: Optional[Any] = ...): ... def get(self): ... def icursor(self, index): ... def identify(self, x, y): ... def index(self, index): ... def insert(self, index, s): ... def invoke(self, element): ... def scan(self, *args): ... def scan_mark(self, x): ... def scan_dragto(self, x): ... def selection(self, *args: Any) -> Tuple[int, ...]: ... def selection_adjust(self, index): ... def selection_clear(self): ... def selection_element(self, element: Optional[Any] = ...): ... if sys.version_info >= (3, 8): def selection_from(self, index: int) -> None: ... def selection_present(self) -> None: ... def selection_range(self, start: int, end: int) -> None: ... def selection_to(self, index: int) -> None: ... _LabelFrameOptionName = Literal[ "background", "bd", "bg", "border", "borderwidth", "class", "colormap", "container", "cursor", "fg", "font", "foreground", "height", "highlightbackground", "highlightcolor", "highlightthickness", "labelanchor", "labelwidget", "padx", "pady", "relief", "takefocus", "text", "visual", "width", ] class LabelFrame(Widget): def __init__( self, master: Optional[Misc] = ..., cnf: Optional[Dict[str, Any]] = ..., *, background: _Color = ..., bd: _ScreenUnits = ..., bg: _Color = ..., border: _ScreenUnits = ..., borderwidth: _ScreenUnits = ..., class_: str = ..., colormap: Union[Literal["new", ""], Misc] = ..., container: bool = ..., # undocumented cursor: _Cursor = ..., fg: _Color = ..., font: _FontDescription = ..., foreground: _Color = ..., height: _ScreenUnits = ..., highlightbackground: _Color = ..., highlightcolor: _Color = ..., highlightthickness: _ScreenUnits = ..., # 'ne' and 'en' are valid labelanchors, but only 'ne' is a valid _Anchor. labelanchor: Literal["nw", "n", "ne", "en", "e", "es", "se", "s", "sw", "ws", "w", "wn"] = ..., labelwidget: Misc = ..., name: str = ..., padx: _ScreenUnits = ..., pady: _ScreenUnits = ..., relief: _Relief = ..., takefocus: _TakeFocusValue = ..., text: str = ..., visual: Union[str, Tuple[str, int]] = ..., width: _ScreenUnits = ..., ) -> None: ... @overload def configure( self, cnf: Optional[Dict[str, Any]] = ..., *, background: _Color = ..., bd: _ScreenUnits = ..., bg: _Color = ..., border: _ScreenUnits = ..., borderwidth: _ScreenUnits = ..., cursor: _Cursor = ..., fg: _Color = ..., font: _FontDescription = ..., foreground: _Color = ..., height: _ScreenUnits = ..., highlightbackground: _Color = ..., highlightcolor: _Color = ..., highlightthickness: _ScreenUnits = ..., labelanchor: Literal["nw", "n", "ne", "en", "e", "es", "se", "s", "sw", "ws", "w", "wn"] = ..., labelwidget: Misc = ..., padx: _ScreenUnits = ..., pady: _ScreenUnits = ..., relief: _Relief = ..., takefocus: _TakeFocusValue = ..., text: str = ..., width: _ScreenUnits = ..., ) -> Optional[Dict[str, Tuple[str, str, str, Any, Any]]]: ... @overload def configure(self, cnf: _LabelFrameOptionName) -> Tuple[str, str, str, Any, Any]: ... config = configure def cget(self, key: _LabelFrameOptionName) -> Any: ... _PanedWindowOptionName = Literal[ "background", "bd", "bg", "border", "borderwidth", "cursor", "handlepad", "handlesize", "height", "opaqueresize", "orient", "proxybackground", "proxyborderwidth", "proxyrelief", "relief", "sashcursor", "sashpad", "sashrelief", "sashwidth", "showhandle", "width", ] class PanedWindow(Widget): def __init__( self, master: Optional[Misc] = ..., cnf: Optional[Dict[str, Any]] = ..., *, background: _Color = ..., bd: _ScreenUnits = ..., bg: _Color = ..., border: _ScreenUnits = ..., borderwidth: _ScreenUnits = ..., cursor: _Cursor = ..., handlepad: _ScreenUnits = ..., handlesize: _ScreenUnits = ..., height: _ScreenUnits = ..., name: str = ..., opaqueresize: bool = ..., orient: Literal["horizontal", "vertical"] = ..., proxybackground: _Color = ..., proxyborderwidth: _ScreenUnits = ..., proxyrelief: _Relief = ..., relief: _Relief = ..., sashcursor: _Cursor = ..., sashpad: _ScreenUnits = ..., sashrelief: _Relief = ..., sashwidth: _ScreenUnits = ..., showhandle: bool = ..., width: _ScreenUnits = ..., ) -> None: ... @overload def configure( self, cnf: Optional[Dict[str, Any]] = ..., *, background: _Color = ..., bd: _ScreenUnits = ..., bg: _Color = ..., border: _ScreenUnits = ..., borderwidth: _ScreenUnits = ..., cursor: _Cursor = ..., handlepad: _ScreenUnits = ..., handlesize: _ScreenUnits = ..., height: _ScreenUnits = ..., opaqueresize: bool = ..., orient: Literal["horizontal", "vertical"] = ..., proxybackground: _Color = ..., proxyborderwidth: _ScreenUnits = ..., proxyrelief: _Relief = ..., relief: _Relief = ..., sashcursor: _Cursor = ..., sashpad: _ScreenUnits = ..., sashrelief: _Relief = ..., sashwidth: _ScreenUnits = ..., showhandle: bool = ..., width: _ScreenUnits = ..., ) -> Optional[Dict[str, Tuple[str, str, str, Any, Any]]]: ... @overload def configure(self, cnf: _PanedWindowOptionName) -> Tuple[str, str, str, Any, Any]: ... config = configure def cget(self, key: _PanedWindowOptionName) -> Any: ... def add(self, child, **kw): ... def remove(self, child): ... forget: Any def identify(self, x, y): ... def proxy(self, *args): ... def proxy_coord(self): ... def proxy_forget(self): ... def proxy_place(self, x, y): ... def sash(self, *args): ... def sash_coord(self, index): ... def sash_mark(self, index): ... def sash_place(self, index, x, y): ... def panecget(self, child, option): ... def paneconfigure(self, tagOrId, cnf: Optional[Any] = ..., **kw): ... paneconfig: Any def panes(self): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/tkinter/commondialog.pyi0000664000175000017500000000042500000000000025770 0ustar00davedave00000000000000from typing import Any, Mapping, Optional class Dialog: command: Optional[Any] = ... master: Optional[Any] = ... options: Mapping[str, Any] = ... def __init__(self, master: Optional[Any] = ..., **options) -> None: ... def show(self, **options) -> Any: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/tkinter/constants.pyi0000664000175000017500000000353600000000000025342 0ustar00davedave00000000000000from typing_extensions import Literal # These are not actually bools. See #4669 NO: bool YES: bool TRUE: bool FALSE: bool ON: bool OFF: bool N: Literal["n"] S: Literal["s"] W: Literal["w"] E: Literal["e"] NW: Literal["nw"] SW: Literal["sw"] NE: Literal["ne"] SE: Literal["se"] NS: Literal["ns"] EW: Literal["ew"] NSEW: Literal["nsew"] CENTER: Literal["center"] NONE: Literal["none"] X: Literal["x"] Y: Literal["y"] BOTH: Literal["both"] LEFT: Literal["left"] TOP: Literal["top"] RIGHT: Literal["right"] BOTTOM: Literal["bottom"] RAISED: Literal["raised"] SUNKEN: Literal["sunken"] FLAT: Literal["flat"] RIDGE: Literal["ridge"] GROOVE: Literal["groove"] SOLID: Literal["solid"] HORIZONTAL: Literal["horizontal"] VERTICAL: Literal["vertical"] NUMERIC: Literal["numeric"] CHAR: Literal["char"] WORD: Literal["word"] BASELINE: Literal["baseline"] INSIDE: Literal["inside"] OUTSIDE: Literal["outside"] SEL: Literal["sel"] SEL_FIRST: Literal["sel.first"] SEL_LAST: Literal["sel.last"] END: Literal["end"] INSERT: Literal["insert"] CURRENT: Literal["current"] ANCHOR: Literal["anchor"] ALL: Literal["all"] NORMAL: Literal["normal"] DISABLED: Literal["disabled"] ACTIVE: Literal["active"] HIDDEN: Literal["hidden"] CASCADE: Literal["cascade"] CHECKBUTTON: Literal["checkbutton"] COMMAND: Literal["command"] RADIOBUTTON: Literal["radiobutton"] SEPARATOR: Literal["separator"] SINGLE: Literal["single"] BROWSE: Literal["browse"] MULTIPLE: Literal["multiple"] EXTENDED: Literal["extended"] DOTBOX: Literal["dotbox"] UNDERLINE: Literal["underline"] PIESLICE: Literal["pieslice"] CHORD: Literal["chord"] ARC: Literal["arc"] FIRST: Literal["first"] LAST: Literal["last"] BUTT: Literal["butt"] PROJECTING: Literal["projecting"] ROUND: Literal["round"] BEVEL: Literal["bevel"] MITER: Literal["miter"] MOVETO: Literal["moveto"] SCROLL: Literal["scroll"] UNITS: Literal["units"] PAGES: Literal["pages"] ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/tkinter/dialog.pyi0000664000175000017500000000044300000000000024557 0ustar00davedave00000000000000from tkinter import Widget from typing import Any, Mapping, Optional DIALOG_ICON: str class Dialog(Widget): widgetName: str = ... num: int = ... def __init__(self, master: Optional[Any] = ..., cnf: Mapping[str, Any] = ..., **kw) -> None: ... def destroy(self) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/tkinter/filedialog.pyi0000664000175000017500000000430700000000000025422 0ustar00davedave00000000000000from tkinter import Button, Entry, Frame, Listbox, Scrollbar, Toplevel, commondialog from typing import Any, Dict, Optional, Tuple dialogstates: Dict[Any, Tuple[Any, Any]] class FileDialog: title: str = ... master: Any = ... directory: Optional[Any] = ... top: Toplevel = ... botframe: Frame = ... selection: Entry = ... filter: Entry = ... midframe: Entry = ... filesbar: Scrollbar = ... files: Listbox = ... dirsbar: Scrollbar = ... dirs: Listbox = ... ok_button: Button = ... filter_button: Button = ... cancel_button: Button = ... def __init__( self, master, title: Optional[Any] = ... ) -> None: ... # title is usually a str or None, but e.g. int doesn't raise en exception either how: Optional[Any] = ... def go(self, dir_or_file: Any = ..., pattern: str = ..., default: str = ..., key: Optional[Any] = ...): ... def quit(self, how: Optional[Any] = ...) -> None: ... def dirs_double_event(self, event) -> None: ... def dirs_select_event(self, event) -> None: ... def files_double_event(self, event) -> None: ... def files_select_event(self, event) -> None: ... def ok_event(self, event) -> None: ... def ok_command(self) -> None: ... def filter_command(self, event: Optional[Any] = ...) -> None: ... def get_filter(self): ... def get_selection(self): ... def cancel_command(self, event: Optional[Any] = ...) -> None: ... def set_filter(self, dir, pat) -> None: ... def set_selection(self, file) -> None: ... class LoadFileDialog(FileDialog): title: str = ... def ok_command(self) -> None: ... class SaveFileDialog(FileDialog): title: str = ... def ok_command(self): ... class _Dialog(commondialog.Dialog): ... class Open(_Dialog): command: str = ... class SaveAs(_Dialog): command: str = ... class Directory(commondialog.Dialog): command: str = ... def askopenfilename(**options): ... def asksaveasfilename(**options): ... def askopenfilenames(**options): ... def askopenfile(mode: str = ..., **options): ... def askopenfiles(mode: str = ..., **options): ... def asksaveasfile(mode: str = ..., **options): ... def askdirectory(**options): ... def test() -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/tkinter/font.pyi0000664000175000017500000000734400000000000024275 0ustar00davedave00000000000000import tkinter from typing import Any, List, Optional, Tuple, TypeVar, Union, overload from typing_extensions import Literal, TypedDict NORMAL: Literal["normal"] ROMAN: Literal["roman"] BOLD: Literal["bold"] ITALIC: Literal["italic"] def nametofont(name: str) -> Font: ... # See 'FONT DESCRIPTIONS' in font man page. This uses str because Literal # inside Tuple doesn't work. _FontDescription = Union[str, Font, Tuple[str, int], Tuple[str, int, str], Tuple[str, int, tkinter._TkinterSequence[str]]] class _FontDict(TypedDict): family: str size: int weight: Literal["normal", "bold"] slant: Literal["roman", "italic"] underline: Literal[0, 1] overstrike: Literal[0, 1] class _MetricsDict(TypedDict): ascent: int descent: int linespace: int fixed: Literal[0, 1] class Font: name: str delete_font: bool def __init__( self, # In tkinter, 'root' refers to tkinter.Tk by convention, but the code # actually works with any tkinter widget so we use tkinter.Misc. root: Optional[tkinter.Misc] = ..., font: Optional[_FontDescription] = ..., name: Optional[str] = ..., exists: bool = ..., *, family: str = ..., size: int = ..., weight: Literal["normal", "bold"] = ..., slant: Literal["roman", "italic"] = ..., underline: bool = ..., overstrike: bool = ..., ) -> None: ... def __getitem__(self, key: str) -> Any: ... def __setitem__(self, key: str, value: Any) -> None: ... @overload def cget(self, option: Literal["family"]) -> str: ... @overload def cget(self, option: Literal["size"]) -> int: ... @overload def cget(self, option: Literal["weight"]) -> Literal["normal", "bold"]: ... @overload def cget(self, option: Literal["slant"]) -> Literal["roman", "italic"]: ... @overload def cget(self, option: Literal["underline", "overstrike"]) -> Literal[0, 1]: ... @overload def actual(self, option: Literal["family"], displayof: Optional[tkinter.Misc] = ...) -> str: ... @overload def actual(self, option: Literal["size"], displayof: Optional[tkinter.Misc] = ...) -> int: ... @overload def actual(self, option: Literal["weight"], displayof: Optional[tkinter.Misc] = ...) -> Literal["normal", "bold"]: ... @overload def actual(self, option: Literal["slant"], displayof: Optional[tkinter.Misc] = ...) -> Literal["roman", "italic"]: ... @overload def actual(self, option: Literal["underline", "overstrike"], displayof: Optional[tkinter.Misc] = ...) -> Literal[0, 1]: ... @overload def actual(self, option: None, displayof: Optional[tkinter.Misc] = ...) -> _FontDict: ... @overload def actual(self, *, displayof: Optional[tkinter.Misc] = ...) -> _FontDict: ... def config( self, *, family: str = ..., size: int = ..., weight: Literal["normal", "bold"] = ..., slant: Literal["roman", "italic"] = ..., underline: bool = ..., overstrike: bool = ..., ) -> Optional[_FontDict]: ... configure = config def copy(self) -> Font: ... @overload def metrics(self, __option: Literal["ascent", "descent", "linespace"], *, displayof: Optional[tkinter.Misc] = ...) -> int: ... @overload def metrics(self, __option: Literal["fixed"], *, displayof: Optional[tkinter.Misc] = ...) -> Literal[0, 1]: ... @overload def metrics(self, *, displayof: Optional[tkinter.Misc] = ...) -> _MetricsDict: ... def measure(self, text: str, displayof: Optional[tkinter.Misc] = ...) -> int: ... def families(root: Optional[tkinter.Misc] = ..., displayof: Optional[tkinter.Misc] = ...) -> Tuple[str, ...]: ... def names(root: Optional[tkinter.Misc] = ...) -> Tuple[str, ...]: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/tkinter/messagebox.pyi0000664000175000017500000000217600000000000025462 0ustar00davedave00000000000000from tkinter.commondialog import Dialog from typing import Any, Optional ERROR: str INFO: str QUESTION: str WARNING: str ABORTRETRYIGNORE: str OK: str OKCANCEL: str RETRYCANCEL: str YESNO: str YESNOCANCEL: str ABORT: str RETRY: str IGNORE: str CANCEL: str YES: str NO: str class Message(Dialog): command: str = ... def showinfo(title: Optional[str] = ..., message: Optional[str] = ..., **options: Any) -> str: ... def showwarning(title: Optional[str] = ..., message: Optional[str] = ..., **options: Any) -> str: ... def showerror(title: Optional[str] = ..., message: Optional[str] = ..., **options: Any) -> str: ... def askquestion(title: Optional[str] = ..., message: Optional[str] = ..., **options: Any) -> str: ... def askokcancel(title: Optional[str] = ..., message: Optional[str] = ..., **options: Any) -> bool: ... def askyesno(title: Optional[str] = ..., message: Optional[str] = ..., **options: Any) -> bool: ... def askyesnocancel(title: Optional[str] = ..., message: Optional[str] = ..., **options: Any) -> Optional[bool]: ... def askretrycancel(title: Optional[str] = ..., message: Optional[str] = ..., **options: Any) -> bool: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/tkinter/ttk.pyi0000664000175000017500000012534400000000000024132 0ustar00davedave00000000000000import _tkinter import sys import tkinter from tkinter.font import _FontDescription from typing import Any, Callable, Dict, List, Optional, Tuple, Union, overload from typing_extensions import Literal def tclobjs_to_py(adict): ... def setup_master(master: Optional[Any] = ...): ... # from ttk_widget (aka ttk::widget) manual page, differs from tkinter._Compound _TtkCompound = Literal["text", "image", tkinter._Compound] class Style: master: Any tk: _tkinter.TkappType def __init__(self, master: Optional[Any] = ...): ... def configure(self, style, query_opt: Optional[Any] = ..., **kw): ... def map(self, style, query_opt: Optional[Any] = ..., **kw): ... def lookup(self, style, option, state: Optional[Any] = ..., default: Optional[Any] = ...): ... def layout(self, style, layoutspec: Optional[Any] = ...): ... def element_create(self, elementname, etype, *args, **kw): ... def element_names(self): ... def element_options(self, elementname): ... def theme_create(self, themename, parent: Optional[Any] = ..., settings: Optional[Any] = ...): ... def theme_settings(self, themename, settings): ... def theme_names(self): ... def theme_use(self, themename: Optional[Any] = ...): ... class Widget(tkinter.Widget): def __init__(self, master: Optional[tkinter.Misc], widgetname, kw: Optional[Any] = ...): ... def identify(self, x, y): ... def instate(self, statespec, callback: Optional[Any] = ..., *args, **kw): ... def state(self, statespec: Optional[Any] = ...): ... _ButtonOptionName = Literal[ "class", "command", "compound", "cursor", "default", "image", "padding", "state", "style", "takefocus", "text", "textvariable", "underline", "width", ] class Button(Widget): def __init__( self, master: Optional[tkinter.Misc] = ..., *, class_: str = ..., command: tkinter._ButtonCommand = ..., compound: _TtkCompound = ..., cursor: tkinter._Cursor = ..., default: Literal["normal", "active", "disabled"] = ..., image: tkinter._ImageSpec = ..., name: str = ..., padding: Any = ..., # undocumented state: Literal["normal", "disabled"] = ..., style: str = ..., takefocus: tkinter._TakeFocusValue = ..., text: str = ..., textvariable: tkinter.Variable = ..., underline: int = ..., width: Union[int, Literal[""]] = ..., ) -> None: ... @overload def configure( self, cnf: Optional[Dict[str, Any]] = ..., *, command: tkinter._ButtonCommand = ..., compound: _TtkCompound = ..., cursor: tkinter._Cursor = ..., default: Literal["normal", "active", "disabled"] = ..., image: tkinter._ImageSpec = ..., padding: Any = ..., state: Literal["normal", "disabled"] = ..., style: str = ..., takefocus: tkinter._TakeFocusValue = ..., text: str = ..., textvariable: tkinter.Variable = ..., underline: int = ..., width: Union[int, Literal[""]] = ..., ) -> Optional[Dict[str, Tuple[str, str, str, Any, Any]]]: ... @overload def configure(self, cnf: _ButtonOptionName) -> Tuple[str, str, str, Any, Any]: ... config = configure def cget(self, key: _ButtonOptionName) -> Any: ... def invoke(self): ... _CheckbuttonOptionName = Literal[ "class", "command", "compound", "cursor", "image", "offvalue", "onvalue", "padding", "state", "style", "takefocus", "text", "textvariable", "underline", "variable", "width", ] class Checkbutton(Widget): def __init__( self, master: Optional[tkinter.Misc] = ..., *, class_: str = ..., command: tkinter._ButtonCommand = ..., compound: _TtkCompound = ..., cursor: tkinter._Cursor = ..., image: tkinter._ImageSpec = ..., name: str = ..., offvalue: Any = ..., onvalue: Any = ..., padding: Any = ..., # undocumented state: Literal["normal", "disabled"] = ..., style: str = ..., takefocus: tkinter._TakeFocusValue = ..., text: str = ..., textvariable: tkinter.Variable = ..., underline: int = ..., # Seems like variable can be empty string, but actually setting it to # empty string segfaults before Tcl 8.6.9. Search for ttk::checkbutton # here: https://sourceforge.net/projects/tcl/files/Tcl/8.6.9/tcltk-release-notes-8.6.9.txt/view variable: tkinter.Variable = ..., width: Union[int, Literal[""]] = ..., ) -> None: ... @overload def configure( self, cnf: Optional[Dict[str, Any]] = ..., *, command: tkinter._ButtonCommand = ..., compound: _TtkCompound = ..., cursor: tkinter._Cursor = ..., image: tkinter._ImageSpec = ..., offvalue: Any = ..., onvalue: Any = ..., padding: Any = ..., state: Literal["normal", "disabled"] = ..., style: str = ..., takefocus: tkinter._TakeFocusValue = ..., text: str = ..., textvariable: tkinter.Variable = ..., underline: int = ..., variable: tkinter.Variable = ..., width: Union[int, Literal[""]] = ..., ) -> Optional[Dict[str, Tuple[str, str, str, Any, Any]]]: ... @overload def configure(self, cnf: _CheckbuttonOptionName) -> Tuple[str, str, str, Any, Any]: ... config = configure def cget(self, key: _CheckbuttonOptionName) -> Any: ... def invoke(self): ... _EntryOptionName = Literal[ "background", "class", "cursor", "exportselection", "font", "foreground", "invalidcommand", "justify", "show", "state", "style", "takefocus", "textvariable", "validate", "validatecommand", "width", "xscrollcommand", ] class Entry(Widget, tkinter.Entry): def __init__( self, master: Optional[tkinter.Misc] = ..., widget: Optional[str] = ..., *, background: tkinter._Color = ..., # undocumented class_: str = ..., cursor: tkinter._Cursor = ..., exportselection: bool = ..., font: _FontDescription = ..., foreground: tkinter._Color = ..., invalidcommand: tkinter._EntryValidateCommand = ..., justify: Literal["left", "center", "right"] = ..., name: str = ..., show: str = ..., state: Literal["normal", "disabled", "readonly"] = ..., style: str = ..., takefocus: tkinter._TakeFocusValue = ..., textvariable: tkinter.Variable = ..., validate: Literal["none", "focus", "focusin", "focusout", "key", "all"] = ..., validatecommand: tkinter._EntryValidateCommand = ..., width: int = ..., xscrollcommand: tkinter._XYScrollCommand = ..., ) -> None: ... @overload # type: ignore def configure( self, cnf: Optional[Dict[str, Any]] = ..., *, background: tkinter._Color = ..., cursor: tkinter._Cursor = ..., exportselection: bool = ..., font: _FontDescription = ..., foreground: tkinter._Color = ..., invalidcommand: tkinter._EntryValidateCommand = ..., justify: Literal["left", "center", "right"] = ..., show: str = ..., state: Literal["normal", "disabled", "readonly"] = ..., style: str = ..., takefocus: tkinter._TakeFocusValue = ..., textvariable: tkinter.Variable = ..., validate: Literal["none", "focus", "focusin", "focusout", "key", "all"] = ..., validatecommand: tkinter._EntryValidateCommand = ..., width: int = ..., xscrollcommand: tkinter._XYScrollCommand = ..., ) -> Optional[Dict[str, Tuple[str, str, str, Any, Any]]]: ... @overload def configure(self, cnf: _EntryOptionName) -> Tuple[str, str, str, Any, Any]: ... # config must be copy/pasted, otherwise ttk.Entry().config is mypy error (don't know why) @overload # type: ignore def config( self, cnf: Optional[Dict[str, Any]] = ..., *, background: tkinter._Color = ..., cursor: tkinter._Cursor = ..., exportselection: bool = ..., font: _FontDescription = ..., foreground: tkinter._Color = ..., invalidcommand: tkinter._EntryValidateCommand = ..., justify: Literal["left", "center", "right"] = ..., show: str = ..., state: Literal["normal", "disabled", "readonly"] = ..., style: str = ..., takefocus: tkinter._TakeFocusValue = ..., textvariable: tkinter.Variable = ..., validate: Literal["none", "focus", "focusin", "focusout", "key", "all"] = ..., validatecommand: tkinter._EntryValidateCommand = ..., width: int = ..., xscrollcommand: tkinter._XYScrollCommand = ..., ) -> Optional[Dict[str, Tuple[str, str, str, Any, Any]]]: ... @overload def config(self, cnf: _EntryOptionName) -> Tuple[str, str, str, Any, Any]: ... def cget(self, key: _EntryOptionName) -> Any: ... # type: ignore def bbox(self, index): ... def identify(self, x, y): ... def validate(self): ... _ComboboxOptionName = Literal[ "background", "class", "cursor", "exportselection", "font", "foreground", "height", "invalidcommand", "justify", "postcommand", "show", "state", "style", "takefocus", "textvariable", "validate", "validatecommand", "values", "width", "xscrollcommand", ] class Combobox(Entry): def __init__( self, master: Optional[tkinter.Misc] = ..., *, background: tkinter._Color = ..., # undocumented class_: str = ..., cursor: tkinter._Cursor = ..., exportselection: bool = ..., font: _FontDescription = ..., # undocumented foreground: tkinter._Color = ..., # undocumented height: int = ..., invalidcommand: tkinter._EntryValidateCommand = ..., # undocumented justify: Literal["left", "center", "right"] = ..., name: str = ..., postcommand: Union[Callable[[], Any], str] = ..., show: Any = ..., # undocumented state: Literal["normal", "readonly", "disabled"] = ..., style: str = ..., takefocus: tkinter._TakeFocusValue = ..., textvariable: tkinter.Variable = ..., validate: Literal["none", "focus", "focusin", "focusout", "key", "all"] = ..., # undocumented validatecommand: tkinter._EntryValidateCommand = ..., # undocumented values: tkinter._TkinterSequence[str] = ..., width: int = ..., xscrollcommand: tkinter._XYScrollCommand = ..., # undocumented ) -> None: ... @overload # type: ignore def configure( self, cnf: Optional[Dict[str, Any]] = ..., *, background: tkinter._Color = ..., cursor: tkinter._Cursor = ..., exportselection: bool = ..., font: _FontDescription = ..., foreground: tkinter._Color = ..., height: int = ..., invalidcommand: tkinter._EntryValidateCommand = ..., justify: Literal["left", "center", "right"] = ..., postcommand: Union[Callable[[], Any], str] = ..., show: Any = ..., state: Literal["normal", "readonly", "disabled"] = ..., style: str = ..., takefocus: tkinter._TakeFocusValue = ..., textvariable: tkinter.Variable = ..., validate: Literal["none", "focus", "focusin", "focusout", "key", "all"] = ..., validatecommand: tkinter._EntryValidateCommand = ..., values: tkinter._TkinterSequence[str] = ..., width: int = ..., xscrollcommand: tkinter._XYScrollCommand = ..., ) -> Optional[Dict[str, Tuple[str, str, str, Any, Any]]]: ... @overload def configure(self, cnf: _ComboboxOptionName) -> Tuple[str, str, str, Any, Any]: ... # config must be copy/pasted, otherwise ttk.Combobox().config is mypy error (don't know why) @overload # type: ignore def config( self, cnf: Optional[Dict[str, Any]] = ..., *, background: tkinter._Color = ..., cursor: tkinter._Cursor = ..., exportselection: bool = ..., font: _FontDescription = ..., foreground: tkinter._Color = ..., height: int = ..., invalidcommand: tkinter._EntryValidateCommand = ..., justify: Literal["left", "center", "right"] = ..., postcommand: Union[Callable[[], Any], str] = ..., show: Any = ..., state: Literal["normal", "readonly", "disabled"] = ..., style: str = ..., takefocus: tkinter._TakeFocusValue = ..., textvariable: tkinter.Variable = ..., validate: Literal["none", "focus", "focusin", "focusout", "key", "all"] = ..., validatecommand: tkinter._EntryValidateCommand = ..., values: tkinter._TkinterSequence[str] = ..., width: int = ..., xscrollcommand: tkinter._XYScrollCommand = ..., ) -> Optional[Dict[str, Tuple[str, str, str, Any, Any]]]: ... @overload def config(self, cnf: _ComboboxOptionName) -> Tuple[str, str, str, Any, Any]: ... def cget(self, key: _ComboboxOptionName) -> Any: ... # type: ignore def current(self, newindex: Optional[Any] = ...): ... def set(self, value): ... _FrameOptionName = Literal[ "border", "borderwidth", "class", "cursor", "height", "padding", "relief", "style", "takefocus", "width" ] class Frame(Widget): def __init__( self, master: Optional[tkinter.Misc] = ..., *, border: tkinter._ScreenUnits = ..., borderwidth: tkinter._ScreenUnits = ..., class_: str = ..., cursor: tkinter._Cursor = ..., height: tkinter._ScreenUnits = ..., name: str = ..., padding: tkinter._Padding = ..., relief: tkinter._Relief = ..., style: str = ..., takefocus: tkinter._TakeFocusValue = ..., width: tkinter._ScreenUnits = ..., ) -> None: ... @overload def configure( self, cnf: Optional[Dict[str, Any]] = ..., *, border: tkinter._ScreenUnits = ..., borderwidth: tkinter._ScreenUnits = ..., cursor: tkinter._Cursor = ..., height: tkinter._ScreenUnits = ..., padding: tkinter._Padding = ..., relief: tkinter._Relief = ..., style: str = ..., takefocus: tkinter._TakeFocusValue = ..., width: tkinter._ScreenUnits = ..., ) -> Optional[Dict[str, Tuple[str, str, str, Any, Any]]]: ... @overload def configure(self, cnf: _FrameOptionName) -> Tuple[str, str, str, Any, Any]: ... config = configure def cget(self, key: _FrameOptionName) -> Any: ... _LabelOptionName = Literal[ "anchor", "background", "border", "borderwidth", "class", "compound", "cursor", "font", "foreground", "image", "justify", "padding", "relief", "state", "style", "takefocus", "text", "textvariable", "underline", "width", "wraplength", ] class Label(Widget): def __init__( self, master: Optional[tkinter.Misc] = ..., *, anchor: tkinter._Anchor = ..., background: tkinter._Color = ..., border: tkinter._ScreenUnits = ..., # alias for borderwidth borderwidth: tkinter._ScreenUnits = ..., # undocumented class_: str = ..., compound: _TtkCompound = ..., cursor: tkinter._Cursor = ..., font: _FontDescription = ..., foreground: tkinter._Color = ..., image: tkinter._ImageSpec = ..., justify: Literal["left", "center", "right"] = ..., name: str = ..., padding: tkinter._Padding = ..., relief: tkinter._Relief = ..., state: Literal["normal", "disabled"] = ..., style: str = ..., takefocus: tkinter._TakeFocusValue = ..., text: str = ..., textvariable: tkinter.Variable = ..., underline: int = ..., width: Union[int, Literal[""]] = ..., wraplength: tkinter._ScreenUnits = ..., ) -> None: ... @overload def configure( self, cnf: Optional[Dict[str, Any]] = ..., *, anchor: tkinter._Anchor = ..., background: tkinter._Color = ..., border: tkinter._ScreenUnits = ..., borderwidth: tkinter._ScreenUnits = ..., compound: _TtkCompound = ..., cursor: tkinter._Cursor = ..., font: _FontDescription = ..., foreground: tkinter._Color = ..., image: tkinter._ImageSpec = ..., justify: Literal["left", "center", "right"] = ..., padding: tkinter._Padding = ..., relief: tkinter._Relief = ..., state: Literal["normal", "disabled"] = ..., style: str = ..., takefocus: tkinter._TakeFocusValue = ..., text: str = ..., textvariable: tkinter.Variable = ..., underline: int = ..., width: Union[int, Literal[""]] = ..., wraplength: tkinter._ScreenUnits = ..., ) -> Optional[Dict[str, Tuple[str, str, str, Any, Any]]]: ... @overload def configure(self, cnf: _LabelOptionName) -> Tuple[str, str, str, Any, Any]: ... config = configure def cget(self, key: _LabelOptionName) -> Any: ... _LabelframeOptionName = Literal[ "border", "borderwidth", "class", "cursor", "height", "labelanchor", "labelwidget", "padding", "relief", "style", "takefocus", "text", "underline", "width", ] class Labelframe(Widget): def __init__( self, master: Optional[tkinter.Misc] = ..., *, border: tkinter._ScreenUnits = ..., borderwidth: tkinter._ScreenUnits = ..., # undocumented class_: str = ..., cursor: tkinter._Cursor = ..., height: tkinter._ScreenUnits = ..., labelanchor: Literal["nw", "n", "ne", "en", "e", "es", "se", "s", "sw", "ws", "w", "wn"] = ..., labelwidget: tkinter.Misc = ..., name: str = ..., padding: tkinter._Padding = ..., relief: tkinter._Relief = ..., # undocumented style: str = ..., takefocus: tkinter._TakeFocusValue = ..., text: str = ..., underline: int = ..., width: tkinter._ScreenUnits = ..., ) -> None: ... @overload def configure( self, cnf: Optional[Dict[str, Any]] = ..., *, border: tkinter._ScreenUnits = ..., borderwidth: tkinter._ScreenUnits = ..., cursor: tkinter._Cursor = ..., height: tkinter._ScreenUnits = ..., labelanchor: Literal["nw", "n", "ne", "en", "e", "es", "se", "s", "sw", "ws", "w", "wn"] = ..., labelwidget: tkinter.Misc = ..., padding: tkinter._Padding = ..., relief: tkinter._Relief = ..., style: str = ..., takefocus: tkinter._TakeFocusValue = ..., text: str = ..., underline: int = ..., width: tkinter._ScreenUnits = ..., ) -> Optional[Dict[str, Tuple[str, str, str, Any, Any]]]: ... @overload def configure(self, cnf: _LabelframeOptionName) -> Tuple[str, str, str, Any, Any]: ... config = configure def cget(self, key: _LabelframeOptionName) -> Any: ... LabelFrame = Labelframe _MenubuttonOptionName = Literal[ "class", "compound", "cursor", "direction", "image", "menu", "padding", "state", "style", "takefocus", "text", "textvariable", "underline", "width", ] class Menubutton(Widget): def __init__( self, master: Optional[tkinter.Misc] = ..., *, class_: str = ..., compound: _TtkCompound = ..., cursor: tkinter._Cursor = ..., direction: Literal["above", "below", "left", "right", "flush"] = ..., image: tkinter._ImageSpec = ..., menu: tkinter.Menu = ..., name: str = ..., padding: Any = ..., # undocumented state: Literal["normal", "disabled"] = ..., style: str = ..., takefocus: tkinter._TakeFocusValue = ..., text: str = ..., textvariable: tkinter.Variable = ..., underline: int = ..., width: Union[int, Literal[""]] = ..., ) -> None: ... @overload def configure( self, cnf: Optional[Dict[str, Any]] = ..., *, compound: _TtkCompound = ..., cursor: tkinter._Cursor = ..., direction: Literal["above", "below", "left", "right", "flush"] = ..., image: tkinter._ImageSpec = ..., menu: tkinter.Menu = ..., padding: Any = ..., state: Literal["normal", "disabled"] = ..., style: str = ..., takefocus: tkinter._TakeFocusValue = ..., text: str = ..., textvariable: tkinter.Variable = ..., underline: int = ..., width: Union[int, Literal[""]] = ..., ) -> Optional[Dict[str, Tuple[str, str, str, Any, Any]]]: ... @overload def configure(self, cnf: _MenubuttonOptionName) -> Tuple[str, str, str, Any, Any]: ... config = configure def cget(self, key: _MenubuttonOptionName) -> Any: ... _NotebookOptionName = Literal["class", "cursor", "height", "padding", "style", "takefocus", "width"] class Notebook(Widget): def __init__( self, master: Optional[tkinter.Misc] = ..., *, class_: str = ..., cursor: tkinter._Cursor = ..., height: int = ..., name: str = ..., padding: tkinter._Padding = ..., style: str = ..., takefocus: tkinter._TakeFocusValue = ..., width: int = ..., ) -> None: ... @overload def configure( self, cnf: Optional[Dict[str, Any]] = ..., *, cursor: tkinter._Cursor = ..., height: int = ..., padding: tkinter._Padding = ..., style: str = ..., takefocus: tkinter._TakeFocusValue = ..., width: int = ..., ) -> Optional[Dict[str, Tuple[str, str, str, Any, Any]]]: ... @overload def configure(self, cnf: _NotebookOptionName) -> Tuple[str, str, str, Any, Any]: ... config = configure def cget(self, key: _NotebookOptionName) -> Any: ... def add(self, child, **kw): ... def forget(self, tab_id): ... def hide(self, tab_id): ... def identify(self, x, y): ... def index(self, tab_id): ... def insert(self, pos, child, **kw): ... def select(self, tab_id: Optional[Any] = ...): ... def tab(self, tab_id, option: Optional[Any] = ..., **kw): ... def tabs(self): ... def enable_traversal(self): ... _PanedwindowOptionName = Literal["class", "cursor", "height", "orient", "style", "takefocus", "width"] class Panedwindow(Widget, tkinter.PanedWindow): def __init__( self, master: Optional[tkinter.Misc] = ..., *, class_: str = ..., cursor: tkinter._Cursor = ..., # width and height for tkinter.ttk.Panedwindow are int but for tkinter.PanedWindow they are screen units height: int = ..., name: str = ..., orient: Literal["vertical", "horizontal"] = ..., style: str = ..., takefocus: tkinter._TakeFocusValue = ..., width: int = ..., ) -> None: ... @overload # type: ignore def configure( self, cnf: Optional[Dict[str, Any]] = ..., *, cursor: tkinter._Cursor = ..., height: int = ..., style: str = ..., takefocus: tkinter._TakeFocusValue = ..., width: int = ..., ) -> Optional[Dict[str, Tuple[str, str, str, Any, Any]]]: ... @overload def configure(self, cnf: _PanedwindowOptionName) -> Tuple[str, str, str, Any, Any]: ... # config must be copy/pasted, otherwise ttk.Panedwindow().config is mypy error (don't know why) @overload # type: ignore def config( self, cnf: Optional[Dict[str, Any]] = ..., *, cursor: tkinter._Cursor = ..., height: int = ..., style: str = ..., takefocus: tkinter._TakeFocusValue = ..., width: int = ..., ) -> Optional[Dict[str, Tuple[str, str, str, Any, Any]]]: ... @overload def config(self, cnf: _PanedwindowOptionName) -> Tuple[str, str, str, Any, Any]: ... def cget(self, key: _PanedwindowOptionName) -> Any: ... # type: ignore forget: Any def insert(self, pos, child, **kw): ... def pane(self, pane, option: Optional[Any] = ..., **kw): ... def sashpos(self, index, newpos: Optional[Any] = ...): ... PanedWindow = Panedwindow _ProgressbarOptionName = Literal[ "class", "cursor", "length", "maximum", "mode", "orient", "phase", "style", "takefocus", "value", "variable" ] class Progressbar(Widget): def __init__( self, master: Optional[tkinter.Misc] = ..., *, class_: str = ..., cursor: tkinter._Cursor = ..., length: tkinter._ScreenUnits = ..., maximum: float = ..., mode: Literal["determinate", "indeterminate"] = ..., name: str = ..., orient: Literal["horizontal", "vertical"] = ..., phase: int = ..., # docs say read-only but assigning int to this works style: str = ..., takefocus: tkinter._TakeFocusValue = ..., value: float = ..., variable: tkinter.DoubleVar = ..., ) -> None: ... @overload def configure( self, cnf: Optional[Dict[str, Any]] = ..., *, cursor: tkinter._Cursor = ..., length: tkinter._ScreenUnits = ..., maximum: float = ..., mode: Literal["determinate", "indeterminate"] = ..., orient: Literal["horizontal", "vertical"] = ..., phase: int = ..., style: str = ..., takefocus: tkinter._TakeFocusValue = ..., value: float = ..., variable: tkinter.DoubleVar = ..., ) -> Optional[Dict[str, Tuple[str, str, str, Any, Any]]]: ... @overload def configure(self, cnf: _ProgressbarOptionName) -> Tuple[str, str, str, Any, Any]: ... config = configure def cget(self, key: _ProgressbarOptionName) -> Any: ... def start(self, interval: Optional[Any] = ...): ... def step(self, amount: Optional[Any] = ...): ... def stop(self): ... _RadiobuttonOptionName = Literal[ "class", "command", "compound", "cursor", "image", "padding", "state", "style", "takefocus", "text", "textvariable", "underline", "value", "variable", "width", ] class Radiobutton(Widget): def __init__( self, master: Optional[tkinter.Misc] = ..., *, class_: str = ..., command: tkinter._ButtonCommand = ..., compound: _TtkCompound = ..., cursor: tkinter._Cursor = ..., image: tkinter._ImageSpec = ..., name: str = ..., padding: Any = ..., # undocumented state: Literal["normal", "disabled"] = ..., style: str = ..., takefocus: tkinter._TakeFocusValue = ..., text: str = ..., textvariable: tkinter.Variable = ..., underline: int = ..., value: Any = ..., variable: Union[tkinter.Variable, Literal[""]] = ..., width: Union[int, Literal[""]] = ..., ) -> None: ... @overload def configure( self, cnf: Optional[Dict[str, Any]] = ..., *, command: tkinter._ButtonCommand = ..., compound: _TtkCompound = ..., cursor: tkinter._Cursor = ..., image: tkinter._ImageSpec = ..., padding: Any = ..., state: Literal["normal", "disabled"] = ..., style: str = ..., takefocus: tkinter._TakeFocusValue = ..., text: str = ..., textvariable: tkinter.Variable = ..., underline: int = ..., value: Any = ..., variable: Union[tkinter.Variable, Literal[""]] = ..., width: Union[int, Literal[""]] = ..., ) -> Optional[Dict[str, Tuple[str, str, str, Any, Any]]]: ... @overload def configure(self, cnf: _RadiobuttonOptionName) -> Tuple[str, str, str, Any, Any]: ... config = configure def cget(self, key: _RadiobuttonOptionName) -> Any: ... def invoke(self): ... _ScaleOptionName = Literal[ "class", "command", "cursor", "from", "length", "orient", "state", "style", "takefocus", "to", "value", "variable" ] class Scale(Widget, tkinter.Scale): def __init__( self, master: Optional[tkinter.Misc] = ..., *, class_: str = ..., command: Union[str, Callable[[str], Any]] = ..., cursor: tkinter._Cursor = ..., from_: float = ..., length: tkinter._ScreenUnits = ..., name: str = ..., orient: Literal["horizontal", "vertical"] = ..., state: Any = ..., # undocumented style: str = ..., takefocus: tkinter._TakeFocusValue = ..., to: float = ..., value: float = ..., variable: tkinter.DoubleVar = ..., ) -> None: ... @overload # type: ignore def configure( self, cnf: Optional[Dict[str, Any]] = ..., *, command: Union[str, Callable[[str], Any]] = ..., cursor: tkinter._Cursor = ..., from_: float = ..., length: tkinter._ScreenUnits = ..., orient: Literal["horizontal", "vertical"] = ..., state: Any = ..., style: str = ..., takefocus: tkinter._TakeFocusValue = ..., to: float = ..., value: float = ..., variable: tkinter.DoubleVar = ..., ) -> Optional[Dict[str, Tuple[str, str, str, Any, Any]]]: ... @overload def configure(self, cnf: _ScaleOptionName) -> Tuple[str, str, str, Any, Any]: ... # config must be copy/pasted, otherwise ttk.Scale().config is mypy error (don't know why) @overload # type: ignore def config( self, cnf: Optional[Dict[str, Any]] = ..., *, command: Union[str, Callable[[str], Any]] = ..., cursor: tkinter._Cursor = ..., from_: float = ..., length: tkinter._ScreenUnits = ..., orient: Literal["horizontal", "vertical"] = ..., state: Any = ..., style: str = ..., takefocus: tkinter._TakeFocusValue = ..., to: float = ..., value: float = ..., variable: tkinter.DoubleVar = ..., ) -> Optional[Dict[str, Tuple[str, str, str, Any, Any]]]: ... @overload def config(self, cnf: _ScaleOptionName) -> Tuple[str, str, str, Any, Any]: ... def cget(self, key: _ScaleOptionName) -> Any: ... # type: ignore def get(self, x: Optional[Any] = ..., y: Optional[Any] = ...): ... _ScrollbarOptionName = Literal["class", "command", "cursor", "orient", "style", "takefocus"] class Scrollbar(Widget, tkinter.Scrollbar): def __init__( self, master: Optional[tkinter.Misc] = ..., *, class_: str = ..., command: Union[Callable[..., Optional[Tuple[float, float]]], str] = ..., cursor: tkinter._Cursor = ..., name: str = ..., orient: Literal["horizontal", "vertical"] = ..., style: str = ..., takefocus: tkinter._TakeFocusValue = ..., ) -> None: ... @overload # type: ignore def configure( self, cnf: Optional[Dict[str, Any]] = ..., *, command: Union[Callable[..., Optional[Tuple[float, float]]], str] = ..., cursor: tkinter._Cursor = ..., orient: Literal["horizontal", "vertical"] = ..., style: str = ..., takefocus: tkinter._TakeFocusValue = ..., ) -> Optional[Dict[str, Tuple[str, str, str, Any, Any]]]: ... @overload def configure(self, cnf: _ScrollbarOptionName) -> Tuple[str, str, str, Any, Any]: ... # config must be copy/pasted, otherwise ttk.Scrollbar().config is mypy error (don't know why) @overload # type: ignore def config( self, cnf: Optional[Dict[str, Any]] = ..., *, command: Union[Callable[..., Optional[Tuple[float, float]]], str] = ..., cursor: tkinter._Cursor = ..., orient: Literal["horizontal", "vertical"] = ..., style: str = ..., takefocus: tkinter._TakeFocusValue = ..., ) -> Optional[Dict[str, Tuple[str, str, str, Any, Any]]]: ... @overload def config(self, cnf: _ScrollbarOptionName) -> Tuple[str, str, str, Any, Any]: ... def cget(self, key: _ScrollbarOptionName) -> Any: ... # type: ignore _SeparatorOptionName = Literal["class", "cursor", "orient", "style", "takefocus"] class Separator(Widget): def __init__( self, master: Optional[tkinter.Misc] = ..., *, class_: str = ..., cursor: tkinter._Cursor = ..., name: str = ..., orient: Literal["horizontal", "vertical"] = ..., style: str = ..., takefocus: tkinter._TakeFocusValue = ..., ) -> None: ... @overload def configure( self, cnf: Optional[Dict[str, Any]] = ..., *, cursor: tkinter._Cursor = ..., orient: Literal["horizontal", "vertical"] = ..., style: str = ..., takefocus: tkinter._TakeFocusValue = ..., ) -> Optional[Dict[str, Tuple[str, str, str, Any, Any]]]: ... @overload def configure(self, cnf: _SeparatorOptionName) -> Tuple[str, str, str, Any, Any]: ... config = configure def cget(self, key: _SeparatorOptionName) -> Any: ... _SizegripOptionName = Literal["class", "cursor", "style", "takefocus"] class Sizegrip(Widget): def __init__( self, master: Optional[tkinter.Misc] = ..., *, class_: str = ..., cursor: tkinter._Cursor = ..., name: str = ..., style: str = ..., takefocus: tkinter._TakeFocusValue = ..., ) -> None: ... @overload def configure( self, cnf: Optional[Dict[str, Any]] = ..., *, cursor: tkinter._Cursor = ..., style: str = ..., takefocus: tkinter._TakeFocusValue = ..., ) -> Optional[Dict[str, Tuple[str, str, str, Any, Any]]]: ... @overload def configure(self, cnf: _SizegripOptionName) -> Tuple[str, str, str, Any, Any]: ... config = configure def cget(self, key: _SizegripOptionName) -> Any: ... if sys.version_info >= (3, 7): _SpinboxOptionName = Literal[ "background", "class", "command", "cursor", "exportselection", "font", "foreground", "format", "from", "increment", "invalidcommand", "justify", "show", "state", "style", "takefocus", "textvariable", "to", "validate", "validatecommand", "values", "width", "wrap", "xscrollcommand", ] class Spinbox(Entry): def __init__( self, master: Optional[tkinter.Misc] = ..., *, background: tkinter._Color = ..., # undocumented class_: str = ..., command: Union[Callable[[], Any], str, tkinter._TkinterSequence[str]] = ..., cursor: tkinter._Cursor = ..., exportselection: bool = ..., # undocumented font: _FontDescription = ..., # undocumented foreground: tkinter._Color = ..., # undocumented format: str = ..., from_: float = ..., increment: float = ..., invalidcommand: tkinter._EntryValidateCommand = ..., # undocumented justify: Literal["left", "center", "right"] = ..., # undocumented name: str = ..., show: Any = ..., # undocumented state: Literal["normal", "disabled"] = ..., style: str = ..., takefocus: tkinter._TakeFocusValue = ..., textvariable: tkinter.Variable = ..., # undocumented to: float = ..., validate: Literal["none", "focus", "focusin", "focusout", "key", "all"] = ..., validatecommand: tkinter._EntryValidateCommand = ..., values: tkinter._TkinterSequence[str] = ..., width: int = ..., # undocumented wrap: bool = ..., xscrollcommand: tkinter._XYScrollCommand = ..., ) -> None: ... @overload # type: ignore def configure( self, cnf: Optional[Dict[str, Any]] = ..., *, background: tkinter._Color = ..., command: Union[Callable[[], Any], str, tkinter._TkinterSequence[str]] = ..., cursor: tkinter._Cursor = ..., exportselection: bool = ..., font: _FontDescription = ..., foreground: tkinter._Color = ..., format: str = ..., from_: float = ..., increment: float = ..., invalidcommand: tkinter._EntryValidateCommand = ..., justify: Literal["left", "center", "right"] = ..., show: Any = ..., state: Literal["normal", "disabled"] = ..., style: str = ..., takefocus: tkinter._TakeFocusValue = ..., textvariable: tkinter.Variable = ..., to: float = ..., validate: Literal["none", "focus", "focusin", "focusout", "key", "all"] = ..., validatecommand: tkinter._EntryValidateCommand = ..., values: tkinter._TkinterSequence[str] = ..., width: int = ..., wrap: bool = ..., xscrollcommand: tkinter._XYScrollCommand = ..., ) -> Optional[Dict[str, Tuple[str, str, str, Any, Any]]]: ... @overload def configure(self, cnf: _SpinboxOptionName) -> Tuple[str, str, str, Any, Any]: ... config = configure # type: ignore def cget(self, key: _SpinboxOptionName) -> Any: ... # type: ignore def set(self, value: Any) -> None: ... _TreeviewOptionName = Literal[ "class", "columns", "cursor", "displaycolumns", "height", "padding", "selectmode", "show", "style", "takefocus", "xscrollcommand", "yscrollcommand", ] class Treeview(Widget, tkinter.XView, tkinter.YView): def __init__( self, master: Optional[tkinter.Misc] = ..., *, class_: str = ..., columns: Union[str, tkinter._TkinterSequence[str]] = ..., cursor: tkinter._Cursor = ..., displaycolumns: Union[str, tkinter._TkinterSequence[str], tkinter._TkinterSequence[int], Literal["#all"]] = ..., height: int = ..., name: str = ..., padding: tkinter._Padding = ..., selectmode: Literal["extended", "browse", "none"] = ..., # _TkinterSequences of Literal don't actually work, using str instead. # # 'tree headings' is same as ['tree', 'headings'], and I wouldn't be # surprised if someone was using it. show: Union[Literal["tree", "headings", "tree headings"], tkinter._TkinterSequence[str]] = ..., style: str = ..., takefocus: tkinter._TakeFocusValue = ..., xscrollcommand: tkinter._XYScrollCommand = ..., yscrollcommand: tkinter._XYScrollCommand = ..., ) -> None: ... @overload def configure( self, cnf: Optional[Dict[str, Any]] = ..., *, columns: Union[str, tkinter._TkinterSequence[str]] = ..., cursor: tkinter._Cursor = ..., displaycolumns: Union[str, tkinter._TkinterSequence[str], tkinter._TkinterSequence[int], Literal["#all"]] = ..., height: int = ..., padding: tkinter._Padding = ..., selectmode: Literal["extended", "browse", "none"] = ..., show: Union[Literal["tree", "headings", "tree headings"], tkinter._TkinterSequence[str]] = ..., style: str = ..., takefocus: tkinter._TakeFocusValue = ..., xscrollcommand: tkinter._XYScrollCommand = ..., yscrollcommand: tkinter._XYScrollCommand = ..., ) -> Optional[Dict[str, Tuple[str, str, str, Any, Any]]]: ... @overload def configure(self, cnf: _TreeviewOptionName) -> Tuple[str, str, str, Any, Any]: ... config = configure def cget(self, key: _TreeviewOptionName) -> Any: ... def bbox(self, item, column: Optional[Any] = ...): ... def get_children(self, item: Optional[Any] = ...): ... def set_children(self, item, *newchildren): ... def column(self, column, option: Optional[Any] = ..., **kw): ... def delete(self, *items): ... def detach(self, *items): ... def exists(self, item): ... def focus(self, item: Optional[Any] = ...): ... def heading(self, column, option: Optional[Any] = ..., **kw): ... def identify(self, component, x, y): ... def identify_row(self, y): ... def identify_column(self, x): ... def identify_region(self, x, y): ... def identify_element(self, x, y): ... def index(self, item): ... def insert(self, parent, index, iid: Optional[Any] = ..., **kw): ... def item(self, item, option: Optional[Any] = ..., **kw): ... def move(self, item, parent, index): ... reattach: Any def next(self, item): ... def parent(self, item): ... def prev(self, item): ... def see(self, item): ... if sys.version_info >= (3, 8): def selection(self) -> List[Any]: ... else: def selection(self, selop: Optional[Any] = ..., items: Optional[Any] = ...) -> List[Any]: ... def selection_set(self, items): ... def selection_add(self, items): ... def selection_remove(self, items): ... def selection_toggle(self, items): ... def set(self, item, column: Optional[Any] = ..., value: Optional[Any] = ...): ... # There's no tag_unbind() or 'add' argument for whatever reason. # Also, it's 'callback' instead of 'func' here. @overload def tag_bind( self, tagname: str, sequence: Optional[str] = ..., callback: Optional[Callable[[tkinter.Event[Treeview]], Optional[Literal["break"]]]] = ..., ) -> str: ... @overload def tag_bind(self, tagname: str, sequence: Optional[str], callback: str) -> None: ... @overload def tag_bind(self, tagname: str, *, callback: str) -> None: ... def tag_configure(self, tagname, option: Optional[Any] = ..., **kw): ... def tag_has(self, tagname, item: Optional[Any] = ...): ... class LabeledScale(Frame): label: Any scale: Any # TODO: don't any-type **kw. That goes to Frame.__init__. def __init__( self, master: Optional[tkinter.Misc] = ..., variable: Optional[Union[tkinter.IntVar, tkinter.DoubleVar]] = ..., from_: float = ..., to: float = ..., *, compound: Union[Literal["top"], Literal["bottom"]] = ..., **kw: Any, ) -> None: ... # destroy is overrided, signature does not change value: Any class OptionMenu(Menubutton): def __init__( self, master, variable, default: Optional[str] = ..., *values: str, # rest of these are keyword-only because *args syntax used above style: str = ..., direction: Union[Literal["above"], Literal["below"], Literal["left"], Literal["right"], Literal["flush"]] = ..., command: Optional[Callable[[tkinter.StringVar], Any]] = ..., ) -> None: ... # configure, config, cget, destroy are inherited from Menubutton # destroy and __setitem__ are overrided, signature does not change def set_menu(self, default: Optional[Any] = ..., *values): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/tokenize.pyi0000664000175000017500000000604600000000000023475 0ustar00davedave00000000000000import sys from builtins import open as _builtin_open from os import PathLike from token import * # noqa: F403 from typing import ( Any, Callable, Dict, Generator, Iterable, List, NamedTuple, Optional, Pattern, Sequence, Set, TextIO, Tuple, Union, ) if sys.version_info < (3, 7): COMMENT: int NL: int ENCODING: int cookie_re: Pattern[str] blank_re: Pattern[bytes] _Position = Tuple[int, int] class _TokenInfo(NamedTuple): type: int string: str start: _Position end: _Position line: str class TokenInfo(_TokenInfo): @property def exact_type(self) -> int: ... # Backwards compatible tokens can be sequences of a shorter length too _Token = Union[TokenInfo, Sequence[Union[int, str, _Position]]] class TokenError(Exception): ... class StopTokenizing(Exception): ... # undocumented class Untokenizer: tokens: List[str] prev_row: int prev_col: int encoding: Optional[str] def __init__(self) -> None: ... def add_whitespace(self, start: _Position) -> None: ... def untokenize(self, iterable: Iterable[_Token]) -> str: ... def compat(self, token: Sequence[Union[int, str]], iterable: Iterable[_Token]) -> None: ... # the docstring says "returns bytes" but is incorrect -- # if the ENCODING token is missing, it skips the encode def untokenize(iterable: Iterable[_Token]) -> Any: ... def detect_encoding(readline: Callable[[], bytes]) -> Tuple[str, Sequence[bytes]]: ... def tokenize(readline: Callable[[], bytes]) -> Generator[TokenInfo, None, None]: ... def generate_tokens(readline: Callable[[], str]) -> Generator[TokenInfo, None, None]: ... # undocumented def open(filename: Union[str, bytes, int, PathLike[Any]]) -> TextIO: ... def group(*choices: str) -> str: ... # undocumented def any(*choices: str) -> str: ... # undocumented def maybe(*choices: str) -> str: ... # undocumented Whitespace: str # undocumented Comment: str # undocumented Ignore: str # undocumented Name: str # undocumented Hexnumber: str # undocumented Binnumber: str # undocumented Octnumber: str # undocumented Decnumber: str # undocumented Intnumber: str # undocumented Exponent: str # undocumented Pointfloat: str # undocumented Expfloat: str # undocumented Floatnumber: str # undocumented Imagnumber: str # undocumented Number: str # undocumented def _all_string_prefixes() -> Set[str]: ... # undocumented StringPrefix: str # undocumented Single: str # undocumented Double: str # undocumented Single3: str # undocumented Double3: str # undocumented Triple: str # undocumented String: str # undocumented if sys.version_info < (3, 7): Operator: str # undocumented Bracket: str # undocumented Special: str # undocumented Funny: str # undocumented PlainToken: str # undocumented Token: str # undocumented ContStr: str # undocumented PseudoExtras: str # undocumented PseudoToken: str # undocumented endpats: Dict[str, str] # undocumented single_quoted: Set[str] # undocumented triple_quoted: Set[str] # undocumented tabsize: int # undocumented ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/tracemalloc.pyi0000664000175000017500000000535300000000000024133 0ustar00davedave00000000000000import sys from typing import List, Optional, Sequence, Tuple, Union, overload from _tracemalloc import * def get_object_traceback(obj: object) -> Optional[Traceback]: ... def take_snapshot() -> Snapshot: ... class DomainFilter: inclusive: bool domain: int def __init__(self, inclusive: bool, domain: int) -> None: ... class Filter: domain: Optional[int] inclusive: bool lineno: Optional[int] filename_pattern: str all_frames: bool def __init__( self, inclusive: bool, filename_pattern: str, lineno: Optional[int] = ..., all_frames: bool = ..., domain: Optional[int] = ..., ) -> None: ... class Statistic: count: int size: int traceback: Traceback def __init__(self, traceback: Traceback, size: int, count: int) -> None: ... class StatisticDiff: count: int count_diff: int size: int size_diff: int traceback: Traceback def __init__(self, traceback: Traceback, size: int, size_diff: int, count: int, count_diff: int) -> None: ... _FrameTupleT = Tuple[str, int] class Frame: filename: str lineno: int def __init__(self, frame: _FrameTupleT) -> None: ... if sys.version_info >= (3, 9): _TraceTupleT = Union[Tuple[int, int, Sequence[_FrameTupleT], Optional[int]], Tuple[int, int, Sequence[_FrameTupleT]]] else: _TraceTupleT = Tuple[int, int, Sequence[_FrameTupleT]] class Trace: domain: int size: int traceback: Traceback def __init__(self, trace: _TraceTupleT) -> None: ... class Traceback(Sequence[Frame]): if sys.version_info >= (3, 9): total_nframe: Optional[int] def __init__(self, frames: Sequence[_FrameTupleT], total_nframe: Optional[int] = ...) -> None: ... else: def __init__(self, frames: Sequence[_FrameTupleT]) -> None: ... if sys.version_info >= (3, 7): def format(self, limit: Optional[int] = ..., most_recent_first: bool = ...) -> List[str]: ... else: def format(self, limit: Optional[int] = ...) -> List[str]: ... @overload def __getitem__(self, i: int) -> Frame: ... @overload def __getitem__(self, s: slice) -> Sequence[Frame]: ... def __len__(self) -> int: ... class Snapshot: def __init__(self, traces: Sequence[_TraceTupleT], traceback_limit: int) -> None: ... def compare_to(self, old_snapshot: Snapshot, key_type: str, cumulative: bool = ...) -> List[StatisticDiff]: ... def dump(self, filename: str) -> None: ... def filter_traces(self, filters: Sequence[Union[DomainFilter, Filter]]) -> Snapshot: ... @staticmethod def load(filename: str) -> Snapshot: ... def statistics(self, key_type: str, cumulative: bool = ...) -> List[Statistic]: ... traceback_limit: int traces: Sequence[Trace] ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/types.pyi0000664000175000017500000002542300000000000023011 0ustar00davedave00000000000000import sys from typing import ( Any, Awaitable, Callable, Dict, Generic, Iterable, Iterator, Mapping, Optional, Tuple, Type, TypeVar, Union, overload, ) from typing_extensions import Literal, final # ModuleType is exported from this module, but for circular import # reasons exists in its own stub file (with ModuleSpec and Loader). from _importlib_modulespec import ModuleType as ModuleType # Exported # Note, all classes "defined" here require special handling. _T = TypeVar("_T") _T_co = TypeVar("_T_co", covariant=True) _T_contra = TypeVar("_T_contra", contravariant=True) _KT = TypeVar("_KT") _VT = TypeVar("_VT") class _Cell: cell_contents: Any class FunctionType: __closure__: Optional[Tuple[_Cell, ...]] __code__: CodeType __defaults__: Optional[Tuple[Any, ...]] __dict__: Dict[str, Any] __globals__: Dict[str, Any] __name__: str __qualname__: str __annotations__: Dict[str, Any] __kwdefaults__: Dict[str, Any] def __init__( self, code: CodeType, globals: Dict[str, Any], name: Optional[str] = ..., argdefs: Optional[Tuple[object, ...]] = ..., closure: Optional[Tuple[_Cell, ...]] = ..., ) -> None: ... def __call__(self, *args: Any, **kwargs: Any) -> Any: ... def __get__(self, obj: Optional[object], type: Optional[type]) -> MethodType: ... LambdaType = FunctionType class CodeType: """Create a code object. Not for the faint of heart.""" co_argcount: int if sys.version_info >= (3, 8): co_posonlyargcount: int co_kwonlyargcount: int co_nlocals: int co_stacksize: int co_flags: int co_code: bytes co_consts: Tuple[Any, ...] co_names: Tuple[str, ...] co_varnames: Tuple[str, ...] co_filename: str co_name: str co_firstlineno: int co_lnotab: bytes co_freevars: Tuple[str, ...] co_cellvars: Tuple[str, ...] if sys.version_info >= (3, 8): def __init__( self, argcount: int, posonlyargcount: int, kwonlyargcount: int, nlocals: int, stacksize: int, flags: int, codestring: bytes, constants: Tuple[Any, ...], names: Tuple[str, ...], varnames: Tuple[str, ...], filename: str, name: str, firstlineno: int, lnotab: bytes, freevars: Tuple[str, ...] = ..., cellvars: Tuple[str, ...] = ..., ) -> None: ... else: def __init__( self, argcount: int, kwonlyargcount: int, nlocals: int, stacksize: int, flags: int, codestring: bytes, constants: Tuple[Any, ...], names: Tuple[str, ...], varnames: Tuple[str, ...], filename: str, name: str, firstlineno: int, lnotab: bytes, freevars: Tuple[str, ...] = ..., cellvars: Tuple[str, ...] = ..., ) -> None: ... if sys.version_info >= (3, 8): def replace( self, *, co_argcount: int = ..., co_posonlyargcount: int = ..., co_kwonlyargcount: int = ..., co_nlocals: int = ..., co_stacksize: int = ..., co_flags: int = ..., co_firstlineno: int = ..., co_code: bytes = ..., co_consts: Tuple[Any, ...] = ..., co_names: Tuple[str, ...] = ..., co_varnames: Tuple[str, ...] = ..., co_freevars: Tuple[str, ...] = ..., co_cellvars: Tuple[str, ...] = ..., co_filename: str = ..., co_name: str = ..., co_lnotab: bytes = ..., ) -> CodeType: ... class MappingProxyType(Mapping[_KT, _VT], Generic[_KT, _VT]): def __init__(self, mapping: Mapping[_KT, _VT]) -> None: ... def __getitem__(self, k: _KT) -> _VT: ... def __iter__(self) -> Iterator[_KT]: ... def __len__(self) -> int: ... def copy(self) -> Dict[_KT, _VT]: ... class SimpleNamespace: def __init__(self, **kwargs: Any) -> None: ... def __getattribute__(self, name: str) -> Any: ... def __setattr__(self, name: str, value: Any) -> None: ... def __delattr__(self, name: str) -> None: ... class GeneratorType: gi_code: CodeType gi_frame: FrameType gi_running: bool gi_yieldfrom: Optional[GeneratorType] def __iter__(self) -> GeneratorType: ... def __next__(self) -> Any: ... def close(self) -> None: ... def send(self, __arg: Any) -> Any: ... @overload def throw( self, __typ: Type[BaseException], __val: Union[BaseException, object] = ..., __tb: Optional[TracebackType] = ... ) -> Any: ... @overload def throw(self, __typ: BaseException, __val: None = ..., __tb: Optional[TracebackType] = ...) -> Any: ... class AsyncGeneratorType(Generic[_T_co, _T_contra]): ag_await: Optional[Awaitable[Any]] ag_frame: FrameType ag_running: bool ag_code: CodeType def __aiter__(self) -> Awaitable[AsyncGeneratorType[_T_co, _T_contra]]: ... def __anext__(self) -> Awaitable[_T_co]: ... def asend(self, __val: _T_contra) -> Awaitable[_T_co]: ... @overload def athrow( self, __typ: Type[BaseException], __val: Union[BaseException, object] = ..., __tb: Optional[TracebackType] = ... ) -> Awaitable[_T_co]: ... @overload def athrow(self, __typ: BaseException, __val: None = ..., __tb: Optional[TracebackType] = ...) -> Awaitable[_T_co]: ... def aclose(self) -> Awaitable[None]: ... class CoroutineType: cr_await: Optional[Any] cr_code: CodeType cr_frame: FrameType cr_running: bool def close(self) -> None: ... def send(self, __arg: Any) -> Any: ... @overload def throw( self, __typ: Type[BaseException], __val: Union[BaseException, object] = ..., __tb: Optional[TracebackType] = ... ) -> Any: ... @overload def throw(self, __typ: BaseException, __val: None = ..., __tb: Optional[TracebackType] = ...) -> Any: ... class _StaticFunctionType: """Fictional type to correct the type of MethodType.__func__. FunctionType is a descriptor, so mypy follows the descriptor protocol and converts MethodType.__func__ back to MethodType (the return type of FunctionType.__get__). But this is actually a special case; MethodType is implemented in C and its attribute access doesn't go through __getattribute__. By wrapping FunctionType in _StaticFunctionType, we get the right result; similar to wrapping a function in staticmethod() at runtime to prevent it being bound as a method. """ def __get__(self, obj: Optional[object], type: Optional[type]) -> FunctionType: ... class MethodType: __func__: _StaticFunctionType __self__: object __name__: str __qualname__: str def __init__(self, func: Callable[..., Any], obj: object) -> None: ... def __call__(self, *args: Any, **kwargs: Any) -> Any: ... class BuiltinFunctionType: __self__: Union[object, ModuleType] __name__: str __qualname__: str def __call__(self, *args: Any, **kwargs: Any) -> Any: ... BuiltinMethodType = BuiltinFunctionType if sys.version_info >= (3, 7): class WrapperDescriptorType: __name__: str __qualname__: str __objclass__: type def __call__(self, *args: Any, **kwargs: Any) -> Any: ... def __get__(self, obj: Any, type: type = ...) -> Any: ... class MethodWrapperType: __self__: object __name__: str __qualname__: str __objclass__: type def __call__(self, *args: Any, **kwargs: Any) -> Any: ... def __eq__(self, other: Any) -> bool: ... def __ne__(self, other: Any) -> bool: ... class MethodDescriptorType: __name__: str __qualname__: str __objclass__: type def __call__(self, *args: Any, **kwargs: Any) -> Any: ... def __get__(self, obj: Any, type: type = ...) -> Any: ... class ClassMethodDescriptorType: __name__: str __qualname__: str __objclass__: type def __call__(self, *args: Any, **kwargs: Any) -> Any: ... def __get__(self, obj: Any, type: type = ...) -> Any: ... class TracebackType: if sys.version_info >= (3, 7): def __init__(self, tb_next: Optional[TracebackType], tb_frame: FrameType, tb_lasti: int, tb_lineno: int) -> None: ... tb_next: Optional[TracebackType] else: @property def tb_next(self) -> Optional[TracebackType]: ... # the rest are read-only even in 3.7 @property def tb_frame(self) -> FrameType: ... @property def tb_lasti(self) -> int: ... @property def tb_lineno(self) -> int: ... class FrameType: f_back: Optional[FrameType] f_builtins: Dict[str, Any] f_code: CodeType f_globals: Dict[str, Any] f_lasti: int f_lineno: int f_locals: Dict[str, Any] f_trace: Optional[Callable[[FrameType, str, Any], Any]] if sys.version_info >= (3, 7): f_trace_lines: bool f_trace_opcodes: bool def clear(self) -> None: ... class GetSetDescriptorType: __name__: str __objclass__: type def __get__(self, obj: Any, type: type = ...) -> Any: ... def __set__(self, obj: Any) -> None: ... def __delete__(self, obj: Any) -> None: ... class MemberDescriptorType: __name__: str __objclass__: type def __get__(self, obj: Any, type: type = ...) -> Any: ... def __set__(self, obj: Any) -> None: ... def __delete__(self, obj: Any) -> None: ... if sys.version_info >= (3, 7): def new_class( name: str, bases: Iterable[object] = ..., kwds: Dict[str, Any] = ..., exec_body: Callable[[Dict[str, Any]], None] = ... ) -> type: ... def resolve_bases(bases: Iterable[object]) -> Tuple[Any, ...]: ... else: def new_class( name: str, bases: Tuple[type, ...] = ..., kwds: Dict[str, Any] = ..., exec_body: Callable[[Dict[str, Any]], None] = ... ) -> type: ... def prepare_class( name: str, bases: Tuple[type, ...] = ..., kwds: Dict[str, Any] = ... ) -> Tuple[type, Dict[str, Any], Dict[str, Any]]: ... # Actually a different type, but `property` is special and we want that too. DynamicClassAttribute = property def coroutine(f: Callable[..., Any]) -> CoroutineType: ... if sys.version_info >= (3, 9): class GenericAlias: __origin__: type __args__: Tuple[Any, ...] __parameters__: Tuple[Any, ...] def __init__(self, origin: type, args: Any) -> None: ... def __getattr__(self, name: str) -> Any: ... # incomplete if sys.version_info >= (3, 10): @final class NoneType: def __bool__(self) -> Literal[False]: ... EllipsisType = ellipsis # noqa F811 from builtins NotImplementedType = _NotImplementedType # noqa F811 from builtins ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/typing.pyi0000664000175000017500000006072000000000000023156 0ustar00davedave00000000000000import collections # Needed by aliases like DefaultDict, see mypy issue 2986 import sys from abc import ABCMeta, abstractmethod from types import BuiltinFunctionType, CodeType, FrameType, FunctionType, MethodType, ModuleType, TracebackType if sys.version_info >= (3, 7): from types import MethodDescriptorType, MethodWrapperType, WrapperDescriptorType if sys.version_info >= (3, 9): from types import GenericAlias # Definitions of special type checking related constructs. Their definitions # are not used, so their value does not matter. overload = object() Any = object() class TypeVar: __name__: str __bound__: Optional[Type[Any]] __constraints__: Tuple[Type[Any], ...] __covariant__: bool __contravariant__: bool def __init__( self, name: str, *constraints: Type[Any], bound: Union[None, Type[Any], str] = ..., covariant: bool = ..., contravariant: bool = ..., ) -> None: ... _promote = object() class _SpecialForm: def __getitem__(self, typeargs: Any) -> object: ... Union: _SpecialForm = ... Optional: _SpecialForm = ... Tuple: _SpecialForm = ... Generic: _SpecialForm = ... # Protocol is only present in 3.8 and later, but mypy needs it unconditionally Protocol: _SpecialForm = ... Callable: _SpecialForm = ... Type: _SpecialForm = ... ClassVar: _SpecialForm = ... if sys.version_info >= (3, 8): Final: _SpecialForm = ... _F = TypeVar("_F", bound=Callable[..., Any]) def final(f: _F) -> _F: ... Literal: _SpecialForm = ... # TypedDict is a (non-subscriptable) special form. TypedDict: object if sys.version_info < (3, 7): class GenericMeta(type): ... if sys.version_info >= (3, 10): class ParamSpec: __name__: str def __init__(self, name: str) -> None: ... Concatenate: _SpecialForm = ... TypeAlias: _SpecialForm = ... # Return type that indicates a function does not return. # This type is equivalent to the None type, but the no-op Union is necessary to # distinguish the None type from the None value. NoReturn = Union[None] # These type variables are used by the container types. _T = TypeVar("_T") _S = TypeVar("_S") _KT = TypeVar("_KT") # Key type. _VT = TypeVar("_VT") # Value type. _T_co = TypeVar("_T_co", covariant=True) # Any type covariant containers. _V_co = TypeVar("_V_co", covariant=True) # Any type covariant containers. _KT_co = TypeVar("_KT_co", covariant=True) # Key type covariant containers. _VT_co = TypeVar("_VT_co", covariant=True) # Value type covariant containers. _T_contra = TypeVar("_T_contra", contravariant=True) # Ditto contravariant. _TC = TypeVar("_TC", bound=Type[object]) _C = TypeVar("_C", bound=Callable[..., Any]) no_type_check = object() def no_type_check_decorator(decorator: _C) -> _C: ... # Type aliases and type constructors class _Alias: # Class for defining generic aliases for library types. def __getitem__(self, typeargs: Any) -> Any: ... List = _Alias() Dict = _Alias() DefaultDict = _Alias() Set = _Alias() FrozenSet = _Alias() Counter = _Alias() Deque = _Alias() ChainMap = _Alias() if sys.version_info >= (3, 7): OrderedDict = _Alias() if sys.version_info >= (3, 9): Annotated: _SpecialForm = ... # Predefined type variables. AnyStr = TypeVar("AnyStr", str, bytes) # Abstract base classes. def runtime_checkable(cls: _TC) -> _TC: ... @runtime_checkable class SupportsInt(Protocol, metaclass=ABCMeta): @abstractmethod def __int__(self) -> int: ... @runtime_checkable class SupportsFloat(Protocol, metaclass=ABCMeta): @abstractmethod def __float__(self) -> float: ... @runtime_checkable class SupportsComplex(Protocol, metaclass=ABCMeta): @abstractmethod def __complex__(self) -> complex: ... @runtime_checkable class SupportsBytes(Protocol, metaclass=ABCMeta): @abstractmethod def __bytes__(self) -> bytes: ... if sys.version_info >= (3, 8): @runtime_checkable class SupportsIndex(Protocol, metaclass=ABCMeta): @abstractmethod def __index__(self) -> int: ... @runtime_checkable class SupportsAbs(Protocol[_T_co]): @abstractmethod def __abs__(self) -> _T_co: ... @runtime_checkable class SupportsRound(Protocol[_T_co]): @overload @abstractmethod def __round__(self) -> int: ... @overload @abstractmethod def __round__(self, ndigits: int) -> _T_co: ... @runtime_checkable class Sized(Protocol, metaclass=ABCMeta): @abstractmethod def __len__(self) -> int: ... @runtime_checkable class Hashable(Protocol, metaclass=ABCMeta): # TODO: This is special, in that a subclass of a hashable class may not be hashable # (for example, list vs. object). It's not obvious how to represent this. This class # is currently mostly useless for static checking. @abstractmethod def __hash__(self) -> int: ... @runtime_checkable class Iterable(Protocol[_T_co]): @abstractmethod def __iter__(self) -> Iterator[_T_co]: ... @runtime_checkable class Iterator(Iterable[_T_co], Protocol[_T_co]): @abstractmethod def __next__(self) -> _T_co: ... def __iter__(self) -> Iterator[_T_co]: ... @runtime_checkable class Reversible(Iterable[_T_co], Protocol[_T_co]): @abstractmethod def __reversed__(self) -> Iterator[_T_co]: ... class Generator(Iterator[_T_co], Generic[_T_co, _T_contra, _V_co]): def __next__(self) -> _T_co: ... @abstractmethod def send(self, __value: _T_contra) -> _T_co: ... @overload @abstractmethod def throw( self, __typ: Type[BaseException], __val: Union[BaseException, object] = ..., __tb: Optional[TracebackType] = ... ) -> _T_co: ... @overload @abstractmethod def throw(self, __typ: BaseException, __val: None = ..., __tb: Optional[TracebackType] = ...) -> _T_co: ... def close(self) -> None: ... def __iter__(self) -> Generator[_T_co, _T_contra, _V_co]: ... @property def gi_code(self) -> CodeType: ... @property def gi_frame(self) -> FrameType: ... @property def gi_running(self) -> bool: ... @property def gi_yieldfrom(self) -> Optional[Generator[Any, Any, Any]]: ... @runtime_checkable class Awaitable(Protocol[_T_co]): @abstractmethod def __await__(self) -> Generator[Any, None, _T_co]: ... class Coroutine(Awaitable[_V_co], Generic[_T_co, _T_contra, _V_co]): __name__: str __qualname__: str @property def cr_await(self) -> Optional[Any]: ... @property def cr_code(self) -> CodeType: ... @property def cr_frame(self) -> FrameType: ... @property def cr_running(self) -> bool: ... @abstractmethod def send(self, __value: _T_contra) -> _T_co: ... @overload @abstractmethod def throw( self, __typ: Type[BaseException], __val: Union[BaseException, object] = ..., __tb: Optional[TracebackType] = ... ) -> _T_co: ... @overload @abstractmethod def throw(self, __typ: BaseException, __val: None = ..., __tb: Optional[TracebackType] = ...) -> _T_co: ... @abstractmethod def close(self) -> None: ... # NOTE: This type does not exist in typing.py or PEP 484. # The parameters correspond to Generator, but the 4th is the original type. class AwaitableGenerator( Awaitable[_V_co], Generator[_T_co, _T_contra, _V_co], Generic[_T_co, _T_contra, _V_co, _S], metaclass=ABCMeta ): ... @runtime_checkable class AsyncIterable(Protocol[_T_co]): @abstractmethod def __aiter__(self) -> AsyncIterator[_T_co]: ... @runtime_checkable class AsyncIterator(AsyncIterable[_T_co], Protocol[_T_co]): @abstractmethod def __anext__(self) -> Awaitable[_T_co]: ... def __aiter__(self) -> AsyncIterator[_T_co]: ... class AsyncGenerator(AsyncIterator[_T_co], Generic[_T_co, _T_contra]): @abstractmethod def __anext__(self) -> Awaitable[_T_co]: ... @abstractmethod def asend(self, __value: _T_contra) -> Awaitable[_T_co]: ... @overload @abstractmethod def athrow( self, __typ: Type[BaseException], __val: Union[BaseException, object] = ..., __tb: Optional[TracebackType] = ... ) -> Awaitable[_T_co]: ... @overload @abstractmethod def athrow(self, __typ: BaseException, __val: None = ..., __tb: Optional[TracebackType] = ...) -> Awaitable[_T_co]: ... @abstractmethod def aclose(self) -> Awaitable[None]: ... @abstractmethod def __aiter__(self) -> AsyncGenerator[_T_co, _T_contra]: ... @property def ag_await(self) -> Any: ... @property def ag_code(self) -> CodeType: ... @property def ag_frame(self) -> FrameType: ... @property def ag_running(self) -> bool: ... @runtime_checkable class Container(Protocol[_T_co]): @abstractmethod def __contains__(self, __x: object) -> bool: ... @runtime_checkable class Collection(Iterable[_T_co], Container[_T_co], Protocol[_T_co]): # Implement Sized (but don't have it as a base class). @abstractmethod def __len__(self) -> int: ... _Collection = Collection[_T_co] class Sequence(_Collection[_T_co], Reversible[_T_co], Generic[_T_co]): @overload @abstractmethod def __getitem__(self, i: int) -> _T_co: ... @overload @abstractmethod def __getitem__(self, s: slice) -> Sequence[_T_co]: ... # Mixin methods def index(self, value: Any, start: int = ..., stop: int = ...) -> int: ... def count(self, value: Any) -> int: ... def __contains__(self, x: object) -> bool: ... def __iter__(self) -> Iterator[_T_co]: ... def __reversed__(self) -> Iterator[_T_co]: ... class MutableSequence(Sequence[_T], Generic[_T]): @abstractmethod def insert(self, index: int, value: _T) -> None: ... @overload @abstractmethod def __getitem__(self, i: int) -> _T: ... @overload @abstractmethod def __getitem__(self, s: slice) -> MutableSequence[_T]: ... @overload @abstractmethod def __setitem__(self, i: int, o: _T) -> None: ... @overload @abstractmethod def __setitem__(self, s: slice, o: Iterable[_T]) -> None: ... @overload @abstractmethod def __delitem__(self, i: int) -> None: ... @overload @abstractmethod def __delitem__(self, i: slice) -> None: ... # Mixin methods def append(self, value: _T) -> None: ... def clear(self) -> None: ... def extend(self, values: Iterable[_T]) -> None: ... def reverse(self) -> None: ... def pop(self, index: int = ...) -> _T: ... def remove(self, value: _T) -> None: ... def __iadd__(self, x: Iterable[_T]) -> MutableSequence[_T]: ... class AbstractSet(_Collection[_T_co], Generic[_T_co]): @abstractmethod def __contains__(self, x: object) -> bool: ... # Mixin methods def __le__(self, s: AbstractSet[Any]) -> bool: ... def __lt__(self, s: AbstractSet[Any]) -> bool: ... def __gt__(self, s: AbstractSet[Any]) -> bool: ... def __ge__(self, s: AbstractSet[Any]) -> bool: ... def __and__(self, s: AbstractSet[Any]) -> AbstractSet[_T_co]: ... def __or__(self, s: AbstractSet[_T]) -> AbstractSet[Union[_T_co, _T]]: ... def __sub__(self, s: AbstractSet[Any]) -> AbstractSet[_T_co]: ... def __xor__(self, s: AbstractSet[_T]) -> AbstractSet[Union[_T_co, _T]]: ... def isdisjoint(self, other: Iterable[Any]) -> bool: ... class MutableSet(AbstractSet[_T], Generic[_T]): @abstractmethod def add(self, value: _T) -> None: ... @abstractmethod def discard(self, value: _T) -> None: ... # Mixin methods def clear(self) -> None: ... def pop(self) -> _T: ... def remove(self, value: _T) -> None: ... def __ior__(self, s: AbstractSet[_S]) -> MutableSet[Union[_T, _S]]: ... def __iand__(self, s: AbstractSet[Any]) -> MutableSet[_T]: ... def __ixor__(self, s: AbstractSet[_S]) -> MutableSet[Union[_T, _S]]: ... def __isub__(self, s: AbstractSet[Any]) -> MutableSet[_T]: ... class MappingView(Sized): def __init__(self, mapping: Mapping[_KT_co, _VT_co]) -> None: ... # undocumented def __len__(self) -> int: ... class ItemsView(MappingView, AbstractSet[Tuple[_KT_co, _VT_co]], Generic[_KT_co, _VT_co]): def __init__(self, mapping: Mapping[_KT_co, _VT_co]) -> None: ... # undocumented def __and__(self, o: Iterable[Any]) -> Set[Tuple[_KT_co, _VT_co]]: ... def __rand__(self, o: Iterable[_T]) -> Set[_T]: ... def __contains__(self, o: object) -> bool: ... def __iter__(self) -> Iterator[Tuple[_KT_co, _VT_co]]: ... if sys.version_info >= (3, 8): def __reversed__(self) -> Iterator[Tuple[_KT_co, _VT_co]]: ... def __or__(self, o: Iterable[_T]) -> Set[Union[Tuple[_KT_co, _VT_co], _T]]: ... def __ror__(self, o: Iterable[_T]) -> Set[Union[Tuple[_KT_co, _VT_co], _T]]: ... def __sub__(self, o: Iterable[Any]) -> Set[Tuple[_KT_co, _VT_co]]: ... def __rsub__(self, o: Iterable[_T]) -> Set[_T]: ... def __xor__(self, o: Iterable[_T]) -> Set[Union[Tuple[_KT_co, _VT_co], _T]]: ... def __rxor__(self, o: Iterable[_T]) -> Set[Union[Tuple[_KT_co, _VT_co], _T]]: ... class KeysView(MappingView, AbstractSet[_KT_co], Generic[_KT_co]): def __init__(self, mapping: Mapping[_KT_co, _VT_co]) -> None: ... # undocumented def __and__(self, o: Iterable[Any]) -> Set[_KT_co]: ... def __rand__(self, o: Iterable[_T]) -> Set[_T]: ... def __contains__(self, o: object) -> bool: ... def __iter__(self) -> Iterator[_KT_co]: ... if sys.version_info >= (3, 8): def __reversed__(self) -> Iterator[_KT_co]: ... def __or__(self, o: Iterable[_T]) -> Set[Union[_KT_co, _T]]: ... def __ror__(self, o: Iterable[_T]) -> Set[Union[_KT_co, _T]]: ... def __sub__(self, o: Iterable[Any]) -> Set[_KT_co]: ... def __rsub__(self, o: Iterable[_T]) -> Set[_T]: ... def __xor__(self, o: Iterable[_T]) -> Set[Union[_KT_co, _T]]: ... def __rxor__(self, o: Iterable[_T]) -> Set[Union[_KT_co, _T]]: ... class ValuesView(MappingView, Iterable[_VT_co], Generic[_VT_co]): def __init__(self, mapping: Mapping[_KT_co, _VT_co]) -> None: ... # undocumented def __contains__(self, o: object) -> bool: ... def __iter__(self) -> Iterator[_VT_co]: ... if sys.version_info >= (3, 8): def __reversed__(self) -> Iterator[_VT_co]: ... @runtime_checkable class ContextManager(Protocol[_T_co]): def __enter__(self) -> _T_co: ... def __exit__( self, __exc_type: Optional[Type[BaseException]], __exc_value: Optional[BaseException], __traceback: Optional[TracebackType], ) -> Optional[bool]: ... @runtime_checkable class AsyncContextManager(Protocol[_T_co]): def __aenter__(self) -> Awaitable[_T_co]: ... def __aexit__( self, exc_type: Optional[Type[BaseException]], exc_value: Optional[BaseException], traceback: Optional[TracebackType] ) -> Awaitable[Optional[bool]]: ... class Mapping(_Collection[_KT], Generic[_KT, _VT_co]): # TODO: We wish the key type could also be covariant, but that doesn't work, # see discussion in https: //github.com/python/typing/pull/273. @abstractmethod def __getitem__(self, k: _KT) -> _VT_co: ... # Mixin methods @overload def get(self, key: _KT) -> Optional[_VT_co]: ... @overload def get(self, key: _KT, default: Union[_VT_co, _T]) -> Union[_VT_co, _T]: ... def items(self) -> AbstractSet[Tuple[_KT, _VT_co]]: ... def keys(self) -> AbstractSet[_KT]: ... def values(self) -> ValuesView[_VT_co]: ... def __contains__(self, o: object) -> bool: ... class MutableMapping(Mapping[_KT, _VT], Generic[_KT, _VT]): @abstractmethod def __setitem__(self, k: _KT, v: _VT) -> None: ... @abstractmethod def __delitem__(self, v: _KT) -> None: ... def clear(self) -> None: ... @overload def pop(self, key: _KT) -> _VT: ... @overload def pop(self, key: _KT, default: Union[_VT, _T] = ...) -> Union[_VT, _T]: ... def popitem(self) -> Tuple[_KT, _VT]: ... def setdefault(self, key: _KT, default: _VT = ...) -> _VT: ... # 'update' used to take a Union, but using overloading is better. # The second overloaded type here is a bit too general, because # Mapping[Tuple[_KT, _VT], W] is a subclass of Iterable[Tuple[_KT, _VT]], # but will always have the behavior of the first overloaded type # at runtime, leading to keys of a mix of types _KT and Tuple[_KT, _VT]. # We don't currently have any way of forcing all Mappings to use # the first overload, but by using overloading rather than a Union, # mypy will commit to using the first overload when the argument is # known to be a Mapping with unknown type parameters, which is closer # to the behavior we want. See mypy issue #1430. @overload def update(self, __m: Mapping[_KT, _VT], **kwargs: _VT) -> None: ... @overload def update(self, __m: Iterable[Tuple[_KT, _VT]], **kwargs: _VT) -> None: ... @overload def update(self, **kwargs: _VT) -> None: ... Text = str TYPE_CHECKING = True class IO(Iterator[AnyStr], Generic[AnyStr]): # TODO use abstract properties @property def mode(self) -> str: ... @property def name(self) -> str: ... @abstractmethod def close(self) -> None: ... @property def closed(self) -> bool: ... @abstractmethod def fileno(self) -> int: ... @abstractmethod def flush(self) -> None: ... @abstractmethod def isatty(self) -> bool: ... @abstractmethod def read(self, n: int = ...) -> AnyStr: ... @abstractmethod def readable(self) -> bool: ... @abstractmethod def readline(self, limit: int = ...) -> AnyStr: ... @abstractmethod def readlines(self, hint: int = ...) -> list[AnyStr]: ... @abstractmethod def seek(self, offset: int, whence: int = ...) -> int: ... @abstractmethod def seekable(self) -> bool: ... @abstractmethod def tell(self) -> int: ... @abstractmethod def truncate(self, size: Optional[int] = ...) -> int: ... @abstractmethod def writable(self) -> bool: ... @abstractmethod def write(self, s: AnyStr) -> int: ... @abstractmethod def writelines(self, lines: Iterable[AnyStr]) -> None: ... @abstractmethod def __next__(self) -> AnyStr: ... @abstractmethod def __iter__(self) -> Iterator[AnyStr]: ... @abstractmethod def __enter__(self) -> IO[AnyStr]: ... @abstractmethod def __exit__( self, t: Optional[Type[BaseException]], value: Optional[BaseException], traceback: Optional[TracebackType] ) -> Optional[bool]: ... class BinaryIO(IO[bytes]): @abstractmethod def __enter__(self) -> BinaryIO: ... class TextIO(IO[str]): # TODO use abstractproperty @property def buffer(self) -> BinaryIO: ... @property def encoding(self) -> str: ... @property def errors(self) -> Optional[str]: ... @property def line_buffering(self) -> int: ... # int on PyPy, bool on CPython @property def newlines(self) -> Any: ... # None, str or tuple @abstractmethod def __enter__(self) -> TextIO: ... class ByteString(Sequence[int], metaclass=ABCMeta): ... class Match(Generic[AnyStr]): pos: int endpos: int lastindex: Optional[int] lastgroup: Optional[AnyStr] string: AnyStr # The regular expression object whose match() or search() method produced # this match instance. re: Pattern[AnyStr] def expand(self, template: AnyStr) -> AnyStr: ... # TODO: The return for a group may be None, except if __group is 0 or not given. @overload def group(self, __group: Union[str, int] = ...) -> AnyStr: ... @overload def group(self, __group1: Union[str, int], __group2: Union[str, int], *groups: Union[str, int]) -> Tuple[AnyStr, ...]: ... def groups(self, default: AnyStr = ...) -> Sequence[AnyStr]: ... def groupdict(self, default: AnyStr = ...) -> dict[str, AnyStr]: ... def start(self, __group: Union[int, str] = ...) -> int: ... def end(self, __group: Union[int, str] = ...) -> int: ... def span(self, __group: Union[int, str] = ...) -> Tuple[int, int]: ... @property def regs(self) -> Tuple[Tuple[int, int], ...]: ... # undocumented def __getitem__(self, g: Union[int, str]) -> AnyStr: ... if sys.version_info >= (3, 9): def __class_getitem__(cls, item: Any) -> GenericAlias: ... class Pattern(Generic[AnyStr]): flags: int groupindex: Mapping[str, int] groups: int pattern: AnyStr def search(self, string: AnyStr, pos: int = ..., endpos: int = ...) -> Optional[Match[AnyStr]]: ... def match(self, string: AnyStr, pos: int = ..., endpos: int = ...) -> Optional[Match[AnyStr]]: ... # New in Python 3.4 def fullmatch(self, string: AnyStr, pos: int = ..., endpos: int = ...) -> Optional[Match[AnyStr]]: ... def split(self, string: AnyStr, maxsplit: int = ...) -> list[AnyStr]: ... def findall(self, string: AnyStr, pos: int = ..., endpos: int = ...) -> list[Any]: ... def finditer(self, string: AnyStr, pos: int = ..., endpos: int = ...) -> Iterator[Match[AnyStr]]: ... @overload def sub(self, repl: AnyStr, string: AnyStr, count: int = ...) -> AnyStr: ... @overload def sub(self, repl: Callable[[Match[AnyStr]], AnyStr], string: AnyStr, count: int = ...) -> AnyStr: ... @overload def subn(self, repl: AnyStr, string: AnyStr, count: int = ...) -> Tuple[AnyStr, int]: ... @overload def subn(self, repl: Callable[[Match[AnyStr]], AnyStr], string: AnyStr, count: int = ...) -> Tuple[AnyStr, int]: ... if sys.version_info >= (3, 9): def __class_getitem__(cls, item: Any) -> GenericAlias: ... # Functions if sys.version_info >= (3, 7): _get_type_hints_obj_allowed_types = Union[ object, Callable[..., Any], FunctionType, BuiltinFunctionType, MethodType, ModuleType, WrapperDescriptorType, MethodWrapperType, MethodDescriptorType, ] else: _get_type_hints_obj_allowed_types = Union[ object, Callable[..., Any], FunctionType, BuiltinFunctionType, MethodType, ModuleType, ] if sys.version_info >= (3, 9): def get_type_hints( obj: _get_type_hints_obj_allowed_types, globalns: Optional[Dict[str, Any]] = ..., localns: Optional[Dict[str, Any]] = ..., include_extras: bool = ..., ) -> Dict[str, Any]: ... else: def get_type_hints( obj: _get_type_hints_obj_allowed_types, globalns: Optional[Dict[str, Any]] = ..., localns: Optional[Dict[str, Any]] = ..., ) -> Dict[str, Any]: ... if sys.version_info >= (3, 8): def get_origin(tp: Any) -> Optional[Any]: ... def get_args(tp: Any) -> Tuple[Any, ...]: ... @overload def cast(typ: Type[_T], val: Any) -> _T: ... @overload def cast(typ: str, val: Any) -> Any: ... @overload def cast(typ: object, val: Any) -> Any: ... # Type constructors # NamedTuple is special-cased in the type checker class NamedTuple(Tuple[Any, ...]): _field_types: collections.OrderedDict[str, Type[Any]] _field_defaults: Dict[str, Any] = ... _fields: Tuple[str, ...] _source: str def __init__(self, typename: str, fields: Iterable[Tuple[str, Any]] = ..., **kwargs: Any) -> None: ... @classmethod def _make(cls: Type[_T], iterable: Iterable[Any]) -> _T: ... if sys.version_info >= (3, 8): def _asdict(self) -> Dict[str, Any]: ... else: def _asdict(self) -> collections.OrderedDict[str, Any]: ... def _replace(self: _T, **kwargs: Any) -> _T: ... # Internal mypy fallback type for all typed dicts (does not exist at runtime) class _TypedDict(Mapping[str, object], metaclass=ABCMeta): def copy(self: _T) -> _T: ... # Using NoReturn so that only calls using mypy plugin hook that specialize the signature # can go through. def setdefault(self, k: NoReturn, default: object) -> object: ... # Mypy plugin hook for 'pop' expects that 'default' has a type variable type. def pop(self, k: NoReturn, default: _T = ...) -> object: ... def update(self: _T, __m: _T) -> None: ... def __delitem__(self, k: NoReturn) -> None: ... def items(self) -> ItemsView[str, object]: ... def keys(self) -> KeysView[str]: ... def values(self) -> ValuesView[object]: ... def NewType(name: str, tp: Type[_T]) -> Type[_T]: ... # This itself is only available during type checking def type_check_only(func_or_cls: _C) -> _C: ... if sys.version_info >= (3, 7): from types import CodeType class ForwardRef: __forward_arg__: str __forward_code__: CodeType __forward_evaluated__: bool __forward_value__: Optional[Any] __forward_is_argument__: bool def __init__(self, arg: str, is_argument: bool = ...) -> None: ... def _evaluate(self, globalns: Optional[Dict[str, Any]], localns: Optional[Dict[str, Any]]) -> Optional[Any]: ... def __eq__(self, other: Any) -> bool: ... def __hash__(self) -> int: ... def __repr__(self) -> str: ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4343793 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/unittest/0000775000175000017500000000000000000000000022773 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/unittest/__init__.pyi0000664000175000017500000000060300000000000025254 0ustar00davedave00000000000000from typing import Optional from unittest.async_case import * from unittest.case import * from unittest.loader import * from unittest.main import * from unittest.result import TestResult as TestResult from unittest.runner import * from unittest.signals import * from unittest.suite import * def load_tests(loader: TestLoader, tests: TestSuite, pattern: Optional[str]) -> TestSuite: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/unittest/async_case.pyi0000664000175000017500000000056400000000000025633 0ustar00davedave00000000000000import sys from typing import Any, Awaitable, Callable from .case import TestCase if sys.version_info >= (3, 8): class IsolatedAsyncioTestCase(TestCase): async def asyncSetUp(self) -> None: ... async def asyncTearDown(self) -> None: ... def addAsyncCleanup(self, __func: Callable[..., Awaitable[Any]], *args: Any, **kwargs: Any) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/unittest/case.pyi0000664000175000017500000003030300000000000024430 0ustar00davedave00000000000000import datetime import logging import sys import unittest.result from types import TracebackType from typing import ( Any, AnyStr, Callable, Container, ContextManager, Dict, FrozenSet, Generic, Iterable, List, Mapping, NoReturn, Optional, Pattern, Sequence, Set, Tuple, Type, TypeVar, Union, overload, ) from warnings import WarningMessage if sys.version_info >= (3, 9): from types import GenericAlias _E = TypeVar("_E", bound=BaseException) _FT = TypeVar("_FT", bound=Callable[..., Any]) if sys.version_info >= (3, 8): def addModuleCleanup(__function: Callable[..., Any], *args: Any, **kwargs: Any) -> None: ... def doModuleCleanups() -> None: ... def expectedFailure(test_item: _FT) -> _FT: ... def skip(reason: str) -> Callable[[_FT], _FT]: ... def skipIf(condition: object, reason: str) -> Callable[[_FT], _FT]: ... def skipUnless(condition: object, reason: str) -> Callable[[_FT], _FT]: ... class SkipTest(Exception): def __init__(self, reason: str) -> None: ... class TestCase: failureException: Type[BaseException] longMessage: bool maxDiff: Optional[int] # undocumented _testMethodName: str # undocumented _testMethodDoc: str def __init__(self, methodName: str = ...) -> None: ... def setUp(self) -> None: ... def tearDown(self) -> None: ... @classmethod def setUpClass(cls) -> None: ... @classmethod def tearDownClass(cls) -> None: ... def run(self, result: Optional[unittest.result.TestResult] = ...) -> Optional[unittest.result.TestResult]: ... def __call__(self, result: Optional[unittest.result.TestResult] = ...) -> Optional[unittest.result.TestResult]: ... def skipTest(self, reason: Any) -> None: ... def subTest(self, msg: Any = ..., **params: Any) -> ContextManager[None]: ... def debug(self) -> None: ... def _addSkip(self, result: unittest.result.TestResult, test_case: TestCase, reason: str) -> None: ... def assertEqual(self, first: Any, second: Any, msg: Any = ...) -> None: ... def assertNotEqual(self, first: Any, second: Any, msg: Any = ...) -> None: ... def assertTrue(self, expr: Any, msg: Any = ...) -> None: ... def assertFalse(self, expr: Any, msg: Any = ...) -> None: ... def assertIs(self, expr1: Any, expr2: Any, msg: Any = ...) -> None: ... def assertIsNot(self, expr1: Any, expr2: Any, msg: Any = ...) -> None: ... def assertIsNone(self, obj: Any, msg: Any = ...) -> None: ... def assertIsNotNone(self, obj: Any, msg: Any = ...) -> None: ... def assertIn(self, member: Any, container: Union[Iterable[Any], Container[Any]], msg: Any = ...) -> None: ... def assertNotIn(self, member: Any, container: Union[Iterable[Any], Container[Any]], msg: Any = ...) -> None: ... def assertIsInstance(self, obj: Any, cls: Union[type, Tuple[type, ...]], msg: Any = ...) -> None: ... def assertNotIsInstance(self, obj: Any, cls: Union[type, Tuple[type, ...]], msg: Any = ...) -> None: ... def assertGreater(self, a: Any, b: Any, msg: Any = ...) -> None: ... def assertGreaterEqual(self, a: Any, b: Any, msg: Any = ...) -> None: ... def assertLess(self, a: Any, b: Any, msg: Any = ...) -> None: ... def assertLessEqual(self, a: Any, b: Any, msg: Any = ...) -> None: ... @overload def assertRaises( # type: ignore self, expected_exception: Union[Type[BaseException], Tuple[Type[BaseException], ...]], callable: Callable[..., Any], *args: Any, **kwargs: Any, ) -> None: ... @overload def assertRaises( self, expected_exception: Union[Type[_E], Tuple[Type[_E], ...]], msg: Any = ... ) -> _AssertRaisesContext[_E]: ... @overload def assertRaisesRegex( # type: ignore self, expected_exception: Union[Type[BaseException], Tuple[Type[BaseException], ...]], expected_regex: Union[str, bytes, Pattern[str], Pattern[bytes]], callable: Callable[..., Any], *args: Any, **kwargs: Any, ) -> None: ... @overload def assertRaisesRegex( self, expected_exception: Union[Type[_E], Tuple[Type[_E], ...]], expected_regex: Union[str, bytes, Pattern[str], Pattern[bytes]], msg: Any = ..., ) -> _AssertRaisesContext[_E]: ... @overload def assertWarns( # type: ignore self, expected_warning: Union[Type[Warning], Tuple[Type[Warning], ...]], callable: Callable[..., Any], *args: Any, **kwargs: Any, ) -> None: ... @overload def assertWarns( self, expected_warning: Union[Type[Warning], Tuple[Type[Warning], ...]], msg: Any = ... ) -> _AssertWarnsContext: ... @overload def assertWarnsRegex( # type: ignore self, expected_warning: Union[Type[Warning], Tuple[Type[Warning], ...]], expected_regex: Union[str, bytes, Pattern[str], Pattern[bytes]], callable: Callable[..., Any], *args: Any, **kwargs: Any, ) -> None: ... @overload def assertWarnsRegex( self, expected_warning: Union[Type[Warning], Tuple[Type[Warning], ...]], expected_regex: Union[str, bytes, Pattern[str], Pattern[bytes]], msg: Any = ..., ) -> _AssertWarnsContext: ... def assertLogs( self, logger: Optional[Union[str, logging.Logger]] = ..., level: Union[int, str, None] = ... ) -> _AssertLogsContext: ... @overload def assertAlmostEqual( self, first: float, second: float, places: Optional[int] = ..., msg: Any = ..., delta: Optional[float] = ... ) -> None: ... @overload def assertAlmostEqual( self, first: datetime.datetime, second: datetime.datetime, places: Optional[int] = ..., msg: Any = ..., delta: Optional[datetime.timedelta] = ..., ) -> None: ... @overload def assertNotAlmostEqual(self, first: float, second: float, *, msg: Any = ...) -> None: ... @overload def assertNotAlmostEqual(self, first: float, second: float, places: Optional[int] = ..., msg: Any = ...) -> None: ... @overload def assertNotAlmostEqual(self, first: float, second: float, *, msg: Any = ..., delta: Optional[float] = ...) -> None: ... @overload def assertNotAlmostEqual( self, first: datetime.datetime, second: datetime.datetime, places: Optional[int] = ..., msg: Any = ..., delta: Optional[datetime.timedelta] = ..., ) -> None: ... def assertRegex(self, text: AnyStr, expected_regex: Union[AnyStr, Pattern[AnyStr]], msg: Any = ...) -> None: ... def assertNotRegex(self, text: AnyStr, unexpected_regex: Union[AnyStr, Pattern[AnyStr]], msg: Any = ...) -> None: ... def assertCountEqual(self, first: Iterable[Any], second: Iterable[Any], msg: Any = ...) -> None: ... def addTypeEqualityFunc(self, typeobj: Type[Any], function: Callable[..., None]) -> None: ... def assertMultiLineEqual(self, first: str, second: str, msg: Any = ...) -> None: ... def assertSequenceEqual( self, seq1: Sequence[Any], seq2: Sequence[Any], msg: Any = ..., seq_type: Optional[Type[Sequence[Any]]] = ... ) -> None: ... def assertListEqual(self, list1: List[Any], list2: List[Any], msg: Any = ...) -> None: ... def assertTupleEqual(self, tuple1: Tuple[Any, ...], tuple2: Tuple[Any, ...], msg: Any = ...) -> None: ... def assertSetEqual( self, set1: Union[Set[Any], FrozenSet[Any]], set2: Union[Set[Any], FrozenSet[Any]], msg: Any = ... ) -> None: ... def assertDictEqual(self, d1: Dict[Any, Any], d2: Dict[Any, Any], msg: Any = ...) -> None: ... def fail(self, msg: Any = ...) -> NoReturn: ... def countTestCases(self) -> int: ... def defaultTestResult(self) -> unittest.result.TestResult: ... def id(self) -> str: ... def shortDescription(self) -> Optional[str]: ... if sys.version_info >= (3, 8): def addCleanup(self, __function: Callable[..., Any], *args: Any, **kwargs: Any) -> None: ... else: def addCleanup(self, function: Callable[..., Any], *args: Any, **kwargs: Any) -> None: ... def doCleanups(self) -> None: ... if sys.version_info >= (3, 8): @classmethod def addClassCleanup(cls, __function: Callable[..., Any], *args: Any, **kwargs: Any) -> None: ... @classmethod def doClassCleanups(cls) -> None: ... def _formatMessage(self, msg: Optional[str], standardMsg: str) -> str: ... # undocumented def _getAssertEqualityFunc(self, first: Any, second: Any) -> Callable[..., None]: ... # undocumented # below is deprecated def failUnlessEqual(self, first: Any, second: Any, msg: Any = ...) -> None: ... def assertEquals(self, first: Any, second: Any, msg: Any = ...) -> None: ... def failIfEqual(self, first: Any, second: Any, msg: Any = ...) -> None: ... def assertNotEquals(self, first: Any, second: Any, msg: Any = ...) -> None: ... def failUnless(self, expr: bool, msg: Any = ...) -> None: ... def assert_(self, expr: bool, msg: Any = ...) -> None: ... def failIf(self, expr: bool, msg: Any = ...) -> None: ... @overload def failUnlessRaises( # type: ignore self, exception: Union[Type[BaseException], Tuple[Type[BaseException], ...]], callable: Callable[..., Any] = ..., *args: Any, **kwargs: Any, ) -> None: ... @overload def failUnlessRaises(self, exception: Union[Type[_E], Tuple[Type[_E], ...]], msg: Any = ...) -> _AssertRaisesContext[_E]: ... def failUnlessAlmostEqual(self, first: float, second: float, places: int = ..., msg: Any = ...) -> None: ... def assertAlmostEquals(self, first: float, second: float, places: int = ..., msg: Any = ..., delta: float = ...) -> None: ... def failIfAlmostEqual(self, first: float, second: float, places: int = ..., msg: Any = ...) -> None: ... def assertNotAlmostEquals( self, first: float, second: float, places: int = ..., msg: Any = ..., delta: float = ... ) -> None: ... def assertRegexpMatches(self, text: AnyStr, regex: Union[AnyStr, Pattern[AnyStr]], msg: Any = ...) -> None: ... def assertNotRegexpMatches(self, text: AnyStr, regex: Union[AnyStr, Pattern[AnyStr]], msg: Any = ...) -> None: ... @overload def assertRaisesRegexp( # type: ignore self, exception: Union[Type[BaseException], Tuple[Type[BaseException], ...]], expected_regex: Union[str, bytes, Pattern[str], Pattern[bytes]], callable: Callable[..., Any], *args: Any, **kwargs: Any, ) -> None: ... @overload def assertRaisesRegexp( self, exception: Union[Type[_E], Tuple[Type[_E], ...]], expected_regex: Union[str, bytes, Pattern[str], Pattern[bytes]], msg: Any = ..., ) -> _AssertRaisesContext[_E]: ... def assertDictContainsSubset(self, subset: Mapping[Any, Any], dictionary: Mapping[Any, Any], msg: object = ...) -> None: ... class FunctionTestCase(TestCase): def __init__( self, testFunc: Callable[[], None], setUp: Optional[Callable[[], None]] = ..., tearDown: Optional[Callable[[], None]] = ..., description: Optional[str] = ..., ) -> None: ... def runTest(self) -> None: ... class _AssertRaisesContext(Generic[_E]): exception: _E def __enter__(self) -> _AssertRaisesContext[_E]: ... def __exit__( self, exc_type: Optional[Type[BaseException]], exc_val: Optional[BaseException], exc_tb: Optional[TracebackType] ) -> bool: ... if sys.version_info >= (3, 9): def __class_getitem__(cls, item: Any) -> GenericAlias: ... class _AssertWarnsContext: warning: WarningMessage filename: str lineno: int warnings: List[WarningMessage] def __enter__(self) -> _AssertWarnsContext: ... def __exit__( self, exc_type: Optional[Type[BaseException]], exc_val: Optional[BaseException], exc_tb: Optional[TracebackType] ) -> None: ... class _AssertLogsContext: LOGGING_FORMAT: str records: List[logging.LogRecord] output: List[str] def __init__(self, test_case: TestCase, logger_name: str, level: int) -> None: ... def __enter__(self) -> _AssertLogsContext: ... def __exit__( self, exc_type: Optional[Type[BaseException]], exc_val: Optional[BaseException], exc_tb: Optional[TracebackType] ) -> Optional[bool]: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/unittest/loader.pyi0000664000175000017500000000402300000000000024763 0ustar00davedave00000000000000import sys import unittest.case import unittest.result import unittest.suite from types import ModuleType from typing import Any, Callable, List, Optional, Sequence, Type _SortComparisonMethod = Callable[[str, str], int] _SuiteClass = Callable[[List[unittest.case.TestCase]], unittest.suite.TestSuite] class TestLoader: errors: List[Type[BaseException]] testMethodPrefix: str sortTestMethodsUsing: _SortComparisonMethod if sys.version_info >= (3, 7): testNamePatterns: Optional[List[str]] suiteClass: _SuiteClass def loadTestsFromTestCase(self, testCaseClass: Type[unittest.case.TestCase]) -> unittest.suite.TestSuite: ... def loadTestsFromModule(self, module: ModuleType, *args: Any, pattern: Any = ...) -> unittest.suite.TestSuite: ... def loadTestsFromName(self, name: str, module: Optional[ModuleType] = ...) -> unittest.suite.TestSuite: ... def loadTestsFromNames(self, names: Sequence[str], module: Optional[ModuleType] = ...) -> unittest.suite.TestSuite: ... def getTestCaseNames(self, testCaseClass: Type[unittest.case.TestCase]) -> Sequence[str]: ... def discover(self, start_dir: str, pattern: str = ..., top_level_dir: Optional[str] = ...) -> unittest.suite.TestSuite: ... defaultTestLoader: TestLoader if sys.version_info >= (3, 7): def getTestCaseNames( testCaseClass: Type[unittest.case.TestCase], prefix: str, sortUsing: _SortComparisonMethod = ..., testNamePatterns: Optional[List[str]] = ..., ) -> Sequence[str]: ... else: def getTestCaseNames( testCaseClass: Type[unittest.case.TestCase], prefix: str, sortUsing: _SortComparisonMethod = ... ) -> Sequence[str]: ... def makeSuite( testCaseClass: Type[unittest.case.TestCase], prefix: str = ..., sortUsing: _SortComparisonMethod = ..., suiteClass: _SuiteClass = ..., ) -> unittest.suite.TestSuite: ... def findTestCases( module: ModuleType, prefix: str = ..., sortUsing: _SortComparisonMethod = ..., suiteClass: _SuiteClass = ... ) -> unittest.suite.TestSuite: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/unittest/main.pyi0000664000175000017500000000323300000000000024443 0ustar00davedave00000000000000import sys import unittest.case import unittest.loader import unittest.result import unittest.suite from types import ModuleType from typing import Any, Iterable, List, Optional, Protocol, Type, Union class _TestRunner(Protocol): def run(self, test: Union[unittest.suite.TestSuite, unittest.case.TestCase]) -> unittest.result.TestResult: ... # not really documented class TestProgram: result: unittest.result.TestResult module: Union[None, str, ModuleType] verbosity: int failfast: Optional[bool] catchbreak: Optional[bool] buffer: Optional[bool] progName: Optional[str] warnings: Optional[str] if sys.version_info >= (3, 7): testNamePatterns: Optional[List[str]] def __init__( self, module: Union[None, str, ModuleType] = ..., defaultTest: Union[str, Iterable[str], None] = ..., argv: Optional[List[str]] = ..., testRunner: Union[Type[_TestRunner], _TestRunner, None] = ..., testLoader: unittest.loader.TestLoader = ..., exit: bool = ..., verbosity: int = ..., failfast: Optional[bool] = ..., catchbreak: Optional[bool] = ..., buffer: Optional[bool] = ..., warnings: Optional[str] = ..., *, tb_locals: bool = ..., ) -> None: ... def usageExit(self, msg: Any = ...) -> None: ... def parseArgs(self, argv: List[str]) -> None: ... if sys.version_info >= (3, 7): def createTests(self, from_discovery: bool = ..., Loader: Optional[unittest.loader.TestLoader] = ...) -> None: ... else: def createTests(self) -> None: ... def runTests(self) -> None: ... # undocumented main = TestProgram ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/unittest/mock.pyi0000664000175000017500000003473100000000000024457 0ustar00davedave00000000000000import sys from typing import Any, Callable, Generic, List, Mapping, Optional, Sequence, Tuple, Type, TypeVar, Union, overload _F = TypeVar("_F", bound=Callable[..., Any]) _T = TypeVar("_T") _TT = TypeVar("_TT", bound=Type[Any]) _R = TypeVar("_R") __all__ = [ "Mock", "MagicMock", "patch", "sentinel", "DEFAULT", "ANY", "call", "create_autospec", "AsyncMock", "FILTER_DIR", "NonCallableMock", "NonCallableMagicMock", "mock_open", "PropertyMock", "seal", ] __version__: str FILTER_DIR: Any class _slotted: ... class _SentinelObject: name: Any def __init__(self, name: Any) -> None: ... class _Sentinel: def __init__(self) -> None: ... def __getattr__(self, name: str) -> Any: ... sentinel: Any DEFAULT: Any class _Call(Tuple[Any, ...]): def __new__( cls, value: Any = ..., name: Optional[Any] = ..., parent: Optional[Any] = ..., two: bool = ..., from_kall: bool = ... ) -> Any: ... name: Any parent: Any from_kall: Any def __init__( self, value: Any = ..., name: Optional[Any] = ..., parent: Optional[Any] = ..., two: bool = ..., from_kall: bool = ... ) -> None: ... def __eq__(self, other: Any) -> bool: ... __ne__: Any def __call__(self, *args: Any, **kwargs: Any) -> _Call: ... def __getattr__(self, attr: Any) -> Any: ... def count(self, *args: Any, **kwargs: Any) -> Any: ... def index(self, *args: Any, **kwargs: Any) -> Any: ... def call_list(self) -> Any: ... call: _Call class _CallList(List[_Call]): def __contains__(self, value: Any) -> bool: ... class _MockIter: obj: Any def __init__(self, obj: Any) -> None: ... def __iter__(self) -> Any: ... def __next__(self) -> Any: ... class Base: def __init__(self, *args: Any, **kwargs: Any) -> None: ... class NonCallableMock(Base, Any): # type: ignore def __new__(__cls, *args: Any, **kw: Any) -> NonCallableMock: ... def __init__( self, spec: Union[List[str], object, Type[object], None] = ..., wraps: Optional[Any] = ..., name: Optional[str] = ..., spec_set: Union[List[str], object, Type[object], None] = ..., parent: Optional[NonCallableMock] = ..., _spec_state: Optional[Any] = ..., _new_name: str = ..., _new_parent: Optional[NonCallableMock] = ..., _spec_as_instance: bool = ..., _eat_self: Optional[bool] = ..., unsafe: bool = ..., **kwargs: Any, ) -> None: ... def __getattr__(self, name: str) -> Any: ... if sys.version_info >= (3, 8): def _calls_repr(self, prefix: str = ...) -> str: ... def assert_called_with(self, *args: Any, **kwargs: Any) -> None: ... def assert_not_called(self) -> None: ... def assert_called_once_with(self, *args: Any, **kwargs: Any) -> None: ... def _format_mock_failure_message(self, args: Any, kwargs: Any, action: str = ...) -> str: ... elif sys.version_info >= (3, 5): def assert_called_with(_mock_self, *args: Any, **kwargs: Any) -> None: ... def assert_not_called(_mock_self) -> None: ... def assert_called_once_with(_mock_self, *args: Any, **kwargs: Any) -> None: ... def _format_mock_failure_message(self, args: Any, kwargs: Any) -> str: ... if sys.version_info >= (3, 8): def assert_called(self) -> None: ... def assert_called_once(self) -> None: ... elif sys.version_info >= (3, 6): def assert_called(_mock_self) -> None: ... def assert_called_once(_mock_self) -> None: ... if sys.version_info >= (3, 6): def reset_mock(self, visited: Any = ..., *, return_value: bool = ..., side_effect: bool = ...) -> None: ... elif sys.version_info >= (3, 5): def reset_mock(self, visited: Any = ...) -> None: ... if sys.version_info >= (3, 7): def _extract_mock_name(self) -> str: ... def _get_call_signature_from_name(self, name: str) -> Any: ... def assert_any_call(self, *args: Any, **kwargs: Any) -> None: ... def assert_has_calls(self, calls: Sequence[_Call], any_order: bool = ...) -> None: ... def mock_add_spec(self, spec: Any, spec_set: bool = ...) -> None: ... def _mock_add_spec(self, spec: Any, spec_set: bool, _spec_as_instance: bool = ..., _eat_self: bool = ...) -> None: ... def attach_mock(self, mock: NonCallableMock, attribute: str) -> None: ... def configure_mock(self, **kwargs: Any) -> None: ... return_value: Any side_effect: Any called: bool call_count: int call_args: Any call_args_list: _CallList mock_calls: _CallList def _format_mock_call_signature(self, args: Any, kwargs: Any) -> str: ... def _call_matcher(self, _call: Tuple[_Call, ...]) -> _Call: ... def _get_child_mock(self, **kw: Any) -> NonCallableMock: ... class CallableMixin(Base): side_effect: Any def __init__( self, spec: Optional[Any] = ..., side_effect: Optional[Any] = ..., return_value: Any = ..., wraps: Optional[Any] = ..., name: Optional[Any] = ..., spec_set: Optional[Any] = ..., parent: Optional[Any] = ..., _spec_state: Optional[Any] = ..., _new_name: Any = ..., _new_parent: Optional[Any] = ..., **kwargs: Any, ) -> None: ... def __call__(_mock_self, *args: Any, **kwargs: Any) -> Any: ... class Mock(CallableMixin, NonCallableMock): ... class _patch(Generic[_T]): attribute_name: Any getter: Callable[[], Any] attribute: str new: _T new_callable: Any spec: Any create: bool has_local: Any spec_set: Any autospec: Any kwargs: Mapping[str, Any] additional_patchers: Any if sys.version_info >= (3, 8): @overload def __init__( self: _patch[Union[MagicMock, AsyncMock]], getter: Callable[[], Any], attribute: str, *, spec: Optional[Any], create: bool, spec_set: Optional[Any], autospec: Optional[Any], new_callable: Optional[Any], kwargs: Mapping[str, Any], ) -> None: ... # This overload also covers the case, where new==DEFAULT. In this case, self is _patch[Any]. # Ideally we'd be able to add an overload for it so that self is _patch[MagicMock], # but that's impossible with the current type system. @overload def __init__( self: _patch[_T], getter: Callable[[], Any], attribute: str, new: _T, spec: Optional[Any], create: bool, spec_set: Optional[Any], autospec: Optional[Any], new_callable: Optional[Any], kwargs: Mapping[str, Any], ) -> None: ... else: @overload def __init__( self: _patch[MagicMock], getter: Callable[[], Any], attribute: str, *, spec: Optional[Any], create: bool, spec_set: Optional[Any], autospec: Optional[Any], new_callable: Optional[Any], kwargs: Mapping[str, Any], ) -> None: ... @overload def __init__( self: _patch[_T], getter: Callable[[], Any], attribute: str, new: _T, spec: Optional[Any], create: bool, spec_set: Optional[Any], autospec: Optional[Any], new_callable: Optional[Any], kwargs: Mapping[str, Any], ) -> None: ... def copy(self) -> _patch[_T]: ... def __call__(self, func: Callable[..., _R]) -> Callable[..., _R]: ... def decorate_class(self, klass: _TT) -> _TT: ... def decorate_callable(self, func: _F) -> _F: ... def get_original(self) -> Tuple[Any, bool]: ... target: Any temp_original: Any is_local: bool def __enter__(self) -> _T: ... def __exit__(self, *exc_info: Any) -> None: ... def start(self) -> _T: ... def stop(self) -> None: ... class _patch_dict: in_dict: Any values: Any clear: Any def __init__(self, in_dict: Any, values: Any = ..., clear: Any = ..., **kwargs: Any) -> None: ... def __call__(self, f: Any) -> Any: ... def decorate_class(self, klass: Any) -> Any: ... def __enter__(self) -> Any: ... def __exit__(self, *args: Any) -> Any: ... start: Any stop: Any class _patcher: TEST_PREFIX: str dict: Type[_patch_dict] if sys.version_info >= (3, 8): @overload def __call__( # type: ignore self, target: Any, *, spec: Optional[Any] = ..., create: bool = ..., spec_set: Optional[Any] = ..., autospec: Optional[Any] = ..., new_callable: Optional[Any] = ..., **kwargs: Any, ) -> _patch[Union[MagicMock, AsyncMock]]: ... # This overload also covers the case, where new==DEFAULT. In this case, the return type is _patch[Any]. # Ideally we'd be able to add an overload for it so that the return type is _patch[MagicMock], # but that's impossible with the current type system. @overload def __call__( self, target: Any, new: _T, spec: Optional[Any] = ..., create: bool = ..., spec_set: Optional[Any] = ..., autospec: Optional[Any] = ..., new_callable: Optional[Any] = ..., **kwargs: Any, ) -> _patch[_T]: ... else: @overload def __call__( # type: ignore self, target: Any, *, spec: Optional[Any] = ..., create: bool = ..., spec_set: Optional[Any] = ..., autospec: Optional[Any] = ..., new_callable: Optional[Any] = ..., **kwargs: Any, ) -> _patch[MagicMock]: ... @overload def __call__( self, target: Any, new: _T, spec: Optional[Any] = ..., create: bool = ..., spec_set: Optional[Any] = ..., autospec: Optional[Any] = ..., new_callable: Optional[Any] = ..., **kwargs: Any, ) -> _patch[_T]: ... if sys.version_info >= (3, 8): @overload def object( # type: ignore self, target: Any, attribute: str, *, spec: Optional[Any] = ..., create: bool = ..., spec_set: Optional[Any] = ..., autospec: Optional[Any] = ..., new_callable: Optional[Any] = ..., **kwargs: Any, ) -> _patch[Union[MagicMock, AsyncMock]]: ... @overload def object( self, target: Any, attribute: str, new: _T = ..., spec: Optional[Any] = ..., create: bool = ..., spec_set: Optional[Any] = ..., autospec: Optional[Any] = ..., new_callable: Optional[Any] = ..., **kwargs: Any, ) -> _patch[_T]: ... else: @overload def object( # type: ignore self, target: Any, attribute: str, *, spec: Optional[Any] = ..., create: bool = ..., spec_set: Optional[Any] = ..., autospec: Optional[Any] = ..., new_callable: Optional[Any] = ..., **kwargs: Any, ) -> _patch[MagicMock]: ... @overload def object( self, target: Any, attribute: str, new: _T = ..., spec: Optional[Any] = ..., create: bool = ..., spec_set: Optional[Any] = ..., autospec: Optional[Any] = ..., new_callable: Optional[Any] = ..., **kwargs: Any, ) -> _patch[_T]: ... def multiple( self, target: Any, spec: Optional[Any] = ..., create: bool = ..., spec_set: Optional[Any] = ..., autospec: Optional[Any] = ..., new_callable: Optional[Any] = ..., **kwargs: _T, ) -> _patch[_T]: ... def stopall(self) -> None: ... patch: _patcher class MagicMixin: def __init__(self, *args: Any, **kw: Any) -> None: ... class NonCallableMagicMock(MagicMixin, NonCallableMock): def mock_add_spec(self, spec: Any, spec_set: bool = ...) -> None: ... class MagicMock(MagicMixin, Mock): def mock_add_spec(self, spec: Any, spec_set: bool = ...) -> None: ... if sys.version_info >= (3, 8): class AsyncMockMixin(Base): def __init__(self, *args: Any, **kwargs: Any) -> None: ... async def _execute_mock_call(self, *args: Any, **kwargs: Any) -> Any: ... def assert_awaited(self) -> None: ... def assert_awaited_once(self) -> None: ... def assert_awaited_with(self, *args: Any, **kwargs: Any) -> None: ... def assert_awaited_once_with(self, *args: Any, **kwargs: Any) -> None: ... def assert_any_await(self, *args: Any, **kwargs: Any) -> None: ... def assert_has_awaits(self, calls: _CallList, any_order: bool = ...) -> None: ... def assert_not_awaited(self) -> None: ... def reset_mock(self, *args, **kwargs) -> None: ... await_count: int await_args: Optional[_Call] await_args_list: _CallList class AsyncMagicMixin(MagicMixin): def __init__(self, *args: Any, **kw: Any) -> None: ... class AsyncMock(AsyncMockMixin, AsyncMagicMixin, Mock): ... class MagicProxy: name: Any parent: Any def __init__(self, name: Any, parent: Any) -> None: ... def __call__(self, *args: Any, **kwargs: Any) -> Any: ... def create_mock(self) -> Any: ... def __get__(self, obj: Any, _type: Optional[Any] = ...) -> Any: ... class _ANY: def __eq__(self, other: Any) -> bool: ... def __ne__(self, other: Any) -> bool: ... ANY: Any def create_autospec( spec: Any, spec_set: Any = ..., instance: Any = ..., _parent: Optional[Any] = ..., _name: Optional[Any] = ..., **kwargs: Any ) -> Any: ... class _SpecState: spec: Any ids: Any spec_set: Any parent: Any instance: Any name: Any def __init__( self, spec: Any, spec_set: Any = ..., parent: Optional[Any] = ..., name: Optional[Any] = ..., ids: Optional[Any] = ..., instance: Any = ..., ) -> None: ... def mock_open(mock: Optional[Any] = ..., read_data: Any = ...) -> Any: ... PropertyMock = Any if sys.version_info >= (3, 7): def seal(mock: Any) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/unittest/result.pyi0000664000175000017500000000350300000000000025035 0ustar00davedave00000000000000import unittest.case from types import TracebackType from typing import Any, Callable, List, Optional, TextIO, Tuple, Type, TypeVar, Union _SysExcInfoType = Union[Tuple[Type[BaseException], BaseException, TracebackType], Tuple[None, None, None]] _F = TypeVar("_F", bound=Callable[..., Any]) # undocumented def failfast(method: _F) -> _F: ... class TestResult: errors: List[Tuple[unittest.case.TestCase, str]] failures: List[Tuple[unittest.case.TestCase, str]] skipped: List[Tuple[unittest.case.TestCase, str]] expectedFailures: List[Tuple[unittest.case.TestCase, str]] unexpectedSuccesses: List[unittest.case.TestCase] shouldStop: bool testsRun: int buffer: bool failfast: bool tb_locals: bool def __init__( self, stream: Optional[TextIO] = ..., descriptions: Optional[bool] = ..., verbosity: Optional[int] = ... ) -> None: ... def printErrors(self) -> None: ... def wasSuccessful(self) -> bool: ... def stop(self) -> None: ... def startTest(self, test: unittest.case.TestCase) -> None: ... def stopTest(self, test: unittest.case.TestCase) -> None: ... def startTestRun(self) -> None: ... def stopTestRun(self) -> None: ... def addError(self, test: unittest.case.TestCase, err: _SysExcInfoType) -> None: ... def addFailure(self, test: unittest.case.TestCase, err: _SysExcInfoType) -> None: ... def addSuccess(self, test: unittest.case.TestCase) -> None: ... def addSkip(self, test: unittest.case.TestCase, reason: str) -> None: ... def addExpectedFailure(self, test: unittest.case.TestCase, err: _SysExcInfoType) -> None: ... def addUnexpectedSuccess(self, test: unittest.case.TestCase) -> None: ... def addSubTest( self, test: unittest.case.TestCase, subtest: unittest.case.TestCase, err: Optional[_SysExcInfoType] ) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/unittest/runner.pyi0000664000175000017500000000247300000000000025035 0ustar00davedave00000000000000import unittest.case import unittest.result import unittest.suite from typing import Callable, Optional, TextIO, Tuple, Type, Union _ResultClassType = Callable[[TextIO, bool, int], unittest.result.TestResult] class TextTestResult(unittest.result.TestResult): descriptions: bool # undocumented dots: bool # undocumented separator1: str separator2: str showall: bool # undocumented stream: TextIO # undocumented def __init__(self, stream: TextIO, descriptions: bool, verbosity: int) -> None: ... def getDescription(self, test: unittest.case.TestCase) -> str: ... def printErrors(self) -> None: ... def printErrorList(self, flavour: str, errors: Tuple[unittest.case.TestCase, str]) -> None: ... class TextTestRunner(object): resultclass: _ResultClassType def __init__( self, stream: Optional[TextIO] = ..., descriptions: bool = ..., verbosity: int = ..., failfast: bool = ..., buffer: bool = ..., resultclass: Optional[_ResultClassType] = ..., warnings: Optional[Type[Warning]] = ..., *, tb_locals: bool = ..., ) -> None: ... def _makeResult(self) -> unittest.result.TestResult: ... def run(self, test: Union[unittest.suite.TestSuite, unittest.case.TestCase]) -> unittest.result.TestResult: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/unittest/signals.pyi0000664000175000017500000000062200000000000025156 0ustar00davedave00000000000000import unittest.result from typing import Any, Callable, TypeVar, overload _F = TypeVar("_F", bound=Callable[..., Any]) def installHandler() -> None: ... def registerResult(result: unittest.result.TestResult) -> None: ... def removeResult(result: unittest.result.TestResult) -> bool: ... @overload def removeHandler(method: None = ...) -> None: ... @overload def removeHandler(method: _F) -> _F: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/unittest/suite.pyi0000664000175000017500000000157400000000000024656 0ustar00davedave00000000000000import unittest.case import unittest.result from typing import Iterable, Iterator, List, Union _TestType = Union[unittest.case.TestCase, TestSuite] class BaseTestSuite(Iterable[_TestType]): _tests: List[unittest.case.TestCase] _removed_tests: int def __init__(self, tests: Iterable[_TestType] = ...) -> None: ... def __call__(self, result: unittest.result.TestResult) -> unittest.result.TestResult: ... def addTest(self, test: _TestType) -> None: ... def addTests(self, tests: Iterable[_TestType]) -> None: ... def run(self, result: unittest.result.TestResult) -> unittest.result.TestResult: ... def debug(self) -> None: ... def countTestCases(self) -> int: ... def __iter__(self) -> Iterator[_TestType]: ... class TestSuite(BaseTestSuite): def run(self, result: unittest.result.TestResult, debug: bool = ...) -> unittest.result.TestResult: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/unittest/util.pyi0000664000175000017500000000161200000000000024473 0ustar00davedave00000000000000from typing import Any, List, Sequence, Tuple, TypeVar _T = TypeVar("_T") _Mismatch = Tuple[_T, _T, int] _MAX_LENGTH: int _PLACEHOLDER_LEN: int _MIN_BEGIN_LEN: int _MIN_END_LEN: int _MIN_COMMON_LEN: int _MIN_DIFF_LEN: int def _shorten(s: str, prefixlen: int, suffixlen: int) -> str: ... def _common_shorten_repr(*args: str) -> Tuple[str]: ... def safe_repr(obj: object, short: bool = ...) -> str: ... def strclass(cls: type) -> str: ... def sorted_list_difference(expected: Sequence[_T], actual: Sequence[_T]) -> Tuple[List[_T], List[_T]]: ... def unorderable_list_difference(expected: Sequence[_T], actual: Sequence[_T]) -> Tuple[List[_T], List[_T]]: ... def three_way_cmp(x: Any, y: Any) -> int: ... def _count_diff_all_purpose(actual: Sequence[_T], expected: Sequence[_T]) -> List[_Mismatch[_T]]: ... def _count_diff_hashable(actual: Sequence[_T], expected: Sequence[_T]) -> List[_Mismatch[_T]]: ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4343793 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/urllib/0000775000175000017500000000000000000000000022405 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/urllib/__init__.pyi0000664000175000017500000000000000000000000024655 0ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/urllib/error.pyi0000664000175000017500000000060700000000000024264 0ustar00davedave00000000000000from typing import IO, Mapping, Optional, Union from urllib.response import addinfourl # Stubs for urllib.error class URLError(IOError): reason: Union[str, BaseException] class HTTPError(URLError, addinfourl): code: int def __init__(self, url: str, code: int, msg: str, hdrs: Mapping[str, str], fp: Optional[IO[bytes]]) -> None: ... class ContentTooShortError(URLError): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/urllib/parse.pyi0000664000175000017500000001247400000000000024252 0ustar00davedave00000000000000import sys from typing import Any, AnyStr, Callable, Dict, Generic, List, Mapping, NamedTuple, Optional, Sequence, Tuple, Union, overload if sys.version_info >= (3, 9): from types import GenericAlias _Str = Union[bytes, str] uses_relative: List[str] uses_netloc: List[str] uses_params: List[str] non_hierarchical: List[str] uses_query: List[str] uses_fragment: List[str] scheme_chars: str MAX_CACHE_SIZE: int class _ResultMixinBase(Generic[AnyStr]): def geturl(self) -> AnyStr: ... class _ResultMixinStr(_ResultMixinBase[str]): def encode(self, encoding: str = ..., errors: str = ...) -> _ResultMixinBytes: ... class _ResultMixinBytes(_ResultMixinBase[str]): def decode(self, encoding: str = ..., errors: str = ...) -> _ResultMixinStr: ... class _NetlocResultMixinBase(Generic[AnyStr]): username: Optional[AnyStr] password: Optional[AnyStr] hostname: Optional[AnyStr] port: Optional[int] if sys.version_info >= (3, 9): def __class_getitem__(cls, item: Any) -> GenericAlias: ... class _NetlocResultMixinStr(_NetlocResultMixinBase[str], _ResultMixinStr): ... class _NetlocResultMixinBytes(_NetlocResultMixinBase[bytes], _ResultMixinBytes): ... class _DefragResultBase(Tuple[Any, ...], Generic[AnyStr]): url: AnyStr fragment: AnyStr class _SplitResultBase(NamedTuple): scheme: str netloc: str path: str query: str fragment: str class _SplitResultBytesBase(NamedTuple): scheme: bytes netloc: bytes path: bytes query: bytes fragment: bytes class _ParseResultBase(NamedTuple): scheme: str netloc: str path: str params: str query: str fragment: str class _ParseResultBytesBase(NamedTuple): scheme: bytes netloc: bytes path: bytes params: bytes query: bytes fragment: bytes # Structured result objects for string data class DefragResult(_DefragResultBase[str], _ResultMixinStr): ... class SplitResult(_SplitResultBase, _NetlocResultMixinStr): ... class ParseResult(_ParseResultBase, _NetlocResultMixinStr): ... # Structured result objects for bytes data class DefragResultBytes(_DefragResultBase[bytes], _ResultMixinBytes): ... class SplitResultBytes(_SplitResultBytesBase, _NetlocResultMixinBytes): ... class ParseResultBytes(_ParseResultBytesBase, _NetlocResultMixinBytes): ... if sys.version_info >= (3, 8): def parse_qs( qs: Optional[AnyStr], keep_blank_values: bool = ..., strict_parsing: bool = ..., encoding: str = ..., errors: str = ..., max_num_fields: Optional[int] = ..., ) -> Dict[AnyStr, List[AnyStr]]: ... def parse_qsl( qs: Optional[AnyStr], keep_blank_values: bool = ..., strict_parsing: bool = ..., encoding: str = ..., errors: str = ..., max_num_fields: Optional[int] = ..., ) -> List[Tuple[AnyStr, AnyStr]]: ... else: def parse_qs( qs: Optional[AnyStr], keep_blank_values: bool = ..., strict_parsing: bool = ..., encoding: str = ..., errors: str = ... ) -> Dict[AnyStr, List[AnyStr]]: ... def parse_qsl( qs: Optional[AnyStr], keep_blank_values: bool = ..., strict_parsing: bool = ..., encoding: str = ..., errors: str = ... ) -> List[Tuple[AnyStr, AnyStr]]: ... @overload def quote(string: str, safe: _Str = ..., encoding: Optional[str] = ..., errors: Optional[str] = ...) -> str: ... @overload def quote(string: bytes, safe: _Str = ...) -> str: ... def quote_from_bytes(bs: bytes, safe: _Str = ...) -> str: ... @overload def quote_plus(string: str, safe: _Str = ..., encoding: Optional[str] = ..., errors: Optional[str] = ...) -> str: ... @overload def quote_plus(string: bytes, safe: _Str = ...) -> str: ... def unquote(string: str, encoding: str = ..., errors: str = ...) -> str: ... def unquote_to_bytes(string: _Str) -> bytes: ... def unquote_plus(string: str, encoding: str = ..., errors: str = ...) -> str: ... @overload def urldefrag(url: str) -> DefragResult: ... @overload def urldefrag(url: Optional[bytes]) -> DefragResultBytes: ... def urlencode( query: Union[Mapping[Any, Any], Mapping[Any, Sequence[Any]], Sequence[Tuple[Any, Any]], Sequence[Tuple[Any, Sequence[Any]]]], doseq: bool = ..., safe: AnyStr = ..., encoding: str = ..., errors: str = ..., quote_via: Callable[[str, AnyStr, str, str], str] = ..., ) -> str: ... def urljoin(base: AnyStr, url: Optional[AnyStr], allow_fragments: bool = ...) -> AnyStr: ... @overload def urlparse(url: str, scheme: Optional[str] = ..., allow_fragments: bool = ...) -> ParseResult: ... @overload def urlparse(url: Optional[bytes], scheme: Optional[bytes] = ..., allow_fragments: bool = ...) -> ParseResultBytes: ... @overload def urlsplit(url: str, scheme: Optional[str] = ..., allow_fragments: bool = ...) -> SplitResult: ... @overload def urlsplit(url: Optional[bytes], scheme: Optional[bytes] = ..., allow_fragments: bool = ...) -> SplitResultBytes: ... @overload def urlunparse( components: Tuple[Optional[AnyStr], Optional[AnyStr], Optional[AnyStr], Optional[AnyStr], Optional[AnyStr], Optional[AnyStr]] ) -> AnyStr: ... @overload def urlunparse(components: Sequence[Optional[AnyStr]]) -> AnyStr: ... @overload def urlunsplit( components: Tuple[Optional[AnyStr], Optional[AnyStr], Optional[AnyStr], Optional[AnyStr], Optional[AnyStr]] ) -> AnyStr: ... @overload def urlunsplit(components: Sequence[Optional[AnyStr]]) -> AnyStr: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/urllib/request.pyi0000664000175000017500000003633500000000000024632 0ustar00davedave00000000000000import os import ssl from email.message import Message from http.client import HTTPMessage, HTTPResponse, _HTTPConnectionProtocol from http.cookiejar import CookieJar from typing import ( IO, Any, Callable, ClassVar, Dict, List, Mapping, NoReturn, Optional, Pattern, Sequence, Tuple, TypeVar, Union, overload, ) from urllib.error import HTTPError from urllib.response import addinfourl _T = TypeVar("_T") _UrlopenRet = Any def urlopen( url: Union[str, Request], data: Optional[bytes] = ..., timeout: Optional[float] = ..., *, cafile: Optional[str] = ..., capath: Optional[str] = ..., cadefault: bool = ..., context: Optional[ssl.SSLContext] = ..., ) -> _UrlopenRet: ... def install_opener(opener: OpenerDirector) -> None: ... def build_opener(*handlers: Union[BaseHandler, Callable[[], BaseHandler]]) -> OpenerDirector: ... def url2pathname(pathname: str) -> str: ... def pathname2url(pathname: str) -> str: ... def getproxies() -> Dict[str, str]: ... def parse_http_list(s: str) -> List[str]: ... def parse_keqv_list(l: List[str]) -> Dict[str, str]: ... def proxy_bypass(host: str) -> Any: ... # Undocumented class Request: @property def full_url(self) -> str: ... @full_url.setter def full_url(self, value: str) -> None: ... @full_url.deleter def full_url(self) -> None: ... type: str host: str origin_req_host: str selector: str data: Optional[bytes] headers: Dict[str, str] unverifiable: bool method: Optional[str] def __init__( self, url: str, data: Optional[bytes] = ..., headers: Dict[str, str] = ..., origin_req_host: Optional[str] = ..., unverifiable: bool = ..., method: Optional[str] = ..., ) -> None: ... def get_method(self) -> str: ... def add_header(self, key: str, val: str) -> None: ... def add_unredirected_header(self, key: str, val: str) -> None: ... def has_header(self, header_name: str) -> bool: ... def remove_header(self, header_name: str) -> None: ... def get_full_url(self) -> str: ... def set_proxy(self, host: str, type: str) -> None: ... @overload def get_header(self, header_name: str) -> Optional[str]: ... @overload def get_header(self, header_name: str, default: _T) -> Union[str, _T]: ... def header_items(self) -> List[Tuple[str, str]]: ... def has_proxy(self) -> bool: ... class OpenerDirector: addheaders: List[Tuple[str, str]] def add_handler(self, handler: BaseHandler) -> None: ... def open(self, fullurl: Union[str, Request], data: Optional[bytes] = ..., timeout: Optional[float] = ...) -> _UrlopenRet: ... def error(self, proto: str, *args: Any) -> _UrlopenRet: ... def close(self) -> None: ... class BaseHandler: handler_order: ClassVar[int] parent: OpenerDirector def add_parent(self, parent: OpenerDirector) -> None: ... def close(self) -> None: ... def http_error_nnn(self, req: Request, fp: IO[str], code: int, msg: int, headers: Mapping[str, str]) -> _UrlopenRet: ... class HTTPDefaultErrorHandler(BaseHandler): def http_error_default( self, req: Request, fp: IO[bytes], code: int, msg: str, hdrs: Mapping[str, str] ) -> HTTPError: ... # undocumented class HTTPRedirectHandler(BaseHandler): max_redirections: ClassVar[int] # undocumented max_repeats: ClassVar[int] # undocumented inf_msg: ClassVar[str] # undocumented def redirect_request( self, req: Request, fp: IO[str], code: int, msg: str, headers: Mapping[str, str], newurl: str ) -> Optional[Request]: ... def http_error_301( self, req: Request, fp: IO[str], code: int, msg: int, headers: Mapping[str, str] ) -> Optional[_UrlopenRet]: ... def http_error_302( self, req: Request, fp: IO[str], code: int, msg: int, headers: Mapping[str, str] ) -> Optional[_UrlopenRet]: ... def http_error_303( self, req: Request, fp: IO[str], code: int, msg: int, headers: Mapping[str, str] ) -> Optional[_UrlopenRet]: ... def http_error_307( self, req: Request, fp: IO[str], code: int, msg: int, headers: Mapping[str, str] ) -> Optional[_UrlopenRet]: ... class HTTPCookieProcessor(BaseHandler): cookiejar: CookieJar def __init__(self, cookiejar: Optional[CookieJar] = ...) -> None: ... def http_request(self, request: Request) -> Request: ... # undocumented def http_response(self, request: Request, response: HTTPResponse) -> HTTPResponse: ... # undocumented def https_request(self, request: Request) -> Request: ... # undocumented def https_response(self, request: Request, response: HTTPResponse) -> HTTPResponse: ... # undocumented class ProxyHandler(BaseHandler): def __init__(self, proxies: Optional[Dict[str, str]] = ...) -> None: ... def proxy_open(self, req: Request, proxy: str, type: str) -> Optional[_UrlopenRet]: ... # undocumented # TODO add a method for every (common) proxy protocol class HTTPPasswordMgr: def add_password(self, realm: str, uri: Union[str, Sequence[str]], user: str, passwd: str) -> None: ... def find_user_password(self, realm: str, authuri: str) -> Tuple[Optional[str], Optional[str]]: ... def is_suburi(self, base: str, test: str) -> bool: ... # undocumented def reduce_uri(self, uri: str, default_port: bool = ...) -> str: ... # undocumented class HTTPPasswordMgrWithDefaultRealm(HTTPPasswordMgr): def add_password(self, realm: Optional[str], uri: Union[str, Sequence[str]], user: str, passwd: str) -> None: ... def find_user_password(self, realm: Optional[str], authuri: str) -> Tuple[Optional[str], Optional[str]]: ... class HTTPPasswordMgrWithPriorAuth(HTTPPasswordMgrWithDefaultRealm): def add_password( self, realm: Optional[str], uri: Union[str, Sequence[str]], user: str, passwd: str, is_authenticated: bool = ... ) -> None: ... def update_authenticated(self, uri: Union[str, Sequence[str]], is_authenticated: bool = ...) -> None: ... def is_authenticated(self, authuri: str) -> bool: ... class AbstractBasicAuthHandler: rx: ClassVar[Pattern[str]] # undocumented def __init__(self, password_mgr: Optional[HTTPPasswordMgr] = ...) -> None: ... def http_error_auth_reqed(self, authreq: str, host: str, req: Request, headers: Mapping[str, str]) -> None: ... def http_request(self, req: Request) -> Request: ... # undocumented def http_response(self, req: Request, response: HTTPResponse) -> HTTPResponse: ... # undocumented def https_request(self, req: Request) -> Request: ... # undocumented def https_response(self, req: Request, response: HTTPResponse) -> HTTPResponse: ... # undocumented def retry_http_basic_auth(self, host: str, req: Request, realm: str) -> Optional[_UrlopenRet]: ... # undocumented class HTTPBasicAuthHandler(AbstractBasicAuthHandler, BaseHandler): auth_header: ClassVar[str] # undocumented def http_error_401( self, req: Request, fp: IO[str], code: int, msg: int, headers: Mapping[str, str] ) -> Optional[_UrlopenRet]: ... class ProxyBasicAuthHandler(AbstractBasicAuthHandler, BaseHandler): auth_header: ClassVar[str] def http_error_407( self, req: Request, fp: IO[str], code: int, msg: int, headers: Mapping[str, str] ) -> Optional[_UrlopenRet]: ... class AbstractDigestAuthHandler: def __init__(self, passwd: Optional[HTTPPasswordMgr] = ...) -> None: ... def reset_retry_count(self) -> None: ... def http_error_auth_reqed(self, auth_header: str, host: str, req: Request, headers: Mapping[str, str]) -> None: ... def retry_http_digest_auth(self, req: Request, auth: str) -> Optional[_UrlopenRet]: ... def get_cnonce(self, nonce: str) -> str: ... def get_authorization(self, req: Request, chal: Mapping[str, str]) -> str: ... def get_algorithm_impls(self, algorithm: str) -> Tuple[Callable[[str], str], Callable[[str, str], str]]: ... def get_entity_digest(self, data: Optional[bytes], chal: Mapping[str, str]) -> Optional[str]: ... class HTTPDigestAuthHandler(BaseHandler, AbstractDigestAuthHandler): auth_header: ClassVar[str] # undocumented def http_error_401( self, req: Request, fp: IO[str], code: int, msg: int, headers: Mapping[str, str] ) -> Optional[_UrlopenRet]: ... class ProxyDigestAuthHandler(BaseHandler, AbstractDigestAuthHandler): auth_header: ClassVar[str] # undocumented def http_error_407( self, req: Request, fp: IO[str], code: int, msg: int, headers: Mapping[str, str] ) -> Optional[_UrlopenRet]: ... class AbstractHTTPHandler(BaseHandler): # undocumented def __init__(self, debuglevel: int = ...) -> None: ... def set_http_debuglevel(self, level: int) -> None: ... def do_request_(self, request: Request) -> Request: ... def do_open(self, http_class: _HTTPConnectionProtocol, req: Request, **http_conn_args: Any) -> HTTPResponse: ... class HTTPHandler(AbstractHTTPHandler): def http_open(self, req: Request) -> HTTPResponse: ... def http_request(self, request: Request) -> Request: ... # undocumented class HTTPSHandler(AbstractHTTPHandler): def __init__( self, debuglevel: int = ..., context: Optional[ssl.SSLContext] = ..., check_hostname: Optional[bool] = ... ) -> None: ... def https_open(self, req: Request) -> HTTPResponse: ... def https_request(self, request: Request) -> Request: ... # undocumented class FileHandler(BaseHandler): names: ClassVar[Optional[Tuple[str, ...]]] # undocumented def file_open(self, req: Request) -> addinfourl: ... def get_names(self) -> Tuple[str, ...]: ... # undocumented def open_local_file(self, req: Request) -> addinfourl: ... # undocumented class DataHandler(BaseHandler): def data_open(self, req: Request) -> addinfourl: ... class ftpwrapper: # undocumented def __init__( self, user: str, passwd: str, host: str, port: int, dirs: str, timeout: Optional[float] = ..., persistent: bool = ... ) -> None: ... class FTPHandler(BaseHandler): def ftp_open(self, req: Request) -> addinfourl: ... def connect_ftp( self, user: str, passwd: str, host: str, port: int, dirs: str, timeout: float ) -> ftpwrapper: ... # undocumented class CacheFTPHandler(FTPHandler): def setTimeout(self, t: float) -> None: ... def setMaxConns(self, m: int) -> None: ... def check_cache(self) -> None: ... # undocumented def clear_cache(self) -> None: ... # undocumented def connect_ftp( self, user: str, passwd: str, host: str, port: int, dirs: str, timeout: float ) -> ftpwrapper: ... # undocumented class UnknownHandler(BaseHandler): def unknown_open(self, req: Request) -> NoReturn: ... class HTTPErrorProcessor(BaseHandler): def http_response(self, request: Request, response: HTTPResponse) -> _UrlopenRet: ... def https_response(self, request: Request, response: HTTPResponse) -> _UrlopenRet: ... def urlretrieve( url: str, filename: Optional[Union[str, os.PathLike[Any]]] = ..., reporthook: Optional[Callable[[int, int, int], None]] = ..., data: Optional[bytes] = ..., ) -> Tuple[str, HTTPMessage]: ... def urlcleanup() -> None: ... class URLopener: version: ClassVar[str] def __init__(self, proxies: Optional[Dict[str, str]] = ..., **x509: str) -> None: ... def open(self, fullurl: str, data: Optional[bytes] = ...) -> _UrlopenRet: ... def open_unknown(self, fullurl: str, data: Optional[bytes] = ...) -> _UrlopenRet: ... def retrieve( self, url: str, filename: Optional[str] = ..., reporthook: Optional[Callable[[int, int, int], None]] = ..., data: Optional[bytes] = ..., ) -> Tuple[str, Optional[Message]]: ... def addheader(self, *args: Tuple[str, str]) -> None: ... # undocumented def cleanup(self) -> None: ... # undocumented def close(self) -> None: ... # undocumented def http_error( self, url: str, fp: IO[bytes], errcode: int, errmsg: str, headers: Mapping[str, str], data: Optional[bytes] = ... ) -> _UrlopenRet: ... # undocumented def http_error_default( self, url: str, fp: IO[bytes], errcode: int, errmsg: str, headers: Mapping[str, str] ) -> _UrlopenRet: ... # undocumented def open_data(self, url: str, data: Optional[bytes] = ...) -> addinfourl: ... # undocumented def open_file(self, url: str) -> addinfourl: ... # undocumented def open_ftp(self, url: str) -> addinfourl: ... # undocumented def open_http(self, url: str, data: Optional[bytes] = ...) -> _UrlopenRet: ... # undocumented def open_https(self, url: str, data: Optional[bytes] = ...) -> _UrlopenRet: ... # undocumented def open_local_file(self, url: str) -> addinfourl: ... # undocumented def open_unknown_proxy(self, proxy: str, fullurl: str, data: Optional[bytes] = ...) -> None: ... # undocumented class FancyURLopener(URLopener): def prompt_user_passwd(self, host: str, realm: str) -> Tuple[str, str]: ... def get_user_passwd(self, host: str, realm: str, clear_cache: int = ...) -> Tuple[str, str]: ... # undocumented def http_error_301( self, url: str, fp: IO[str], errcode: int, errmsg: str, headers: Mapping[str, str], data: Optional[bytes] = ... ) -> Optional[Union[_UrlopenRet, addinfourl]]: ... # undocumented def http_error_302( self, url: str, fp: IO[str], errcode: int, errmsg: str, headers: Mapping[str, str], data: Optional[bytes] = ... ) -> Optional[Union[_UrlopenRet, addinfourl]]: ... # undocumented def http_error_303( self, url: str, fp: IO[str], errcode: int, errmsg: str, headers: Mapping[str, str], data: Optional[bytes] = ... ) -> Optional[Union[_UrlopenRet, addinfourl]]: ... # undocumented def http_error_307( self, url: str, fp: IO[str], errcode: int, errmsg: str, headers: Mapping[str, str], data: Optional[bytes] = ... ) -> Optional[Union[_UrlopenRet, addinfourl]]: ... # undocumented def http_error_401( self, url: str, fp: IO[str], errcode: int, errmsg: str, headers: Mapping[str, str], data: Optional[bytes] = ..., retry: bool = ..., ) -> Optional[_UrlopenRet]: ... # undocumented def http_error_407( self, url: str, fp: IO[str], errcode: int, errmsg: str, headers: Mapping[str, str], data: Optional[bytes] = ..., retry: bool = ..., ) -> Optional[_UrlopenRet]: ... # undocumented def http_error_default( self, url: str, fp: IO[bytes], errcode: int, errmsg: str, headers: Mapping[str, str] ) -> addinfourl: ... # undocumented def redirect_internal( self, url: str, fp: IO[str], errcode: int, errmsg: str, headers: Mapping[str, str], data: Optional[bytes] ) -> Optional[_UrlopenRet]: ... # undocumented def retry_http_basic_auth( self, url: str, realm: str, data: Optional[bytes] = ... ) -> Optional[_UrlopenRet]: ... # undocumented def retry_https_basic_auth( self, url: str, realm: str, data: Optional[bytes] = ... ) -> Optional[_UrlopenRet]: ... # undocumented def retry_proxy_http_basic_auth( self, url: str, realm: str, data: Optional[bytes] = ... ) -> Optional[_UrlopenRet]: ... # undocumented def retry_proxy_https_basic_auth( self, url: str, realm: str, data: Optional[bytes] = ... ) -> Optional[_UrlopenRet]: ... # undocumented ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/urllib/response.pyi0000664000175000017500000000407300000000000024772 0ustar00davedave00000000000000from email.message import Message from types import TracebackType from typing import IO, Any, BinaryIO, Callable, Iterable, List, Optional, Tuple, Type, TypeVar _AIUT = TypeVar("_AIUT", bound=addbase) class addbase(BinaryIO): fp: IO[bytes] def __init__(self, fp: IO[bytes]) -> None: ... def __enter__(self: _AIUT) -> _AIUT: ... def __exit__( self, type: Optional[Type[BaseException]], value: Optional[BaseException], traceback: Optional[TracebackType] ) -> None: ... def __iter__(self: _AIUT) -> _AIUT: ... def __next__(self) -> bytes: ... def close(self) -> None: ... # These methods don't actually exist, but the class inherits at runtime from # tempfile._TemporaryFileWrapper, which uses __getattr__ to delegate to the # underlying file object. To satisfy the BinaryIO interface, we pretend that this # class has these additional methods. def fileno(self) -> int: ... def flush(self) -> None: ... def isatty(self) -> bool: ... def read(self, n: int = ...) -> bytes: ... def readable(self) -> bool: ... def readline(self, limit: int = ...) -> bytes: ... def readlines(self, hint: int = ...) -> List[bytes]: ... def seek(self, offset: int, whence: int = ...) -> int: ... def seekable(self) -> bool: ... def tell(self) -> int: ... def truncate(self, size: Optional[int] = ...) -> int: ... def writable(self) -> bool: ... def write(self, s: bytes) -> int: ... def writelines(self, lines: Iterable[bytes]) -> None: ... class addclosehook(addbase): closehook: Callable[..., object] hookargs: Tuple[Any, ...] def __init__(self, fp: IO[bytes], closehook: Callable[..., object], *hookargs: Any) -> None: ... class addinfo(addbase): headers: Message def __init__(self, fp: IO[bytes], headers: Message) -> None: ... def info(self) -> Message: ... class addinfourl(addinfo): url: str code: int def __init__(self, fp: IO[bytes], headers: Message, url: str, code: Optional[int] = ...) -> None: ... def geturl(self) -> str: ... def getcode(self) -> int: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/urllib/robotparser.pyi0000664000175000017500000000130000000000000025464 0ustar00davedave00000000000000import sys from typing import Iterable, List, NamedTuple, Optional class _RequestRate(NamedTuple): requests: int seconds: int class RobotFileParser: def __init__(self, url: str = ...) -> None: ... def set_url(self, url: str) -> None: ... def read(self) -> None: ... def parse(self, lines: Iterable[str]) -> None: ... def can_fetch(self, user_agent: str, url: str) -> bool: ... def mtime(self) -> int: ... def modified(self) -> None: ... def crawl_delay(self, useragent: str) -> Optional[str]: ... def request_rate(self, useragent: str) -> Optional[_RequestRate]: ... if sys.version_info >= (3, 8): def site_maps(self) -> Optional[List[str]]: ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4343793 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/venv/0000775000175000017500000000000000000000000022072 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/venv/__init__.pyi0000664000175000017500000000562700000000000024366 0ustar00davedave00000000000000import sys from _typeshed import AnyPath from types import SimpleNamespace from typing import Optional, Sequence class EnvBuilder: system_site_packages: bool clear: bool symlinks: bool upgrade: bool with_pip: bool if sys.version_info >= (3, 6): prompt: Optional[str] if sys.version_info >= (3, 9): def __init__( self, system_site_packages: bool = ..., clear: bool = ..., symlinks: bool = ..., upgrade: bool = ..., with_pip: bool = ..., prompt: Optional[str] = ..., upgrade_deps: bool = ..., ) -> None: ... elif sys.version_info >= (3, 6): def __init__( self, system_site_packages: bool = ..., clear: bool = ..., symlinks: bool = ..., upgrade: bool = ..., with_pip: bool = ..., prompt: Optional[str] = ..., ) -> None: ... else: def __init__( self, system_site_packages: bool = ..., clear: bool = ..., symlinks: bool = ..., upgrade: bool = ..., with_pip: bool = ..., ) -> None: ... def create(self, env_dir: AnyPath) -> None: ... def clear_directory(self, path: AnyPath) -> None: ... # undocumented def ensure_directories(self, env_dir: AnyPath) -> SimpleNamespace: ... def create_configuration(self, context: SimpleNamespace) -> None: ... def symlink_or_copy(self, src: AnyPath, dst: AnyPath, relative_symlinks_ok: bool = ...) -> None: ... # undocumented def setup_python(self, context: SimpleNamespace) -> None: ... def _setup_pip(self, context: SimpleNamespace) -> None: ... # undocumented def setup_scripts(self, context: SimpleNamespace) -> None: ... def post_setup(self, context: SimpleNamespace) -> None: ... def replace_variables(self, text: str, context: SimpleNamespace) -> str: ... # undocumented def install_scripts(self, context: SimpleNamespace, path: str) -> None: ... if sys.version_info >= (3, 9): def upgrade_dependencies(self, context: SimpleNamespace) -> None: ... if sys.version_info >= (3, 9): def create( env_dir: AnyPath, system_site_packages: bool = ..., clear: bool = ..., symlinks: bool = ..., with_pip: bool = ..., prompt: Optional[str] = ..., upgrade_deps: bool = ..., ) -> None: ... elif sys.version_info >= (3, 6): def create( env_dir: AnyPath, system_site_packages: bool = ..., clear: bool = ..., symlinks: bool = ..., with_pip: bool = ..., prompt: Optional[str] = ..., ) -> None: ... else: def create( env_dir: AnyPath, system_site_packages: bool = ..., clear: bool = ..., symlinks: bool = ..., with_pip: bool = ... ) -> None: ... def main(args: Optional[Sequence[str]] = ...) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/winreg.pyi0000664000175000017500000000730300000000000023135 0ustar00davedave00000000000000import sys from types import TracebackType from typing import Any, Optional, Tuple, Type, Union _KeyType = Union[HKEYType, int] def CloseKey(__hkey: _KeyType) -> None: ... def ConnectRegistry(__computer_name: Optional[str], __key: _KeyType) -> HKEYType: ... def CreateKey(__key: _KeyType, __sub_key: Optional[str]) -> HKEYType: ... def CreateKeyEx(key: _KeyType, sub_key: Optional[str], reserved: int = ..., access: int = ...) -> HKEYType: ... def DeleteKey(__key: _KeyType, __sub_key: str) -> None: ... def DeleteKeyEx(key: _KeyType, sub_key: str, access: int = ..., reserved: int = ...) -> None: ... def DeleteValue(__key: _KeyType, __value: str) -> None: ... def EnumKey(__key: _KeyType, __index: int) -> str: ... def EnumValue(__key: _KeyType, __index: int) -> Tuple[str, Any, int]: ... def ExpandEnvironmentStrings(__str: str) -> str: ... def FlushKey(__key: _KeyType) -> None: ... def LoadKey(__key: _KeyType, __sub_key: str, __file_name: str) -> None: ... def OpenKey(key: _KeyType, sub_key: str, reserved: int = ..., access: int = ...) -> HKEYType: ... def OpenKeyEx(key: _KeyType, sub_key: str, reserved: int = ..., access: int = ...) -> HKEYType: ... def QueryInfoKey(__key: _KeyType) -> Tuple[int, int, int]: ... def QueryValue(__key: _KeyType, __sub_key: Optional[str]) -> str: ... def QueryValueEx(__key: _KeyType, __name: str) -> Tuple[Any, int]: ... def SaveKey(__key: _KeyType, __file_name: str) -> None: ... def SetValue(__key: _KeyType, __sub_key: str, __type: int, __value: str) -> None: ... def SetValueEx( __key: _KeyType, __value_name: Optional[str], __reserved: Any, __type: int, __value: Union[str, int] ) -> None: ... # reserved is ignored def DisableReflectionKey(__key: _KeyType) -> None: ... def EnableReflectionKey(__key: _KeyType) -> None: ... def QueryReflectionKey(__key: _KeyType) -> bool: ... HKEY_CLASSES_ROOT: int HKEY_CURRENT_USER: int HKEY_LOCAL_MACHINE: int HKEY_USERS: int HKEY_PERFORMANCE_DATA: int HKEY_CURRENT_CONFIG: int HKEY_DYN_DATA: int KEY_ALL_ACCESS: int KEY_WRITE: int KEY_READ: int KEY_EXECUTE: int KEY_QUERY_VALUE: int KEY_SET_VALUE: int KEY_CREATE_SUB_KEY: int KEY_ENUMERATE_SUB_KEYS: int KEY_NOTIFY: int KEY_CREATE_LINK: int KEY_WOW64_64KEY: int KEY_WOW64_32KEY: int REG_BINARY: int REG_DWORD: int REG_DWORD_LITTLE_ENDIAN: int REG_DWORD_BIG_ENDIAN: int REG_EXPAND_SZ: int REG_LINK: int REG_MULTI_SZ: int REG_NONE: int if sys.version_info >= (3, 6): REG_QWORD: int REG_QWORD_LITTLE_ENDIAN: int REG_RESOURCE_LIST: int REG_FULL_RESOURCE_DESCRIPTOR: int REG_RESOURCE_REQUIREMENTS_LIST: int REG_SZ: int REG_CREATED_NEW_KEY: int # undocumented REG_LEGAL_CHANGE_FILTER: int # undocumented REG_LEGAL_OPTION: int # undocumented REG_NOTIFY_CHANGE_ATTRIBUTES: int # undocumented REG_NOTIFY_CHANGE_LAST_SET: int # undocumented REG_NOTIFY_CHANGE_NAME: int # undocumented REG_NOTIFY_CHANGE_SECURITY: int # undocumented REG_NO_LAZY_FLUSH: int # undocumented REG_OPENED_EXISTING_KEY: int # undocumented REG_OPTION_BACKUP_RESTORE: int # undocumented REG_OPTION_CREATE_LINK: int # undocumented REG_OPTION_NON_VOLATILE: int # undocumented REG_OPTION_OPEN_LINK: int # undocumented REG_OPTION_RESERVED: int # undocumented REG_OPTION_VOLATILE: int # undocumented REG_REFRESH_HIVE: int # undocumented REG_WHOLE_HIVE_VOLATILE: int # undocumented error = OSError # Though this class has a __name__ of PyHKEY, it's exposed as HKEYType for some reason class HKEYType: def __bool__(self) -> bool: ... def __int__(self) -> int: ... def __enter__(self) -> HKEYType: ... def __exit__( self, exc_type: Optional[Type[BaseException]], exc_val: Optional[BaseException], exc_tb: Optional[TracebackType] ) -> Optional[bool]: ... def Close(self) -> None: ... def Detach(self) -> int: ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4343793 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/xmlrpc/0000775000175000017500000000000000000000000022421 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/xmlrpc/__init__.pyi0000664000175000017500000000000000000000000024671 0ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/xmlrpc/client.pyi0000664000175000017500000002777500000000000024444 0ustar00davedave00000000000000import gzip import http.client import sys import time from _typeshed import SupportsRead, SupportsWrite from datetime import datetime from io import BytesIO from types import TracebackType from typing import Any, Callable, Dict, Iterable, List, Mapping, Optional, Protocol, Tuple, Type, Union, overload from typing_extensions import Literal class _SupportsTimeTuple(Protocol): def timetuple(self) -> time.struct_time: ... _DateTimeComparable = Union[DateTime, datetime, str, _SupportsTimeTuple] _Marshallable = Union[None, bool, int, float, str, bytes, tuple, list, dict, datetime, DateTime, Binary] _XMLDate = Union[int, datetime, Tuple[int, ...], time.struct_time] _HostType = Union[Tuple[str, Dict[str, str]], str] def escape(s: str) -> str: ... # undocumented PARSE_ERROR: int # undocumented SERVER_ERROR: int # undocumented APPLICATION_ERROR: int # undocumented SYSTEM_ERROR: int # undocumented TRANSPORT_ERROR: int # undocumented NOT_WELLFORMED_ERROR: int # undocumented UNSUPPORTED_ENCODING: int # undocumented INVALID_ENCODING_CHAR: int # undocumented INVALID_XMLRPC: int # undocumented METHOD_NOT_FOUND: int # undocumented INVALID_METHOD_PARAMS: int # undocumented INTERNAL_ERROR: int # undocumented class Error(Exception): ... class ProtocolError(Error): url: str errcode: int errmsg: str headers: Dict[str, str] def __init__(self, url: str, errcode: int, errmsg: str, headers: Dict[str, str]) -> None: ... class ResponseError(Error): ... class Fault(Error): faultCode: str faultString: str def __init__(self, faultCode: str, faultString: str, **extra: Any) -> None: ... boolean = bool Boolean = bool def _iso8601_format(value: datetime) -> str: ... # undocumented def _strftime(value: _XMLDate) -> str: ... # undocumented class DateTime: value: str # undocumented def __init__(self, value: Union[int, str, datetime, time.struct_time, Tuple[int, ...]] = ...) -> None: ... def __lt__(self, other: _DateTimeComparable) -> bool: ... def __le__(self, other: _DateTimeComparable) -> bool: ... def __gt__(self, other: _DateTimeComparable) -> bool: ... def __ge__(self, other: _DateTimeComparable) -> bool: ... def __eq__(self, other: _DateTimeComparable) -> bool: ... # type: ignore def make_comparable(self, other: _DateTimeComparable) -> Tuple[str, str]: ... # undocumented def timetuple(self) -> time.struct_time: ... # undocumented def decode(self, data: Any) -> None: ... def encode(self, out: SupportsWrite[str]) -> None: ... def _datetime(data: Any) -> DateTime: ... # undocumented def _datetime_type(data: str) -> datetime: ... # undocumented class Binary: data: bytes def __init__(self, data: Optional[bytes] = ...) -> None: ... def decode(self, data: bytes) -> None: ... def encode(self, out: SupportsWrite[str]) -> None: ... def _binary(data: bytes) -> Binary: ... # undocumented WRAPPERS: Tuple[Type[DateTime], Type[Binary]] # undocumented class ExpatParser: # undocumented def __init__(self, target: Unmarshaller) -> None: ... def feed(self, data: Union[str, bytes]) -> None: ... def close(self) -> None: ... class Marshaller: dispatch: Dict[ Type[Any], Callable[[Marshaller, Any, Callable[[str], Any]], None] ] = ... # TODO: Replace 'Any' with some kind of binding memo: Dict[Any, None] data: None encoding: Optional[str] allow_none: bool def __init__(self, encoding: Optional[str] = ..., allow_none: bool = ...) -> None: ... def dumps(self, values: Union[Fault, Iterable[_Marshallable]]) -> str: ... def __dump(self, value: Union[_Marshallable], write: Callable[[str], Any]) -> None: ... # undocumented def dump_nil(self, value: None, write: Callable[[str], Any]) -> None: ... def dump_bool(self, value: bool, write: Callable[[str], Any]) -> None: ... def dump_long(self, value: int, write: Callable[[str], Any]) -> None: ... def dump_int(self, value: int, write: Callable[[str], Any]) -> None: ... def dump_double(self, value: float, write: Callable[[str], Any]) -> None: ... def dump_unicode(self, value: str, write: Callable[[str], Any], escape: Callable[[str], str] = ...) -> None: ... def dump_bytes(self, value: bytes, write: Callable[[str], Any]) -> None: ... def dump_array(self, value: Iterable[_Marshallable], write: Callable[[str], Any]) -> None: ... def dump_struct( self, value: Mapping[str, _Marshallable], write: Callable[[str], Any], escape: Callable[[str], str] = ... ) -> None: ... def dump_datetime(self, value: _XMLDate, write: Callable[[str], Any]) -> None: ... def dump_instance(self, value: object, write: Callable[[str], Any]) -> None: ... class Unmarshaller: dispatch: Dict[str, Callable[[Unmarshaller, str], None]] = ... _type: Optional[str] _stack: List[_Marshallable] _marks: List[int] _data: List[str] _value: bool _methodname: Optional[str] _encoding: str append: Callable[[Any], None] _use_datetime: bool _use_builtin_types: bool def __init__(self, use_datetime: bool = ..., use_builtin_types: bool = ...) -> None: ... def close(self) -> Tuple[_Marshallable, ...]: ... def getmethodname(self) -> Optional[str]: ... def xml(self, encoding: str, standalone: Any) -> None: ... # Standalone is ignored def start(self, tag: str, attrs: Dict[str, str]) -> None: ... def data(self, text: str) -> None: ... def end(self, tag: str) -> None: ... def end_dispatch(self, tag: str, data: str) -> None: ... def end_nil(self, data: str) -> None: ... def end_boolean(self, data: str) -> None: ... def end_int(self, data: str) -> None: ... def end_double(self, data: str) -> None: ... def end_bigdecimal(self, data: str) -> None: ... def end_string(self, data: str) -> None: ... def end_array(self, data: str) -> None: ... def end_struct(self, data: str) -> None: ... def end_base64(self, data: str) -> None: ... def end_dateTime(self, data: str) -> None: ... def end_value(self, data: str) -> None: ... def end_params(self, data: str) -> None: ... def end_fault(self, data: str) -> None: ... def end_methodName(self, data: str) -> None: ... class _MultiCallMethod: # undocumented __call_list: List[Tuple[str, Tuple[_Marshallable, ...]]] __name: str def __init__(self, call_list: List[Tuple[str, _Marshallable]], name: str) -> None: ... def __getattr__(self, name: str) -> _MultiCallMethod: ... def __call__(self, *args: _Marshallable) -> None: ... class MultiCallIterator: # undocumented results: List[List[_Marshallable]] def __init__(self, results: List[List[_Marshallable]]) -> None: ... def __getitem__(self, i: int) -> _Marshallable: ... class MultiCall: __server: ServerProxy __call_list: List[Tuple[str, Tuple[_Marshallable, ...]]] def __init__(self, server: ServerProxy) -> None: ... def __getattr__(self, item: str) -> _MultiCallMethod: ... def __call__(self) -> MultiCallIterator: ... # A little white lie FastMarshaller: Optional[Marshaller] FastParser: Optional[ExpatParser] FastUnmarshaller: Optional[Unmarshaller] def getparser(use_datetime: bool = ..., use_builtin_types: bool = ...) -> Tuple[ExpatParser, Unmarshaller]: ... def dumps( params: Union[Fault, Tuple[_Marshallable, ...]], methodname: Optional[str] = ..., methodresponse: Optional[bool] = ..., encoding: Optional[str] = ..., allow_none: bool = ..., ) -> str: ... def loads( data: str, use_datetime: bool = ..., use_builtin_types: bool = ... ) -> Tuple[Tuple[_Marshallable, ...], Optional[str]]: ... def gzip_encode(data: bytes) -> bytes: ... # undocumented def gzip_decode(data: bytes, max_decode: int = ...) -> bytes: ... # undocumented class GzipDecodedResponse(gzip.GzipFile): # undocumented io: BytesIO def __init__(self, response: SupportsRead[bytes]) -> None: ... def close(self) -> None: ... class _Method: # undocumented __send: Callable[[str, Tuple[_Marshallable, ...]], _Marshallable] __name: str def __init__(self, send: Callable[[str, Tuple[_Marshallable, ...]], _Marshallable], name: str) -> None: ... def __getattr__(self, name: str) -> _Method: ... def __call__(self, *args: _Marshallable) -> _Marshallable: ... class Transport: user_agent: str = ... accept_gzip_encoding: bool = ... encode_threshold: Optional[int] = ... _use_datetime: bool _use_builtin_types: bool _connection: Tuple[Optional[_HostType], Optional[http.client.HTTPConnection]] _headers: List[Tuple[str, str]] _extra_headers: List[Tuple[str, str]] if sys.version_info >= (3, 8): def __init__( self, use_datetime: bool = ..., use_builtin_types: bool = ..., *, headers: Iterable[Tuple[str, str]] = ... ) -> None: ... else: def __init__(self, use_datetime: bool = ..., use_builtin_types: bool = ...) -> None: ... def request(self, host: _HostType, handler: str, request_body: bytes, verbose: bool = ...) -> Tuple[_Marshallable, ...]: ... def single_request( self, host: _HostType, handler: str, request_body: bytes, verbose: bool = ... ) -> Tuple[_Marshallable, ...]: ... def getparser(self) -> Tuple[ExpatParser, Unmarshaller]: ... def get_host_info(self, host: _HostType) -> Tuple[str, List[Tuple[str, str]], Dict[str, str]]: ... def make_connection(self, host: _HostType) -> http.client.HTTPConnection: ... def close(self) -> None: ... def send_request(self, host: _HostType, handler: str, request_body: bytes, debug: bool) -> http.client.HTTPConnection: ... def send_headers(self, connection: http.client.HTTPConnection, headers: List[Tuple[str, str]]) -> None: ... def send_content(self, connection: http.client.HTTPConnection, request_body: bytes) -> None: ... def parse_response(self, response: http.client.HTTPResponse) -> Tuple[_Marshallable, ...]: ... class SafeTransport(Transport): if sys.version_info >= (3, 8): def __init__( self, use_datetime: bool = ..., use_builtin_types: bool = ..., *, headers: Iterable[Tuple[str, str]] = ..., context: Optional[Any] = ..., ) -> None: ... else: def __init__(self, use_datetime: bool = ..., use_builtin_types: bool = ..., *, context: Optional[Any] = ...) -> None: ... def make_connection(self, host: _HostType) -> http.client.HTTPSConnection: ... class ServerProxy: __host: str __handler: str __transport: Transport __encoding: str __verbose: bool __allow_none: bool if sys.version_info >= (3, 8): def __init__( self, uri: str, transport: Optional[Transport] = ..., encoding: Optional[str] = ..., verbose: bool = ..., allow_none: bool = ..., use_datetime: bool = ..., use_builtin_types: bool = ..., *, headers: Iterable[Tuple[str, str]] = ..., context: Optional[Any] = ..., ) -> None: ... else: def __init__( self, uri: str, transport: Optional[Transport] = ..., encoding: Optional[str] = ..., verbose: bool = ..., allow_none: bool = ..., use_datetime: bool = ..., use_builtin_types: bool = ..., *, context: Optional[Any] = ..., ) -> None: ... def __getattr__(self, name: str) -> _Method: ... @overload def __call__(self, attr: Literal["close"]) -> Callable[[], None]: ... @overload def __call__(self, attr: Literal["transport"]) -> Transport: ... @overload def __call__(self, attr: str) -> Union[Callable[[], None], Transport]: ... def __enter__(self) -> ServerProxy: ... def __exit__( self, exc_type: Optional[Type[BaseException]], exc_val: Optional[BaseException], exc_tb: Optional[TracebackType] ) -> None: ... def __close(self) -> None: ... # undocumented def __request(self, methodname: str, params: Tuple[_Marshallable, ...]) -> Tuple[_Marshallable, ...]: ... # undocumented Server = ServerProxy ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/xmlrpc/server.pyi0000664000175000017500000001523200000000000024455 0ustar00davedave00000000000000import http.server import pydoc import socketserver import sys from datetime import datetime from typing import Any, Callable, Dict, Iterable, List, Mapping, Optional, Pattern, Protocol, Tuple, Type, Union from xmlrpc.client import Fault _Marshallable = Union[ None, bool, int, float, str, bytes, tuple, list, dict, datetime ] # TODO: Recursive type on tuple, list, dict # The dispatch accepts anywhere from 0 to N arguments, no easy way to allow this in mypy class _DispatchArity0(Protocol): def __call__(self) -> _Marshallable: ... class _DispatchArity1(Protocol): def __call__(self, __arg1: _Marshallable) -> _Marshallable: ... class _DispatchArity2(Protocol): def __call__(self, __arg1: _Marshallable, __arg2: _Marshallable) -> _Marshallable: ... class _DispatchArity3(Protocol): def __call__(self, __arg1: _Marshallable, __arg2: _Marshallable, __arg3: _Marshallable) -> _Marshallable: ... class _DispatchArity4(Protocol): def __call__( self, __arg1: _Marshallable, __arg2: _Marshallable, __arg3: _Marshallable, __arg4: _Marshallable ) -> _Marshallable: ... class _DispatchArityN(Protocol): def __call__(self, *args: _Marshallable) -> _Marshallable: ... _DispatchProtocol = Union[_DispatchArity0, _DispatchArity1, _DispatchArity2, _DispatchArity3, _DispatchArity4, _DispatchArityN] def resolve_dotted_attribute(obj: Any, attr: str, allow_dotted_names: bool = ...) -> Any: ... # undocumented def list_public_methods(obj: Any) -> List[str]: ... # undocumented class SimpleXMLRPCDispatcher: # undocumented funcs: Dict[str, _DispatchProtocol] instance: Optional[Any] allow_none: bool encoding: str use_builtin_types: bool def __init__(self, allow_none: bool = ..., encoding: Optional[str] = ..., use_builtin_types: bool = ...) -> None: ... def register_instance(self, instance: Any, allow_dotted_names: bool = ...) -> None: ... if sys.version_info >= (3, 7): def register_function( self, function: Optional[_DispatchProtocol] = ..., name: Optional[str] = ... ) -> Callable[..., Any]: ... else: def register_function(self, function: _DispatchProtocol, name: Optional[str] = ...) -> Callable[..., Any]: ... def register_introspection_functions(self) -> None: ... def register_multicall_functions(self) -> None: ... def _marshaled_dispatch( self, data: str, dispatch_method: Optional[ Callable[[Optional[str], Tuple[_Marshallable, ...]], Union[Fault, Tuple[_Marshallable, ...]]] ] = ..., path: Optional[Any] = ..., ) -> str: ... # undocumented def system_listMethods(self) -> List[str]: ... # undocumented def system_methodSignature(self, method_name: str) -> str: ... # undocumented def system_methodHelp(self, method_name: str) -> str: ... # undocumented def system_multicall(self, call_list: List[Dict[str, _Marshallable]]) -> List[_Marshallable]: ... # undocumented def _dispatch(self, method: str, params: Iterable[_Marshallable]) -> _Marshallable: ... # undocumented class SimpleXMLRPCRequestHandler(http.server.BaseHTTPRequestHandler): rpc_paths: Tuple[str, str] = ... encode_threshold: int = ... # undocumented aepattern: Pattern[str] # undocumented def accept_encodings(self) -> Dict[str, float]: ... def is_rpc_path_valid(self) -> bool: ... def do_POST(self) -> None: ... def decode_request_content(self, data: bytes) -> Optional[bytes]: ... def report_404(self) -> None: ... def log_request(self, code: Union[int, str] = ..., size: Union[int, str] = ...) -> None: ... class SimpleXMLRPCServer(socketserver.TCPServer, SimpleXMLRPCDispatcher): allow_reuse_address: bool = ... _send_traceback_handler: bool = ... def __init__( self, addr: Tuple[str, int], requestHandler: Type[SimpleXMLRPCRequestHandler] = ..., logRequests: bool = ..., allow_none: bool = ..., encoding: Optional[str] = ..., bind_and_activate: bool = ..., use_builtin_types: bool = ..., ) -> None: ... class MultiPathXMLRPCServer(SimpleXMLRPCServer): # undocumented dispatchers: Dict[str, SimpleXMLRPCDispatcher] allow_none: bool encoding: str def __init__( self, addr: Tuple[str, int], requestHandler: Type[SimpleXMLRPCRequestHandler] = ..., logRequests: bool = ..., allow_none: bool = ..., encoding: Optional[str] = ..., bind_and_activate: bool = ..., use_builtin_types: bool = ..., ) -> None: ... def add_dispatcher(self, path: str, dispatcher: SimpleXMLRPCDispatcher) -> SimpleXMLRPCDispatcher: ... def get_dispatcher(self, path: str) -> SimpleXMLRPCDispatcher: ... def _marshaled_dispatch( self, data: str, dispatch_method: Optional[ Callable[[Optional[str], Tuple[_Marshallable, ...]], Union[Fault, Tuple[_Marshallable, ...]]] ] = ..., path: Optional[Any] = ..., ) -> str: ... class CGIXMLRPCRequestHandler(SimpleXMLRPCDispatcher): def __init__(self, allow_none: bool = ..., encoding: Optional[str] = ..., use_builtin_types: bool = ...) -> None: ... def handle_xmlrpc(self, request_text: str) -> None: ... def handle_get(self) -> None: ... def handle_request(self, request_text: Optional[str] = ...) -> None: ... class ServerHTMLDoc(pydoc.HTMLDoc): # undocumented def docroutine(self, object: object, name: str, mod: Optional[str] = ..., funcs: Mapping[str, str] = ..., classes: Mapping[str, str] = ..., methods: Mapping[str, str] = ..., cl: Optional[type] = ...) -> str: ... # type: ignore def docserver(self, server_name: str, package_documentation: str, methods: Dict[str, str]) -> str: ... class XMLRPCDocGenerator: # undocumented server_name: str server_documentation: str server_title: str def __init__(self) -> None: ... def set_server_title(self, server_title: str) -> None: ... def set_server_name(self, server_name: str) -> None: ... def set_server_documentation(self, server_documentation: str) -> None: ... def generate_html_documentation(self) -> str: ... class DocXMLRPCRequestHandler(SimpleXMLRPCRequestHandler): def do_GET(self) -> None: ... class DocXMLRPCServer(SimpleXMLRPCServer, XMLRPCDocGenerator): def __init__( self, addr: Tuple[str, int], requestHandler: Type[SimpleXMLRPCRequestHandler] = ..., logRequests: bool = ..., allow_none: bool = ..., encoding: Optional[str] = ..., bind_and_activate: bool = ..., use_builtin_types: bool = ..., ) -> None: ... class DocCGIXMLRPCRequestHandler(CGIXMLRPCRequestHandler, XMLRPCDocGenerator): def __init__(self) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/xxlimited.pyi0000664000175000017500000000032300000000000023644 0ustar00davedave00000000000000from typing import Any class Null: ... class Str: ... class Xxo: def demo(self) -> None: ... class error: ... def foo(__i: int, __j: int) -> Any: ... def new() -> Xxo: ... def roj(__b: Any) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3/zipapp.pyi0000664000175000017500000000124600000000000023145 0ustar00davedave00000000000000import sys from pathlib import Path from typing import BinaryIO, Callable, Optional, Union _Path = Union[str, Path, BinaryIO] class ZipAppError(ValueError): ... if sys.version_info >= (3, 7): def create_archive( source: _Path, target: Optional[_Path] = ..., interpreter: Optional[str] = ..., main: Optional[str] = ..., filter: Optional[Callable[[Path], bool]] = ..., compressed: bool = ..., ) -> None: ... else: def create_archive( source: _Path, target: Optional[_Path] = ..., interpreter: Optional[str] = ..., main: Optional[str] = ... ) -> None: ... def get_interpreter(archive: _Path) -> str: ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4303794 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3.7/0000775000175000017500000000000000000000000021261 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3.7/_py_abc.pyi0000664000175000017500000000057000000000000023402 0ustar00davedave00000000000000from typing import Any, Dict, Tuple, Type, TypeVar _T = TypeVar("_T") # TODO: Change the return into a NewType bound to int after pytype/#597 def get_cache_token() -> object: ... class ABCMeta(type): def __new__(__mcls, __name: str, __bases: Tuple[Type[Any], ...], __namespace: Dict[str, Any]) -> ABCMeta: ... def register(cls, subclass: Type[_T]) -> Type[_T]: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3.7/contextvars.pyi0000664000175000017500000000275200000000000024372 0ustar00davedave00000000000000import sys from typing import Any, Callable, ClassVar, Generic, Iterator, Mapping, TypeVar, Union, overload if sys.version_info >= (3, 9): from types import GenericAlias _T = TypeVar("_T") _D = TypeVar("_D") class ContextVar(Generic[_T]): def __init__(self, name: str, *, default: _T = ...) -> None: ... @property def name(self) -> str: ... @overload def get(self) -> _T: ... @overload def get(self, default: Union[_D, _T]) -> Union[_D, _T]: ... def set(self, value: _T) -> Token[_T]: ... def reset(self, token: Token[_T]) -> None: ... if sys.version_info >= (3, 9): def __class_getitem__(cls, item: Any) -> GenericAlias: ... class Token(Generic[_T]): @property def var(self) -> ContextVar[_T]: ... @property def old_value(self) -> Any: ... # returns either _T or MISSING, but that's hard to express MISSING: ClassVar[object] if sys.version_info >= (3, 9): def __class_getitem__(cls, item: Any) -> GenericAlias: ... def copy_context() -> Context: ... # It doesn't make sense to make this generic, because for most Contexts each ContextVar will have # a different value. class Context(Mapping[ContextVar[Any], Any]): def __init__(self) -> None: ... def run(self, callable: Callable[..., _T], *args: Any, **kwargs: Any) -> _T: ... def copy(self) -> Context: ... def __getitem__(self, key: ContextVar[Any]) -> Any: ... def __iter__(self) -> Iterator[ContextVar[Any]]: ... def __len__(self) -> int: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3.7/dataclasses.pyi0000664000175000017500000000526100000000000024277 0ustar00davedave00000000000000import sys from typing import Any, Callable, Dict, Generic, Iterable, List, Mapping, Optional, Tuple, Type, TypeVar, Union, overload if sys.version_info >= (3, 9): from types import GenericAlias _T = TypeVar("_T") class _MISSING_TYPE: ... MISSING: _MISSING_TYPE @overload def asdict(obj: Any) -> Dict[str, Any]: ... @overload def asdict(obj: Any, *, dict_factory: Callable[[List[Tuple[str, Any]]], _T]) -> _T: ... @overload def astuple(obj: Any) -> Tuple[Any, ...]: ... @overload def astuple(obj: Any, *, tuple_factory: Callable[[List[Any]], _T]) -> _T: ... @overload def dataclass(_cls: Type[_T]) -> Type[_T]: ... @overload def dataclass(_cls: None) -> Callable[[Type[_T]], Type[_T]]: ... @overload def dataclass( *, init: bool = ..., repr: bool = ..., eq: bool = ..., order: bool = ..., unsafe_hash: bool = ..., frozen: bool = ... ) -> Callable[[Type[_T]], Type[_T]]: ... class Field(Generic[_T]): name: str type: Type[_T] default: _T default_factory: Callable[[], _T] repr: bool hash: Optional[bool] init: bool compare: bool metadata: Mapping[str, Any] if sys.version_info >= (3, 9): def __class_getitem__(cls, item: Any) -> GenericAlias: ... # NOTE: Actual return type is 'Field[_T]', but we want to help type checkers # to understand the magic that happens at runtime. @overload # `default` and `default_factory` are optional and mutually exclusive. def field( *, default: _T, init: bool = ..., repr: bool = ..., hash: Optional[bool] = ..., compare: bool = ..., metadata: Optional[Mapping[str, Any]] = ..., ) -> _T: ... @overload def field( *, default_factory: Callable[[], _T], init: bool = ..., repr: bool = ..., hash: Optional[bool] = ..., compare: bool = ..., metadata: Optional[Mapping[str, Any]] = ..., ) -> _T: ... @overload def field( *, init: bool = ..., repr: bool = ..., hash: Optional[bool] = ..., compare: bool = ..., metadata: Optional[Mapping[str, Any]] = ..., ) -> Any: ... def fields(class_or_instance: Any) -> Tuple[Field[Any], ...]: ... def is_dataclass(obj: Any) -> bool: ... class FrozenInstanceError(AttributeError): ... class InitVar(Generic[_T]): if sys.version_info >= (3, 9): def __class_getitem__(cls, type: Any) -> GenericAlias: ... def make_dataclass( cls_name: str, fields: Iterable[Union[str, Tuple[str, type], Tuple[str, type, Field[Any]]]], *, bases: Tuple[type, ...] = ..., namespace: Optional[Dict[str, Any]] = ..., init: bool = ..., repr: bool = ..., eq: bool = ..., order: bool = ..., unsafe_hash: bool = ..., frozen: bool = ..., ) -> type: ... def replace(obj: _T, **changes: Any) -> _T: ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4303794 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3.9/0000775000175000017500000000000000000000000021263 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3.9/graphlib.pyi0000664000175000017500000000112000000000000023570 0ustar00davedave00000000000000from _typeshed import SupportsItems from typing import Generic, Iterable, Optional, Tuple, TypeVar _T = TypeVar("_T") class TopologicalSorter(Generic[_T]): def __init__(self, graph: Optional[SupportsItems[_T, Iterable[_T]]] = ...) -> None: ... def add(self, node: _T, *predecessors: _T) -> None: ... def prepare(self) -> None: ... def is_active(self) -> bool: ... def __bool__(self) -> bool: ... def done(self, *nodes: _T) -> None: ... def get_ready(self) -> Tuple[_T, ...]: ... def static_order(self) -> Iterable[_T]: ... class CycleError(ValueError): ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4303794 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3.9/zoneinfo/0000775000175000017500000000000000000000000023112 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/stdlib/3.9/zoneinfo/__init__.pyi0000664000175000017500000000223700000000000025400 0ustar00davedave00000000000000import os import typing from datetime import tzinfo from typing import Any, AnyStr, Iterable, Optional, Protocol, Sequence, Set, Type, Union _T = typing.TypeVar("_T", bound="ZoneInfo") class _IOBytes(Protocol): def read(self, __size: int) -> bytes: ... def seek(self, __size: int, __whence: int = ...) -> Any: ... class ZoneInfo(tzinfo): @property def key(self) -> str: ... def __init__(self, key: str) -> None: ... @classmethod def no_cache(cls: Type[_T], key: str) -> _T: ... @classmethod def from_file(cls: Type[_T], __fobj: _IOBytes, key: Optional[str] = ...) -> _T: ... @classmethod def clear_cache(cls, *, only_keys: Iterable[str] = ...) -> None: ... # Note: Both here and in clear_cache, the types allow the use of `str` where # a sequence of strings is required. This should be remedied if a solution # to this typing bug is found: https://github.com/python/typing/issues/256 def reset_tzpath(to: Optional[Sequence[Union[os.PathLike[AnyStr], str]]] = ...) -> None: ... def available_timezones() -> Set[str]: ... TZPATH: Sequence[str] class ZoneInfoNotFoundError(KeyError): ... class InvalidTZPathWarning(RuntimeWarning): ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.3823793 jedi-0.19.1/jedi/third_party/typeshed/third_party/0000775000175000017500000000000000000000000022022 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4343793 jedi-0.19.1/jedi/third_party/typeshed/third_party/2/0000775000175000017500000000000000000000000022163 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4343793 jedi-0.19.1/jedi/third_party/typeshed/third_party/2/OpenSSL/0000775000175000017500000000000000000000000023446 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2/OpenSSL/__init__.pyi0000664000175000017500000000000000000000000025716 0ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2/OpenSSL/crypto.pyi0000664000175000017500000001664400000000000025524 0ustar00davedave00000000000000from datetime import datetime from typing import Any, Callable, Iterable, List, Optional, Set, Text, Tuple, Union from cryptography.hazmat.primitives.asymmetric import dsa, rsa FILETYPE_PEM: int FILETYPE_ASN1: int FILETYPE_TEXT: int TYPE_RSA: int TYPE_DSA: int class Error(Exception): ... _Key = Union[rsa.RSAPublicKey, rsa.RSAPrivateKey, dsa.DSAPublicKey, dsa.DSAPrivateKey] class PKey: def __init__(self) -> None: ... def to_cryptography_key(self) -> _Key: ... @classmethod def from_cryptography_key(cls, crypto_key: _Key): ... def generate_key(self, type: int, bits: int) -> None: ... def check(self) -> bool: ... def type(self) -> int: ... def bits(self) -> int: ... class _EllipticCurve: name: Text def get_elliptic_curves() -> Set[_EllipticCurve]: ... def get_elliptic_curve(name: str) -> _EllipticCurve: ... class X509Name: def __init__(self, name: X509Name) -> None: ... countryName: Union[str, unicode] stateOrProvinceName: Union[str, unicode] localityName: Union[str, unicode] organizationName: Union[str, unicode] organizationalUnitName: Union[str, unicode] commonName: Union[str, unicode] emailAddress: Union[str, unicode] C: Union[str, unicode] ST: Union[str, unicode] L: Union[str, unicode] O: Union[str, unicode] OU: Union[str, unicode] CN: Union[str, unicode] def hash(self) -> int: ... def der(self) -> bytes: ... def get_components(self) -> List[Tuple[str, str]]: ... class X509Extension: def __init__( self, type_name: bytes, critical: bool, value: bytes, subject: Optional[X509] = ..., issuer: Optional[X509] = ... ) -> None: ... def get_critical(self) -> bool: ... def get_short_name(self) -> str: ... def get_data(self) -> str: ... class X509Req: def __init__(self) -> None: ... def set_pubkey(self, pkey: PKey) -> None: ... def get_pubkey(self) -> PKey: ... def set_version(self, version: int) -> None: ... def get_version(self) -> int: ... def get_subject(self) -> X509Name: ... def add_extensions(self, extensions: Iterable[X509Extension]) -> None: ... def get_extensions(self) -> List[X509Extension]: ... def sign(self, pkey: PKey, digest: str) -> None: ... def verify(self, pkey: PKey) -> bool: ... class X509: def __init__(self) -> None: ... def set_version(self, version: int) -> None: ... def get_version(self) -> int: ... def get_pubkey(self) -> PKey: ... def set_pubkey(self, pkey: PKey) -> None: ... def sign(self, pkey: PKey, digest: str) -> None: ... def get_signature_algorithm(self) -> str: ... def digest(self, digest_name: str) -> str: ... def subject_name_hash(self) -> str: ... def set_serial_number(self, serial: int) -> None: ... def get_serial_number(self) -> int: ... def gmtime_adj_notAfter(self, amount: int) -> None: ... def gmtime_adj_notBefore(self, amount: int) -> None: ... def has_expired(self) -> bool: ... def get_notBefore(self) -> str: ... def set_notBefore(self, when: str) -> None: ... def get_notAfter(self) -> str: ... def set_notAfter(self, when: str) -> None: ... def get_issuer(self) -> X509Name: ... def set_issuer(self, issuer: X509Name) -> None: ... def get_subject(self) -> X509Name: ... def set_subject(self, subject: X509Name) -> None: ... def get_extension_count(self) -> int: ... def add_extensions(self, extensions: Iterable[X509Extension]) -> None: ... def get_extension(self, index: int) -> X509Extension: ... class X509StoreFlags: CRL_CHECK: int CRL_CHECK_ALL: int IGNORE_CRITICAL: int X509_STRICT: int ALLOW_PROXY_CERTS: int POLICY_CHECK: int EXPLICIT_POLICY: int INHIBIT_MAP: int NOTIFY_POLICY: int CHECK_SS_SIGNATURE: int CB_ISSUER_CHECK: int class X509Store: def __init__(self) -> None: ... def add_cert(self, cert: X509) -> None: ... def add_crl(self, crl: CRL) -> None: ... def set_flags(self, flags: int) -> None: ... def set_time(self, vfy_time: datetime) -> None: ... class X509StoreContextError(Exception): certificate: X509 def __init__(self, message: str, certificate: X509) -> None: ... class X509StoreContext: def __init__(self, store: X509Store, certificate: X509) -> None: ... def set_store(self, store: X509Store) -> None: ... def verify_certificate(self) -> None: ... def load_certificate(type: int, buffer: Union[str, unicode]) -> X509: ... def dump_certificate(type: int, cert: X509) -> bytes: ... def dump_publickey(type: int, pkey: PKey) -> bytes: ... def dump_privatekey( type: int, pkey: PKey, cipher: Optional[str] = ..., passphrase: Optional[Union[str, Callable[[int], int]]] = ... ) -> bytes: ... class Revoked: def __init__(self) -> None: ... def set_serial(self, hex_str: str) -> None: ... def get_serial(self) -> str: ... def set_reason(self, reason: str) -> None: ... def get_reason(self) -> str: ... def all_reasons(self) -> List[str]: ... def set_rev_date(self, when: str) -> None: ... def get_rev_date(self) -> str: ... class CRL: def __init__(self) -> None: ... def get_revoked(self) -> Tuple[Revoked, ...]: ... def add_revoked(self, revoked: Revoked) -> None: ... def get_issuer(self) -> X509Name: ... def set_version(self, version: int) -> None: ... def set_lastUpdate(self, when: str) -> None: ... def set_nextUpdate(self, when: str) -> None: ... def sign(self, issuer_cert: X509, issuer_key: PKey, digest: str) -> None: ... def export(self, cert: X509, key: PKey, type: int = ..., days: int = ..., digest: str = ...) -> bytes: ... class PKCS7: def type_is_signed(self) -> bool: ... def type_is_enveloped(self) -> bool: ... def type_is_signedAndEnveloped(self) -> bool: ... def type_is_data(self) -> bool: ... def get_type_name(self) -> str: ... class PKCS12: def __init__(self) -> None: ... def get_certificate(self) -> X509: ... def set_certificate(self, cert: X509) -> None: ... def get_privatekey(self) -> PKey: ... def set_privatekey(self, pkey: PKey) -> None: ... def get_ca_certificates(self) -> Tuple[X509, ...]: ... def set_ca_certificates(self, cacerts: Iterable[X509]) -> None: ... def set_friendlyname(self, name: bytes) -> None: ... def get_friendlyname(self) -> bytes: ... def export(self, passphrase: Optional[str] = ..., iter: int = ..., maciter: int = ...): ... class NetscapeSPKI: def __init__(self) -> None: ... def sign(self, pkey: PKey, digest: str) -> None: ... def verify(self, key: PKey) -> bool: ... def b64_encode(self) -> str: ... def get_pubkey(self) -> PKey: ... def set_pubkey(self, pkey: PKey) -> None: ... def load_publickey(type: int, buffer: Union[str, unicode]) -> PKey: ... def load_privatekey(type: int, buffer: bytes, passphrase: Optional[Union[str, Callable[[int], int]]] = ...): ... def dump_certificate_request(type: int, req: X509Req): ... def load_certificate_request(type, buffer: Union[str, unicode]) -> X509Req: ... def sign(pkey: PKey, data: Union[str, unicode], digest: str) -> bytes: ... def verify(cert: X509, signature: bytes, data: Union[str, unicode], digest: str) -> None: ... def dump_crl(type: int, crl: CRL) -> bytes: ... def load_crl(type: int, buffer: Union[str, unicode]) -> CRL: ... def load_pkcs7_data(type: int, buffer: Union[str, unicode]) -> PKCS7: ... def load_pkcs12(buffer: Union[str, unicode], passphrase: Optional[Union[str, Callable[[int], int]]] = ...) -> PKCS12: ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4343793 jedi-0.19.1/jedi/third_party/typeshed/third_party/2/concurrent/0000775000175000017500000000000000000000000024345 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2/concurrent/__init__.pyi0000664000175000017500000000000000000000000026615 0ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4343793 jedi-0.19.1/jedi/third_party/typeshed/third_party/2/concurrent/futures/0000775000175000017500000000000000000000000026042 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2/concurrent/futures/__init__.pyi0000664000175000017500000000066400000000000030332 0ustar00davedave00000000000000from ._base import ( ALL_COMPLETED as ALL_COMPLETED, FIRST_COMPLETED as FIRST_COMPLETED, FIRST_EXCEPTION as FIRST_EXCEPTION, CancelledError as CancelledError, Executor as Executor, Future as Future, TimeoutError as TimeoutError, as_completed as as_completed, wait as wait, ) from .process import ProcessPoolExecutor as ProcessPoolExecutor from .thread import ThreadPoolExecutor as ThreadPoolExecutor ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2/concurrent/futures/_base.pyi0000664000175000017500000000716500000000000027647 0ustar00davedave00000000000000import threading from abc import abstractmethod from logging import Logger from types import TracebackType from typing import Any, Callable, Container, Generic, Iterable, Iterator, List, Optional, Protocol, Set, Tuple, TypeVar FIRST_COMPLETED: str FIRST_EXCEPTION: str ALL_COMPLETED: str PENDING: str RUNNING: str CANCELLED: str CANCELLED_AND_NOTIFIED: str FINISHED: str LOGGER: Logger class Error(Exception): ... class CancelledError(Error): ... class TimeoutError(Error): ... _T = TypeVar("_T") _T_co = TypeVar("_T_co", covariant=True) # Copied over Collection implementation as it does not exist in Python 2 and <3.6. # Also to solve pytype issues with _Collection. class _Collection(Iterable[_T_co], Container[_T_co], Protocol[_T_co]): # Implement Sized (but don't have it as a base class). @abstractmethod def __len__(self) -> int: ... class Future(Generic[_T]): def __init__(self) -> None: ... def cancel(self) -> bool: ... def cancelled(self) -> bool: ... def running(self) -> bool: ... def done(self) -> bool: ... def add_done_callback(self, fn: Callable[[Future[_T]], Any]) -> None: ... def result(self, timeout: Optional[float] = ...) -> _T: ... def set_running_or_notify_cancel(self) -> bool: ... def set_result(self, result: _T) -> None: ... def exception(self, timeout: Optional[float] = ...) -> Any: ... def exception_info(self, timeout: Optional[float] = ...) -> Tuple[Any, Optional[TracebackType]]: ... def set_exception(self, exception: Any) -> None: ... def set_exception_info(self, exception: Any, traceback: Optional[TracebackType]) -> None: ... class Executor: def submit(self, fn: Callable[..., _T], *args: Any, **kwargs: Any) -> Future[_T]: ... def map(self, func: Callable[..., _T], *iterables: Iterable[Any], timeout: Optional[float] = ...) -> Iterator[_T]: ... def shutdown(self, wait: bool = ...) -> None: ... def __enter__(self: _T) -> _T: ... def __exit__(self, exc_type: Any, exc_val: Any, exc_tb: Any) -> Optional[bool]: ... def as_completed(fs: Iterable[Future[_T]], timeout: Optional[float] = ...) -> Iterator[Future[_T]]: ... def wait( fs: _Collection[Future[_T]], timeout: Optional[float] = ..., return_when: str = ... ) -> Tuple[Set[Future[_T]], Set[Future[_T]]]: ... class _Waiter: event: threading.Event finished_futures: List[Future[Any]] def __init__(self) -> None: ... def add_result(self, future: Future[Any]) -> None: ... def add_exception(self, future: Future[Any]) -> None: ... def add_cancelled(self, future: Future[Any]) -> None: ... class _AsCompletedWaiter(_Waiter): lock: threading.Lock def __init__(self) -> None: ... def add_result(self, future: Future[Any]) -> None: ... def add_exception(self, future: Future[Any]) -> None: ... def add_cancelled(self, future: Future[Any]) -> None: ... class _FirstCompletedWaiter(_Waiter): def add_result(self, future: Future[Any]) -> None: ... def add_exception(self, future: Future[Any]) -> None: ... def add_cancelled(self, future: Future[Any]) -> None: ... class _AllCompletedWaiter(_Waiter): num_pending_calls: int stop_on_exception: bool lock: threading.Lock def __init__(self, num_pending_calls: int, stop_on_exception: bool) -> None: ... def add_result(self, future: Future[Any]) -> None: ... def add_exception(self, future: Future[Any]) -> None: ... def add_cancelled(self, future: Future[Any]) -> None: ... class _AcquireFutures: futures: Iterable[Future[Any]] def __init__(self, futures: Iterable[Future[Any]]) -> None: ... def __enter__(self) -> None: ... def __exit__(self, *args: Any) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2/concurrent/futures/process.pyi0000664000175000017500000000030300000000000030237 0ustar00davedave00000000000000from typing import Any, Optional from ._base import Executor EXTRA_QUEUED_CALLS: Any class ProcessPoolExecutor(Executor): def __init__(self, max_workers: Optional[int] = ...) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2/concurrent/futures/thread.pyi0000664000175000017500000000107600000000000030040 0ustar00davedave00000000000000from typing import Any, Callable, Generic, Iterable, Mapping, Optional, Tuple, TypeVar from ._base import Executor, Future _S = TypeVar("_S") class ThreadPoolExecutor(Executor): def __init__(self, max_workers: Optional[int] = ..., thread_name_prefix: str = ...) -> None: ... class _WorkItem(Generic[_S]): future: Future[_S] fn: Callable[..., _S] args: Iterable[Any] kwargs: Mapping[str, Any] def __init__(self, future: Future[_S], fn: Callable[..., _S], args: Iterable[Any], kwargs: Mapping[str, Any]) -> None: ... def run(self) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2/enum.pyi0000664000175000017500000000512300000000000023653 0ustar00davedave00000000000000import sys from abc import ABCMeta from typing import Any, Dict, Iterator, List, Mapping, Type, TypeVar, Union _T = TypeVar("_T") _S = TypeVar("_S", bound=Type[Enum]) # Note: EnumMeta actually subclasses type directly, not ABCMeta. # This is a temporary workaround to allow multiple creation of enums with builtins # such as str as mixins, which due to the handling of ABCs of builtin types, cause # spurious inconsistent metaclass structure. See #1595. # Structurally: Iterable[T], Reversible[T], Container[T] where T is the enum itself class EnumMeta(ABCMeta): def __iter__(self: Type[_T]) -> Iterator[_T]: ... def __reversed__(self: Type[_T]) -> Iterator[_T]: ... def __contains__(self: Type[_T], member: object) -> bool: ... def __getitem__(self: Type[_T], name: str) -> _T: ... @property def __members__(self: Type[_T]) -> Mapping[str, _T]: ... def __len__(self) -> int: ... class Enum(metaclass=EnumMeta): name: str value: Any _name_: str _value_: Any _member_names_: List[str] # undocumented _member_map_: Dict[str, Enum] # undocumented _value2member_map_: Dict[int, Enum] # undocumented if sys.version_info >= (3, 7): _ignore_: Union[str, List[str]] _order_: str __order__: str @classmethod def _missing_(cls, value: object) -> Any: ... @staticmethod def _generate_next_value_(name: str, start: int, count: int, last_values: List[Any]) -> Any: ... def __new__(cls: Type[_T], value: object) -> _T: ... def __repr__(self) -> str: ... def __str__(self) -> str: ... def __dir__(self) -> List[str]: ... def __format__(self, format_spec: str) -> str: ... def __hash__(self) -> Any: ... def __reduce_ex__(self, proto: object) -> Any: ... class IntEnum(int, Enum): value: int def unique(enumeration: _S) -> _S: ... _auto_null: Any # subclassing IntFlag so it picks up all implemented base functions, best modeling behavior of enum.auto() class auto(IntFlag): value: Any class Flag(Enum): def __contains__(self: _T, other: _T) -> bool: ... def __repr__(self) -> str: ... def __str__(self) -> str: ... def __bool__(self) -> bool: ... def __or__(self: _T, other: _T) -> _T: ... def __and__(self: _T, other: _T) -> _T: ... def __xor__(self: _T, other: _T) -> _T: ... def __invert__(self: _T) -> _T: ... class IntFlag(int, Flag): def __or__(self: _T, other: Union[int, _T]) -> _T: ... def __and__(self: _T, other: Union[int, _T]) -> _T: ... def __xor__(self: _T, other: Union[int, _T]) -> _T: ... __ror__ = __or__ __rand__ = __and__ __rxor__ = __xor__ ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4343793 jedi-0.19.1/jedi/third_party/typeshed/third_party/2/fb303/0000775000175000017500000000000000000000000023000 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2/fb303/FacebookService.pyi0000664000175000017500000002076400000000000026566 0ustar00davedave00000000000000from typing import Any from thrift.Thrift import TProcessor # type: ignore fastbinary: Any class Iface: def getName(self): ... def getVersion(self): ... def getStatus(self): ... def getStatusDetails(self): ... def getCounters(self): ... def getCounter(self, key): ... def setOption(self, key, value): ... def getOption(self, key): ... def getOptions(self): ... def getCpuProfile(self, profileDurationInSec): ... def aliveSince(self): ... def reinitialize(self): ... def shutdown(self): ... class Client(Iface): def __init__(self, iprot, oprot=...) -> None: ... def getName(self): ... def send_getName(self): ... def recv_getName(self): ... def getVersion(self): ... def send_getVersion(self): ... def recv_getVersion(self): ... def getStatus(self): ... def send_getStatus(self): ... def recv_getStatus(self): ... def getStatusDetails(self): ... def send_getStatusDetails(self): ... def recv_getStatusDetails(self): ... def getCounters(self): ... def send_getCounters(self): ... def recv_getCounters(self): ... def getCounter(self, key): ... def send_getCounter(self, key): ... def recv_getCounter(self): ... def setOption(self, key, value): ... def send_setOption(self, key, value): ... def recv_setOption(self): ... def getOption(self, key): ... def send_getOption(self, key): ... def recv_getOption(self): ... def getOptions(self): ... def send_getOptions(self): ... def recv_getOptions(self): ... def getCpuProfile(self, profileDurationInSec): ... def send_getCpuProfile(self, profileDurationInSec): ... def recv_getCpuProfile(self): ... def aliveSince(self): ... def send_aliveSince(self): ... def recv_aliveSince(self): ... def reinitialize(self): ... def send_reinitialize(self): ... def shutdown(self): ... def send_shutdown(self): ... class Processor(Iface, TProcessor): # type: ignore def __init__(self, handler) -> None: ... def process(self, iprot, oprot): ... def process_getName(self, seqid, iprot, oprot): ... def process_getVersion(self, seqid, iprot, oprot): ... def process_getStatus(self, seqid, iprot, oprot): ... def process_getStatusDetails(self, seqid, iprot, oprot): ... def process_getCounters(self, seqid, iprot, oprot): ... def process_getCounter(self, seqid, iprot, oprot): ... def process_setOption(self, seqid, iprot, oprot): ... def process_getOption(self, seqid, iprot, oprot): ... def process_getOptions(self, seqid, iprot, oprot): ... def process_getCpuProfile(self, seqid, iprot, oprot): ... def process_aliveSince(self, seqid, iprot, oprot): ... def process_reinitialize(self, seqid, iprot, oprot): ... def process_shutdown(self, seqid, iprot, oprot): ... class getName_args: thrift_spec: Any def read(self, iprot): ... def write(self, oprot): ... def validate(self): ... def __eq__(self, other): ... def __ne__(self, other): ... class getName_result: thrift_spec: Any success: Any def __init__(self, success=...) -> None: ... def read(self, iprot): ... def write(self, oprot): ... def validate(self): ... def __eq__(self, other): ... def __ne__(self, other): ... class getVersion_args: thrift_spec: Any def read(self, iprot): ... def write(self, oprot): ... def validate(self): ... def __eq__(self, other): ... def __ne__(self, other): ... class getVersion_result: thrift_spec: Any success: Any def __init__(self, success=...) -> None: ... def read(self, iprot): ... def write(self, oprot): ... def validate(self): ... def __eq__(self, other): ... def __ne__(self, other): ... class getStatus_args: thrift_spec: Any def read(self, iprot): ... def write(self, oprot): ... def validate(self): ... def __eq__(self, other): ... def __ne__(self, other): ... class getStatus_result: thrift_spec: Any success: Any def __init__(self, success=...) -> None: ... def read(self, iprot): ... def write(self, oprot): ... def validate(self): ... def __eq__(self, other): ... def __ne__(self, other): ... class getStatusDetails_args: thrift_spec: Any def read(self, iprot): ... def write(self, oprot): ... def validate(self): ... def __eq__(self, other): ... def __ne__(self, other): ... class getStatusDetails_result: thrift_spec: Any success: Any def __init__(self, success=...) -> None: ... def read(self, iprot): ... def write(self, oprot): ... def validate(self): ... def __eq__(self, other): ... def __ne__(self, other): ... class getCounters_args: thrift_spec: Any def read(self, iprot): ... def write(self, oprot): ... def validate(self): ... def __eq__(self, other): ... def __ne__(self, other): ... class getCounters_result: thrift_spec: Any success: Any def __init__(self, success=...) -> None: ... def read(self, iprot): ... def write(self, oprot): ... def validate(self): ... def __eq__(self, other): ... def __ne__(self, other): ... class getCounter_args: thrift_spec: Any key: Any def __init__(self, key=...) -> None: ... def read(self, iprot): ... def write(self, oprot): ... def validate(self): ... def __eq__(self, other): ... def __ne__(self, other): ... class getCounter_result: thrift_spec: Any success: Any def __init__(self, success=...) -> None: ... def read(self, iprot): ... def write(self, oprot): ... def validate(self): ... def __eq__(self, other): ... def __ne__(self, other): ... class setOption_args: thrift_spec: Any key: Any value: Any def __init__(self, key=..., value=...) -> None: ... def read(self, iprot): ... def write(self, oprot): ... def validate(self): ... def __eq__(self, other): ... def __ne__(self, other): ... class setOption_result: thrift_spec: Any def read(self, iprot): ... def write(self, oprot): ... def validate(self): ... def __eq__(self, other): ... def __ne__(self, other): ... class getOption_args: thrift_spec: Any key: Any def __init__(self, key=...) -> None: ... def read(self, iprot): ... def write(self, oprot): ... def validate(self): ... def __eq__(self, other): ... def __ne__(self, other): ... class getOption_result: thrift_spec: Any success: Any def __init__(self, success=...) -> None: ... def read(self, iprot): ... def write(self, oprot): ... def validate(self): ... def __eq__(self, other): ... def __ne__(self, other): ... class getOptions_args: thrift_spec: Any def read(self, iprot): ... def write(self, oprot): ... def validate(self): ... def __eq__(self, other): ... def __ne__(self, other): ... class getOptions_result: thrift_spec: Any success: Any def __init__(self, success=...) -> None: ... def read(self, iprot): ... def write(self, oprot): ... def validate(self): ... def __eq__(self, other): ... def __ne__(self, other): ... class getCpuProfile_args: thrift_spec: Any profileDurationInSec: Any def __init__(self, profileDurationInSec=...) -> None: ... def read(self, iprot): ... def write(self, oprot): ... def validate(self): ... def __eq__(self, other): ... def __ne__(self, other): ... class getCpuProfile_result: thrift_spec: Any success: Any def __init__(self, success=...) -> None: ... def read(self, iprot): ... def write(self, oprot): ... def validate(self): ... def __eq__(self, other): ... def __ne__(self, other): ... class aliveSince_args: thrift_spec: Any def read(self, iprot): ... def write(self, oprot): ... def validate(self): ... def __eq__(self, other): ... def __ne__(self, other): ... class aliveSince_result: thrift_spec: Any success: Any def __init__(self, success=...) -> None: ... def read(self, iprot): ... def write(self, oprot): ... def validate(self): ... def __eq__(self, other): ... def __ne__(self, other): ... class reinitialize_args: thrift_spec: Any def read(self, iprot): ... def write(self, oprot): ... def validate(self): ... def __eq__(self, other): ... def __ne__(self, other): ... class shutdown_args: thrift_spec: Any def read(self, iprot): ... def write(self, oprot): ... def validate(self): ... def __eq__(self, other): ... def __ne__(self, other): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2/fb303/__init__.pyi0000664000175000017500000000000000000000000025250 0ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2/ipaddress.pyi0000664000175000017500000001176300000000000024674 0ustar00davedave00000000000000from typing import Any, Container, Generic, Iterable, Iterator, Optional, SupportsInt, Text, Tuple, TypeVar, overload # Undocumented length constants IPV4LENGTH: int IPV6LENGTH: int _A = TypeVar("_A", IPv4Address, IPv6Address) _N = TypeVar("_N", IPv4Network, IPv6Network) _T = TypeVar("_T") def ip_address(address: object) -> Any: ... # morally Union[IPv4Address, IPv6Address] def ip_network(address: object, strict: bool = ...) -> Any: ... # morally Union[IPv4Network, IPv6Network] def ip_interface(address: object) -> Any: ... # morally Union[IPv4Interface, IPv6Interface] class _IPAddressBase: def __eq__(self, other: Any) -> bool: ... def __ge__(self: _T, other: _T) -> bool: ... def __gt__(self: _T, other: _T) -> bool: ... def __le__(self: _T, other: _T) -> bool: ... def __lt__(self: _T, other: _T) -> bool: ... def __ne__(self, other: Any) -> bool: ... @property def compressed(self) -> Text: ... @property def exploded(self) -> Text: ... @property def reverse_pointer(self) -> Text: ... @property def version(self) -> int: ... class _BaseAddress(_IPAddressBase, SupportsInt): def __init__(self, address: object) -> None: ... def __add__(self: _T, other: int) -> _T: ... def __hash__(self) -> int: ... def __int__(self) -> int: ... def __sub__(self: _T, other: int) -> _T: ... @property def is_global(self) -> bool: ... @property def is_link_local(self) -> bool: ... @property def is_loopback(self) -> bool: ... @property def is_multicast(self) -> bool: ... @property def is_private(self) -> bool: ... @property def is_reserved(self) -> bool: ... @property def is_unspecified(self) -> bool: ... @property def max_prefixlen(self) -> int: ... @property def packed(self) -> bytes: ... class _BaseNetwork(_IPAddressBase, Container[_A], Iterable[_A], Generic[_A]): network_address: _A netmask: _A def __init__(self, address: object, strict: bool = ...) -> None: ... def __contains__(self, other: Any) -> bool: ... def __getitem__(self, n: int) -> _A: ... def __iter__(self) -> Iterator[_A]: ... def address_exclude(self: _T, other: _T) -> Iterator[_T]: ... @property def broadcast_address(self) -> _A: ... def compare_networks(self: _T, other: _T) -> int: ... def hosts(self) -> Iterator[_A]: ... @property def is_global(self) -> bool: ... @property def is_link_local(self) -> bool: ... @property def is_loopback(self) -> bool: ... @property def is_multicast(self) -> bool: ... @property def is_private(self) -> bool: ... @property def is_reserved(self) -> bool: ... @property def is_unspecified(self) -> bool: ... @property def max_prefixlen(self) -> int: ... @property def num_addresses(self) -> int: ... def overlaps(self, other: _BaseNetwork[_A]) -> bool: ... @property def prefixlen(self) -> int: ... def subnets(self: _T, prefixlen_diff: int = ..., new_prefix: Optional[int] = ...) -> Iterator[_T]: ... def supernet(self: _T, prefixlen_diff: int = ..., new_prefix: Optional[int] = ...) -> _T: ... @property def with_hostmask(self) -> Text: ... @property def with_netmask(self) -> Text: ... @property def with_prefixlen(self) -> Text: ... @property def hostmask(self) -> _A: ... class _BaseInterface(_BaseAddress, Generic[_A, _N]): hostmask: _A netmask: _A network: _N @property def ip(self) -> _A: ... @property def with_hostmask(self) -> Text: ... @property def with_netmask(self) -> Text: ... @property def with_prefixlen(self) -> Text: ... class IPv4Address(_BaseAddress): ... class IPv4Network(_BaseNetwork[IPv4Address]): ... class IPv4Interface(IPv4Address, _BaseInterface[IPv4Address, IPv4Network]): ... class IPv6Address(_BaseAddress): @property def ipv4_mapped(self) -> Optional[IPv4Address]: ... @property def is_site_local(self) -> bool: ... @property def sixtofour(self) -> Optional[IPv4Address]: ... @property def teredo(self) -> Optional[Tuple[IPv4Address, IPv4Address]]: ... class IPv6Network(_BaseNetwork[IPv6Address]): @property def is_site_local(self) -> bool: ... class IPv6Interface(IPv6Address, _BaseInterface[IPv6Address, IPv6Network]): ... def v4_int_to_packed(address: int) -> bytes: ... def v6_int_to_packed(address: int) -> bytes: ... @overload def summarize_address_range(first: IPv4Address, last: IPv4Address) -> Iterator[IPv4Network]: ... @overload def summarize_address_range(first: IPv6Address, last: IPv6Address) -> Iterator[IPv6Network]: ... def collapse_addresses(addresses: Iterable[_N]) -> Iterator[_N]: ... @overload def get_mixed_type_key(obj: _A) -> Tuple[int, _A]: ... @overload def get_mixed_type_key(obj: IPv4Network) -> Tuple[int, IPv4Address, IPv4Address]: ... @overload def get_mixed_type_key(obj: IPv6Network) -> Tuple[int, IPv6Address, IPv6Address]: ... class AddressValueError(ValueError): ... class NetmaskValueError(ValueError): ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4343793 jedi-0.19.1/jedi/third_party/typeshed/third_party/2/kazoo/0000775000175000017500000000000000000000000023306 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2/kazoo/__init__.pyi0000664000175000017500000000000000000000000025556 0ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2/kazoo/client.pyi0000664000175000017500000000651000000000000025311 0ustar00davedave00000000000000from typing import Any string_types: Any bytes_types: Any LOST_STATES: Any ENVI_VERSION: Any ENVI_VERSION_KEY: Any log: Any class KazooClient: logger: Any handler: Any auth_data: Any default_acl: Any randomize_hosts: Any hosts: Any chroot: Any state: Any state_listeners: Any read_only: Any retry: Any Barrier: Any Counter: Any DoubleBarrier: Any ChildrenWatch: Any DataWatch: Any Election: Any NonBlockingLease: Any MultiNonBlockingLease: Any Lock: Any Party: Any Queue: Any LockingQueue: Any SetPartitioner: Any Semaphore: Any ShallowParty: Any def __init__( self, hosts=..., timeout=..., client_id=..., handler=..., default_acl=..., auth_data=..., read_only=..., randomize_hosts=..., connection_retry=..., command_retry=..., logger=..., **kwargs, ) -> None: ... @property def client_state(self): ... @property def client_id(self): ... @property def connected(self): ... def set_hosts(self, hosts, randomize_hosts=...): ... def add_listener(self, listener): ... def remove_listener(self, listener): ... def start(self, timeout=...): ... def start_async(self): ... def stop(self): ... def restart(self): ... def close(self): ... def command(self, cmd=...): ... def server_version(self, retries=...): ... def add_auth(self, scheme, credential): ... def add_auth_async(self, scheme, credential): ... def unchroot(self, path): ... def sync_async(self, path): ... def sync(self, path): ... def create(self, path, value=..., acl=..., ephemeral=..., sequence=..., makepath=...): ... def create_async(self, path, value=..., acl=..., ephemeral=..., sequence=..., makepath=...): ... def ensure_path(self, path, acl=...): ... def ensure_path_async(self, path, acl=...): ... def exists(self, path, watch=...): ... def exists_async(self, path, watch=...): ... def get(self, path, watch=...): ... def get_async(self, path, watch=...): ... def get_children(self, path, watch=..., include_data=...): ... def get_children_async(self, path, watch=..., include_data=...): ... def get_acls(self, path): ... def get_acls_async(self, path): ... def set_acls(self, path, acls, version=...): ... def set_acls_async(self, path, acls, version=...): ... def set(self, path, value, version=...): ... def set_async(self, path, value, version=...): ... def transaction(self): ... def delete(self, path, version=..., recursive=...): ... def delete_async(self, path, version=...): ... def reconfig(self, joining, leaving, new_members, from_config=...): ... def reconfig_async(self, joining, leaving, new_members, from_config): ... class TransactionRequest: client: Any operations: Any committed: Any def __init__(self, client) -> None: ... def create(self, path, value=..., acl=..., ephemeral=..., sequence=...): ... def delete(self, path, version=...): ... def set_data(self, path, value, version=...): ... def check(self, path, version): ... def commit_async(self): ... def commit(self): ... def __enter__(self): ... def __exit__(self, exc_type, exc_value, exc_tb): ... class KazooState: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2/kazoo/exceptions.pyi0000664000175000017500000000400600000000000026212 0ustar00davedave00000000000000from typing import Any class KazooException(Exception): ... class ZookeeperError(KazooException): ... class CancelledError(KazooException): ... class ConfigurationError(KazooException): ... class ZookeeperStoppedError(KazooException): ... class ConnectionDropped(KazooException): ... class LockTimeout(KazooException): ... class WriterNotClosedException(KazooException): ... EXCEPTIONS: Any class RolledBackError(ZookeeperError): ... class SystemZookeeperError(ZookeeperError): ... class RuntimeInconsistency(ZookeeperError): ... class DataInconsistency(ZookeeperError): ... class ConnectionLoss(ZookeeperError): ... class MarshallingError(ZookeeperError): ... class UnimplementedError(ZookeeperError): ... class OperationTimeoutError(ZookeeperError): ... class BadArgumentsError(ZookeeperError): ... class NewConfigNoQuorumError(ZookeeperError): ... class ReconfigInProcessError(ZookeeperError): ... class APIError(ZookeeperError): ... class NoNodeError(ZookeeperError): ... class NoAuthError(ZookeeperError): ... class BadVersionError(ZookeeperError): ... class NoChildrenForEphemeralsError(ZookeeperError): ... class NodeExistsError(ZookeeperError): ... class NotEmptyError(ZookeeperError): ... class SessionExpiredError(ZookeeperError): ... class InvalidCallbackError(ZookeeperError): ... class InvalidACLError(ZookeeperError): ... class AuthFailedError(ZookeeperError): ... class SessionMovedError(ZookeeperError): ... class NotReadOnlyCallError(ZookeeperError): ... class ConnectionClosedError(SessionExpiredError): ... ConnectionLossException: Any MarshallingErrorException: Any SystemErrorException: Any RuntimeInconsistencyException: Any DataInconsistencyException: Any UnimplementedException: Any OperationTimeoutException: Any BadArgumentsException: Any ApiErrorException: Any NoNodeException: Any NoAuthException: Any BadVersionException: Any NoChildrenForEphemeralsException: Any NodeExistsException: Any InvalidACLException: Any AuthFailedException: Any NotEmptyException: Any SessionExpiredException: Any InvalidCallbackException: Any ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4343793 jedi-0.19.1/jedi/third_party/typeshed/third_party/2/kazoo/recipe/0000775000175000017500000000000000000000000024555 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2/kazoo/recipe/__init__.pyi0000664000175000017500000000000000000000000027025 0ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2/kazoo/recipe/watchers.pyi0000664000175000017500000000104700000000000027122 0ustar00davedave00000000000000from typing import Any log: Any class DataWatch: def __init__(self, client, path, func=..., *args, **kwargs) -> None: ... def __call__(self, func): ... class ChildrenWatch: def __init__(self, client, path, func=..., allow_session_lost=..., send_event=...) -> None: ... def __call__(self, func): ... class PatientChildrenWatch: client: Any path: Any children: Any time_boundary: Any children_changed: Any def __init__(self, client, path, time_boundary=...) -> None: ... asy: Any def start(self): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2/pathlib2.pyi0000664000175000017500000001027300000000000024416 0ustar00davedave00000000000000import os import sys from _typeshed import OpenBinaryMode, OpenBinaryModeReading, OpenBinaryModeUpdating, OpenBinaryModeWriting, OpenTextMode from io import BufferedRandom, BufferedReader, BufferedWriter, FileIO, TextIOWrapper from types import TracebackType from typing import IO, Any, BinaryIO, Generator, List, Optional, Sequence, Text, TextIO, Tuple, Type, TypeVar, Union, overload from typing_extensions import Literal _P = TypeVar("_P", bound=PurePath) _PurePathBase = object _PathLike = PurePath class PurePath(_PurePathBase): parts: Tuple[str, ...] drive: str root: str anchor: str name: str suffix: str suffixes: List[str] stem: str def __new__(cls: Type[_P], *args: Union[str, _PathLike]) -> _P: ... def __hash__(self) -> int: ... def __lt__(self, other: PurePath) -> bool: ... def __le__(self, other: PurePath) -> bool: ... def __gt__(self, other: PurePath) -> bool: ... def __ge__(self, other: PurePath) -> bool: ... def __truediv__(self: _P, key: Union[str, _PathLike]) -> _P: ... def __rtruediv__(self: _P, key: Union[str, _PathLike]) -> _P: ... def __div__(self: _P, key: Union[str, PurePath]) -> _P: ... def __bytes__(self) -> bytes: ... def as_posix(self) -> str: ... def as_uri(self) -> str: ... def is_absolute(self) -> bool: ... def is_reserved(self) -> bool: ... def match(self, path_pattern: str) -> bool: ... def relative_to(self: _P, *other: Union[str, _PathLike]) -> _P: ... def with_name(self: _P, name: str) -> _P: ... def with_suffix(self: _P, suffix: str) -> _P: ... def joinpath(self: _P, *other: Union[str, _PathLike]) -> _P: ... @property def parents(self: _P) -> Sequence[_P]: ... @property def parent(self: _P) -> _P: ... class PurePosixPath(PurePath): ... class PureWindowsPath(PurePath): ... class Path(PurePath): def __new__(cls: Type[_P], *args: Union[str, _PathLike], **kwargs: Any) -> _P: ... def __enter__(self) -> Path: ... def __exit__( self, exc_type: Optional[Type[BaseException]], exc_value: Optional[BaseException], traceback: Optional[TracebackType] ) -> Optional[bool]: ... @classmethod def cwd(cls: Type[_P]) -> _P: ... def stat(self) -> os.stat_result: ... def chmod(self, mode: int) -> None: ... def exists(self) -> bool: ... def glob(self, pattern: str) -> Generator[Path, None, None]: ... def group(self) -> str: ... def is_dir(self) -> bool: ... def is_file(self) -> bool: ... def is_symlink(self) -> bool: ... def is_socket(self) -> bool: ... def is_fifo(self) -> bool: ... def is_block_device(self) -> bool: ... def is_char_device(self) -> bool: ... def iterdir(self) -> Generator[Path, None, None]: ... def lchmod(self, mode: int) -> None: ... def lstat(self) -> os.stat_result: ... def mkdir(self, mode: int = ..., parents: bool = ...) -> None: ... # Adapted from _io.open def open( self, mode: Text = ..., buffering: int = ..., encoding: Optional[Text] = ..., errors: Optional[Text] = ..., newline: Optional[Text] = ..., ) -> IO[Any]: ... def owner(self) -> str: ... def rename(self, target: Union[str, PurePath]) -> None: ... def replace(self, target: Union[str, PurePath]) -> None: ... def resolve(self: _P) -> _P: ... def rglob(self, pattern: str) -> Generator[Path, None, None]: ... def rmdir(self) -> None: ... def symlink_to(self, target: Union[str, Path], target_is_directory: bool = ...) -> None: ... def touch(self, mode: int = ..., exist_ok: bool = ...) -> None: ... def unlink(self) -> None: ... @classmethod def home(cls: Type[_P]) -> _P: ... def absolute(self: _P) -> _P: ... def expanduser(self: _P) -> _P: ... def read_bytes(self) -> bytes: ... def read_text(self, encoding: Optional[str] = ..., errors: Optional[str] = ...) -> str: ... def samefile(self, other_path: Union[str, bytes, int, Path]) -> bool: ... def write_bytes(self, data: bytes) -> int: ... def write_text(self, data: str, encoding: Optional[str] = ..., errors: Optional[str] = ...) -> int: ... class PosixPath(Path, PurePosixPath): ... class WindowsPath(Path, PureWindowsPath): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2/pymssql.pyi0000664000175000017500000000322500000000000024420 0ustar00davedave00000000000000from datetime import date, datetime, time from typing import Any, Dict, Iterable, List, Optional, Sequence, Tuple, Union Scalar = Union[int, float, str, datetime, date, time] Result = Union[Tuple[Scalar, ...], Dict[str, Scalar]] class Connection(object): def __init__(self, user, password, host, database, timeout, login_timeout, charset, as_dict) -> None: ... def autocommit(self, status: bool) -> None: ... def close(self) -> None: ... def commit(self) -> None: ... def cursor(self) -> Cursor: ... def rollback(self) -> None: ... class Cursor(object): def __init__(self) -> None: ... def __iter__(self): ... def __next__(self) -> Any: ... def callproc(self, procname: str, **kwargs) -> None: ... def close(self) -> None: ... def execute(self, stmt: str, params: Optional[Union[Scalar, Tuple[Scalar, ...], Dict[str, Scalar]]]) -> None: ... def executemany(self, stmt: str, params: Optional[Sequence[Tuple[Scalar, ...]]]) -> None: ... def fetchall(self) -> List[Result]: ... def fetchmany(self, size: Optional[int]) -> List[Result]: ... def fetchone(self) -> Result: ... def connect( server: Optional[str], user: Optional[str], password: Optional[str], database: Optional[str], timeout: Optional[int], login_timeout: Optional[int], charset: Optional[str], as_dict: Optional[bool], host: Optional[str], appname: Optional[str], port: Optional[str], conn_properties: Optional[Union[str, Sequence[str]]], autocommit: Optional[bool], tds_version: Optional[str], ) -> Connection: ... def get_max_connections() -> int: ... def set_max_connections(n: int) -> None: ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4343793 jedi-0.19.1/jedi/third_party/typeshed/third_party/2/routes/0000775000175000017500000000000000000000000023504 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2/routes/__init__.pyi0000664000175000017500000000055400000000000025772 0ustar00davedave00000000000000from . import mapper, util class _RequestConfig: def __getattr__(self, name): ... def __setattr__(self, name, value): ... def __delattr__(self, name): ... def load_wsgi_environ(self, environ): ... def request_config(original=...): ... Mapper = mapper.Mapper redirect_to = util.redirect_to url_for = util.url_for URLGenerator = util.URLGenerator ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2/routes/mapper.pyi0000664000175000017500000000447200000000000025522 0ustar00davedave00000000000000from typing import Any COLLECTION_ACTIONS: Any MEMBER_ACTIONS: Any def strip_slashes(name): ... class SubMapperParent: def submapper(self, **kargs): ... def collection( self, collection_name, resource_name, path_prefix=..., member_prefix=..., controller=..., collection_actions=..., member_actions=..., member_options=..., **kwargs, ): ... class SubMapper(SubMapperParent): kwargs: Any obj: Any collection_name: Any member: Any resource_name: Any formatted: Any def __init__(self, obj, resource_name=..., collection_name=..., actions=..., formatted=..., **kwargs) -> None: ... def connect(self, *args, **kwargs): ... def link(self, rel=..., name=..., action=..., method=..., formatted=..., **kwargs): ... def new(self, **kwargs): ... def edit(self, **kwargs): ... def action(self, name=..., action=..., method=..., formatted=..., **kwargs): ... def index(self, name=..., **kwargs): ... def show(self, name=..., **kwargs): ... def create(self, **kwargs): ... def update(self, **kwargs): ... def delete(self, **kwargs): ... def add_actions(self, actions): ... def __enter__(self): ... def __exit__(self, type, value, tb): ... class Mapper(SubMapperParent): matchlist: Any maxkeys: Any minkeys: Any urlcache: Any prefix: Any req_data: Any directory: Any always_scan: Any controller_scan: Any debug: Any append_slash: Any sub_domains: Any sub_domains_ignore: Any domain_match: Any explicit: Any encoding: Any decode_errors: Any hardcode_names: Any minimization: Any create_regs_lock: Any def __init__(self, controller_scan=..., directory=..., always_scan=..., register=..., explicit=...) -> None: ... environ: Any def extend(self, routes, path_prefix=...): ... def make_route(self, *args, **kargs): ... def connect(self, *args, **kargs): ... def create_regs(self, *args, **kwargs): ... def match(self, url=..., environ=...): ... def routematch(self, url=..., environ=...): ... obj: Any def generate(self, *args, **kargs): ... def resource(self, member_name, collection_name, **kwargs): ... def redirect(self, match_path, destination_path, *args, **kwargs): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2/routes/util.pyi0000664000175000017500000000110000000000000025174 0ustar00davedave00000000000000from typing import Any class RoutesException(Exception): ... class MatchException(RoutesException): ... class GenerationException(RoutesException): ... def url_for(*args, **kargs): ... class URLGenerator: mapper: Any environ: Any def __init__(self, mapper, environ) -> None: ... def __call__(self, *args, **kargs): ... def current(self, *args, **kwargs): ... def redirect_to(*args, **kargs): ... def cache_hostinfo(environ): ... def controller_scan(directory=...): ... def as_unicode(value, encoding, errors=...): ... def ascii_characters(string): ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4383793 jedi-0.19.1/jedi/third_party/typeshed/third_party/2/scribe/0000775000175000017500000000000000000000000023432 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2/scribe/__init__.pyi0000664000175000017500000000000000000000000025702 0ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2/scribe/scribe.pyi0000664000175000017500000000230000000000000025417 0ustar00davedave00000000000000from typing import Any import fb303.FacebookService from thrift.Thrift import TProcessor # type: ignore # We don't have thrift stubs in typeshed from .ttypes import * # noqa: F403 class Iface(fb303.FacebookService.Iface): def Log(self, messages): ... class Client(fb303.FacebookService.Client, Iface): def __init__(self, iprot, oprot=...) -> None: ... def Log(self, messages): ... def send_Log(self, messages): ... def recv_Log(self): ... class Processor(fb303.FacebookService.Processor, Iface, TProcessor): # type: ignore def __init__(self, handler) -> None: ... def process(self, iprot, oprot): ... def process_Log(self, seqid, iprot, oprot): ... class Log_args: thrift_spec: Any messages: Any def __init__(self, messages=...) -> None: ... def read(self, iprot): ... def write(self, oprot): ... def validate(self): ... def __eq__(self, other): ... def __ne__(self, other): ... class Log_result: thrift_spec: Any success: Any def __init__(self, success=...) -> None: ... def read(self, iprot): ... def write(self, oprot): ... def validate(self): ... def __eq__(self, other): ... def __ne__(self, other): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2/scribe/ttypes.pyi0000664000175000017500000000057700000000000025516 0ustar00davedave00000000000000from typing import Any fastbinary: Any class ResultCode: OK: Any TRY_LATER: Any class LogEntry: thrift_spec: Any category: Any message: Any def __init__(self, category=..., message=...) -> None: ... def read(self, iprot): ... def write(self, oprot): ... def validate(self): ... def __eq__(self, other): ... def __ne__(self, other): ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4383793 jedi-0.19.1/jedi/third_party/typeshed/third_party/2/six/0000775000175000017500000000000000000000000022766 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2/six/__init__.pyi0000664000175000017500000001044600000000000025255 0ustar00davedave00000000000000from __future__ import print_function import types import typing import unittest from __builtin__ import unichr as unichr from functools import wraps as wraps from StringIO import StringIO as StringIO from typing import ( Any, AnyStr, Callable, Dict, ItemsView, Iterable, KeysView, Mapping, NoReturn, Optional, Pattern, Text, Tuple, Type, TypeVar, Union, ValuesView, overload, ) from . import moves BytesIO = StringIO _T = TypeVar("_T") _K = TypeVar("_K") _V = TypeVar("_V") __version__: str # TODO make constant, then move this stub to 2and3 # https://github.com/python/typeshed/issues/17 PY2 = True PY3 = False PY34 = False string_types = (str, unicode) integer_types = (int, long) class_types = (type, types.ClassType) text_type = unicode binary_type = str MAXSIZE: int def advance_iterator(it: typing.Iterator[_T]) -> _T: ... next = advance_iterator def callable(obj: object) -> bool: ... def get_unbound_function(unbound: types.MethodType) -> types.FunctionType: ... def create_bound_method(func: types.FunctionType, obj: object) -> types.MethodType: ... def create_unbound_method(func: types.FunctionType, cls: Union[type, types.ClassType]) -> types.MethodType: ... class Iterator: def next(self) -> Any: ... def get_method_function(meth: types.MethodType) -> types.FunctionType: ... def get_method_self(meth: types.MethodType) -> Optional[object]: ... def get_function_closure(fun: types.FunctionType) -> Optional[Tuple[types._Cell, ...]]: ... def get_function_code(fun: types.FunctionType) -> types.CodeType: ... def get_function_defaults(fun: types.FunctionType) -> Optional[Tuple[Any, ...]]: ... def get_function_globals(fun: types.FunctionType) -> Dict[str, Any]: ... def iterkeys(d: Mapping[_K, _V]) -> typing.Iterator[_K]: ... def itervalues(d: Mapping[_K, _V]) -> typing.Iterator[_V]: ... def iteritems(d: Mapping[_K, _V]) -> typing.Iterator[Tuple[_K, _V]]: ... # def iterlists def viewkeys(d: Mapping[_K, _V]) -> KeysView[_K]: ... def viewvalues(d: Mapping[_K, _V]) -> ValuesView[_V]: ... def viewitems(d: Mapping[_K, _V]) -> ItemsView[_K, _V]: ... def b(s: str) -> binary_type: ... def u(s: str) -> text_type: ... int2byte = chr def byte2int(bs: binary_type) -> int: ... def indexbytes(buf: binary_type, i: int) -> int: ... def iterbytes(buf: binary_type) -> typing.Iterator[int]: ... def assertCountEqual(self: unittest.TestCase, first: Iterable[_T], second: Iterable[_T], msg: str = ...) -> None: ... @overload def assertRaisesRegex(self: unittest.TestCase, msg: str = ...) -> Any: ... @overload def assertRaisesRegex(self: unittest.TestCase, callable_obj: Callable[..., Any], *args: Any, **kwargs: Any) -> Any: ... def assertRegex( self: unittest.TestCase, text: AnyStr, expected_regex: Union[AnyStr, Pattern[AnyStr]], msg: str = ... ) -> None: ... def reraise( tp: Optional[Type[BaseException]], value: Optional[BaseException], tb: Optional[types.TracebackType] = ... ) -> NoReturn: ... def exec_(_code_: Union[unicode, types.CodeType], _globs_: Dict[str, Any] = ..., _locs_: Dict[str, Any] = ...): ... def raise_from(value: Union[BaseException, Type[BaseException]], from_value: Optional[BaseException]) -> NoReturn: ... print_ = print def with_metaclass(meta: type, *bases: type) -> type: ... def add_metaclass(metaclass: type) -> Callable[[_T], _T]: ... def ensure_binary(s: Union[bytes, Text], encoding: str = ..., errors: str = ...) -> bytes: ... def ensure_str(s: Union[bytes, Text], encoding: str = ..., errors: str = ...) -> str: ... def ensure_text(s: Union[bytes, Text], encoding: str = ..., errors: str = ...) -> Text: ... def python_2_unicode_compatible(klass: _T) -> _T: ... class _LazyDescriptor: name: str def __init__(self, name: str) -> None: ... def __get__(self, obj: Optional[object], type: Optional[type] = ...) -> Any: ... class MovedModule(_LazyDescriptor): mod: str def __init__(self, name: str, old: str, new: Optional[str] = ...) -> None: ... def __getattr__(self, attr: str) -> Any: ... class MovedAttribute(_LazyDescriptor): mod: str attr: str def __init__( self, name: str, old_mod: str, new_mod: str, old_attr: Optional[str] = ..., new_attr: Optional[str] = ... ) -> None: ... def add_move(move: Union[MovedModule, MovedAttribute]) -> None: ... def remove_move(name: str) -> None: ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4383793 jedi-0.19.1/jedi/third_party/typeshed/third_party/2/six/moves/0000775000175000017500000000000000000000000024117 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2/six/moves/BaseHTTPServer.pyi0000664000175000017500000000003500000000000027401 0ustar00davedave00000000000000from BaseHTTPServer import * ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2/six/moves/CGIHTTPServer.pyi0000664000175000017500000000003400000000000027130 0ustar00davedave00000000000000from CGIHTTPServer import * ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2/six/moves/SimpleHTTPServer.pyi0000664000175000017500000000003700000000000027762 0ustar00davedave00000000000000from SimpleHTTPServer import * ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2/six/moves/__init__.pyi0000664000175000017500000000407100000000000026403 0ustar00davedave00000000000000# Stubs for six.moves # # Note: Commented out items means they weren't implemented at the time. # Uncomment them when the modules have been added to the typeshed. import __builtin__ import itertools import os import pipes from __builtin__ import intern as intern, reduce as reduce, xrange as xrange from cStringIO import StringIO as _cStringIO from StringIO import StringIO as StringIO from UserDict import UserDict as UserDict from UserList import UserList as UserList from UserString import UserString as UserString # import Tkinter as tkinter # import Dialog as tkinter_dialog # import FileDialog as tkinter_filedialog # import ScrolledText as tkinter_scrolledtext # import SimpleDialog as tkinter_simpledialog # import Tix as tkinter_tix # import ttk as tkinter_ttk # import Tkconstants as tkinter_constants # import Tkdnd as tkinter_dnd # import tkColorChooser as tkinter_colorchooser # import tkCommonDialog as tkinter_commondialog # import tkFileDialog as tkinter_tkfiledialog # import tkFont as tkinter_font # import tkMessageBox as tkinter_messagebox # import tkSimpleDialog as tkinter_tksimpledialog # import email.MIMEBase as email_mime_base # import email.MIMEMultipart as email_mime_multipart # import email.MIMENonMultipart as email_mime_nonmultipart # import copy_reg as copyreg # import gdbm as dbm_gnu from . import ( BaseHTTPServer, CGIHTTPServer, SimpleHTTPServer, _dummy_thread, _thread, configparser, cPickle, email_mime_text, html_entities, html_parser, http_client, http_cookiejar, http_cookies, queue, reprlib, socketserver, urllib, urllib_error, urllib_parse, urllib_robotparser, xmlrpc_client, ) # import SimpleXMLRPCServer as xmlrpc_server builtins = __builtin__ input = __builtin__.raw_input reload_module = __builtin__.reload range = __builtin__.xrange cStringIO = _cStringIO filter = itertools.ifilter filterfalse = itertools.ifilterfalse map = itertools.imap zip = itertools.izip zip_longest = itertools.izip_longest getcwdb = os.getcwd getcwd = os.getcwdu shlex_quote = pipes.quote ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2/six/moves/_dummy_thread.pyi0000664000175000017500000000003300000000000027457 0ustar00davedave00000000000000from dummy_thread import * ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2/six/moves/_thread.pyi0000664000175000017500000000002500000000000026245 0ustar00davedave00000000000000from thread import * ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2/six/moves/cPickle.pyi0000664000175000017500000000002600000000000026212 0ustar00davedave00000000000000from cPickle import * ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2/six/moves/collections_abc.pyi0000664000175000017500000000003200000000000027760 0ustar00davedave00000000000000from collections import * ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2/six/moves/configparser.pyi0000664000175000017500000000003300000000000027320 0ustar00davedave00000000000000from ConfigParser import * ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2/six/moves/email_mime_base.pyi0000664000175000017500000000003600000000000027731 0ustar00davedave00000000000000from email.mime.base import * ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2/six/moves/email_mime_multipart.pyi0000664000175000017500000000004300000000000031036 0ustar00davedave00000000000000from email.mime.multipart import * ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2/six/moves/email_mime_nonmultipart.pyi0000664000175000017500000000004600000000000031554 0ustar00davedave00000000000000from email.mime.nonmultipart import * ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2/six/moves/email_mime_text.pyi0000664000175000017500000000003500000000000030002 0ustar00davedave00000000000000from email.MIMEText import * ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2/six/moves/html_entities.pyi0000664000175000017500000000003500000000000027510 0ustar00davedave00000000000000from htmlentitydefs import * ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2/six/moves/html_parser.pyi0000664000175000017500000000003100000000000027154 0ustar00davedave00000000000000from HTMLParser import * ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2/six/moves/http_client.pyi0000664000175000017500000000002600000000000027155 0ustar00davedave00000000000000from httplib import * ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2/six/moves/http_cookiejar.pyi0000664000175000017500000000003000000000000027640 0ustar00davedave00000000000000from cookielib import * ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2/six/moves/http_cookies.pyi0000664000175000017500000000002500000000000027332 0ustar00davedave00000000000000from Cookie import * ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2/six/moves/queue.pyi0000664000175000017500000000002400000000000025762 0ustar00davedave00000000000000from Queue import * ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2/six/moves/reprlib.pyi0000664000175000017500000000002300000000000026274 0ustar00davedave00000000000000from repr import * ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2/six/moves/socketserver.pyi0000664000175000017500000000003300000000000027355 0ustar00davedave00000000000000from SocketServer import * ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4383793 jedi-0.19.1/jedi/third_party/typeshed/third_party/2/six/moves/urllib/0000775000175000017500000000000000000000000025410 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2/six/moves/urllib/__init__.pyi0000664000175000017500000000033100000000000027667 0ustar00davedave00000000000000import six.moves.urllib.error as error import six.moves.urllib.parse as parse import six.moves.urllib.request as request import six.moves.urllib.response as response import six.moves.urllib.robotparser as robotparser ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2/six/moves/urllib/error.pyi0000664000175000017500000000020100000000000027255 0ustar00davedave00000000000000from urllib import ContentTooShortError as ContentTooShortError from urllib2 import HTTPError as HTTPError, URLError as URLError ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2/six/moves/urllib/parse.pyi0000664000175000017500000000135000000000000027244 0ustar00davedave00000000000000from urllib import ( quote as quote, quote_plus as quote_plus, splitquery as splitquery, splittag as splittag, splituser as splituser, unquote as unquote, unquote_plus as unquote_plus, urlencode as urlencode, ) from urlparse import ( ParseResult as ParseResult, SplitResult as SplitResult, parse_qs as parse_qs, parse_qsl as parse_qsl, urldefrag as urldefrag, urljoin as urljoin, urlparse as urlparse, urlsplit as urlsplit, urlunparse as urlunparse, urlunsplit as urlunsplit, uses_fragment as uses_fragment, uses_netloc as uses_netloc, uses_params as uses_params, uses_query as uses_query, uses_relative as uses_relative, ) unquote_to_bytes = unquote ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2/six/moves/urllib/request.pyi0000664000175000017500000000265500000000000027633 0ustar00davedave00000000000000from urllib import ( FancyURLopener as FancyURLopener, URLopener as URLopener, getproxies as getproxies, pathname2url as pathname2url, proxy_bypass as proxy_bypass, url2pathname as url2pathname, urlcleanup as urlcleanup, urlretrieve as urlretrieve, ) from urllib2 import ( AbstractBasicAuthHandler as AbstractBasicAuthHandler, AbstractDigestAuthHandler as AbstractDigestAuthHandler, BaseHandler as BaseHandler, CacheFTPHandler as CacheFTPHandler, FileHandler as FileHandler, FTPHandler as FTPHandler, HTTPBasicAuthHandler as HTTPBasicAuthHandler, HTTPCookieProcessor as HTTPCookieProcessor, HTTPDefaultErrorHandler as HTTPDefaultErrorHandler, HTTPDigestAuthHandler as HTTPDigestAuthHandler, HTTPErrorProcessor as HTTPErrorProcessor, HTTPHandler as HTTPHandler, HTTPPasswordMgr as HTTPPasswordMgr, HTTPPasswordMgrWithDefaultRealm as HTTPPasswordMgrWithDefaultRealm, HTTPRedirectHandler as HTTPRedirectHandler, HTTPSHandler as HTTPSHandler, OpenerDirector as OpenerDirector, ProxyBasicAuthHandler as ProxyBasicAuthHandler, ProxyDigestAuthHandler as ProxyDigestAuthHandler, ProxyHandler as ProxyHandler, Request as Request, UnknownHandler as UnknownHandler, build_opener as build_opener, install_opener as install_opener, parse_http_list as parse_http_list, parse_keqv_list as parse_keqv_list, urlopen as urlopen, ) ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2/six/moves/urllib/response.pyi0000664000175000017500000000016200000000000027770 0ustar00davedave00000000000000from urllib import addbase as addbase, addclosehook as addclosehook, addinfo as addinfo, addinfourl as addinfourl ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2/six/moves/urllib/robotparser.pyi0000664000175000017500000000007300000000000030475 0ustar00davedave00000000000000from robotparser import RobotFileParser as RobotFileParser ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2/six/moves/urllib_error.pyi0000664000175000017500000000003400000000000027341 0ustar00davedave00000000000000from .urllib.error import * ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2/six/moves/urllib_parse.pyi0000664000175000017500000000003400000000000027322 0ustar00davedave00000000000000from .urllib.parse import * ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2/six/moves/urllib_request.pyi0000664000175000017500000000003600000000000027702 0ustar00davedave00000000000000from .urllib.request import * ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2/six/moves/urllib_response.pyi0000664000175000017500000000003700000000000030051 0ustar00davedave00000000000000from .urllib.response import * ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2/six/moves/urllib_robotparser.pyi0000664000175000017500000000003200000000000030550 0ustar00davedave00000000000000from robotparser import * ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2/six/moves/xmlrpc_client.pyi0000664000175000017500000000003000000000000027476 0ustar00davedave00000000000000from xmlrpclib import * ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4383793 jedi-0.19.1/jedi/third_party/typeshed/third_party/2/tornado/0000775000175000017500000000000000000000000023631 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2/tornado/__init__.pyi0000664000175000017500000000000000000000000026101 0ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2/tornado/concurrent.pyi0000664000175000017500000000177000000000000026543 0ustar00davedave00000000000000from typing import Any futures: Any class ReturnValueIgnoredError(Exception): ... class _TracebackLogger: exc_info: Any formatted_tb: Any def __init__(self, exc_info) -> None: ... def activate(self): ... def clear(self): ... def __del__(self): ... class Future: def __init__(self) -> None: ... def cancel(self): ... def cancelled(self): ... def running(self): ... def done(self): ... def result(self, timeout=...): ... def exception(self, timeout=...): ... def add_done_callback(self, fn): ... def set_result(self, result): ... def set_exception(self, exception): ... def exc_info(self): ... def set_exc_info(self, exc_info): ... def __del__(self): ... TracebackFuture: Any FUTURES: Any def is_future(x): ... class DummyExecutor: def submit(self, fn, *args, **kwargs): ... def shutdown(self, wait=...): ... dummy_executor: Any def run_on_executor(*args, **kwargs): ... def return_future(f): ... def chain_future(a, b): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2/tornado/gen.pyi0000664000175000017500000000534100000000000025130 0ustar00davedave00000000000000from typing import Any, Dict, NamedTuple, Tuple singledispatch: Any class KeyReuseError(Exception): ... class UnknownKeyError(Exception): ... class LeakedCallbackError(Exception): ... class BadYieldError(Exception): ... class ReturnValueIgnoredError(Exception): ... class TimeoutError(Exception): ... def engine(func): ... def coroutine(func, replace_callback=...): ... class Return(Exception): value: Any def __init__(self, value=...) -> None: ... class WaitIterator: current_index: Any def __init__(self, *args, **kwargs) -> None: ... def done(self): ... def next(self): ... class YieldPoint: def start(self, runner): ... def is_ready(self): ... def get_result(self): ... class Callback(YieldPoint): key: Any def __init__(self, key) -> None: ... runner: Any def start(self, runner): ... def is_ready(self): ... def get_result(self): ... class Wait(YieldPoint): key: Any def __init__(self, key) -> None: ... runner: Any def start(self, runner): ... def is_ready(self): ... def get_result(self): ... class WaitAll(YieldPoint): keys: Any def __init__(self, keys) -> None: ... runner: Any def start(self, runner): ... def is_ready(self): ... def get_result(self): ... def Task(func, *args, **kwargs): ... class YieldFuture(YieldPoint): future: Any io_loop: Any def __init__(self, future, io_loop=...) -> None: ... runner: Any key: Any result_fn: Any def start(self, runner): ... def is_ready(self): ... def get_result(self): ... class Multi(YieldPoint): keys: Any children: Any unfinished_children: Any quiet_exceptions: Any def __init__(self, children, quiet_exceptions=...) -> None: ... def start(self, runner): ... def is_ready(self): ... def get_result(self): ... def multi_future(children, quiet_exceptions=...): ... def maybe_future(x): ... def with_timeout(timeout, future, io_loop=..., quiet_exceptions=...): ... def sleep(duration): ... moment: Any class Runner: gen: Any result_future: Any future: Any yield_point: Any pending_callbacks: Any results: Any running: Any finished: Any had_exception: Any io_loop: Any stack_context_deactivate: Any def __init__(self, gen, result_future, first_yielded) -> None: ... def register_callback(self, key): ... def is_ready(self, key): ... def set_result(self, key, result): ... def pop_result(self, key): ... def run(self): ... def handle_yield(self, yielded): ... def result_callback(self, key): ... def handle_exception(self, typ, value, tb): ... class Arguments(NamedTuple): args: Tuple[str, ...] kwargs: Dict[str, Any] def convert_yielded(yielded): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2/tornado/httpclient.pyi0000664000175000017500000000622300000000000026535 0ustar00davedave00000000000000from typing import Any from tornado.util import Configurable class HTTPClient: def __init__(self, async_client_class=..., **kwargs) -> None: ... def __del__(self): ... def close(self): ... def fetch(self, request, **kwargs): ... class AsyncHTTPClient(Configurable): @classmethod def configurable_base(cls): ... @classmethod def configurable_default(cls): ... def __new__(cls, io_loop=..., force_instance=..., **kwargs): ... io_loop: Any defaults: Any def initialize(self, io_loop, defaults=...): ... def close(self): ... def fetch(self, request, callback=..., raise_error=..., **kwargs): ... def fetch_impl(self, request, callback): ... @classmethod def configure(cls, impl, **kwargs): ... class HTTPRequest: proxy_host: Any proxy_port: Any proxy_username: Any proxy_password: Any url: Any method: Any body_producer: Any auth_username: Any auth_password: Any auth_mode: Any connect_timeout: Any request_timeout: Any follow_redirects: Any max_redirects: Any user_agent: Any decompress_response: Any network_interface: Any streaming_callback: Any header_callback: Any prepare_curl_callback: Any allow_nonstandard_methods: Any validate_cert: Any ca_certs: Any allow_ipv6: Any client_key: Any client_cert: Any ssl_options: Any expect_100_continue: Any start_time: Any def __init__( self, url, method=..., headers=..., body=..., auth_username=..., auth_password=..., auth_mode=..., connect_timeout=..., request_timeout=..., if_modified_since=..., follow_redirects=..., max_redirects=..., user_agent=..., use_gzip=..., network_interface=..., streaming_callback=..., header_callback=..., prepare_curl_callback=..., proxy_host=..., proxy_port=..., proxy_username=..., proxy_password=..., allow_nonstandard_methods=..., validate_cert=..., ca_certs=..., allow_ipv6=..., client_key=..., client_cert=..., body_producer=..., expect_100_continue=..., decompress_response=..., ssl_options=..., ) -> None: ... @property def headers(self): ... @headers.setter def headers(self, value): ... @property def body(self): ... @body.setter def body(self, value): ... class HTTPResponse: request: Any code: Any reason: Any headers: Any buffer: Any effective_url: Any error: Any request_time: Any time_info: Any def __init__( self, request, code, headers=..., buffer=..., effective_url=..., error=..., request_time=..., time_info=..., reason=... ) -> None: ... body: bytes def rethrow(self): ... class HTTPError(Exception): code: Any response: Any def __init__(self, code, message=..., response=...) -> None: ... class _RequestProxy: request: Any defaults: Any def __init__(self, request, defaults) -> None: ... def __getattr__(self, name): ... def main(): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2/tornado/httpserver.pyi0000664000175000017500000000312100000000000026557 0ustar00davedave00000000000000from typing import Any from tornado import httputil from tornado.tcpserver import TCPServer from tornado.util import Configurable class HTTPServer(TCPServer, Configurable, httputil.HTTPServerConnectionDelegate): def __init__(self, *args, **kwargs) -> None: ... request_callback: Any no_keep_alive: Any xheaders: Any protocol: Any conn_params: Any def initialize( self, request_callback, no_keep_alive=..., io_loop=..., xheaders=..., ssl_options=..., protocol=..., decompress_request=..., chunk_size=..., max_header_size=..., idle_connection_timeout=..., body_timeout=..., max_body_size=..., max_buffer_size=..., ): ... @classmethod def configurable_base(cls): ... @classmethod def configurable_default(cls): ... def close_all_connections(self): ... def handle_stream(self, stream, address): ... def start_request(self, server_conn, request_conn): ... def on_close(self, server_conn): ... class _HTTPRequestContext: address: Any protocol: Any address_family: Any remote_ip: Any def __init__(self, stream, address, protocol) -> None: ... class _ServerRequestAdapter(httputil.HTTPMessageDelegate): server: Any connection: Any request: Any delegate: Any def __init__(self, server, server_conn, request_conn) -> None: ... def headers_received(self, start_line, headers): ... def data_received(self, chunk): ... def finish(self): ... def on_connection_close(self): ... HTTPRequest: Any ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2/tornado/httputil.pyi0000664000175000017500000000544500000000000026241 0ustar00davedave00000000000000from typing import Any, Dict, List, NamedTuple, Optional from tornado.util import ObjectDict class SSLError(Exception): ... class _NormalizedHeaderCache(Dict[Any, Any]): size: Any queue: Any def __init__(self, size) -> None: ... def __missing__(self, key): ... class HTTPHeaders(Dict[Any, Any]): def __init__(self, *args, **kwargs) -> None: ... def add(self, name, value): ... def get_list(self, name): ... def get_all(self): ... def parse_line(self, line): ... @classmethod def parse(cls, headers): ... def __setitem__(self, name, value): ... def __getitem__(self, name): ... def __delitem__(self, name): ... def __contains__(self, name): ... def get(self, name, default=...): ... def update(self, *args, **kwargs): ... def copy(self): ... __copy__: Any def __deepcopy__(self, memo_dict): ... class HTTPServerRequest: path: str query: str method: Optional[str] uri: Optional[str] version: str headers: HTTPHeaders body: bytes remote_ip: Any protocol: Any host: str files: Dict[str, List[HTTPFile]] connection: Optional[HTTPConnection] arguments: Dict[str, List[bytes]] query_arguments: Dict[str, List[bytes]] body_arguments: Dict[str, List[bytes]] def __init__( self, method=..., uri=..., version=..., headers=..., body=..., host=..., files=..., connection=..., start_line=... ) -> None: ... def supports_http_1_1(self): ... @property def cookies(self): ... def write(self, chunk, callback=...): ... def finish(self): ... def full_url(self): ... def request_time(self): ... def get_ssl_certificate(self, binary_form=...): ... class HTTPInputError(Exception): ... class HTTPOutputError(Exception): ... class HTTPServerConnectionDelegate: def start_request(self, server_conn, request_conn): ... def on_close(self, server_conn): ... class HTTPMessageDelegate: def headers_received(self, start_line, headers): ... def data_received(self, chunk): ... def finish(self): ... def on_connection_close(self): ... class HTTPConnection: def write_headers(self, start_line, headers, chunk=..., callback=...): ... def write(self, chunk, callback=...): ... def finish(self): ... def url_concat(url, args): ... class HTTPFile(ObjectDict): ... def parse_body_arguments(content_type, body, arguments, files, headers=...): ... def parse_multipart_form_data(boundary, data, arguments, files): ... def format_timestamp(ts): ... class RequestStartLine(NamedTuple): method: str path: str version: str def parse_request_start_line(line): ... class ResponseStartLine(NamedTuple): version: str code: str reason: str def parse_response_start_line(line): ... def doctests(): ... def split_host_and_port(netloc): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2/tornado/ioloop.pyi0000664000175000017500000000535600000000000025666 0ustar00davedave00000000000000from typing import Any from tornado.util import Configurable signal: Any class TimeoutError(Exception): ... class IOLoop(Configurable): NONE: Any READ: Any WRITE: Any ERROR: Any @staticmethod def instance(): ... @staticmethod def initialized(): ... def install(self): ... @staticmethod def clear_instance(): ... @staticmethod def current(instance=...): ... def make_current(self): ... @staticmethod def clear_current(): ... @classmethod def configurable_base(cls): ... @classmethod def configurable_default(cls): ... def initialize(self, make_current=...): ... def close(self, all_fds=...): ... def add_handler(self, fd, handler, events): ... def update_handler(self, fd, events): ... def remove_handler(self, fd): ... def set_blocking_signal_threshold(self, seconds, action): ... def set_blocking_log_threshold(self, seconds): ... def log_stack(self, signal, frame): ... def start(self): ... def stop(self): ... def run_sync(self, func, timeout=...): ... def time(self): ... def add_timeout(self, deadline, callback, *args, **kwargs): ... def call_later(self, delay, callback, *args, **kwargs): ... def call_at(self, when, callback, *args, **kwargs): ... def remove_timeout(self, timeout): ... def add_callback(self, callback, *args, **kwargs): ... def add_callback_from_signal(self, callback, *args, **kwargs): ... def spawn_callback(self, callback, *args, **kwargs): ... def add_future(self, future, callback): ... def handle_callback_exception(self, callback): ... def split_fd(self, fd): ... def close_fd(self, fd): ... class PollIOLoop(IOLoop): time_func: Any def initialize(self, impl, time_func=..., **kwargs): ... def close(self, all_fds=...): ... def add_handler(self, fd, handler, events): ... def update_handler(self, fd, events): ... def remove_handler(self, fd): ... def set_blocking_signal_threshold(self, seconds, action): ... def start(self): ... def stop(self): ... def time(self): ... def call_at(self, deadline, callback, *args, **kwargs): ... def remove_timeout(self, timeout): ... def add_callback(self, callback, *args, **kwargs): ... def add_callback_from_signal(self, callback, *args, **kwargs): ... class _Timeout: deadline: Any callback: Any tiebreaker: Any def __init__(self, deadline, callback, io_loop) -> None: ... def __lt__(self, other): ... def __le__(self, other): ... class PeriodicCallback: callback: Any callback_time: Any io_loop: Any def __init__(self, callback, callback_time, io_loop=...) -> None: ... def start(self): ... def stop(self): ... def is_running(self): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2/tornado/locks.pyi0000664000175000017500000000237700000000000025500 0ustar00davedave00000000000000from typing import Any, Optional class _TimeoutGarbageCollector: def __init__(self): ... class Condition(_TimeoutGarbageCollector): io_loop: Any def __init__(self): ... def wait(self, timeout: Optional[Any] = ...): ... def notify(self, n: int = ...): ... def notify_all(self): ... class Event: def __init__(self): ... def is_set(self): ... def set(self): ... def clear(self): ... def wait(self, timeout: Optional[Any] = ...): ... class _ReleasingContextManager: def __init__(self, obj): ... def __enter__(self): ... def __exit__(self, exc_type, exc_val, exc_tb): ... class Semaphore(_TimeoutGarbageCollector): def __init__(self, value: int = ...): ... def release(self): ... def acquire(self, timeout: Optional[Any] = ...): ... def __enter__(self): ... __exit__: Any def __aenter__(self): ... def __aexit__(self, typ, value, tb): ... class BoundedSemaphore(Semaphore): def __init__(self, value: int = ...): ... def release(self): ... class Lock: def __init__(self): ... def acquire(self, timeout: Optional[Any] = ...): ... def release(self): ... def __enter__(self): ... __exit__: Any def __aenter__(self): ... def __aexit__(self, typ, value, tb): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2/tornado/netutil.pyi0000664000175000017500000000250600000000000026043 0ustar00davedave00000000000000from typing import Any from tornado.util import Configurable ssl: Any certifi: Any xrange: Any ssl_match_hostname: Any SSLCertificateError: Any def bind_sockets(port, address=..., family=..., backlog=..., flags=...): ... def bind_unix_socket(file, mode=..., backlog=...): ... def add_accept_handler(sock, callback, io_loop=...): ... def is_valid_ip(ip): ... class Resolver(Configurable): @classmethod def configurable_base(cls): ... @classmethod def configurable_default(cls): ... def resolve(self, host, port, family=..., callback=...): ... def close(self): ... class ExecutorResolver(Resolver): io_loop: Any executor: Any close_executor: Any def initialize(self, io_loop=..., executor=..., close_executor=...): ... def close(self): ... def resolve(self, host, port, family=...): ... class BlockingResolver(ExecutorResolver): def initialize(self, io_loop=...): ... class ThreadedResolver(ExecutorResolver): def initialize(self, io_loop=..., num_threads=...): ... class OverrideResolver(Resolver): resolver: Any mapping: Any def initialize(self, resolver, mapping): ... def close(self): ... def resolve(self, host, port, *args, **kwargs): ... def ssl_options_to_context(ssl_options): ... def ssl_wrap_socket(socket, ssl_options, server_hostname=..., **kwargs): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2/tornado/process.pyi0000664000175000017500000000122600000000000026033 0ustar00davedave00000000000000from typing import Any, Optional long = int CalledProcessError: Any def cpu_count() -> int: ... def fork_processes(num_processes, max_restarts: int = ...) -> Optional[int]: ... def task_id() -> int: ... class Subprocess: STREAM: Any = ... io_loop: Any = ... stdin: Any = ... stdout: Any = ... stderr: Any = ... proc: Any = ... returncode: Any = ... def __init__(self, *args, **kwargs) -> None: ... def set_exit_callback(self, callback): ... def wait_for_exit(self, raise_error: bool = ...): ... @classmethod def initialize(cls, io_loop: Optional[Any] = ...): ... @classmethod def uninitialize(cls): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2/tornado/tcpserver.pyi0000664000175000017500000000105400000000000026371 0ustar00davedave00000000000000from typing import Any ssl: Any class TCPServer: io_loop: Any ssl_options: Any max_buffer_size: Any read_chunk_size: Any def __init__(self, io_loop=..., ssl_options=..., max_buffer_size=..., read_chunk_size=...) -> None: ... def listen(self, port, address=...): ... def add_sockets(self, sockets): ... def add_socket(self, socket): ... def bind(self, port, address=..., family=..., backlog=...): ... def start(self, num_processes=...): ... def stop(self): ... def handle_stream(self, stream, address): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2/tornado/testing.pyi0000664000175000017500000000351100000000000026031 0ustar00davedave00000000000000import logging import unittest from typing import Any, Callable, Generator, Optional, overload AsyncHTTPClient: Any gen: Any HTTPServer: Any IOLoop: Any netutil: Any SimpleAsyncHTTPClient: Any def get_unused_port(): ... def bind_unused_port(): ... class AsyncTestCase(unittest.TestCase): def __init__(self, *args, **kwargs): ... io_loop: Any def setUp(self): ... def tearDown(self): ... def get_new_ioloop(self): ... def run(self, result: Optional[Any] = ...): ... def stop(self, _arg: Optional[Any] = ..., **kwargs): ... def wait(self, condition: Optional[Any] = ..., timeout: float = ...): ... class AsyncHTTPTestCase(AsyncTestCase): http_client: Any http_server: Any def setUp(self): ... def get_http_client(self): ... def get_http_server(self): ... def get_app(self): ... def fetch(self, path, **kwargs): ... def get_httpserver_options(self): ... def get_http_port(self): ... def get_protocol(self): ... def get_url(self, path): ... def tearDown(self): ... class AsyncHTTPSTestCase(AsyncHTTPTestCase): def get_http_client(self): ... def get_httpserver_options(self): ... def get_ssl_options(self): ... def get_protocol(self): ... @overload def gen_test(*, timeout: Optional[float] = ...) -> Callable[[Callable[..., Generator[Any, Any, Any]]], Callable[..., None]]: ... @overload def gen_test(func: Callable[..., Generator[Any, Any, Any]]) -> Callable[..., None]: ... class LogTrapTestCase(unittest.TestCase): def run(self, result: Optional[Any] = ...): ... class ExpectLog(logging.Filter): logger: Any regex: Any required: Any matched: Any def __init__(self, logger, regex, required: bool = ...): ... def filter(self, record): ... def __enter__(self): ... def __exit__(self, typ, value, tb): ... def main(**kwargs): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2/tornado/util.pyi0000664000175000017500000000206000000000000025327 0ustar00davedave00000000000000from typing import Any, Dict xrange: Any class ObjectDict(Dict[Any, Any]): def __getattr__(self, name): ... def __setattr__(self, name, value): ... class GzipDecompressor: decompressobj: Any def __init__(self) -> None: ... def decompress(self, value, max_length=...): ... @property def unconsumed_tail(self): ... def flush(self): ... unicode_type: Any basestring_type: Any def import_object(name): ... bytes_type: Any def errno_from_exception(e): ... class Configurable: def __new__(cls, *args, **kwargs): ... @classmethod def configurable_base(cls): ... @classmethod def configurable_default(cls): ... def initialize(self): ... @classmethod def configure(cls, impl, **kwargs): ... @classmethod def configured_class(cls): ... class ArgReplacer: name: Any arg_pos: Any def __init__(self, func, name) -> None: ... def get_old_value(self, args, kwargs, default=...): ... def replace(self, new_value, args, kwargs): ... def timedelta_to_seconds(td): ... def doctests(): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2/tornado/web.pyi0000664000175000017500000002122000000000000025126 0ustar00davedave00000000000000import sys from typing import Any, Callable, Dict, List, Optional from tornado import httputil MIN_SUPPORTED_SIGNED_VALUE_VERSION: Any MAX_SUPPORTED_SIGNED_VALUE_VERSION: Any DEFAULT_SIGNED_VALUE_VERSION: Any DEFAULT_SIGNED_VALUE_MIN_VERSION: Any if sys.version_info >= (3, 5): from typing import Awaitable _MethodType = Callable[..., Optional[Awaitable[None]]] else: _MethodType = Callable[..., Any] class RequestHandler: SUPPORTED_METHODS: Any application: Application request: httputil.HTTPServerRequest path_args: List[str] path_kwargs: Dict[str, str] ui: Any def __init__(self, application, request, **kwargs) -> None: ... initialize: Callable[..., None] = ... @property def settings(self): ... head: _MethodType get: _MethodType post: _MethodType delete: _MethodType patch: _MethodType put: _MethodType options: _MethodType def prepare(self): ... def on_finish(self): ... def on_connection_close(self): ... def clear(self): ... def set_default_headers(self): ... def set_status(self, status_code, reason=...): ... def get_status(self): ... def set_header(self, name, value): ... def add_header(self, name, value): ... def clear_header(self, name): ... def get_argument(self, name, default=..., strip=...): ... def get_arguments(self, name, strip=...): ... def get_body_argument(self, name, default=..., strip=...): ... def get_body_arguments(self, name, strip=...): ... def get_query_argument(self, name, default=..., strip=...): ... def get_query_arguments(self, name, strip=...): ... def decode_argument(self, value, name=...): ... @property def cookies(self): ... def get_cookie(self, name, default=...): ... def set_cookie(self, name, value, domain=..., expires=..., path=..., expires_days=..., **kwargs): ... def clear_cookie(self, name, path=..., domain=...): ... def clear_all_cookies(self, path=..., domain=...): ... def set_secure_cookie(self, name, value, expires_days=..., version=..., **kwargs): ... def create_signed_value(self, name, value, version=...): ... def get_secure_cookie(self, name, value=..., max_age_days=..., min_version=...): ... def get_secure_cookie_key_version(self, name, value=...): ... def redirect(self, url, permanent=..., status=...): ... def write(self, chunk): ... def render(self, template_name, **kwargs): ... def render_string(self, template_name, **kwargs): ... def get_template_namespace(self): ... def create_template_loader(self, template_path): ... def flush(self, include_footers=..., callback=...): ... def finish(self, chunk=...): ... def send_error(self, status_code=..., **kwargs): ... def write_error(self, status_code, **kwargs): ... @property def locale(self): ... @locale.setter def locale(self, value): ... def get_user_locale(self): ... def get_browser_locale(self, default=...): ... @property def current_user(self): ... @current_user.setter def current_user(self, value): ... def get_current_user(self): ... def get_login_url(self): ... def get_template_path(self): ... @property def xsrf_token(self): ... def check_xsrf_cookie(self): ... def xsrf_form_html(self): ... def static_url(self, path, include_host=..., **kwargs): ... def require_setting(self, name, feature=...): ... def reverse_url(self, name, *args): ... def compute_etag(self): ... def set_etag_header(self): ... def check_etag_header(self): ... def data_received(self, chunk): ... def log_exception(self, typ, value, tb): ... def asynchronous(method): ... def stream_request_body(cls): ... def removeslash(method): ... def addslash(method): ... class Application(httputil.HTTPServerConnectionDelegate): transforms: Any handlers: Any named_handlers: Any default_host: Any settings: Any ui_modules: Any ui_methods: Any def __init__(self, handlers=..., default_host=..., transforms=..., **settings) -> None: ... def listen(self, port, address=..., **kwargs): ... def add_handlers(self, host_pattern, host_handlers): ... def add_transform(self, transform_class): ... def start_request(self, server_conn, request_conn): ... def __call__(self, request): ... def reverse_url(self, name, *args): ... def log_request(self, handler): ... class _RequestDispatcher(httputil.HTTPMessageDelegate): application: Any connection: Any request: Any chunks: Any handler_class: Any handler_kwargs: Any path_args: Any path_kwargs: Any def __init__(self, application, connection) -> None: ... def headers_received(self, start_line, headers): ... stream_request_body: Any def set_request(self, request): ... def data_received(self, data): ... def finish(self): ... def on_connection_close(self): ... handler: Any def execute(self): ... class HTTPError(Exception): status_code: Any log_message: Any args: Any reason: Any def __init__(self, status_code, log_message=..., *args, **kwargs) -> None: ... class Finish(Exception): ... class MissingArgumentError(HTTPError): arg_name: Any def __init__(self, arg_name) -> None: ... class ErrorHandler(RequestHandler): def initialize(self, status_code): ... def prepare(self): ... def check_xsrf_cookie(self): ... class RedirectHandler(RequestHandler): def initialize(self, url, permanent=...): ... def get(self): ... class StaticFileHandler(RequestHandler): CACHE_MAX_AGE: Any root: Any default_filename: Any def initialize(self, path, default_filename=...): ... @classmethod def reset(cls): ... def head(self, path): ... path: Any absolute_path: Any modified: Any def get(self, path, include_body=...): ... def compute_etag(self): ... def set_headers(self): ... def should_return_304(self): ... @classmethod def get_absolute_path(cls, root, path): ... def validate_absolute_path(self, root, absolute_path): ... @classmethod def get_content(cls, abspath, start=..., end=...): ... @classmethod def get_content_version(cls, abspath): ... def get_content_size(self): ... def get_modified_time(self): ... def get_content_type(self): ... def set_extra_headers(self, path): ... def get_cache_time(self, path, modified, mime_type): ... @classmethod def make_static_url(cls, settings, path, include_version=...): ... def parse_url_path(self, url_path): ... @classmethod def get_version(cls, settings, path): ... class FallbackHandler(RequestHandler): fallback: Any def initialize(self, fallback): ... def prepare(self): ... class OutputTransform: def __init__(self, request) -> None: ... def transform_first_chunk(self, status_code, headers, chunk, finishing): ... def transform_chunk(self, chunk, finishing): ... class GZipContentEncoding(OutputTransform): CONTENT_TYPES: Any MIN_LENGTH: Any def __init__(self, request) -> None: ... def transform_first_chunk(self, status_code, headers, chunk, finishing): ... def transform_chunk(self, chunk, finishing): ... def authenticated(method): ... class UIModule: handler: Any request: Any ui: Any locale: Any def __init__(self, handler) -> None: ... @property def current_user(self): ... def render(self, *args, **kwargs): ... def embedded_javascript(self): ... def javascript_files(self): ... def embedded_css(self): ... def css_files(self): ... def html_head(self): ... def html_body(self): ... def render_string(self, path, **kwargs): ... class _linkify(UIModule): def render(self, text, **kwargs): ... class _xsrf_form_html(UIModule): def render(self): ... class TemplateModule(UIModule): def __init__(self, handler) -> None: ... def render(self, path, **kwargs): ... def embedded_javascript(self): ... def javascript_files(self): ... def embedded_css(self): ... def css_files(self): ... def html_head(self): ... def html_body(self): ... class _UIModuleNamespace: handler: Any ui_modules: Any def __init__(self, handler, ui_modules) -> None: ... def __getitem__(self, key): ... def __getattr__(self, key): ... class URLSpec: regex: Any handler_class: Any kwargs: Any name: Any def __init__(self, pattern, handler, kwargs=..., name=...) -> None: ... def reverse(self, *args): ... url: Any def create_signed_value(secret, name, value, version=..., clock=..., key_version=...): ... def decode_signed_value(secret, name, value, max_age_days=..., clock=..., min_version=...): ... def get_signature_key_version(value): ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4383793 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/0000775000175000017500000000000000000000000022731 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4383793 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/atomicwrites/0000775000175000017500000000000000000000000025443 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/atomicwrites/__init__.pyi0000664000175000017500000000152200000000000027725 0ustar00davedave00000000000000from _typeshed import AnyPath from typing import IO, Any, AnyStr, Callable, ContextManager, Optional, Text, Type def replace_atomic(src: AnyStr, dst: AnyStr) -> None: ... def move_atomic(src: AnyStr, dst: AnyStr) -> None: ... class AtomicWriter(object): def __init__(self, path: AnyPath, mode: Text = ..., overwrite: bool = ...) -> None: ... def open(self) -> ContextManager[IO[Any]]: ... def _open(self, get_fileobject: Callable[..., IO[AnyStr]]) -> ContextManager[IO[AnyStr]]: ... def get_fileobject(self, dir: Optional[AnyPath] = ..., **kwargs: Any) -> IO[Any]: ... def sync(self, f: IO[Any]) -> None: ... def commit(self, f: IO[Any]) -> None: ... def rollback(self, f: IO[Any]) -> None: ... def atomic_write(path: AnyPath, writer_cls: Type[AtomicWriter] = ..., **cls_kwargs: object) -> ContextManager[IO[Any]]: ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4383793 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/attr/0000775000175000017500000000000000000000000023703 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/attr/__init__.pyi0000664000175000017500000001772500000000000026201 0ustar00davedave00000000000000from typing import Any, Callable, Dict, Generic, List, Mapping, Optional, Sequence, Tuple, Type, TypeVar, Union, overload # `import X as X` is required to make these public from . import converters as converters, exceptions as exceptions, filters as filters, validators as validators from ._version_info import VersionInfo __version__: str __version_info__: VersionInfo __title__: str __description__: str __url__: str __uri__: str __author__: str __email__: str __license__: str __copyright__: str _T = TypeVar("_T") _C = TypeVar("_C", bound=type) _ValidatorType = Callable[[Any, Attribute[_T], _T], Any] _ConverterType = Callable[[Any], _T] _FilterType = Callable[[Attribute[_T], _T], bool] _ReprType = Callable[[Any], str] _ReprArgType = Union[bool, _ReprType] # FIXME: in reality, if multiple validators are passed they must be in a list or tuple, # but those are invariant and so would prevent subtypes of _ValidatorType from working # when passed in a list or tuple. _ValidatorArgType = Union[_ValidatorType[_T], Sequence[_ValidatorType[_T]]] # _make -- NOTHING: object # NOTE: Factory lies about its return type to make this possible: `x: List[int] = Factory(list)` # Work around mypy issue #4554 in the common case by using an overload. @overload def Factory(factory: Callable[[], _T]) -> _T: ... @overload def Factory(factory: Union[Callable[[Any], _T], Callable[[], _T]], takes_self: bool = ...) -> _T: ... class Attribute(Generic[_T]): name: str default: Optional[_T] validator: Optional[_ValidatorType[_T]] repr: _ReprArgType cmp: bool eq: bool order: bool hash: Optional[bool] init: bool converter: Optional[_ConverterType[_T]] metadata: Dict[Any, Any] type: Optional[Type[_T]] kw_only: bool # NOTE: We had several choices for the annotation to use for type arg: # 1) Type[_T] # - Pros: Handles simple cases correctly # - Cons: Might produce less informative errors in the case of conflicting TypeVars # e.g. `attr.ib(default='bad', type=int)` # 2) Callable[..., _T] # - Pros: Better error messages than #1 for conflicting TypeVars # - Cons: Terrible error messages for validator checks. # e.g. attr.ib(type=int, validator=validate_str) # -> error: Cannot infer function type argument # 3) type (and do all of the work in the mypy plugin) # - Pros: Simple here, and we could customize the plugin with our own errors. # - Cons: Would need to write mypy plugin code to handle all the cases. # We chose option #1. # `attr` lies about its return type to make the following possible: # attr() -> Any # attr(8) -> int # attr(validator=) -> Whatever the callable expects. # This makes this type of assignments possible: # x: int = attr(8) # # This form catches explicit None or no default but with no other arguments returns Any. @overload def attrib( default: None = ..., validator: None = ..., repr: _ReprArgType = ..., cmp: Optional[bool] = ..., hash: Optional[bool] = ..., init: bool = ..., metadata: Optional[Mapping[Any, Any]] = ..., type: None = ..., converter: None = ..., factory: None = ..., kw_only: bool = ..., eq: Optional[bool] = ..., order: Optional[bool] = ..., ) -> Any: ... # This form catches an explicit None or no default and infers the type from the other arguments. @overload def attrib( default: None = ..., validator: Optional[_ValidatorArgType[_T]] = ..., repr: _ReprArgType = ..., cmp: Optional[bool] = ..., hash: Optional[bool] = ..., init: bool = ..., metadata: Optional[Mapping[Any, Any]] = ..., type: Optional[Type[_T]] = ..., converter: Optional[_ConverterType[_T]] = ..., factory: Optional[Callable[[], _T]] = ..., kw_only: bool = ..., eq: Optional[bool] = ..., order: Optional[bool] = ..., ) -> _T: ... # This form catches an explicit default argument. @overload def attrib( default: _T, validator: Optional[_ValidatorArgType[_T]] = ..., repr: _ReprArgType = ..., cmp: Optional[bool] = ..., hash: Optional[bool] = ..., init: bool = ..., metadata: Optional[Mapping[Any, Any]] = ..., type: Optional[Type[_T]] = ..., converter: Optional[_ConverterType[_T]] = ..., factory: Optional[Callable[[], _T]] = ..., kw_only: bool = ..., eq: Optional[bool] = ..., order: Optional[bool] = ..., ) -> _T: ... # This form covers type=non-Type: e.g. forward references (str), Any @overload def attrib( default: Optional[_T] = ..., validator: Optional[_ValidatorArgType[_T]] = ..., repr: _ReprArgType = ..., cmp: Optional[bool] = ..., hash: Optional[bool] = ..., init: bool = ..., metadata: Optional[Mapping[Any, Any]] = ..., type: object = ..., converter: Optional[_ConverterType[_T]] = ..., factory: Optional[Callable[[], _T]] = ..., kw_only: bool = ..., eq: Optional[bool] = ..., order: Optional[bool] = ..., ) -> Any: ... @overload def attrs( maybe_cls: _C, these: Optional[Dict[str, Any]] = ..., repr_ns: Optional[str] = ..., repr: bool = ..., cmp: Optional[bool] = ..., hash: Optional[bool] = ..., init: bool = ..., slots: bool = ..., frozen: bool = ..., weakref_slot: bool = ..., str: bool = ..., auto_attribs: bool = ..., kw_only: bool = ..., cache_hash: bool = ..., auto_exc: bool = ..., eq: Optional[bool] = ..., order: Optional[bool] = ..., ) -> _C: ... @overload def attrs( maybe_cls: None = ..., these: Optional[Dict[str, Any]] = ..., repr_ns: Optional[str] = ..., repr: bool = ..., cmp: Optional[bool] = ..., hash: Optional[bool] = ..., init: bool = ..., slots: bool = ..., frozen: bool = ..., weakref_slot: bool = ..., str: bool = ..., auto_attribs: bool = ..., kw_only: bool = ..., cache_hash: bool = ..., auto_exc: bool = ..., eq: Optional[bool] = ..., order: Optional[bool] = ..., ) -> Callable[[_C], _C]: ... # TODO: add support for returning NamedTuple from the mypy plugin class _Fields(Tuple[Attribute[Any], ...]): def __getattr__(self, name: str) -> Attribute[Any]: ... def fields(cls: type) -> _Fields: ... def fields_dict(cls: type) -> Dict[str, Attribute[Any]]: ... def validate(inst: Any) -> None: ... # TODO: add support for returning a proper attrs class from the mypy plugin # we use Any instead of _CountingAttr so that e.g. `make_class('Foo', [attr.ib()])` is valid def make_class( name: str, attrs: Union[List[str], Tuple[str, ...], Dict[str, Any]], bases: Tuple[type, ...] = ..., repr_ns: Optional[str] = ..., repr: bool = ..., cmp: Optional[bool] = ..., hash: Optional[bool] = ..., init: bool = ..., slots: bool = ..., frozen: bool = ..., weakref_slot: bool = ..., str: bool = ..., auto_attribs: bool = ..., kw_only: bool = ..., cache_hash: bool = ..., auto_exc: bool = ..., eq: Optional[bool] = ..., order: Optional[bool] = ..., ) -> type: ... # _funcs -- # TODO: add support for returning TypedDict from the mypy plugin # FIXME: asdict/astuple do not honor their factory args. waiting on one of these: # https://github.com/python/mypy/issues/4236 # https://github.com/python/typing/issues/253 def asdict( inst: Any, recurse: bool = ..., filter: Optional[_FilterType[Any]] = ..., dict_factory: Type[Mapping[Any, Any]] = ..., retain_collection_types: bool = ..., ) -> Dict[str, Any]: ... # TODO: add support for returning NamedTuple from the mypy plugin def astuple( inst: Any, recurse: bool = ..., filter: Optional[_FilterType[Any]] = ..., tuple_factory: Type[Sequence[Any]] = ..., retain_collection_types: bool = ..., ) -> Tuple[Any, ...]: ... def has(cls: type) -> bool: ... def assoc(inst: _T, **changes: Any) -> _T: ... def evolve(inst: _T, **changes: Any) -> _T: ... # _config -- def set_run_validators(run: bool) -> None: ... def get_run_validators() -> bool: ... # aliases -- s = attributes = attrs ib = attr = attrib dataclass = attrs # Technically, partial(attrs, auto_attribs=True) ;) ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/attr/_version_info.pyi0000664000175000017500000000032100000000000027261 0ustar00davedave00000000000000class VersionInfo: @property def year(self) -> int: ... @property def minor(self) -> int: ... @property def micro(self) -> int: ... @property def releaselevel(self) -> str: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/attr/converters.pyi0000664000175000017500000000053200000000000026620 0ustar00davedave00000000000000from typing import Callable, Optional, TypeVar, overload from . import _ConverterType _T = TypeVar("_T") def optional(converter: _ConverterType[_T]) -> _ConverterType[Optional[_T]]: ... @overload def default_if_none(default: _T) -> _ConverterType[_T]: ... @overload def default_if_none(*, factory: Callable[[], _T]) -> _ConverterType[_T]: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/attr/exceptions.pyi0000664000175000017500000000071200000000000026607 0ustar00davedave00000000000000from typing import Any class FrozenInstanceError(AttributeError): msg: str = ... class AttrsAttributeNotFoundError(ValueError): ... class NotAnAttrsClassError(ValueError): ... class DefaultAlreadySetError(RuntimeError): ... class UnannotatedAttributeError(RuntimeError): ... class PythonTooOldError(RuntimeError): ... class NotCallableError(TypeError): msg: str = ... value: Any = ... def __init__(self, msg: str, value: Any) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/attr/filters.pyi0000664000175000017500000000032700000000000026100 0ustar00davedave00000000000000from typing import Any, Union from . import Attribute, _FilterType def include(*what: Union[type, Attribute[Any]]) -> _FilterType[Any]: ... def exclude(*what: Union[type, Attribute[Any]]) -> _FilterType[Any]: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/attr/validators.pyi0000664000175000017500000000342600000000000026603 0ustar00davedave00000000000000from typing import ( Any, AnyStr, Callable, Container, Iterable, List, Mapping, Match, Optional, Tuple, Type, TypeVar, Union, overload, ) from . import _ValidatorType _T = TypeVar("_T") _T1 = TypeVar("_T1") _T2 = TypeVar("_T2") _T3 = TypeVar("_T3") _I = TypeVar("_I", bound=Iterable) _K = TypeVar("_K") _V = TypeVar("_V") _M = TypeVar("_M", bound=Mapping) # To be more precise on instance_of use some overloads. # If there are more than 3 items in the tuple then we fall back to Any @overload def instance_of(type: Type[_T]) -> _ValidatorType[_T]: ... @overload def instance_of(type: Tuple[Type[_T]]) -> _ValidatorType[_T]: ... @overload def instance_of(type: Tuple[Type[_T1], Type[_T2]]) -> _ValidatorType[Union[_T1, _T2]]: ... @overload def instance_of(type: Tuple[Type[_T1], Type[_T2], Type[_T3]]) -> _ValidatorType[Union[_T1, _T2, _T3]]: ... @overload def instance_of(type: Tuple[type, ...]) -> _ValidatorType[Any]: ... def provides(interface: Any) -> _ValidatorType[Any]: ... def optional(validator: Union[_ValidatorType[_T], List[_ValidatorType[_T]]]) -> _ValidatorType[Optional[_T]]: ... def in_(options: Container[_T]) -> _ValidatorType[_T]: ... def and_(*validators: _ValidatorType[_T]) -> _ValidatorType[_T]: ... def matches_re( regex: AnyStr, flags: int = ..., func: Optional[Callable[[AnyStr, AnyStr, int], Optional[Match[AnyStr]]]] = ... ) -> _ValidatorType[AnyStr]: ... def deep_iterable( member_validator: _ValidatorType[_T], iterable_validator: Optional[_ValidatorType[_I]] = ... ) -> _ValidatorType[_I]: ... def deep_mapping( key_validator: _ValidatorType[_K], value_validator: _ValidatorType[_V], mapping_validator: Optional[_ValidatorType[_M]] = ... ) -> _ValidatorType[_M]: ... def is_callable() -> _ValidatorType[_T]: ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4383793 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/backports/0000775000175000017500000000000000000000000024721 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/backports/__init__.pyi0000664000175000017500000000015500000000000027204 0ustar00davedave00000000000000from typing import Any # Explicitly mark this package as incomplete. def __getattr__(name: str) -> Any: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/backports/ssl_match_hostname.pyi0000664000175000017500000000012100000000000031311 0ustar00davedave00000000000000class CertificateError(ValueError): ... def match_hostname(cert, hostname): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/backports_abc.pyi0000664000175000017500000000033400000000000026251 0ustar00davedave00000000000000from typing import Any def mk_gen(): ... def mk_awaitable(): ... def mk_coroutine(): ... Generator: Any Awaitable: Any Coroutine: Any def isawaitable(obj): ... PATCHED: Any def patch(patch_inspect: bool = ...): ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4383793 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/bleach/0000775000175000017500000000000000000000000024147 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/bleach/__init__.pyi0000664000175000017500000000151100000000000026427 0ustar00davedave00000000000000from typing import Any, Container, Iterable, Optional, Text from bleach.linkifier import DEFAULT_CALLBACKS as DEFAULT_CALLBACKS, Linker as Linker, _Callback from bleach.sanitizer import ( ALLOWED_ATTRIBUTES as ALLOWED_ATTRIBUTES, ALLOWED_PROTOCOLS as ALLOWED_PROTOCOLS, ALLOWED_STYLES as ALLOWED_STYLES, ALLOWED_TAGS as ALLOWED_TAGS, Cleaner as Cleaner, ) __releasedate__: Text __version__: Text VERSION: Any # packaging.version.Version def clean( text: Text, tags: Container[Text] = ..., attributes: Any = ..., styles: Container[Text] = ..., protocols: Container[Text] = ..., strip: bool = ..., strip_comments: bool = ..., ) -> Text: ... def linkify( text: Text, callbacks: Iterable[_Callback] = ..., skip_tags: Optional[Container[Text]] = ..., parse_email: bool = ... ) -> Text: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/bleach/callbacks.pyi0000664000175000017500000000031600000000000026611 0ustar00davedave00000000000000from typing import Any, MutableMapping, Text _Attrs = MutableMapping[Any, Text] def nofollow(attrs: _Attrs, new: bool = ...) -> _Attrs: ... def target_blank(attrs: _Attrs, new: bool = ...) -> _Attrs: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/bleach/linkifier.pyi0000664000175000017500000000172200000000000026650 0ustar00davedave00000000000000from typing import Any, Container, Iterable, List, MutableMapping, Optional, Pattern, Protocol, Text _Attrs = MutableMapping[Any, Text] class _Callback(Protocol): def __call__(self, attrs: _Attrs, new: bool = ...) -> _Attrs: ... DEFAULT_CALLBACKS: List[_Callback] TLDS: List[Text] def build_url_re(tlds: Iterable[Text] = ..., protocols: Iterable[Text] = ...) -> Pattern[Text]: ... URL_RE: Pattern[Text] PROTO_RE: Pattern[Text] EMAIL_RE: Pattern[Text] class Linker(object): def __init__( self, callbacks: Iterable[_Callback] = ..., skip_tags: Optional[Container[Text]] = ..., parse_email: bool = ..., url_re: Pattern[Text] = ..., email_re: Pattern[Text] = ..., recognized_tags: Optional[Container[Text]] = ..., ) -> None: ... def linkify(self, text: Text) -> Text: ... class LinkifyFilter(object): # TODO: derives from html5lib.Filter def __getattr__(self, item: str) -> Any: ... # incomplete ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/bleach/sanitizer.pyi0000664000175000017500000000217400000000000026706 0ustar00davedave00000000000000from typing import Any, Callable, Container, Dict, Iterable, List, Optional, Pattern, Text, Union ALLOWED_TAGS: List[Text] ALLOWED_ATTRIBUTES: Dict[Text, List[Text]] ALLOWED_STYLES: List[Text] ALLOWED_PROTOCOLS: List[Text] INVISIBLE_CHARACTERS: Text INVISIBLE_CHARACTERS_RE: Pattern[Text] INVISIBLE_REPLACEMENT_CHAR: Text # A html5lib Filter class _Filter = Any class Cleaner(object): def __init__( self, tags: Container[Text] = ..., attributes: Any = ..., styles: Container[Text] = ..., protocols: Container[Text] = ..., strip: bool = ..., strip_comments: bool = ..., filters: Optional[Iterable[_Filter]] = ..., ) -> None: ... def clean(self, text: Text) -> Text: ... _AttributeFilter = Callable[[Text, Text, Text], bool] _AttributeDict = Dict[Text, Union[Container[Text], _AttributeFilter]] def attribute_filter_factory(attributes: Union[_AttributeFilter, _AttributeDict, Container[Text]]) -> _AttributeFilter: ... class BleachSanitizerFilter(object): # TODO: derives from html5lib.sanitizer.Filter def __getattr__(self, item: str) -> Any: ... # incomplete ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/bleach/utils.pyi0000664000175000017500000000043600000000000026035 0ustar00davedave00000000000000from collections import OrderedDict from typing import Any, Mapping, Text, overload def force_unicode(text: Text) -> Text: ... @overload def alphabetize_attributes(attrs: None) -> None: ... @overload def alphabetize_attributes(attrs: Mapping[Any, Text]) -> OrderedDict[Any, Text]: ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4383793 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/boto/0000775000175000017500000000000000000000000023674 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/boto/__init__.pyi0000664000175000017500000001601700000000000026163 0ustar00davedave00000000000000import logging from typing import Any, Optional, Text from .s3.connection import S3Connection Version: Any UserAgent: Any config: Any BUCKET_NAME_RE: Any TOO_LONG_DNS_NAME_COMP: Any GENERATION_RE: Any VERSION_RE: Any ENDPOINTS_PATH: Any def init_logging(): ... class NullHandler(logging.Handler): def emit(self, record): ... log: Any perflog: Any def set_file_logger(name, filepath, level: Any = ..., format_string: Optional[Any] = ...): ... def set_stream_logger(name, level: Any = ..., format_string: Optional[Any] = ...): ... def connect_sqs(aws_access_key_id: Optional[Any] = ..., aws_secret_access_key: Optional[Any] = ..., **kwargs): ... def connect_s3( aws_access_key_id: Optional[Text] = ..., aws_secret_access_key: Optional[Text] = ..., **kwargs ) -> S3Connection: ... def connect_gs(gs_access_key_id: Optional[Any] = ..., gs_secret_access_key: Optional[Any] = ..., **kwargs): ... def connect_ec2(aws_access_key_id: Optional[Any] = ..., aws_secret_access_key: Optional[Any] = ..., **kwargs): ... def connect_elb(aws_access_key_id: Optional[Any] = ..., aws_secret_access_key: Optional[Any] = ..., **kwargs): ... def connect_autoscale(aws_access_key_id: Optional[Any] = ..., aws_secret_access_key: Optional[Any] = ..., **kwargs): ... def connect_cloudwatch(aws_access_key_id: Optional[Any] = ..., aws_secret_access_key: Optional[Any] = ..., **kwargs): ... def connect_sdb(aws_access_key_id: Optional[Any] = ..., aws_secret_access_key: Optional[Any] = ..., **kwargs): ... def connect_fps(aws_access_key_id: Optional[Any] = ..., aws_secret_access_key: Optional[Any] = ..., **kwargs): ... def connect_mturk(aws_access_key_id: Optional[Any] = ..., aws_secret_access_key: Optional[Any] = ..., **kwargs): ... def connect_cloudfront(aws_access_key_id: Optional[Any] = ..., aws_secret_access_key: Optional[Any] = ..., **kwargs): ... def connect_vpc(aws_access_key_id: Optional[Any] = ..., aws_secret_access_key: Optional[Any] = ..., **kwargs): ... def connect_rds(aws_access_key_id: Optional[Any] = ..., aws_secret_access_key: Optional[Any] = ..., **kwargs): ... def connect_rds2(aws_access_key_id: Optional[Any] = ..., aws_secret_access_key: Optional[Any] = ..., **kwargs): ... def connect_emr(aws_access_key_id: Optional[Any] = ..., aws_secret_access_key: Optional[Any] = ..., **kwargs): ... def connect_sns(aws_access_key_id: Optional[Any] = ..., aws_secret_access_key: Optional[Any] = ..., **kwargs): ... def connect_iam(aws_access_key_id: Optional[Any] = ..., aws_secret_access_key: Optional[Any] = ..., **kwargs): ... def connect_route53(aws_access_key_id: Optional[Any] = ..., aws_secret_access_key: Optional[Any] = ..., **kwargs): ... def connect_cloudformation(aws_access_key_id: Optional[Any] = ..., aws_secret_access_key: Optional[Any] = ..., **kwargs): ... def connect_euca( host: Optional[Any] = ..., aws_access_key_id: Optional[Any] = ..., aws_secret_access_key: Optional[Any] = ..., port: int = ..., path: str = ..., is_secure: bool = ..., **kwargs, ): ... def connect_glacier(aws_access_key_id: Optional[Any] = ..., aws_secret_access_key: Optional[Any] = ..., **kwargs): ... def connect_ec2_endpoint(url, aws_access_key_id: Optional[Any] = ..., aws_secret_access_key: Optional[Any] = ..., **kwargs): ... def connect_walrus( host: Optional[Any] = ..., aws_access_key_id: Optional[Any] = ..., aws_secret_access_key: Optional[Any] = ..., port: int = ..., path: str = ..., is_secure: bool = ..., **kwargs, ): ... def connect_ses(aws_access_key_id: Optional[Any] = ..., aws_secret_access_key: Optional[Any] = ..., **kwargs): ... def connect_sts(aws_access_key_id: Optional[Any] = ..., aws_secret_access_key: Optional[Any] = ..., **kwargs): ... def connect_ia( ia_access_key_id: Optional[Any] = ..., ia_secret_access_key: Optional[Any] = ..., is_secure: bool = ..., **kwargs ): ... def connect_dynamodb(aws_access_key_id: Optional[Any] = ..., aws_secret_access_key: Optional[Any] = ..., **kwargs): ... def connect_swf(aws_access_key_id: Optional[Any] = ..., aws_secret_access_key: Optional[Any] = ..., **kwargs): ... def connect_cloudsearch(aws_access_key_id: Optional[Any] = ..., aws_secret_access_key: Optional[Any] = ..., **kwargs): ... def connect_cloudsearch2( aws_access_key_id: Optional[Any] = ..., aws_secret_access_key: Optional[Any] = ..., sign_request: bool = ..., **kwargs ): ... def connect_cloudsearchdomain(aws_access_key_id: Optional[Any] = ..., aws_secret_access_key: Optional[Any] = ..., **kwargs): ... def connect_beanstalk(aws_access_key_id: Optional[Any] = ..., aws_secret_access_key: Optional[Any] = ..., **kwargs): ... def connect_elastictranscoder(aws_access_key_id: Optional[Any] = ..., aws_secret_access_key: Optional[Any] = ..., **kwargs): ... def connect_opsworks(aws_access_key_id: Optional[Any] = ..., aws_secret_access_key: Optional[Any] = ..., **kwargs): ... def connect_redshift(aws_access_key_id: Optional[Any] = ..., aws_secret_access_key: Optional[Any] = ..., **kwargs): ... def connect_support(aws_access_key_id: Optional[Any] = ..., aws_secret_access_key: Optional[Any] = ..., **kwargs): ... def connect_cloudtrail(aws_access_key_id: Optional[Any] = ..., aws_secret_access_key: Optional[Any] = ..., **kwargs): ... def connect_directconnect(aws_access_key_id: Optional[Any] = ..., aws_secret_access_key: Optional[Any] = ..., **kwargs): ... def connect_kinesis(aws_access_key_id: Optional[Any] = ..., aws_secret_access_key: Optional[Any] = ..., **kwargs): ... def connect_logs(aws_access_key_id: Optional[Any] = ..., aws_secret_access_key: Optional[Any] = ..., **kwargs): ... def connect_route53domains(aws_access_key_id: Optional[Any] = ..., aws_secret_access_key: Optional[Any] = ..., **kwargs): ... def connect_cognito_identity(aws_access_key_id: Optional[Any] = ..., aws_secret_access_key: Optional[Any] = ..., **kwargs): ... def connect_cognito_sync(aws_access_key_id: Optional[Any] = ..., aws_secret_access_key: Optional[Any] = ..., **kwargs): ... def connect_kms(aws_access_key_id: Optional[Any] = ..., aws_secret_access_key: Optional[Any] = ..., **kwargs): ... def connect_awslambda(aws_access_key_id: Optional[Any] = ..., aws_secret_access_key: Optional[Any] = ..., **kwargs): ... def connect_codedeploy(aws_access_key_id: Optional[Any] = ..., aws_secret_access_key: Optional[Any] = ..., **kwargs): ... def connect_configservice(aws_access_key_id: Optional[Any] = ..., aws_secret_access_key: Optional[Any] = ..., **kwargs): ... def connect_cloudhsm(aws_access_key_id: Optional[Any] = ..., aws_secret_access_key: Optional[Any] = ..., **kwargs): ... def connect_ec2containerservice(aws_access_key_id: Optional[Any] = ..., aws_secret_access_key: Optional[Any] = ..., **kwargs): ... def connect_machinelearning(aws_access_key_id: Optional[Any] = ..., aws_secret_access_key: Optional[Any] = ..., **kwargs): ... def storage_uri( uri_str, default_scheme: str = ..., debug: int = ..., validate: bool = ..., bucket_storage_uri_class: Any = ..., suppress_consec_slashes: bool = ..., is_latest: bool = ..., ): ... def storage_uri_for_key(key): ... # Explicitly mark this package as incomplete. def __getattr__(name: str) -> Any: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/boto/auth.pyi0000664000175000017500000001005500000000000025361 0ustar00davedave00000000000000from typing import Any, Optional from boto.auth_handler import AuthHandler SIGV4_DETECT: Any class HmacKeys: host: Any def __init__(self, host, config, provider) -> None: ... def update_provider(self, provider): ... def algorithm(self): ... def sign_string(self, string_to_sign): ... class AnonAuthHandler(AuthHandler, HmacKeys): capability: Any def __init__(self, host, config, provider) -> None: ... def add_auth(self, http_request, **kwargs): ... class HmacAuthV1Handler(AuthHandler, HmacKeys): capability: Any def __init__(self, host, config, provider) -> None: ... def update_provider(self, provider): ... def add_auth(self, http_request, **kwargs): ... class HmacAuthV2Handler(AuthHandler, HmacKeys): capability: Any def __init__(self, host, config, provider) -> None: ... def update_provider(self, provider): ... def add_auth(self, http_request, **kwargs): ... class HmacAuthV3Handler(AuthHandler, HmacKeys): capability: Any def __init__(self, host, config, provider) -> None: ... def add_auth(self, http_request, **kwargs): ... class HmacAuthV3HTTPHandler(AuthHandler, HmacKeys): capability: Any def __init__(self, host, config, provider) -> None: ... def headers_to_sign(self, http_request): ... def canonical_headers(self, headers_to_sign): ... def string_to_sign(self, http_request): ... def add_auth(self, req, **kwargs): ... class HmacAuthV4Handler(AuthHandler, HmacKeys): capability: Any service_name: Any region_name: Any def __init__(self, host, config, provider, service_name: Optional[Any] = ..., region_name: Optional[Any] = ...) -> None: ... def headers_to_sign(self, http_request): ... def host_header(self, host, http_request): ... def query_string(self, http_request): ... def canonical_query_string(self, http_request): ... def canonical_headers(self, headers_to_sign): ... def signed_headers(self, headers_to_sign): ... def canonical_uri(self, http_request): ... def payload(self, http_request): ... def canonical_request(self, http_request): ... def scope(self, http_request): ... def split_host_parts(self, host): ... def determine_region_name(self, host): ... def determine_service_name(self, host): ... def credential_scope(self, http_request): ... def string_to_sign(self, http_request, canonical_request): ... def signature(self, http_request, string_to_sign): ... def add_auth(self, req, **kwargs): ... class S3HmacAuthV4Handler(HmacAuthV4Handler, AuthHandler): capability: Any region_name: Any def __init__(self, *args, **kwargs) -> None: ... def clean_region_name(self, region_name): ... def canonical_uri(self, http_request): ... def canonical_query_string(self, http_request): ... def host_header(self, host, http_request): ... def headers_to_sign(self, http_request): ... def determine_region_name(self, host): ... def determine_service_name(self, host): ... def mangle_path_and_params(self, req): ... def payload(self, http_request): ... def add_auth(self, req, **kwargs): ... def presign(self, req, expires, iso_date: Optional[Any] = ...): ... class STSAnonHandler(AuthHandler): capability: Any def add_auth(self, http_request, **kwargs): ... class QuerySignatureHelper(HmacKeys): def add_auth(self, http_request, **kwargs): ... class QuerySignatureV0AuthHandler(QuerySignatureHelper, AuthHandler): SignatureVersion: int capability: Any class QuerySignatureV1AuthHandler(QuerySignatureHelper, AuthHandler): SignatureVersion: int capability: Any def __init__(self, *args, **kw) -> None: ... class QuerySignatureV2AuthHandler(QuerySignatureHelper, AuthHandler): SignatureVersion: int capability: Any class POSTPathQSV2AuthHandler(QuerySignatureV2AuthHandler, AuthHandler): capability: Any def add_auth(self, req, **kwargs): ... def get_auth_handler(host, config, provider, requested_capability: Optional[Any] = ...): ... def detect_potential_sigv4(func): ... def detect_potential_s3sigv4(func): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/boto/auth_handler.pyi0000664000175000017500000000037300000000000027060 0ustar00davedave00000000000000from typing import Any from boto.plugin import Plugin class NotReadyToAuthenticate(Exception): ... class AuthHandler(Plugin): capability: Any def __init__(self, host, config, provider) -> None: ... def add_auth(self, http_request): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/boto/compat.pyi0000664000175000017500000000060000000000000025676 0ustar00davedave00000000000000import sys from typing import Any if sys.version_info >= (3,): from base64 import encodebytes as encodebytes else: from base64 import encodestring encodebytes = encodestring expanduser: Any if sys.version_info >= (3, 0): StandardError = Exception else: from __builtin__ import StandardError as StandardError long_type: Any unquote_str: Any parse_qs_safe: Any ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/boto/connection.pyi0000664000175000017500000001305700000000000026564 0ustar00davedave00000000000000from typing import Any, Optional from six.moves import http_client HAVE_HTTPS_CONNECTION: bool ON_APP_ENGINE: Any PORTS_BY_SECURITY: Any DEFAULT_CA_CERTS_FILE: Any class HostConnectionPool: queue: Any def __init__(self) -> None: ... def size(self): ... def put(self, conn): ... def get(self): ... def clean(self): ... class ConnectionPool: CLEAN_INTERVAL: float STALE_DURATION: float host_to_pool: Any last_clean_time: float mutex: Any def __init__(self) -> None: ... def size(self): ... def get_http_connection(self, host, port, is_secure): ... def put_http_connection(self, host, port, is_secure, conn): ... def clean(self): ... class HTTPRequest: method: Any protocol: Any host: Any port: Any path: Any auth_path: Any params: Any headers: Any body: Any def __init__(self, method, protocol, host, port, path, auth_path, params, headers, body) -> None: ... def authorize(self, connection, **kwargs): ... class HTTPResponse(http_client.HTTPResponse): def __init__(self, *args, **kwargs) -> None: ... def read(self, amt: Optional[Any] = ...): ... class AWSAuthConnection: suppress_consec_slashes: Any num_retries: int is_secure: Any https_validate_certificates: Any ca_certificates_file: Any port: Any http_exceptions: Any http_unretryable_exceptions: Any socket_exception_values: Any https_connection_factory: Any protocol: str host: Any path: Any debug: Any host_header: Any http_connection_kwargs: Any provider: Any auth_service_name: Any request_hook: Any def __init__( self, host, aws_access_key_id: Optional[Any] = ..., aws_secret_access_key: Optional[Any] = ..., is_secure: bool = ..., port: Optional[Any] = ..., proxy: Optional[Any] = ..., proxy_port: Optional[Any] = ..., proxy_user: Optional[Any] = ..., proxy_pass: Optional[Any] = ..., debug: int = ..., https_connection_factory: Optional[Any] = ..., path: str = ..., provider: str = ..., security_token: Optional[Any] = ..., suppress_consec_slashes: bool = ..., validate_certs: bool = ..., profile_name: Optional[Any] = ..., ) -> None: ... auth_region_name: Any @property def connection(self): ... @property def aws_access_key_id(self): ... @property def gs_access_key_id(self) -> Any: ... access_key: Any @property def aws_secret_access_key(self): ... @property def gs_secret_access_key(self): ... secret_key: Any @property def profile_name(self): ... def get_path(self, path: str = ...): ... def server_name(self, port: Optional[Any] = ...): ... proxy: Any proxy_port: Any proxy_user: Any proxy_pass: Any no_proxy: Any use_proxy: Any def handle_proxy(self, proxy, proxy_port, proxy_user, proxy_pass): ... def get_http_connection(self, host, port, is_secure): ... def skip_proxy(self, host): ... def new_http_connection(self, host, port, is_secure): ... def put_http_connection(self, host, port, is_secure, connection): ... def proxy_ssl(self, host: Optional[Any] = ..., port: Optional[Any] = ...): ... def prefix_proxy_to_path(self, path, host: Optional[Any] = ...): ... def get_proxy_auth_header(self): ... def get_proxy_url_with_auth(self): ... def set_host_header(self, request): ... def set_request_hook(self, hook): ... def build_base_http_request( self, method, path, auth_path, params: Optional[Any] = ..., headers: Optional[Any] = ..., data: str = ..., host: Optional[Any] = ..., ): ... def make_request( self, method, path, headers: Optional[Any] = ..., data: str = ..., host: Optional[Any] = ..., auth_path: Optional[Any] = ..., sender: Optional[Any] = ..., override_num_retries: Optional[Any] = ..., params: Optional[Any] = ..., retry_handler: Optional[Any] = ..., ): ... def close(self): ... class AWSQueryConnection(AWSAuthConnection): APIVersion: str ResponseError: Any def __init__( self, aws_access_key_id: Optional[Any] = ..., aws_secret_access_key: Optional[Any] = ..., is_secure: bool = ..., port: Optional[Any] = ..., proxy: Optional[Any] = ..., proxy_port: Optional[Any] = ..., proxy_user: Optional[Any] = ..., proxy_pass: Optional[Any] = ..., host: Optional[Any] = ..., debug: int = ..., https_connection_factory: Optional[Any] = ..., path: str = ..., security_token: Optional[Any] = ..., validate_certs: bool = ..., profile_name: Optional[Any] = ..., provider: str = ..., ) -> None: ... def get_utf8_value(self, value): ... def make_request(self, action, params: Optional[Any] = ..., path: str = ..., verb: str = ..., *args, **kwargs): ... # type: ignore # https://github.com/python/mypy/issues/1237 def build_list_params(self, params, items, label): ... def build_complex_list_params(self, params, items, label, names): ... def get_list(self, action, params, markers, path: str = ..., parent: Optional[Any] = ..., verb: str = ...): ... def get_object(self, action, params, cls, path: str = ..., parent: Optional[Any] = ..., verb: str = ...): ... def get_status(self, action, params, path: str = ..., parent: Optional[Any] = ..., verb: str = ...): ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4383793 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/boto/ec2/0000775000175000017500000000000000000000000024345 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/boto/ec2/__init__.pyi0000664000175000017500000000040000000000000026621 0ustar00davedave00000000000000from typing import Any RegionData: Any def regions(**kw_params): ... def connect_to_region(region_name, **kw_params): ... def get_region(region_name, **kw_params): ... # Explicitly mark this package as incomplete. def __getattr__(name: str) -> Any: ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4383793 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/boto/elb/0000775000175000017500000000000000000000000024436 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/boto/elb/__init__.pyi0000664000175000017500000000510500000000000026721 0ustar00davedave00000000000000from typing import Any from boto.connection import AWSQueryConnection RegionData: Any def regions(): ... def connect_to_region(region_name, **kw_params): ... class ELBConnection(AWSQueryConnection): APIVersion: Any DefaultRegionName: Any DefaultRegionEndpoint: Any region: Any def __init__( self, aws_access_key_id=..., aws_secret_access_key=..., is_secure=..., port=..., proxy=..., proxy_port=..., proxy_user=..., proxy_pass=..., debug=..., https_connection_factory=..., region=..., path=..., security_token=..., validate_certs=..., profile_name=..., ) -> None: ... def build_list_params(self, params, items, label): ... def get_all_load_balancers(self, load_balancer_names=..., marker=...): ... def create_load_balancer( self, name, zones, listeners=..., subnets=..., security_groups=..., scheme=..., complex_listeners=... ): ... def create_load_balancer_listeners(self, name, listeners=..., complex_listeners=...): ... def delete_load_balancer(self, name): ... def delete_load_balancer_listeners(self, name, ports): ... def enable_availability_zones(self, load_balancer_name, zones_to_add): ... def disable_availability_zones(self, load_balancer_name, zones_to_remove): ... def modify_lb_attribute(self, load_balancer_name, attribute, value): ... def get_all_lb_attributes(self, load_balancer_name): ... def get_lb_attribute(self, load_balancer_name, attribute): ... def register_instances(self, load_balancer_name, instances): ... def deregister_instances(self, load_balancer_name, instances): ... def describe_instance_health(self, load_balancer_name, instances=...): ... def configure_health_check(self, name, health_check): ... def set_lb_listener_SSL_certificate(self, lb_name, lb_port, ssl_certificate_id): ... def create_app_cookie_stickiness_policy(self, name, lb_name, policy_name): ... def create_lb_cookie_stickiness_policy(self, cookie_expiration_period, lb_name, policy_name): ... def create_lb_policy(self, lb_name, policy_name, policy_type, policy_attributes): ... def delete_lb_policy(self, lb_name, policy_name): ... def set_lb_policies_of_listener(self, lb_name, lb_port, policies): ... def set_lb_policies_of_backend_server(self, lb_name, instance_port, policies): ... def apply_security_groups_to_lb(self, name, security_groups): ... def attach_lb_to_subnets(self, name, subnets): ... def detach_lb_from_subnets(self, name, subnets): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/boto/exception.pyi0000664000175000017500000001073100000000000026417 0ustar00davedave00000000000000from typing import Any, Optional from boto.compat import StandardError class BotoClientError(StandardError): reason: Any def __init__(self, reason, *args) -> None: ... class SDBPersistenceError(StandardError): ... class StoragePermissionsError(BotoClientError): ... class S3PermissionsError(StoragePermissionsError): ... class GSPermissionsError(StoragePermissionsError): ... class BotoServerError(StandardError): status: Any reason: Any body: Any request_id: Any error_code: Any message: str box_usage: Any def __init__(self, status, reason, body: Optional[Any] = ..., *args) -> None: ... def __getattr__(self, name): ... def __setattr__(self, name, value): ... def startElement(self, name, attrs, connection): ... def endElement(self, name, value, connection): ... class ConsoleOutput: parent: Any instance_id: Any timestamp: Any comment: Any output: Any def __init__(self, parent: Optional[Any] = ...) -> None: ... def startElement(self, name, attrs, connection): ... def endElement(self, name, value, connection): ... class StorageCreateError(BotoServerError): bucket: Any def __init__(self, status, reason, body: Optional[Any] = ...) -> None: ... def endElement(self, name, value, connection): ... class S3CreateError(StorageCreateError): ... class GSCreateError(StorageCreateError): ... class StorageCopyError(BotoServerError): ... class S3CopyError(StorageCopyError): ... class GSCopyError(StorageCopyError): ... class SQSError(BotoServerError): detail: Any type: Any def __init__(self, status, reason, body: Optional[Any] = ...) -> None: ... def startElement(self, name, attrs, connection): ... def endElement(self, name, value, connection): ... class SQSDecodeError(BotoClientError): message: Any def __init__(self, reason, message) -> None: ... class StorageResponseError(BotoServerError): resource: Any def __init__(self, status, reason, body: Optional[Any] = ...) -> None: ... def startElement(self, name, attrs, connection): ... def endElement(self, name, value, connection): ... class S3ResponseError(StorageResponseError): ... class GSResponseError(StorageResponseError): ... class EC2ResponseError(BotoServerError): errors: Any def __init__(self, status, reason, body: Optional[Any] = ...) -> None: ... def startElement(self, name, attrs, connection): ... request_id: Any def endElement(self, name, value, connection): ... class JSONResponseError(BotoServerError): status: Any reason: Any body: Any error_message: Any error_code: Any def __init__(self, status, reason, body: Optional[Any] = ..., *args) -> None: ... class DynamoDBResponseError(JSONResponseError): ... class SWFResponseError(JSONResponseError): ... class EmrResponseError(BotoServerError): ... class _EC2Error: connection: Any error_code: Any error_message: Any def __init__(self, connection: Optional[Any] = ...) -> None: ... def startElement(self, name, attrs, connection): ... def endElement(self, name, value, connection): ... class SDBResponseError(BotoServerError): ... class AWSConnectionError(BotoClientError): ... class StorageDataError(BotoClientError): ... class S3DataError(StorageDataError): ... class GSDataError(StorageDataError): ... class InvalidUriError(Exception): message: Any def __init__(self, message) -> None: ... class InvalidAclError(Exception): message: Any def __init__(self, message) -> None: ... class InvalidCorsError(Exception): message: Any def __init__(self, message) -> None: ... class NoAuthHandlerFound(Exception): ... class InvalidLifecycleConfigError(Exception): message: Any def __init__(self, message) -> None: ... class ResumableTransferDisposition: START_OVER: str WAIT_BEFORE_RETRY: str ABORT_CUR_PROCESS: str ABORT: str class ResumableUploadException(Exception): message: Any disposition: Any def __init__(self, message, disposition) -> None: ... class ResumableDownloadException(Exception): message: Any disposition: Any def __init__(self, message, disposition) -> None: ... class TooManyRecordsException(Exception): message: Any def __init__(self, message) -> None: ... class PleaseRetryException(Exception): message: Any response: Any def __init__(self, message, response: Optional[Any] = ...) -> None: ... class InvalidInstanceMetadataError(Exception): MSG: str def __init__(self, msg) -> None: ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4383793 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/boto/kms/0000775000175000017500000000000000000000000024466 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/boto/kms/__init__.pyi0000664000175000017500000000023500000000000026750 0ustar00davedave00000000000000from typing import List import boto.regioninfo def regions() -> List[boto.regioninfo.RegionInfo]: ... def connect_to_region(region_name, **kw_params): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/boto/kms/exceptions.pyi0000664000175000017500000000147500000000000027401 0ustar00davedave00000000000000from boto.exception import BotoServerError class InvalidGrantTokenException(BotoServerError): ... class DisabledException(BotoServerError): ... class LimitExceededException(BotoServerError): ... class DependencyTimeoutException(BotoServerError): ... class InvalidMarkerException(BotoServerError): ... class AlreadyExistsException(BotoServerError): ... class InvalidCiphertextException(BotoServerError): ... class KeyUnavailableException(BotoServerError): ... class InvalidAliasNameException(BotoServerError): ... class UnsupportedOperationException(BotoServerError): ... class InvalidArnException(BotoServerError): ... class KMSInternalException(BotoServerError): ... class InvalidKeyUsageException(BotoServerError): ... class MalformedPolicyDocumentException(BotoServerError): ... class NotFoundException(BotoServerError): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/boto/kms/layer1.pyi0000664000175000017500000000760400000000000026415 0ustar00davedave00000000000000from typing import Any, Dict, List, Mapping, Optional, Type from boto.connection import AWSQueryConnection class KMSConnection(AWSQueryConnection): APIVersion: str DefaultRegionName: str DefaultRegionEndpoint: str ServiceName: str TargetPrefix: str ResponseError: Type[Exception] region: Any def __init__(self, **kwargs) -> None: ... def create_alias(self, alias_name: str, target_key_id: str) -> Optional[Dict[str, Any]]: ... def create_grant( self, key_id: str, grantee_principal: str, retiring_principal: Optional[str] = ..., operations: Optional[List[str]] = ..., constraints: Optional[Dict[str, Dict[str, str]]] = ..., grant_tokens: Optional[List[str]] = ..., ) -> Optional[Dict[str, Any]]: ... def create_key( self, policy: Optional[str] = ..., description: Optional[str] = ..., key_usage: Optional[str] = ... ) -> Optional[Dict[str, Any]]: ... def decrypt( self, ciphertext_blob: bytes, encryption_context: Optional[Mapping[str, Any]] = ..., grant_tokens: Optional[List[str]] = ..., ) -> Optional[Dict[str, Any]]: ... def delete_alias(self, alias_name: str) -> Optional[Dict[str, Any]]: ... def describe_key(self, key_id: str) -> Optional[Dict[str, Any]]: ... def disable_key(self, key_id: str) -> Optional[Dict[str, Any]]: ... def disable_key_rotation(self, key_id: str) -> Optional[Dict[str, Any]]: ... def enable_key(self, key_id: str) -> Optional[Dict[str, Any]]: ... def enable_key_rotation(self, key_id: str) -> Optional[Dict[str, Any]]: ... def encrypt( self, key_id: str, plaintext: bytes, encryption_context: Optional[Mapping[str, Any]] = ..., grant_tokens: Optional[List[str]] = ..., ) -> Optional[Dict[str, Any]]: ... def generate_data_key( self, key_id: str, encryption_context: Optional[Mapping[str, Any]] = ..., number_of_bytes: Optional[int] = ..., key_spec: Optional[str] = ..., grant_tokens: Optional[List[str]] = ..., ) -> Optional[Dict[str, Any]]: ... def generate_data_key_without_plaintext( self, key_id: str, encryption_context: Optional[Mapping[str, Any]] = ..., key_spec: Optional[str] = ..., number_of_bytes: Optional[int] = ..., grant_tokens: Optional[List[str]] = ..., ) -> Optional[Dict[str, Any]]: ... def generate_random(self, number_of_bytes: Optional[int] = ...) -> Optional[Dict[str, Any]]: ... def get_key_policy(self, key_id: str, policy_name: str) -> Optional[Dict[str, Any]]: ... def get_key_rotation_status(self, key_id: str) -> Optional[Dict[str, Any]]: ... def list_aliases(self, limit: Optional[int] = ..., marker: Optional[str] = ...) -> Optional[Dict[str, Any]]: ... def list_grants(self, key_id: str, limit: Optional[int] = ..., marker: Optional[str] = ...) -> Optional[Dict[str, Any]]: ... def list_key_policies( self, key_id: str, limit: Optional[int] = ..., marker: Optional[str] = ... ) -> Optional[Dict[str, Any]]: ... def list_keys(self, limit: Optional[int] = ..., marker: Optional[str] = ...) -> Optional[Dict[str, Any]]: ... def put_key_policy(self, key_id: str, policy_name: str, policy: str) -> Optional[Dict[str, Any]]: ... def re_encrypt( self, ciphertext_blob: bytes, destination_key_id: str, source_encryption_context: Optional[Mapping[str, Any]] = ..., destination_encryption_context: Optional[Mapping[str, Any]] = ..., grant_tokens: Optional[List[str]] = ..., ) -> Optional[Dict[str, Any]]: ... def retire_grant(self, grant_token: str) -> Optional[Dict[str, Any]]: ... def revoke_grant(self, key_id: str, grant_id: str) -> Optional[Dict[str, Any]]: ... def update_key_description(self, key_id: str, description: str) -> Optional[Dict[str, Any]]: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/boto/plugin.pyi0000664000175000017500000000035300000000000025716 0ustar00davedave00000000000000from typing import Any, Optional class Plugin: capability: Any @classmethod def is_capable(cls, requested_capability): ... def get_plugin(cls, requested_capability: Optional[Any] = ...): ... def load_plugins(config): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/boto/regioninfo.pyi0000664000175000017500000000127500000000000026563 0ustar00davedave00000000000000from typing import Any, Optional def load_endpoint_json(path): ... def merge_endpoints(defaults, additions): ... def load_regions(): ... def get_regions(service_name, region_cls: Optional[Any] = ..., connection_cls: Optional[Any] = ...): ... class RegionInfo: connection: Any name: Any endpoint: Any connection_cls: Any def __init__( self, connection: Optional[Any] = ..., name: Optional[Any] = ..., endpoint: Optional[Any] = ..., connection_cls: Optional[Any] = ..., ) -> None: ... def startElement(self, name, attrs, connection): ... def endElement(self, name, value, connection): ... def connect(self, **kw_params): ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4423795 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/boto/s3/0000775000175000017500000000000000000000000024221 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/boto/s3/__init__.pyi0000664000175000017500000000101300000000000026476 0ustar00davedave00000000000000from typing import List, Optional, Text, Type from boto.connection import AWSAuthConnection from boto.regioninfo import RegionInfo from .connection import S3Connection class S3RegionInfo(RegionInfo): def connect( self, name: Optional[Text] = ..., endpoint: Optional[str] = ..., connection_cls: Optional[Type[AWSAuthConnection]] = ..., **kw_params, ) -> S3Connection: ... def regions() -> List[S3RegionInfo]: ... def connect_to_region(region_name: Text, **kw_params): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/boto/s3/acl.pyi0000664000175000017500000000322600000000000025506 0ustar00davedave00000000000000from typing import Any, Dict, List, Optional, Text, Union from .connection import S3Connection from .user import User CannedACLStrings: List[str] class Policy: parent: Any namespace: Any acl: ACL def __init__(self, parent: Optional[Any] = ...) -> None: ... owner: User def startElement(self, name: Text, attrs: Dict[str, Any], connection: S3Connection) -> Union[None, User, ACL]: ... def endElement(self, name: Text, value: Any, connection: S3Connection) -> None: ... def to_xml(self) -> str: ... class ACL: policy: Policy grants: List[Grant] def __init__(self, policy: Optional[Policy] = ...) -> None: ... def add_grant(self, grant: Grant) -> None: ... def add_email_grant(self, permission: Text, email_address: Text) -> None: ... def add_user_grant(self, permission: Text, user_id: Text, display_name: Optional[Text] = ...) -> None: ... def startElement(self, name, attrs, connection): ... def endElement(self, name: Text, value: Any, connection: S3Connection) -> None: ... def to_xml(self) -> str: ... class Grant: NameSpace: Text permission: Text id: Text display_name: Text uri: Text email_address: Text type: Text def __init__( self, permission: Optional[Text] = ..., type: Optional[Text] = ..., id: Optional[Text] = ..., display_name: Optional[Text] = ..., uri: Optional[Text] = ..., email_address: Optional[Text] = ..., ) -> None: ... def startElement(self, name, attrs, connection): ... def endElement(self, name: Text, value: Any, connection: S3Connection) -> None: ... def to_xml(self) -> str: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/boto/s3/bucket.pyi0000664000175000017500000002105300000000000026222 0ustar00davedave00000000000000from typing import Any, Dict, List, Optional, Text, Type from .bucketlistresultset import BucketListResultSet from .connection import S3Connection from .key import Key class S3WebsiteEndpointTranslate: trans_region: Dict[str, str] @classmethod def translate_region(cls, reg: Text) -> str: ... S3Permissions: List[str] class Bucket: LoggingGroup: str BucketPaymentBody: str VersioningBody: str VersionRE: str MFADeleteRE: str name: Text connection: S3Connection key_class: Type[Key] def __init__( self, connection: Optional[S3Connection] = ..., name: Optional[Text] = ..., key_class: Type[Key] = ... ) -> None: ... def __iter__(self): ... def __contains__(self, key_name) -> bool: ... def startElement(self, name, attrs, connection): ... creation_date: Any def endElement(self, name, value, connection): ... def set_key_class(self, key_class): ... def lookup(self, key_name, headers: Optional[Dict[Text, Text]] = ...): ... def get_key( self, key_name, headers: Optional[Dict[Text, Text]] = ..., version_id: Optional[Any] = ..., response_headers: Optional[Dict[Text, Text]] = ..., validate: bool = ..., ) -> Key: ... def list( self, prefix: Text = ..., delimiter: Text = ..., marker: Text = ..., headers: Optional[Dict[Text, Text]] = ..., encoding_type: Optional[Any] = ..., ) -> BucketListResultSet: ... def list_versions( self, prefix: str = ..., delimiter: str = ..., key_marker: str = ..., version_id_marker: str = ..., headers: Optional[Dict[Text, Text]] = ..., encoding_type: Optional[Text] = ..., ) -> BucketListResultSet: ... def list_multipart_uploads( self, key_marker: str = ..., upload_id_marker: str = ..., headers: Optional[Dict[Text, Text]] = ..., encoding_type: Optional[Any] = ..., ): ... def validate_kwarg_names(self, kwargs, names): ... def get_all_keys(self, headers: Optional[Dict[Text, Text]] = ..., **params): ... def get_all_versions(self, headers: Optional[Dict[Text, Text]] = ..., **params): ... def validate_get_all_versions_params(self, params): ... def get_all_multipart_uploads(self, headers: Optional[Dict[Text, Text]] = ..., **params): ... def new_key(self, key_name: Optional[Any] = ...): ... def generate_url( self, expires_in, method: str = ..., headers: Optional[Dict[Text, Text]] = ..., force_http: bool = ..., response_headers: Optional[Dict[Text, Text]] = ..., expires_in_absolute: bool = ..., ): ... def delete_keys(self, keys, quiet: bool = ..., mfa_token: Optional[Any] = ..., headers: Optional[Dict[Text, Text]] = ...): ... def delete_key( self, key_name, headers: Optional[Dict[Text, Text]] = ..., version_id: Optional[Any] = ..., mfa_token: Optional[Any] = ... ): ... def copy_key( self, new_key_name, src_bucket_name, src_key_name, metadata: Optional[Any] = ..., src_version_id: Optional[Any] = ..., storage_class: str = ..., preserve_acl: bool = ..., encrypt_key: bool = ..., headers: Optional[Dict[Text, Text]] = ..., query_args: Optional[Any] = ..., ): ... def set_canned_acl( self, acl_str, key_name: str = ..., headers: Optional[Dict[Text, Text]] = ..., version_id: Optional[Any] = ... ): ... def get_xml_acl(self, key_name: str = ..., headers: Optional[Dict[Text, Text]] = ..., version_id: Optional[Any] = ...): ... def set_xml_acl( self, acl_str, key_name: str = ..., headers: Optional[Dict[Text, Text]] = ..., version_id: Optional[Any] = ..., query_args: str = ..., ): ... def set_acl( self, acl_or_str, key_name: str = ..., headers: Optional[Dict[Text, Text]] = ..., version_id: Optional[Any] = ... ): ... def get_acl(self, key_name: str = ..., headers: Optional[Dict[Text, Text]] = ..., version_id: Optional[Any] = ...): ... def set_subresource( self, subresource, value, key_name: str = ..., headers: Optional[Dict[Text, Text]] = ..., version_id: Optional[Any] = ... ): ... def get_subresource( self, subresource, key_name: str = ..., headers: Optional[Dict[Text, Text]] = ..., version_id: Optional[Any] = ... ): ... def make_public(self, recursive: bool = ..., headers: Optional[Dict[Text, Text]] = ...): ... def add_email_grant(self, permission, email_address, recursive: bool = ..., headers: Optional[Dict[Text, Text]] = ...): ... def add_user_grant( self, permission, user_id, recursive: bool = ..., headers: Optional[Dict[Text, Text]] = ..., display_name: Optional[Any] = ..., ): ... def list_grants(self, headers: Optional[Dict[Text, Text]] = ...): ... def get_location(self): ... def set_xml_logging(self, logging_str, headers: Optional[Dict[Text, Text]] = ...): ... def enable_logging( self, target_bucket, target_prefix: str = ..., grants: Optional[Any] = ..., headers: Optional[Dict[Text, Text]] = ... ): ... def disable_logging(self, headers: Optional[Dict[Text, Text]] = ...): ... def get_logging_status(self, headers: Optional[Dict[Text, Text]] = ...): ... def set_as_logging_target(self, headers: Optional[Dict[Text, Text]] = ...): ... def get_request_payment(self, headers: Optional[Dict[Text, Text]] = ...): ... def set_request_payment(self, payer: str = ..., headers: Optional[Dict[Text, Text]] = ...): ... def configure_versioning( self, versioning, mfa_delete: bool = ..., mfa_token: Optional[Any] = ..., headers: Optional[Dict[Text, Text]] = ... ): ... def get_versioning_status(self, headers: Optional[Dict[Text, Text]] = ...): ... def configure_lifecycle(self, lifecycle_config, headers: Optional[Dict[Text, Text]] = ...): ... def get_lifecycle_config(self, headers: Optional[Dict[Text, Text]] = ...): ... def delete_lifecycle_configuration(self, headers: Optional[Dict[Text, Text]] = ...): ... def configure_website( self, suffix: Optional[Any] = ..., error_key: Optional[Any] = ..., redirect_all_requests_to: Optional[Any] = ..., routing_rules: Optional[Any] = ..., headers: Optional[Dict[Text, Text]] = ..., ): ... def set_website_configuration(self, config, headers: Optional[Dict[Text, Text]] = ...): ... def set_website_configuration_xml(self, xml, headers: Optional[Dict[Text, Text]] = ...): ... def get_website_configuration(self, headers: Optional[Dict[Text, Text]] = ...): ... def get_website_configuration_obj(self, headers: Optional[Dict[Text, Text]] = ...): ... def get_website_configuration_with_xml(self, headers: Optional[Dict[Text, Text]] = ...): ... def get_website_configuration_xml(self, headers: Optional[Dict[Text, Text]] = ...): ... def delete_website_configuration(self, headers: Optional[Dict[Text, Text]] = ...): ... def get_website_endpoint(self): ... def get_policy(self, headers: Optional[Dict[Text, Text]] = ...): ... def set_policy(self, policy, headers: Optional[Dict[Text, Text]] = ...): ... def delete_policy(self, headers: Optional[Dict[Text, Text]] = ...): ... def set_cors_xml(self, cors_xml, headers: Optional[Dict[Text, Text]] = ...): ... def set_cors(self, cors_config, headers: Optional[Dict[Text, Text]] = ...): ... def get_cors_xml(self, headers: Optional[Dict[Text, Text]] = ...): ... def get_cors(self, headers: Optional[Dict[Text, Text]] = ...): ... def delete_cors(self, headers: Optional[Dict[Text, Text]] = ...): ... def initiate_multipart_upload( self, key_name, headers: Optional[Dict[Text, Text]] = ..., reduced_redundancy: bool = ..., metadata: Optional[Any] = ..., encrypt_key: bool = ..., policy: Optional[Any] = ..., ): ... def complete_multipart_upload(self, key_name, upload_id, xml_body, headers: Optional[Dict[Text, Text]] = ...): ... def cancel_multipart_upload(self, key_name, upload_id, headers: Optional[Dict[Text, Text]] = ...): ... def delete(self, headers: Optional[Dict[Text, Text]] = ...): ... def get_tags(self): ... def get_xml_tags(self): ... def set_xml_tags(self, tag_str, headers: Optional[Dict[Text, Text]] = ..., query_args: str = ...): ... def set_tags(self, tags, headers: Optional[Dict[Text, Text]] = ...): ... def delete_tags(self, headers: Optional[Dict[Text, Text]] = ...): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/boto/s3/bucketlistresultset.pyi0000664000175000017500000000375500000000000031102 0ustar00davedave00000000000000from typing import Any, Iterable, Iterator, Optional from .key import Key def bucket_lister( bucket, prefix: str = ..., delimiter: str = ..., marker: str = ..., headers: Optional[Any] = ..., encoding_type: Optional[Any] = ..., ): ... class BucketListResultSet(Iterable[Key]): bucket: Any prefix: Any delimiter: Any marker: Any headers: Any encoding_type: Any def __init__( self, bucket: Optional[Any] = ..., prefix: str = ..., delimiter: str = ..., marker: str = ..., headers: Optional[Any] = ..., encoding_type: Optional[Any] = ..., ) -> None: ... def __iter__(self) -> Iterator[Key]: ... def versioned_bucket_lister( bucket, prefix: str = ..., delimiter: str = ..., key_marker: str = ..., version_id_marker: str = ..., headers: Optional[Any] = ..., encoding_type: Optional[Any] = ..., ): ... class VersionedBucketListResultSet: bucket: Any prefix: Any delimiter: Any key_marker: Any version_id_marker: Any headers: Any encoding_type: Any def __init__( self, bucket: Optional[Any] = ..., prefix: str = ..., delimiter: str = ..., key_marker: str = ..., version_id_marker: str = ..., headers: Optional[Any] = ..., encoding_type: Optional[Any] = ..., ) -> None: ... def __iter__(self) -> Iterator[Key]: ... def multipart_upload_lister( bucket, key_marker: str = ..., upload_id_marker: str = ..., headers: Optional[Any] = ..., encoding_type: Optional[Any] = ... ): ... class MultiPartUploadListResultSet: bucket: Any key_marker: Any upload_id_marker: Any headers: Any encoding_type: Any def __init__( self, bucket: Optional[Any] = ..., key_marker: str = ..., upload_id_marker: str = ..., headers: Optional[Any] = ..., encoding_type: Optional[Any] = ..., ) -> None: ... def __iter__(self): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/boto/s3/bucketlogging.pyi0000664000175000017500000000062000000000000027566 0ustar00davedave00000000000000from typing import Any, Optional class BucketLogging: target: Any prefix: Any grants: Any def __init__(self, target: Optional[Any] = ..., prefix: Optional[Any] = ..., grants: Optional[Any] = ...) -> None: ... def add_grant(self, grant): ... def startElement(self, name, attrs, connection): ... def endElement(self, name, value, connection): ... def to_xml(self): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/boto/s3/connection.pyi0000664000175000017500000001133500000000000027106 0ustar00davedave00000000000000from typing import Any, Dict, Optional, Text, Type from boto.connection import AWSAuthConnection from boto.exception import BotoClientError from .bucket import Bucket def check_lowercase_bucketname(n): ... def assert_case_insensitive(f): ... class _CallingFormat: def get_bucket_server(self, server, bucket): ... def build_url_base(self, connection, protocol, server, bucket, key: str = ...): ... def build_host(self, server, bucket): ... def build_auth_path(self, bucket, key: str = ...): ... def build_path_base(self, bucket, key: str = ...): ... class SubdomainCallingFormat(_CallingFormat): def get_bucket_server(self, server, bucket): ... class VHostCallingFormat(_CallingFormat): def get_bucket_server(self, server, bucket): ... class OrdinaryCallingFormat(_CallingFormat): def get_bucket_server(self, server, bucket): ... def build_path_base(self, bucket, key: str = ...): ... class ProtocolIndependentOrdinaryCallingFormat(OrdinaryCallingFormat): def build_url_base(self, connection, protocol, server, bucket, key: str = ...): ... class Location: DEFAULT: str EU: str EUCentral1: str USWest: str USWest2: str SAEast: str APNortheast: str APSoutheast: str APSoutheast2: str CNNorth1: str class NoHostProvided: ... class HostRequiredError(BotoClientError): ... class S3Connection(AWSAuthConnection): DefaultHost: Any DefaultCallingFormat: Any QueryString: str calling_format: Any bucket_class: Type[Bucket] anon: Any def __init__( self, aws_access_key_id: Optional[Any] = ..., aws_secret_access_key: Optional[Any] = ..., is_secure: bool = ..., port: Optional[Any] = ..., proxy: Optional[Any] = ..., proxy_port: Optional[Any] = ..., proxy_user: Optional[Any] = ..., proxy_pass: Optional[Any] = ..., host: Any = ..., debug: int = ..., https_connection_factory: Optional[Any] = ..., calling_format: Any = ..., path: str = ..., provider: str = ..., bucket_class: Type[Bucket] = ..., security_token: Optional[Any] = ..., suppress_consec_slashes: bool = ..., anon: bool = ..., validate_certs: Optional[Any] = ..., profile_name: Optional[Any] = ..., ) -> None: ... def __iter__(self): ... def __contains__(self, bucket_name): ... def set_bucket_class(self, bucket_class: Type[Bucket]) -> None: ... def build_post_policy(self, expiration_time, conditions): ... def build_post_form_args( self, bucket_name, key, expires_in: int = ..., acl: Optional[Any] = ..., success_action_redirect: Optional[Any] = ..., max_content_length: Optional[Any] = ..., http_method: str = ..., fields: Optional[Any] = ..., conditions: Optional[Any] = ..., storage_class: str = ..., server_side_encryption: Optional[Any] = ..., ): ... def generate_url_sigv4( self, expires_in, method, bucket: str = ..., key: str = ..., headers: Optional[Dict[Text, Text]] = ..., force_http: bool = ..., response_headers: Optional[Dict[Text, Text]] = ..., version_id: Optional[Any] = ..., iso_date: Optional[Any] = ..., ): ... def generate_url( self, expires_in, method, bucket: str = ..., key: str = ..., headers: Optional[Dict[Text, Text]] = ..., query_auth: bool = ..., force_http: bool = ..., response_headers: Optional[Dict[Text, Text]] = ..., expires_in_absolute: bool = ..., version_id: Optional[Any] = ..., ): ... def get_all_buckets(self, headers: Optional[Dict[Text, Text]] = ...): ... def get_canonical_user_id(self, headers: Optional[Dict[Text, Text]] = ...): ... def get_bucket(self, bucket_name: Text, validate: bool = ..., headers: Optional[Dict[Text, Text]] = ...) -> Bucket: ... def head_bucket(self, bucket_name, headers: Optional[Dict[Text, Text]] = ...): ... def lookup(self, bucket_name, validate: bool = ..., headers: Optional[Dict[Text, Text]] = ...): ... def create_bucket( self, bucket_name, headers: Optional[Dict[Text, Text]] = ..., location: Any = ..., policy: Optional[Any] = ... ): ... def delete_bucket(self, bucket, headers: Optional[Dict[Text, Text]] = ...): ... def make_request(self, method, bucket: str = ..., key: str = ..., headers: Optional[Any] = ..., data: str = ..., query_args: Optional[Any] = ..., sender: Optional[Any] = ..., override_num_retries: Optional[Any] = ..., retry_handler: Optional[Any] = ..., *args, **kwargs): ... # type: ignore # https://github.com/python/mypy/issues/1237 ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/boto/s3/cors.pyi0000664000175000017500000000210000000000000025703 0ustar00davedave00000000000000from typing import Any, List, Optional class CORSRule: allowed_method: Any allowed_origin: Any id: Any allowed_header: Any max_age_seconds: Any expose_header: Any def __init__( self, allowed_method: Optional[Any] = ..., allowed_origin: Optional[Any] = ..., id: Optional[Any] = ..., allowed_header: Optional[Any] = ..., max_age_seconds: Optional[Any] = ..., expose_header: Optional[Any] = ..., ) -> None: ... def startElement(self, name, attrs, connection): ... def endElement(self, name, value, connection): ... def to_xml(self) -> str: ... class CORSConfiguration(List[CORSRule]): def startElement(self, name, attrs, connection): ... def endElement(self, name, value, connection): ... def to_xml(self) -> str: ... def add_rule( self, allowed_method, allowed_origin, id: Optional[Any] = ..., allowed_header: Optional[Any] = ..., max_age_seconds: Optional[Any] = ..., expose_header: Optional[Any] = ..., ): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/boto/s3/deletemarker.pyi0000664000175000017500000000055600000000000027416 0ustar00davedave00000000000000from typing import Any, Optional class DeleteMarker: bucket: Any name: Any version_id: Any is_latest: bool last_modified: Any owner: Any def __init__(self, bucket: Optional[Any] = ..., name: Optional[Any] = ...) -> None: ... def startElement(self, name, attrs, connection): ... def endElement(self, name, value, connection): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/boto/s3/key.pyi0000664000175000017500000002017500000000000025541 0ustar00davedave00000000000000from typing import Any, Callable, Dict, Optional, Text, Union, overload class Key: DefaultContentType: str RestoreBody: str BufferSize: Any base_user_settable_fields: Any base_fields: Any bucket: Any name: str metadata: Any cache_control: Any content_type: Any content_encoding: Any content_disposition: Any content_language: Any filename: Any etag: Any is_latest: bool last_modified: Any owner: Any path: Any resp: Any mode: Any size: Any version_id: Any source_version_id: Any delete_marker: bool encrypted: Any ongoing_restore: Any expiry_date: Any local_hashes: Any def __init__(self, bucket: Optional[Any] = ..., name: Optional[Any] = ...) -> None: ... def __iter__(self): ... @property def provider(self): ... key: Any md5: Any base64md5: Any storage_class: Any def get_md5_from_hexdigest(self, md5_hexdigest): ... def handle_encryption_headers(self, resp): ... def handle_version_headers(self, resp, force: bool = ...): ... def handle_restore_headers(self, response): ... def handle_addl_headers(self, headers): ... def open_read( self, headers: Optional[Dict[Text, Text]] = ..., query_args: str = ..., override_num_retries: Optional[Any] = ..., response_headers: Optional[Dict[Text, Text]] = ..., ): ... def open_write(self, headers: Optional[Dict[Text, Text]] = ..., override_num_retries: Optional[Any] = ...): ... def open( self, mode: str = ..., headers: Optional[Dict[Text, Text]] = ..., query_args: Optional[Any] = ..., override_num_retries: Optional[Any] = ..., ): ... closed: bool def close(self, fast: bool = ...): ... def next(self): ... __next__: Any def read(self, size: int = ...): ... def change_storage_class(self, new_storage_class, dst_bucket: Optional[Any] = ..., validate_dst_bucket: bool = ...): ... def copy( self, dst_bucket, dst_key, metadata: Optional[Any] = ..., reduced_redundancy: bool = ..., preserve_acl: bool = ..., encrypt_key: bool = ..., validate_dst_bucket: bool = ..., ): ... def startElement(self, name, attrs, connection): ... def endElement(self, name, value, connection): ... def exists(self, headers: Optional[Dict[Text, Text]] = ...): ... def delete(self, headers: Optional[Dict[Text, Text]] = ...): ... def get_metadata(self, name): ... def set_metadata(self, name, value): ... def update_metadata(self, d): ... def set_acl(self, acl_str, headers: Optional[Dict[Text, Text]] = ...): ... def get_acl(self, headers: Optional[Dict[Text, Text]] = ...): ... def get_xml_acl(self, headers: Optional[Dict[Text, Text]] = ...): ... def set_xml_acl(self, acl_str, headers: Optional[Dict[Text, Text]] = ...): ... def set_canned_acl(self, acl_str, headers: Optional[Dict[Text, Text]] = ...): ... def get_redirect(self): ... def set_redirect(self, redirect_location, headers: Optional[Dict[Text, Text]] = ...): ... def make_public(self, headers: Optional[Dict[Text, Text]] = ...): ... def generate_url( self, expires_in, method: str = ..., headers: Optional[Dict[Text, Text]] = ..., query_auth: bool = ..., force_http: bool = ..., response_headers: Optional[Dict[Text, Text]] = ..., expires_in_absolute: bool = ..., version_id: Optional[Any] = ..., policy: Optional[Any] = ..., reduced_redundancy: bool = ..., encrypt_key: bool = ..., ): ... def send_file( self, fp, headers: Optional[Dict[Text, Text]] = ..., cb: Optional[Callable[[int, int], Any]] = ..., num_cb: int = ..., query_args: Optional[Any] = ..., chunked_transfer: bool = ..., size: Optional[Any] = ..., ): ... def should_retry(self, response, chunked_transfer: bool = ...): ... def compute_md5(self, fp, size: Optional[Any] = ...): ... def set_contents_from_stream( self, fp, headers: Optional[Dict[Text, Text]] = ..., replace: bool = ..., cb: Optional[Callable[[int, int], Any]] = ..., num_cb: int = ..., policy: Optional[Any] = ..., reduced_redundancy: bool = ..., query_args: Optional[Any] = ..., size: Optional[Any] = ..., ): ... def set_contents_from_file( self, fp, headers: Optional[Dict[Text, Text]] = ..., replace: bool = ..., cb: Optional[Callable[[int, int], Any]] = ..., num_cb: int = ..., policy: Optional[Any] = ..., md5: Optional[Any] = ..., reduced_redundancy: bool = ..., query_args: Optional[Any] = ..., encrypt_key: bool = ..., size: Optional[Any] = ..., rewind: bool = ..., ): ... def set_contents_from_filename( self, filename, headers: Optional[Dict[Text, Text]] = ..., replace: bool = ..., cb: Optional[Callable[[int, int], Any]] = ..., num_cb: int = ..., policy: Optional[Any] = ..., md5: Optional[Any] = ..., reduced_redundancy: bool = ..., encrypt_key: bool = ..., ): ... def set_contents_from_string( self, string_data: Union[Text, bytes], headers: Optional[Dict[Text, Text]] = ..., replace: bool = ..., cb: Optional[Callable[[int, int], Any]] = ..., num_cb: int = ..., policy: Optional[Any] = ..., md5: Optional[Any] = ..., reduced_redundancy: bool = ..., encrypt_key: bool = ..., ) -> None: ... def get_file( self, fp, headers: Optional[Dict[Text, Text]] = ..., cb: Optional[Callable[[int, int], Any]] = ..., num_cb: int = ..., torrent: bool = ..., version_id: Optional[Any] = ..., override_num_retries: Optional[Any] = ..., response_headers: Optional[Dict[Text, Text]] = ..., ): ... def get_torrent_file( self, fp, headers: Optional[Dict[Text, Text]] = ..., cb: Optional[Callable[[int, int], Any]] = ..., num_cb: int = ... ): ... def get_contents_to_file( self, fp, headers: Optional[Dict[Text, Text]] = ..., cb: Optional[Callable[[int, int], Any]] = ..., num_cb: int = ..., torrent: bool = ..., version_id: Optional[Any] = ..., res_download_handler: Optional[Any] = ..., response_headers: Optional[Dict[Text, Text]] = ..., ): ... def get_contents_to_filename( self, filename, headers: Optional[Dict[Text, Text]] = ..., cb: Optional[Callable[[int, int], Any]] = ..., num_cb: int = ..., torrent: bool = ..., version_id: Optional[Any] = ..., res_download_handler: Optional[Any] = ..., response_headers: Optional[Dict[Text, Text]] = ..., ): ... @overload def get_contents_as_string( self, headers: Optional[Dict[Text, Text]] = ..., cb: Optional[Callable[[int, int], Any]] = ..., num_cb: int = ..., torrent: bool = ..., version_id: Optional[Any] = ..., response_headers: Optional[Dict[Text, Text]] = ..., encoding: None = ..., ) -> bytes: ... @overload def get_contents_as_string( self, headers: Optional[Dict[Text, Text]] = ..., cb: Optional[Callable[[int, int], Any]] = ..., num_cb: int = ..., torrent: bool = ..., version_id: Optional[Any] = ..., response_headers: Optional[Dict[Text, Text]] = ..., *, encoding: Text, ) -> Text: ... def add_email_grant(self, permission, email_address, headers: Optional[Dict[Text, Text]] = ...): ... def add_user_grant( self, permission, user_id, headers: Optional[Dict[Text, Text]] = ..., display_name: Optional[Any] = ... ): ... def set_remote_metadata(self, metadata_plus, metadata_minus, preserve_acl, headers: Optional[Dict[Text, Text]] = ...): ... def restore(self, days, headers: Optional[Dict[Text, Text]] = ...): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/boto/s3/keyfile.pyi0000664000175000017500000000125400000000000026376 0ustar00davedave00000000000000from typing import Any class KeyFile: key: Any location: int closed: bool softspace: int mode: str encoding: str errors: str newlines: str name: Any def __init__(self, key) -> None: ... def tell(self): ... def seek(self, pos, whence: Any = ...): ... def read(self, size): ... def close(self): ... def isatty(self): ... def getkey(self): ... def write(self, buf): ... def fileno(self): ... def flush(self): ... def next(self): ... def readinto(self): ... def readline(self): ... def readlines(self): ... def truncate(self): ... def writelines(self): ... def xreadlines(self): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/boto/s3/lifecycle.pyi0000664000175000017500000000370000000000000026703 0ustar00davedave00000000000000from typing import Any, List, Optional class Rule: id: Any prefix: Any status: Any expiration: Any transition: Any def __init__( self, id: Optional[Any] = ..., prefix: Optional[Any] = ..., status: Optional[Any] = ..., expiration: Optional[Any] = ..., transition: Optional[Any] = ..., ) -> None: ... def startElement(self, name, attrs, connection): ... def endElement(self, name, value, connection): ... def to_xml(self): ... class Expiration: days: Any date: Any def __init__(self, days: Optional[Any] = ..., date: Optional[Any] = ...) -> None: ... def startElement(self, name, attrs, connection): ... def endElement(self, name, value, connection): ... def to_xml(self): ... class Transition: days: Any date: Any storage_class: Any def __init__(self, days: Optional[Any] = ..., date: Optional[Any] = ..., storage_class: Optional[Any] = ...) -> None: ... def to_xml(self): ... class Transitions(List[Transition]): transition_properties: int current_transition_property: int temp_days: Any temp_date: Any temp_storage_class: Any def __init__(self) -> None: ... def startElement(self, name, attrs, connection): ... def endElement(self, name, value, connection): ... def to_xml(self): ... def add_transition(self, days: Optional[Any] = ..., date: Optional[Any] = ..., storage_class: Optional[Any] = ...): ... @property def days(self): ... @property def date(self): ... @property def storage_class(self): ... class Lifecycle(List[Rule]): def startElement(self, name, attrs, connection): ... def endElement(self, name, value, connection): ... def to_xml(self): ... def add_rule( self, id: Optional[Any] = ..., prefix: str = ..., status: str = ..., expiration: Optional[Any] = ..., transition: Optional[Any] = ..., ): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/boto/s3/multidelete.pyi0000664000175000017500000000206300000000000027262 0ustar00davedave00000000000000from typing import Any, Optional class Deleted: key: Any version_id: Any delete_marker: Any delete_marker_version_id: Any def __init__( self, key: Optional[Any] = ..., version_id: Optional[Any] = ..., delete_marker: bool = ..., delete_marker_version_id: Optional[Any] = ..., ) -> None: ... def startElement(self, name, attrs, connection): ... def endElement(self, name, value, connection): ... class Error: key: Any version_id: Any code: Any message: Any def __init__( self, key: Optional[Any] = ..., version_id: Optional[Any] = ..., code: Optional[Any] = ..., message: Optional[Any] = ... ) -> None: ... def startElement(self, name, attrs, connection): ... def endElement(self, name, value, connection): ... class MultiDeleteResult: bucket: Any deleted: Any errors: Any def __init__(self, bucket: Optional[Any] = ...) -> None: ... def startElement(self, name, attrs, connection): ... def endElement(self, name, value, connection): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/boto/s3/multipart.pyi0000664000175000017500000000371500000000000026773 0ustar00davedave00000000000000from typing import Any, Optional class CompleteMultiPartUpload: bucket: Any location: Any bucket_name: Any key_name: Any etag: Any version_id: Any encrypted: Any def __init__(self, bucket: Optional[Any] = ...) -> None: ... def startElement(self, name, attrs, connection): ... def endElement(self, name, value, connection): ... class Part: bucket: Any part_number: Any last_modified: Any etag: Any size: Any def __init__(self, bucket: Optional[Any] = ...) -> None: ... def startElement(self, name, attrs, connection): ... def endElement(self, name, value, connection): ... def part_lister(mpupload, part_number_marker: Optional[Any] = ...): ... class MultiPartUpload: bucket: Any bucket_name: Any key_name: Any id: Any initiator: Any owner: Any storage_class: Any initiated: Any part_number_marker: Any next_part_number_marker: Any max_parts: Any is_truncated: bool def __init__(self, bucket: Optional[Any] = ...) -> None: ... def __iter__(self): ... def to_xml(self): ... def startElement(self, name, attrs, connection): ... def endElement(self, name, value, connection): ... def get_all_parts( self, max_parts: Optional[Any] = ..., part_number_marker: Optional[Any] = ..., encoding_type: Optional[Any] = ... ): ... def upload_part_from_file( self, fp, part_num, headers: Optional[Any] = ..., replace: bool = ..., cb: Optional[Any] = ..., num_cb: int = ..., md5: Optional[Any] = ..., size: Optional[Any] = ..., ): ... def copy_part_from_key( self, src_bucket_name, src_key_name, part_num, start: Optional[Any] = ..., end: Optional[Any] = ..., src_version_id: Optional[Any] = ..., headers: Optional[Any] = ..., ): ... def complete_upload(self): ... def cancel_upload(self): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/boto/s3/prefix.pyi0000664000175000017500000000050400000000000026240 0ustar00davedave00000000000000from typing import Any, Optional class Prefix: bucket: Any name: Any def __init__(self, bucket: Optional[Any] = ..., name: Optional[Any] = ...) -> None: ... def startElement(self, name, attrs, connection): ... def endElement(self, name, value, connection): ... @property def provider(self): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/boto/s3/tagging.pyi0000664000175000017500000000135400000000000026367 0ustar00davedave00000000000000from typing import Any, List, Optional class Tag: key: Any value: Any def __init__(self, key: Optional[Any] = ..., value: Optional[Any] = ...) -> None: ... def startElement(self, name, attrs, connection): ... def endElement(self, name, value, connection): ... def to_xml(self): ... def __eq__(self, other): ... class TagSet(List[Tag]): def startElement(self, name, attrs, connection): ... def endElement(self, name, value, connection): ... def add_tag(self, key, value): ... def to_xml(self): ... class Tags(List[TagSet]): def startElement(self, name, attrs, connection): ... def endElement(self, name, value, connection): ... def to_xml(self): ... def add_tag_set(self, tag_set): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/boto/s3/user.pyi0000664000175000017500000000055200000000000025724 0ustar00davedave00000000000000from typing import Any, Optional class User: type: Any id: Any display_name: Any def __init__(self, parent: Optional[Any] = ..., id: str = ..., display_name: str = ...) -> None: ... def startElement(self, name, attrs, connection): ... def endElement(self, name, value, connection): ... def to_xml(self, element_name: str = ...): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/boto/s3/website.pyi0000664000175000017500000000513100000000000026406 0ustar00davedave00000000000000from typing import Any, List, Optional def tag(key, value): ... class WebsiteConfiguration: suffix: Any error_key: Any redirect_all_requests_to: Any routing_rules: Any def __init__( self, suffix: Optional[Any] = ..., error_key: Optional[Any] = ..., redirect_all_requests_to: Optional[Any] = ..., routing_rules: Optional[Any] = ..., ) -> None: ... def startElement(self, name, attrs, connection): ... def endElement(self, name, value, connection): ... def to_xml(self): ... class _XMLKeyValue: translator: Any container: Any def __init__(self, translator, container: Optional[Any] = ...) -> None: ... def startElement(self, name, attrs, connection): ... def endElement(self, name, value, connection): ... def to_xml(self): ... class RedirectLocation(_XMLKeyValue): TRANSLATOR: Any hostname: Any protocol: Any def __init__(self, hostname: Optional[Any] = ..., protocol: Optional[Any] = ...) -> None: ... def to_xml(self): ... class RoutingRules(List[RoutingRule]): def add_rule(self, rule: RoutingRule) -> RoutingRules: ... def startElement(self, name, attrs, connection): ... def endElement(self, name, value, connection): ... def to_xml(self): ... class RoutingRule: condition: Any redirect: Any def __init__(self, condition: Optional[Any] = ..., redirect: Optional[Any] = ...) -> None: ... def startElement(self, name, attrs, connection): ... def endElement(self, name, value, connection): ... def to_xml(self): ... @classmethod def when(cls, key_prefix: Optional[Any] = ..., http_error_code: Optional[Any] = ...): ... def then_redirect( self, hostname: Optional[Any] = ..., protocol: Optional[Any] = ..., replace_key: Optional[Any] = ..., replace_key_prefix: Optional[Any] = ..., http_redirect_code: Optional[Any] = ..., ): ... class Condition(_XMLKeyValue): TRANSLATOR: Any key_prefix: Any http_error_code: Any def __init__(self, key_prefix: Optional[Any] = ..., http_error_code: Optional[Any] = ...) -> None: ... def to_xml(self): ... class Redirect(_XMLKeyValue): TRANSLATOR: Any hostname: Any protocol: Any replace_key: Any replace_key_prefix: Any http_redirect_code: Any def __init__( self, hostname: Optional[Any] = ..., protocol: Optional[Any] = ..., replace_key: Optional[Any] = ..., replace_key_prefix: Optional[Any] = ..., http_redirect_code: Optional[Any] = ..., ) -> None: ... def to_xml(self): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/boto/utils.pyi0000664000175000017500000001336400000000000025566 0ustar00davedave00000000000000import datetime import logging.handlers import subprocess import sys import time from typing import ( IO, Any, Callable, ContextManager, Dict, Iterable, List, Mapping, Optional, Sequence, Tuple, Type, TypeVar, Union, ) import boto.connection _KT = TypeVar("_KT") _VT = TypeVar("_VT") if sys.version_info >= (3,): # TODO move _StringIO definition into boto.compat once stubs exist and rename to StringIO import io _StringIO = io.StringIO from hashlib import _Hash _HashType = _Hash from email.message import Message as _Message else: # TODO move _StringIO definition into boto.compat once stubs exist and rename to StringIO import StringIO _StringIO = StringIO.StringIO[Any] from hashlib import _hash _HashType = _hash # TODO use email.message.Message once stubs exist _Message = Any _Provider = Any # TODO replace this with boto.provider.Provider once stubs exist _LockType = Any # TODO replace this with _thread.LockType once stubs exist JSONDecodeError: Type[ValueError] qsa_of_interest: List[str] def unquote_v(nv: str) -> Union[str, Tuple[str, str]]: ... def canonical_string( method: str, path: str, headers: Mapping[str, Optional[str]], expires: Optional[int] = ..., provider: Optional[_Provider] = ..., ) -> str: ... def merge_meta( headers: Mapping[str, str], metadata: Mapping[str, str], provider: Optional[_Provider] = ... ) -> Mapping[str, str]: ... def get_aws_metadata(headers: Mapping[str, str], provider: Optional[_Provider] = ...) -> Mapping[str, str]: ... def retry_url(url: str, retry_on_404: bool = ..., num_retries: int = ..., timeout: Optional[int] = ...) -> str: ... class LazyLoadMetadata(Dict[_KT, _VT]): def __init__(self, url: str, num_retries: int, timeout: Optional[int] = ...) -> None: ... def get_instance_metadata( version: str = ..., url: str = ..., data: str = ..., timeout: Optional[int] = ..., num_retries: int = ... ) -> Optional[LazyLoadMetadata[Any, Any]]: ... def get_instance_identity( version: str = ..., url: str = ..., timeout: Optional[int] = ..., num_retries: int = ... ) -> Optional[Mapping[str, Any]]: ... def get_instance_userdata( version: str = ..., sep: Optional[str] = ..., url: str = ..., timeout: Optional[int] = ..., num_retries: int = ... ) -> Mapping[str, str]: ... ISO8601: str ISO8601_MS: str RFC1123: str LOCALE_LOCK: _LockType def setlocale(name: Union[str, Tuple[str, str]]) -> ContextManager[str]: ... def get_ts(ts: Optional[time.struct_time] = ...) -> str: ... def parse_ts(ts: str) -> datetime.datetime: ... def find_class(module_name: str, class_name: Optional[str] = ...) -> Optional[Type[Any]]: ... def update_dme(username: str, password: str, dme_id: str, ip_address: str) -> str: ... def fetch_file( uri: str, file: Optional[IO[str]] = ..., username: Optional[str] = ..., password: Optional[str] = ... ) -> Optional[IO[str]]: ... class ShellCommand: exit_code: int command: subprocess._CMD log_fp: _StringIO wait: bool fail_fast: bool def __init__( self, command: subprocess._CMD, wait: bool = ..., fail_fast: bool = ..., cwd: Optional[subprocess._TXT] = ... ) -> None: ... process: subprocess.Popen[Any] def run(self, cwd: Optional[subprocess._CMD] = ...) -> Optional[int]: ... def setReadOnly(self, value) -> None: ... def getStatus(self) -> Optional[int]: ... status: Optional[int] def getOutput(self) -> str: ... output: str class AuthSMTPHandler(logging.handlers.SMTPHandler): username: str password: str def __init__( self, mailhost: str, username: str, password: str, fromaddr: str, toaddrs: Sequence[str], subject: str ) -> None: ... class LRUCache(Dict[_KT, _VT]): class _Item: previous: Optional[LRUCache._Item] next: Optional[LRUCache._Item] key = ... value = ... def __init__(self, key, value) -> None: ... _dict: Dict[_KT, LRUCache._Item] capacity: int head: Optional[LRUCache._Item] tail: Optional[LRUCache._Item] def __init__(self, capacity: int) -> None: ... # This exists to work around Password.str's name shadowing the str type _str = str class Password: hashfunc: Callable[[bytes], _HashType] str: Optional[_str] def __init__(self, str: Optional[_str] = ..., hashfunc: Optional[Callable[[bytes], _HashType]] = ...) -> None: ... def set(self, value: Union[bytes, _str]) -> None: ... def __eq__(self, other: Any) -> bool: ... def __len__(self) -> int: ... def notify( subject: str, body: Optional[str] = ..., html_body: Optional[Union[Sequence[str], str]] = ..., to_string: Optional[str] = ..., attachments: Optional[Iterable[_Message]] = ..., append_instance_id: bool = ..., ) -> None: ... def get_utf8_value(value: str) -> bytes: ... def mklist(value: Any) -> List[Any]: ... def pythonize_name(name: str) -> str: ... def write_mime_multipart( content: List[Tuple[str, str]], compress: bool = ..., deftype: str = ..., delimiter: str = ... ) -> str: ... def guess_mime_type(content: str, deftype: str) -> str: ... def compute_md5(fp: IO[Any], buf_size: int = ..., size: Optional[int] = ...) -> Tuple[str, str, int]: ... def compute_hash( fp: IO[Any], buf_size: int = ..., size: Optional[int] = ..., hash_algorithm: Any = ... ) -> Tuple[str, str, int]: ... def find_matching_headers(name: str, headers: Mapping[str, Optional[str]]) -> List[str]: ... def merge_headers_by_name(name: str, headers: Mapping[str, Optional[str]]) -> str: ... class RequestHook: def handle_request_data( self, request: boto.connection.HTTPRequest, response: boto.connection.HTTPResponse, error: bool = ... ) -> Any: ... def host_is_ipv6(hostname: str) -> bool: ... def parse_host(hostname: str) -> str: ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4423795 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/cachetools/0000775000175000017500000000000000000000000025055 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/cachetools/__init__.pyi0000664000175000017500000000037600000000000027345 0ustar00davedave00000000000000from .cache import Cache as Cache from .decorators import cached as cached, cachedmethod as cachedmethod from .lfu import LFUCache as LFUCache from .lru import LRUCache as LRUCache from .rr import RRCache as RRCache from .ttl import TTLCache as TTLCache ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/cachetools/abc.pyi0000664000175000017500000000026600000000000026331 0ustar00davedave00000000000000from abc import ABCMeta from typing import MutableMapping, TypeVar _KT = TypeVar("_KT") _VT = TypeVar("_VT") class DefaultMapping(MutableMapping[_KT, _VT], metaclass=ABCMeta): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/cachetools/cache.pyi0000664000175000017500000000131000000000000026636 0ustar00davedave00000000000000from typing import Callable, Generic, Iterator, Optional, TypeVar from .abc import DefaultMapping as DefaultMapping _KT = TypeVar("_KT") _VT = TypeVar("_VT") class Cache(DefaultMapping[_KT, _VT], Generic[_KT, _VT]): def __init__(self, maxsize: int, getsizeof: Optional[Callable[[_VT], int]] = ...) -> None: ... def __getitem__(self, key: _KT) -> _VT: ... def __setitem__(self, key: _KT, value: _VT) -> None: ... def __delitem__(self, key: _KT) -> None: ... def __iter__(self) -> Iterator[_KT]: ... def __len__(self) -> int: ... @property def maxsize(self) -> int: ... @property def currsize(self) -> int: ... @staticmethod def getsizeof(value: _VT) -> int: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/cachetools/decorators.pyi0000664000175000017500000000113500000000000027745 0ustar00davedave00000000000000from typing import Any, Callable, ContextManager, MutableMapping, Optional, TypeVar _KT = TypeVar("_KT") _VT = TypeVar("_VT") _T = TypeVar("_T", bound=Callable[..., Any]) _T_co = TypeVar("_T_co", covariant=True) _T_self = TypeVar("_T_self") def cached( cache: Optional[MutableMapping[_KT, _VT]], key: Callable[..., _KT] = ..., lock: Optional[ContextManager[_T_co]] = ... ) -> Callable[[_T], _T]: ... def cachedmethod( cache: Callable[[_T_self], Optional[MutableMapping[_KT, _VT]]], key: Callable[..., _KT] = ..., lock: Optional[ContextManager[_T_co]] = ..., ) -> Callable[[_T], _T]: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/cachetools/func.pyi0000664000175000017500000000077600000000000026545 0ustar00davedave00000000000000from typing import Any, Callable, Optional, Sequence, TypeVar _T = TypeVar("_T") _F = TypeVar("_F", bound=Callable[..., Any]) _RET = Callable[[_F], _F] def lfu_cache(maxsize: int = ..., typed: bool = ...) -> _RET: ... def lru_cache(maxsize: int = ..., typed: bool = ...) -> _RET: ... def rr_cache(maxsize: int = ..., choice: Optional[Callable[[Sequence[_T]], _T]] = ..., typed: bool = ...) -> _RET: ... def ttl_cache(maxsize: int = ..., ttl: float = ..., timer: float = ..., typed: bool = ...) -> _RET: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/cachetools/lfu.pyi0000664000175000017500000000117000000000000026365 0ustar00davedave00000000000000from typing import Callable, Iterator, Optional, TypeVar from .cache import Cache _KT = TypeVar("_KT") _VT = TypeVar("_VT") class LFUCache(Cache[_KT, _VT]): def __init__(self, maxsize: int, getsizeof: Optional[Callable[[_VT], int]] = ...) -> None: ... def __getitem__(self, key: _KT, cache_getitem: Callable[[_KT], _VT] = ...) -> _VT: ... def __setitem__(self, key: _KT, value: _VT, cache_setitem: Callable[[_KT, _VT], None] = ...) -> None: ... def __delitem__(self, key: _KT, cache_delitem: Callable[[_KT], None] = ...) -> None: ... def __iter__(self) -> Iterator[_KT]: ... def __len__(self) -> int: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/cachetools/lru.pyi0000664000175000017500000000113700000000000026404 0ustar00davedave00000000000000from typing import Callable, Iterator, Optional, TypeVar from .cache import Cache as Cache _KT = TypeVar("_KT") _VT = TypeVar("_VT") class LRUCache(Cache[_KT, _VT]): def __init__(self, maxsize: int, getsizeof: Optional[Callable[[_VT], int]] = ...) -> None: ... def __getitem__(self, key: _KT, cache_getitem: Callable[[_KT], _VT] = ...) -> _VT: ... def __setitem__(self, key: _KT, value: _VT, cache_setitem: Callable[[_KT, _VT], None] = ...) -> None: ... def __delitem__(self, key: _KT, cache_delitem: Callable[[_KT], None] = ...) -> None: ... def __iter__(self) -> Iterator[_KT]: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/cachetools/rr.pyi0000664000175000017500000000125300000000000026224 0ustar00davedave00000000000000from typing import Callable, Iterator, Optional, Sequence, TypeVar from .cache import Cache as Cache _KT = TypeVar("_KT") _VT = TypeVar("_VT") class RRCache(Cache[_KT, _VT]): def __init__( self, maxsize: int, choice: Optional[Callable[[Sequence[_KT]], _KT]] = ..., getsizeof: Optional[Callable[[_VT], int]] = ..., ) -> None: ... def __getitem__(self, key: _KT) -> _VT: ... def __setitem__(self, key: _KT, value: _VT) -> None: ... def __delitem__(self, key: _KT) -> None: ... def __iter__(self) -> Iterator[_KT]: ... def __len__(self) -> int: ... @property def choice(self) -> Callable[[Sequence[_KT]], _KT]: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/cachetools/ttl.pyi0000664000175000017500000000163600000000000026411 0ustar00davedave00000000000000from typing import Callable, Iterator, Optional, TypeVar from .cache import Cache _KT = TypeVar("_KT") _VT = TypeVar("_VT") class TTLCache(Cache[_KT, _VT]): def __init__( self, maxsize: int, ttl: float, timer: Callable[[], float] = ..., getsizeof: Optional[Callable[[_VT], int]] = ... ) -> None: ... def __getitem__(self, key: _KT, cache_getitem: Callable[[_KT], _VT] = ...) -> _VT: ... def __setitem__(self, key: _KT, value: _VT, cache_setitem: Callable[[_KT, _VT], None] = ...) -> None: ... def __delitem__(self, key: _KT, cache_delitem: Callable[[_KT], None] = ...) -> None: ... def __iter__(self) -> Iterator[_KT]: ... def __len__(self) -> int: ... @property def currsize(self) -> int: ... @property def timer(self) -> Callable[[], float]: ... @property def ttl(self) -> float: ... def expire(self, time: Optional[Callable[[], float]] = ...) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/certifi.pyi0000664000175000017500000000003000000000000025072 0ustar00davedave00000000000000def where() -> str: ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4423795 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/characteristic/0000775000175000017500000000000000000000000025721 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/characteristic/__init__.pyi0000664000175000017500000000246200000000000030207 0ustar00davedave00000000000000from typing import Any, AnyStr, Callable, Dict, Optional, Sequence, Type, TypeVar, Union def with_repr(attrs: Sequence[Union[AnyStr, Attribute]]) -> Callable[..., Any]: ... def with_cmp(attrs: Sequence[Union[AnyStr, Attribute]]) -> Callable[..., Any]: ... def with_init(attrs: Sequence[Union[AnyStr, Attribute]]) -> Callable[..., Any]: ... def immutable(attrs: Sequence[Union[AnyStr, Attribute]]) -> Callable[..., Any]: ... def strip_leading_underscores(attribute_name: AnyStr) -> AnyStr: ... NOTHING = Any _T = TypeVar("_T") def attributes( attrs: Sequence[Union[AnyStr, Attribute]], apply_with_cmp: bool = ..., apply_with_init: bool = ..., apply_with_repr: bool = ..., apply_immutable: bool = ..., store_attributes: Optional[Callable[[type, Attribute], Any]] = ..., **kw: Optional[Dict[Any, Any]], ) -> Callable[[Type[_T]], Type[_T]]: ... class Attribute: def __init__( self, name: AnyStr, exclude_from_cmp: bool = ..., exclude_from_init: bool = ..., exclude_from_repr: bool = ..., exclude_from_immutable: bool = ..., default_value: Any = ..., default_factory: Optional[Callable[[None], Any]] = ..., instance_of: Optional[Any] = ..., init_aliaser: Optional[Callable[[AnyStr], AnyStr]] = ..., ) -> None: ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4423795 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/chardet/0000775000175000017500000000000000000000000024343 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/chardet/__init__.pyi0000664000175000017500000000123300000000000026624 0ustar00davedave00000000000000import sys from typing import Any, Tuple from .universaldetector import UniversalDetector as UniversalDetector def __getattr__(name: str) -> Any: ... # incomplete if sys.version_info >= (3, 8): from typing import TypedDict else: from typing_extensions import TypedDict class _LangModelType(TypedDict): char_to_order_map: Tuple[int, ...] precedence_matrix: Tuple[int, ...] typical_positive_ratio: float keep_english_letter: bool charset_name: str language: str class _SMModelType(TypedDict): class_table: Tuple[int, ...] class_factor: int state_table: Tuple[int, ...] char_len_table: Tuple[int, ...] name: str ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/chardet/enums.pyi0000664000175000017500000000130600000000000026215 0ustar00davedave00000000000000class InputState(object): PURE_ASCII: int ESC_ASCII: int HIGH_BYTE: int class LanguageFilter(object): CHINESE_SIMPLIFIED: int CHINESE_TRADITIONAL: int JAPANESE: int KOREAN: int NON_CJK: int ALL: int CHINESE: int CJK: int class ProbingState(object): DETECTING: int FOUND_IT: int NOT_ME: int class MachineState(object): START: int ERROR: int ITS_ME: int class SequenceLikelihood(object): NEGATIVE: int UNLIKELY: int LIKELY: int POSITIVE: int @classmethod def get_num_categories(cls) -> int: ... class CharacterCategory(object): UNDEFINED: int LINE_BREAK: int SYMBOL: int DIGIT: int CONTROL: int ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/chardet/langbulgarianmodel.pyi0000664000175000017500000000040700000000000030716 0ustar00davedave00000000000000from typing import Tuple from . import _LangModelType Latin5_BulgarianCharToOrderMap: Tuple[int, ...] win1251BulgarianCharToOrderMap: Tuple[int, ...] BulgarianLangModel: Tuple[int, ...] Latin5BulgarianModel: _LangModelType Win1251BulgarianModel: _LangModelType ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/chardet/langcyrillicmodel.pyi0000664000175000017500000000103000000000000030555 0ustar00davedave00000000000000from typing import Tuple from . import _LangModelType KOI8R_char_to_order_map: Tuple[int, ...] win1251_char_to_order_map: Tuple[int, ...] latin5_char_to_order_map: Tuple[int, ...] macCyrillic_char_to_order_map: Tuple[int, ...] IBM855_char_to_order_map: Tuple[int, ...] IBM866_char_to_order_map: Tuple[int, ...] RussianLangModel: Tuple[int, ...] Koi8rModel: _LangModelType Win1251CyrillicModel: _LangModelType Latin5CyrillicModel: _LangModelType MacCyrillicModel: _LangModelType Ibm866Model: _LangModelType Ibm855Model: _LangModelType ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/chardet/langgreekmodel.pyi0000664000175000017500000000036000000000000030045 0ustar00davedave00000000000000from typing import Tuple from . import _LangModelType Latin7_char_to_order_map: Tuple[int, ...] win1253_char_to_order_map: Tuple[int, ...] GreekLangModel: Tuple[int, ...] Latin7GreekModel: _LangModelType Win1253GreekModel: _LangModelType ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/chardet/langhebrewmodel.pyi0000664000175000017500000000025100000000000030223 0ustar00davedave00000000000000from typing import Tuple from . import _LangModelType WIN1255_CHAR_TO_ORDER_MAP: Tuple[int, ...] HEBREW_LANG_MODEL: Tuple[int, ...] Win1255HebrewModel: _LangModelType ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/chardet/langhungarianmodel.pyi0000664000175000017500000000040700000000000030726 0ustar00davedave00000000000000from typing import Tuple from . import _LangModelType Latin2_HungarianCharToOrderMap: Tuple[int, ...] win1250HungarianCharToOrderMap: Tuple[int, ...] HungarianLangModel: Tuple[int, ...] Latin2HungarianModel: _LangModelType Win1250HungarianModel: _LangModelType ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/chardet/langthaimodel.pyi0000664000175000017500000000023500000000000027676 0ustar00davedave00000000000000from typing import Tuple from . import _LangModelType TIS620CharToOrderMap: Tuple[int, ...] ThaiLangModel: Tuple[int, ...] TIS620ThaiModel: _LangModelType ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/chardet/langturkishmodel.pyi0000664000175000017500000000025300000000000030442 0ustar00davedave00000000000000from typing import Tuple from . import _LangModelType Latin5_TurkishCharToOrderMap: Tuple[int, ...] TurkishLangModel: Tuple[int, ...] Latin5TurkishModel: _LangModelType ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/chardet/universaldetector.pyi0000664000175000017500000000145100000000000030631 0ustar00davedave00000000000000from logging import Logger from typing import Dict, Optional, Pattern from typing_extensions import TypedDict class _FinalResultType(TypedDict): encoding: str confidence: float language: str class _IntermediateResultType(TypedDict): encoding: Optional[str] confidence: float language: Optional[str] class UniversalDetector(object): MINIMUM_THRESHOLD: float HIGH_BYTE_DETECTOR: Pattern[bytes] ESC_DETECTOR: Pattern[bytes] WIN_BYTE_DETECTOR: Pattern[bytes] ISO_WIN_MAP: Dict[str, str] result: _IntermediateResultType done: bool lang_filter: int logger: Logger def __init__(self, lang_filter: int = ...) -> None: ... def reset(self) -> None: ... def feed(self, byte_str: bytes) -> None: ... def close(self) -> _FinalResultType: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/chardet/version.pyi0000664000175000017500000000007500000000000026555 0ustar00davedave00000000000000from typing import List __version__: str VERSION: List[str] ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4423795 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/click/0000775000175000017500000000000000000000000024016 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/click/__init__.pyi0000664000175000017500000000434100000000000026302 0ustar00davedave00000000000000from .core import ( Argument as Argument, BaseCommand as BaseCommand, Command as Command, CommandCollection as CommandCollection, Context as Context, Group as Group, MultiCommand as MultiCommand, Option as Option, Parameter as Parameter, ) from .decorators import ( argument as argument, command as command, confirmation_option as confirmation_option, group as group, help_option as help_option, make_pass_decorator as make_pass_decorator, option as option, pass_context as pass_context, pass_obj as pass_obj, password_option as password_option, version_option as version_option, ) from .exceptions import ( Abort as Abort, BadArgumentUsage as BadArgumentUsage, BadOptionUsage as BadOptionUsage, BadParameter as BadParameter, ClickException as ClickException, FileError as FileError, MissingParameter as MissingParameter, NoSuchOption as NoSuchOption, UsageError as UsageError, ) from .formatting import HelpFormatter as HelpFormatter, wrap_text as wrap_text from .globals import get_current_context as get_current_context from .parser import OptionParser as OptionParser from .termui import ( clear as clear, confirm as confirm, echo_via_pager as echo_via_pager, edit as edit, get_terminal_size as get_terminal_size, getchar as getchar, launch as launch, pause as pause, progressbar as progressbar, prompt as prompt, secho as secho, style as style, unstyle as unstyle, ) from .types import ( BOOL as BOOL, FLOAT as FLOAT, INT as INT, STRING as STRING, UNPROCESSED as UNPROCESSED, UUID as UUID, Choice as Choice, DateTime as DateTime, File as File, FloatRange as FloatRange, IntRange as IntRange, ParamType as ParamType, Path as Path, Tuple as Tuple, ) from .utils import ( echo as echo, format_filename as format_filename, get_app_dir as get_app_dir, get_binary_stream as get_binary_stream, get_os_args as get_os_args, get_text_stream as get_text_stream, open_file as open_file, ) # Controls if click should emit the warning about the use of unicode # literals. disable_unicode_literals_warning: bool __version__: str ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/click/_termui_impl.pyi0000664000175000017500000000067200000000000027233 0ustar00davedave00000000000000from typing import Generic, Optional, TypeVar _T = TypeVar("_T") class ProgressBar(Generic[_T]): def update(self, n_steps: int) -> None: ... def finish(self) -> None: ... def __enter__(self) -> ProgressBar[_T]: ... def __exit__(self, exc_type, exc_value, tb) -> None: ... def __iter__(self) -> ProgressBar[_T]: ... def next(self) -> _T: ... def __next__(self) -> _T: ... length: Optional[int] label: str ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/click/core.pyi0000664000175000017500000002540400000000000025476 0ustar00davedave00000000000000from typing import ( Any, Callable, ContextManager, Dict, Iterable, List, Mapping, NoReturn, Optional, Sequence, Set, Tuple, TypeVar, Union, ) from click.formatting import HelpFormatter from click.parser import OptionParser _CC = TypeVar("_CC", bound=Callable[[], Any]) def invoke_param_callback( callback: Callable[[Context, Parameter, Optional[str]], Any], ctx: Context, param: Parameter, value: Optional[str] ) -> Any: ... def augment_usage_errors(ctx: Context, param: Optional[Parameter] = ...) -> ContextManager[None]: ... def iter_params_for_processing( invocation_order: Sequence[Parameter], declaration_order: Iterable[Parameter] ) -> Iterable[Parameter]: ... class Context: parent: Optional[Context] command: Command info_name: Optional[str] params: Dict[Any, Any] args: List[str] protected_args: List[str] obj: Any default_map: Optional[Mapping[str, Any]] invoked_subcommand: Optional[str] terminal_width: Optional[int] max_content_width: Optional[int] allow_extra_args: bool allow_interspersed_args: bool ignore_unknown_options: bool help_option_names: List[str] token_normalize_func: Optional[Callable[[str], str]] resilient_parsing: bool auto_envvar_prefix: Optional[str] color: Optional[bool] _meta: Dict[str, Any] _close_callbacks: List[Any] _depth: int def __init__( self, command: Command, parent: Optional[Context] = ..., info_name: Optional[str] = ..., obj: Optional[Any] = ..., auto_envvar_prefix: Optional[str] = ..., default_map: Optional[Mapping[str, Any]] = ..., terminal_width: Optional[int] = ..., max_content_width: Optional[int] = ..., resilient_parsing: bool = ..., allow_extra_args: Optional[bool] = ..., allow_interspersed_args: Optional[bool] = ..., ignore_unknown_options: Optional[bool] = ..., help_option_names: Optional[List[str]] = ..., token_normalize_func: Optional[Callable[[str], str]] = ..., color: Optional[bool] = ..., ) -> None: ... @property def meta(self) -> Dict[str, Any]: ... @property def command_path(self) -> str: ... def scope(self, cleanup: bool = ...) -> ContextManager[Context]: ... def make_formatter(self) -> HelpFormatter: ... def call_on_close(self, f: _CC) -> _CC: ... def close(self) -> None: ... def find_root(self) -> Context: ... def find_object(self, object_type: type) -> Any: ... def ensure_object(self, object_type: type) -> Any: ... def lookup_default(self, name: str) -> Any: ... def fail(self, message: str) -> NoReturn: ... def abort(self) -> NoReturn: ... def exit(self, code: Union[int, str] = ...) -> NoReturn: ... def get_usage(self) -> str: ... def get_help(self) -> str: ... def invoke(self, callback: Union[Command, Callable[..., Any]], *args, **kwargs) -> Any: ... def forward(self, callback: Union[Command, Callable[..., Any]], *args, **kwargs) -> Any: ... class BaseCommand: allow_extra_args: bool allow_interspersed_args: bool ignore_unknown_options: bool name: str context_settings: Dict[Any, Any] def __init__(self, name: str, context_settings: Optional[Dict[Any, Any]] = ...) -> None: ... def get_usage(self, ctx: Context) -> str: ... def get_help(self, ctx: Context) -> str: ... def make_context(self, info_name: str, args: List[str], parent: Optional[Context] = ..., **extra) -> Context: ... def parse_args(self, ctx: Context, args: List[str]) -> List[str]: ... def invoke(self, ctx: Context) -> Any: ... def main( self, args: Optional[List[str]] = ..., prog_name: Optional[str] = ..., complete_var: Optional[str] = ..., standalone_mode: bool = ..., **extra, ) -> Any: ... def __call__(self, *args, **kwargs) -> Any: ... class Command(BaseCommand): callback: Optional[Callable[..., Any]] params: List[Parameter] help: Optional[str] epilog: Optional[str] short_help: Optional[str] options_metavar: str add_help_option: bool hidden: bool deprecated: bool def __init__( self, name: str, context_settings: Optional[Dict[Any, Any]] = ..., callback: Optional[Callable[..., Any]] = ..., params: Optional[List[Parameter]] = ..., help: Optional[str] = ..., epilog: Optional[str] = ..., short_help: Optional[str] = ..., options_metavar: str = ..., add_help_option: bool = ..., hidden: bool = ..., deprecated: bool = ..., ) -> None: ... def get_params(self, ctx: Context) -> List[Parameter]: ... def format_usage(self, ctx: Context, formatter: HelpFormatter) -> None: ... def collect_usage_pieces(self, ctx: Context) -> List[str]: ... def get_help_option_names(self, ctx: Context) -> Set[str]: ... def get_help_option(self, ctx: Context) -> Optional[Option]: ... def make_parser(self, ctx: Context) -> OptionParser: ... def get_short_help_str(self, limit: int = ...) -> str: ... def format_help(self, ctx: Context, formatter: HelpFormatter) -> None: ... def format_help_text(self, ctx: Context, formatter: HelpFormatter) -> None: ... def format_options(self, ctx: Context, formatter: HelpFormatter) -> None: ... def format_epilog(self, ctx: Context, formatter: HelpFormatter) -> None: ... _T = TypeVar("_T") _F = TypeVar("_F", bound=Callable[..., Any]) class MultiCommand(Command): no_args_is_help: bool invoke_without_command: bool subcommand_metavar: str chain: bool result_callback: Callable[..., Any] def __init__( self, name: Optional[str] = ..., invoke_without_command: bool = ..., no_args_is_help: Optional[bool] = ..., subcommand_metavar: Optional[str] = ..., chain: bool = ..., result_callback: Optional[Callable[..., Any]] = ..., **attrs, ) -> None: ... def resultcallback(self, replace: bool = ...) -> Callable[[_F], _F]: ... def format_commands(self, ctx: Context, formatter: HelpFormatter) -> None: ... def resolve_command(self, ctx: Context, args: List[str]) -> Tuple[str, Command, List[str]]: ... def get_command(self, ctx: Context, cmd_name: str) -> Optional[Command]: ... def list_commands(self, ctx: Context) -> Iterable[str]: ... class Group(MultiCommand): commands: Dict[str, Command] def __init__(self, name: Optional[str] = ..., commands: Optional[Dict[str, Command]] = ..., **attrs) -> None: ... def add_command(self, cmd: Command, name: Optional[str] = ...): ... def command(self, *args, **kwargs) -> Callable[[Callable[..., Any]], Command]: ... def group(self, *args, **kwargs) -> Callable[[Callable[..., Any]], Group]: ... class CommandCollection(MultiCommand): sources: List[MultiCommand] def __init__(self, name: Optional[str] = ..., sources: Optional[List[MultiCommand]] = ..., **attrs) -> None: ... def add_source(self, multi_cmd: MultiCommand) -> None: ... class _ParamType: name: str is_composite: bool envvar_list_splitter: Optional[str] def __call__(self, value: Optional[str], param: Optional[Parameter] = ..., ctx: Optional[Context] = ...) -> Any: ... def get_metavar(self, param: Parameter) -> str: ... def get_missing_message(self, param: Parameter) -> str: ... def convert(self, value: str, param: Optional[Parameter], ctx: Optional[Context]) -> Any: ... def split_envvar_value(self, rv: str) -> List[str]: ... def fail(self, message: str, param: Optional[Parameter] = ..., ctx: Optional[Context] = ...) -> NoReturn: ... # This type is here to resolve https://github.com/python/mypy/issues/5275 _ConvertibleType = Union[ type, _ParamType, Tuple[Union[type, _ParamType], ...], Callable[[str], Any], Callable[[Optional[str]], Any] ] class Parameter: param_type_name: str name: str opts: List[str] secondary_opts: List[str] type: _ParamType required: bool callback: Optional[Callable[[Context, Parameter, str], Any]] nargs: int multiple: bool expose_value: bool default: Any is_eager: bool metavar: Optional[str] envvar: Union[str, List[str], None] def __init__( self, param_decls: Optional[List[str]] = ..., type: Optional[_ConvertibleType] = ..., required: bool = ..., default: Optional[Any] = ..., callback: Optional[Callable[[Context, Parameter, str], Any]] = ..., nargs: Optional[int] = ..., metavar: Optional[str] = ..., expose_value: bool = ..., is_eager: bool = ..., envvar: Optional[Union[str, List[str]]] = ..., ) -> None: ... @property def human_readable_name(self) -> str: ... def make_metavar(self) -> str: ... def get_default(self, ctx: Context) -> Any: ... def add_to_parser(self, parser: OptionParser, ctx: Context) -> None: ... def consume_value(self, ctx: Context, opts: Dict[str, Any]) -> Any: ... def type_cast_value(self, ctx: Context, value: Any) -> Any: ... def process_value(self, ctx: Context, value: Any) -> Any: ... def value_is_missing(self, value: Any) -> bool: ... def full_process_value(self, ctx: Context, value: Any) -> Any: ... def resolve_envvar_value(self, ctx: Context) -> str: ... def value_from_envvar(self, ctx: Context) -> Union[str, List[str]]: ... def handle_parse_result(self, ctx: Context, opts: Dict[str, Any], args: List[str]) -> Tuple[Any, List[str]]: ... def get_help_record(self, ctx: Context) -> Tuple[str, str]: ... def get_usage_pieces(self, ctx: Context) -> List[str]: ... def get_error_hint(self, ctx: Context) -> str: ... class Option(Parameter): prompt: str # sic confirmation_prompt: bool hide_input: bool is_flag: bool flag_value: Any is_bool_flag: bool count: bool multiple: bool allow_from_autoenv: bool help: Optional[str] hidden: bool show_default: bool show_choices: bool show_envvar: bool def __init__( self, param_decls: Optional[List[str]] = ..., show_default: bool = ..., prompt: Union[bool, str] = ..., confirmation_prompt: bool = ..., hide_input: bool = ..., is_flag: Optional[bool] = ..., flag_value: Optional[Any] = ..., multiple: bool = ..., count: bool = ..., allow_from_autoenv: bool = ..., type: Optional[_ConvertibleType] = ..., help: Optional[str] = ..., hidden: bool = ..., show_choices: bool = ..., show_envvar: bool = ..., **attrs, ) -> None: ... def prompt_for_value(self, ctx: Context) -> Any: ... class Argument(Parameter): def __init__(self, param_decls: Optional[List[str]] = ..., required: Optional[bool] = ..., **attrs) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/click/decorators.pyi0000664000175000017500000002166700000000000026722 0ustar00davedave00000000000000from distutils.version import Version from typing import Any, Callable, Dict, List, Optional, Protocol, Text, Tuple, Type, TypeVar, Union, overload from click.core import Argument, Command, Context, Group, Option, Parameter, _ConvertibleType _T = TypeVar("_T") _F = TypeVar("_F", bound=Callable[..., Any]) class _IdentityFunction(Protocol): def __call__(self, __x: _T) -> _T: ... _Callback = Callable[[Context, Union[Option, Parameter], Any], Any] def pass_context(__f: _T) -> _T: ... def pass_obj(__f: _T) -> _T: ... def make_pass_decorator(object_type: type, ensure: bool = ...) -> _IdentityFunction: ... # NOTE: Decorators below have **attrs converted to concrete constructor # arguments from core.pyi to help with type checking. def command( name: Optional[str] = ..., cls: Optional[Type[Command]] = ..., # Command context_settings: Optional[Dict[Any, Any]] = ..., help: Optional[str] = ..., epilog: Optional[str] = ..., short_help: Optional[str] = ..., options_metavar: str = ..., add_help_option: bool = ..., hidden: bool = ..., deprecated: bool = ..., ) -> Callable[[Callable[..., Any]], Command]: ... # This inherits attrs from Group, MultiCommand and Command. def group( name: Optional[str] = ..., cls: Type[Command] = ..., # Group commands: Optional[Dict[str, Command]] = ..., # MultiCommand invoke_without_command: bool = ..., no_args_is_help: Optional[bool] = ..., subcommand_metavar: Optional[str] = ..., chain: bool = ..., result_callback: Optional[Callable[..., Any]] = ..., # Command help: Optional[str] = ..., epilog: Optional[str] = ..., short_help: Optional[str] = ..., options_metavar: str = ..., add_help_option: bool = ..., hidden: bool = ..., deprecated: bool = ..., # User-defined **kwargs: Any, ) -> Callable[[Callable[..., Any]], Group]: ... def argument( *param_decls: Text, cls: Type[Argument] = ..., # Argument required: Optional[bool] = ..., # Parameter type: Optional[_ConvertibleType] = ..., default: Optional[Any] = ..., callback: Optional[_Callback] = ..., nargs: Optional[int] = ..., metavar: Optional[str] = ..., expose_value: bool = ..., is_eager: bool = ..., envvar: Optional[Union[str, List[str]]] = ..., autocompletion: Optional[Callable[[Any, List[str], str], List[Union[str, Tuple[str, str]]]]] = ..., ) -> _IdentityFunction: ... @overload def option( *param_decls: Text, cls: Type[Option] = ..., # Option show_default: Union[bool, Text] = ..., prompt: Union[bool, Text] = ..., confirmation_prompt: bool = ..., hide_input: bool = ..., is_flag: Optional[bool] = ..., flag_value: Optional[Any] = ..., multiple: bool = ..., count: bool = ..., allow_from_autoenv: bool = ..., type: Optional[_ConvertibleType] = ..., help: Optional[Text] = ..., show_choices: bool = ..., # Parameter default: Optional[Any] = ..., required: bool = ..., callback: Optional[_Callback] = ..., nargs: Optional[int] = ..., metavar: Optional[str] = ..., expose_value: bool = ..., is_eager: bool = ..., envvar: Optional[Union[str, List[str]]] = ..., # User-defined **kwargs: Any, ) -> _IdentityFunction: ... @overload def option( *param_decls: str, cls: Type[Option] = ..., # Option show_default: Union[bool, Text] = ..., prompt: Union[bool, Text] = ..., confirmation_prompt: bool = ..., hide_input: bool = ..., is_flag: Optional[bool] = ..., flag_value: Optional[Any] = ..., multiple: bool = ..., count: bool = ..., allow_from_autoenv: bool = ..., type: _T = ..., help: Optional[str] = ..., show_choices: bool = ..., # Parameter default: Optional[Any] = ..., required: bool = ..., callback: Optional[Callable[[Context, Union[Option, Parameter], Union[bool, int, str]], _T]] = ..., nargs: Optional[int] = ..., metavar: Optional[str] = ..., expose_value: bool = ..., is_eager: bool = ..., envvar: Optional[Union[str, List[str]]] = ..., # User-defined **kwargs: Any, ) -> _IdentityFunction: ... @overload def option( *param_decls: str, cls: Type[Option] = ..., # Option show_default: Union[bool, Text] = ..., prompt: Union[bool, Text] = ..., confirmation_prompt: bool = ..., hide_input: bool = ..., is_flag: Optional[bool] = ..., flag_value: Optional[Any] = ..., multiple: bool = ..., count: bool = ..., allow_from_autoenv: bool = ..., type: Type[str] = ..., help: Optional[str] = ..., show_choices: bool = ..., # Parameter default: Optional[Any] = ..., required: bool = ..., callback: Callable[[Context, Union[Option, Parameter], str], Any] = ..., nargs: Optional[int] = ..., metavar: Optional[str] = ..., expose_value: bool = ..., is_eager: bool = ..., envvar: Optional[Union[str, List[str]]] = ..., # User-defined **kwargs: Any, ) -> _IdentityFunction: ... @overload def option( *param_decls: str, cls: Type[Option] = ..., # Option show_default: Union[bool, Text] = ..., prompt: Union[bool, Text] = ..., confirmation_prompt: bool = ..., hide_input: bool = ..., is_flag: Optional[bool] = ..., flag_value: Optional[Any] = ..., multiple: bool = ..., count: bool = ..., allow_from_autoenv: bool = ..., type: Type[int] = ..., help: Optional[str] = ..., show_choices: bool = ..., # Parameter default: Optional[Any] = ..., required: bool = ..., callback: Callable[[Context, Union[Option, Parameter], int], Any] = ..., nargs: Optional[int] = ..., metavar: Optional[str] = ..., expose_value: bool = ..., is_eager: bool = ..., envvar: Optional[Union[str, List[str]]] = ..., # User-defined **kwargs: Any, ) -> _IdentityFunction: ... def confirmation_option( *param_decls: str, cls: Type[Option] = ..., # Option show_default: Union[bool, Text] = ..., prompt: Union[bool, Text] = ..., confirmation_prompt: bool = ..., hide_input: bool = ..., is_flag: bool = ..., flag_value: Optional[Any] = ..., multiple: bool = ..., count: bool = ..., allow_from_autoenv: bool = ..., type: Optional[_ConvertibleType] = ..., help: str = ..., show_choices: bool = ..., # Parameter default: Optional[Any] = ..., callback: Optional[_Callback] = ..., nargs: Optional[int] = ..., metavar: Optional[str] = ..., expose_value: bool = ..., is_eager: bool = ..., envvar: Optional[Union[str, List[str]]] = ..., ) -> _IdentityFunction: ... def password_option( *param_decls: str, cls: Type[Option] = ..., # Option show_default: Union[bool, Text] = ..., prompt: Union[bool, Text] = ..., confirmation_prompt: bool = ..., hide_input: bool = ..., is_flag: Optional[bool] = ..., flag_value: Optional[Any] = ..., multiple: bool = ..., count: bool = ..., allow_from_autoenv: bool = ..., type: Optional[_ConvertibleType] = ..., help: Optional[str] = ..., show_choices: bool = ..., # Parameter default: Optional[Any] = ..., callback: Optional[_Callback] = ..., nargs: Optional[int] = ..., metavar: Optional[str] = ..., expose_value: bool = ..., is_eager: bool = ..., envvar: Optional[Union[str, List[str]]] = ..., ) -> _IdentityFunction: ... def version_option( version: Optional[Union[str, Version]] = ..., *param_decls: str, cls: Type[Option] = ..., # Option prog_name: Optional[str] = ..., message: Optional[str] = ..., show_default: Union[bool, Text] = ..., prompt: Union[bool, Text] = ..., confirmation_prompt: bool = ..., hide_input: bool = ..., is_flag: bool = ..., flag_value: Optional[Any] = ..., multiple: bool = ..., count: bool = ..., allow_from_autoenv: bool = ..., type: Optional[_ConvertibleType] = ..., help: str = ..., show_choices: bool = ..., # Parameter default: Optional[Any] = ..., callback: Optional[_Callback] = ..., nargs: Optional[int] = ..., metavar: Optional[str] = ..., expose_value: bool = ..., is_eager: bool = ..., envvar: Optional[Union[str, List[str]]] = ..., ) -> _IdentityFunction: ... def help_option( *param_decls: str, cls: Type[Option] = ..., # Option show_default: Union[bool, Text] = ..., prompt: Union[bool, Text] = ..., confirmation_prompt: bool = ..., hide_input: bool = ..., is_flag: bool = ..., flag_value: Optional[Any] = ..., multiple: bool = ..., count: bool = ..., allow_from_autoenv: bool = ..., type: Optional[_ConvertibleType] = ..., help: str = ..., show_choices: bool = ..., # Parameter default: Optional[Any] = ..., callback: Optional[_Callback] = ..., nargs: Optional[int] = ..., metavar: Optional[str] = ..., expose_value: bool = ..., is_eager: bool = ..., envvar: Optional[Union[str, List[str]]] = ..., ) -> _IdentityFunction: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/click/exceptions.pyi0000664000175000017500000000362000000000000026723 0ustar00davedave00000000000000from typing import IO, Any, List, Optional from click.core import Context, Parameter class ClickException(Exception): exit_code: int message: str def __init__(self, message: str) -> None: ... def format_message(self) -> str: ... def show(self, file: Optional[Any] = ...) -> None: ... class UsageError(ClickException): ctx: Optional[Context] def __init__(self, message: str, ctx: Optional[Context] = ...) -> None: ... def show(self, file: Optional[IO[Any]] = ...) -> None: ... class BadParameter(UsageError): param: Optional[Parameter] param_hint: Optional[str] def __init__( self, message: str, ctx: Optional[Context] = ..., param: Optional[Parameter] = ..., param_hint: Optional[str] = ... ) -> None: ... class MissingParameter(BadParameter): param_type: str # valid values: 'parameter', 'option', 'argument' def __init__( self, message: Optional[str] = ..., ctx: Optional[Context] = ..., param: Optional[Parameter] = ..., param_hint: Optional[str] = ..., param_type: Optional[str] = ..., ) -> None: ... class NoSuchOption(UsageError): option_name: str possibilities: Optional[List[str]] def __init__( self, option_name: str, message: Optional[str] = ..., possibilities: Optional[List[str]] = ..., ctx: Optional[Context] = ..., ) -> None: ... class BadOptionUsage(UsageError): def __init__(self, option_name: str, message: str, ctx: Optional[Context] = ...) -> None: ... class BadArgumentUsage(UsageError): def __init__(self, message: str, ctx: Optional[Context] = ...) -> None: ... class FileError(ClickException): ui_filename: str filename: str def __init__(self, filename: str, hint: Optional[str] = ...) -> None: ... class Abort(RuntimeError): ... class Exit(RuntimeError): def __init__(self, code: int = ...) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/click/formatting.pyi0000664000175000017500000000254700000000000026723 0ustar00davedave00000000000000from typing import ContextManager, Generator, Iterable, List, Optional, Tuple FORCED_WIDTH: Optional[int] def measure_table(rows: Iterable[Iterable[str]]) -> Tuple[int, ...]: ... def iter_rows(rows: Iterable[Iterable[str]], col_count: int) -> Generator[Tuple[str, ...], None, None]: ... def wrap_text( text: str, width: int = ..., initial_indent: str = ..., subsequent_indent: str = ..., preserve_paragraphs: bool = ... ) -> str: ... class HelpFormatter: indent_increment: int width: Optional[int] current_indent: int buffer: List[str] def __init__(self, indent_increment: int = ..., width: Optional[int] = ..., max_width: Optional[int] = ...) -> None: ... def write(self, string: str) -> None: ... def indent(self) -> None: ... def dedent(self) -> None: ... def write_usage( self, prog: str, args: str = ..., prefix: str = ..., ): ... def write_heading(self, heading: str) -> None: ... def write_paragraph(self) -> None: ... def write_text(self, text: str) -> None: ... def write_dl(self, rows: Iterable[Iterable[str]], col_max: int = ..., col_spacing: int = ...) -> None: ... def section(self, name) -> ContextManager[None]: ... def indentation(self) -> ContextManager[None]: ... def getvalue(self) -> str: ... def join_options(options: List[str]) -> Tuple[str, bool]: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/click/globals.pyi0000664000175000017500000000042200000000000026162 0ustar00davedave00000000000000from typing import Optional from click.core import Context def get_current_context(silent: bool = ...) -> Context: ... def push_context(ctx: Context) -> None: ... def pop_context() -> None: ... def resolve_color_default(color: Optional[bool] = ...) -> Optional[bool]: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/click/parser.pyi0000664000175000017500000000372600000000000026045 0ustar00davedave00000000000000from typing import Any, Dict, Iterable, List, Optional, Set, Tuple from click.core import Context def _unpack_args(args: Iterable[str], nargs_spec: Iterable[int]) -> Tuple[Tuple[Optional[Tuple[str, ...]], ...], List[str]]: ... def split_opt(opt: str) -> Tuple[str, str]: ... def normalize_opt(opt: str, ctx: Context) -> str: ... def split_arg_string(string: str) -> List[str]: ... class Option: dest: str action: str nargs: int const: Any obj: Any prefixes: Set[str] _short_opts: List[str] _long_opts: List[str] def __init__( self, opts: Iterable[str], dest: str, action: Optional[str] = ..., nargs: int = ..., const: Optional[Any] = ..., obj: Optional[Any] = ..., ) -> None: ... @property def takes_value(self) -> bool: ... def process(self, value: Any, state: ParsingState) -> None: ... class Argument: dest: str nargs: int obj: Any def __init__(self, dest: str, nargs: int = ..., obj: Optional[Any] = ...) -> None: ... def process(self, value: Any, state: ParsingState) -> None: ... class ParsingState: opts: Dict[str, Any] largs: List[str] rargs: List[str] order: List[Any] def __init__(self, rargs: List[str]) -> None: ... class OptionParser: ctx: Optional[Context] allow_interspersed_args: bool ignore_unknown_options: bool _short_opt: Dict[str, Option] _long_opt: Dict[str, Option] _opt_prefixes: Set[str] _args: List[Argument] def __init__(self, ctx: Optional[Context] = ...) -> None: ... def add_option( self, opts: Iterable[str], dest: str, action: Optional[str] = ..., nargs: int = ..., const: Optional[Any] = ..., obj: Optional[Any] = ..., ) -> None: ... def add_argument(self, dest: str, nargs: int = ..., obj: Optional[Any] = ...) -> None: ... def parse_args(self, args: List[str]) -> Tuple[Dict[str, Any], List[str], List[Any]]: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/click/termui.pyi0000664000175000017500000000633300000000000026053 0ustar00davedave00000000000000from typing import IO, Any, Callable, Generator, Iterable, Optional, Text, Tuple, TypeVar, Union, overload from click._termui_impl import ProgressBar as _ProgressBar from click.core import _ConvertibleType def hidden_prompt_func(prompt: str) -> str: ... def _build_prompt(text: str, suffix: str, show_default: bool = ..., default: Optional[str] = ...) -> str: ... def prompt( text: str, default: Optional[str] = ..., hide_input: bool = ..., confirmation_prompt: bool = ..., type: Optional[_ConvertibleType] = ..., value_proc: Optional[Callable[[Optional[str]], Any]] = ..., prompt_suffix: str = ..., show_default: bool = ..., err: bool = ..., show_choices: bool = ..., ) -> Any: ... def confirm( text: str, default: bool = ..., abort: bool = ..., prompt_suffix: str = ..., show_default: bool = ..., err: bool = ... ) -> bool: ... def get_terminal_size() -> Tuple[int, int]: ... def echo_via_pager( text_or_generator: Union[str, Iterable[str], Callable[[], Generator[str, None, None]]], color: Optional[bool] = ... ) -> None: ... _T = TypeVar("_T") @overload def progressbar( iterable: Iterable[_T], length: Optional[int] = ..., label: Optional[str] = ..., show_eta: bool = ..., show_percent: Optional[bool] = ..., show_pos: bool = ..., item_show_func: Optional[Callable[[_T], str]] = ..., fill_char: str = ..., empty_char: str = ..., bar_template: str = ..., info_sep: str = ..., width: int = ..., file: Optional[IO[Any]] = ..., color: Optional[bool] = ..., ) -> _ProgressBar[_T]: ... @overload def progressbar( iterable: None = ..., length: Optional[int] = ..., label: Optional[str] = ..., show_eta: bool = ..., show_percent: Optional[bool] = ..., show_pos: bool = ..., item_show_func: Optional[Callable[[_T], str]] = ..., fill_char: str = ..., empty_char: str = ..., bar_template: str = ..., info_sep: str = ..., width: int = ..., file: Optional[IO[Any]] = ..., color: Optional[bool] = ..., ) -> _ProgressBar[int]: ... def clear() -> None: ... def style( text: Text, fg: Optional[Text] = ..., bg: Optional[Text] = ..., bold: Optional[bool] = ..., dim: Optional[bool] = ..., underline: Optional[bool] = ..., blink: Optional[bool] = ..., reverse: Optional[bool] = ..., reset: bool = ..., ) -> str: ... def unstyle(text: Text) -> str: ... # Styling options copied from style() for nicer type checking. def secho( message: Optional[str] = ..., file: Optional[IO[Any]] = ..., nl: bool = ..., err: bool = ..., color: Optional[bool] = ..., fg: Optional[str] = ..., bg: Optional[str] = ..., bold: Optional[bool] = ..., dim: Optional[bool] = ..., underline: Optional[bool] = ..., blink: Optional[bool] = ..., reverse: Optional[bool] = ..., reset: bool = ..., ): ... def edit( text: Optional[str] = ..., editor: Optional[str] = ..., env: Optional[str] = ..., require_save: bool = ..., extension: str = ..., filename: Optional[str] = ..., ) -> str: ... def launch(url: str, wait: bool = ..., locate: bool = ...) -> int: ... def getchar(echo: bool = ...) -> Text: ... def pause(info: str = ..., err: bool = ...) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/click/testing.pyi0000664000175000017500000000413000000000000026214 0ustar00davedave00000000000000from typing import IO, Any, BinaryIO, ContextManager, Dict, Iterable, List, Mapping, Optional, Text, Union from .core import BaseCommand clickpkg: Any class EchoingStdin: def __init__(self, input: BinaryIO, output: BinaryIO) -> None: ... def __getattr__(self, x: str) -> Any: ... def read(self, n: int = ...) -> bytes: ... def readline(self, n: int = ...) -> bytes: ... def readlines(self) -> List[bytes]: ... def __iter__(self) -> Iterable[bytes]: ... def make_input_stream(input: Optional[Union[bytes, Text, IO[Any]]], charset: Text) -> BinaryIO: ... class Result: runner: CliRunner exit_code: int exception: Any exc_info: Optional[Any] stdout_bytes: bytes stderr_bytes: bytes def __init__( self, runner: CliRunner, stdout_bytes: bytes, stderr_bytes: bytes, exit_code: int, exception: Any, exc_info: Optional[Any] = ..., ) -> None: ... @property def output(self) -> Text: ... @property def stdout(self) -> Text: ... @property def stderr(self) -> Text: ... class CliRunner: charset: str env: Mapping[str, str] echo_stdin: bool mix_stderr: bool def __init__( self, charset: Optional[Text] = ..., env: Optional[Mapping[str, str]] = ..., echo_stdin: bool = ..., mix_stderr: bool = ..., ) -> None: ... def get_default_prog_name(self, cli: BaseCommand) -> str: ... def make_env(self, overrides: Optional[Mapping[str, str]] = ...) -> Dict[str, str]: ... def isolation( self, input: Optional[Union[bytes, Text, IO[Any]]] = ..., env: Optional[Mapping[str, str]] = ..., color: bool = ... ) -> ContextManager[BinaryIO]: ... def invoke( self, cli: BaseCommand, args: Optional[Union[str, Iterable[str]]] = ..., input: Optional[Union[bytes, Text, IO[Any]]] = ..., env: Optional[Mapping[str, str]] = ..., catch_exceptions: bool = ..., color: bool = ..., **extra: Any, ) -> Result: ... def isolated_filesystem(self) -> ContextManager[str]: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/click/types.pyi0000664000175000017500000001166500000000000025716 0ustar00davedave00000000000000import datetime import uuid from typing import IO, Any, Callable, Generic, Iterable, List, Optional, Sequence, Text, Tuple as _PyTuple, Type, TypeVar, Union from click.core import Context, Parameter, _ConvertibleType, _ParamType ParamType = _ParamType class BoolParamType(ParamType): def __call__(self, value: Optional[str], param: Optional[Parameter] = ..., ctx: Optional[Context] = ...) -> bool: ... def convert(self, value: str, param: Optional[Parameter], ctx: Optional[Context]) -> bool: ... class CompositeParamType(ParamType): arity: int class Choice(ParamType): choices: Iterable[str] case_sensitive: bool def __init__(self, choices: Iterable[str], case_sensitive: bool = ...) -> None: ... class DateTime(ParamType): formats: Sequence[str] def __init__(self, formats: Optional[Sequence[str]] = ...) -> None: ... def convert(self, value: str, param: Optional[Parameter], ctx: Optional[Context]) -> datetime.datetime: ... class FloatParamType(ParamType): def __call__(self, value: Optional[str], param: Optional[Parameter] = ..., ctx: Optional[Context] = ...) -> float: ... def convert(self, value: str, param: Optional[Parameter], ctx: Optional[Context]) -> float: ... class FloatRange(FloatParamType): min: Optional[float] max: Optional[float] clamp: bool def __init__(self, min: Optional[float] = ..., max: Optional[float] = ..., clamp: bool = ...) -> None: ... class File(ParamType): mode: str encoding: Optional[str] errors: Optional[str] lazy: Optional[bool] atomic: bool def __init__( self, mode: Text = ..., encoding: Optional[str] = ..., errors: Optional[str] = ..., lazy: Optional[bool] = ..., atomic: Optional[bool] = ..., ) -> None: ... def __call__(self, value: Optional[str], param: Optional[Parameter] = ..., ctx: Optional[Context] = ...) -> IO[Any]: ... def convert(self, value: str, param: Optional[Parameter], ctx: Optional[Context]) -> IO[Any]: ... def resolve_lazy_flag(self, value: str) -> bool: ... _F = TypeVar("_F") # result of the function _Func = Callable[[Optional[str]], _F] class FuncParamType(ParamType, Generic[_F]): func: _Func[_F] def __init__(self, func: _Func[_F]) -> None: ... def __call__(self, value: Optional[str], param: Optional[Parameter] = ..., ctx: Optional[Context] = ...) -> _F: ... def convert(self, value: str, param: Optional[Parameter], ctx: Optional[Context]) -> _F: ... class IntParamType(ParamType): def __call__(self, value: Optional[str], param: Optional[Parameter] = ..., ctx: Optional[Context] = ...) -> int: ... def convert(self, value: str, param: Optional[Parameter], ctx: Optional[Context]) -> int: ... class IntRange(IntParamType): min: Optional[int] max: Optional[int] clamp: bool def __init__(self, min: Optional[int] = ..., max: Optional[int] = ..., clamp: bool = ...) -> None: ... _PathType = TypeVar("_PathType", str, bytes) _PathTypeBound = Union[Type[str], Type[bytes]] class Path(ParamType): exists: bool file_okay: bool dir_okay: bool writable: bool readable: bool resolve_path: bool allow_dash: bool type: Optional[_PathTypeBound] def __init__( self, exists: bool = ..., file_okay: bool = ..., dir_okay: bool = ..., writable: bool = ..., readable: bool = ..., resolve_path: bool = ..., allow_dash: bool = ..., path_type: Optional[Type[_PathType]] = ..., ) -> None: ... def coerce_path_result(self, rv: Union[str, bytes]) -> _PathType: ... def __call__(self, value: Optional[str], param: Optional[Parameter] = ..., ctx: Optional[Context] = ...) -> _PathType: ... def convert(self, value: str, param: Optional[Parameter], ctx: Optional[Context]) -> _PathType: ... class StringParamType(ParamType): def __call__(self, value: Optional[str], param: Optional[Parameter] = ..., ctx: Optional[Context] = ...) -> str: ... def convert(self, value: str, param: Optional[Parameter], ctx: Optional[Context]) -> str: ... class Tuple(CompositeParamType): types: List[ParamType] def __init__(self, types: Iterable[Any]) -> None: ... def __call__(self, value: Optional[str], param: Optional[Parameter] = ..., ctx: Optional[Context] = ...) -> Tuple: ... def convert(self, value: str, param: Optional[Parameter], ctx: Optional[Context]) -> Tuple: ... class UnprocessedParamType(ParamType): ... class UUIDParameterType(ParamType): def __call__(self, value: Optional[str], param: Optional[Parameter] = ..., ctx: Optional[Context] = ...) -> uuid.UUID: ... def convert(self, value: str, param: Optional[Parameter], ctx: Optional[Context]) -> uuid.UUID: ... def convert_type(ty: Optional[_ConvertibleType], default: Optional[Any] = ...) -> ParamType: ... # parameter type shortcuts BOOL: BoolParamType FLOAT: FloatParamType INT: IntParamType STRING: StringParamType UNPROCESSED: UnprocessedParamType UUID: UUIDParameterType ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/click/utils.pyi0000664000175000017500000000333000000000000025700 0ustar00davedave00000000000000from typing import IO, Any, AnyStr, Generic, Iterator, List, Optional, Text, TypeVar _T = TypeVar("_T") def _posixify(name: str) -> str: ... def safecall(func: _T) -> _T: ... def make_str(value: Any) -> str: ... def make_default_short_help(help: str, max_length: int = ...): ... class LazyFile(object): name: str mode: str encoding: Optional[str] errors: str atomic: bool def __init__( self, filename: str, mode: str = ..., encoding: Optional[str] = ..., errors: str = ..., atomic: bool = ... ) -> None: ... def open(self) -> IO[Any]: ... def close(self) -> None: ... def close_intelligently(self) -> None: ... def __enter__(self) -> LazyFile: ... def __exit__(self, exc_type, exc_value, tb): ... def __iter__(self) -> Iterator[Any]: ... class KeepOpenFile(Generic[AnyStr]): _file: IO[AnyStr] def __init__(self, file: IO[AnyStr]) -> None: ... def __enter__(self) -> KeepOpenFile[AnyStr]: ... def __exit__(self, exc_type, exc_value, tb): ... def __iter__(self) -> Iterator[AnyStr]: ... def echo( message: object = ..., file: Optional[IO[Text]] = ..., nl: bool = ..., err: bool = ..., color: Optional[bool] = ... ) -> None: ... def get_binary_stream(name: str) -> IO[bytes]: ... def get_text_stream(name: str, encoding: Optional[str] = ..., errors: str = ...) -> IO[str]: ... def open_file( filename: str, mode: str = ..., encoding: Optional[str] = ..., errors: str = ..., lazy: bool = ..., atomic: bool = ... ) -> Any: ... # really Union[IO, LazyFile, KeepOpenFile] def get_os_args() -> List[str]: ... def format_filename(filename: str, shorten: bool = ...) -> str: ... def get_app_dir(app_name: str, roaming: bool = ..., force_posix: bool = ...) -> str: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/croniter.pyi0000664000175000017500000000361600000000000025307 0ustar00davedave00000000000000import datetime from typing import Any, Dict, Iterator, List, Optional, Text, Tuple, Type, TypeVar, Union _RetType = Union[Type[float], Type[datetime.datetime]] _SelfT = TypeVar("_SelfT", bound=croniter) class CroniterError(ValueError): ... class CroniterBadCronError(CroniterError): ... class CroniterBadDateError(CroniterError): ... class CroniterNotAlphaError(CroniterError): ... class croniter(Iterator[Any]): MONTHS_IN_YEAR: int RANGES: Tuple[Tuple[int, int], ...] DAYS: Tuple[int, ...] ALPHACONV: Tuple[Dict[str, Any], ...] LOWMAP: Tuple[Dict[int, Any], ...] bad_length: str tzinfo: Optional[datetime.tzinfo] cur: float expanded: List[List[str]] start_time: float dst_start_time: float nth_weekday_of_month: Dict[str, Any] def __init__( self, expr_format: Text, start_time: Optional[Union[float, datetime.datetime]] = ..., ret_type: Optional[_RetType] = ... ) -> None: ... # Most return value depend on ret_type, which can be passed in both as a method argument and as # a constructor argument. def get_next(self, ret_type: Optional[_RetType] = ...) -> Any: ... def get_prev(self, ret_type: Optional[_RetType] = ...) -> Any: ... def get_current(self, ret_type: Optional[_RetType] = ...) -> Any: ... def __iter__(self: _SelfT) -> _SelfT: ... def __next__(self, ret_type: Optional[_RetType] = ...) -> Any: ... def next(self, ret_type: Optional[_RetType] = ...) -> Any: ... def all_next(self, ret_type: Optional[_RetType] = ...) -> Iterator[Any]: ... def all_prev(self, ret_type: Optional[_RetType] = ...) -> Iterator[Any]: ... def iter(self, ret_type: Optional[_RetType] = ...) -> Iterator[Any]: ... def is_leap(self, year: int) -> bool: ... @classmethod def expand(cls, expr_format: Text) -> Tuple[List[List[str]], Dict[str, Any]]: ... @classmethod def is_valid(cls, expression: Text) -> bool: ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4423795 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/cryptography/0000775000175000017500000000000000000000000025464 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/cryptography/__init__.pyi0000664000175000017500000000000000000000000027734 0ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/cryptography/exceptions.pyi0000664000175000017500000000040600000000000030370 0ustar00davedave00000000000000class AlreadyFinalized(Exception): ... class AlreadyUpdated(Exception): ... class InvalidKey(Exception): ... class InvalidSignature(Exception): ... class InvalidTag(Exception): ... class NotYetFinalized(Exception): ... class UnsupportedAlgorithm(Exception): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/cryptography/fernet.pyi0000664000175000017500000000240200000000000027470 0ustar00davedave00000000000000from typing import List, Optional, Text, Union class InvalidToken(Exception): ... class Fernet(object): def __init__(self, key: Union[bytes, Text]) -> None: ... def decrypt(self, token: bytes, ttl: Optional[int] = ...) -> bytes: ... # decrypt_at_time accepts None ttl at runtime but it's an implementtion detail and it doesn't really # make sense for the client code to use it like that, so the parameter is typed as int as opposed to # Optional[int]. def decrypt_at_time(self, token: bytes, ttl: int, current_time: int) -> bytes: ... def encrypt(self, data: bytes) -> bytes: ... def encrypt_at_time(self, data: bytes, current_time: int) -> bytes: ... def extract_timestamp(self, token: bytes) -> int: ... @classmethod def generate_key(cls) -> bytes: ... class MultiFernet(object): def __init__(self, fernets: List[Fernet]) -> None: ... def decrypt(self, token: bytes, ttl: Optional[int] = ...) -> bytes: ... # See a note above on the typing of the ttl parameter. def decrypt_at_time(self, token: bytes, ttl: int, current_time: int) -> bytes: ... def encrypt(self, data: bytes) -> bytes: ... def encrypt_at_time(self, data: bytes, current_time: int) -> bytes: ... def rotate(self, msg: bytes) -> bytes: ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4423795 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/cryptography/hazmat/0000775000175000017500000000000000000000000026750 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/cryptography/hazmat/__init__.pyi0000664000175000017500000000007700000000000031236 0ustar00davedave00000000000000from typing import Any def __getattr__(name: str) -> Any: ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4423795 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/cryptography/hazmat/backends/0000775000175000017500000000000000000000000030522 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/cryptography/hazmat/backends/__init__.pyi0000664000175000017500000000017400000000000033006 0ustar00davedave00000000000000from typing import Any def default_backend() -> Any: ... # TODO: add some backends def __getattr__(name: str) -> Any: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/cryptography/hazmat/backends/interfaces.pyi0000664000175000017500000002005600000000000033373 0ustar00davedave00000000000000from abc import ABCMeta, abstractmethod from typing import Any, Optional, Union from cryptography.hazmat.primitives.asymmetric.dh import ( DHParameterNumbers, DHParameters, DHPrivateKey, DHPrivateNumbers, DHPublicKey, DHPublicNumbers, ) from cryptography.hazmat.primitives.asymmetric.dsa import ( DSAParameterNumbers, DSAParameters, DSAPrivateKey, DSAPrivateNumbers, DSAPublicKey, DSAPublicNumbers, ) from cryptography.hazmat.primitives.asymmetric.ec import ( EllipticCurve, EllipticCurvePrivateKey, EllipticCurvePrivateNumbers, EllipticCurvePublicKey, EllipticCurvePublicNumbers, EllipticCurveSignatureAlgorithm, ) from cryptography.hazmat.primitives.asymmetric.padding import AsymmetricPadding from cryptography.hazmat.primitives.asymmetric.rsa import RSAPrivateKey, RSAPrivateNumbers, RSAPublicKey, RSAPublicNumbers from cryptography.hazmat.primitives.ciphers import BlockCipherAlgorithm, CipherAlgorithm, CipherContext from cryptography.hazmat.primitives.ciphers.modes import Mode from cryptography.hazmat.primitives.hashes import HashAlgorithm, HashContext from cryptography.x509 import ( Certificate, CertificateBuilder, CertificateRevocationList, CertificateRevocationListBuilder, CertificateSigningRequest, CertificateSigningRequestBuilder, Name, RevokedCertificate, RevokedCertificateBuilder, ) class CipherBackend(metaclass=ABCMeta): @abstractmethod def cipher_supported(self, cipher: CipherAlgorithm, mode: Mode) -> bool: ... @abstractmethod def create_symmetric_encryption_ctx(self, cipher: CipherAlgorithm, mode: Mode) -> CipherContext: ... @abstractmethod def create_symmetric_decryption_ctx(self, cipher: CipherAlgorithm, mode: Mode) -> CipherContext: ... class CMACBackend(metaclass=ABCMeta): @abstractmethod def cmac_algorithm_supported(self, algorithm: BlockCipherAlgorithm) -> bool: ... @abstractmethod def create_cmac_ctx(self, algorithm: BlockCipherAlgorithm) -> Any: ... class DERSerializationBackend(metaclass=ABCMeta): @abstractmethod def load_der_parameters(self, data: bytes) -> Any: ... @abstractmethod def load_der_private_key(self, data: bytes, password: Optional[bytes]) -> Any: ... @abstractmethod def load_der_public_key(self, data: bytes) -> Any: ... class DHBackend(metaclass=ABCMeta): @abstractmethod def dh_parameters_supported(self, p: int, g: int, q: Optional[int]) -> bool: ... @abstractmethod def dh_x942_serialization_supported(self) -> bool: ... @abstractmethod def generate_dh_parameters(self, generator: int, key_size: int) -> DHParameters: ... @abstractmethod def generate_dh_private_key(self, parameters: DHParameters) -> DHPrivateKey: ... @abstractmethod def generate_dh_private_key_and_parameters(self, generator: int, key_size: int) -> DHPrivateKey: ... @abstractmethod def load_dh_parameter_numbers(self, numbers: DHParameterNumbers) -> DHParameters: ... @abstractmethod def load_dh_private_numbers(self, numbers: DHPrivateNumbers) -> DHPrivateKey: ... @abstractmethod def load_dh_public_numbers(self, numbers: DHPublicNumbers) -> DHPublicKey: ... class DSABackend(metaclass=ABCMeta): @abstractmethod def dsa_hash_supported(self, algorithm: HashAlgorithm) -> bool: ... @abstractmethod def dsa_parameters_supported(self, p: int, q: int, g: int) -> bool: ... @abstractmethod def generate_dsa_parameters(self, key_size: int) -> DSAParameters: ... @abstractmethod def generate_dsa_private_key(self, parameters: DSAParameters) -> DSAPrivateKey: ... @abstractmethod def generate_dsa_private_key_and_parameters(self, key_size: int) -> DSAPrivateKey: ... @abstractmethod def load_dsa_parameter_numbers(self, numbers: DSAParameterNumbers) -> DSAParameters: ... @abstractmethod def load_dsa_private_numbers(self, numbers: DSAPrivateNumbers) -> DSAPrivateKey: ... @abstractmethod def load_dsa_public_numbers(self, numbers: DSAPublicNumbers) -> DSAPublicKey: ... class EllipticCurveBackend(metaclass=ABCMeta): @abstractmethod def derive_elliptic_curve_private_key(self, private_value: int, curve: EllipticCurve) -> EllipticCurvePrivateKey: ... @abstractmethod def elliptic_curve_signature_algorithm_supported( self, signature_algorithm: EllipticCurveSignatureAlgorithm, curve: EllipticCurve ) -> bool: ... @abstractmethod def elliptic_curve_supported(self, curve: EllipticCurve) -> bool: ... @abstractmethod def generate_elliptic_curve_private_key(self, curve: EllipticCurve) -> EllipticCurvePrivateKey: ... @abstractmethod def load_elliptic_curve_private_numbers(self, numbers: EllipticCurvePrivateNumbers) -> EllipticCurvePrivateKey: ... @abstractmethod def load_elliptic_curve_public_numbers(self, numbers: EllipticCurvePublicNumbers) -> EllipticCurvePublicKey: ... class HMACBackend(metaclass=ABCMeta): @abstractmethod def create_hmac_ctx(self, key: bytes, algorithm: HashAlgorithm) -> HashContext: ... @abstractmethod def cmac_algorithm_supported(self, algorithm: HashAlgorithm) -> bool: ... class HashBackend(metaclass=ABCMeta): @abstractmethod def create_hash_ctx(self, algorithm: HashAlgorithm) -> HashContext: ... @abstractmethod def hash_supported(self, algorithm: HashAlgorithm) -> bool: ... class PBKDF2HMACBackend(metaclass=ABCMeta): @abstractmethod def derive_pbkdf2_hmac( self, algorithm: HashAlgorithm, length: int, salt: bytes, iterations: int, key_material: bytes ) -> bytes: ... @abstractmethod def pbkdf2_hmac_supported(self, algorithm: HashAlgorithm) -> bool: ... class PEMSerializationBackend(metaclass=ABCMeta): @abstractmethod def load_pem_parameters(self, data: bytes) -> Any: ... @abstractmethod def load_pem_private_key(self, data: bytes, password: Optional[bytes]) -> Any: ... @abstractmethod def load_pem_public_key(self, data: bytes) -> Any: ... class RSABackend(metaclass=ABCMeta): @abstractmethod def generate_rsa_parameters_supported(self, public_exponent: int, key_size: int) -> bool: ... @abstractmethod def generate_rsa_private_key(self, public_exponent: int, key_size: int) -> RSAPrivateKey: ... @abstractmethod def load_rsa_public_numbers(self, numbers: RSAPublicNumbers) -> RSAPublicKey: ... @abstractmethod def load_rsa_private_numbers(self, numbers: RSAPrivateNumbers) -> RSAPrivateKey: ... @abstractmethod def rsa_padding_supported(self, padding: AsymmetricPadding) -> bool: ... class ScryptBackend(metaclass=ABCMeta): @abstractmethod def derive_scrypt(self, key_material: bytes, salt: bytes, length: int, n: int, r: int, p: int) -> bytes: ... class X509Backend(metaclass=ABCMeta): @abstractmethod def create_x509_certificate( self, builder: CertificateBuilder, private_key: Union[DSAPrivateKey, EllipticCurvePrivateKey, RSAPrivateKey], algorithm: HashAlgorithm, ) -> Certificate: ... @abstractmethod def create_x509_crl( self, builder: CertificateRevocationListBuilder, private_key: Union[DSAPrivateKey, EllipticCurvePrivateKey, RSAPrivateKey], algorithm: HashAlgorithm, ) -> CertificateRevocationList: ... @abstractmethod def create_x509_csr( self, builder: CertificateSigningRequestBuilder, private_key: Union[DSAPrivateKey, EllipticCurvePrivateKey, RSAPrivateKey], algorithm: HashAlgorithm, ) -> CertificateSigningRequest: ... @abstractmethod def create_x509_revoked_certificate(self, builder: RevokedCertificateBuilder) -> RevokedCertificate: ... @abstractmethod def load_der_x509_certificate(self, data: bytes) -> Certificate: ... @abstractmethod def load_der_x509_csr(self, data: bytes) -> CertificateSigningRequest: ... @abstractmethod def load_pem_x509_certificate(self, data: bytes) -> Certificate: ... @abstractmethod def load_pem_x509_csr(self, data: bytes) -> CertificateSigningRequest: ... @abstractmethod def x509_name_bytes(self, name: Name) -> bytes: ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4423795 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/cryptography/hazmat/bindings/0000775000175000017500000000000000000000000030545 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/cryptography/hazmat/bindings/__init__.pyi0000664000175000017500000000000000000000000033015 0ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4423795 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/cryptography/hazmat/bindings/openssl/0000775000175000017500000000000000000000000032230 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000021100000000000011447 xustar0000000000000000115 path=jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/cryptography/hazmat/bindings/openssl/__init__.pyi 22 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/cryptography/hazmat/bindings/openssl/__init_0000664000175000017500000000000000000000000033541 0ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000021000000000000011446 xustar0000000000000000114 path=jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/cryptography/hazmat/bindings/openssl/binding.pyi 22 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/cryptography/hazmat/bindings/openssl/binding0000664000175000017500000000022400000000000033563 0ustar00davedave00000000000000from typing import Any, Optional class Binding(object): ffi: Optional[Any] lib: Optional[Any] def init_static_locks(self) -> None: ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4423795 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/cryptography/hazmat/primitives/0000775000175000017500000000000000000000000031143 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/cryptography/hazmat/primitives/__init__.pyi0000664000175000017500000000007700000000000033431 0ustar00davedave00000000000000from typing import Any def __getattr__(name: str) -> Any: ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4423795 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/cryptography/hazmat/primitives/asymmetric/0000775000175000017500000000000000000000000033320 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000021600000000000011454 xustar0000000000000000120 path=jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/cryptography/hazmat/primitives/asymmetric/__init__.pyi 22 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/cryptography/hazmat/primitives/asymmetric/__0000664000175000017500000000007700000000000033624 0ustar00davedave00000000000000from typing import Any def __getattr__(name: str) -> Any: ... ././@PaxHeader0000000000000000000000000000021000000000000011446 xustar0000000000000000114 path=jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/cryptography/hazmat/primitives/asymmetric/dh.pyi 22 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/cryptography/hazmat/primitives/asymmetric/dh0000664000175000017500000000513300000000000033640 0ustar00davedave00000000000000from abc import ABCMeta, abstractmethod from typing import Optional from cryptography.hazmat.backends.interfaces import DHBackend from cryptography.hazmat.primitives.serialization import ( Encoding, KeySerializationEncryption, ParameterFormat, PrivateFormat, PublicFormat, ) class DHParameters(metaclass=ABCMeta): @abstractmethod def generate_private_key(self) -> DHPrivateKey: ... @abstractmethod def parameter_bytes(self, encoding: Encoding, format: ParameterFormat) -> bytes: ... @abstractmethod def parameter_numbers(self) -> DHParameterNumbers: ... DHParametersWithSerialization = DHParameters class DHParameterNumbers(object): @property def p(self) -> int: ... @property def g(self) -> int: ... @property def q(self) -> int: ... def __init__(self, p: int, g: int, q: Optional[int]) -> None: ... def parameters(self, backend: Optional[DHBackend] = ...) -> DHParameters: ... class DHPrivateKey(metaclass=ABCMeta): key_size: int @abstractmethod def exchange(self, peer_public_key: DHPublicKey) -> bytes: ... @abstractmethod def parameters(self) -> DHParameters: ... @abstractmethod def public_key(self) -> DHPublicKey: ... class DHPrivateKeyWithSerialization(DHPrivateKey): @abstractmethod def private_bytes( self, encoding: Encoding, format: PrivateFormat, encryption_algorithm: KeySerializationEncryption ) -> bytes: ... @abstractmethod def private_numbers(self) -> DHPrivateNumbers: ... class DHPrivateNumbers(object): @property def public_numbers(self) -> DHPublicNumbers: ... @property def x(self) -> int: ... def __init__(self, x: int, public_numbers: DHPublicNumbers) -> None: ... def private_key(self, backend: Optional[DHBackend] = ...) -> DHPrivateKey: ... class DHPublicKey(metaclass=ABCMeta): @property @abstractmethod def key_size(self) -> int: ... @abstractmethod def parameters(self) -> DHParameters: ... @abstractmethod def public_bytes(self, encoding: Encoding, format: PublicFormat) -> bytes: ... @abstractmethod def public_numbers(self) -> DHPublicNumbers: ... DHPublicKeyWithSerialization = DHPublicKey class DHPublicNumbers(object): @property def parameter_numbers(self) -> DHParameterNumbers: ... @property def y(self) -> int: ... def __init__(self, y: int, parameter_numbers: DHParameterNumbers) -> None: ... def public_key(self, backend: Optional[DHBackend] = ...) -> DHPublicKey: ... def generate_parameters(generator: int, key_size: int, backend: Optional[DHBackend] = ...) -> DHParameters: ... ././@PaxHeader0000000000000000000000000000021100000000000011447 xustar0000000000000000115 path=jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/cryptography/hazmat/primitives/asymmetric/dsa.pyi 22 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/cryptography/hazmat/primitives/asymmetric/ds0000664000175000017500000000562500000000000033661 0ustar00davedave00000000000000from abc import ABCMeta, abstractmethod from typing import Optional, Union from cryptography.hazmat.backends.interfaces import DSABackend from cryptography.hazmat.primitives.asymmetric import AsymmetricVerificationContext from cryptography.hazmat.primitives.asymmetric.utils import Prehashed from cryptography.hazmat.primitives.hashes import HashAlgorithm from cryptography.hazmat.primitives.serialization import Encoding, KeySerializationEncryption, PrivateFormat, PublicFormat class DSAParameters(metaclass=ABCMeta): @abstractmethod def generate_private_key(self) -> DSAPrivateKey: ... class DSAParametersWithNumbers(DSAParameters): @abstractmethod def parameter_numbers(self) -> DSAParameterNumbers: ... class DSAParameterNumbers(object): @property def p(self) -> int: ... @property def q(self) -> int: ... @property def g(self) -> int: ... def __init__(self, p: int, q: int, g: int) -> None: ... def parameters(self, backend: Optional[DSABackend] = ...) -> DSAParameters: ... class DSAPrivateKey(metaclass=ABCMeta): @property @abstractmethod def key_size(self) -> int: ... @abstractmethod def parameters(self) -> DSAParameters: ... @abstractmethod def public_key(self) -> DSAPublicKey: ... @abstractmethod def sign(self, data: bytes, algorithm: Union[HashAlgorithm, Prehashed]) -> bytes: ... class DSAPrivateKeyWithSerialization(DSAPrivateKey): @abstractmethod def private_bytes( self, encoding: Encoding, format: PrivateFormat, encryption_algorithm: KeySerializationEncryption ) -> bytes: ... @abstractmethod def private_numbers(self) -> DSAPrivateNumbers: ... class DSAPrivateNumbers(object): @property def x(self) -> int: ... @property def public_numbers(self) -> DSAPublicNumbers: ... def __init__(self, x: int, public_numbers: DSAPublicNumbers) -> None: ... class DSAPublicKey(metaclass=ABCMeta): @property @abstractmethod def key_size(self) -> int: ... @abstractmethod def public_bytes(self, encoding: Encoding, format: PublicFormat) -> bytes: ... @abstractmethod def public_numbers(self) -> DSAPublicNumbers: ... @abstractmethod def verifier( self, signature: bytes, signature_algorithm: Union[HashAlgorithm, Prehashed] ) -> AsymmetricVerificationContext: ... @abstractmethod def verify(self, signature: bytes, data: bytes, algorithm: Union[HashAlgorithm, Prehashed]) -> None: ... DSAPublicKeyWithSerialization = DSAPublicKey class DSAPublicNumbers(object): @property def y(self) -> int: ... @property def parameter_numbers(self) -> DSAParameterNumbers: ... def __init__(self, y: int, parameter_numbers: DSAParameterNumbers) -> None: ... def generate_parameters(key_size: int, backend: Optional[DSABackend] = ...) -> DSAParameters: ... def generate_private_key(key_size: int, backend: Optional[DSABackend] = ...) -> DSAPrivateKey: ... ././@PaxHeader0000000000000000000000000000021000000000000011446 xustar0000000000000000114 path=jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/cryptography/hazmat/primitives/asymmetric/ec.pyi 22 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/cryptography/hazmat/primitives/asymmetric/ec0000664000175000017500000001430400000000000033634 0ustar00davedave00000000000000from abc import ABCMeta, abstractmethod from typing import ClassVar, Optional, Union from cryptography.hazmat.backends.interfaces import EllipticCurveBackend from cryptography.hazmat.primitives.asymmetric import AsymmetricVerificationContext from cryptography.hazmat.primitives.asymmetric.utils import Prehashed from cryptography.hazmat.primitives.hashes import HashAlgorithm from cryptography.hazmat.primitives.serialization import Encoding, KeySerializationEncryption, PrivateFormat, PublicFormat from cryptography.x509 import ObjectIdentifier class EllipticCurve(metaclass=ABCMeta): @property @abstractmethod def key_size(self) -> int: ... @property @abstractmethod def name(self) -> str: ... class BrainpoolP256R1(EllipticCurve): key_size: int = ... name: str = ... class BrainpoolP384R1(EllipticCurve): key_size: int = ... name: str = ... class BrainpoolP512R1(EllipticCurve): key_size: int = ... name: str = ... class SECP192R1(EllipticCurve): key_size: int = ... name: str = ... class SECP224R1(EllipticCurve): key_size: int = ... name: str = ... class SECP256K1(EllipticCurve): key_size: int = ... name: str = ... class SECP256R1(EllipticCurve): key_size: int = ... name: str = ... class SECP384R1(EllipticCurve): key_size: int = ... name: str = ... class SECP521R1(EllipticCurve): key_size: int = ... name: str = ... class SECT163K1(EllipticCurve): key_size: int = ... name: str = ... class SECT163R2(EllipticCurve): key_size: int = ... name: str = ... class SECT233K1(EllipticCurve): key_size: int = ... name: str = ... class SECT233R1(EllipticCurve): key_size: int = ... name: str = ... class SECT283K1(EllipticCurve): key_size: int = ... name: str = ... class SECT283R1(EllipticCurve): key_size: int = ... name: str = ... class SECT409K1(EllipticCurve): key_size: int = ... name: str = ... class SECT409R1(EllipticCurve): key_size: int = ... name: str = ... class SECT571K1(EllipticCurve): key_size: int = ... name: str = ... class SECT571R1(EllipticCurve): key_size: int = ... name: str = ... class EllipticCurveOID(object): SECP192R1: ClassVar[ObjectIdentifier] SECP224R1: ClassVar[ObjectIdentifier] SECP256K1: ClassVar[ObjectIdentifier] SECP256R1: ClassVar[ObjectIdentifier] SECP384R1: ClassVar[ObjectIdentifier] SECP521R1: ClassVar[ObjectIdentifier] BRAINPOOLP256R1: ClassVar[ObjectIdentifier] BRAINPOOLP384R1: ClassVar[ObjectIdentifier] BRAINPOOLP512R1: ClassVar[ObjectIdentifier] SECT163K1: ClassVar[ObjectIdentifier] SECT163R2: ClassVar[ObjectIdentifier] SECT233K1: ClassVar[ObjectIdentifier] SECT233R1: ClassVar[ObjectIdentifier] SECT283K1: ClassVar[ObjectIdentifier] SECT283R1: ClassVar[ObjectIdentifier] SECT409K1: ClassVar[ObjectIdentifier] SECT409R1: ClassVar[ObjectIdentifier] SECT571K1: ClassVar[ObjectIdentifier] SECT571R1: ClassVar[ObjectIdentifier] class EllipticCurvePrivateKey(metaclass=ABCMeta): @property @abstractmethod def curve(self) -> EllipticCurve: ... @property @abstractmethod def key_size(self) -> int: ... @abstractmethod def exchange(self, algorithm: ECDH, peer_public_key: EllipticCurvePublicKey) -> bytes: ... @abstractmethod def public_key(self) -> EllipticCurvePublicKey: ... @abstractmethod def sign(self, data: bytes, signature_algorithm: EllipticCurveSignatureAlgorithm) -> bytes: ... class EllipticCurvePrivateKeyWithSerialization(EllipticCurvePrivateKey): @abstractmethod def private_bytes( self, encoding: Encoding, format: PrivateFormat, encryption_algorithm: KeySerializationEncryption ) -> bytes: ... @abstractmethod def private_numbers(self) -> EllipticCurvePrivateNumbers: ... class EllipticCurvePrivateNumbers(object): @property def private_value(self) -> int: ... @property def public_numbers(self) -> EllipticCurvePublicNumbers: ... def __init__(self, private_value: int, public_numbers: EllipticCurvePublicNumbers) -> None: ... def private_key(self, backend: Optional[EllipticCurveBackend] = ...) -> EllipticCurvePrivateKey: ... class EllipticCurvePublicKey(metaclass=ABCMeta): @property @abstractmethod def curve(self) -> EllipticCurve: ... @property @abstractmethod def key_size(self) -> int: ... @classmethod def from_encoded_point(cls, curve: EllipticCurve, data: bytes) -> EllipticCurvePublicKey: ... @abstractmethod def public_bytes(self, encoding: Encoding, format: PublicFormat) -> bytes: ... @abstractmethod def public_numbers(self) -> EllipticCurvePublicNumbers: ... @abstractmethod def verifier( self, signature: bytes, signature_algorithm: EllipticCurveSignatureAlgorithm ) -> AsymmetricVerificationContext: ... @abstractmethod def verify(self, signature: bytes, data: bytes, signature_algorithm: EllipticCurveSignatureAlgorithm) -> None: ... EllipticCurvePublicKeyWithSerialization = EllipticCurvePublicKey class EllipticCurvePublicNumbers(object): @property def curve(self) -> EllipticCurve: ... @property def x(self) -> int: ... @property def y(self) -> int: ... def __init__(self, x: int, y: int, curve: EllipticCurve) -> None: ... @classmethod def from_encoded_point(cls, curve: EllipticCurve, data: bytes) -> EllipticCurvePublicNumbers: ... def public_key(self, backend: Optional[EllipticCurveBackend] = ...) -> EllipticCurvePublicKey: ... class EllipticCurveSignatureAlgorithm(metaclass=ABCMeta): @property @abstractmethod def algorithm(self) -> Union[HashAlgorithm, Prehashed]: ... class ECDH(object): ... class ECDSA(EllipticCurveSignatureAlgorithm): def __init__(self, algorithm: Union[HashAlgorithm, Prehashed]): ... @property def algorithm(self) -> Union[HashAlgorithm, Prehashed]: ... def derive_private_key( private_value: int, curve: EllipticCurve, backend: Optional[EllipticCurveBackend] = ... ) -> EllipticCurvePrivateKey: ... def generate_private_key(curve: EllipticCurve, backend: Optional[EllipticCurveBackend] = ...) -> EllipticCurvePrivateKey: ... def get_curve_for_oid(oid: ObjectIdentifier) -> EllipticCurve: ... ././@PaxHeader0000000000000000000000000000021500000000000011453 xustar0000000000000000119 path=jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/cryptography/hazmat/primitives/asymmetric/ed25519.pyi 22 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/cryptography/hazmat/primitives/asymmetric/ed0000664000175000017500000000173100000000000033635 0ustar00davedave00000000000000from abc import ABCMeta, abstractmethod from cryptography.hazmat.primitives.serialization import Encoding, KeySerializationEncryption, PrivateFormat, PublicFormat class Ed25519PrivateKey(metaclass=ABCMeta): @classmethod def generate(cls) -> Ed25519PrivateKey: ... @classmethod def from_private_bytes(cls, data: bytes) -> Ed25519PrivateKey: ... @abstractmethod def private_bytes( self, encoding: Encoding, format: PrivateFormat, encryption_algorithm: KeySerializationEncryption ) -> bytes: ... @abstractmethod def public_key(self) -> Ed25519PublicKey: ... @abstractmethod def sign(self, data: bytes) -> bytes: ... class Ed25519PublicKey(metaclass=ABCMeta): @classmethod def from_public_bytes(cls, data: bytes) -> Ed25519PublicKey: ... @abstractmethod def public_bytes(self, encoding: Encoding, format: PublicFormat) -> bytes: ... @abstractmethod def verify(self, signature: bytes, data: bytes) -> None: ... ././@PaxHeader0000000000000000000000000000021300000000000011451 xustar0000000000000000117 path=jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/cryptography/hazmat/primitives/asymmetric/ed448.pyi 22 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/cryptography/hazmat/primitives/asymmetric/ed0000664000175000017500000000171500000000000033637 0ustar00davedave00000000000000from abc import ABCMeta, abstractmethod from cryptography.hazmat.primitives.serialization import Encoding, KeySerializationEncryption, PrivateFormat, PublicFormat class Ed448PrivateKey(metaclass=ABCMeta): @classmethod def generate(cls) -> Ed448PrivateKey: ... @classmethod def from_private_bytes(cls, data: bytes) -> Ed448PrivateKey: ... @abstractmethod def private_bytes( self, encoding: Encoding, format: PrivateFormat, encryption_algorithm: KeySerializationEncryption ) -> bytes: ... @abstractmethod def public_key(self) -> Ed448PublicKey: ... @abstractmethod def sign(self, data: bytes) -> bytes: ... class Ed448PublicKey(metaclass=ABCMeta): @classmethod def from_public_bytes(cls, data: bytes) -> Ed448PublicKey: ... @abstractmethod def public_bytes(self, encoding: Encoding, format: PublicFormat) -> bytes: ... @abstractmethod def verify(self, signature: bytes, data: bytes) -> None: ... ././@PaxHeader0000000000000000000000000000021500000000000011453 xustar0000000000000000119 path=jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/cryptography/hazmat/primitives/asymmetric/padding.pyi 22 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/cryptography/hazmat/primitives/asymmetric/pa0000664000175000017500000000142300000000000033643 0ustar00davedave00000000000000from abc import ABCMeta, abstractmethod from typing import ClassVar, Optional, Union from cryptography.hazmat.primitives.hashes import HashAlgorithm class AsymmetricPadding(metaclass=ABCMeta): @property @abstractmethod def name(self) -> str: ... class MGF1(object): def __init__(self, algorithm: HashAlgorithm) -> None: ... class OAEP(AsymmetricPadding): def __init__(self, mgf: MGF1, algorithm: HashAlgorithm, label: Optional[bytes]) -> None: ... @property def name(self) -> str: ... class PKCS1v15(AsymmetricPadding): @property def name(self) -> str: ... class PSS(AsymmetricPadding): MAX_LENGTH: ClassVar[object] def __init__(self, mgf: MGF1, salt_length: Union[int, object]) -> None: ... @property def name(self) -> str: ... ././@PaxHeader0000000000000000000000000000021100000000000011447 xustar0000000000000000115 path=jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/cryptography/hazmat/primitives/asymmetric/rsa.pyi 22 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/cryptography/hazmat/primitives/asymmetric/rs0000664000175000017500000000633000000000000033671 0ustar00davedave00000000000000from abc import ABCMeta, abstractmethod from typing import Optional, Tuple, Union from cryptography.hazmat.backends.interfaces import RSABackend from cryptography.hazmat.primitives.asymmetric import AsymmetricVerificationContext from cryptography.hazmat.primitives.asymmetric.padding import AsymmetricPadding from cryptography.hazmat.primitives.asymmetric.utils import Prehashed from cryptography.hazmat.primitives.hashes import HashAlgorithm from cryptography.hazmat.primitives.serialization import Encoding, KeySerializationEncryption, PrivateFormat, PublicFormat class RSAPrivateKey(metaclass=ABCMeta): @property @abstractmethod def key_size(self) -> int: ... @abstractmethod def decrypt(self, ciphertext: bytes, padding: AsymmetricPadding) -> bytes: ... @abstractmethod def public_key(self) -> RSAPublicKey: ... @abstractmethod def sign(self, data: bytes, padding: AsymmetricPadding, algorithm: Union[HashAlgorithm, Prehashed]) -> bytes: ... class RSAPrivateKeyWithSerialization(RSAPrivateKey): @abstractmethod def private_bytes( self, encoding: Encoding, format: PrivateFormat, encryption_algorithm: KeySerializationEncryption ) -> bytes: ... @abstractmethod def private_numbers(self) -> RSAPrivateNumbers: ... class RSAPublicKey(metaclass=ABCMeta): @property @abstractmethod def key_size(self) -> int: ... @abstractmethod def encrypt(self, plaintext: bytes, padding: AsymmetricPadding) -> bytes: ... @abstractmethod def public_bytes(self, encoding: Encoding, format: PublicFormat) -> bytes: ... @abstractmethod def public_numbers(self) -> RSAPublicNumbers: ... @abstractmethod def verifier( self, signature: bytes, padding: AsymmetricPadding, algorithm: Union[HashAlgorithm, Prehashed] ) -> AsymmetricVerificationContext: ... @abstractmethod def verify( self, signature: bytes, data: bytes, padding: AsymmetricPadding, algorithm: Union[HashAlgorithm, Prehashed] ) -> None: ... RSAPublicKeyWithSerialization = RSAPublicKey def generate_private_key( public_exponent: int, key_size: int, backend: Optional[RSABackend] = ... ) -> RSAPrivateKeyWithSerialization: ... def rsa_crt_iqmp(p: int, q: int) -> int: ... def rsa_crt_dmp1(private_exponent: int, p: int) -> int: ... def rsa_crt_dmq1(private_exponent: int, q: int) -> int: ... def rsa_recover_prime_factors(n: int, e: int, d: int) -> Tuple[int, int]: ... class RSAPrivateNumbers(object): def __init__(self, p: int, q: int, d: int, dmp1: int, dmq1: int, iqmp: int, public_numbers: RSAPublicNumbers) -> None: ... @property def p(self) -> int: ... @property def q(self) -> int: ... @property def d(self) -> int: ... @property def dmp1(self) -> int: ... @property def dmq1(self) -> int: ... @property def iqmp(self) -> int: ... @property def public_numbers(self) -> RSAPublicNumbers: ... def private_key(self, backend: Optional[RSABackend] = ...) -> RSAPrivateKey: ... class RSAPublicNumbers(object): def __init__(self, e: int, n: int) -> None: ... @property def e(self) -> int: ... @property def n(self) -> int: ... def public_key(self, backend: Optional[RSABackend] = ...) -> RSAPublicKey: ... ././@PaxHeader0000000000000000000000000000021300000000000011451 xustar0000000000000000117 path=jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/cryptography/hazmat/primitives/asymmetric/utils.pyi 22 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/cryptography/hazmat/primitives/asymmetric/ut0000664000175000017500000000062600000000000033677 0ustar00davedave00000000000000from typing import Tuple from cryptography.hazmat.primitives.hashes import HashAlgorithm def decode_dss_signature(signature: bytes) -> Tuple[int, int]: ... def encode_dss_signature(r: int, s: int) -> bytes: ... class Prehashed(object): _algorithm: HashAlgorithm # undocumented _digest_size: int # undocumented def __init__(self, algorithm: HashAlgorithm) -> None: ... digest_size: int ././@PaxHeader0000000000000000000000000000021400000000000011452 xustar0000000000000000118 path=jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/cryptography/hazmat/primitives/asymmetric/x25519.pyi 22 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/cryptography/hazmat/primitives/asymmetric/x20000664000175000017500000000162700000000000033602 0ustar00davedave00000000000000from abc import ABCMeta, abstractmethod from cryptography.hazmat.primitives.serialization import Encoding, KeySerializationEncryption, PrivateFormat, PublicFormat class X25519PrivateKey(metaclass=ABCMeta): @classmethod def from_private_bytes(cls, data: bytes) -> X25519PrivateKey: ... @classmethod def generate(cls) -> X25519PrivateKey: ... @abstractmethod def exchange(self, peer_public_key: X25519PublicKey) -> bytes: ... @abstractmethod def private_bytes( self, encoding: Encoding, format: PrivateFormat, encryption_algorithm: KeySerializationEncryption ) -> bytes: ... @abstractmethod def public_key(self) -> X25519PublicKey: ... class X25519PublicKey(metaclass=ABCMeta): @classmethod def from_public_bytes(cls, data: bytes) -> X25519PublicKey: ... @abstractmethod def public_bytes(self, encoding: Encoding, format: PublicFormat) -> bytes: ... ././@PaxHeader0000000000000000000000000000021200000000000011450 xustar0000000000000000116 path=jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/cryptography/hazmat/primitives/asymmetric/x448.pyi 22 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/cryptography/hazmat/primitives/asymmetric/x40000664000175000017500000000161100000000000033575 0ustar00davedave00000000000000from abc import ABCMeta, abstractmethod from cryptography.hazmat.primitives.serialization import Encoding, KeySerializationEncryption, PrivateFormat, PublicFormat class X448PrivateKey(metaclass=ABCMeta): @classmethod def from_private_bytes(cls, data: bytes) -> X448PrivateKey: ... @classmethod def generate(cls) -> X448PrivateKey: ... @abstractmethod def exchange(self, peer_public_key: X448PublicKey) -> bytes: ... @abstractmethod def private_bytes( self, encoding: Encoding, format: PrivateFormat, encryption_algorithm: KeySerializationEncryption ) -> bytes: ... @abstractmethod def public_key(self) -> X448PublicKey: ... class X448PublicKey(metaclass=ABCMeta): @classmethod def from_public_bytes(cls, data: bytes) -> X448PublicKey: ... @abstractmethod def public_bytes(self, encoding: Encoding, format: PublicFormat) -> bytes: ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4423795 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/cryptography/hazmat/primitives/ciphers/0000775000175000017500000000000000000000000032600 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000021300000000000011451 xustar0000000000000000117 path=jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/cryptography/hazmat/primitives/ciphers/__init__.pyi 22 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/cryptography/hazmat/primitives/ciphers/__ini0000664000175000017500000000252300000000000033602 0ustar00davedave00000000000000from abc import ABCMeta, abstractmethod from typing import Optional from cryptography.hazmat.backends.interfaces import CipherBackend from cryptography.hazmat.primitives.ciphers.modes import Mode class AEADCipherContext(metaclass=ABCMeta): @abstractmethod def authenticate_additional_data(self, data: bytes) -> None: ... class AEADDecryptionContext(metaclass=ABCMeta): @abstractmethod def finalize_with_tag(self, tag: bytes) -> bytes: ... class AEADEncryptionContext(metaclass=ABCMeta): @property @abstractmethod def tag(self) -> bytes: ... class BlockCipherAlgorithm(metaclass=ABCMeta): @property @abstractmethod def block_size(self) -> int: ... class Cipher(object): def __init__(self, algorithm: CipherAlgorithm, mode: Optional[Mode], backend: Optional[CipherBackend] = ...) -> None: ... def decryptor(self) -> CipherContext: ... def encryptor(self) -> CipherContext: ... class CipherAlgorithm(metaclass=ABCMeta): @property @abstractmethod def key_size(self) -> int: ... @property @abstractmethod def name(self) -> str: ... class CipherContext(metaclass=ABCMeta): @abstractmethod def finalize(self) -> bytes: ... @abstractmethod def update(self, data: bytes) -> bytes: ... @abstractmethod def update_into(self, data: bytes, buf: bytearray) -> int: ... ././@PaxHeader0000000000000000000000000000020700000000000011454 xustar0000000000000000113 path=jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/cryptography/hazmat/primitives/ciphers/aead.pyi 22 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/cryptography/hazmat/primitives/ciphers/aead.0000664000175000017500000000205100000000000033471 0ustar00davedave00000000000000from typing import Optional class AESCCM(object): def __init__(self, key: bytes, tag_length: Optional[int]) -> None: ... def decrypt(self, nonce: bytes, data: bytes, associated_data: Optional[bytes]) -> bytes: ... def encrypt(self, nonce: bytes, data: bytes, associated_data: Optional[bytes]) -> bytes: ... @classmethod def generate_key(cls, bit_length: int) -> bytes: ... class AESGCM(object): def __init__(self, key: bytes) -> None: ... def decrypt(self, nonce: bytes, data: bytes, associated_data: Optional[bytes]) -> bytes: ... def encrypt(self, nonce: bytes, data: bytes, associated_data: Optional[bytes]) -> bytes: ... @classmethod def generate_key(cls, bit_length: int) -> bytes: ... class ChaCha20Poly1305(object): def __init__(self, key: bytes) -> None: ... def decrypt(self, nonce: bytes, data: bytes, associated_data: Optional[bytes]) -> bytes: ... def encrypt(self, nonce: bytes, data: bytes, associated_data: Optional[bytes]) -> bytes: ... @classmethod def generate_key(cls) -> bytes: ... ././@PaxHeader0000000000000000000000000000021500000000000011453 xustar0000000000000000119 path=jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/cryptography/hazmat/primitives/ciphers/algorithms.pyi 22 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/cryptography/hazmat/primitives/ciphers/algor0000664000175000017500000000430500000000000033631 0ustar00davedave00000000000000from typing import FrozenSet from cryptography.hazmat.primitives.ciphers import BlockCipherAlgorithm, CipherAlgorithm from cryptography.hazmat.primitives.ciphers.modes import ModeWithNonce class AES(BlockCipherAlgorithm, CipherAlgorithm): def __init__(self, key: bytes) -> None: ... block_size: int = ... name: str = ... key_sizes: FrozenSet[int] = ... @property def key_size(self) -> int: ... class ARC4(CipherAlgorithm): def __init__(self, key: bytes) -> None: ... @property def key_size(self) -> int: ... name: str = ... key_sizes: FrozenSet[int] = ... class Blowfish(BlockCipherAlgorithm, CipherAlgorithm): def __init__(self, key: bytes) -> None: ... @property def key_size(self) -> int: ... block_size: int = ... name: str = ... key_sizes: FrozenSet[int] = ... class Camellia(BlockCipherAlgorithm, CipherAlgorithm): def __init__(self, key: bytes) -> None: ... @property def key_size(self) -> int: ... block_size: int = ... name: str = ... key_sizes: FrozenSet[int] = ... class CAST5(BlockCipherAlgorithm, CipherAlgorithm): def __init__(self, key: bytes) -> None: ... @property def key_size(self) -> int: ... block_size: int = ... name: str = ... key_sizes: FrozenSet[int] = ... class ChaCha20(CipherAlgorithm, ModeWithNonce): def __init__(self, key: bytes, nonce: bytes) -> None: ... @property def key_size(self) -> int: ... name: str = ... key_sizes: FrozenSet[int] = ... @property def nonce(self) -> bytes: ... class IDEA(CipherAlgorithm): def __init__(self, key: bytes) -> None: ... @property def key_size(self) -> int: ... block_size: int = ... name: str = ... key_sizes: FrozenSet[int] = ... class SEED(BlockCipherAlgorithm, CipherAlgorithm): def __init__(self, key: bytes) -> None: ... @property def key_size(self) -> int: ... block_size: int = ... name: str = ... key_sizes: FrozenSet[int] = ... class TripleDES(BlockCipherAlgorithm, CipherAlgorithm): def __init__(self, key: bytes) -> None: ... @property def key_size(self) -> int: ... block_size: int = ... name: str = ... key_sizes: FrozenSet[int] = ... ././@PaxHeader0000000000000000000000000000021000000000000011446 xustar0000000000000000114 path=jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/cryptography/hazmat/primitives/ciphers/modes.pyi 22 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/cryptography/hazmat/primitives/ciphers/modes0000664000175000017500000000602100000000000033631 0ustar00davedave00000000000000from abc import ABCMeta, abstractmethod from typing import Optional from cryptography.hazmat.primitives.ciphers import CipherAlgorithm class Mode(metaclass=ABCMeta): @property @abstractmethod def name(self) -> str: ... @abstractmethod def validate_for_algorithm(self, algorithm: CipherAlgorithm) -> None: ... class ModeWithAuthenticationTag(metaclass=ABCMeta): @property @abstractmethod def tag(self) -> bytes: ... class ModeWithInitializationVector(metaclass=ABCMeta): @property @abstractmethod def initialization_vector(self) -> bytes: ... class ModeWithNonce(metaclass=ABCMeta): @property @abstractmethod def nonce(self) -> bytes: ... class ModeWithTweak(metaclass=ABCMeta): @property @abstractmethod def tweak(self) -> bytes: ... class CBC(Mode, ModeWithInitializationVector): def __init__(self, initialization_vector: bytes) -> None: ... @property def initialization_vector(self) -> bytes: ... @property def name(self) -> str: ... def validate_for_algorithm(self, algorithm: CipherAlgorithm) -> None: ... class CTR(Mode, ModeWithNonce): def __init__(self, nonce: bytes) -> None: ... @property def name(self) -> str: ... @property def nonce(self) -> bytes: ... def validate_for_algorithm(self, algorithm: CipherAlgorithm) -> None: ... class CFB(Mode, ModeWithInitializationVector): def __init__(self, initialization_vector: bytes) -> None: ... @property def initialization_vector(self) -> bytes: ... @property def name(self) -> str: ... def validate_for_algorithm(self, algorithm: CipherAlgorithm) -> None: ... class CFB8(Mode, ModeWithInitializationVector): def __init__(self, initialization_vector: bytes) -> None: ... @property def initialization_vector(self) -> bytes: ... @property def name(self) -> str: ... def validate_for_algorithm(self, algorithm: CipherAlgorithm) -> None: ... class ECB(Mode): @property def name(self) -> str: ... def validate_for_algorithm(self, algorithm: CipherAlgorithm) -> None: ... class GCM(Mode, ModeWithInitializationVector, ModeWithAuthenticationTag): def __init__(self, initialization_vector: bytes, tag: Optional[bytes], min_tag_length: Optional[int]) -> None: ... @property def initialization_vector(self) -> bytes: ... @property def name(self) -> str: ... @property def tag(self) -> bytes: ... def validate_for_algorithm(self, algorithm: CipherAlgorithm) -> None: ... class OFB(Mode, ModeWithInitializationVector): def __init__(self, initialization_vector: bytes) -> None: ... @property def initialization_vector(self) -> bytes: ... @property def name(self) -> str: ... def validate_for_algorithm(self, algorithm: CipherAlgorithm) -> None: ... class XTS(Mode, ModeWithTweak): def __init__(self, tweak: bytes) -> None: ... @property def name(self) -> str: ... @property def tweak(self) -> bytes: ... def validate_for_algorithm(self, algorithm: CipherAlgorithm) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/cryptography/hazmat/primitives/cmac.pyi0000664000175000017500000000071500000000000032574 0ustar00davedave00000000000000from typing import Optional from cryptography.hazmat.backends.interfaces import CMACBackend from cryptography.hazmat.primitives.ciphers import BlockCipherAlgorithm class CMAC(object): def __init__(self, algorithm: BlockCipherAlgorithm, backend: Optional[CMACBackend] = ...) -> None: ... def copy(self) -> CMAC: ... def finalize(self) -> bytes: ... def update(self, data: bytes) -> None: ... def verify(self, signature: bytes) -> None: ... ././@PaxHeader0000000000000000000000000000021000000000000011446 xustar0000000000000000114 path=jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/cryptography/hazmat/primitives/constant_time.pyi 22 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/cryptography/hazmat/primitives/constant_time0000664000175000017500000000005600000000000033736 0ustar00davedave00000000000000def bytes_eq(a: bytes, b: bytes) -> bool: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/cryptography/hazmat/primitives/hashes.pyi0000664000175000017500000000247600000000000033152 0ustar00davedave00000000000000from abc import ABCMeta, abstractmethod from typing import Optional from cryptography.hazmat.backends.interfaces import HashBackend class HashAlgorithm(metaclass=ABCMeta): digest_size: int name: str class HashContext(metaclass=ABCMeta): algorithm: HashAlgorithm @abstractmethod def copy(self) -> HashContext: ... @abstractmethod def finalize(self) -> bytes: ... @abstractmethod def update(self, data: bytes) -> None: ... class BLAKE2b(HashAlgorithm): ... class BLAKE2s(HashAlgorithm): ... class MD5(HashAlgorithm): ... class SHA1(HashAlgorithm): ... class SHA224(HashAlgorithm): ... class SHA256(HashAlgorithm): ... class SHA384(HashAlgorithm): ... class SHA3_224(HashAlgorithm): ... class SHA3_256(HashAlgorithm): ... class SHA3_384(HashAlgorithm): ... class SHA3_512(HashAlgorithm): ... class SHA512(HashAlgorithm): ... class SHA512_224(HashAlgorithm): ... class SHA512_256(HashAlgorithm): ... class SHAKE128(HashAlgorithm): def __init__(self, digest_size: int) -> None: ... class SHAKE256(HashAlgorithm): def __init__(self, digest_size: int) -> None: ... class Hash(HashContext): def __init__(self, algorithm: HashAlgorithm, backend: Optional[HashBackend] = ...): ... def copy(self) -> Hash: ... def finalize(self) -> bytes: ... def update(self, data: bytes) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/cryptography/hazmat/primitives/hmac.pyi0000664000175000017500000000071100000000000032575 0ustar00davedave00000000000000from typing import Optional from cryptography.hazmat.backends.interfaces import HMACBackend from cryptography.hazmat.primitives.hashes import HashAlgorithm class HMAC(object): def __init__(self, key: bytes, algorithm: HashAlgorithm, backend: Optional[HMACBackend] = ...) -> None: ... def copy(self) -> HMAC: ... def finalize(self) -> bytes: ... def update(self, msg: bytes) -> None: ... def verify(self, signature: bytes) -> None: ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4463794 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/cryptography/hazmat/primitives/kdf/0000775000175000017500000000000000000000000031707 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000020700000000000011454 xustar0000000000000000113 path=jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/cryptography/hazmat/primitives/kdf/__init__.pyi 22 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/cryptography/hazmat/primitives/kdf/__init__.0000664000175000017500000000040500000000000033446 0ustar00davedave00000000000000from abc import ABCMeta, abstractmethod class KeyDerivationFunction(metaclass=ABCMeta): @abstractmethod def derive(self, key_material: bytes) -> bytes: ... @abstractmethod def verify(self, key_material: bytes, expected_key: bytes) -> None: ... ././@PaxHeader0000000000000000000000000000021000000000000011446 xustar0000000000000000114 path=jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/cryptography/hazmat/primitives/kdf/concatkdf.pyi 22 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/cryptography/hazmat/primitives/kdf/concatkdf0000664000175000017500000000166700000000000033600 0ustar00davedave00000000000000from typing import Optional from cryptography.hazmat.backends.interfaces import HashBackend, HMACBackend from cryptography.hazmat.primitives.hashes import HashAlgorithm from cryptography.hazmat.primitives.kdf import KeyDerivationFunction class ConcatKDFHash(KeyDerivationFunction): def __init__( self, algorithm: HashAlgorithm, length: int, otherinfo: Optional[bytes], backend: Optional[HashBackend] = ... ): ... def derive(self, key_material: bytes) -> bytes: ... def verify(self, key_material: bytes, expected_key: bytes) -> None: ... class ConcatKDFHMAC(KeyDerivationFunction): def __init__( self, algorithm: HashAlgorithm, length: int, salt: Optional[bytes], otherinfo: Optional[bytes], backend: Optional[HMACBackend] = ..., ): ... def derive(self, key_material: bytes) -> bytes: ... def verify(self, key_material: bytes, expected_key: bytes) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/cryptography/hazmat/primitives/kdf/hkdf.pyi0000664000175000017500000000160600000000000033351 0ustar00davedave00000000000000from typing import Optional from cryptography.hazmat.backends.interfaces import HMACBackend from cryptography.hazmat.primitives.hashes import HashAlgorithm from cryptography.hazmat.primitives.kdf import KeyDerivationFunction class HKDF(KeyDerivationFunction): def __init__( self, algorithm: HashAlgorithm, length: int, salt: Optional[bytes], info: Optional[bytes], backend: Optional[HMACBackend] = ..., ): ... def derive(self, key_material: bytes) -> bytes: ... def verify(self, key_material: bytes, expected_key: bytes) -> None: ... class HKDFExpand(KeyDerivationFunction): def __init__(self, algorithm: HashAlgorithm, length: int, info: Optional[bytes], backend: Optional[HMACBackend] = ...): ... def derive(self, key_material: bytes) -> bytes: ... def verify(self, key_material: bytes, expected_key: bytes) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/cryptography/hazmat/primitives/kdf/kbkdf.pyi0000664000175000017500000000154300000000000033516 0ustar00davedave00000000000000from enum import Enum from typing import Optional from cryptography.hazmat.backends.interfaces import HMACBackend from cryptography.hazmat.primitives.hashes import HashAlgorithm from cryptography.hazmat.primitives.kdf import KeyDerivationFunction class Mode(Enum): CounterMode: str class CounterLocation(Enum): BeforeFixed: str AfterFixed: str class KBKDFHMAC(KeyDerivationFunction): def __init__( self, algorithm: HashAlgorithm, mode: Mode, length: int, rlen: int, llen: int, location: CounterLocation, label: Optional[bytes], context: Optional[bytes], fixed: Optional[bytes], backend: Optional[HMACBackend] = ..., ): ... def derive(self, key_material: bytes) -> bytes: ... def verify(self, key_material: bytes, expected_key: bytes) -> None: ... ././@PaxHeader0000000000000000000000000000020500000000000011452 xustar0000000000000000111 path=jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/cryptography/hazmat/primitives/kdf/pbkdf2.pyi 22 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/cryptography/hazmat/primitives/kdf/pbkdf2.py0000664000175000017500000000106100000000000033427 0ustar00davedave00000000000000from typing import Optional from cryptography.hazmat.backends.interfaces import PBKDF2HMACBackend from cryptography.hazmat.primitives.hashes import HashAlgorithm from cryptography.hazmat.primitives.kdf import KeyDerivationFunction class PBKDF2HMAC(KeyDerivationFunction): def __init__( self, algorithm: HashAlgorithm, length: int, salt: bytes, iterations: int, backend: Optional[PBKDF2HMACBackend] = ... ): ... def derive(self, key_material: bytes) -> bytes: ... def verify(self, key_material: bytes, expected_key: bytes) -> None: ... ././@PaxHeader0000000000000000000000000000020500000000000011452 xustar0000000000000000111 path=jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/cryptography/hazmat/primitives/kdf/scrypt.pyi 22 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/cryptography/hazmat/primitives/kdf/scrypt.py0000664000175000017500000000070400000000000033606 0ustar00davedave00000000000000from typing import Optional from cryptography.hazmat.backends.interfaces import ScryptBackend from cryptography.hazmat.primitives.kdf import KeyDerivationFunction class Scrypt(KeyDerivationFunction): def __init__(self, salt: bytes, length: int, n: int, r: int, p: int, backend: Optional[ScryptBackend] = ...): ... def derive(self, key_material: bytes) -> bytes: ... def verify(self, key_material: bytes, expected_key: bytes) -> None: ... ././@PaxHeader0000000000000000000000000000020600000000000011453 xustar0000000000000000112 path=jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/cryptography/hazmat/primitives/kdf/x963kdf.pyi 22 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/cryptography/hazmat/primitives/kdf/x963kdf.p0000664000175000017500000000104100000000000033262 0ustar00davedave00000000000000from typing import Optional from cryptography.hazmat.backends.interfaces import HashBackend from cryptography.hazmat.primitives.hashes import HashAlgorithm from cryptography.hazmat.primitives.kdf import KeyDerivationFunction class X963KDF(KeyDerivationFunction): def __init__( self, algorithm: HashAlgorithm, length: int, sharedinfo: Optional[bytes], backend: Optional[HashBackend] = ... ): ... def derive(self, key_material: bytes) -> bytes: ... def verify(self, key_material: bytes, expected_key: bytes) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/cryptography/hazmat/primitives/keywrap.pyi0000664000175000017500000000114300000000000033347 0ustar00davedave00000000000000from typing import Optional from cryptography.hazmat.backends.interfaces import CipherBackend def aes_key_wrap(wrapping_key: bytes, key_to_wrap: bytes, backend: Optional[CipherBackend] = ...) -> bytes: ... def aes_key_wrap_with_padding(wrapping_key: bytes, key_to_wrap: bytes, backend: Optional[CipherBackend] = ...) -> bytes: ... def aes_key_unwrap(wrapping_key: bytes, wrapped_key: bytes, backend: Optional[CipherBackend] = ...) -> bytes: ... def aes_key_unwrap_with_padding(wrapping_key: bytes, wrapped_key: bytes, backend: Optional[CipherBackend] = ...) -> bytes: ... class InvalidUnwrap(Exception): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/cryptography/hazmat/primitives/padding.pyi0000664000175000017500000000103400000000000033272 0ustar00davedave00000000000000from abc import ABCMeta, abstractmethod class PaddingContext(metaclass=ABCMeta): @abstractmethod def finalize(self) -> bytes: ... @abstractmethod def update(self, data: bytes) -> bytes: ... class ANSIX923(object): def __init__(self, block_size: int) -> None: ... def padder(self) -> PaddingContext: ... def unpadder(self) -> PaddingContext: ... class PKCS7(object): def __init__(self, block_size: int) -> None: ... def padder(self) -> PaddingContext: ... def unpadder(self) -> PaddingContext: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/cryptography/hazmat/primitives/poly1305.pyi0000664000175000017500000000056700000000000033172 0ustar00davedave00000000000000class Poly1305(object): def __init__(self, key: bytes) -> None: ... def finalize(self) -> bytes: ... @classmethod def generate_tag(cls, key: bytes, data: bytes) -> bytes: ... def update(self, data: bytes) -> None: ... def verify(self, tag: bytes) -> None: ... @classmethod def verify_tag(cls, key: bytes, data: bytes, tag: bytes) -> None: ... ././@PaxHeader0000000000000000000000000000021300000000000011451 xustar0000000000000000111 path=jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/cryptography/hazmat/primitives/serialization/ 28 mtime=1696238359.4463794 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/cryptography/hazmat/primitives/serialization0000775000175000017500000000000000000000000033741 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000022100000000000011450 xustar0000000000000000123 path=jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/cryptography/hazmat/primitives/serialization/__init__.pyi 22 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/cryptography/hazmat/primitives/serialization0000664000175000017500000000446700000000000033756 0ustar00davedave00000000000000from abc import ABCMeta from enum import Enum from typing import Any, Optional, Union from cryptography.hazmat.backends.interfaces import ( DERSerializationBackend, DSABackend, EllipticCurveBackend, PEMSerializationBackend, RSABackend, ) from cryptography.hazmat.primitives.asymmetric.dh import DHPrivateKey, DHPublicKey from cryptography.hazmat.primitives.asymmetric.dsa import DSAPrivateKey, DSAPublicKey from cryptography.hazmat.primitives.asymmetric.ec import EllipticCurvePrivateKey, EllipticCurvePublicKey from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PublicKey from cryptography.hazmat.primitives.asymmetric.rsa import RSAPrivateKey, RSAPublicKey def load_pem_private_key( data: bytes, password: Optional[bytes], backend: Optional[PEMSerializationBackend] = ... ) -> Any: ... # actually Union[RSAPrivateKey, DSAPrivateKey, DHPrivateKey, EllipticCurvePrivateKey] def load_pem_public_key( data: bytes, backend: Optional[PEMSerializationBackend] = ... ) -> Any: ... # actually Union[RSAPublicKey, DSAPublicKey, DHPublicKey, EllipticCurvePublicKey] def load_der_private_key( data: bytes, password: Optional[bytes], backend: Optional[DERSerializationBackend] = ... ) -> Any: ... # actually Union[RSAPrivateKey, DSAPrivateKey, DHPrivateKey, EllipticCurvePrivateKey] def load_der_public_key( data: bytes, backend: Optional[DERSerializationBackend] = ... ) -> Any: ... # actually Union[RSAPublicKey, DSAPublicKey, DHPublicKey, EllipticCurvePublicKey] def load_ssh_public_key( data: bytes, backend: Union[RSABackend, DSABackend, EllipticCurveBackend, None] ) -> Any: ... # actually Union[RSAPublicKey, DSAPublicKey, DHPublicKey, EllipticCurvePublicKey, Ed25519PublicKey] class Encoding(Enum): PEM: str DER: str OpenSSH: str Raw: str X962: str class PrivateFormat(Enum): PKCS8: str TraditionalOpenSSL: str Raw: str class PublicFormat(Enum): SubjectPublicKeyInfo: str PKCS1: str OpenSSH: str Raw: str CompressedPoint: str UncompressedPoint: str class ParameterFormat(Enum): PKCS3: str class KeySerializationEncryption(metaclass=ABCMeta): ... class BestAvailableEncryption(KeySerializationEncryption): password: bytes def __init__(self, password: bytes) -> None: ... class NoEncryption(KeySerializationEncryption): ... ././@PaxHeader0000000000000000000000000000021700000000000011455 xustar0000000000000000121 path=jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/cryptography/hazmat/primitives/serialization/pkcs12.pyi 22 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/cryptography/hazmat/primitives/serialization0000664000175000017500000000164500000000000033751 0ustar00davedave00000000000000from typing import Any, List, Optional, Tuple, Union from cryptography.hazmat.primitives.asymmetric.dsa import DSAPrivateKeyWithSerialization from cryptography.hazmat.primitives.asymmetric.ec import EllipticCurvePrivateKeyWithSerialization from cryptography.hazmat.primitives.asymmetric.rsa import RSAPrivateKeyWithSerialization from cryptography.hazmat.primitives.serialization import KeySerializationEncryption from cryptography.x509 import Certificate def load_key_and_certificates( data: bytes, password: Optional[bytes], backend: Optional[Any] = ... ) -> Tuple[Optional[Any], Optional[Certificate], List[Certificate]]: ... def serialize_key_and_certificates( name: bytes, key: Union[RSAPrivateKeyWithSerialization, EllipticCurvePrivateKeyWithSerialization, DSAPrivateKeyWithSerialization], cert: Optional[Certificate], cas: Optional[List[Certificate]], enc: KeySerializationEncryption, ) -> bytes: ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4463794 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/cryptography/hazmat/primitives/twofactor/0000775000175000017500000000000000000000000033153 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000021500000000000011453 xustar0000000000000000119 path=jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/cryptography/hazmat/primitives/twofactor/__init__.pyi 22 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/cryptography/hazmat/primitives/twofactor/__i0000664000175000017500000000004300000000000033621 0ustar00davedave00000000000000class InvalidToken(Exception): ... ././@PaxHeader0000000000000000000000000000021100000000000011447 xustar0000000000000000115 path=jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/cryptography/hazmat/primitives/twofactor/hotp.pyi 22 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/cryptography/hazmat/primitives/twofactor/hot0000664000175000017500000000103400000000000033666 0ustar00davedave00000000000000from typing import Optional from cryptography.hazmat.backends.interfaces import HMACBackend from cryptography.hazmat.primitives.hashes import HashAlgorithm class HOTP(object): def __init__( self, key: bytes, length: int, algorithm: HashAlgorithm, backend: HMACBackend, enforce_key_length: bool = ... ): ... def generate(self, counter: int) -> bytes: ... def get_provisioning_uri(self, account_name: str, counter: int, issuer: Optional[str]) -> str: ... def verify(self, hotp: bytes, counter: int) -> None: ... ././@PaxHeader0000000000000000000000000000021100000000000011447 xustar0000000000000000115 path=jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/cryptography/hazmat/primitives/twofactor/totp.pyi 22 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/cryptography/hazmat/primitives/twofactor/tot0000664000175000017500000000111100000000000033676 0ustar00davedave00000000000000from typing import Optional from cryptography.hazmat.backends.interfaces import HMACBackend from cryptography.hazmat.primitives.hashes import HashAlgorithm class TOTP(object): def __init__( self, key: bytes, length: int, algorithm: HashAlgorithm, time_step: int, backend: HMACBackend, enforce_key_length: bool = ..., ): ... def generate(self, time: int) -> bytes: ... def get_provisioning_uri(self, account_name: str, issuer: Optional[str]) -> str: ... def verify(self, totp: bytes, time: int) -> None: ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4463794 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/cryptography/x509/0000775000175000017500000000000000000000000026171 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/cryptography/x509/__init__.pyi0000664000175000017500000004250600000000000030462 0ustar00davedave00000000000000import datetime from abc import ABCMeta, abstractmethod from enum import Enum from ipaddress import IPv4Address, IPv4Network, IPv6Address, IPv6Network from typing import Any, ClassVar, Generator, Generic, Iterable, List, Optional, Sequence, Text, Type, TypeVar, Union from cryptography.hazmat.backends.interfaces import X509Backend from cryptography.hazmat.primitives.asymmetric.dsa import DSAPrivateKey, DSAPublicKey from cryptography.hazmat.primitives.asymmetric.ec import EllipticCurvePrivateKey, EllipticCurvePublicKey from cryptography.hazmat.primitives.asymmetric.ed448 import Ed448PrivateKey, Ed448PublicKey from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PrivateKey, Ed25519PublicKey from cryptography.hazmat.primitives.asymmetric.rsa import RSAPrivateKey, RSAPublicKey from cryptography.hazmat.primitives.hashes import HashAlgorithm from cryptography.hazmat.primitives.serialization import Encoding class ObjectIdentifier(object): dotted_string: str def __init__(self, dotted_string: str) -> None: ... class CRLEntryExtensionOID(object): CERTIFICATE_ISSUER: ClassVar[ObjectIdentifier] CRL_REASON: ClassVar[ObjectIdentifier] INVALIDITY_DATE: ClassVar[ObjectIdentifier] class ExtensionOID(object): AUTHORITY_INFORMATION_ACCESS: ClassVar[ObjectIdentifier] AUTHORITY_KEY_IDENTIFIER: ClassVar[ObjectIdentifier] BASIC_CONSTRAINTS: ClassVar[ObjectIdentifier] CERTIFICATE_POLICIES: ClassVar[ObjectIdentifier] CRL_DISTRIBUTION_POINTS: ClassVar[ObjectIdentifier] CRL_NUMBER: ClassVar[ObjectIdentifier] DELTA_CRL_INDICATOR: ClassVar[ObjectIdentifier] EXTENDED_KEY_USAGE: ClassVar[ObjectIdentifier] FRESHEST_CRL: ClassVar[ObjectIdentifier] INHIBIT_ANY_POLICY: ClassVar[ObjectIdentifier] ISSUER_ALTERNATIVE_NAME: ClassVar[ObjectIdentifier] ISSUING_DISTRIBUTION_POINT: ClassVar[ObjectIdentifier] KEY_USAGE: ClassVar[ObjectIdentifier] NAME_CONSTRAINTS: ClassVar[ObjectIdentifier] OCSP_NO_CHECK: ClassVar[ObjectIdentifier] POLICY_CONSTRAINTS: ClassVar[ObjectIdentifier] POLICY_MAPPINGS: ClassVar[ObjectIdentifier] PRECERT_POISON: ClassVar[ObjectIdentifier] PRECERT_SIGNED_CERTIFICATE_TIMESTAMPS: ClassVar[ObjectIdentifier] SUBJECT_ALTERNATIVE_NAME: ClassVar[ObjectIdentifier] SUBJECT_DIRECTORY_ATTRIBUTES: ClassVar[ObjectIdentifier] SUBJECT_INFORMATION_ACCESS: ClassVar[ObjectIdentifier] SUBJECT_KEY_IDENTIFIER: ClassVar[ObjectIdentifier] TLS_FEATURE: ClassVar[ObjectIdentifier] class NameOID(object): BUSINESS_CATEGORY: ClassVar[ObjectIdentifier] COMMON_NAME: ClassVar[ObjectIdentifier] COUNTRY_NAME: ClassVar[ObjectIdentifier] DN_QUALIFIER: ClassVar[ObjectIdentifier] DOMAIN_COMPONENT: ClassVar[ObjectIdentifier] EMAIL_ADDRESS: ClassVar[ObjectIdentifier] GENERATION_QUALIFIER: ClassVar[ObjectIdentifier] GIVEN_NAME: ClassVar[ObjectIdentifier] JURISDICTION_COUNTRY_NAME: ClassVar[ObjectIdentifier] JURISDICTION_LOCALITY_NAME: ClassVar[ObjectIdentifier] JURISDICTION_STATE_OR_PROVINCE_NAME: ClassVar[ObjectIdentifier] LOCALITY_NAME: ClassVar[ObjectIdentifier] ORGANIZATIONAL_UNIT_NAME: ClassVar[ObjectIdentifier] ORGANIZATION_NAME: ClassVar[ObjectIdentifier] POSTAL_ADDRESS: ClassVar[ObjectIdentifier] POSTAL_CODE: ClassVar[ObjectIdentifier] PSEUDONYM: ClassVar[ObjectIdentifier] SERIAL_NUMBER: ClassVar[ObjectIdentifier] STATE_OR_PROVINCE_NAME: ClassVar[ObjectIdentifier] STREET_ADDRESS: ClassVar[ObjectIdentifier] SURNAME: ClassVar[ObjectIdentifier] TITLE: ClassVar[ObjectIdentifier] USER_ID: ClassVar[ObjectIdentifier] X500_UNIQUE_IDENTIFIER: ClassVar[ObjectIdentifier] class OCSPExtensionOID(object): NONCE: ClassVar[ObjectIdentifier] class SignatureAlgorithmOID(object): DSA_WITH_SHA1: ClassVar[ObjectIdentifier] DSA_WITH_SHA224: ClassVar[ObjectIdentifier] DSA_WITH_SHA256: ClassVar[ObjectIdentifier] ECDSA_WITH_SHA1: ClassVar[ObjectIdentifier] ECDSA_WITH_SHA224: ClassVar[ObjectIdentifier] ECDSA_WITH_SHA256: ClassVar[ObjectIdentifier] ECDSA_WITH_SHA384: ClassVar[ObjectIdentifier] ECDSA_WITH_SHA512: ClassVar[ObjectIdentifier] ED25519: ClassVar[ObjectIdentifier] ED448: ClassVar[ObjectIdentifier] RSASSA_PSS: ClassVar[ObjectIdentifier] RSA_WITH_MD5: ClassVar[ObjectIdentifier] RSA_WITH_SHA1: ClassVar[ObjectIdentifier] RSA_WITH_SHA224: ClassVar[ObjectIdentifier] RSA_WITH_SHA256: ClassVar[ObjectIdentifier] RSA_WITH_SHA384: ClassVar[ObjectIdentifier] RSA_WITH_SHA512: ClassVar[ObjectIdentifier] class ExtendedKeyUsageOID(object): SERVER_AUTH: ClassVar[ObjectIdentifier] CLIENT_AUTH: ClassVar[ObjectIdentifier] CODE_SIGNING: ClassVar[ObjectIdentifier] EMAIL_PROTECTION: ClassVar[ObjectIdentifier] TIME_STAMPING: ClassVar[ObjectIdentifier] OCSP_SIGNING: ClassVar[ObjectIdentifier] ANY_EXTENDED_KEY_USAGE: ClassVar[ObjectIdentifier] class NameAttribute(object): oid: ObjectIdentifier value: Text def __init__(self, oid: ObjectIdentifier, value: Text) -> None: ... def rfc4514_string(self) -> str: ... class RelativeDistinguishedName(object): def __init__(self, attributes: List[NameAttribute]) -> None: ... def __iter__(self) -> Generator[NameAttribute, None, None]: ... def get_attributes_for_oid(self, oid: ObjectIdentifier) -> List[NameAttribute]: ... def rfc4514_string(self) -> str: ... class Name(object): rdns: List[RelativeDistinguishedName] def __init__(self, attributes: Sequence[Union[NameAttribute, RelativeDistinguishedName]]) -> None: ... def __iter__(self) -> Generator[NameAttribute, None, None]: ... def __len__(self) -> int: ... def get_attributes_for_oid(self, oid: ObjectIdentifier) -> List[NameAttribute]: ... def public_bytes(self, backend: Optional[X509Backend] = ...) -> bytes: ... def rfc4514_string(self) -> str: ... class Version(Enum): v1: int v3: int class Certificate(metaclass=ABCMeta): extensions: Extensions issuer: Name not_valid_after: datetime.datetime not_valid_before: datetime.datetime serial_number: int signature: bytes signature_algorithm_oid: ObjectIdentifier signature_hash_algorithm: HashAlgorithm tbs_certificate_bytes: bytes subject: Name version: Version @abstractmethod def fingerprint(self, algorithm: HashAlgorithm) -> bytes: ... @abstractmethod def public_bytes(self, encoding: Encoding) -> bytes: ... @abstractmethod def public_key(self) -> Union[DSAPublicKey, Ed25519PublicKey, Ed448PublicKey, EllipticCurvePublicKey, RSAPublicKey]: ... class CertificateBuilder(object): def __init__( self, issuer_name: Optional[Name] = ..., subject_name: Optional[Name] = ..., public_key: Union[DSAPublicKey, Ed25519PublicKey, Ed448PublicKey, EllipticCurvePublicKey, RSAPublicKey, None] = ..., serial_number: Optional[int] = ..., not_valid_before: Optional[datetime.datetime] = ..., not_valid_after: Optional[datetime.datetime] = ..., extensions: Optional[Iterable[ExtensionType]] = ..., ) -> None: ... def add_extension(self, extension: ExtensionType, critical: bool) -> CertificateBuilder: ... def issuer_name(self, name: Name) -> CertificateBuilder: ... def not_valid_after(self, time: datetime.datetime) -> CertificateBuilder: ... def not_valid_before(self, time: datetime.datetime) -> CertificateBuilder: ... def public_key( self, public_key: Union[DSAPublicKey, Ed25519PublicKey, Ed448PublicKey, EllipticCurvePublicKey, RSAPublicKey] ) -> CertificateBuilder: ... def serial_number(self, serial_number: int) -> CertificateBuilder: ... def sign( self, private_key: Union[DSAPrivateKey, Ed25519PrivateKey, Ed448PrivateKey, EllipticCurvePrivateKey, RSAPrivateKey], algorithm: Optional[HashAlgorithm], backend: Optional[X509Backend] = ..., ) -> Certificate: ... def subject_name(self, name: Name) -> CertificateBuilder: ... class CertificateRevocationList(metaclass=ABCMeta): extensions: Extensions issuer: Name last_update: datetime.datetime next_update: datetime.datetime signature: bytes signature_algorithm_oid: ObjectIdentifier signature_hash_algorithm: HashAlgorithm tbs_certlist_bytes: bytes @abstractmethod def fingerprint(self, algorithm: HashAlgorithm) -> bytes: ... @abstractmethod def get_revoked_certificate_by_serial_number(self, serial_number: int) -> RevokedCertificate: ... @abstractmethod def is_signature_valid( self, public_key: Union[DSAPublicKey, Ed25519PublicKey, Ed448PublicKey, EllipticCurvePublicKey, RSAPublicKey] ) -> bool: ... @abstractmethod def public_bytes(self, encoding: Encoding) -> bytes: ... class CertificateRevocationListBuilder(object): def add_extension(self, extension: ExtensionType, critical: bool) -> CertificateRevocationListBuilder: ... def add_revoked_certificate(self, revoked_certificate: RevokedCertificate) -> CertificateRevocationListBuilder: ... def issuer_name(self, name: Name) -> CertificateRevocationListBuilder: ... def last_update(self, time: datetime.datetime) -> CertificateRevocationListBuilder: ... def next_update(self, time: datetime.datetime) -> CertificateRevocationListBuilder: ... def sign( self, private_key: Union[DSAPrivateKey, Ed25519PrivateKey, Ed448PrivateKey, EllipticCurvePrivateKey, RSAPrivateKey], algorithm: Optional[HashAlgorithm], backend: Optional[X509Backend] = ..., ) -> CertificateRevocationList: ... class CertificateSigningRequest(metaclass=ABCMeta): extensions: Extensions is_signature_valid: bool signature: bytes signature_algorithm_oid: ObjectIdentifier signature_hash_algorithm: HashAlgorithm subject: Name tbs_certrequest_bytes: bytes @abstractmethod def public_bytes(self, encoding: Encoding) -> bytes: ... @abstractmethod def public_key(self) -> Union[DSAPublicKey, Ed25519PublicKey, Ed448PublicKey, EllipticCurvePublicKey, RSAPublicKey]: ... class CertificateSigningRequestBuilder(object): def add_extension(self, extension: ExtensionType, critical: bool) -> CertificateSigningRequestBuilder: ... def subject_name(self, name: Name) -> CertificateSigningRequestBuilder: ... def sign( self, private_key: Union[DSAPrivateKey, Ed25519PrivateKey, Ed448PrivateKey, EllipticCurvePrivateKey, RSAPrivateKey], algorithm: Optional[HashAlgorithm], backend: Optional[X509Backend] = ..., ) -> CertificateSigningRequest: ... class RevokedCertificate(metaclass=ABCMeta): extensions: Extensions revocation_date: datetime.datetime serial_number: int class RevokedCertificateBuilder(object): def add_extension(self, extension: ExtensionType, critical: bool) -> RevokedCertificateBuilder: ... def build(self, backend: Optional[X509Backend] = ...) -> RevokedCertificate: ... def revocation_date(self, time: datetime.datetime) -> RevokedCertificateBuilder: ... def serial_number(self, serial_number: int) -> RevokedCertificateBuilder: ... # General Name Classes class GeneralName(metaclass=ABCMeta): value: Any class DirectoryName(GeneralName): value: Name def __init__(self, value: Name) -> None: ... class DNSName(GeneralName): value: Text def __init__(self, value: Text) -> None: ... class IPAddress(GeneralName): value: Union[IPv4Address, IPv6Address, IPv4Network, IPv6Network] def __init__(self, value: Union[IPv4Address, IPv6Address, IPv4Network, IPv6Network]) -> None: ... class OtherName(GeneralName): type_id: ObjectIdentifier value: bytes def __init__(self, type_id: ObjectIdentifier, value: bytes) -> None: ... class RegisteredID(GeneralName): value: ObjectIdentifier def __init__(self, value: ObjectIdentifier) -> None: ... class RFC822Name(GeneralName): value: Text def __init__(self, value: Text) -> None: ... class UniformResourceIdentifier(GeneralName): value: Text def __init__(self, value: Text) -> None: ... # X.509 Extensions class ExtensionType(metaclass=ABCMeta): oid: ObjectIdentifier _T = TypeVar("_T", bound="ExtensionType") class Extension(Generic[_T]): critical: bool oid: ObjectIdentifier value: _T class Extensions(object): def __init__(self, general_names: List[Extension[Any]]) -> None: ... def __iter__(self) -> Generator[Extension[Any], None, None]: ... def get_extension_for_oid(self, oid: ObjectIdentifier) -> Extension[Any]: ... def get_extension_for_class(self, extclass: Type[_T]) -> Extension[_T]: ... class DuplicateExtension(Exception): oid: ObjectIdentifier def __init__(self, msg: str, oid: ObjectIdentifier) -> None: ... class ExtensionNotFound(Exception): oid: ObjectIdentifier def __init__(self, msg: str, oid: ObjectIdentifier) -> None: ... class IssuerAlternativeName(ExtensionType): def __init__(self, general_names: List[GeneralName]) -> None: ... def __iter__(self) -> Generator[GeneralName, None, None]: ... def get_values_for_type(self, type: Type[GeneralName]) -> List[Any]: ... class SubjectAlternativeName(ExtensionType): def __init__(self, general_names: List[GeneralName]) -> None: ... def __iter__(self) -> Generator[GeneralName, None, None]: ... def get_values_for_type(self, type: Type[GeneralName]) -> List[Any]: ... class AuthorityKeyIdentifier(ExtensionType): @property def key_identifier(self) -> bytes: ... @property def authority_cert_issuer(self) -> Optional[List[GeneralName]]: ... @property def authority_cert_serial_number(self) -> Optional[int]: ... def __init__( self, key_identifier: bytes, authority_cert_issuer: Optional[Iterable[GeneralName]], authority_cert_serial_number: Optional[int], ) -> None: ... @classmethod def from_issuer_public_key( cls, public_key: Union[RSAPublicKey, DSAPublicKey, EllipticCurvePublicKey, Ed25519PublicKey, Ed448PublicKey] ) -> AuthorityKeyIdentifier: ... @classmethod def from_issuer_subject_key_identifier(cls, ski: SubjectKeyIdentifier) -> AuthorityKeyIdentifier: ... class SubjectKeyIdentifier(ExtensionType): @property def digest(self) -> bytes: ... def __init__(self, digest: bytes) -> None: ... @classmethod def from_public_key( cls, public_key: Union[RSAPublicKey, DSAPublicKey, EllipticCurvePublicKey, Ed25519PublicKey, Ed448PublicKey] ) -> SubjectKeyIdentifier: ... class AccessDescription: @property def access_method(self) -> ObjectIdentifier: ... @property def access_location(self) -> GeneralName: ... def __init__(self, access_method: ObjectIdentifier, access_location: GeneralName) -> None: ... class AuthorityInformationAccess(ExtensionType): def __init__(self, descriptions: Iterable[AccessDescription]) -> None: ... def __len__(self) -> int: ... def __iter__(self) -> Generator[AccessDescription, None, None]: ... def __getitem__(self, item: int) -> AccessDescription: ... class SubjectInformationAccess(ExtensionType): def __init__(self, descriptions: Iterable[AccessDescription]) -> None: ... def __len__(self) -> int: ... def __iter__(self) -> Generator[AccessDescription, None, None]: ... def __getitem__(self, item: int) -> AccessDescription: ... class BasicConstraints(ExtensionType): @property def ca(self) -> bool: ... @property def path_length(self) -> Optional[int]: ... def __init__(self, ca: bool, path_length: Optional[int]) -> None: ... class KeyUsage(ExtensionType): @property def digital_signature(self) -> bool: ... @property def content_commitment(self) -> bool: ... @property def key_encipherment(self) -> bool: ... @property def data_encipherment(self) -> bool: ... @property def key_agreement(self) -> bool: ... @property def key_cert_sign(self) -> bool: ... @property def crl_sign(self) -> bool: ... @property def encipher_only(self) -> bool: ... @property def decipher_only(self) -> bool: ... def __init__( self, digital_signature: bool, content_commitment: bool, key_encipherment: bool, data_encipherment: bool, key_agreement: bool, key_cert_sign: bool, crl_sign: bool, encipher_only: bool, decipher_only: bool, ) -> None: ... class ExtendedKeyUsage(ExtensionType): def __init__(self, usages: Iterable[ObjectIdentifier]) -> None: ... def __len__(self) -> int: ... def __iter__(self) -> Generator[ObjectIdentifier, None, None]: ... def __getitem__(self, item: int) -> ObjectIdentifier: ... class UnrecognizedExtension(ExtensionType): @property def value(self) -> bytes: ... def __init__(self, oid: ObjectIdentifier, value: bytes) -> None: ... def load_der_x509_certificate(data: bytes, backend: Optional[X509Backend] = ...) -> Certificate: ... def load_pem_x509_certificate(data: bytes, backend: Optional[X509Backend] = ...) -> Certificate: ... def load_der_x509_crl(data: bytes, backend: Optional[X509Backend] = ...) -> CertificateRevocationList: ... def load_pem_x509_crl(data: bytes, backend: Optional[X509Backend] = ...) -> CertificateRevocationList: ... def load_der_x509_csr(data: bytes, backend: Optional[X509Backend] = ...) -> CertificateSigningRequest: ... def load_pem_x509_csr(data: bytes, backend: Optional[X509Backend] = ...) -> CertificateSigningRequest: ... def __getattr__(name: str) -> Any: ... # incomplete ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/cryptography/x509/extensions.pyi0000664000175000017500000000105500000000000031114 0ustar00davedave00000000000000from typing import Any, Iterator from cryptography.x509 import GeneralName, ObjectIdentifier class Extension: value: Any = ... class GeneralNames: def __iter__(self) -> Iterator[GeneralName]: ... class DistributionPoint: full_name: GeneralNames = ... class CRLDistributionPoints: def __iter__(self) -> Iterator[DistributionPoint]: ... class AccessDescription: access_method: ObjectIdentifier = ... access_location: GeneralName = ... class AuthorityInformationAccess: def __iter__(self) -> Iterator[AccessDescription]: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/cryptography/x509/oid.pyi0000664000175000017500000001007100000000000027466 0ustar00davedave00000000000000from typing import Dict, Optional from cryptography.hazmat.primitives.hashes import HashAlgorithm from cryptography.x509 import ObjectIdentifier class ExtensionOID: SUBJECT_DIRECTORY_ATTRIBUTES: ObjectIdentifier = ... SUBJECT_KEY_IDENTIFIER: ObjectIdentifier = ... KEY_USAGE: ObjectIdentifier = ... SUBJECT_ALTERNATIVE_NAME: ObjectIdentifier = ... ISSUER_ALTERNATIVE_NAME: ObjectIdentifier = ... BASIC_CONSTRAINTS: ObjectIdentifier = ... NAME_CONSTRAINTS: ObjectIdentifier = ... CRL_DISTRIBUTION_POINTS: ObjectIdentifier = ... CERTIFICATE_POLICIES: ObjectIdentifier = ... POLICY_MAPPINGS: ObjectIdentifier = ... AUTHORITY_KEY_IDENTIFIER: ObjectIdentifier = ... POLICY_CONSTRAINTS: ObjectIdentifier = ... EXTENDED_KEY_USAGE: ObjectIdentifier = ... FRESHEST_CRL: ObjectIdentifier = ... INHIBIT_ANY_POLICY: ObjectIdentifier = ... ISSUING_DISTRIBUTION_POINT: ObjectIdentifier = ... AUTHORITY_INFORMATION_ACCESS: ObjectIdentifier = ... SUBJECT_INFORMATION_ACCESS: ObjectIdentifier = ... OCSP_NO_CHECK: ObjectIdentifier = ... TLS_FEATURE: ObjectIdentifier = ... CRL_NUMBER: ObjectIdentifier = ... DELTA_CRL_INDICATOR: ObjectIdentifier = ... PRECERT_SIGNED_CERTIFICATE_TIMESTAMPS: ObjectIdentifier = ... PRECERT_POISON: ObjectIdentifier = ... class OCSPExtensionOID: NONCE: ObjectIdentifier = ... class CRLEntryExtensionOID: CERTIFICATE_ISSUER: ObjectIdentifier = ... CRL_REASON: ObjectIdentifier = ... INVALIDITY_DATE: ObjectIdentifier = ... class NameOID: COMMON_NAME: ObjectIdentifier = ... COUNTRY_NAME: ObjectIdentifier = ... LOCALITY_NAME: ObjectIdentifier = ... STATE_OR_PROVINCE_NAME: ObjectIdentifier = ... STREET_ADDRESS: ObjectIdentifier = ... ORGANIZATION_NAME: ObjectIdentifier = ... ORGANIZATIONAL_UNIT_NAME: ObjectIdentifier = ... SERIAL_NUMBER: ObjectIdentifier = ... SURNAME: ObjectIdentifier = ... GIVEN_NAME: ObjectIdentifier = ... TITLE: ObjectIdentifier = ... GENERATION_QUALIFIER: ObjectIdentifier = ... X500_UNIQUE_IDENTIFIER: ObjectIdentifier = ... DN_QUALIFIER: ObjectIdentifier = ... PSEUDONYM: ObjectIdentifier = ... USER_ID: ObjectIdentifier = ... DOMAIN_COMPONENT: ObjectIdentifier = ... EMAIL_ADDRESS: ObjectIdentifier = ... JURISDICTION_COUNTRY_NAME: ObjectIdentifier = ... JURISDICTION_LOCALITY_NAME: ObjectIdentifier = ... JURISDICTION_STATE_OR_PROVINCE_NAME: ObjectIdentifier = ... BUSINESS_CATEGORY: ObjectIdentifier = ... POSTAL_ADDRESS: ObjectIdentifier = ... POSTAL_CODE: ObjectIdentifier = ... class SignatureAlgorithmOID: RSA_WITH_MD5: ObjectIdentifier = ... RSA_WITH_SHA1: ObjectIdentifier = ... _RSA_WITH_SHA1: ObjectIdentifier = ... RSA_WITH_SHA224: ObjectIdentifier = ... RSA_WITH_SHA256: ObjectIdentifier = ... RSA_WITH_SHA384: ObjectIdentifier = ... RSA_WITH_SHA512: ObjectIdentifier = ... RSASSA_PSS: ObjectIdentifier = ... ECDSA_WITH_SHA1: ObjectIdentifier = ... ECDSA_WITH_SHA224: ObjectIdentifier = ... ECDSA_WITH_SHA256: ObjectIdentifier = ... ECDSA_WITH_SHA384: ObjectIdentifier = ... ECDSA_WITH_SHA512: ObjectIdentifier = ... DSA_WITH_SHA1: ObjectIdentifier = ... DSA_WITH_SHA224: ObjectIdentifier = ... DSA_WITH_SHA256: ObjectIdentifier = ... ED25519: ObjectIdentifier = ... ED448: ObjectIdentifier = ... class ExtendedKeyUsageOID: SERVER_AUTH: ObjectIdentifier = ... CLIENT_AUTH: ObjectIdentifier = ... CODE_SIGNING: ObjectIdentifier = ... EMAIL_PROTECTION: ObjectIdentifier = ... TIME_STAMPING: ObjectIdentifier = ... OCSP_SIGNING: ObjectIdentifier = ... ANY_EXTENDED_KEY_USAGE: ObjectIdentifier = ... class AuthorityInformationAccessOID: CA_ISSUERS: ObjectIdentifier = ... OCSP: ObjectIdentifier = ... class CertificatePoliciesOID: CPS_QUALIFIER: ObjectIdentifier = ... CPS_USER_NOTICE: ObjectIdentifier = ... ANY_POLICY: ObjectIdentifier = ... _OID_NAMES: Dict[ObjectIdentifier, str] = ... _SIG_OIDS_TO_HASH: Dict[ObjectIdentifier, Optional[HashAlgorithm]] = ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/dateparser.pyi0000664000175000017500000000101200000000000025600 0ustar00davedave00000000000000import datetime from typing import Any, List, Mapping, Optional, Set, Tuple, Union __version__: str def parse( date_string: str, date_formats: Optional[Union[List[str], Tuple[str], Set[str]]] = ..., languages: Optional[Union[List[str], Tuple[str], Set[str]]] = ..., locales: Optional[Union[List[str], Tuple[str], Set[str]]] = ..., region: Optional[str] = ..., settings: Optional[Mapping[str, Any]] = ..., ) -> Optional[datetime.datetime]: ... def __getattr__(name: str) -> Any: ... # incomplete ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4463794 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/datetimerange/0000775000175000017500000000000000000000000025542 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/datetimerange/__init__.pyi0000664000175000017500000000401600000000000030025 0ustar00davedave00000000000000import datetime from typing import Iterable, Optional, Union from dateutil.relativedelta import relativedelta class DateTimeRange(object): NOT_A_TIME_STR: str start_time_format: str end_time_format: str is_output_elapse: bool separator: str def __init__( self, start_datetime: Optional[Union[datetime.datetime, str]] = ..., end_datetime: Optional[Union[datetime.datetime, str]] = ..., start_time_format: str = ..., end_time_format: str = ..., ) -> None: ... def __eq__(self, other) -> bool: ... def __ne__(self, other) -> bool: ... def __add__(self, other) -> DateTimeRange: ... def __iadd__(self, other) -> DateTimeRange: ... def __sub__(self, other) -> DateTimeRange: ... def __isub__(self, other) -> DateTimeRange: ... def __contains__(self, x) -> bool: ... @property def start_datetime(self) -> datetime.datetime: ... @property def end_datetime(self) -> datetime.datetime: ... @property def timedelta(self) -> datetime.timedelta: ... def is_set(self) -> bool: ... def validate_time_inversion(self) -> None: ... def is_valid_timerange(self) -> bool: ... def is_intersection(self, x) -> bool: ... def get_start_time_str(self) -> str: ... def get_end_time_str(self) -> str: ... def get_timedelta_second(self) -> float: ... def set_start_datetime(self, value: Optional[Union[datetime.datetime, str]], timezone: Optional[str] = ...) -> None: ... def set_end_datetime(self, value: Optional[Union[datetime.datetime, str]], timezone: Optional[str] = ...) -> None: ... def set_time_range( self, start: Optional[Union[datetime.datetime, str]], end: Optional[Union[datetime.datetime, str]] ) -> None: ... def range(self, step: Union[datetime.timedelta, relativedelta]) -> Iterable[datetime.datetime]: ... def intersection(self, x: DateTimeRange) -> DateTimeRange: ... def encompass(self, x: DateTimeRange) -> DateTimeRange: ... def truncate(self, percentage: float) -> None: ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4463794 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/dateutil/0000775000175000017500000000000000000000000024544 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/dateutil/__init__.pyi0000664000175000017500000000000000000000000027014 0ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/dateutil/_common.pyi0000664000175000017500000000052400000000000026717 0ustar00davedave00000000000000from typing import Optional, TypeVar _T = TypeVar("_T") class weekday(object): def __init__(self, weekday: int, n: Optional[int] = ...) -> None: ... def __call__(self: _T, n: int) -> _T: ... def __eq__(self, other) -> bool: ... def __repr__(self) -> str: ... def __hash__(self) -> int: ... weekday: int n: int ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/dateutil/easter.pyi0000664000175000017500000000032600000000000026553 0ustar00davedave00000000000000from datetime import date from typing_extensions import Literal EASTER_JULIAN: Literal[1] EASTER_ORTHODOX: Literal[2] EASTER_WESTERN: Literal[3] def easter(year: int, method: Literal[1, 2, 3] = ...) -> date: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/dateutil/parser.pyi0000664000175000017500000000336300000000000026570 0ustar00davedave00000000000000from datetime import datetime, tzinfo from typing import IO, Any, Dict, List, Mapping, Optional, Text, Tuple, Union _FileOrStr = Union[bytes, Text, IO[str], IO[Any]] class parserinfo(object): JUMP: List[str] WEEKDAYS: List[Tuple[str, str]] MONTHS: List[Tuple[str, str]] HMS: List[Tuple[str, str, str]] AMPM: List[Tuple[str, str]] UTCZONE: List[str] PERTAIN: List[str] TZOFFSET: Dict[str, int] def __init__(self, dayfirst: bool = ..., yearfirst: bool = ...) -> None: ... def jump(self, name: Text) -> bool: ... def weekday(self, name: Text) -> Optional[int]: ... def month(self, name: Text) -> Optional[int]: ... def hms(self, name: Text) -> Optional[int]: ... def ampm(self, name: Text) -> Optional[int]: ... def pertain(self, name: Text) -> bool: ... def utczone(self, name: Text) -> bool: ... def tzoffset(self, name: Text) -> Optional[int]: ... def convertyear(self, year: int) -> int: ... def validate(self, res: datetime) -> bool: ... class parser(object): def __init__(self, info: Optional[parserinfo] = ...) -> None: ... def parse( self, timestr: _FileOrStr, default: Optional[datetime] = ..., ignoretz: bool = ..., tzinfos: Optional[Mapping[Text, tzinfo]] = ..., **kwargs: Any, ) -> datetime: ... def isoparse(dt_str: Union[str, bytes, IO[str], IO[bytes]]) -> datetime: ... DEFAULTPARSER: parser def parse(timestr: _FileOrStr, parserinfo: Optional[parserinfo] = ..., **kwargs: Any) -> datetime: ... class _tzparser: ... DEFAULTTZPARSER: _tzparser class InvalidDatetimeError(ValueError): ... class InvalidDateError(InvalidDatetimeError): ... class InvalidTimeError(InvalidDatetimeError): ... class ParserError(ValueError): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/dateutil/relativedelta.pyi0000664000175000017500000000625300000000000030122 0ustar00davedave00000000000000from datetime import date, datetime, timedelta from typing import Optional, SupportsFloat, TypeVar, Union, overload from ._common import weekday _SelfT = TypeVar("_SelfT", bound=relativedelta) _DateT = TypeVar("_DateT", date, datetime) # Work around attribute and type having the same name. _weekday = weekday MO: weekday TU: weekday WE: weekday TH: weekday FR: weekday SA: weekday SU: weekday class relativedelta(object): years: int months: int days: int leapdays: int hours: int minutes: int seconds: int microseconds: int year: Optional[int] month: Optional[int] weekday: Optional[_weekday] day: Optional[int] hour: Optional[int] minute: Optional[int] second: Optional[int] microsecond: Optional[int] def __init__( self, dt1: Optional[date] = ..., dt2: Optional[date] = ..., years: Optional[int] = ..., months: Optional[int] = ..., days: Optional[int] = ..., leapdays: Optional[int] = ..., weeks: Optional[int] = ..., hours: Optional[int] = ..., minutes: Optional[int] = ..., seconds: Optional[int] = ..., microseconds: Optional[int] = ..., year: Optional[int] = ..., month: Optional[int] = ..., day: Optional[int] = ..., weekday: Optional[Union[int, _weekday]] = ..., yearday: Optional[int] = ..., nlyearday: Optional[int] = ..., hour: Optional[int] = ..., minute: Optional[int] = ..., second: Optional[int] = ..., microsecond: Optional[int] = ..., ) -> None: ... @property def weeks(self) -> int: ... @weeks.setter def weeks(self, value: int) -> None: ... def normalized(self: _SelfT) -> _SelfT: ... # TODO: use Union when mypy will handle it properly in overloaded operator # methods (#2129, #1442, #1264 in mypy) @overload def __add__(self: _SelfT, other: relativedelta) -> _SelfT: ... @overload def __add__(self: _SelfT, other: timedelta) -> _SelfT: ... @overload def __add__(self, other: _DateT) -> _DateT: ... @overload def __radd__(self: _SelfT, other: relativedelta) -> _SelfT: ... @overload def __radd__(self: _SelfT, other: timedelta) -> _SelfT: ... @overload def __radd__(self, other: _DateT) -> _DateT: ... @overload def __rsub__(self: _SelfT, other: relativedelta) -> _SelfT: ... @overload def __rsub__(self: _SelfT, other: timedelta) -> _SelfT: ... @overload def __rsub__(self, other: _DateT) -> _DateT: ... def __sub__(self: _SelfT, other: relativedelta) -> _SelfT: ... def __neg__(self: _SelfT) -> _SelfT: ... def __bool__(self) -> bool: ... def __nonzero__(self) -> bool: ... def __mul__(self: _SelfT, other: SupportsFloat) -> _SelfT: ... def __rmul__(self: _SelfT, other: SupportsFloat) -> _SelfT: ... def __eq__(self, other) -> bool: ... def __ne__(self, other: object) -> bool: ... def __div__(self: _SelfT, other: SupportsFloat) -> _SelfT: ... def __truediv__(self: _SelfT, other: SupportsFloat) -> _SelfT: ... def __repr__(self) -> str: ... def __abs__(self: _SelfT) -> _SelfT: ... def __hash__(self) -> int: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/dateutil/rrule.pyi0000664000175000017500000000622300000000000026423 0ustar00davedave00000000000000import datetime from typing import Any, Iterable, Optional, Union from ._common import weekday as weekdaybase YEARLY: int MONTHLY: int WEEKLY: int DAILY: int HOURLY: int MINUTELY: int SECONDLY: int class weekday(weekdaybase): ... MO: weekday TU: weekday WE: weekday TH: weekday FR: weekday SA: weekday SU: weekday class rrulebase: def __init__(self, cache: bool = ...) -> None: ... def __iter__(self): ... def __getitem__(self, item): ... def __contains__(self, item): ... def count(self): ... def before(self, dt, inc: bool = ...): ... def after(self, dt, inc: bool = ...): ... def xafter(self, dt, count: Optional[Any] = ..., inc: bool = ...): ... def between(self, after, before, inc: bool = ..., count: int = ...): ... class rrule(rrulebase): def __init__( self, freq, dtstart: Optional[datetime.date] = ..., interval: int = ..., wkst: Optional[Union[weekday, int]] = ..., count: Optional[int] = ..., until: Optional[Union[datetime.date, int]] = ..., bysetpos: Optional[Union[int, Iterable[int]]] = ..., bymonth: Optional[Union[int, Iterable[int]]] = ..., bymonthday: Optional[Union[int, Iterable[int]]] = ..., byyearday: Optional[Union[int, Iterable[int]]] = ..., byeaster: Optional[Union[int, Iterable[int]]] = ..., byweekno: Optional[Union[int, Iterable[int]]] = ..., byweekday: Optional[Union[int, weekday, Iterable[int], Iterable[weekday]]] = ..., byhour: Optional[Union[int, Iterable[int]]] = ..., byminute: Optional[Union[int, Iterable[int]]] = ..., bysecond: Optional[Union[int, Iterable[int]]] = ..., cache: bool = ..., ) -> None: ... def replace(self, **kwargs): ... class _iterinfo: rrule: Any = ... def __init__(self, rrule) -> None: ... yearlen: int = ... nextyearlen: int = ... yearordinal: int = ... yearweekday: int = ... mmask: Any = ... mdaymask: Any = ... nmdaymask: Any = ... wdaymask: Any = ... mrange: Any = ... wnomask: Any = ... nwdaymask: Any = ... eastermask: Any = ... lastyear: int = ... lastmonth: int = ... def rebuild(self, year, month): ... def ydayset(self, year, month, day): ... def mdayset(self, year, month, day): ... def wdayset(self, year, month, day): ... def ddayset(self, year, month, day): ... def htimeset(self, hour, minute, second): ... def mtimeset(self, hour, minute, second): ... def stimeset(self, hour, minute, second): ... class rruleset(rrulebase): class _genitem: dt: Any = ... genlist: Any = ... gen: Any = ... def __init__(self, genlist, gen) -> None: ... def __next__(self): ... next: Any = ... def __lt__(self, other): ... def __gt__(self, other): ... def __eq__(self, other): ... def __ne__(self, other): ... def __init__(self, cache: bool = ...) -> None: ... def rrule(self, rrule): ... def rdate(self, rdate): ... def exrule(self, exrule): ... def exdate(self, exdate): ... class _rrulestr: def __call__(self, s, **kwargs): ... rrulestr: _rrulestr ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4463794 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/dateutil/tz/0000775000175000017500000000000000000000000025201 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/dateutil/tz/__init__.pyi0000664000175000017500000000052400000000000027464 0ustar00davedave00000000000000from .tz import ( datetime_ambiguous as datetime_ambiguous, datetime_exists as datetime_exists, gettz as gettz, resolve_imaginary as resolve_imaginary, tzfile as tzfile, tzical as tzical, tzlocal as tzlocal, tzoffset as tzoffset, tzrange as tzrange, tzstr as tzstr, tzutc as tzutc, ) UTC: tzutc ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/dateutil/tz/_common.pyi0000664000175000017500000000146200000000000027356 0ustar00davedave00000000000000from datetime import datetime, timedelta, tzinfo from typing import Any, Optional def tzname_in_python2(namefunc): ... def enfold(dt: datetime, fold: int = ...): ... class _DatetimeWithFold(datetime): @property def fold(self): ... class _tzinfo(tzinfo): def is_ambiguous(self, dt: datetime) -> bool: ... def fromutc(self, dt: datetime) -> datetime: ... class tzrangebase(_tzinfo): def __init__(self) -> None: ... def utcoffset(self, dt: Optional[datetime]) -> Optional[timedelta]: ... def dst(self, dt: Optional[datetime]) -> Optional[timedelta]: ... def tzname(self, dt: Optional[datetime]) -> str: ... def fromutc(self, dt: datetime) -> datetime: ... def is_ambiguous(self, dt: datetime) -> bool: ... __hash__: Any def __ne__(self, other): ... __reduce__: Any ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/dateutil/tz/tz.pyi0000664000175000017500000000760200000000000026366 0ustar00davedave00000000000000import datetime from typing import IO, Any, List, Optional, Text, Tuple, Union from ..relativedelta import relativedelta from ._common import _tzinfo as _tzinfo, enfold as enfold, tzname_in_python2 as tzname_in_python2, tzrangebase as tzrangebase _FileObj = Union[str, Text, IO[str], IO[Text]] ZERO: datetime.timedelta EPOCH: datetime.datetime EPOCHORDINAL: int class tzutc(datetime.tzinfo): def utcoffset(self, dt: Optional[datetime.datetime]) -> Optional[datetime.timedelta]: ... def dst(self, dt: Optional[datetime.datetime]) -> Optional[datetime.timedelta]: ... def tzname(self, dt: Optional[datetime.datetime]) -> str: ... def is_ambiguous(self, dt: Optional[datetime.datetime]) -> bool: ... def __eq__(self, other): ... __hash__: Any def __ne__(self, other): ... __reduce__: Any class tzoffset(datetime.tzinfo): def __init__(self, name, offset) -> None: ... def utcoffset(self, dt: Optional[datetime.datetime]) -> Optional[datetime.timedelta]: ... def dst(self, dt: Optional[datetime.datetime]) -> Optional[datetime.timedelta]: ... def is_ambiguous(self, dt: Optional[datetime.datetime]) -> bool: ... def tzname(self, dt: Optional[datetime.datetime]) -> str: ... def __eq__(self, other): ... __hash__: Any def __ne__(self, other): ... __reduce__: Any @classmethod def instance(cls, name, offset) -> tzoffset: ... class tzlocal(_tzinfo): def __init__(self) -> None: ... def utcoffset(self, dt: Optional[datetime.datetime]) -> Optional[datetime.timedelta]: ... def dst(self, dt: Optional[datetime.datetime]) -> Optional[datetime.timedelta]: ... def tzname(self, dt: Optional[datetime.datetime]) -> str: ... def is_ambiguous(self, dt: Optional[datetime.datetime]) -> bool: ... def __eq__(self, other): ... __hash__: Any def __ne__(self, other): ... __reduce__: Any class _ttinfo: def __init__(self) -> None: ... def __eq__(self, other): ... __hash__: Any def __ne__(self, other): ... class tzfile(_tzinfo): def __init__(self, fileobj: _FileObj, filename: Optional[Text] = ...) -> None: ... def is_ambiguous(self, dt: Optional[datetime.datetime], idx: Optional[int] = ...) -> bool: ... def utcoffset(self, dt: Optional[datetime.datetime]) -> Optional[datetime.timedelta]: ... def dst(self, dt: Optional[datetime.datetime]) -> Optional[datetime.timedelta]: ... def tzname(self, dt: Optional[datetime.datetime]) -> str: ... def __eq__(self, other): ... __hash__: Any def __ne__(self, other): ... def __reduce__(self): ... def __reduce_ex__(self, protocol): ... class tzrange(tzrangebase): hasdst: bool def __init__( self, stdabbr: Text, stdoffset: Union[int, datetime.timedelta, None] = ..., dstabbr: Optional[Text] = ..., dstoffset: Union[int, datetime.timedelta, None] = ..., start: Optional[relativedelta] = ..., end: Optional[relativedelta] = ..., ) -> None: ... def transitions(self, year: int) -> Tuple[datetime.datetime, datetime.datetime]: ... def __eq__(self, other): ... class tzstr(tzrange): hasdst: bool def __init__(self, s: Union[bytes, _FileObj], posix_offset: bool = ...) -> None: ... @classmethod def instance(cls, name, offset) -> tzoffset: ... class tzical: def __init__(self, fileobj: _FileObj) -> None: ... def keys(self): ... def get(self, tzid: Optional[Any] = ...): ... TZFILES: List[str] TZPATHS: List[str] def datetime_exists(dt: datetime.datetime, tz: Optional[datetime.tzinfo] = ...) -> bool: ... def datetime_ambiguous(dt: datetime.datetime, tz: Optional[datetime.tzinfo] = ...) -> bool: ... def resolve_imaginary(dt: datetime.datetime) -> datetime.datetime: ... class _GetTZ: def __call__(self, name: Optional[Text] = ...) -> Optional[datetime.tzinfo]: ... def nocache(self, name: Optional[Text]) -> Optional[datetime.tzinfo]: ... gettz: _GetTZ ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/dateutil/utils.pyi0000664000175000017500000000043100000000000026425 0ustar00davedave00000000000000from datetime import datetime, timedelta, tzinfo from typing import Optional def default_tzinfo(dt: datetime, tzinfo: tzinfo) -> datetime: ... def today(tzinfo: Optional[tzinfo] = ...) -> datetime: ... def within_delta(dt1: datetime, dt2: datetime, delta: timedelta) -> bool: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/decorator.pyi0000664000175000017500000000531000000000000025435 0ustar00davedave00000000000000import sys from typing import Any, Callable, Dict, Iterator, List, NamedTuple, Optional, Pattern, Text, Tuple, TypeVar _C = TypeVar("_C", bound=Callable[..., Any]) _Func = TypeVar("_Func", bound=Callable[..., Any]) _T = TypeVar("_T") def get_init(cls): ... if sys.version_info >= (3,): from inspect import getfullargspec as getfullargspec, iscoroutinefunction as iscoroutinefunction else: class FullArgSpec(NamedTuple): args: List[str] varargs: Optional[str] varkw: Optional[str] defaults: Tuple[Any, ...] kwonlyargs: List[str] kwonlydefaults: Dict[str, Any] annotations: Dict[str, Any] def iscoroutinefunction(f: Callable[..., Any]) -> bool: ... def getfullargspec(func: Any) -> FullArgSpec: ... if sys.version_info >= (3, 2): from contextlib import _GeneratorContextManager else: from contextlib import GeneratorContextManager as _GeneratorContextManager DEF: Pattern[str] class FunctionMaker(object): args: List[Text] varargs: Optional[Text] varkw: Optional[Text] defaults: Tuple[Any, ...] kwonlyargs: List[Text] kwonlydefaults: Optional[Text] shortsignature: Optional[Text] name: Text doc: Optional[Text] module: Optional[Text] annotations: Dict[Text, Any] signature: Text dict: Dict[Text, Any] def __init__( self, func: Optional[Callable[..., Any]] = ..., name: Optional[Text] = ..., signature: Optional[Text] = ..., defaults: Optional[Tuple[Any, ...]] = ..., doc: Optional[Text] = ..., module: Optional[Text] = ..., funcdict: Optional[Dict[Text, Any]] = ..., ) -> None: ... def update(self, func: Any, **kw: Any) -> None: ... def make( self, src_templ: Text, evaldict: Optional[Dict[Text, Any]] = ..., addsource: bool = ..., **attrs: Any ) -> Callable[..., Any]: ... @classmethod def create( cls, obj: Any, body: Text, evaldict: Dict[Text, Any], defaults: Optional[Tuple[Any, ...]] = ..., doc: Optional[Text] = ..., module: Optional[Text] = ..., addsource: bool = ..., **attrs: Any, ) -> Callable[..., Any]: ... def decorate(func: _Func, caller: Callable[..., Any], extras: Any = ...) -> _Func: ... def decorator( caller: Callable[..., Any], _func: Optional[Callable[..., Any]] = ... ) -> Callable[[Callable[..., Any]], Callable[..., Any]]: ... class ContextManager(_GeneratorContextManager[_T]): def __call__(self, func: _C) -> _C: ... def contextmanager(func: Callable[..., Iterator[_T]]) -> Callable[..., ContextManager[_T]]: ... def dispatch_on(*dispatch_args: Any) -> Callable[[Callable[..., Any]], Callable[..., Any]]: ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4463794 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/deprecated/0000775000175000017500000000000000000000000025031 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/deprecated/__init__.pyi0000664000175000017500000000005600000000000027314 0ustar00davedave00000000000000from .classic import deprecated as deprecated ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/deprecated/classic.pyi0000664000175000017500000000141700000000000027200 0ustar00davedave00000000000000from typing import Any, Callable, Optional, Type, TypeVar, overload _F = TypeVar("_F", bound=Callable[..., Any]) class ClassicAdapter: reason: str version: str action: Optional[str] category: Type[DeprecationWarning] def __init__( self, reason: str = ..., version: str = ..., action: Optional[str] = ..., category: Type[DeprecationWarning] = ... ) -> None: ... def get_deprecated_msg(self, wrapped: Callable[..., Any], instance: object) -> str: ... def __call__(self, wrapped: _F) -> Callable[[_F], _F]: ... @overload def deprecated(__wrapped: _F) -> _F: ... @overload def deprecated( reason: str = ..., *, version: str = ..., action: Optional[str] = ..., category: Optional[Type[DeprecationWarning]] = ... ) -> Callable[[_F], _F]: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/deprecated/sphinx.pyi0000664000175000017500000000215100000000000027064 0ustar00davedave00000000000000from typing import Any, Callable, Optional, Type, TypeVar, overload from typing_extensions import Literal from .classic import ClassicAdapter _F = TypeVar("_F", bound=Callable[..., Any]) class SphinxAdapter(ClassicAdapter): directive: Literal["versionadded", "versionchanged", "deprecated"] reason: str version: str action: Optional[str] category: Type[DeprecationWarning] def __init__( self, directive: Literal["versionadded", "versionchanged", "deprecated"], reason: str = ..., version: str = ..., action: Optional[str] = ..., category: Type[DeprecationWarning] = ..., ) -> None: ... def __call__(self, wrapped: _F) -> Callable[[_F], _F]: ... def versionadded(reason: str = ..., version: str = ...) -> Callable[[_F], _F]: ... def versionchanged(reason: str = ..., version: str = ...) -> Callable[[_F], _F]: ... @overload def deprecated(__wrapped: _F) -> _F: ... @overload def deprecated( reason: str = ..., *, version: str = ..., action: Optional[str] = ..., category: Optional[Type[DeprecationWarning]] = ... ) -> Callable[[_F], _F]: ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4463794 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/emoji/0000775000175000017500000000000000000000000024034 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/emoji/__init__.pyi0000664000175000017500000000056500000000000026324 0ustar00davedave00000000000000from .core import ( demojize as demojize, emoji_count as emoji_count, emoji_lis as emoji_lis, emojize as emojize, get_emoji_regexp as get_emoji_regexp, ) from .unicode_codes import ( EMOJI_ALIAS_UNICODE as EMOJI_ALIAS_UNICODE, EMOJI_UNICODE as EMOJI_UNICODE, UNICODE_EMOJI as UNICODE_EMOJI, UNICODE_EMOJI_ALIAS as UNICODE_EMOJI_ALIAS, ) ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/emoji/core.pyi0000664000175000017500000000064300000000000025512 0ustar00davedave00000000000000from typing import Dict, List, Optional, Pattern, Text, Tuple, Union _DEFAULT_DELIMITER: str def emojize(string: str, use_aliases: bool = ..., delimiters: Tuple[str, str] = ...) -> str: ... def demojize(string: str, delimiters: Tuple[str, str] = ...) -> str: ... def get_emoji_regexp() -> Pattern[Text]: ... def emoji_lis(string: str) -> List[Dict[str, Union[int, str]]]: ... def emoji_count(string: str) -> int: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/emoji/unicode_codes.pyi0000664000175000017500000000025300000000000027362 0ustar00davedave00000000000000from typing import Dict, Text EMOJI_ALIAS_UNICODE: Dict[Text, Text] EMOJI_UNICODE: Dict[Text, Text] UNICODE_EMOJI: Dict[Text, Text] UNICODE_EMOJI_ALIAS: Dict[Text, Text] ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/first.pyi0000664000175000017500000000074100000000000024605 0ustar00davedave00000000000000from typing import Any, Callable, Iterable, Optional, TypeVar, Union, overload _T = TypeVar("_T") _S = TypeVar("_S") @overload def first(iterable: Iterable[_T]) -> Optional[_T]: ... @overload def first(iterable: Iterable[_T], default: _S) -> Union[_T, _S]: ... @overload def first(iterable: Iterable[_T], default: _S, key: Optional[Callable[[_T], Any]]) -> Union[_T, _S]: ... @overload def first(iterable: Iterable[_T], *, key: Optional[Callable[[_T], Any]]) -> Optional[_T]: ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4463794 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/flask/0000775000175000017500000000000000000000000024031 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/flask/__init__.pyi0000664000175000017500000000323000000000000026311 0ustar00davedave00000000000000from jinja2 import Markup as Markup, escape as escape from werkzeug.exceptions import abort as abort from werkzeug.utils import redirect as redirect from .app import Flask as Flask from .blueprints import Blueprint as Blueprint from .config import Config as Config from .ctx import ( after_this_request as after_this_request, copy_current_request_context as copy_current_request_context, has_app_context as has_app_context, has_request_context as has_request_context, ) from .globals import current_app as current_app, g as g, request as request, session as session from .helpers import ( flash as flash, get_flashed_messages as get_flashed_messages, get_template_attribute as get_template_attribute, make_response as make_response, safe_join as safe_join, send_file as send_file, send_from_directory as send_from_directory, stream_with_context as stream_with_context, url_for as url_for, ) from .json import jsonify as jsonify from .signals import ( appcontext_popped as appcontext_popped, appcontext_pushed as appcontext_pushed, appcontext_tearing_down as appcontext_tearing_down, before_render_template as before_render_template, got_request_exception as got_request_exception, message_flashed as message_flashed, request_finished as request_finished, request_started as request_started, request_tearing_down as request_tearing_down, signals_available as signals_available, template_rendered as template_rendered, ) from .templating import render_template as render_template, render_template_string as render_template_string from .wrappers import Request as Request, Response as Response ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/flask/app.pyi0000664000175000017500000002004000000000000025330 0ustar00davedave00000000000000from datetime import timedelta from types import TracebackType from typing import ( Any, ByteString, Callable, ContextManager, Dict, Iterable, List, NoReturn, Optional, Text, Tuple, Type, TypeVar, Union, ) from .blueprints import Blueprint from .config import Config from .ctx import AppContext, RequestContext from .helpers import _PackageBoundObject from .testing import FlaskClient from .wrappers import Response def setupmethod(f: Any): ... _T = TypeVar("_T") _ExcInfo = Tuple[Optional[Type[BaseException]], Optional[BaseException], Optional[TracebackType]] _StartResponse = Callable[[str, List[Tuple[str, str]], Optional[_ExcInfo]], Callable[[bytes], Any]] _WSGICallable = Callable[[Dict[Text, Any], _StartResponse], Iterable[bytes]] _Status = Union[str, int] _Headers = Union[Dict[Any, Any], List[Tuple[Any, Any]]] _Body = Union[Text, ByteString, Dict[Text, Any], Response, _WSGICallable] _ViewFuncReturnType = Union[_Body, Tuple[_Body, _Status, _Headers], Tuple[_Body, _Status], Tuple[_Body, _Headers]] _ViewFunc = Union[Callable[..., NoReturn], Callable[..., _ViewFuncReturnType]] _VT = TypeVar("_VT", bound=_ViewFunc) class Flask(_PackageBoundObject): request_class: type = ... response_class: type = ... jinja_environment: type = ... app_ctx_globals_class: type = ... config_class: Type[Config] = ... testing: Any = ... secret_key: Union[Text, bytes, None] = ... session_cookie_name: Any = ... permanent_session_lifetime: timedelta = ... send_file_max_age_default: timedelta = ... use_x_sendfile: Any = ... json_encoder: Any = ... json_decoder: Any = ... jinja_options: Any = ... default_config: Any = ... url_rule_class: type = ... test_client_class: type = ... test_cli_runner_class: type = ... session_interface: Any = ... import_name: str = ... template_folder: str = ... root_path: Union[str, Text] = ... static_url_path: Any = ... static_folder: Optional[str] = ... instance_path: Union[str, Text] = ... config: Config = ... view_functions: Any = ... error_handler_spec: Any = ... url_build_error_handlers: Any = ... before_request_funcs: Dict[Optional[str], List[Callable[[], Any]]] = ... before_first_request_funcs: List[Callable[[], None]] = ... after_request_funcs: Dict[Optional[str], List[Callable[[Response], Response]]] = ... teardown_request_funcs: Dict[Optional[str], List[Callable[[Optional[Exception]], Any]]] = ... teardown_appcontext_funcs: List[Callable[[Optional[Exception]], Any]] = ... url_value_preprocessors: Any = ... url_default_functions: Any = ... template_context_processors: Any = ... shell_context_processors: Any = ... blueprints: Any = ... extensions: Any = ... url_map: Any = ... subdomain_matching: Any = ... cli: Any = ... def __init__( self, import_name: str, static_url_path: Optional[str] = ..., static_folder: Optional[str] = ..., static_host: Optional[str] = ..., host_matching: bool = ..., subdomain_matching: bool = ..., template_folder: str = ..., instance_path: Optional[str] = ..., instance_relative_config: bool = ..., root_path: Optional[str] = ..., ) -> None: ... @property def name(self) -> str: ... @property def propagate_exceptions(self) -> bool: ... @property def preserve_context_on_exception(self): ... @property def logger(self): ... @property def jinja_env(self): ... @property def got_first_request(self) -> bool: ... def make_config(self, instance_relative: bool = ...): ... def auto_find_instance_path(self): ... def open_instance_resource(self, resource: Union[str, Text], mode: str = ...): ... templates_auto_reload: Any = ... def create_jinja_environment(self): ... def create_global_jinja_loader(self): ... def select_jinja_autoescape(self, filename: Any): ... def update_template_context(self, context: Any) -> None: ... def make_shell_context(self): ... env: Optional[str] = ... debug: bool = ... def run( self, host: Optional[str] = ..., port: Optional[Union[int, str]] = ..., debug: Optional[bool] = ..., load_dotenv: bool = ..., **options: Any, ) -> None: ... def test_client(self, use_cookies: bool = ..., **kwargs: Any) -> FlaskClient[Response]: ... def test_cli_runner(self, **kwargs: Any): ... def open_session(self, request: Any): ... def save_session(self, session: Any, response: Any): ... def make_null_session(self): ... def register_blueprint(self, blueprint: Blueprint, **options: Any) -> None: ... def iter_blueprints(self): ... def add_url_rule( self, rule: str, endpoint: Optional[str] = ..., view_func: _ViewFunc = ..., provide_automatic_options: Optional[bool] = ..., **options: Any, ) -> None: ... def route(self, rule: str, **options: Any) -> Callable[[_VT], _VT]: ... def endpoint(self, endpoint: str) -> Callable[[Callable[..., _T]], Callable[..., _T]]: ... def errorhandler( self, code_or_exception: Union[int, Type[Exception]] ) -> Callable[[Callable[..., _T]], Callable[..., _T]]: ... def register_error_handler(self, code_or_exception: Union[int, Type[Exception]], f: Callable[..., Any]) -> None: ... def template_filter(self, name: Optional[Any] = ...): ... def add_template_filter(self, f: Any, name: Optional[Any] = ...) -> None: ... def template_test(self, name: Optional[Any] = ...): ... def add_template_test(self, f: Any, name: Optional[Any] = ...) -> None: ... def template_global(self, name: Optional[Any] = ...): ... def add_template_global(self, f: Any, name: Optional[Any] = ...) -> None: ... def before_request(self, f: Callable[[], _T]) -> Callable[[], _T]: ... def before_first_request(self, f: Callable[[], _T]) -> Callable[[], _T]: ... def after_request(self, f: Callable[[Response], Response]) -> Callable[[Response], Response]: ... def teardown_request(self, f: Callable[[Optional[Exception]], _T]) -> Callable[[Optional[Exception]], _T]: ... def teardown_appcontext(self, f: Callable[[Optional[Exception]], _T]) -> Callable[[Optional[Exception]], _T]: ... def context_processor(self, f: Any): ... def shell_context_processor(self, f: Any): ... def url_value_preprocessor(self, f: Any): ... def url_defaults(self, f: Any): ... def handle_http_exception(self, e: Any): ... def trap_http_exception(self, e: Any): ... def handle_user_exception(self, e: Any): ... def handle_exception(self, e: Any): ... def log_exception(self, exc_info: Any) -> None: ... def raise_routing_exception(self, request: Any) -> None: ... def dispatch_request(self): ... def full_dispatch_request(self): ... def finalize_request(self, rv: Any, from_error_handler: bool = ...): ... def try_trigger_before_first_request_functions(self): ... def make_default_options_response(self): ... def should_ignore_error(self, error: Any): ... def make_response(self, rv: Any): ... def create_url_adapter(self, request: Any): ... def inject_url_defaults(self, endpoint: Any, values: Any) -> None: ... def handle_url_build_error(self, error: Any, endpoint: Any, values: Any): ... def preprocess_request(self): ... def process_response(self, response: Any): ... def do_teardown_request(self, exc: Any = ...) -> None: ... def do_teardown_appcontext(self, exc: Any = ...) -> None: ... def app_context(self) -> AppContext: ... def request_context(self, environ: Any): ... def test_request_context(self, *args: Any, **kwargs: Any) -> ContextManager[RequestContext]: ... def wsgi_app(self, environ: Any, start_response: Any): ... def __call__(self, environ: Any, start_response: Any): ... # These are not preset at runtime but we add them since monkeypatching this # class is quite common. def __setattr__(self, name: str, value: Any): ... def __getattr__(self, name: str): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/flask/blueprints.pyi0000664000175000017500000000675400000000000026757 0ustar00davedave00000000000000from typing import Any, Callable, Optional, Type, TypeVar, Union from .app import _ViewFunc from .helpers import _PackageBoundObject _T = TypeVar("_T") _VT = TypeVar("_VT", bound=_ViewFunc) class _Sentinel(object): ... class BlueprintSetupState: app: Any = ... blueprint: Any = ... options: Any = ... first_registration: Any = ... subdomain: Any = ... url_prefix: Any = ... url_defaults: Any = ... def __init__(self, blueprint: Any, app: Any, options: Any, first_registration: Any) -> None: ... def add_url_rule(self, rule: str, endpoint: Optional[str] = ..., view_func: _ViewFunc = ..., **options: Any) -> None: ... class Blueprint(_PackageBoundObject): warn_on_modifications: bool = ... json_encoder: Any = ... json_decoder: Any = ... import_name: str = ... template_folder: Optional[str] = ... root_path: str = ... name: str = ... url_prefix: Optional[str] = ... subdomain: Optional[str] = ... static_folder: Optional[str] = ... static_url_path: Optional[str] = ... deferred_functions: Any = ... url_values_defaults: Any = ... cli_group: Union[Optional[str], _Sentinel] = ... def __init__( self, name: str, import_name: str, static_folder: Optional[str] = ..., static_url_path: Optional[str] = ..., template_folder: Optional[str] = ..., url_prefix: Optional[str] = ..., subdomain: Optional[str] = ..., url_defaults: Optional[Any] = ..., root_path: Optional[str] = ..., cli_group: Union[Optional[str], _Sentinel] = ..., ) -> None: ... def record(self, func: Any) -> None: ... def record_once(self, func: Any): ... def make_setup_state(self, app: Any, options: Any, first_registration: bool = ...): ... def register(self, app: Any, options: Any, first_registration: bool = ...) -> None: ... def route(self, rule: str, **options: Any) -> Callable[[_VT], _VT]: ... def add_url_rule(self, rule: str, endpoint: Optional[str] = ..., view_func: _ViewFunc = ..., **options: Any) -> None: ... def endpoint(self, endpoint: str) -> Callable[[Callable[..., _T]], Callable[..., _T]]: ... def app_template_filter(self, name: Optional[Any] = ...): ... def add_app_template_filter(self, f: Any, name: Optional[Any] = ...) -> None: ... def app_template_test(self, name: Optional[Any] = ...): ... def add_app_template_test(self, f: Any, name: Optional[Any] = ...) -> None: ... def app_template_global(self, name: Optional[Any] = ...): ... def add_app_template_global(self, f: Any, name: Optional[Any] = ...) -> None: ... def before_request(self, f: Any): ... def before_app_request(self, f: Any): ... def before_app_first_request(self, f: Any): ... def after_request(self, f: Any): ... def after_app_request(self, f: Any): ... def teardown_request(self, f: Any): ... def teardown_app_request(self, f: Any): ... def context_processor(self, f: Any): ... def app_context_processor(self, f: Any): ... def app_errorhandler(self, code: Any): ... def url_value_preprocessor(self, f: Any): ... def url_defaults(self, f: Any): ... def app_url_value_preprocessor(self, f: Any): ... def app_url_defaults(self, f: Any): ... def errorhandler( self, code_or_exception: Union[int, Type[Exception]] ) -> Callable[[Callable[..., _T]], Callable[..., _T]]: ... def register_error_handler(self, code_or_exception: Union[int, Type[Exception]], f: Callable[..., Any]) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/flask/cli.pyi0000664000175000017500000000422300000000000025324 0ustar00davedave00000000000000from typing import Any, Optional import click class NoAppException(click.UsageError): ... def find_best_app(script_info: Any, module: Any): ... def call_factory(script_info: Any, app_factory: Any, arguments: Any = ...): ... def find_app_by_string(script_info: Any, module: Any, app_name: Any): ... def prepare_import(path: Any): ... def locate_app(script_info: Any, module_name: Any, app_name: Any, raise_if_not_found: bool = ...): ... def get_version(ctx: Any, param: Any, value: Any): ... version_option: Any class DispatchingApp: loader: Any = ... def __init__(self, loader: Any, use_eager_loading: bool = ...) -> None: ... def __call__(self, environ: Any, start_response: Any): ... class ScriptInfo: app_import_path: Any = ... create_app: Any = ... data: Any = ... def __init__(self, app_import_path: Optional[Any] = ..., create_app: Optional[Any] = ...) -> None: ... def load_app(self): ... pass_script_info: Any def with_appcontext(f: Any): ... class AppGroup(click.Group): def command(self, *args: Any, **kwargs: Any): ... def group(self, *args: Any, **kwargs: Any): ... class FlaskGroup(AppGroup): create_app: Any = ... load_dotenv: Any = ... def __init__( self, add_default_commands: bool = ..., create_app: Optional[Any] = ..., add_version_option: bool = ..., load_dotenv: bool = ..., **extra: Any, ) -> None: ... def get_command(self, ctx: Any, name: Any): ... def list_commands(self, ctx: Any): ... def main(self, *args: Any, **kwargs: Any): ... def load_dotenv(path: Optional[Any] = ...): ... def show_server_banner(env: Any, debug: Any, app_import_path: Any, eager_loading: Any): ... class CertParamType(click.ParamType): name: str = ... path_type: Any = ... def __init__(self) -> None: ... def convert(self, value: Any, param: Any, ctx: Any): ... def run_command( info: Any, host: Any, port: Any, reload: Any, debugger: Any, eager_loading: Any, with_threads: Any, cert: Any ) -> None: ... def shell_command() -> None: ... def routes_command(sort: Any, all_methods: Any): ... cli: Any def main(as_module: bool = ...) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/flask/config.pyi0000664000175000017500000000154700000000000026030 0ustar00davedave00000000000000from typing import Any, Dict, Optional class ConfigAttribute: __name__: Any = ... get_converter: Any = ... def __init__(self, name: Any, get_converter: Optional[Any] = ...) -> None: ... def __get__(self, obj: Any, type: Optional[Any] = ...): ... def __set__(self, obj: Any, value: Any) -> None: ... class Config(Dict[str, Any]): root_path: Any = ... def __init__(self, root_path: Any, defaults: Optional[Any] = ...) -> None: ... def from_envvar(self, variable_name: Any, silent: bool = ...): ... def from_pyfile(self, filename: Any, silent: bool = ...): ... def from_object(self, obj: Any) -> None: ... def from_json(self, filename: Any, silent: bool = ...): ... def from_mapping(self, *mapping: Any, **kwargs: Any): ... def get_namespace(self, namespace: Any, lowercase: bool = ..., trim_namespace: bool = ...): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/flask/ctx.pyi0000664000175000017500000000246700000000000025363 0ustar00davedave00000000000000from typing import Any, Optional class _AppCtxGlobals: def get(self, name: Any, default: Optional[Any] = ...): ... def pop(self, name: Any, default: Any = ...): ... def setdefault(self, name: Any, default: Optional[Any] = ...): ... def __contains__(self, item: Any): ... def __iter__(self): ... def after_this_request(f: Any): ... def copy_current_request_context(f: Any): ... def has_request_context(): ... def has_app_context(): ... class AppContext: app: Any = ... url_adapter: Any = ... g: Any = ... def __init__(self, app: Any) -> None: ... def push(self) -> None: ... def pop(self, exc: Any = ...) -> None: ... def __enter__(self): ... def __exit__(self, exc_type: Any, exc_value: Any, tb: Any) -> None: ... class RequestContext: app: Any = ... request: Any = ... url_adapter: Any = ... flashes: Any = ... session: Any = ... preserved: bool = ... def __init__(self, app: Any, environ: Any, request: Optional[Any] = ...) -> None: ... g: Any = ... def copy(self): ... def match_request(self) -> None: ... def push(self) -> None: ... def pop(self, exc: Any = ...) -> None: ... def auto_pop(self, exc: Any) -> None: ... def __enter__(self): ... def __exit__(self, exc_type: Any, exc_value: Any, tb: Any) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/flask/debughelpers.pyi0000664000175000017500000000077300000000000027234 0ustar00davedave00000000000000from typing import Any class UnexpectedUnicodeError(AssertionError, UnicodeError): ... class DebugFilesKeyError(KeyError, AssertionError): msg: Any = ... def __init__(self, request: Any, key: Any) -> None: ... class FormDataRoutingRedirect(AssertionError): def __init__(self, request: Any) -> None: ... def attach_enctype_error_multidict(request: Any): ... def explain_template_loading_attempts(app: Any, template: Any, attempts: Any) -> None: ... def explain_ignored_app_run() -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/flask/globals.pyi0000664000175000017500000000050200000000000026174 0ustar00davedave00000000000000from typing import Any from werkzeug.local import LocalStack from .app import Flask from .wrappers import Request class _FlaskLocalProxy(Flask): def _get_current_object(self) -> Flask: ... _request_ctx_stack: LocalStack _app_ctx_stack: LocalStack current_app: _FlaskLocalProxy request: Request session: Any g: Any ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/flask/helpers.pyi0000664000175000017500000000376400000000000026230 0ustar00davedave00000000000000from typing import Any, Optional from .cli import AppGroup from .wrappers import Response def get_env(): ... def get_debug_flag(): ... def get_load_dotenv(default: bool = ...): ... def stream_with_context(generator_or_function: Any): ... def make_response(*args: Any) -> Response: ... def url_for(endpoint: str, **values: Any) -> str: ... def get_template_attribute(template_name: Any, attribute: Any): ... def flash(message: Any, category: str = ...) -> None: ... def get_flashed_messages(with_categories: bool = ..., category_filter: Any = ...): ... def send_file( filename_or_fp: Any, mimetype: Optional[Any] = ..., as_attachment: bool = ..., attachment_filename: Optional[Any] = ..., add_etags: bool = ..., cache_timeout: Optional[Any] = ..., conditional: bool = ..., last_modified: Optional[Any] = ..., ) -> Response: ... def safe_join(directory: Any, *pathnames: Any): ... def send_from_directory(directory: Any, filename: Any, **options: Any) -> Response: ... def get_root_path(import_name: Any): ... def find_package(import_name: Any): ... class locked_cached_property: __name__: Any = ... __module__: Any = ... __doc__: Any = ... func: Any = ... lock: Any = ... def __init__(self, func: Any, name: Optional[Any] = ..., doc: Optional[Any] = ...) -> None: ... def __get__(self, obj: Any, type: Optional[Any] = ...): ... class _PackageBoundObject: import_name: Any = ... template_folder: Any = ... root_path: Any = ... cli: AppGroup = ... def __init__(self, import_name: Any, template_folder: Optional[Any] = ..., root_path: Optional[Any] = ...) -> None: ... static_folder: Any = ... static_url_path: Any = ... @property def has_static_folder(self): ... def jinja_loader(self): ... def get_send_file_max_age(self, filename: Any): ... def send_static_file(self, filename: Any) -> Response: ... def open_resource(self, resource: Any, mode: str = ...): ... def total_seconds(td: Any): ... def is_ip(value: Any): ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4463794 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/flask/json/0000775000175000017500000000000000000000000025002 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/flask/json/__init__.pyi0000664000175000017500000000121600000000000027264 0ustar00davedave00000000000000import json as _json from typing import Any from jinja2 import Markup class JSONEncoder(_json.JSONEncoder): def default(self, o: Any): ... class JSONDecoder(_json.JSONDecoder): ... def detect_encoding(data: bytes) -> str: ... # undocumented def dumps(obj: Any, **kwargs: Any): ... def dump(obj: Any, fp: Any, **kwargs: Any) -> None: ... def loads(s: Any, **kwargs: Any): ... def load(fp: Any, **kwargs: Any): ... def htmlsafe_dumps(obj: Any, **kwargs: Any): ... def htmlsafe_dump(obj: Any, fp: Any, **kwargs: Any) -> None: ... def jsonify(*args: Any, **kwargs: Any): ... def tojson_filter(obj: Any, **kwargs: Any) -> Markup: ... # undocumented ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/flask/json/tag.pyi0000664000175000017500000000357600000000000026313 0ustar00davedave00000000000000from typing import Any, Optional class JSONTag: key: Any = ... serializer: Any = ... def __init__(self, serializer: Any) -> None: ... def check(self, value: Any) -> None: ... def to_json(self, value: Any) -> None: ... def to_python(self, value: Any) -> None: ... def tag(self, value: Any): ... class TagDict(JSONTag): key: str = ... def check(self, value: Any): ... def to_json(self, value: Any): ... def to_python(self, value: Any): ... class PassDict(JSONTag): def check(self, value: Any): ... def to_json(self, value: Any): ... tag: Any = ... class TagTuple(JSONTag): key: str = ... def check(self, value: Any): ... def to_json(self, value: Any): ... def to_python(self, value: Any): ... class PassList(JSONTag): def check(self, value: Any): ... def to_json(self, value: Any): ... tag: Any = ... class TagBytes(JSONTag): key: str = ... def check(self, value: Any): ... def to_json(self, value: Any): ... def to_python(self, value: Any): ... class TagMarkup(JSONTag): key: str = ... def check(self, value: Any): ... def to_json(self, value: Any): ... def to_python(self, value: Any): ... class TagUUID(JSONTag): key: str = ... def check(self, value: Any): ... def to_json(self, value: Any): ... def to_python(self, value: Any): ... class TagDateTime(JSONTag): key: str = ... def check(self, value: Any): ... def to_json(self, value: Any): ... def to_python(self, value: Any): ... class TaggedJSONSerializer: default_tags: Any = ... tags: Any = ... order: Any = ... def __init__(self) -> None: ... def register(self, tag_class: Any, force: bool = ..., index: Optional[Any] = ...) -> None: ... def tag(self, value: Any): ... def untag(self, value: Any): ... def dumps(self, value: Any): ... def loads(self, value: Any): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/flask/logging.pyi0000664000175000017500000000022600000000000026202 0ustar00davedave00000000000000from typing import Any def wsgi_errors_stream(): ... def has_level_handler(logger: Any): ... default_handler: Any def create_logger(app: Any): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/flask/sessions.pyi0000664000175000017500000000374100000000000026427 0ustar00davedave00000000000000from abc import ABCMeta from typing import Any, MutableMapping, Optional from werkzeug.datastructures import CallbackDict class SessionMixin(MutableMapping[str, Any], metaclass=ABCMeta): @property def permanent(self): ... @permanent.setter def permanent(self, value: Any) -> None: ... new: bool = ... modified: bool = ... accessed: bool = ... class SecureCookieSession(CallbackDict[str, Any], SessionMixin): modified: bool = ... accessed: bool = ... def __init__(self, initial: Optional[Any] = ...) -> None: ... def __getitem__(self, key: Any): ... def get(self, key: Any, default: Optional[Any] = ...): ... def setdefault(self, key: Any, default: Optional[Any] = ...): ... class NullSession(SecureCookieSession): __setitem__: Any = ... __delitem__: Any = ... clear: Any = ... pop: Any = ... popitem: Any = ... update: Any = ... setdefault: Any = ... class SessionInterface: null_session_class: Any = ... pickle_based: bool = ... def make_null_session(self, app: Any): ... def is_null_session(self, obj: Any): ... def get_cookie_domain(self, app: Any): ... def get_cookie_path(self, app: Any): ... def get_cookie_httponly(self, app: Any): ... def get_cookie_secure(self, app: Any): ... def get_cookie_samesite(self, app: Any): ... def get_expiration_time(self, app: Any, session: Any): ... def should_set_cookie(self, app: Any, session: Any): ... def open_session(self, app: Any, request: Any) -> None: ... def save_session(self, app: Any, session: Any, response: Any) -> None: ... session_json_serializer: Any class SecureCookieSessionInterface(SessionInterface): salt: str = ... digest_method: Any = ... key_derivation: str = ... serializer: Any = ... session_class: Any = ... def get_signing_serializer(self, app: Any): ... def open_session(self, app: Any, request: Any): ... def save_session(self, app: Any, session: Any, response: Any): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/flask/signals.pyi0000664000175000017500000000131600000000000026215 0ustar00davedave00000000000000from typing import Any, Optional signals_available: bool class Namespace: def signal(self, name: Any, doc: Optional[Any] = ...): ... class _FakeSignal: name: Any = ... __doc__: Any = ... def __init__(self, name: Any, doc: Optional[Any] = ...) -> None: ... send: Any = ... connect: Any = ... disconnect: Any = ... has_receivers_for: Any = ... receivers_for: Any = ... temporarily_connected_to: Any = ... connected_to: Any = ... template_rendered: Any before_render_template: Any request_started: Any request_finished: Any request_tearing_down: Any got_request_exception: Any appcontext_tearing_down: Any appcontext_pushed: Any appcontext_popped: Any message_flashed: Any ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/flask/templating.pyi0000664000175000017500000000113400000000000026717 0ustar00davedave00000000000000from typing import Any, Iterable, Text, Union from jinja2 import BaseLoader, Environment as BaseEnvironment class Environment(BaseEnvironment): app: Any = ... def __init__(self, app: Any, **options: Any) -> None: ... class DispatchingJinjaLoader(BaseLoader): app: Any = ... def __init__(self, app: Any) -> None: ... def get_source(self, environment: Any, template: Any): ... def list_templates(self): ... def render_template(template_name_or_list: Union[Text, Iterable[Text]], **context: Any) -> Text: ... def render_template_string(source: Text, **context: Any) -> Text: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/flask/testing.pyi0000664000175000017500000000344300000000000026235 0ustar00davedave00000000000000from typing import IO, Any, Iterable, Mapping, Optional, Text, TypeVar, Union from click import BaseCommand from click.testing import CliRunner, Result from werkzeug.test import Client, EnvironBuilder as WerkzeugEnvironBuilder # Response type for the client below. # By default _R is Tuple[Iterable[Any], Union[Text, int], werkzeug.datastructures.Headers], however # most commonly it is wrapped in a Reponse object. _R = TypeVar("_R") class FlaskClient(Client[_R]): preserve_context: bool = ... environ_base: Any = ... def __init__(self, *args: Any, **kwargs: Any) -> None: ... def session_transaction(self, *args: Any, **kwargs: Any) -> None: ... def __enter__(self): ... def __exit__(self, exc_type: Any, exc_value: Any, tb: Any) -> None: ... class FlaskCliRunner(CliRunner): app: Any = ... def __init__(self, app: Any, **kwargs: Any) -> None: ... def invoke( self, cli: Optional[BaseCommand] = ..., args: Optional[Union[str, Iterable[str]]] = ..., input: Optional[Union[bytes, IO[Any], Text]] = ..., env: Optional[Mapping[str, str]] = ..., catch_exceptions: bool = ..., color: bool = ..., **extra: Any, ) -> Result: ... class EnvironBuilder(WerkzeugEnvironBuilder): app: Any def __init__( self, app: Any, path: str = ..., base_url: Optional[Any] = ..., subdomain: Optional[Any] = ..., url_scheme: Optional[Any] = ..., *args: Any, **kwargs: Any, ) -> None: ... def json_dumps(self, obj: Any, **kwargs: Any) -> str: ... def make_test_environ_builder( app: Any, path: str = ..., base_url: Optional[Any] = ..., subdomain: Optional[Any] = ..., url_scheme: Optional[Any] = ..., *args: Any, **kwargs: Any, ): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/flask/views.pyi0000664000175000017500000000102200000000000025704 0ustar00davedave00000000000000from typing import Any http_method_funcs: Any class View: methods: Any = ... provide_automatic_options: Any = ... decorators: Any = ... def dispatch_request(self, *args: Any, **kwargs: Any) -> Any: ... @classmethod def as_view(cls, name: Any, *class_args: Any, **class_kwargs: Any): ... class MethodViewType(type): def __init__(self, name: Any, bases: Any, d: Any) -> None: ... class MethodView(View, metaclass=MethodViewType): def dispatch_request(self, *args: Any, **kwargs: Any) -> Any: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/flask/wrappers.pyi0000664000175000017500000000217100000000000026420 0ustar00davedave00000000000000from typing import Any, Dict, Optional from werkzeug.exceptions import HTTPException from werkzeug.routing import Rule from werkzeug.wrappers import Request as RequestBase, Response as ResponseBase class JSONMixin: @property def is_json(self) -> bool: ... @property def json(self): ... def get_json(self, force: bool = ..., silent: bool = ..., cache: bool = ...): ... def on_json_loading_failed(self, e: Any) -> None: ... class Request(RequestBase, JSONMixin): url_rule: Optional[Rule] = ... view_args: Dict[str, Any] = ... routing_exception: Optional[HTTPException] = ... # Request is making the max_content_length readonly, where it was not the # case in its supertype. # We would require something like https://github.com/python/typing/issues/241 @property def max_content_length(self) -> Optional[int]: ... # type: ignore @property def endpoint(self) -> Optional[str]: ... @property def blueprint(self) -> Optional[str]: ... class Response(ResponseBase, JSONMixin): default_mimetype: Optional[str] = ... @property def max_cookie_size(self) -> int: ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4463794 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/geoip2/0000775000175000017500000000000000000000000024116 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/geoip2/__init__.pyi0000664000175000017500000000000000000000000026366 0ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/geoip2/database.pyi0000664000175000017500000000215500000000000026410 0ustar00davedave00000000000000from types import TracebackType from typing import Optional, Sequence, Text, Type from geoip2.models import ASN, ISP, AnonymousIP, City, ConnectionType, Country, Domain, Enterprise from maxminddb.reader import Metadata _Locales = Optional[Sequence[Text]] class Reader: def __init__(self, filename: Text, locales: _Locales = ..., mode: int = ...) -> None: ... def __enter__(self) -> Reader: ... def __exit__( self, exc_type: Optional[Type[BaseException]] = ..., exc_val: Optional[BaseException] = ..., exc_tb: Optional[TracebackType] = ..., ) -> None: ... def country(self, ip_address: Text) -> Country: ... def city(self, ip_address: Text) -> City: ... def anonymous_ip(self, ip_address: Text) -> AnonymousIP: ... def asn(self, ip_address: Text) -> ASN: ... def connection_type(self, ip_address: Text) -> ConnectionType: ... def domain(self, ip_address: Text) -> Domain: ... def enterprise(self, ip_address: Text) -> Enterprise: ... def isp(self, ip_address: Text) -> ISP: ... def metadata(self) -> Metadata: ... def close(self) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/geoip2/errors.pyi0000664000175000017500000000075600000000000026165 0ustar00davedave00000000000000from typing import Optional, Text class GeoIP2Error(RuntimeError): ... class AddressNotFoundError(GeoIP2Error): ... class AuthenticationError(GeoIP2Error): ... class HTTPError(GeoIP2Error): http_status: Optional[int] uri: Optional[Text] def __init__(self, message: Text, http_status: Optional[int] = ..., uri: Optional[Text] = ...) -> None: ... class InvalidRequestError(GeoIP2Error): ... class OutOfQueriesError(GeoIP2Error): ... class PermissionRequiredError(GeoIP2Error): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/geoip2/mixins.pyi0000664000175000017500000000017000000000000026146 0ustar00davedave00000000000000class SimpleEquality: def __eq__(self, other: object) -> bool: ... def __ne__(self, other: object) -> bool: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/geoip2/models.pyi0000664000175000017500000000351300000000000026126 0ustar00davedave00000000000000from typing import Any, Mapping, Optional, Sequence, Text from geoip2 import records from geoip2.mixins import SimpleEquality _Locales = Optional[Sequence[Text]] _RawResponse = Mapping[Text, Mapping[Text, Any]] class Country(SimpleEquality): continent: records.Continent country: records.Country registered_country: records.Country represented_country: records.RepresentedCountry maxmind: records.MaxMind traits: records.Traits raw: _RawResponse def __init__(self, raw_response: _RawResponse, locales: _Locales = ...) -> None: ... class City(Country): city: records.City location: records.Location postal: records.Postal subdivisions: records.Subdivisions def __init__(self, raw_response: _RawResponse, locales: _Locales = ...) -> None: ... class Insights(City): ... class Enterprise(City): ... class SimpleModel(SimpleEquality): ... class AnonymousIP(SimpleModel): is_anonymous: bool is_anonymous_vpn: bool is_hosting_provider: bool is_public_proxy: bool is_tor_exit_node: bool ip_address: Optional[Text] raw: _RawResponse def __init__(self, raw: _RawResponse) -> None: ... class ASN(SimpleModel): autonomous_system_number: Optional[int] autonomous_system_organization: Optional[Text] ip_address: Optional[Text] raw: _RawResponse def __init__(self, raw: _RawResponse) -> None: ... class ConnectionType(SimpleModel): connection_type: Optional[Text] ip_address: Optional[Text] raw: _RawResponse def __init__(self, raw: _RawResponse) -> None: ... class Domain(SimpleModel): domain: Optional[Text] ip_address: Optional[Text] raw: Optional[Text] def __init__(self, raw: _RawResponse) -> None: ... class ISP(ASN): isp: Optional[Text] organization: Optional[Text] def __init__(self, raw: _RawResponse) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/geoip2/records.pyi0000664000175000017500000000402700000000000026305 0ustar00davedave00000000000000from typing import Any, Mapping, Optional, Sequence, Text, Tuple from geoip2.mixins import SimpleEquality _Locales = Optional[Sequence[Text]] _Names = Mapping[Text, Text] class Record(SimpleEquality): def __init__(self, **kwargs: Any) -> None: ... def __setattr__(self, name: Text, value: Any) -> None: ... class PlaceRecord(Record): def __init__(self, locales: _Locales = ..., **kwargs: Any) -> None: ... @property def name(self) -> Text: ... class City(PlaceRecord): confidence: int geoname_id: int names: _Names class Continent(PlaceRecord): code: Text geoname_id: int names: _Names class Country(PlaceRecord): confidence: int geoname_id: int is_in_european_union: bool iso_code: Text names: _Names def __init__(self, locales: _Locales = ..., **kwargs: Any) -> None: ... class RepresentedCountry(Country): type: Text class Location(Record): average_income: int accuracy_radius: int latitude: float longitude: float metro_code: int population_density: int time_zone: Text class MaxMind(Record): queries_remaining: int class Postal(Record): code: Text confidence: int class Subdivision(PlaceRecord): confidence: int geoname_id: int iso_code: Text names: _Names class Subdivisions(Tuple[Subdivision]): def __new__(cls, locales: _Locales, *subdivisions: Subdivision) -> Subdivisions: ... def __init__(self, locales: _Locales, *subdivisions: Subdivision) -> None: ... @property def most_specific(self) -> Subdivision: ... class Traits(Record): autonomous_system_number: int autonomous_system_organization: Text connection_type: Text domain: Text ip_address: Text is_anonymous: bool is_anonymous_proxy: bool is_anonymous_vpn: bool is_hosting_provider: bool is_legitimate_proxy: bool is_public_proxy: bool is_satellite_provider: bool is_tor_exit_node: bool isp: Text organization: Text user_type: Text def __init__(self, **kwargs: Any) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/gflags.pyi0000664000175000017500000002503000000000000024717 0ustar00davedave00000000000000from types import ModuleType from typing import IO, Any, Callable, Dict, Iterable, List, Optional, Sequence, Text, Union class Error(Exception): ... FlagsError = Error class DuplicateFlag(FlagsError): ... class CantOpenFlagFileError(FlagsError): ... class DuplicateFlagCannotPropagateNoneToSwig(DuplicateFlag): ... class DuplicateFlagError(DuplicateFlag): def __init__(self, flagname: str, flag_values: FlagValues, other_flag_values: FlagValues = ...) -> None: ... class IllegalFlagValueError(FlagsError): ... IllegalFlagValue = IllegalFlagValueError class UnrecognizedFlag(FlagsError): ... class UnrecognizedFlagError(UnrecognizedFlag): def __init__(self, flagname: str, flagvalue: str = ...) -> None: ... def get_help_width() -> int: ... GetHelpWidth = get_help_width def text_wrap(text: str, length: int = ..., indent: str = ..., firstline_indent: str = ..., tabs: str = ...) -> str: ... TextWrap = text_wrap def doc_to_help(doc: str) -> str: ... DocToHelp = doc_to_help class FlagValues: def __init__(self) -> None: ... def UseGnuGetOpt(self, use_gnu_getopt: bool = ...) -> None: ... def is_gnu_getopt(self) -> bool: ... IsGnuGetOpt = is_gnu_getopt # TODO dict type def FlagDict(self) -> Dict[Any, Any]: ... def flags_by_module_dict(self) -> Dict[str, List[Flag]]: ... FlagsByModuleDict = flags_by_module_dict def flags_by_module_id_dict(self) -> Dict[int, List[Flag]]: ... FlagsByModuleIdDict = flags_by_module_id_dict def key_flags_by_module_dict(self) -> Dict[str, List[Flag]]: ... KeyFlagsByModuleDict = key_flags_by_module_dict def find_module_defining_flag(self, flagname: str, default: str = ...) -> str: ... FindModuleDefiningFlag = find_module_defining_flag def find_module_id_defining_flag(self, flagname: str, default: int = ...) -> int: ... FindModuleIdDefiningFlag = find_module_id_defining_flag def append_flag_values(self, flag_values: FlagValues) -> None: ... AppendFlagValues = append_flag_values def remove_flag_values(self, flag_values: FlagValues) -> None: ... RemoveFlagValues = remove_flag_values def __setitem__(self, name: str, flag: Flag) -> None: ... def __getitem__(self, name: str) -> Flag: ... def __getattr__(self, name: str) -> Any: ... def __setattr__(self, name: str, value: Any) -> None: ... def __delattr__(self, flag_name: str) -> None: ... def set_default(self, name: str, value: Any) -> None: ... SetDefault = set_default def __contains__(self, name: str) -> bool: ... has_key = __contains__ def __iter__(self) -> Iterable[str]: ... def __call__(self, argv: List[str], known_only: bool = ...) -> List[str]: ... def reset(self) -> None: ... Reset = reset def RegisteredFlags(self) -> List[str]: ... def flag_values_dict(self) -> Dict[str, Any]: ... FlagValuesDict = flag_values_dict def __str__(self) -> str: ... def GetHelp(self, prefix: str = ...) -> str: ... def module_help(self, module: Union[ModuleType, str]) -> str: ... ModuleHelp = module_help def main_module_help(self) -> str: ... MainModuleHelp = main_module_help def get(self, name: str, default: Any) -> Any: ... def ShortestUniquePrefixes(self, fl: Dict[str, Flag]) -> Dict[str, str]: ... def ExtractFilename(self, flagfile_str: str) -> str: ... def read_flags_from_files(self, argv: List[str], force_gnu: bool = ...) -> List[str]: ... ReadFlagsFromFiles = read_flags_from_files def flags_into_string(self) -> str: ... FlagsIntoString = flags_into_string def append_flags_into_file(self, filename: str) -> None: ... AppendFlagsIntoFile = append_flags_into_file def write_help_in_xml_format(self, outfile: IO[str] = ...) -> None: ... WriteHelpInXMLFormat = write_help_in_xml_format # TODO validator: gflags_validators.Validator def AddValidator(self, validator: Any) -> None: ... def is_parsed(self) -> bool: ... IsParsed = is_parsed FLAGS: FlagValues class Flag: name: str default: Any default_as_str: str value: Any help: str short_name: str boolean = False present = False parser: ArgumentParser serializer: ArgumentSerializer allow_override = False def __init__( self, parser: ArgumentParser, serializer: ArgumentSerializer, name: str, default: Optional[str], help_string: str, short_name: str = ..., boolean: bool = ..., allow_override: bool = ..., ) -> None: ... def Parse(self, argument: Any) -> Any: ... def Unparse(self) -> None: ... def Serialize(self) -> str: ... def SetDefault(self, value: Any) -> None: ... def Type(self) -> str: ... def WriteInfoInXMLFormat(self, outfile: IO[str], module_name: str, is_key: bool = ..., indent: str = ...) -> None: ... class ArgumentParser(object): syntactic_help: str # TODO what is this def parse(self, argument: Any) -> Any: ... Parser = parse def flag_type(self) -> str: ... Type = flag_type def WriteCustomInfoInXMLFormat(self, outfile: IO[str], indent: str) -> None: ... class ArgumentSerializer: def Serialize(self, value: Any) -> Text: ... class ListSerializer(ArgumentSerializer): def __init__(self, list_sep: str) -> None: ... def Serialize(self, value: List[Any]) -> str: ... def register_validator( flag_name: str, checker: Callable[[Any], bool], message: str = ..., flag_values: FlagValues = ... ) -> None: ... RegisterValidator = register_validator def mark_flag_as_required(flag_name: str, flag_values: FlagValues = ...) -> None: ... MarkFlagAsRequired = mark_flag_as_required def mark_flags_as_required(flag_names: Iterable[str], flag_values: FlagValues = ...) -> None: ... MarkFlagsAsRequired = mark_flags_as_required def mark_flags_as_mutual_exclusive(flag_names: Iterable[str], required: bool = ..., flag_values: FlagValues = ...) -> None: ... MarkFlagsAsMutualExclusive = mark_flags_as_mutual_exclusive def DEFINE( parser: ArgumentParser, name: str, default: Any, help: str, flag_values: FlagValues = ..., serializer: ArgumentSerializer = ..., **args: Any, ) -> None: ... def DEFINE_flag(flag: Flag, flag_values: FlagValues = ...) -> None: ... def declare_key_flag(flag_name: str, flag_values: FlagValues = ...) -> None: ... DECLARE_key_flag = declare_key_flag def adopt_module_key_flags(module: ModuleType, flag_values: FlagValues = ...) -> None: ... ADOPT_module_key_flags = adopt_module_key_flags def DEFINE_string(name: str, default: Optional[str], help: str, flag_values: FlagValues = ..., **args: Any) -> None: ... class BooleanParser(ArgumentParser): def Convert(self, argument: Any) -> bool: ... def Parse(self, argument: Any) -> bool: ... class BooleanFlag(Flag): def __init__(self, name: str, default: Optional[bool], help: str, short_name: str = ..., **args: Any) -> None: ... def DEFINE_boolean(name: str, default: Optional[bool], help: str, flag_values: FlagValues = ..., **args: Any) -> None: ... DEFINE_bool = DEFINE_boolean class HelpFlag(BooleanFlag): def __init__(self) -> None: ... def Parse(self, arg: Any) -> None: ... class HelpXMLFlag(BooleanFlag): def __init__(self) -> None: ... def Parse(self, arg: Any) -> None: ... class HelpshortFlag(BooleanFlag): def __init__(self) -> None: ... def Parse(self, arg: Any) -> None: ... class NumericParser(ArgumentParser): def IsOutsideBounds(self, val: float) -> bool: ... def Parse(self, argument: Any) -> float: ... def WriteCustomInfoInXMLFormat(self, outfile: IO[str], indent: str) -> None: ... def Convert(self, argument: Any) -> Any: ... class FloatParser(NumericParser): number_article: str number_name: str syntactic_help: str def __init__(self, lower_bound: float = ..., upper_bound: float = ...) -> None: ... def Convert(self, argument: Any) -> float: ... def DEFINE_float( name: str, default: Optional[float], help: str, lower_bound: float = ..., upper_bound: float = ..., flag_values: FlagValues = ..., **args: Any, ) -> None: ... class IntegerParser(NumericParser): number_article: str number_name: str syntactic_help: str def __init__(self, lower_bound: int = ..., upper_bound: int = ...) -> None: ... def Convert(self, argument: Any) -> int: ... def DEFINE_integer( name: str, default: Optional[int], help: str, lower_bound: int = ..., upper_bound: int = ..., flag_values: FlagValues = ..., **args: Any, ) -> None: ... class EnumParser(ArgumentParser): def __init__(self, enum_values: List[str]) -> None: ... def Parse(self, argument: Any) -> Any: ... class EnumFlag(Flag): def __init__( self, name: str, default: Optional[str], help: str, enum_values: List[str], short_name: str, **args: Any ) -> None: ... def DEFINE_enum( name: str, default: Optional[str], enum_values: Iterable[str], help: str, flag_values: FlagValues = ..., **args: Any ) -> None: ... class BaseListParser(ArgumentParser): def __init__(self, token: str = ..., name: str = ...) -> None: ... def Parse(self, argument: Any) -> List[Any]: ... class ListParser(BaseListParser): def __init__(self) -> None: ... class WhitespaceSeparatedListParser(BaseListParser): def __init__(self) -> None: ... def DEFINE_list(name: str, default: Optional[List[str]], help: str, flag_values: FlagValues = ..., **args: Any) -> None: ... def DEFINE_spaceseplist( name: str, default: Optional[List[str]], help: str, flag_values: FlagValues = ..., **args: Any ) -> None: ... class MultiFlag(Flag): def __init__(self, *args: Any, **kwargs: Any) -> None: ... def Parse(self, arguments: Any) -> None: ... def Serialize(self) -> str: ... def DEFINE_multi_string( name: str, default: Optional[Union[str, List[str]]], help: str, flag_values: FlagValues = ..., **args: Any ) -> None: ... DEFINE_multistring = DEFINE_multi_string def DEFINE_multi_integer( name: str, default: Optional[Union[int, List[int]]], help: str, lower_bound: int = ..., upper_bound: int = ..., flag_values: FlagValues = ..., **args: Any, ) -> None: ... DEFINE_multi_int = DEFINE_multi_integer def DEFINE_multi_float( name: str, default: Optional[Union[float, List[float]]], help: str, lower_bound: float = ..., upper_bound: float = ..., flag_values: FlagValues = ..., **args: Any, ) -> None: ... def DEFINE_multi_enum( name: str, default: Optional[Union[Sequence[str], str]], enum_values: Sequence[str], help: str, flag_values: FlagValues = ..., case_sensitive: bool = ..., **args: Any, ) -> None: ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4463794 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/google/0000775000175000017500000000000000000000000024205 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/google/__init__.pyi0000664000175000017500000000000000000000000026455 0ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4463794 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/google/protobuf/0000775000175000017500000000000000000000000026045 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/google/protobuf/__init__.pyi0000664000175000017500000000002300000000000030322 0ustar00davedave00000000000000__version__: bytes ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/google/protobuf/any_pb2.pyi0000664000175000017500000000251100000000000030121 0ustar00davedave00000000000000""" @generated by mypy-protobuf. Do not edit manually! isort:skip_file """ from google.protobuf.descriptor import ( Descriptor as google___protobuf___descriptor___Descriptor, FileDescriptor as google___protobuf___descriptor___FileDescriptor, ) from google.protobuf.internal.well_known_types import ( Any as google___protobuf___internal___well_known_types___Any, ) from google.protobuf.message import ( Message as google___protobuf___message___Message, ) from typing import ( Optional as typing___Optional, Text as typing___Text, ) from typing_extensions import ( Literal as typing_extensions___Literal, ) builtin___bool = bool builtin___bytes = bytes builtin___float = float builtin___int = int DESCRIPTOR: google___protobuf___descriptor___FileDescriptor = ... class Any(google___protobuf___message___Message, google___protobuf___internal___well_known_types___Any): DESCRIPTOR: google___protobuf___descriptor___Descriptor = ... type_url: typing___Text = ... value: builtin___bytes = ... def __init__(self, *, type_url : typing___Optional[typing___Text] = None, value : typing___Optional[builtin___bytes] = None, ) -> None: ... def ClearField(self, field_name: typing_extensions___Literal[u"type_url",b"type_url",u"value",b"value"]) -> None: ... type___Any = Any ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/google/protobuf/api_pb2.pyi0000664000175000017500000001142100000000000030103 0ustar00davedave00000000000000""" @generated by mypy-protobuf. Do not edit manually! isort:skip_file """ from google.protobuf.descriptor import ( Descriptor as google___protobuf___descriptor___Descriptor, FileDescriptor as google___protobuf___descriptor___FileDescriptor, ) from google.protobuf.internal.containers import ( RepeatedCompositeFieldContainer as google___protobuf___internal___containers___RepeatedCompositeFieldContainer, ) from google.protobuf.message import ( Message as google___protobuf___message___Message, ) from google.protobuf.source_context_pb2 import ( SourceContext as google___protobuf___source_context_pb2___SourceContext, ) from google.protobuf.type_pb2 import ( Option as google___protobuf___type_pb2___Option, SyntaxValue as google___protobuf___type_pb2___SyntaxValue, ) from typing import ( Iterable as typing___Iterable, Optional as typing___Optional, Text as typing___Text, ) from typing_extensions import ( Literal as typing_extensions___Literal, ) builtin___bool = bool builtin___bytes = bytes builtin___float = float builtin___int = int DESCRIPTOR: google___protobuf___descriptor___FileDescriptor = ... class Api(google___protobuf___message___Message): DESCRIPTOR: google___protobuf___descriptor___Descriptor = ... name: typing___Text = ... version: typing___Text = ... syntax: google___protobuf___type_pb2___SyntaxValue = ... @property def methods(self) -> google___protobuf___internal___containers___RepeatedCompositeFieldContainer[type___Method]: ... @property def options(self) -> google___protobuf___internal___containers___RepeatedCompositeFieldContainer[google___protobuf___type_pb2___Option]: ... @property def source_context(self) -> google___protobuf___source_context_pb2___SourceContext: ... @property def mixins(self) -> google___protobuf___internal___containers___RepeatedCompositeFieldContainer[type___Mixin]: ... def __init__(self, *, name : typing___Optional[typing___Text] = None, methods : typing___Optional[typing___Iterable[type___Method]] = None, options : typing___Optional[typing___Iterable[google___protobuf___type_pb2___Option]] = None, version : typing___Optional[typing___Text] = None, source_context : typing___Optional[google___protobuf___source_context_pb2___SourceContext] = None, mixins : typing___Optional[typing___Iterable[type___Mixin]] = None, syntax : typing___Optional[google___protobuf___type_pb2___SyntaxValue] = None, ) -> None: ... def HasField(self, field_name: typing_extensions___Literal[u"source_context",b"source_context"]) -> builtin___bool: ... def ClearField(self, field_name: typing_extensions___Literal[u"methods",b"methods",u"mixins",b"mixins",u"name",b"name",u"options",b"options",u"source_context",b"source_context",u"syntax",b"syntax",u"version",b"version"]) -> None: ... type___Api = Api class Method(google___protobuf___message___Message): DESCRIPTOR: google___protobuf___descriptor___Descriptor = ... name: typing___Text = ... request_type_url: typing___Text = ... request_streaming: builtin___bool = ... response_type_url: typing___Text = ... response_streaming: builtin___bool = ... syntax: google___protobuf___type_pb2___SyntaxValue = ... @property def options(self) -> google___protobuf___internal___containers___RepeatedCompositeFieldContainer[google___protobuf___type_pb2___Option]: ... def __init__(self, *, name : typing___Optional[typing___Text] = None, request_type_url : typing___Optional[typing___Text] = None, request_streaming : typing___Optional[builtin___bool] = None, response_type_url : typing___Optional[typing___Text] = None, response_streaming : typing___Optional[builtin___bool] = None, options : typing___Optional[typing___Iterable[google___protobuf___type_pb2___Option]] = None, syntax : typing___Optional[google___protobuf___type_pb2___SyntaxValue] = None, ) -> None: ... def ClearField(self, field_name: typing_extensions___Literal[u"name",b"name",u"options",b"options",u"request_streaming",b"request_streaming",u"request_type_url",b"request_type_url",u"response_streaming",b"response_streaming",u"response_type_url",b"response_type_url",u"syntax",b"syntax"]) -> None: ... type___Method = Method class Mixin(google___protobuf___message___Message): DESCRIPTOR: google___protobuf___descriptor___Descriptor = ... name: typing___Text = ... root: typing___Text = ... def __init__(self, *, name : typing___Optional[typing___Text] = None, root : typing___Optional[typing___Text] = None, ) -> None: ... def ClearField(self, field_name: typing_extensions___Literal[u"name",b"name",u"root",b"root"]) -> None: ... type___Mixin = Mixin ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4463794 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/google/protobuf/compiler/0000775000175000017500000000000000000000000027657 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/google/protobuf/compiler/__init__.pyi0000664000175000017500000000000000000000000032127 0ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/google/protobuf/compiler/plugin_pb2.pyi0000664000175000017500000001462400000000000032452 0ustar00davedave00000000000000""" @generated by mypy-protobuf. Do not edit manually! isort:skip_file """ from google.protobuf.descriptor import ( Descriptor as google___protobuf___descriptor___Descriptor, EnumDescriptor as google___protobuf___descriptor___EnumDescriptor, FileDescriptor as google___protobuf___descriptor___FileDescriptor, ) from google.protobuf.descriptor_pb2 import ( FileDescriptorProto as google___protobuf___descriptor_pb2___FileDescriptorProto, GeneratedCodeInfo as google___protobuf___descriptor_pb2___GeneratedCodeInfo, ) from google.protobuf.internal.containers import ( RepeatedCompositeFieldContainer as google___protobuf___internal___containers___RepeatedCompositeFieldContainer, RepeatedScalarFieldContainer as google___protobuf___internal___containers___RepeatedScalarFieldContainer, ) from google.protobuf.internal.enum_type_wrapper import ( _EnumTypeWrapper as google___protobuf___internal___enum_type_wrapper____EnumTypeWrapper, ) from google.protobuf.message import ( Message as google___protobuf___message___Message, ) from typing import ( Iterable as typing___Iterable, NewType as typing___NewType, Optional as typing___Optional, Text as typing___Text, cast as typing___cast, ) from typing_extensions import ( Literal as typing_extensions___Literal, ) builtin___bool = bool builtin___bytes = bytes builtin___float = float builtin___int = int DESCRIPTOR: google___protobuf___descriptor___FileDescriptor = ... class Version(google___protobuf___message___Message): DESCRIPTOR: google___protobuf___descriptor___Descriptor = ... major: builtin___int = ... minor: builtin___int = ... patch: builtin___int = ... suffix: typing___Text = ... def __init__(self, *, major : typing___Optional[builtin___int] = None, minor : typing___Optional[builtin___int] = None, patch : typing___Optional[builtin___int] = None, suffix : typing___Optional[typing___Text] = None, ) -> None: ... def HasField(self, field_name: typing_extensions___Literal[u"major",b"major",u"minor",b"minor",u"patch",b"patch",u"suffix",b"suffix"]) -> builtin___bool: ... def ClearField(self, field_name: typing_extensions___Literal[u"major",b"major",u"minor",b"minor",u"patch",b"patch",u"suffix",b"suffix"]) -> None: ... type___Version = Version class CodeGeneratorRequest(google___protobuf___message___Message): DESCRIPTOR: google___protobuf___descriptor___Descriptor = ... file_to_generate: google___protobuf___internal___containers___RepeatedScalarFieldContainer[typing___Text] = ... parameter: typing___Text = ... @property def proto_file(self) -> google___protobuf___internal___containers___RepeatedCompositeFieldContainer[google___protobuf___descriptor_pb2___FileDescriptorProto]: ... @property def compiler_version(self) -> type___Version: ... def __init__(self, *, file_to_generate : typing___Optional[typing___Iterable[typing___Text]] = None, parameter : typing___Optional[typing___Text] = None, proto_file : typing___Optional[typing___Iterable[google___protobuf___descriptor_pb2___FileDescriptorProto]] = None, compiler_version : typing___Optional[type___Version] = None, ) -> None: ... def HasField(self, field_name: typing_extensions___Literal[u"compiler_version",b"compiler_version",u"parameter",b"parameter"]) -> builtin___bool: ... def ClearField(self, field_name: typing_extensions___Literal[u"compiler_version",b"compiler_version",u"file_to_generate",b"file_to_generate",u"parameter",b"parameter",u"proto_file",b"proto_file"]) -> None: ... type___CodeGeneratorRequest = CodeGeneratorRequest class CodeGeneratorResponse(google___protobuf___message___Message): DESCRIPTOR: google___protobuf___descriptor___Descriptor = ... FeatureValue = typing___NewType('FeatureValue', builtin___int) type___FeatureValue = FeatureValue Feature: _Feature class _Feature(google___protobuf___internal___enum_type_wrapper____EnumTypeWrapper[CodeGeneratorResponse.FeatureValue]): DESCRIPTOR: google___protobuf___descriptor___EnumDescriptor = ... FEATURE_NONE = typing___cast(CodeGeneratorResponse.FeatureValue, 0) FEATURE_PROTO3_OPTIONAL = typing___cast(CodeGeneratorResponse.FeatureValue, 1) FEATURE_NONE = typing___cast(CodeGeneratorResponse.FeatureValue, 0) FEATURE_PROTO3_OPTIONAL = typing___cast(CodeGeneratorResponse.FeatureValue, 1) class File(google___protobuf___message___Message): DESCRIPTOR: google___protobuf___descriptor___Descriptor = ... name: typing___Text = ... insertion_point: typing___Text = ... content: typing___Text = ... @property def generated_code_info(self) -> google___protobuf___descriptor_pb2___GeneratedCodeInfo: ... def __init__(self, *, name : typing___Optional[typing___Text] = None, insertion_point : typing___Optional[typing___Text] = None, content : typing___Optional[typing___Text] = None, generated_code_info : typing___Optional[google___protobuf___descriptor_pb2___GeneratedCodeInfo] = None, ) -> None: ... def HasField(self, field_name: typing_extensions___Literal[u"content",b"content",u"generated_code_info",b"generated_code_info",u"insertion_point",b"insertion_point",u"name",b"name"]) -> builtin___bool: ... def ClearField(self, field_name: typing_extensions___Literal[u"content",b"content",u"generated_code_info",b"generated_code_info",u"insertion_point",b"insertion_point",u"name",b"name"]) -> None: ... type___File = File error: typing___Text = ... supported_features: builtin___int = ... @property def file(self) -> google___protobuf___internal___containers___RepeatedCompositeFieldContainer[type___CodeGeneratorResponse.File]: ... def __init__(self, *, error : typing___Optional[typing___Text] = None, supported_features : typing___Optional[builtin___int] = None, file : typing___Optional[typing___Iterable[type___CodeGeneratorResponse.File]] = None, ) -> None: ... def HasField(self, field_name: typing_extensions___Literal[u"error",b"error",u"supported_features",b"supported_features"]) -> builtin___bool: ... def ClearField(self, field_name: typing_extensions___Literal[u"error",b"error",u"file",b"file",u"supported_features",b"supported_features"]) -> None: ... type___CodeGeneratorResponse = CodeGeneratorResponse ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/google/protobuf/descriptor.pyi0000664000175000017500000001724300000000000030755 0ustar00davedave00000000000000from typing import Any from .descriptor_pb2 import ( EnumOptions, EnumValueOptions, FieldOptions, FileOptions, MessageOptions, MethodOptions, OneofOptions, ServiceOptions, ) from .message import Message class Error(Exception): ... class TypeTransformationError(Error): ... class DescriptorMetaclass(type): def __instancecheck__(self, obj): ... class DescriptorBase(metaclass=DescriptorMetaclass): has_options: Any def __init__(self, options, serialized_options, options_class_name) -> None: ... def GetOptions(self): ... class _NestedDescriptorBase(DescriptorBase): name: Any full_name: Any file: Any containing_type: Any def __init__( self, options, options_class_name, name, full_name, file, containing_type, serialized_start=..., serialized_end=..., serialized_options=..., ) -> None: ... def GetTopLevelContainingType(self): ... def CopyToProto(self, proto): ... class Descriptor(_NestedDescriptorBase): def __new__( cls, name, full_name, filename, containing_type, fields, nested_types, enum_types, extensions, options=..., serialized_options=..., is_extendable=..., extension_ranges=..., oneofs=..., file=..., serialized_start=..., serialized_end=..., syntax=..., ): ... fields: Any fields_by_number: Any fields_by_name: Any nested_types: Any nested_types_by_name: Any enum_types: Any enum_types_by_name: Any enum_values_by_name: Any extensions: Any extensions_by_name: Any is_extendable: Any extension_ranges: Any oneofs: Any oneofs_by_name: Any syntax: Any def __init__( self, name, full_name, filename, containing_type, fields, nested_types, enum_types, extensions, options=..., serialized_options=..., is_extendable=..., extension_ranges=..., oneofs=..., file=..., serialized_start=..., serialized_end=..., syntax=..., ) -> None: ... def EnumValueName(self, enum, value): ... def CopyToProto(self, proto): ... def GetOptions(self) -> MessageOptions: ... class FieldDescriptor(DescriptorBase): TYPE_DOUBLE: Any TYPE_FLOAT: Any TYPE_INT64: Any TYPE_UINT64: Any TYPE_INT32: Any TYPE_FIXED64: Any TYPE_FIXED32: Any TYPE_BOOL: Any TYPE_STRING: Any TYPE_GROUP: Any TYPE_MESSAGE: Any TYPE_BYTES: Any TYPE_UINT32: Any TYPE_ENUM: Any TYPE_SFIXED32: Any TYPE_SFIXED64: Any TYPE_SINT32: Any TYPE_SINT64: Any MAX_TYPE: Any CPPTYPE_INT32: Any CPPTYPE_INT64: Any CPPTYPE_UINT32: Any CPPTYPE_UINT64: Any CPPTYPE_DOUBLE: Any CPPTYPE_FLOAT: Any CPPTYPE_BOOL: Any CPPTYPE_ENUM: Any CPPTYPE_STRING: Any CPPTYPE_MESSAGE: Any MAX_CPPTYPE: Any LABEL_OPTIONAL: Any LABEL_REQUIRED: Any LABEL_REPEATED: Any MAX_LABEL: Any MAX_FIELD_NUMBER: Any FIRST_RESERVED_FIELD_NUMBER: Any LAST_RESERVED_FIELD_NUMBER: Any def __new__( cls, name, full_name, index, number, type, cpp_type, label, default_value, message_type, enum_type, containing_type, is_extension, extension_scope, options=..., serialized_options=..., file=..., has_default_value=..., containing_oneof=..., ): ... name: Any full_name: Any index: Any number: Any type: Any cpp_type: Any label: Any has_default_value: Any default_value: Any containing_type: Any message_type: Any enum_type: Any is_extension: Any extension_scope: Any containing_oneof: Any def __init__( self, name, full_name, index, number, type, cpp_type, label, default_value, message_type, enum_type, containing_type, is_extension, extension_scope, options=..., serialized_options=..., file=..., has_default_value=..., containing_oneof=..., ) -> None: ... @staticmethod def ProtoTypeToCppProtoType(proto_type): ... def GetOptions(self) -> FieldOptions: ... class EnumDescriptor(_NestedDescriptorBase): def __new__( cls, name, full_name, filename, values, containing_type=..., options=..., serialized_options=..., file=..., serialized_start=..., serialized_end=..., ): ... values: Any values_by_name: Any values_by_number: Any def __init__( self, name, full_name, filename, values, containing_type=..., options=..., serialized_options=..., file=..., serialized_start=..., serialized_end=..., ) -> None: ... def CopyToProto(self, proto): ... def GetOptions(self) -> EnumOptions: ... class EnumValueDescriptor(DescriptorBase): def __new__(cls, name, index, number, type=..., options=..., serialized_options=...): ... name: Any index: Any number: Any type: Any def __init__(self, name, index, number, type=..., options=..., serialized_options=...) -> None: ... def GetOptions(self) -> EnumValueOptions: ... class OneofDescriptor: def __new__(cls, name, full_name, index, containing_type, fields): ... name: Any full_name: Any index: Any containing_type: Any fields: Any def __init__(self, name, full_name, index, containing_type, fields) -> None: ... def GetOptions(self) -> OneofOptions: ... class ServiceDescriptor(_NestedDescriptorBase): index: Any methods: Any methods_by_name: Any def __init__( self, name, full_name, index, methods, options=..., serialized_options=..., file=..., serialized_start=..., serialized_end=..., ) -> None: ... def FindMethodByName(self, name): ... def CopyToProto(self, proto): ... def GetOptions(self) -> ServiceOptions: ... class MethodDescriptor(DescriptorBase): name: Any full_name: Any index: Any containing_service: Any input_type: Any output_type: Any def __init__( self, name, full_name, index, containing_service, input_type, output_type, options=..., serialized_options=... ) -> None: ... def GetOptions(self) -> MethodOptions: ... class FileDescriptor(DescriptorBase): def __new__( cls, name, package, options=..., serialized_options=..., serialized_pb=..., dependencies=..., public_dependencies=..., syntax=..., pool=..., ): ... _options: Any pool: Any message_types_by_name: Any name: Any package: Any syntax: Any serialized_pb: Any enum_types_by_name: Any extensions_by_name: Any services_by_name: Any dependencies: Any public_dependencies: Any def __init__( self, name, package, options=..., serialized_options=..., serialized_pb=..., dependencies=..., public_dependencies=..., syntax=..., pool=..., ) -> None: ... def CopyToProto(self, proto): ... def GetOptions(self) -> FileOptions: ... def MakeDescriptor(desc_proto, package=..., build_file_if_cpp=..., syntax=...): ... def _ParseOptions(message: Message, string: bytes) -> Message: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/google/protobuf/descriptor_pb2.pyi0000664000175000017500000012421200000000000031513 0ustar00davedave00000000000000""" @generated by mypy-protobuf. Do not edit manually! isort:skip_file """ from google.protobuf.descriptor import ( Descriptor as google___protobuf___descriptor___Descriptor, EnumDescriptor as google___protobuf___descriptor___EnumDescriptor, FileDescriptor as google___protobuf___descriptor___FileDescriptor, ) from google.protobuf.internal.containers import ( RepeatedCompositeFieldContainer as google___protobuf___internal___containers___RepeatedCompositeFieldContainer, RepeatedScalarFieldContainer as google___protobuf___internal___containers___RepeatedScalarFieldContainer, ) from google.protobuf.internal.enum_type_wrapper import ( _EnumTypeWrapper as google___protobuf___internal___enum_type_wrapper____EnumTypeWrapper, ) from google.protobuf.message import ( Message as google___protobuf___message___Message, ) from typing import ( Iterable as typing___Iterable, NewType as typing___NewType, Optional as typing___Optional, Text as typing___Text, cast as typing___cast, ) from typing_extensions import ( Literal as typing_extensions___Literal, ) builtin___bool = bool builtin___bytes = bytes builtin___float = float builtin___int = int DESCRIPTOR: google___protobuf___descriptor___FileDescriptor = ... class FileDescriptorSet(google___protobuf___message___Message): DESCRIPTOR: google___protobuf___descriptor___Descriptor = ... @property def file(self) -> google___protobuf___internal___containers___RepeatedCompositeFieldContainer[type___FileDescriptorProto]: ... def __init__(self, *, file : typing___Optional[typing___Iterable[type___FileDescriptorProto]] = None, ) -> None: ... def ClearField(self, field_name: typing_extensions___Literal[u"file",b"file"]) -> None: ... type___FileDescriptorSet = FileDescriptorSet class FileDescriptorProto(google___protobuf___message___Message): DESCRIPTOR: google___protobuf___descriptor___Descriptor = ... name: typing___Text = ... package: typing___Text = ... dependency: google___protobuf___internal___containers___RepeatedScalarFieldContainer[typing___Text] = ... public_dependency: google___protobuf___internal___containers___RepeatedScalarFieldContainer[builtin___int] = ... weak_dependency: google___protobuf___internal___containers___RepeatedScalarFieldContainer[builtin___int] = ... syntax: typing___Text = ... @property def message_type(self) -> google___protobuf___internal___containers___RepeatedCompositeFieldContainer[type___DescriptorProto]: ... @property def enum_type(self) -> google___protobuf___internal___containers___RepeatedCompositeFieldContainer[type___EnumDescriptorProto]: ... @property def service(self) -> google___protobuf___internal___containers___RepeatedCompositeFieldContainer[type___ServiceDescriptorProto]: ... @property def extension(self) -> google___protobuf___internal___containers___RepeatedCompositeFieldContainer[type___FieldDescriptorProto]: ... @property def options(self) -> type___FileOptions: ... @property def source_code_info(self) -> type___SourceCodeInfo: ... def __init__(self, *, name : typing___Optional[typing___Text] = None, package : typing___Optional[typing___Text] = None, dependency : typing___Optional[typing___Iterable[typing___Text]] = None, public_dependency : typing___Optional[typing___Iterable[builtin___int]] = None, weak_dependency : typing___Optional[typing___Iterable[builtin___int]] = None, message_type : typing___Optional[typing___Iterable[type___DescriptorProto]] = None, enum_type : typing___Optional[typing___Iterable[type___EnumDescriptorProto]] = None, service : typing___Optional[typing___Iterable[type___ServiceDescriptorProto]] = None, extension : typing___Optional[typing___Iterable[type___FieldDescriptorProto]] = None, options : typing___Optional[type___FileOptions] = None, source_code_info : typing___Optional[type___SourceCodeInfo] = None, syntax : typing___Optional[typing___Text] = None, ) -> None: ... def HasField(self, field_name: typing_extensions___Literal[u"name",b"name",u"options",b"options",u"package",b"package",u"source_code_info",b"source_code_info",u"syntax",b"syntax"]) -> builtin___bool: ... def ClearField(self, field_name: typing_extensions___Literal[u"dependency",b"dependency",u"enum_type",b"enum_type",u"extension",b"extension",u"message_type",b"message_type",u"name",b"name",u"options",b"options",u"package",b"package",u"public_dependency",b"public_dependency",u"service",b"service",u"source_code_info",b"source_code_info",u"syntax",b"syntax",u"weak_dependency",b"weak_dependency"]) -> None: ... type___FileDescriptorProto = FileDescriptorProto class DescriptorProto(google___protobuf___message___Message): DESCRIPTOR: google___protobuf___descriptor___Descriptor = ... class ExtensionRange(google___protobuf___message___Message): DESCRIPTOR: google___protobuf___descriptor___Descriptor = ... start: builtin___int = ... end: builtin___int = ... @property def options(self) -> type___ExtensionRangeOptions: ... def __init__(self, *, start : typing___Optional[builtin___int] = None, end : typing___Optional[builtin___int] = None, options : typing___Optional[type___ExtensionRangeOptions] = None, ) -> None: ... def HasField(self, field_name: typing_extensions___Literal[u"end",b"end",u"options",b"options",u"start",b"start"]) -> builtin___bool: ... def ClearField(self, field_name: typing_extensions___Literal[u"end",b"end",u"options",b"options",u"start",b"start"]) -> None: ... type___ExtensionRange = ExtensionRange class ReservedRange(google___protobuf___message___Message): DESCRIPTOR: google___protobuf___descriptor___Descriptor = ... start: builtin___int = ... end: builtin___int = ... def __init__(self, *, start : typing___Optional[builtin___int] = None, end : typing___Optional[builtin___int] = None, ) -> None: ... def HasField(self, field_name: typing_extensions___Literal[u"end",b"end",u"start",b"start"]) -> builtin___bool: ... def ClearField(self, field_name: typing_extensions___Literal[u"end",b"end",u"start",b"start"]) -> None: ... type___ReservedRange = ReservedRange name: typing___Text = ... reserved_name: google___protobuf___internal___containers___RepeatedScalarFieldContainer[typing___Text] = ... @property def field(self) -> google___protobuf___internal___containers___RepeatedCompositeFieldContainer[type___FieldDescriptorProto]: ... @property def extension(self) -> google___protobuf___internal___containers___RepeatedCompositeFieldContainer[type___FieldDescriptorProto]: ... @property def nested_type(self) -> google___protobuf___internal___containers___RepeatedCompositeFieldContainer[type___DescriptorProto]: ... @property def enum_type(self) -> google___protobuf___internal___containers___RepeatedCompositeFieldContainer[type___EnumDescriptorProto]: ... @property def extension_range(self) -> google___protobuf___internal___containers___RepeatedCompositeFieldContainer[type___DescriptorProto.ExtensionRange]: ... @property def oneof_decl(self) -> google___protobuf___internal___containers___RepeatedCompositeFieldContainer[type___OneofDescriptorProto]: ... @property def options(self) -> type___MessageOptions: ... @property def reserved_range(self) -> google___protobuf___internal___containers___RepeatedCompositeFieldContainer[type___DescriptorProto.ReservedRange]: ... def __init__(self, *, name : typing___Optional[typing___Text] = None, field : typing___Optional[typing___Iterable[type___FieldDescriptorProto]] = None, extension : typing___Optional[typing___Iterable[type___FieldDescriptorProto]] = None, nested_type : typing___Optional[typing___Iterable[type___DescriptorProto]] = None, enum_type : typing___Optional[typing___Iterable[type___EnumDescriptorProto]] = None, extension_range : typing___Optional[typing___Iterable[type___DescriptorProto.ExtensionRange]] = None, oneof_decl : typing___Optional[typing___Iterable[type___OneofDescriptorProto]] = None, options : typing___Optional[type___MessageOptions] = None, reserved_range : typing___Optional[typing___Iterable[type___DescriptorProto.ReservedRange]] = None, reserved_name : typing___Optional[typing___Iterable[typing___Text]] = None, ) -> None: ... def HasField(self, field_name: typing_extensions___Literal[u"name",b"name",u"options",b"options"]) -> builtin___bool: ... def ClearField(self, field_name: typing_extensions___Literal[u"enum_type",b"enum_type",u"extension",b"extension",u"extension_range",b"extension_range",u"field",b"field",u"name",b"name",u"nested_type",b"nested_type",u"oneof_decl",b"oneof_decl",u"options",b"options",u"reserved_name",b"reserved_name",u"reserved_range",b"reserved_range"]) -> None: ... type___DescriptorProto = DescriptorProto class ExtensionRangeOptions(google___protobuf___message___Message): DESCRIPTOR: google___protobuf___descriptor___Descriptor = ... @property def uninterpreted_option(self) -> google___protobuf___internal___containers___RepeatedCompositeFieldContainer[type___UninterpretedOption]: ... def __init__(self, *, uninterpreted_option : typing___Optional[typing___Iterable[type___UninterpretedOption]] = None, ) -> None: ... def ClearField(self, field_name: typing_extensions___Literal[u"uninterpreted_option",b"uninterpreted_option"]) -> None: ... type___ExtensionRangeOptions = ExtensionRangeOptions class FieldDescriptorProto(google___protobuf___message___Message): DESCRIPTOR: google___protobuf___descriptor___Descriptor = ... TypeValue = typing___NewType('TypeValue', builtin___int) type___TypeValue = TypeValue Type: _Type class _Type(google___protobuf___internal___enum_type_wrapper____EnumTypeWrapper[FieldDescriptorProto.TypeValue]): DESCRIPTOR: google___protobuf___descriptor___EnumDescriptor = ... TYPE_DOUBLE = typing___cast(FieldDescriptorProto.TypeValue, 1) TYPE_FLOAT = typing___cast(FieldDescriptorProto.TypeValue, 2) TYPE_INT64 = typing___cast(FieldDescriptorProto.TypeValue, 3) TYPE_UINT64 = typing___cast(FieldDescriptorProto.TypeValue, 4) TYPE_INT32 = typing___cast(FieldDescriptorProto.TypeValue, 5) TYPE_FIXED64 = typing___cast(FieldDescriptorProto.TypeValue, 6) TYPE_FIXED32 = typing___cast(FieldDescriptorProto.TypeValue, 7) TYPE_BOOL = typing___cast(FieldDescriptorProto.TypeValue, 8) TYPE_STRING = typing___cast(FieldDescriptorProto.TypeValue, 9) TYPE_GROUP = typing___cast(FieldDescriptorProto.TypeValue, 10) TYPE_MESSAGE = typing___cast(FieldDescriptorProto.TypeValue, 11) TYPE_BYTES = typing___cast(FieldDescriptorProto.TypeValue, 12) TYPE_UINT32 = typing___cast(FieldDescriptorProto.TypeValue, 13) TYPE_ENUM = typing___cast(FieldDescriptorProto.TypeValue, 14) TYPE_SFIXED32 = typing___cast(FieldDescriptorProto.TypeValue, 15) TYPE_SFIXED64 = typing___cast(FieldDescriptorProto.TypeValue, 16) TYPE_SINT32 = typing___cast(FieldDescriptorProto.TypeValue, 17) TYPE_SINT64 = typing___cast(FieldDescriptorProto.TypeValue, 18) TYPE_DOUBLE = typing___cast(FieldDescriptorProto.TypeValue, 1) TYPE_FLOAT = typing___cast(FieldDescriptorProto.TypeValue, 2) TYPE_INT64 = typing___cast(FieldDescriptorProto.TypeValue, 3) TYPE_UINT64 = typing___cast(FieldDescriptorProto.TypeValue, 4) TYPE_INT32 = typing___cast(FieldDescriptorProto.TypeValue, 5) TYPE_FIXED64 = typing___cast(FieldDescriptorProto.TypeValue, 6) TYPE_FIXED32 = typing___cast(FieldDescriptorProto.TypeValue, 7) TYPE_BOOL = typing___cast(FieldDescriptorProto.TypeValue, 8) TYPE_STRING = typing___cast(FieldDescriptorProto.TypeValue, 9) TYPE_GROUP = typing___cast(FieldDescriptorProto.TypeValue, 10) TYPE_MESSAGE = typing___cast(FieldDescriptorProto.TypeValue, 11) TYPE_BYTES = typing___cast(FieldDescriptorProto.TypeValue, 12) TYPE_UINT32 = typing___cast(FieldDescriptorProto.TypeValue, 13) TYPE_ENUM = typing___cast(FieldDescriptorProto.TypeValue, 14) TYPE_SFIXED32 = typing___cast(FieldDescriptorProto.TypeValue, 15) TYPE_SFIXED64 = typing___cast(FieldDescriptorProto.TypeValue, 16) TYPE_SINT32 = typing___cast(FieldDescriptorProto.TypeValue, 17) TYPE_SINT64 = typing___cast(FieldDescriptorProto.TypeValue, 18) LabelValue = typing___NewType('LabelValue', builtin___int) type___LabelValue = LabelValue Label: _Label class _Label(google___protobuf___internal___enum_type_wrapper____EnumTypeWrapper[FieldDescriptorProto.LabelValue]): DESCRIPTOR: google___protobuf___descriptor___EnumDescriptor = ... LABEL_OPTIONAL = typing___cast(FieldDescriptorProto.LabelValue, 1) LABEL_REQUIRED = typing___cast(FieldDescriptorProto.LabelValue, 2) LABEL_REPEATED = typing___cast(FieldDescriptorProto.LabelValue, 3) LABEL_OPTIONAL = typing___cast(FieldDescriptorProto.LabelValue, 1) LABEL_REQUIRED = typing___cast(FieldDescriptorProto.LabelValue, 2) LABEL_REPEATED = typing___cast(FieldDescriptorProto.LabelValue, 3) name: typing___Text = ... number: builtin___int = ... label: type___FieldDescriptorProto.LabelValue = ... type: type___FieldDescriptorProto.TypeValue = ... type_name: typing___Text = ... extendee: typing___Text = ... default_value: typing___Text = ... oneof_index: builtin___int = ... json_name: typing___Text = ... proto3_optional: builtin___bool = ... @property def options(self) -> type___FieldOptions: ... def __init__(self, *, name : typing___Optional[typing___Text] = None, number : typing___Optional[builtin___int] = None, label : typing___Optional[type___FieldDescriptorProto.LabelValue] = None, type : typing___Optional[type___FieldDescriptorProto.TypeValue] = None, type_name : typing___Optional[typing___Text] = None, extendee : typing___Optional[typing___Text] = None, default_value : typing___Optional[typing___Text] = None, oneof_index : typing___Optional[builtin___int] = None, json_name : typing___Optional[typing___Text] = None, options : typing___Optional[type___FieldOptions] = None, proto3_optional : typing___Optional[builtin___bool] = None, ) -> None: ... def HasField(self, field_name: typing_extensions___Literal[u"default_value",b"default_value",u"extendee",b"extendee",u"json_name",b"json_name",u"label",b"label",u"name",b"name",u"number",b"number",u"oneof_index",b"oneof_index",u"options",b"options",u"proto3_optional",b"proto3_optional",u"type",b"type",u"type_name",b"type_name"]) -> builtin___bool: ... def ClearField(self, field_name: typing_extensions___Literal[u"default_value",b"default_value",u"extendee",b"extendee",u"json_name",b"json_name",u"label",b"label",u"name",b"name",u"number",b"number",u"oneof_index",b"oneof_index",u"options",b"options",u"proto3_optional",b"proto3_optional",u"type",b"type",u"type_name",b"type_name"]) -> None: ... type___FieldDescriptorProto = FieldDescriptorProto class OneofDescriptorProto(google___protobuf___message___Message): DESCRIPTOR: google___protobuf___descriptor___Descriptor = ... name: typing___Text = ... @property def options(self) -> type___OneofOptions: ... def __init__(self, *, name : typing___Optional[typing___Text] = None, options : typing___Optional[type___OneofOptions] = None, ) -> None: ... def HasField(self, field_name: typing_extensions___Literal[u"name",b"name",u"options",b"options"]) -> builtin___bool: ... def ClearField(self, field_name: typing_extensions___Literal[u"name",b"name",u"options",b"options"]) -> None: ... type___OneofDescriptorProto = OneofDescriptorProto class EnumDescriptorProto(google___protobuf___message___Message): DESCRIPTOR: google___protobuf___descriptor___Descriptor = ... class EnumReservedRange(google___protobuf___message___Message): DESCRIPTOR: google___protobuf___descriptor___Descriptor = ... start: builtin___int = ... end: builtin___int = ... def __init__(self, *, start : typing___Optional[builtin___int] = None, end : typing___Optional[builtin___int] = None, ) -> None: ... def HasField(self, field_name: typing_extensions___Literal[u"end",b"end",u"start",b"start"]) -> builtin___bool: ... def ClearField(self, field_name: typing_extensions___Literal[u"end",b"end",u"start",b"start"]) -> None: ... type___EnumReservedRange = EnumReservedRange name: typing___Text = ... reserved_name: google___protobuf___internal___containers___RepeatedScalarFieldContainer[typing___Text] = ... @property def value(self) -> google___protobuf___internal___containers___RepeatedCompositeFieldContainer[type___EnumValueDescriptorProto]: ... @property def options(self) -> type___EnumOptions: ... @property def reserved_range(self) -> google___protobuf___internal___containers___RepeatedCompositeFieldContainer[type___EnumDescriptorProto.EnumReservedRange]: ... def __init__(self, *, name : typing___Optional[typing___Text] = None, value : typing___Optional[typing___Iterable[type___EnumValueDescriptorProto]] = None, options : typing___Optional[type___EnumOptions] = None, reserved_range : typing___Optional[typing___Iterable[type___EnumDescriptorProto.EnumReservedRange]] = None, reserved_name : typing___Optional[typing___Iterable[typing___Text]] = None, ) -> None: ... def HasField(self, field_name: typing_extensions___Literal[u"name",b"name",u"options",b"options"]) -> builtin___bool: ... def ClearField(self, field_name: typing_extensions___Literal[u"name",b"name",u"options",b"options",u"reserved_name",b"reserved_name",u"reserved_range",b"reserved_range",u"value",b"value"]) -> None: ... type___EnumDescriptorProto = EnumDescriptorProto class EnumValueDescriptorProto(google___protobuf___message___Message): DESCRIPTOR: google___protobuf___descriptor___Descriptor = ... name: typing___Text = ... number: builtin___int = ... @property def options(self) -> type___EnumValueOptions: ... def __init__(self, *, name : typing___Optional[typing___Text] = None, number : typing___Optional[builtin___int] = None, options : typing___Optional[type___EnumValueOptions] = None, ) -> None: ... def HasField(self, field_name: typing_extensions___Literal[u"name",b"name",u"number",b"number",u"options",b"options"]) -> builtin___bool: ... def ClearField(self, field_name: typing_extensions___Literal[u"name",b"name",u"number",b"number",u"options",b"options"]) -> None: ... type___EnumValueDescriptorProto = EnumValueDescriptorProto class ServiceDescriptorProto(google___protobuf___message___Message): DESCRIPTOR: google___protobuf___descriptor___Descriptor = ... name: typing___Text = ... @property def method(self) -> google___protobuf___internal___containers___RepeatedCompositeFieldContainer[type___MethodDescriptorProto]: ... @property def options(self) -> type___ServiceOptions: ... def __init__(self, *, name : typing___Optional[typing___Text] = None, method : typing___Optional[typing___Iterable[type___MethodDescriptorProto]] = None, options : typing___Optional[type___ServiceOptions] = None, ) -> None: ... def HasField(self, field_name: typing_extensions___Literal[u"name",b"name",u"options",b"options"]) -> builtin___bool: ... def ClearField(self, field_name: typing_extensions___Literal[u"method",b"method",u"name",b"name",u"options",b"options"]) -> None: ... type___ServiceDescriptorProto = ServiceDescriptorProto class MethodDescriptorProto(google___protobuf___message___Message): DESCRIPTOR: google___protobuf___descriptor___Descriptor = ... name: typing___Text = ... input_type: typing___Text = ... output_type: typing___Text = ... client_streaming: builtin___bool = ... server_streaming: builtin___bool = ... @property def options(self) -> type___MethodOptions: ... def __init__(self, *, name : typing___Optional[typing___Text] = None, input_type : typing___Optional[typing___Text] = None, output_type : typing___Optional[typing___Text] = None, options : typing___Optional[type___MethodOptions] = None, client_streaming : typing___Optional[builtin___bool] = None, server_streaming : typing___Optional[builtin___bool] = None, ) -> None: ... def HasField(self, field_name: typing_extensions___Literal[u"client_streaming",b"client_streaming",u"input_type",b"input_type",u"name",b"name",u"options",b"options",u"output_type",b"output_type",u"server_streaming",b"server_streaming"]) -> builtin___bool: ... def ClearField(self, field_name: typing_extensions___Literal[u"client_streaming",b"client_streaming",u"input_type",b"input_type",u"name",b"name",u"options",b"options",u"output_type",b"output_type",u"server_streaming",b"server_streaming"]) -> None: ... type___MethodDescriptorProto = MethodDescriptorProto class FileOptions(google___protobuf___message___Message): DESCRIPTOR: google___protobuf___descriptor___Descriptor = ... OptimizeModeValue = typing___NewType('OptimizeModeValue', builtin___int) type___OptimizeModeValue = OptimizeModeValue OptimizeMode: _OptimizeMode class _OptimizeMode(google___protobuf___internal___enum_type_wrapper____EnumTypeWrapper[FileOptions.OptimizeModeValue]): DESCRIPTOR: google___protobuf___descriptor___EnumDescriptor = ... SPEED = typing___cast(FileOptions.OptimizeModeValue, 1) CODE_SIZE = typing___cast(FileOptions.OptimizeModeValue, 2) LITE_RUNTIME = typing___cast(FileOptions.OptimizeModeValue, 3) SPEED = typing___cast(FileOptions.OptimizeModeValue, 1) CODE_SIZE = typing___cast(FileOptions.OptimizeModeValue, 2) LITE_RUNTIME = typing___cast(FileOptions.OptimizeModeValue, 3) java_package: typing___Text = ... java_outer_classname: typing___Text = ... java_multiple_files: builtin___bool = ... java_generate_equals_and_hash: builtin___bool = ... java_string_check_utf8: builtin___bool = ... optimize_for: type___FileOptions.OptimizeModeValue = ... go_package: typing___Text = ... cc_generic_services: builtin___bool = ... java_generic_services: builtin___bool = ... py_generic_services: builtin___bool = ... php_generic_services: builtin___bool = ... deprecated: builtin___bool = ... cc_enable_arenas: builtin___bool = ... objc_class_prefix: typing___Text = ... csharp_namespace: typing___Text = ... swift_prefix: typing___Text = ... php_class_prefix: typing___Text = ... php_namespace: typing___Text = ... php_metadata_namespace: typing___Text = ... ruby_package: typing___Text = ... @property def uninterpreted_option(self) -> google___protobuf___internal___containers___RepeatedCompositeFieldContainer[type___UninterpretedOption]: ... def __init__(self, *, java_package : typing___Optional[typing___Text] = None, java_outer_classname : typing___Optional[typing___Text] = None, java_multiple_files : typing___Optional[builtin___bool] = None, java_generate_equals_and_hash : typing___Optional[builtin___bool] = None, java_string_check_utf8 : typing___Optional[builtin___bool] = None, optimize_for : typing___Optional[type___FileOptions.OptimizeModeValue] = None, go_package : typing___Optional[typing___Text] = None, cc_generic_services : typing___Optional[builtin___bool] = None, java_generic_services : typing___Optional[builtin___bool] = None, py_generic_services : typing___Optional[builtin___bool] = None, php_generic_services : typing___Optional[builtin___bool] = None, deprecated : typing___Optional[builtin___bool] = None, cc_enable_arenas : typing___Optional[builtin___bool] = None, objc_class_prefix : typing___Optional[typing___Text] = None, csharp_namespace : typing___Optional[typing___Text] = None, swift_prefix : typing___Optional[typing___Text] = None, php_class_prefix : typing___Optional[typing___Text] = None, php_namespace : typing___Optional[typing___Text] = None, php_metadata_namespace : typing___Optional[typing___Text] = None, ruby_package : typing___Optional[typing___Text] = None, uninterpreted_option : typing___Optional[typing___Iterable[type___UninterpretedOption]] = None, ) -> None: ... def HasField(self, field_name: typing_extensions___Literal[u"cc_enable_arenas",b"cc_enable_arenas",u"cc_generic_services",b"cc_generic_services",u"csharp_namespace",b"csharp_namespace",u"deprecated",b"deprecated",u"go_package",b"go_package",u"java_generate_equals_and_hash",b"java_generate_equals_and_hash",u"java_generic_services",b"java_generic_services",u"java_multiple_files",b"java_multiple_files",u"java_outer_classname",b"java_outer_classname",u"java_package",b"java_package",u"java_string_check_utf8",b"java_string_check_utf8",u"objc_class_prefix",b"objc_class_prefix",u"optimize_for",b"optimize_for",u"php_class_prefix",b"php_class_prefix",u"php_generic_services",b"php_generic_services",u"php_metadata_namespace",b"php_metadata_namespace",u"php_namespace",b"php_namespace",u"py_generic_services",b"py_generic_services",u"ruby_package",b"ruby_package",u"swift_prefix",b"swift_prefix"]) -> builtin___bool: ... def ClearField(self, field_name: typing_extensions___Literal[u"cc_enable_arenas",b"cc_enable_arenas",u"cc_generic_services",b"cc_generic_services",u"csharp_namespace",b"csharp_namespace",u"deprecated",b"deprecated",u"go_package",b"go_package",u"java_generate_equals_and_hash",b"java_generate_equals_and_hash",u"java_generic_services",b"java_generic_services",u"java_multiple_files",b"java_multiple_files",u"java_outer_classname",b"java_outer_classname",u"java_package",b"java_package",u"java_string_check_utf8",b"java_string_check_utf8",u"objc_class_prefix",b"objc_class_prefix",u"optimize_for",b"optimize_for",u"php_class_prefix",b"php_class_prefix",u"php_generic_services",b"php_generic_services",u"php_metadata_namespace",b"php_metadata_namespace",u"php_namespace",b"php_namespace",u"py_generic_services",b"py_generic_services",u"ruby_package",b"ruby_package",u"swift_prefix",b"swift_prefix",u"uninterpreted_option",b"uninterpreted_option"]) -> None: ... type___FileOptions = FileOptions class MessageOptions(google___protobuf___message___Message): DESCRIPTOR: google___protobuf___descriptor___Descriptor = ... message_set_wire_format: builtin___bool = ... no_standard_descriptor_accessor: builtin___bool = ... deprecated: builtin___bool = ... map_entry: builtin___bool = ... @property def uninterpreted_option(self) -> google___protobuf___internal___containers___RepeatedCompositeFieldContainer[type___UninterpretedOption]: ... def __init__(self, *, message_set_wire_format : typing___Optional[builtin___bool] = None, no_standard_descriptor_accessor : typing___Optional[builtin___bool] = None, deprecated : typing___Optional[builtin___bool] = None, map_entry : typing___Optional[builtin___bool] = None, uninterpreted_option : typing___Optional[typing___Iterable[type___UninterpretedOption]] = None, ) -> None: ... def HasField(self, field_name: typing_extensions___Literal[u"deprecated",b"deprecated",u"map_entry",b"map_entry",u"message_set_wire_format",b"message_set_wire_format",u"no_standard_descriptor_accessor",b"no_standard_descriptor_accessor"]) -> builtin___bool: ... def ClearField(self, field_name: typing_extensions___Literal[u"deprecated",b"deprecated",u"map_entry",b"map_entry",u"message_set_wire_format",b"message_set_wire_format",u"no_standard_descriptor_accessor",b"no_standard_descriptor_accessor",u"uninterpreted_option",b"uninterpreted_option"]) -> None: ... type___MessageOptions = MessageOptions class FieldOptions(google___protobuf___message___Message): DESCRIPTOR: google___protobuf___descriptor___Descriptor = ... CTypeValue = typing___NewType('CTypeValue', builtin___int) type___CTypeValue = CTypeValue CType: _CType class _CType(google___protobuf___internal___enum_type_wrapper____EnumTypeWrapper[FieldOptions.CTypeValue]): DESCRIPTOR: google___protobuf___descriptor___EnumDescriptor = ... STRING = typing___cast(FieldOptions.CTypeValue, 0) CORD = typing___cast(FieldOptions.CTypeValue, 1) STRING_PIECE = typing___cast(FieldOptions.CTypeValue, 2) STRING = typing___cast(FieldOptions.CTypeValue, 0) CORD = typing___cast(FieldOptions.CTypeValue, 1) STRING_PIECE = typing___cast(FieldOptions.CTypeValue, 2) JSTypeValue = typing___NewType('JSTypeValue', builtin___int) type___JSTypeValue = JSTypeValue JSType: _JSType class _JSType(google___protobuf___internal___enum_type_wrapper____EnumTypeWrapper[FieldOptions.JSTypeValue]): DESCRIPTOR: google___protobuf___descriptor___EnumDescriptor = ... JS_NORMAL = typing___cast(FieldOptions.JSTypeValue, 0) JS_STRING = typing___cast(FieldOptions.JSTypeValue, 1) JS_NUMBER = typing___cast(FieldOptions.JSTypeValue, 2) JS_NORMAL = typing___cast(FieldOptions.JSTypeValue, 0) JS_STRING = typing___cast(FieldOptions.JSTypeValue, 1) JS_NUMBER = typing___cast(FieldOptions.JSTypeValue, 2) ctype: type___FieldOptions.CTypeValue = ... packed: builtin___bool = ... jstype: type___FieldOptions.JSTypeValue = ... lazy: builtin___bool = ... deprecated: builtin___bool = ... weak: builtin___bool = ... @property def uninterpreted_option(self) -> google___protobuf___internal___containers___RepeatedCompositeFieldContainer[type___UninterpretedOption]: ... def __init__(self, *, ctype : typing___Optional[type___FieldOptions.CTypeValue] = None, packed : typing___Optional[builtin___bool] = None, jstype : typing___Optional[type___FieldOptions.JSTypeValue] = None, lazy : typing___Optional[builtin___bool] = None, deprecated : typing___Optional[builtin___bool] = None, weak : typing___Optional[builtin___bool] = None, uninterpreted_option : typing___Optional[typing___Iterable[type___UninterpretedOption]] = None, ) -> None: ... def HasField(self, field_name: typing_extensions___Literal[u"ctype",b"ctype",u"deprecated",b"deprecated",u"jstype",b"jstype",u"lazy",b"lazy",u"packed",b"packed",u"weak",b"weak"]) -> builtin___bool: ... def ClearField(self, field_name: typing_extensions___Literal[u"ctype",b"ctype",u"deprecated",b"deprecated",u"jstype",b"jstype",u"lazy",b"lazy",u"packed",b"packed",u"uninterpreted_option",b"uninterpreted_option",u"weak",b"weak"]) -> None: ... type___FieldOptions = FieldOptions class OneofOptions(google___protobuf___message___Message): DESCRIPTOR: google___protobuf___descriptor___Descriptor = ... @property def uninterpreted_option(self) -> google___protobuf___internal___containers___RepeatedCompositeFieldContainer[type___UninterpretedOption]: ... def __init__(self, *, uninterpreted_option : typing___Optional[typing___Iterable[type___UninterpretedOption]] = None, ) -> None: ... def ClearField(self, field_name: typing_extensions___Literal[u"uninterpreted_option",b"uninterpreted_option"]) -> None: ... type___OneofOptions = OneofOptions class EnumOptions(google___protobuf___message___Message): DESCRIPTOR: google___protobuf___descriptor___Descriptor = ... allow_alias: builtin___bool = ... deprecated: builtin___bool = ... @property def uninterpreted_option(self) -> google___protobuf___internal___containers___RepeatedCompositeFieldContainer[type___UninterpretedOption]: ... def __init__(self, *, allow_alias : typing___Optional[builtin___bool] = None, deprecated : typing___Optional[builtin___bool] = None, uninterpreted_option : typing___Optional[typing___Iterable[type___UninterpretedOption]] = None, ) -> None: ... def HasField(self, field_name: typing_extensions___Literal[u"allow_alias",b"allow_alias",u"deprecated",b"deprecated"]) -> builtin___bool: ... def ClearField(self, field_name: typing_extensions___Literal[u"allow_alias",b"allow_alias",u"deprecated",b"deprecated",u"uninterpreted_option",b"uninterpreted_option"]) -> None: ... type___EnumOptions = EnumOptions class EnumValueOptions(google___protobuf___message___Message): DESCRIPTOR: google___protobuf___descriptor___Descriptor = ... deprecated: builtin___bool = ... @property def uninterpreted_option(self) -> google___protobuf___internal___containers___RepeatedCompositeFieldContainer[type___UninterpretedOption]: ... def __init__(self, *, deprecated : typing___Optional[builtin___bool] = None, uninterpreted_option : typing___Optional[typing___Iterable[type___UninterpretedOption]] = None, ) -> None: ... def HasField(self, field_name: typing_extensions___Literal[u"deprecated",b"deprecated"]) -> builtin___bool: ... def ClearField(self, field_name: typing_extensions___Literal[u"deprecated",b"deprecated",u"uninterpreted_option",b"uninterpreted_option"]) -> None: ... type___EnumValueOptions = EnumValueOptions class ServiceOptions(google___protobuf___message___Message): DESCRIPTOR: google___protobuf___descriptor___Descriptor = ... deprecated: builtin___bool = ... @property def uninterpreted_option(self) -> google___protobuf___internal___containers___RepeatedCompositeFieldContainer[type___UninterpretedOption]: ... def __init__(self, *, deprecated : typing___Optional[builtin___bool] = None, uninterpreted_option : typing___Optional[typing___Iterable[type___UninterpretedOption]] = None, ) -> None: ... def HasField(self, field_name: typing_extensions___Literal[u"deprecated",b"deprecated"]) -> builtin___bool: ... def ClearField(self, field_name: typing_extensions___Literal[u"deprecated",b"deprecated",u"uninterpreted_option",b"uninterpreted_option"]) -> None: ... type___ServiceOptions = ServiceOptions class MethodOptions(google___protobuf___message___Message): DESCRIPTOR: google___protobuf___descriptor___Descriptor = ... IdempotencyLevelValue = typing___NewType('IdempotencyLevelValue', builtin___int) type___IdempotencyLevelValue = IdempotencyLevelValue IdempotencyLevel: _IdempotencyLevel class _IdempotencyLevel(google___protobuf___internal___enum_type_wrapper____EnumTypeWrapper[MethodOptions.IdempotencyLevelValue]): DESCRIPTOR: google___protobuf___descriptor___EnumDescriptor = ... IDEMPOTENCY_UNKNOWN = typing___cast(MethodOptions.IdempotencyLevelValue, 0) NO_SIDE_EFFECTS = typing___cast(MethodOptions.IdempotencyLevelValue, 1) IDEMPOTENT = typing___cast(MethodOptions.IdempotencyLevelValue, 2) IDEMPOTENCY_UNKNOWN = typing___cast(MethodOptions.IdempotencyLevelValue, 0) NO_SIDE_EFFECTS = typing___cast(MethodOptions.IdempotencyLevelValue, 1) IDEMPOTENT = typing___cast(MethodOptions.IdempotencyLevelValue, 2) deprecated: builtin___bool = ... idempotency_level: type___MethodOptions.IdempotencyLevelValue = ... @property def uninterpreted_option(self) -> google___protobuf___internal___containers___RepeatedCompositeFieldContainer[type___UninterpretedOption]: ... def __init__(self, *, deprecated : typing___Optional[builtin___bool] = None, idempotency_level : typing___Optional[type___MethodOptions.IdempotencyLevelValue] = None, uninterpreted_option : typing___Optional[typing___Iterable[type___UninterpretedOption]] = None, ) -> None: ... def HasField(self, field_name: typing_extensions___Literal[u"deprecated",b"deprecated",u"idempotency_level",b"idempotency_level"]) -> builtin___bool: ... def ClearField(self, field_name: typing_extensions___Literal[u"deprecated",b"deprecated",u"idempotency_level",b"idempotency_level",u"uninterpreted_option",b"uninterpreted_option"]) -> None: ... type___MethodOptions = MethodOptions class UninterpretedOption(google___protobuf___message___Message): DESCRIPTOR: google___protobuf___descriptor___Descriptor = ... class NamePart(google___protobuf___message___Message): DESCRIPTOR: google___protobuf___descriptor___Descriptor = ... name_part: typing___Text = ... is_extension: builtin___bool = ... def __init__(self, *, name_part : typing___Optional[typing___Text] = None, is_extension : typing___Optional[builtin___bool] = None, ) -> None: ... def HasField(self, field_name: typing_extensions___Literal[u"is_extension",b"is_extension",u"name_part",b"name_part"]) -> builtin___bool: ... def ClearField(self, field_name: typing_extensions___Literal[u"is_extension",b"is_extension",u"name_part",b"name_part"]) -> None: ... type___NamePart = NamePart identifier_value: typing___Text = ... positive_int_value: builtin___int = ... negative_int_value: builtin___int = ... double_value: builtin___float = ... string_value: builtin___bytes = ... aggregate_value: typing___Text = ... @property def name(self) -> google___protobuf___internal___containers___RepeatedCompositeFieldContainer[type___UninterpretedOption.NamePart]: ... def __init__(self, *, name : typing___Optional[typing___Iterable[type___UninterpretedOption.NamePart]] = None, identifier_value : typing___Optional[typing___Text] = None, positive_int_value : typing___Optional[builtin___int] = None, negative_int_value : typing___Optional[builtin___int] = None, double_value : typing___Optional[builtin___float] = None, string_value : typing___Optional[builtin___bytes] = None, aggregate_value : typing___Optional[typing___Text] = None, ) -> None: ... def HasField(self, field_name: typing_extensions___Literal[u"aggregate_value",b"aggregate_value",u"double_value",b"double_value",u"identifier_value",b"identifier_value",u"negative_int_value",b"negative_int_value",u"positive_int_value",b"positive_int_value",u"string_value",b"string_value"]) -> builtin___bool: ... def ClearField(self, field_name: typing_extensions___Literal[u"aggregate_value",b"aggregate_value",u"double_value",b"double_value",u"identifier_value",b"identifier_value",u"name",b"name",u"negative_int_value",b"negative_int_value",u"positive_int_value",b"positive_int_value",u"string_value",b"string_value"]) -> None: ... type___UninterpretedOption = UninterpretedOption class SourceCodeInfo(google___protobuf___message___Message): DESCRIPTOR: google___protobuf___descriptor___Descriptor = ... class Location(google___protobuf___message___Message): DESCRIPTOR: google___protobuf___descriptor___Descriptor = ... path: google___protobuf___internal___containers___RepeatedScalarFieldContainer[builtin___int] = ... span: google___protobuf___internal___containers___RepeatedScalarFieldContainer[builtin___int] = ... leading_comments: typing___Text = ... trailing_comments: typing___Text = ... leading_detached_comments: google___protobuf___internal___containers___RepeatedScalarFieldContainer[typing___Text] = ... def __init__(self, *, path : typing___Optional[typing___Iterable[builtin___int]] = None, span : typing___Optional[typing___Iterable[builtin___int]] = None, leading_comments : typing___Optional[typing___Text] = None, trailing_comments : typing___Optional[typing___Text] = None, leading_detached_comments : typing___Optional[typing___Iterable[typing___Text]] = None, ) -> None: ... def HasField(self, field_name: typing_extensions___Literal[u"leading_comments",b"leading_comments",u"trailing_comments",b"trailing_comments"]) -> builtin___bool: ... def ClearField(self, field_name: typing_extensions___Literal[u"leading_comments",b"leading_comments",u"leading_detached_comments",b"leading_detached_comments",u"path",b"path",u"span",b"span",u"trailing_comments",b"trailing_comments"]) -> None: ... type___Location = Location @property def location(self) -> google___protobuf___internal___containers___RepeatedCompositeFieldContainer[type___SourceCodeInfo.Location]: ... def __init__(self, *, location : typing___Optional[typing___Iterable[type___SourceCodeInfo.Location]] = None, ) -> None: ... def ClearField(self, field_name: typing_extensions___Literal[u"location",b"location"]) -> None: ... type___SourceCodeInfo = SourceCodeInfo class GeneratedCodeInfo(google___protobuf___message___Message): DESCRIPTOR: google___protobuf___descriptor___Descriptor = ... class Annotation(google___protobuf___message___Message): DESCRIPTOR: google___protobuf___descriptor___Descriptor = ... path: google___protobuf___internal___containers___RepeatedScalarFieldContainer[builtin___int] = ... source_file: typing___Text = ... begin: builtin___int = ... end: builtin___int = ... def __init__(self, *, path : typing___Optional[typing___Iterable[builtin___int]] = None, source_file : typing___Optional[typing___Text] = None, begin : typing___Optional[builtin___int] = None, end : typing___Optional[builtin___int] = None, ) -> None: ... def HasField(self, field_name: typing_extensions___Literal[u"begin",b"begin",u"end",b"end",u"source_file",b"source_file"]) -> builtin___bool: ... def ClearField(self, field_name: typing_extensions___Literal[u"begin",b"begin",u"end",b"end",u"path",b"path",u"source_file",b"source_file"]) -> None: ... type___Annotation = Annotation @property def annotation(self) -> google___protobuf___internal___containers___RepeatedCompositeFieldContainer[type___GeneratedCodeInfo.Annotation]: ... def __init__(self, *, annotation : typing___Optional[typing___Iterable[type___GeneratedCodeInfo.Annotation]] = None, ) -> None: ... def ClearField(self, field_name: typing_extensions___Literal[u"annotation",b"annotation"]) -> None: ... type___GeneratedCodeInfo = GeneratedCodeInfo ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/google/protobuf/descriptor_pool.pyi0000664000175000017500000000135000000000000031776 0ustar00davedave00000000000000from typing import Any, Optional class DescriptorPool: def __new__(cls, descriptor_db: Optional[Any] = ...): ... def __init__(self, descriptor_db: Optional[Any] = ...) -> None: ... def Add(self, file_desc_proto): ... def AddSerializedFile(self, serialized_file_desc_proto): ... def AddDescriptor(self, desc): ... def AddEnumDescriptor(self, enum_desc): ... def AddFileDescriptor(self, file_desc): ... def FindFileByName(self, file_name): ... def FindFileContainingSymbol(self, symbol): ... def FindMessageTypeByName(self, full_name): ... def FindEnumTypeByName(self, full_name): ... def FindFieldByName(self, full_name): ... def FindExtensionByName(self, full_name): ... def Default(): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/google/protobuf/duration_pb2.pyi0000664000175000017500000000250400000000000031161 0ustar00davedave00000000000000""" @generated by mypy-protobuf. Do not edit manually! isort:skip_file """ from google.protobuf.descriptor import ( Descriptor as google___protobuf___descriptor___Descriptor, FileDescriptor as google___protobuf___descriptor___FileDescriptor, ) from google.protobuf.internal.well_known_types import ( Duration as google___protobuf___internal___well_known_types___Duration, ) from google.protobuf.message import ( Message as google___protobuf___message___Message, ) from typing import ( Optional as typing___Optional, ) from typing_extensions import ( Literal as typing_extensions___Literal, ) builtin___bool = bool builtin___bytes = bytes builtin___float = float builtin___int = int DESCRIPTOR: google___protobuf___descriptor___FileDescriptor = ... class Duration(google___protobuf___message___Message, google___protobuf___internal___well_known_types___Duration): DESCRIPTOR: google___protobuf___descriptor___Descriptor = ... seconds: builtin___int = ... nanos: builtin___int = ... def __init__(self, *, seconds : typing___Optional[builtin___int] = None, nanos : typing___Optional[builtin___int] = None, ) -> None: ... def ClearField(self, field_name: typing_extensions___Literal[u"nanos",b"nanos",u"seconds",b"seconds"]) -> None: ... type___Duration = Duration ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/google/protobuf/empty_pb2.pyi0000664000175000017500000000113300000000000030467 0ustar00davedave00000000000000""" @generated by mypy-protobuf. Do not edit manually! isort:skip_file """ from google.protobuf.descriptor import ( Descriptor as google___protobuf___descriptor___Descriptor, FileDescriptor as google___protobuf___descriptor___FileDescriptor, ) from google.protobuf.message import ( Message as google___protobuf___message___Message, ) DESCRIPTOR: google___protobuf___descriptor___FileDescriptor = ... class Empty(google___protobuf___message___Message): DESCRIPTOR: google___protobuf___descriptor___Descriptor = ... def __init__(self, ) -> None: ... type___Empty = Empty ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/google/protobuf/field_mask_pb2.pyi0000664000175000017500000000302600000000000031432 0ustar00davedave00000000000000""" @generated by mypy-protobuf. Do not edit manually! isort:skip_file """ from google.protobuf.descriptor import ( Descriptor as google___protobuf___descriptor___Descriptor, FileDescriptor as google___protobuf___descriptor___FileDescriptor, ) from google.protobuf.internal.containers import ( RepeatedScalarFieldContainer as google___protobuf___internal___containers___RepeatedScalarFieldContainer, ) from google.protobuf.internal.well_known_types import ( FieldMask as google___protobuf___internal___well_known_types___FieldMask, ) from google.protobuf.message import ( Message as google___protobuf___message___Message, ) from typing import ( Iterable as typing___Iterable, Optional as typing___Optional, Text as typing___Text, ) from typing_extensions import ( Literal as typing_extensions___Literal, ) builtin___bool = bool builtin___bytes = bytes builtin___float = float builtin___int = int DESCRIPTOR: google___protobuf___descriptor___FileDescriptor = ... class FieldMask(google___protobuf___message___Message, google___protobuf___internal___well_known_types___FieldMask): DESCRIPTOR: google___protobuf___descriptor___Descriptor = ... paths: google___protobuf___internal___containers___RepeatedScalarFieldContainer[typing___Text] = ... def __init__(self, *, paths : typing___Optional[typing___Iterable[typing___Text]] = None, ) -> None: ... def ClearField(self, field_name: typing_extensions___Literal[u"paths",b"paths"]) -> None: ... type___FieldMask = FieldMask ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4463794 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/google/protobuf/internal/0000775000175000017500000000000000000000000027661 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/google/protobuf/internal/__init__.pyi0000664000175000017500000000000000000000000032131 0ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/google/protobuf/internal/containers.pyi0000664000175000017500000000710500000000000032554 0ustar00davedave00000000000000from typing import ( Any, Callable, Iterable, Iterator, List, Mapping as Mapping, MutableMapping as MutableMapping, Optional, Sequence, TypeVar, Union, overload, ) from google.protobuf.descriptor import Descriptor from google.protobuf.internal.message_listener import MessageListener from google.protobuf.internal.python_message import GeneratedProtocolMessageType _T = TypeVar("_T") _K = TypeVar("_K") _V = TypeVar("_V") _M = TypeVar("_M") class BaseContainer(Sequence[_T]): def __init__(self, message_listener: MessageListener) -> None: ... def __len__(self) -> int: ... def __ne__(self, other: object) -> bool: ... def __hash__(self) -> int: ... def __repr__(self) -> str: ... def sort(self, *, key: Optional[Callable[[_T], Any]] = ..., reverse: bool = ...) -> None: ... @overload def __getitem__(self, key: int) -> _T: ... @overload def __getitem__(self, key: slice) -> List[_T]: ... class RepeatedScalarFieldContainer(BaseContainer[_T]): def __init__(self, message_listener: MessageListener, message_descriptor: Descriptor) -> None: ... def append(self, value: _T) -> None: ... def insert(self, key: int, value: _T) -> None: ... def extend(self, elem_seq: Optional[Iterable[_T]]) -> None: ... def MergeFrom(self: _M, other: _M) -> None: ... def remove(self, elem: _T) -> None: ... def pop(self, key: int = ...) -> _T: ... @overload def __setitem__(self, key: int, value: _T) -> None: ... @overload def __setitem__(self, key: slice, value: Iterable[_T]) -> None: ... def __getslice__(self, start: int, stop: int) -> List[_T]: ... def __setslice__(self, start: int, stop: int, values: Iterable[_T]) -> None: ... def __delitem__(self, key: Union[int, slice]) -> None: ... def __delslice__(self, start: int, stop: int) -> None: ... def __eq__(self, other: object) -> bool: ... class RepeatedCompositeFieldContainer(BaseContainer[_T]): def __init__(self, message_listener: MessageListener, type_checker: Any) -> None: ... def add(self, **kwargs: Any) -> _T: ... def append(self, value: _T) -> None: ... def insert(self, key: int, value: _T) -> None: ... def extend(self, elem_seq: Iterable[_T]) -> None: ... def MergeFrom(self: _M, other: _M) -> None: ... def remove(self, elem: _T) -> None: ... def pop(self, key: int = ...) -> _T: ... def __getslice__(self, start: int, stop: int) -> List[_T]: ... def __delitem__(self, key: Union[int, slice]) -> None: ... def __delslice__(self, start: int, stop: int) -> None: ... def __eq__(self, other: object) -> bool: ... class ScalarMap(MutableMapping[_K, _V]): def __setitem__(self, k: _K, v: _V) -> None: ... def __delitem__(self, v: _K) -> None: ... def __getitem__(self, k: _K) -> _V: ... def __len__(self) -> int: ... def __iter__(self) -> Iterator[_K]: ... def __eq__(self, other: object) -> bool: ... def MergeFrom(self: _M, other: _M): ... def InvalidateIterators(self) -> None: ... def GetEntryClass(self) -> GeneratedProtocolMessageType: ... class MessageMap(MutableMapping[_K, _V]): def __setitem__(self, k: _K, v: _V) -> None: ... def __delitem__(self, v: _K) -> None: ... def __getitem__(self, k: _K) -> _V: ... def __len__(self) -> int: ... def __iter__(self) -> Iterator[_K]: ... def __eq__(self, other: object) -> bool: ... def get_or_create(self, key: _K) -> _V: ... def MergeFrom(self: _M, other: _M): ... def InvalidateIterators(self) -> None: ... def GetEntryClass(self) -> GeneratedProtocolMessageType: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/google/protobuf/internal/decoder.pyi0000664000175000017500000000153400000000000032014 0ustar00davedave00000000000000from typing import Any def ReadTag(buffer, pos): ... def EnumDecoder(field_number, is_repeated, is_packed, key, new_default): ... Int32Decoder: Any Int64Decoder: Any UInt32Decoder: Any UInt64Decoder: Any SInt32Decoder: Any SInt64Decoder: Any Fixed32Decoder: Any Fixed64Decoder: Any SFixed32Decoder: Any SFixed64Decoder: Any FloatDecoder: Any DoubleDecoder: Any BoolDecoder: Any def StringDecoder(field_number, is_repeated, is_packed, key, new_default): ... def BytesDecoder(field_number, is_repeated, is_packed, key, new_default): ... def GroupDecoder(field_number, is_repeated, is_packed, key, new_default): ... def MessageDecoder(field_number, is_repeated, is_packed, key, new_default): ... MESSAGE_SET_ITEM_TAG: Any def MessageSetItemDecoder(extensions_by_number): ... def MapDecoder(field_descriptor, new_default, is_message_map): ... SkipField: Any ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/google/protobuf/internal/encoder.pyi0000664000175000017500000000202500000000000032022 0ustar00davedave00000000000000from typing import Any Int32Sizer: Any UInt32Sizer: Any SInt32Sizer: Any Fixed32Sizer: Any Fixed64Sizer: Any BoolSizer: Any def StringSizer(field_number, is_repeated, is_packed): ... def BytesSizer(field_number, is_repeated, is_packed): ... def GroupSizer(field_number, is_repeated, is_packed): ... def MessageSizer(field_number, is_repeated, is_packed): ... def MessageSetItemSizer(field_number): ... def MapSizer(field_descriptor): ... def TagBytes(field_number, wire_type): ... Int32Encoder: Any UInt32Encoder: Any SInt32Encoder: Any Fixed32Encoder: Any Fixed64Encoder: Any SFixed32Encoder: Any SFixed64Encoder: Any FloatEncoder: Any DoubleEncoder: Any def BoolEncoder(field_number, is_repeated, is_packed): ... def StringEncoder(field_number, is_repeated, is_packed): ... def BytesEncoder(field_number, is_repeated, is_packed): ... def GroupEncoder(field_number, is_repeated, is_packed): ... def MessageEncoder(field_number, is_repeated, is_packed): ... def MessageSetItemEncoder(field_number): ... def MapEncoder(field_descriptor): ... ././@PaxHeader0000000000000000000000000000020600000000000011453 xustar0000000000000000112 path=jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/google/protobuf/internal/enum_type_wrapper.pyi 22 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/google/protobuf/internal/enum_type_wrapper.p0000664000175000017500000000121200000000000033603 0ustar00davedave00000000000000from typing import Generic, List, Tuple, TypeVar from google.protobuf.descriptor import EnumDescriptor _V = TypeVar("_V", bound=int) # Expose a generic version so that those using mypy-protobuf # can get autogenerated NewType wrapper around the int values class _EnumTypeWrapper(Generic[_V]): DESCRIPTOR: EnumDescriptor def __init__(self, enum_type: EnumDescriptor) -> None: ... def Name(self, number: _V) -> str: ... def Value(self, name: str) -> _V: ... def keys(self) -> List[str]: ... def values(self) -> List[_V]: ... def items(self) -> List[Tuple[str, _V]]: ... class EnumTypeWrapper(_EnumTypeWrapper[int]): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/google/protobuf/internal/extension_dict.pyi0000664000175000017500000000340300000000000033423 0ustar00davedave00000000000000from typing import Any, Generic, Iterator, TypeVar, overload from google.protobuf.descriptor import FieldDescriptor from google.protobuf.message import Message _ContainerMessageT = TypeVar("_ContainerMessageT", bound=Message) _ExtenderMessageT = TypeVar("_ExtenderMessageT", bound=Message) class _ExtensionFieldDescriptor(FieldDescriptor, Generic[_ContainerMessageT, _ExtenderMessageT]): ... class _ExtensionDict(Generic[_ContainerMessageT]): def __init__(self, extended_message: _ContainerMessageT) -> None: ... # Dummy fallback overloads with FieldDescriptor are for backward compatibility with # mypy-protobuf <= 1.23. We can drop them a few months after 1.24 releases. @overload def __getitem__( self, extension_handle: _ExtensionFieldDescriptor[_ContainerMessageT, _ExtenderMessageT] ) -> _ExtenderMessageT: ... @overload def __getitem__(self, extension_handle: FieldDescriptor) -> Any: ... @overload def __setitem__( self, extension_handle: _ExtensionFieldDescriptor[_ContainerMessageT, _ExtenderMessageT], value: _ExtenderMessageT ) -> None: ... @overload def __setitem__(self, extension_handle: FieldDescriptor, value: Any) -> None: ... @overload def __delitem__(self, extension_handle: _ExtensionFieldDescriptor[_ContainerMessageT, _ExtenderMessageT]) -> None: ... @overload def __delitem__(self, extension_handle: FieldDescriptor) -> None: ... @overload def __contains__(self, extension_handle: _ExtensionFieldDescriptor[_ContainerMessageT, _ExtenderMessageT]) -> bool: ... @overload def __contains__(self, extension_handle: FieldDescriptor) -> bool: ... def __iter__(self) -> Iterator[_ExtensionFieldDescriptor[_ContainerMessageT, Any]]: ... def __len__(self) -> int: ... ././@PaxHeader0000000000000000000000000000020500000000000011452 xustar0000000000000000111 path=jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/google/protobuf/internal/message_listener.pyi 22 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/google/protobuf/internal/message_listener.py0000664000175000017500000000022400000000000033562 0ustar00davedave00000000000000class MessageListener(object): def Modified(self) -> None: ... class NullMessageListener(MessageListener): def Modified(self) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/google/protobuf/internal/python_message.pyi0000664000175000017500000000005600000000000033432 0ustar00davedave00000000000000class GeneratedProtocolMessageType(type): ... ././@PaxHeader0000000000000000000000000000020500000000000011452 xustar0000000000000000111 path=jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/google/protobuf/internal/well_known_types.pyi 22 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/google/protobuf/internal/well_known_types.py0000664000175000017500000000725400000000000033646 0ustar00davedave00000000000000from datetime import datetime, timedelta from typing import Any as tAny, Dict, Optional, Text, Type class Error(Exception): ... class ParseError(Error): ... class Any: type_url: tAny = ... value: tAny = ... def Pack(self, msg: tAny, type_url_prefix: bytes = ..., deterministic: Optional[tAny] = ...) -> None: ... def Unpack(self, msg: tAny): ... def TypeName(self): ... def Is(self, descriptor: tAny): ... class Timestamp: def ToJsonString(self) -> str: ... seconds: int = ... nanos: int = ... def FromJsonString(self, value: str) -> None: ... def GetCurrentTime(self) -> None: ... def ToNanoseconds(self) -> int: ... def ToMicroseconds(self) -> int: ... def ToMilliseconds(self) -> int: ... def ToSeconds(self) -> int: ... def FromNanoseconds(self, nanos: int) -> None: ... def FromMicroseconds(self, micros: int) -> None: ... def FromMilliseconds(self, millis: int) -> None: ... def FromSeconds(self, seconds: int) -> None: ... def ToDatetime(self) -> datetime: ... def FromDatetime(self, dt: datetime) -> None: ... class Duration: def ToJsonString(self) -> str: ... seconds: int = ... nanos: int = ... def FromJsonString(self, value: tAny) -> None: ... def ToNanoseconds(self) -> int: ... def ToMicroseconds(self) -> int: ... def ToMilliseconds(self) -> int: ... def ToSeconds(self) -> int: ... def FromNanoseconds(self, nanos: int) -> None: ... def FromMicroseconds(self, micros: int) -> None: ... def FromMilliseconds(self, millis: int) -> None: ... def FromSeconds(self, seconds: int) -> None: ... def ToTimedelta(self) -> timedelta: ... def FromTimedelta(self, td: timedelta) -> None: ... class FieldMask: def ToJsonString(self) -> str: ... def FromJsonString(self, value: tAny) -> None: ... def IsValidForDescriptor(self, message_descriptor: tAny): ... def AllFieldsFromDescriptor(self, message_descriptor: tAny) -> None: ... def CanonicalFormFromMask(self, mask: tAny) -> None: ... def Union(self, mask1: tAny, mask2: tAny) -> None: ... def Intersect(self, mask1: tAny, mask2: tAny) -> None: ... def MergeMessage( self, source: tAny, destination: tAny, replace_message_field: bool = ..., replace_repeated_field: bool = ... ) -> None: ... class _FieldMaskTree: def __init__(self, field_mask: Optional[tAny] = ...) -> None: ... def MergeFromFieldMask(self, field_mask: tAny) -> None: ... def AddPath(self, path: tAny): ... def ToFieldMask(self, field_mask: tAny) -> None: ... def IntersectPath(self, path: tAny, intersection: tAny): ... def AddLeafNodes(self, prefix: tAny, node: tAny) -> None: ... def MergeMessage(self, source: tAny, destination: tAny, replace_message: tAny, replace_repeated: tAny) -> None: ... class Struct: def __getitem__(self, key: tAny): ... def __contains__(self, item: tAny): ... def __setitem__(self, key: tAny, value: tAny) -> None: ... def __delitem__(self, key: tAny) -> None: ... def __len__(self): ... def __iter__(self): ... def keys(self): ... def values(self): ... def items(self): ... def get_or_create_list(self, key: tAny): ... def get_or_create_struct(self, key: tAny): ... def update(self, dictionary: tAny) -> None: ... class ListValue: def __len__(self): ... def append(self, value: tAny) -> None: ... def extend(self, elem_seq: tAny) -> None: ... def __getitem__(self, index: tAny): ... def __setitem__(self, index: tAny, value: tAny) -> None: ... def __delitem__(self, key: tAny) -> None: ... def items(self) -> None: ... def add_struct(self): ... def add_list(self): ... WKTBASES: Dict[Text, Type] ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/google/protobuf/internal/wire_format.pyi0000664000175000017500000000302200000000000032717 0ustar00davedave00000000000000from typing import Any TAG_TYPE_BITS: Any TAG_TYPE_MASK: Any WIRETYPE_VARINT: Any WIRETYPE_FIXED64: Any WIRETYPE_LENGTH_DELIMITED: Any WIRETYPE_START_GROUP: Any WIRETYPE_END_GROUP: Any WIRETYPE_FIXED32: Any INT32_MAX: Any INT32_MIN: Any UINT32_MAX: Any INT64_MAX: Any INT64_MIN: Any UINT64_MAX: Any FORMAT_UINT32_LITTLE_ENDIAN: Any FORMAT_UINT64_LITTLE_ENDIAN: Any FORMAT_FLOAT_LITTLE_ENDIAN: Any FORMAT_DOUBLE_LITTLE_ENDIAN: Any def PackTag(field_number, wire_type): ... def UnpackTag(tag): ... def ZigZagEncode(value): ... def ZigZagDecode(value): ... def Int32ByteSize(field_number, int32): ... def Int32ByteSizeNoTag(int32): ... def Int64ByteSize(field_number, int64): ... def UInt32ByteSize(field_number, uint32): ... def UInt64ByteSize(field_number, uint64): ... def SInt32ByteSize(field_number, int32): ... def SInt64ByteSize(field_number, int64): ... def Fixed32ByteSize(field_number, fixed32): ... def Fixed64ByteSize(field_number, fixed64): ... def SFixed32ByteSize(field_number, sfixed32): ... def SFixed64ByteSize(field_number, sfixed64): ... def FloatByteSize(field_number, flt): ... def DoubleByteSize(field_number, double): ... def BoolByteSize(field_number, b): ... def EnumByteSize(field_number, enum): ... def StringByteSize(field_number, string): ... def BytesByteSize(field_number, b): ... def GroupByteSize(field_number, message): ... def MessageByteSize(field_number, message): ... def MessageSetItemByteSize(field_number, msg): ... def TagByteSize(field_number): ... NON_PACKABLE_TYPES: Any def IsTypePackable(field_type): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/google/protobuf/json_format.pyi0000664000175000017500000000160700000000000031115 0ustar00davedave00000000000000from typing import Any, Dict, Text, TypeVar, Union from google.protobuf.message import Message _MessageVar = TypeVar("_MessageVar", bound=Message) class Error(Exception): ... class ParseError(Error): ... class SerializeToJsonError(Error): ... def MessageToJson( message: Message, including_default_value_fields: bool = ..., preserving_proto_field_name: bool = ..., indent: int = ..., sort_keys: bool = ..., use_integers_for_enums: bool = ..., ) -> str: ... def MessageToDict( message: Message, including_default_value_fields: bool = ..., preserving_proto_field_name: bool = ..., use_integers_for_enums: bool = ..., ) -> Dict[Text, Any]: ... def Parse(text: Union[bytes, Text], message: _MessageVar, ignore_unknown_fields: bool = ...) -> _MessageVar: ... def ParseDict(js_dict: Any, message: _MessageVar, ignore_unknown_fields: bool = ...) -> _MessageVar: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/google/protobuf/message.pyi0000664000175000017500000000473200000000000030222 0ustar00davedave00000000000000import sys from typing import Any, ByteString, Sequence, Tuple, Type, TypeVar, Union, overload from .descriptor import Descriptor, FieldDescriptor from .internal.extension_dict import _ExtensionDict, _ExtensionFieldDescriptor class Error(Exception): ... class DecodeError(Error): ... class EncodeError(Error): ... _M = TypeVar("_M", bound=Message) # message type (of self) if sys.version_info < (3,): _Serialized = Union[bytes, buffer, unicode] else: _Serialized = ByteString class Message: DESCRIPTOR: Descriptor def __deepcopy__(self, memo=...): ... def __eq__(self, other_msg): ... def __ne__(self, other_msg): ... def MergeFrom(self: _M, other_msg: _M) -> None: ... def CopyFrom(self: _M, other_msg: _M) -> None: ... def Clear(self) -> None: ... def SetInParent(self) -> None: ... def IsInitialized(self) -> bool: ... def MergeFromString(self, serialized: _Serialized) -> int: ... def ParseFromString(self, serialized: _Serialized) -> int: ... def SerializeToString(self, deterministic: bool = ...) -> bytes: ... def SerializePartialToString(self, deterministic: bool = ...) -> bytes: ... def ListFields(self) -> Sequence[Tuple[FieldDescriptor, Any]]: ... # Dummy fallback overloads with FieldDescriptor are for backward compatibility with # mypy-protobuf <= 1.23. We can drop them a few months after 1.24 releases. @overload def HasExtension(self: _M, extension_handle: _ExtensionFieldDescriptor[_M, Any]) -> bool: ... @overload def HasExtension(self, extension_handle: FieldDescriptor) -> bool: ... @overload def ClearExtension(self: _M, extension_handle: _ExtensionFieldDescriptor[_M, Any]) -> None: ... @overload def ClearExtension(self, extension_handle: FieldDescriptor) -> None: ... def ByteSize(self) -> int: ... @classmethod def FromString(cls: Type[_M], s: _Serialized) -> _M: ... @property def Extensions(self: _M) -> _ExtensionDict[_M]: ... # Intentionally left out typing on these three methods, because they are # stringly typed and it is not useful to call them on a Message directly. # We prefer more specific typing on individual subclasses of Message # See https://github.com/dropbox/mypy-protobuf/issues/62 for details def HasField(self, field_name: Any) -> bool: ... def ClearField(self, field_name: Any) -> None: ... def WhichOneof(self, oneof_group: Any) -> Any: ... # TODO: check kwargs def __init__(self, **kwargs) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/google/protobuf/message_factory.pyi0000664000175000017500000000116700000000000031750 0ustar00davedave00000000000000from typing import Any, Dict, Iterable, Optional, Type from google.protobuf.descriptor import Descriptor from google.protobuf.descriptor_pb2 import FileDescriptorProto from google.protobuf.descriptor_pool import DescriptorPool from google.protobuf.message import Message class MessageFactory: pool: Any def __init__(self, pool: Optional[DescriptorPool] = ...) -> None: ... def GetPrototype(self, descriptor: Descriptor) -> Type[Message]: ... def GetMessages(self, files: Iterable[str]) -> Dict[str, Type[Message]]: ... def GetMessages(file_protos: Iterable[FileDescriptorProto]) -> Dict[str, Type[Message]]: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/google/protobuf/reflection.pyi0000664000175000017500000000034600000000000030725 0ustar00davedave00000000000000class GeneratedProtocolMessageType(type): def __new__(cls, name, bases, dictionary): ... def __init__(self, name, bases, dictionary) -> None: ... def ParseMessage(descriptor, byte_str): ... def MakeClass(descriptor): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/google/protobuf/service.pyi0000664000175000017500000000253300000000000030233 0ustar00davedave00000000000000from concurrent.futures import Future from typing import Callable, Optional, Text, Type from google.protobuf.descriptor import MethodDescriptor, ServiceDescriptor from google.protobuf.message import Message class RpcException(Exception): ... class Service: @staticmethod def GetDescriptor() -> ServiceDescriptor: ... def CallMethod( self, method_descriptor: MethodDescriptor, rpc_controller: RpcController, request: Message, done: Optional[Callable[[Message], None]], ) -> Optional[Future[Message]]: ... def GetRequestClass(self, method_descriptor: MethodDescriptor) -> Type[Message]: ... def GetResponseClass(self, method_descriptor: MethodDescriptor) -> Type[Message]: ... class RpcController: def Reset(self) -> None: ... def Failed(self) -> bool: ... def ErrorText(self) -> Optional[Text]: ... def StartCancel(self) -> None: ... def SetFailed(self, reason: Text) -> None: ... def IsCanceled(self) -> bool: ... def NotifyOnCancel(self, callback: Callable[[], None]) -> None: ... class RpcChannel: def CallMethod( self, method_descriptor: MethodDescriptor, rpc_controller: RpcController, request: Message, response_class: Type[Message], done: Optional[Callable[[Message], None]], ) -> Optional[Future[Message]]: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/google/protobuf/source_context_pb2.pyi0000664000175000017500000000211100000000000032372 0ustar00davedave00000000000000""" @generated by mypy-protobuf. Do not edit manually! isort:skip_file """ from google.protobuf.descriptor import ( Descriptor as google___protobuf___descriptor___Descriptor, FileDescriptor as google___protobuf___descriptor___FileDescriptor, ) from google.protobuf.message import ( Message as google___protobuf___message___Message, ) from typing import ( Optional as typing___Optional, Text as typing___Text, ) from typing_extensions import ( Literal as typing_extensions___Literal, ) builtin___bool = bool builtin___bytes = bytes builtin___float = float builtin___int = int DESCRIPTOR: google___protobuf___descriptor___FileDescriptor = ... class SourceContext(google___protobuf___message___Message): DESCRIPTOR: google___protobuf___descriptor___Descriptor = ... file_name: typing___Text = ... def __init__(self, *, file_name : typing___Optional[typing___Text] = None, ) -> None: ... def ClearField(self, field_name: typing_extensions___Literal[u"file_name",b"file_name"]) -> None: ... type___SourceContext = SourceContext ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/google/protobuf/struct_pb2.pyi0000664000175000017500000001235600000000000030666 0ustar00davedave00000000000000""" @generated by mypy-protobuf. Do not edit manually! isort:skip_file """ from google.protobuf.descriptor import ( Descriptor as google___protobuf___descriptor___Descriptor, EnumDescriptor as google___protobuf___descriptor___EnumDescriptor, FileDescriptor as google___protobuf___descriptor___FileDescriptor, ) from google.protobuf.internal.containers import ( MessageMap as google___protobuf___internal___containers___MessageMap, RepeatedCompositeFieldContainer as google___protobuf___internal___containers___RepeatedCompositeFieldContainer, ) from google.protobuf.internal.enum_type_wrapper import ( _EnumTypeWrapper as google___protobuf___internal___enum_type_wrapper____EnumTypeWrapper, ) from google.protobuf.internal.well_known_types import ( ListValue as google___protobuf___internal___well_known_types___ListValue, Struct as google___protobuf___internal___well_known_types___Struct, ) from google.protobuf.message import ( Message as google___protobuf___message___Message, ) from typing import ( Iterable as typing___Iterable, Mapping as typing___Mapping, NewType as typing___NewType, Optional as typing___Optional, Text as typing___Text, cast as typing___cast, ) from typing_extensions import ( Literal as typing_extensions___Literal, ) builtin___bool = bool builtin___bytes = bytes builtin___float = float builtin___int = int DESCRIPTOR: google___protobuf___descriptor___FileDescriptor = ... NullValueValue = typing___NewType('NullValueValue', builtin___int) type___NullValueValue = NullValueValue NullValue: _NullValue class _NullValue(google___protobuf___internal___enum_type_wrapper____EnumTypeWrapper[NullValueValue]): DESCRIPTOR: google___protobuf___descriptor___EnumDescriptor = ... NULL_VALUE = typing___cast(NullValueValue, 0) NULL_VALUE = typing___cast(NullValueValue, 0) class Struct(google___protobuf___message___Message, google___protobuf___internal___well_known_types___Struct): DESCRIPTOR: google___protobuf___descriptor___Descriptor = ... class FieldsEntry(google___protobuf___message___Message): DESCRIPTOR: google___protobuf___descriptor___Descriptor = ... key: typing___Text = ... @property def value(self) -> type___Value: ... def __init__(self, *, key : typing___Optional[typing___Text] = None, value : typing___Optional[type___Value] = None, ) -> None: ... def HasField(self, field_name: typing_extensions___Literal[u"value",b"value"]) -> builtin___bool: ... def ClearField(self, field_name: typing_extensions___Literal[u"key",b"key",u"value",b"value"]) -> None: ... type___FieldsEntry = FieldsEntry @property def fields(self) -> google___protobuf___internal___containers___MessageMap[typing___Text, type___Value]: ... def __init__(self, *, fields : typing___Optional[typing___Mapping[typing___Text, type___Value]] = None, ) -> None: ... def ClearField(self, field_name: typing_extensions___Literal[u"fields",b"fields"]) -> None: ... type___Struct = Struct class Value(google___protobuf___message___Message): DESCRIPTOR: google___protobuf___descriptor___Descriptor = ... null_value: type___NullValueValue = ... number_value: builtin___float = ... string_value: typing___Text = ... bool_value: builtin___bool = ... @property def struct_value(self) -> type___Struct: ... @property def list_value(self) -> type___ListValue: ... def __init__(self, *, null_value : typing___Optional[type___NullValueValue] = None, number_value : typing___Optional[builtin___float] = None, string_value : typing___Optional[typing___Text] = None, bool_value : typing___Optional[builtin___bool] = None, struct_value : typing___Optional[type___Struct] = None, list_value : typing___Optional[type___ListValue] = None, ) -> None: ... def HasField(self, field_name: typing_extensions___Literal[u"bool_value",b"bool_value",u"kind",b"kind",u"list_value",b"list_value",u"null_value",b"null_value",u"number_value",b"number_value",u"string_value",b"string_value",u"struct_value",b"struct_value"]) -> builtin___bool: ... def ClearField(self, field_name: typing_extensions___Literal[u"bool_value",b"bool_value",u"kind",b"kind",u"list_value",b"list_value",u"null_value",b"null_value",u"number_value",b"number_value",u"string_value",b"string_value",u"struct_value",b"struct_value"]) -> None: ... def WhichOneof(self, oneof_group: typing_extensions___Literal[u"kind",b"kind"]) -> typing_extensions___Literal["null_value","number_value","string_value","bool_value","struct_value","list_value"]: ... type___Value = Value class ListValue(google___protobuf___message___Message, google___protobuf___internal___well_known_types___ListValue): DESCRIPTOR: google___protobuf___descriptor___Descriptor = ... @property def values(self) -> google___protobuf___internal___containers___RepeatedCompositeFieldContainer[type___Value]: ... def __init__(self, *, values : typing___Optional[typing___Iterable[type___Value]] = None, ) -> None: ... def ClearField(self, field_name: typing_extensions___Literal[u"values",b"values"]) -> None: ... type___ListValue = ListValue ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/google/protobuf/symbol_database.pyi0000664000175000017500000000162000000000000031720 0ustar00davedave00000000000000from typing import Dict, Iterable, Type, Union from google.protobuf.descriptor import Descriptor, EnumDescriptor, FileDescriptor, ServiceDescriptor from google.protobuf.message import Message from google.protobuf.message_factory import MessageFactory class SymbolDatabase(MessageFactory): def RegisterMessage(self, message: Union[Type[Message], Message]) -> Union[Type[Message], Message]: ... def RegisterMessageDescriptor(self, message_descriptor: Descriptor) -> None: ... def RegisterEnumDescriptor(self, enum_descriptor: EnumDescriptor) -> EnumDescriptor: ... def RegisterServiceDescriptor(self, service_descriptor: ServiceDescriptor) -> None: ... def RegisterFileDescriptor(self, file_descriptor: FileDescriptor) -> None: ... def GetSymbol(self, symbol: str) -> Type[Message]: ... def GetMessages(self, files: Iterable[str]) -> Dict[str, Type[Message]]: ... def Default(): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/google/protobuf/timestamp_pb2.pyi0000664000175000017500000000251200000000000031336 0ustar00davedave00000000000000""" @generated by mypy-protobuf. Do not edit manually! isort:skip_file """ from google.protobuf.descriptor import ( Descriptor as google___protobuf___descriptor___Descriptor, FileDescriptor as google___protobuf___descriptor___FileDescriptor, ) from google.protobuf.internal.well_known_types import ( Timestamp as google___protobuf___internal___well_known_types___Timestamp, ) from google.protobuf.message import ( Message as google___protobuf___message___Message, ) from typing import ( Optional as typing___Optional, ) from typing_extensions import ( Literal as typing_extensions___Literal, ) builtin___bool = bool builtin___bytes = bytes builtin___float = float builtin___int = int DESCRIPTOR: google___protobuf___descriptor___FileDescriptor = ... class Timestamp(google___protobuf___message___Message, google___protobuf___internal___well_known_types___Timestamp): DESCRIPTOR: google___protobuf___descriptor___Descriptor = ... seconds: builtin___int = ... nanos: builtin___int = ... def __init__(self, *, seconds : typing___Optional[builtin___int] = None, nanos : typing___Optional[builtin___int] = None, ) -> None: ... def ClearField(self, field_name: typing_extensions___Literal[u"nanos",b"nanos",u"seconds",b"seconds"]) -> None: ... type___Timestamp = Timestamp ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/google/protobuf/type_pb2.pyi0000664000175000017500000002560300000000000030322 0ustar00davedave00000000000000""" @generated by mypy-protobuf. Do not edit manually! isort:skip_file """ from google.protobuf.any_pb2 import ( Any as google___protobuf___any_pb2___Any, ) from google.protobuf.descriptor import ( Descriptor as google___protobuf___descriptor___Descriptor, EnumDescriptor as google___protobuf___descriptor___EnumDescriptor, FileDescriptor as google___protobuf___descriptor___FileDescriptor, ) from google.protobuf.internal.containers import ( RepeatedCompositeFieldContainer as google___protobuf___internal___containers___RepeatedCompositeFieldContainer, RepeatedScalarFieldContainer as google___protobuf___internal___containers___RepeatedScalarFieldContainer, ) from google.protobuf.internal.enum_type_wrapper import ( _EnumTypeWrapper as google___protobuf___internal___enum_type_wrapper____EnumTypeWrapper, ) from google.protobuf.message import ( Message as google___protobuf___message___Message, ) from google.protobuf.source_context_pb2 import ( SourceContext as google___protobuf___source_context_pb2___SourceContext, ) from typing import ( Iterable as typing___Iterable, NewType as typing___NewType, Optional as typing___Optional, Text as typing___Text, cast as typing___cast, ) from typing_extensions import ( Literal as typing_extensions___Literal, ) builtin___bool = bool builtin___bytes = bytes builtin___float = float builtin___int = int DESCRIPTOR: google___protobuf___descriptor___FileDescriptor = ... SyntaxValue = typing___NewType('SyntaxValue', builtin___int) type___SyntaxValue = SyntaxValue Syntax: _Syntax class _Syntax(google___protobuf___internal___enum_type_wrapper____EnumTypeWrapper[SyntaxValue]): DESCRIPTOR: google___protobuf___descriptor___EnumDescriptor = ... SYNTAX_PROTO2 = typing___cast(SyntaxValue, 0) SYNTAX_PROTO3 = typing___cast(SyntaxValue, 1) SYNTAX_PROTO2 = typing___cast(SyntaxValue, 0) SYNTAX_PROTO3 = typing___cast(SyntaxValue, 1) class Type(google___protobuf___message___Message): DESCRIPTOR: google___protobuf___descriptor___Descriptor = ... name: typing___Text = ... oneofs: google___protobuf___internal___containers___RepeatedScalarFieldContainer[typing___Text] = ... syntax: type___SyntaxValue = ... @property def fields(self) -> google___protobuf___internal___containers___RepeatedCompositeFieldContainer[type___Field]: ... @property def options(self) -> google___protobuf___internal___containers___RepeatedCompositeFieldContainer[type___Option]: ... @property def source_context(self) -> google___protobuf___source_context_pb2___SourceContext: ... def __init__(self, *, name : typing___Optional[typing___Text] = None, fields : typing___Optional[typing___Iterable[type___Field]] = None, oneofs : typing___Optional[typing___Iterable[typing___Text]] = None, options : typing___Optional[typing___Iterable[type___Option]] = None, source_context : typing___Optional[google___protobuf___source_context_pb2___SourceContext] = None, syntax : typing___Optional[type___SyntaxValue] = None, ) -> None: ... def HasField(self, field_name: typing_extensions___Literal[u"source_context",b"source_context"]) -> builtin___bool: ... def ClearField(self, field_name: typing_extensions___Literal[u"fields",b"fields",u"name",b"name",u"oneofs",b"oneofs",u"options",b"options",u"source_context",b"source_context",u"syntax",b"syntax"]) -> None: ... type___Type = Type class Field(google___protobuf___message___Message): DESCRIPTOR: google___protobuf___descriptor___Descriptor = ... KindValue = typing___NewType('KindValue', builtin___int) type___KindValue = KindValue Kind: _Kind class _Kind(google___protobuf___internal___enum_type_wrapper____EnumTypeWrapper[Field.KindValue]): DESCRIPTOR: google___protobuf___descriptor___EnumDescriptor = ... TYPE_UNKNOWN = typing___cast(Field.KindValue, 0) TYPE_DOUBLE = typing___cast(Field.KindValue, 1) TYPE_FLOAT = typing___cast(Field.KindValue, 2) TYPE_INT64 = typing___cast(Field.KindValue, 3) TYPE_UINT64 = typing___cast(Field.KindValue, 4) TYPE_INT32 = typing___cast(Field.KindValue, 5) TYPE_FIXED64 = typing___cast(Field.KindValue, 6) TYPE_FIXED32 = typing___cast(Field.KindValue, 7) TYPE_BOOL = typing___cast(Field.KindValue, 8) TYPE_STRING = typing___cast(Field.KindValue, 9) TYPE_GROUP = typing___cast(Field.KindValue, 10) TYPE_MESSAGE = typing___cast(Field.KindValue, 11) TYPE_BYTES = typing___cast(Field.KindValue, 12) TYPE_UINT32 = typing___cast(Field.KindValue, 13) TYPE_ENUM = typing___cast(Field.KindValue, 14) TYPE_SFIXED32 = typing___cast(Field.KindValue, 15) TYPE_SFIXED64 = typing___cast(Field.KindValue, 16) TYPE_SINT32 = typing___cast(Field.KindValue, 17) TYPE_SINT64 = typing___cast(Field.KindValue, 18) TYPE_UNKNOWN = typing___cast(Field.KindValue, 0) TYPE_DOUBLE = typing___cast(Field.KindValue, 1) TYPE_FLOAT = typing___cast(Field.KindValue, 2) TYPE_INT64 = typing___cast(Field.KindValue, 3) TYPE_UINT64 = typing___cast(Field.KindValue, 4) TYPE_INT32 = typing___cast(Field.KindValue, 5) TYPE_FIXED64 = typing___cast(Field.KindValue, 6) TYPE_FIXED32 = typing___cast(Field.KindValue, 7) TYPE_BOOL = typing___cast(Field.KindValue, 8) TYPE_STRING = typing___cast(Field.KindValue, 9) TYPE_GROUP = typing___cast(Field.KindValue, 10) TYPE_MESSAGE = typing___cast(Field.KindValue, 11) TYPE_BYTES = typing___cast(Field.KindValue, 12) TYPE_UINT32 = typing___cast(Field.KindValue, 13) TYPE_ENUM = typing___cast(Field.KindValue, 14) TYPE_SFIXED32 = typing___cast(Field.KindValue, 15) TYPE_SFIXED64 = typing___cast(Field.KindValue, 16) TYPE_SINT32 = typing___cast(Field.KindValue, 17) TYPE_SINT64 = typing___cast(Field.KindValue, 18) CardinalityValue = typing___NewType('CardinalityValue', builtin___int) type___CardinalityValue = CardinalityValue Cardinality: _Cardinality class _Cardinality(google___protobuf___internal___enum_type_wrapper____EnumTypeWrapper[Field.CardinalityValue]): DESCRIPTOR: google___protobuf___descriptor___EnumDescriptor = ... CARDINALITY_UNKNOWN = typing___cast(Field.CardinalityValue, 0) CARDINALITY_OPTIONAL = typing___cast(Field.CardinalityValue, 1) CARDINALITY_REQUIRED = typing___cast(Field.CardinalityValue, 2) CARDINALITY_REPEATED = typing___cast(Field.CardinalityValue, 3) CARDINALITY_UNKNOWN = typing___cast(Field.CardinalityValue, 0) CARDINALITY_OPTIONAL = typing___cast(Field.CardinalityValue, 1) CARDINALITY_REQUIRED = typing___cast(Field.CardinalityValue, 2) CARDINALITY_REPEATED = typing___cast(Field.CardinalityValue, 3) kind: type___Field.KindValue = ... cardinality: type___Field.CardinalityValue = ... number: builtin___int = ... name: typing___Text = ... type_url: typing___Text = ... oneof_index: builtin___int = ... packed: builtin___bool = ... json_name: typing___Text = ... default_value: typing___Text = ... @property def options(self) -> google___protobuf___internal___containers___RepeatedCompositeFieldContainer[type___Option]: ... def __init__(self, *, kind : typing___Optional[type___Field.KindValue] = None, cardinality : typing___Optional[type___Field.CardinalityValue] = None, number : typing___Optional[builtin___int] = None, name : typing___Optional[typing___Text] = None, type_url : typing___Optional[typing___Text] = None, oneof_index : typing___Optional[builtin___int] = None, packed : typing___Optional[builtin___bool] = None, options : typing___Optional[typing___Iterable[type___Option]] = None, json_name : typing___Optional[typing___Text] = None, default_value : typing___Optional[typing___Text] = None, ) -> None: ... def ClearField(self, field_name: typing_extensions___Literal[u"cardinality",b"cardinality",u"default_value",b"default_value",u"json_name",b"json_name",u"kind",b"kind",u"name",b"name",u"number",b"number",u"oneof_index",b"oneof_index",u"options",b"options",u"packed",b"packed",u"type_url",b"type_url"]) -> None: ... type___Field = Field class Enum(google___protobuf___message___Message): DESCRIPTOR: google___protobuf___descriptor___Descriptor = ... name: typing___Text = ... syntax: type___SyntaxValue = ... @property def enumvalue(self) -> google___protobuf___internal___containers___RepeatedCompositeFieldContainer[type___EnumValue]: ... @property def options(self) -> google___protobuf___internal___containers___RepeatedCompositeFieldContainer[type___Option]: ... @property def source_context(self) -> google___protobuf___source_context_pb2___SourceContext: ... def __init__(self, *, name : typing___Optional[typing___Text] = None, enumvalue : typing___Optional[typing___Iterable[type___EnumValue]] = None, options : typing___Optional[typing___Iterable[type___Option]] = None, source_context : typing___Optional[google___protobuf___source_context_pb2___SourceContext] = None, syntax : typing___Optional[type___SyntaxValue] = None, ) -> None: ... def HasField(self, field_name: typing_extensions___Literal[u"source_context",b"source_context"]) -> builtin___bool: ... def ClearField(self, field_name: typing_extensions___Literal[u"enumvalue",b"enumvalue",u"name",b"name",u"options",b"options",u"source_context",b"source_context",u"syntax",b"syntax"]) -> None: ... type___Enum = Enum class EnumValue(google___protobuf___message___Message): DESCRIPTOR: google___protobuf___descriptor___Descriptor = ... name: typing___Text = ... number: builtin___int = ... @property def options(self) -> google___protobuf___internal___containers___RepeatedCompositeFieldContainer[type___Option]: ... def __init__(self, *, name : typing___Optional[typing___Text] = None, number : typing___Optional[builtin___int] = None, options : typing___Optional[typing___Iterable[type___Option]] = None, ) -> None: ... def ClearField(self, field_name: typing_extensions___Literal[u"name",b"name",u"number",b"number",u"options",b"options"]) -> None: ... type___EnumValue = EnumValue class Option(google___protobuf___message___Message): DESCRIPTOR: google___protobuf___descriptor___Descriptor = ... name: typing___Text = ... @property def value(self) -> google___protobuf___any_pb2___Any: ... def __init__(self, *, name : typing___Optional[typing___Text] = None, value : typing___Optional[google___protobuf___any_pb2___Any] = None, ) -> None: ... def HasField(self, field_name: typing_extensions___Literal[u"value",b"value"]) -> builtin___bool: ... def ClearField(self, field_name: typing_extensions___Literal[u"name",b"name",u"value",b"value"]) -> None: ... type___Option = Option ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4463794 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/google/protobuf/util/0000775000175000017500000000000000000000000027022 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/google/protobuf/util/__init__.pyi0000664000175000017500000000000000000000000031272 0ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/google/protobuf/wrappers_pb2.pyi0000664000175000017500000001027700000000000031205 0ustar00davedave00000000000000""" @generated by mypy-protobuf. Do not edit manually! isort:skip_file """ from google.protobuf.descriptor import ( Descriptor as google___protobuf___descriptor___Descriptor, FileDescriptor as google___protobuf___descriptor___FileDescriptor, ) from google.protobuf.message import ( Message as google___protobuf___message___Message, ) from typing import ( Optional as typing___Optional, Text as typing___Text, ) from typing_extensions import ( Literal as typing_extensions___Literal, ) builtin___bool = bool builtin___bytes = bytes builtin___float = float builtin___int = int DESCRIPTOR: google___protobuf___descriptor___FileDescriptor = ... class DoubleValue(google___protobuf___message___Message): DESCRIPTOR: google___protobuf___descriptor___Descriptor = ... value: builtin___float = ... def __init__(self, *, value : typing___Optional[builtin___float] = None, ) -> None: ... def ClearField(self, field_name: typing_extensions___Literal[u"value",b"value"]) -> None: ... type___DoubleValue = DoubleValue class FloatValue(google___protobuf___message___Message): DESCRIPTOR: google___protobuf___descriptor___Descriptor = ... value: builtin___float = ... def __init__(self, *, value : typing___Optional[builtin___float] = None, ) -> None: ... def ClearField(self, field_name: typing_extensions___Literal[u"value",b"value"]) -> None: ... type___FloatValue = FloatValue class Int64Value(google___protobuf___message___Message): DESCRIPTOR: google___protobuf___descriptor___Descriptor = ... value: builtin___int = ... def __init__(self, *, value : typing___Optional[builtin___int] = None, ) -> None: ... def ClearField(self, field_name: typing_extensions___Literal[u"value",b"value"]) -> None: ... type___Int64Value = Int64Value class UInt64Value(google___protobuf___message___Message): DESCRIPTOR: google___protobuf___descriptor___Descriptor = ... value: builtin___int = ... def __init__(self, *, value : typing___Optional[builtin___int] = None, ) -> None: ... def ClearField(self, field_name: typing_extensions___Literal[u"value",b"value"]) -> None: ... type___UInt64Value = UInt64Value class Int32Value(google___protobuf___message___Message): DESCRIPTOR: google___protobuf___descriptor___Descriptor = ... value: builtin___int = ... def __init__(self, *, value : typing___Optional[builtin___int] = None, ) -> None: ... def ClearField(self, field_name: typing_extensions___Literal[u"value",b"value"]) -> None: ... type___Int32Value = Int32Value class UInt32Value(google___protobuf___message___Message): DESCRIPTOR: google___protobuf___descriptor___Descriptor = ... value: builtin___int = ... def __init__(self, *, value : typing___Optional[builtin___int] = None, ) -> None: ... def ClearField(self, field_name: typing_extensions___Literal[u"value",b"value"]) -> None: ... type___UInt32Value = UInt32Value class BoolValue(google___protobuf___message___Message): DESCRIPTOR: google___protobuf___descriptor___Descriptor = ... value: builtin___bool = ... def __init__(self, *, value : typing___Optional[builtin___bool] = None, ) -> None: ... def ClearField(self, field_name: typing_extensions___Literal[u"value",b"value"]) -> None: ... type___BoolValue = BoolValue class StringValue(google___protobuf___message___Message): DESCRIPTOR: google___protobuf___descriptor___Descriptor = ... value: typing___Text = ... def __init__(self, *, value : typing___Optional[typing___Text] = None, ) -> None: ... def ClearField(self, field_name: typing_extensions___Literal[u"value",b"value"]) -> None: ... type___StringValue = StringValue class BytesValue(google___protobuf___message___Message): DESCRIPTOR: google___protobuf___descriptor___Descriptor = ... value: builtin___bytes = ... def __init__(self, *, value : typing___Optional[builtin___bytes] = None, ) -> None: ... def ClearField(self, field_name: typing_extensions___Literal[u"value",b"value"]) -> None: ... type___BytesValue = BytesValue ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/itsdangerous.pyi0000664000175000017500000002032500000000000026165 0ustar00davedave00000000000000from datetime import datetime from typing import IO, Any, Callable, Generator, Mapping, MutableMapping, Optional, Text, Tuple, Union _serializer = Any # must be an object that has "dumps" and "loads" attributes (e.g. the json module) def want_bytes(s: Union[Text, bytes], encoding: Text = ..., errors: Text = ...) -> bytes: ... class BadData(Exception): message: str def __init__(self, message: str) -> None: ... class BadPayload(BadData): original_error: Optional[Exception] def __init__(self, message: str, original_error: Optional[Exception] = ...) -> None: ... class BadSignature(BadData): payload: Optional[Any] def __init__(self, message: str, payload: Optional[Any] = ...) -> None: ... class BadTimeSignature(BadSignature): date_signed: Optional[int] def __init__(self, message: str, payload: Optional[Any] = ..., date_signed: Optional[int] = ...) -> None: ... class BadHeader(BadSignature): header: Any original_error: Any def __init__( self, message: str, payload: Optional[Any] = ..., header: Optional[Any] = ..., original_error: Optional[Any] = ... ) -> None: ... class SignatureExpired(BadTimeSignature): ... def base64_encode(string: Union[Text, bytes]) -> bytes: ... def base64_decode(string: Union[Text, bytes]) -> bytes: ... class SigningAlgorithm(object): def get_signature(self, key: bytes, value: bytes) -> bytes: ... def verify_signature(self, key: bytes, value: bytes, sig: bytes) -> bool: ... class NoneAlgorithm(SigningAlgorithm): def get_signature(self, key: bytes, value: bytes) -> bytes: ... class HMACAlgorithm(SigningAlgorithm): default_digest_method: Callable[..., Any] digest_method: Callable[..., Any] def __init__(self, digest_method: Optional[Callable[..., Any]] = ...) -> None: ... def get_signature(self, key: bytes, value: bytes) -> bytes: ... class Signer(object): default_digest_method: Callable[..., Any] = ... default_key_derivation: str = ... secret_key: bytes sep: bytes salt: Union[Text, bytes] key_derivation: str digest_method: Callable[..., Any] algorithm: SigningAlgorithm def __init__( self, secret_key: Union[Text, bytes], salt: Optional[Union[Text, bytes]] = ..., sep: Optional[Union[Text, bytes]] = ..., key_derivation: Optional[str] = ..., digest_method: Optional[Callable[..., Any]] = ..., algorithm: Optional[SigningAlgorithm] = ..., ) -> None: ... def derive_key(self) -> bytes: ... def get_signature(self, value: Union[Text, bytes]) -> bytes: ... def sign(self, value: Union[Text, bytes]) -> bytes: ... def verify_signature(self, value: bytes, sig: Union[Text, bytes]) -> bool: ... def unsign(self, signed_value: Union[Text, bytes]) -> bytes: ... def validate(self, signed_value: Union[Text, bytes]) -> bool: ... class TimestampSigner(Signer): def get_timestamp(self) -> int: ... def timestamp_to_datetime(self, ts: float) -> datetime: ... def sign(self, value: Union[Text, bytes]) -> bytes: ... def unsign( self, value: Union[Text, bytes], max_age: Optional[int] = ..., return_timestamp: bool = ... ) -> Any: ... # morally -> Union[bytes, Tuple[bytes, datetime]] def validate(self, signed_value: Union[Text, bytes], max_age: Optional[int] = ...) -> bool: ... class Serializer(object): default_serializer: _serializer = ... default_signer: Callable[..., Signer] = ... secret_key: bytes salt: bytes serializer: _serializer is_text_serializer: bool signer: Callable[..., Signer] signer_kwargs: MutableMapping[str, Any] def __init__( self, secret_key: Union[Text, bytes], salt: Optional[Union[Text, bytes]] = ..., serializer: Optional[_serializer] = ..., signer: Optional[Callable[..., Signer]] = ..., signer_kwargs: Optional[MutableMapping[str, Any]] = ..., ) -> None: ... def load_payload(self, payload: bytes, serializer: Optional[_serializer] = ...) -> Any: ... def dump_payload(self, obj: Any) -> bytes: ... def make_signer(self, salt: Optional[Union[Text, bytes]] = ...) -> Signer: ... def iter_unsigners(self, salt: Optional[Union[Text, bytes]] = ...) -> Generator[Any, None, None]: ... def dumps(self, obj: Any, salt: Optional[Union[Text, bytes]] = ...) -> Any: ... # morally -> Union[str, bytes] def dump(self, obj: Any, f: IO[Any], salt: Optional[Union[Text, bytes]] = ...) -> None: ... def loads(self, s: Union[Text, bytes], salt: Optional[Union[Text, bytes]] = ...) -> Any: ... def load(self, f: IO[Any], salt: Optional[Union[Text, bytes]] = ...) -> Any: ... def loads_unsafe(self, s: Union[Text, bytes], salt: Optional[Union[Text, bytes]] = ...) -> Tuple[bool, Optional[Any]]: ... def load_unsafe(self, f: IO[Any], salt: Optional[Union[Text, bytes]] = ...) -> Tuple[bool, Optional[Any]]: ... class TimedSerializer(Serializer): def loads( self, s: Union[Text, bytes], salt: Optional[Union[Text, bytes]] = ..., max_age: Optional[int] = ..., return_timestamp: bool = ..., ) -> Any: ... # morally -> Union[Any, Tuple[Any, datetime]] def loads_unsafe( self, s: Union[Text, bytes], salt: Optional[Union[Text, bytes]] = ..., max_age: Optional[int] = ... ) -> Tuple[bool, Any]: ... class JSONWebSignatureSerializer(Serializer): jws_algorithms: MutableMapping[Text, SigningAlgorithm] = ... default_algorithm: Text = ... default_serializer: Any = ... algorithm_name: Text algorithm: SigningAlgorithm def __init__( self, secret_key: Union[Text, bytes], salt: Optional[Union[Text, bytes]] = ..., serializer: Optional[_serializer] = ..., signer: Optional[Callable[..., Signer]] = ..., signer_kwargs: Optional[MutableMapping[str, Any]] = ..., algorithm_name: Optional[Text] = ..., ) -> None: ... def load_payload( self, payload: Union[Text, bytes], serializer: Optional[_serializer] = ..., return_header: bool = ... ) -> Any: ... # morally -> Union[Any, Tuple[Any, MutableMapping[str, Any]]] def dump_payload(self, header: Mapping[str, Any], obj: Any) -> bytes: ... # type: ignore def make_algorithm(self, algorithm_name: Text) -> SigningAlgorithm: ... def make_signer(self, salt: Optional[Union[Text, bytes]] = ..., algorithm: SigningAlgorithm = ...) -> Signer: ... def make_header(self, header_fields: Optional[Mapping[str, Any]]) -> MutableMapping[str, Any]: ... def dumps( self, obj: Any, salt: Optional[Union[Text, bytes]] = ..., header_fields: Optional[Mapping[str, Any]] = ... ) -> bytes: ... def loads( self, s: Union[Text, bytes], salt: Optional[Union[Text, bytes]] = ..., return_header: bool = ... ) -> Any: ... # morally -> Union[Any, Tuple[Any, MutableMapping[str, Any]]] def loads_unsafe( self, s: Union[Text, bytes], salt: Optional[Union[Text, bytes]] = ..., return_header: bool = ... ) -> Tuple[bool, Any]: ... class TimedJSONWebSignatureSerializer(JSONWebSignatureSerializer): DEFAULT_EXPIRES_IN: int = ... expires_in: int def __init__( self, secret_key: Union[Text, bytes], expires_in: Optional[int] = ..., salt: Optional[Union[Text, bytes]] = ..., serializer: Optional[_serializer] = ..., signer: Optional[Callable[..., Signer]] = ..., signer_kwargs: Optional[MutableMapping[str, Any]] = ..., algorithm_name: Optional[Text] = ..., ) -> None: ... def make_header(self, header_fields: Optional[Mapping[str, Any]]) -> MutableMapping[str, Any]: ... def loads( self, s: Union[Text, bytes], salt: Optional[Union[Text, bytes]] = ..., return_header: bool = ... ) -> Any: ... # morally -> Union[Any, Tuple[Any, MutableMapping[str, Any]]] def get_issue_date(self, header: Mapping[str, Any]) -> Optional[datetime]: ... def now(self) -> int: ... class _URLSafeSerializerMixin(object): default_serializer: _serializer = ... def load_payload(self, payload: bytes, serializer: Optional[_serializer] = ...) -> Any: ... def dump_payload(self, obj: Any) -> bytes: ... class URLSafeSerializer(_URLSafeSerializerMixin, Serializer): ... class URLSafeTimedSerializer(_URLSafeSerializerMixin, TimedSerializer): ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4503794 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/jinja2/0000775000175000017500000000000000000000000024106 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/jinja2/__init__.pyi0000664000175000017500000000277100000000000026377 0ustar00davedave00000000000000from jinja2.bccache import ( BytecodeCache as BytecodeCache, FileSystemBytecodeCache as FileSystemBytecodeCache, MemcachedBytecodeCache as MemcachedBytecodeCache, ) from jinja2.environment import Environment as Environment, Template as Template from jinja2.exceptions import ( TemplateAssertionError as TemplateAssertionError, TemplateError as TemplateError, TemplateNotFound as TemplateNotFound, TemplatesNotFound as TemplatesNotFound, TemplateSyntaxError as TemplateSyntaxError, UndefinedError as UndefinedError, ) from jinja2.filters import ( contextfilter as contextfilter, environmentfilter as environmentfilter, evalcontextfilter as evalcontextfilter, ) from jinja2.loaders import ( BaseLoader as BaseLoader, ChoiceLoader as ChoiceLoader, DictLoader as DictLoader, FileSystemLoader as FileSystemLoader, FunctionLoader as FunctionLoader, ModuleLoader as ModuleLoader, PackageLoader as PackageLoader, PrefixLoader as PrefixLoader, ) from jinja2.runtime import ( DebugUndefined as DebugUndefined, StrictUndefined as StrictUndefined, Undefined as Undefined, make_logging_undefined as make_logging_undefined, ) from jinja2.utils import ( Markup as Markup, clear_caches as clear_caches, contextfunction as contextfunction, environmentfunction as environmentfunction, escape as escape, evalcontextfunction as evalcontextfunction, is_undefined as is_undefined, select_autoescape as select_autoescape, ) ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/jinja2/_compat.pyi0000664000175000017500000000112600000000000026253 0ustar00davedave00000000000000import sys from typing import Any, Optional if sys.version_info >= (3,): from urllib.parse import quote_from_bytes url_quote = quote_from_bytes else: import urllib url_quote = urllib.quote PY2: Any PYPY: Any unichr: Any range_type: Any text_type: Any string_types: Any integer_types: Any iterkeys: Any itervalues: Any iteritems: Any NativeStringIO: Any def reraise(tp, value, tb: Optional[Any] = ...): ... ifilter: Any imap: Any izip: Any intern: Any implements_iterator: Any implements_to_string: Any encode_filename: Any get_next: Any def with_metaclass(meta, *bases): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/jinja2/_stringdefs.pyi0000664000175000017500000000055000000000000027140 0ustar00davedave00000000000000from typing import Any Cc: str Cf: str Cn: str Co: str Cs: Any Ll: str Lm: str Lo: str Lt: str Lu: str Mc: str Me: str Mn: str Nd: str Nl: str No: str Pc: str Pd: str Pe: str Pf: str Pi: str Po: str Ps: str Sc: str Sk: str Sm: str So: str Zl: str Zp: str Zs: str cats: Any def combine(*args): ... xid_start: str xid_continue: str def allexcept(*args): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/jinja2/bccache.pyi0000664000175000017500000000256400000000000026210 0ustar00davedave00000000000000from typing import Any, Optional marshal_dump: Any marshal_load: Any bc_version: int bc_magic: Any class Bucket: environment: Any key: Any checksum: Any def __init__(self, environment, key, checksum) -> None: ... code: Any def reset(self): ... def load_bytecode(self, f): ... def write_bytecode(self, f): ... def bytecode_from_string(self, string): ... def bytecode_to_string(self): ... class BytecodeCache: def load_bytecode(self, bucket): ... def dump_bytecode(self, bucket): ... def clear(self): ... def get_cache_key(self, name, filename: Optional[Any] = ...): ... def get_source_checksum(self, source): ... def get_bucket(self, environment, name, filename, source): ... def set_bucket(self, bucket): ... class FileSystemBytecodeCache(BytecodeCache): directory: Any pattern: Any def __init__(self, directory: Optional[Any] = ..., pattern: str = ...) -> None: ... def load_bytecode(self, bucket): ... def dump_bytecode(self, bucket): ... def clear(self): ... class MemcachedBytecodeCache(BytecodeCache): client: Any prefix: Any timeout: Any ignore_memcache_errors: Any def __init__(self, client, prefix: str = ..., timeout: Optional[Any] = ..., ignore_memcache_errors: bool = ...) -> None: ... def load_bytecode(self, bucket): ... def dump_bytecode(self, bucket): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/jinja2/compiler.pyi0000664000175000017500000001433300000000000026447 0ustar00davedave00000000000000from keyword import iskeyword as is_python_keyword from typing import Any, Optional from jinja2.visitor import NodeVisitor operators: Any dict_item_iter: str unoptimize_before_dead_code: bool def generate(node, environment, name, filename, stream: Optional[Any] = ..., defer_init: bool = ...): ... def has_safe_repr(value): ... def find_undeclared(nodes, names): ... class Identifiers: declared: Any outer_undeclared: Any undeclared: Any declared_locally: Any declared_parameter: Any def __init__(self) -> None: ... def add_special(self, name): ... def is_declared(self, name): ... def copy(self): ... class Frame: eval_ctx: Any identifiers: Any toplevel: bool rootlevel: bool require_output_check: Any buffer: Any block: Any assigned_names: Any parent: Any def __init__(self, eval_ctx, parent: Optional[Any] = ...) -> None: ... def copy(self): ... def inspect(self, nodes): ... def find_shadowed(self, extra: Any = ...): ... def inner(self): ... def soft(self): ... __copy__: Any class VisitorExit(RuntimeError): ... class DependencyFinderVisitor(NodeVisitor): filters: Any tests: Any def __init__(self) -> None: ... def visit_Filter(self, node): ... def visit_Test(self, node): ... def visit_Block(self, node): ... class UndeclaredNameVisitor(NodeVisitor): names: Any undeclared: Any def __init__(self, names) -> None: ... def visit_Name(self, node): ... def visit_Block(self, node): ... class FrameIdentifierVisitor(NodeVisitor): identifiers: Any def __init__(self, identifiers) -> None: ... def visit_Name(self, node): ... def visit_If(self, node): ... def visit_Macro(self, node): ... def visit_Import(self, node): ... def visit_FromImport(self, node): ... def visit_Assign(self, node): ... def visit_For(self, node): ... def visit_CallBlock(self, node): ... def visit_FilterBlock(self, node): ... def visit_AssignBlock(self, node): ... def visit_Scope(self, node): ... def visit_Block(self, node): ... class CompilerExit(Exception): ... class CodeGenerator(NodeVisitor): environment: Any name: Any filename: Any stream: Any created_block_context: bool defer_init: Any import_aliases: Any blocks: Any extends_so_far: int has_known_extends: bool code_lineno: int tests: Any filters: Any debug_info: Any def __init__(self, environment, name, filename, stream: Optional[Any] = ..., defer_init: bool = ...) -> None: ... def fail(self, msg, lineno): ... def temporary_identifier(self): ... def buffer(self, frame): ... def return_buffer_contents(self, frame): ... def indent(self): ... def outdent(self, step: int = ...): ... def start_write(self, frame, node: Optional[Any] = ...): ... def end_write(self, frame): ... def simple_write(self, s, frame, node: Optional[Any] = ...): ... def blockvisit(self, nodes, frame): ... def write(self, x): ... def writeline(self, x, node: Optional[Any] = ..., extra: int = ...): ... def newline(self, node: Optional[Any] = ..., extra: int = ...): ... def signature(self, node, frame, extra_kwargs: Optional[Any] = ...): ... def pull_locals(self, frame): ... def pull_dependencies(self, nodes): ... def unoptimize_scope(self, frame): ... def push_scope(self, frame, extra_vars: Any = ...): ... def pop_scope(self, aliases, frame): ... def function_scoping(self, node, frame, children: Optional[Any] = ..., find_special: bool = ...): ... def macro_body(self, node, frame, children: Optional[Any] = ...): ... def macro_def(self, node, frame): ... def position(self, node): ... def visit_Template(self, node, frame: Optional[Any] = ...): ... def visit_Block(self, node, frame): ... def visit_Extends(self, node, frame): ... def visit_Include(self, node, frame): ... def visit_Import(self, node, frame): ... def visit_FromImport(self, node, frame): ... def visit_For(self, node, frame): ... def visit_If(self, node, frame): ... def visit_Macro(self, node, frame): ... def visit_CallBlock(self, node, frame): ... def visit_FilterBlock(self, node, frame): ... def visit_ExprStmt(self, node, frame): ... def visit_Output(self, node, frame): ... def make_assignment_frame(self, frame): ... def export_assigned_vars(self, frame, assignment_frame): ... def visit_Assign(self, node, frame): ... def visit_AssignBlock(self, node, frame): ... def visit_Name(self, node, frame): ... def visit_Const(self, node, frame): ... def visit_TemplateData(self, node, frame): ... def visit_Tuple(self, node, frame): ... def visit_List(self, node, frame): ... def visit_Dict(self, node, frame): ... def binop(self, interceptable: bool = ...): ... def uaop(self, interceptable: bool = ...): ... visit_Add: Any visit_Sub: Any visit_Mul: Any visit_Div: Any visit_FloorDiv: Any visit_Pow: Any visit_Mod: Any visit_And: Any visit_Or: Any visit_Pos: Any visit_Neg: Any visit_Not: Any def visit_Concat(self, node, frame): ... def visit_Compare(self, node, frame): ... def visit_Operand(self, node, frame): ... def visit_Getattr(self, node, frame): ... def visit_Getitem(self, node, frame): ... def visit_Slice(self, node, frame): ... def visit_Filter(self, node, frame): ... def visit_Test(self, node, frame): ... def visit_CondExpr(self, node, frame): ... def visit_Call(self, node, frame, forward_caller: bool = ...): ... def visit_Keyword(self, node, frame): ... def visit_MarkSafe(self, node, frame): ... def visit_MarkSafeIfAutoescape(self, node, frame): ... def visit_EnvironmentAttribute(self, node, frame): ... def visit_ExtensionAttribute(self, node, frame): ... def visit_ImportedName(self, node, frame): ... def visit_InternalName(self, node, frame): ... def visit_ContextReference(self, node, frame): ... def visit_Continue(self, node, frame): ... def visit_Break(self, node, frame): ... def visit_Scope(self, node, frame): ... def visit_EvalContextModifier(self, node, frame): ... def visit_ScopedEvalContextModifier(self, node, frame): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/jinja2/constants.pyi0000664000175000017500000000002700000000000026644 0ustar00davedave00000000000000LOREM_IPSUM_WORDS: str ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/jinja2/debug.pyi0000664000175000017500000000177200000000000025726 0ustar00davedave00000000000000from typing import Any, Optional tproxy: Any raise_helper: str class TracebackFrameProxy: tb: Any def __init__(self, tb) -> None: ... @property def tb_next(self): ... def set_next(self, next): ... @property def is_jinja_frame(self): ... def __getattr__(self, name): ... def make_frame_proxy(frame): ... class ProcessedTraceback: exc_type: Any exc_value: Any frames: Any def __init__(self, exc_type, exc_value, frames) -> None: ... def render_as_text(self, limit: Optional[Any] = ...): ... def render_as_html(self, full: bool = ...): ... @property def is_template_syntax_error(self): ... @property def exc_info(self): ... @property def standard_exc_info(self): ... def make_traceback(exc_info, source_hint: Optional[Any] = ...): ... def translate_syntax_error(error, source: Optional[Any] = ...): ... def translate_exception(exc_info, initial_skip: int = ...): ... def fake_exc_info(exc_info, filename, lineno): ... tb_set_next: Any ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/jinja2/defaults.pyi0000664000175000017500000000102400000000000026435 0ustar00davedave00000000000000from typing import Any, Dict, Optional from jinja2.filters import FILTERS from jinja2.tests import TESTS DEFAULT_FILTERS = FILTERS DEFAULT_TESTS = TESTS BLOCK_START_STRING: str BLOCK_END_STRING: str VARIABLE_START_STRING: str VARIABLE_END_STRING: str COMMENT_START_STRING: str COMMENT_END_STRING: str LINE_STATEMENT_PREFIX: Optional[str] LINE_COMMENT_PREFIX: Optional[str] TRIM_BLOCKS: bool LSTRIP_BLOCKS: bool NEWLINE_SEQUENCE: str KEEP_TRAILING_NEWLINE: bool DEFAULT_NAMESPACE: Dict[str, Any] DEFAULT_POLICIES = Dict[str, Any] ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/jinja2/environment.pyi0000664000175000017500000002045500000000000027203 0ustar00davedave00000000000000import sys from typing import Any, Callable, Dict, Iterator, List, Optional, Sequence, Text, Type, Union from .bccache import BytecodeCache from .loaders import BaseLoader from .runtime import Context, Undefined if sys.version_info >= (3, 6): from typing import AsyncIterator, Awaitable def get_spontaneous_environment(*args): ... def create_cache(size): ... def copy_cache(cache): ... def load_extensions(environment, extensions): ... class Environment: sandboxed: bool overlayed: bool linked_to: Any shared: bool exception_handler: Any exception_formatter: Any code_generator_class: Any context_class: Any block_start_string: Text block_end_string: Text variable_start_string: Text variable_end_string: Text comment_start_string: Text comment_end_string: Text line_statement_prefix: Text line_comment_prefix: Text trim_blocks: bool lstrip_blocks: Any newline_sequence: Text keep_trailing_newline: bool undefined: Type[Undefined] optimized: bool finalize: Callable[..., Any] autoescape: Any filters: Any tests: Any globals: Dict[str, Any] loader: BaseLoader cache: Any bytecode_cache: BytecodeCache auto_reload: bool extensions: List[Any] def __init__( self, block_start_string: Text = ..., block_end_string: Text = ..., variable_start_string: Text = ..., variable_end_string: Text = ..., comment_start_string: Any = ..., comment_end_string: Text = ..., line_statement_prefix: Text = ..., line_comment_prefix: Text = ..., trim_blocks: bool = ..., lstrip_blocks: bool = ..., newline_sequence: Text = ..., keep_trailing_newline: bool = ..., extensions: List[Any] = ..., optimized: bool = ..., undefined: Type[Undefined] = ..., finalize: Optional[Callable[..., Any]] = ..., autoescape: Union[bool, Callable[[str], bool]] = ..., loader: Optional[BaseLoader] = ..., cache_size: int = ..., auto_reload: bool = ..., bytecode_cache: Optional[BytecodeCache] = ..., enable_async: bool = ..., ) -> None: ... def add_extension(self, extension): ... def extend(self, **attributes): ... def overlay( self, block_start_string: Text = ..., block_end_string: Text = ..., variable_start_string: Text = ..., variable_end_string: Text = ..., comment_start_string: Any = ..., comment_end_string: Text = ..., line_statement_prefix: Text = ..., line_comment_prefix: Text = ..., trim_blocks: bool = ..., lstrip_blocks: bool = ..., extensions: List[Any] = ..., optimized: bool = ..., undefined: Type[Undefined] = ..., finalize: Callable[..., Any] = ..., autoescape: bool = ..., loader: Optional[BaseLoader] = ..., cache_size: int = ..., auto_reload: bool = ..., bytecode_cache: Optional[BytecodeCache] = ..., ): ... lexer: Any def iter_extensions(self): ... def getitem(self, obj, argument): ... def getattr(self, obj, attribute): ... def call_filter( self, name, value, args: Optional[Any] = ..., kwargs: Optional[Any] = ..., context: Optional[Any] = ..., eval_ctx: Optional[Any] = ..., ): ... def call_test(self, name, value, args: Optional[Any] = ..., kwargs: Optional[Any] = ...): ... def parse(self, source, name: Optional[Any] = ..., filename: Optional[Any] = ...): ... def lex(self, source, name: Optional[Any] = ..., filename: Optional[Any] = ...): ... def preprocess(self, source: Text, name: Optional[Any] = ..., filename: Optional[Any] = ...): ... def compile( self, source, name: Optional[Any] = ..., filename: Optional[Any] = ..., raw: bool = ..., defer_init: bool = ... ): ... def compile_expression(self, source: Text, undefined_to_none: bool = ...): ... def compile_templates( self, target, extensions: Optional[Any] = ..., filter_func: Optional[Any] = ..., zip: str = ..., log_function: Optional[Any] = ..., ignore_errors: bool = ..., py_compile: bool = ..., ): ... def list_templates(self, extensions: Optional[Any] = ..., filter_func: Optional[Any] = ...): ... def handle_exception(self, exc_info: Optional[Any] = ..., rendered: bool = ..., source_hint: Optional[Any] = ...): ... def join_path(self, template: Union[Template, Text], parent: Text) -> Text: ... def get_template( self, name: Union[Template, Text], parent: Optional[Text] = ..., globals: Optional[Any] = ... ) -> Template: ... def select_template( self, names: Sequence[Union[Template, Text]], parent: Optional[Text] = ..., globals: Optional[Dict[str, Any]] = ... ) -> Template: ... def get_or_select_template( self, template_name_or_list: Union[Union[Template, Text], Sequence[Union[Template, Text]]], parent: Optional[Text] = ..., globals: Optional[Dict[str, Any]] = ..., ) -> Template: ... def from_string( self, source: Text, globals: Optional[Dict[str, Any]] = ..., template_class: Optional[Type[Template]] = ... ) -> Template: ... def make_globals(self, d: Optional[Dict[str, Any]]) -> Dict[str, Any]: ... # Frequently added extensions are included here: # from InternationalizationExtension: def install_gettext_translations(self, translations: Any, newstyle: Optional[bool] = ...): ... def install_null_translations(self, newstyle: Optional[bool] = ...): ... def install_gettext_callables( self, gettext: Callable[..., Any], ngettext: Callable[..., Any], newstyle: Optional[bool] = ... ): ... def uninstall_gettext_translations(self, translations: Any): ... def extract_translations(self, source: Any, gettext_functions: Any): ... newstyle_gettext: bool class Template: name: Optional[str] filename: Optional[str] def __new__( cls, source, block_start_string: Any = ..., block_end_string: Any = ..., variable_start_string: Any = ..., variable_end_string: Any = ..., comment_start_string: Any = ..., comment_end_string: Any = ..., line_statement_prefix: Any = ..., line_comment_prefix: Any = ..., trim_blocks: Any = ..., lstrip_blocks: Any = ..., newline_sequence: Any = ..., keep_trailing_newline: Any = ..., extensions: Any = ..., optimized: bool = ..., undefined: Any = ..., finalize: Optional[Any] = ..., autoescape: bool = ..., ): ... environment: Environment = ... @classmethod def from_code(cls, environment, code, globals, uptodate: Optional[Any] = ...): ... @classmethod def from_module_dict(cls, environment, module_dict, globals): ... def render(self, *args, **kwargs) -> Text: ... def stream(self, *args, **kwargs) -> TemplateStream: ... def generate(self, *args, **kwargs) -> Iterator[Text]: ... def new_context( self, vars: Optional[Dict[str, Any]] = ..., shared: bool = ..., locals: Optional[Dict[str, Any]] = ... ) -> Context: ... def make_module( self, vars: Optional[Dict[str, Any]] = ..., shared: bool = ..., locals: Optional[Dict[str, Any]] = ... ) -> Context: ... @property def module(self) -> Any: ... def get_corresponding_lineno(self, lineno): ... @property def is_up_to_date(self) -> bool: ... @property def debug_info(self): ... if sys.version_info >= (3, 6): def render_async(self, *args, **kwargs) -> Awaitable[Text]: ... def generate_async(self, *args, **kwargs) -> AsyncIterator[Text]: ... class TemplateModule: __name__: Any def __init__(self, template, context) -> None: ... def __html__(self): ... class TemplateExpression: def __init__(self, template, undefined_to_none) -> None: ... def __call__(self, *args, **kwargs): ... class TemplateStream: def __init__(self, gen) -> None: ... def dump(self, fp, encoding: Optional[Text] = ..., errors: Text = ...): ... buffered: bool def disable_buffering(self) -> None: ... def enable_buffering(self, size: int = ...) -> None: ... def __iter__(self): ... def __next__(self): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/jinja2/exceptions.pyi0000664000175000017500000000203200000000000027007 0ustar00davedave00000000000000from typing import Any, Optional, Text class TemplateError(Exception): def __init__(self, message: Optional[Text] = ...) -> None: ... @property def message(self): ... def __unicode__(self): ... class TemplateNotFound(IOError, LookupError, TemplateError): message: Any name: Any templates: Any def __init__(self, name, message: Optional[Text] = ...) -> None: ... class TemplatesNotFound(TemplateNotFound): templates: Any def __init__(self, names: Any = ..., message: Optional[Text] = ...) -> None: ... class TemplateSyntaxError(TemplateError): lineno: int name: Text filename: Text source: Text translated: bool def __init__(self, message: Text, lineno: int, name: Optional[Text] = ..., filename: Optional[Text] = ...) -> None: ... class TemplateAssertionError(TemplateSyntaxError): ... class TemplateRuntimeError(TemplateError): ... class UndefinedError(TemplateRuntimeError): ... class SecurityError(TemplateRuntimeError): ... class FilterArgumentError(TemplateRuntimeError): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/jinja2/ext.pyi0000664000175000017500000000322400000000000025432 0ustar00davedave00000000000000from typing import Any, Optional GETTEXT_FUNCTIONS: Any class ExtensionRegistry(type): def __new__(cls, name, bases, d): ... class Extension: tags: Any priority: int environment: Any def __init__(self, environment) -> None: ... def bind(self, environment): ... def preprocess(self, source, name, filename: Optional[Any] = ...): ... def filter_stream(self, stream): ... def parse(self, parser): ... def attr(self, name, lineno: Optional[Any] = ...): ... def call_method( self, name, args: Optional[Any] = ..., kwargs: Optional[Any] = ..., dyn_args: Optional[Any] = ..., dyn_kwargs: Optional[Any] = ..., lineno: Optional[Any] = ..., ): ... class InternationalizationExtension(Extension): tags: Any def __init__(self, environment) -> None: ... def parse(self, parser): ... class ExprStmtExtension(Extension): tags: Any def parse(self, parser): ... class LoopControlExtension(Extension): tags: Any def parse(self, parser): ... class WithExtension(Extension): tags: Any def parse(self, parser): ... class AutoEscapeExtension(Extension): tags: Any def parse(self, parser): ... def extract_from_ast(node, gettext_functions: Any = ..., babel_style: bool = ...): ... class _CommentFinder: tokens: Any comment_tags: Any offset: int last_lineno: int def __init__(self, tokens, comment_tags) -> None: ... def find_backwards(self, offset): ... def find_comments(self, lineno): ... def babel_extract(fileobj, keywords, comment_tags, options): ... i18n: Any do: Any loopcontrols: Any with_: Any autoescape: Any ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/jinja2/filters.pyi0000664000175000017500000000457100000000000026310 0ustar00davedave00000000000000from typing import Any, NamedTuple, Optional def contextfilter(f): ... def evalcontextfilter(f): ... def environmentfilter(f): ... def make_attrgetter(environment, attribute): ... def do_forceescape(value): ... def do_urlencode(value): ... def do_replace(eval_ctx, s, old, new, count: Optional[Any] = ...): ... def do_upper(s): ... def do_lower(s): ... def do_xmlattr(_eval_ctx, d, autospace: bool = ...): ... def do_capitalize(s): ... def do_title(s): ... def do_dictsort(value, case_sensitive: bool = ..., by: str = ...): ... def do_sort(environment, value, reverse: bool = ..., case_sensitive: bool = ..., attribute: Optional[Any] = ...): ... def do_default(value, default_value: str = ..., boolean: bool = ...): ... def do_join(eval_ctx, value, d: str = ..., attribute: Optional[Any] = ...): ... def do_center(value, width: int = ...): ... def do_first(environment, seq): ... def do_last(environment, seq): ... def do_random(environment, seq): ... def do_filesizeformat(value, binary: bool = ...): ... def do_pprint(value, verbose: bool = ...): ... def do_urlize(eval_ctx, value, trim_url_limit: Optional[Any] = ..., nofollow: bool = ..., target: Optional[Any] = ...): ... def do_indent(s, width: int = ..., indentfirst: bool = ...): ... def do_truncate(s, length: int = ..., killwords: bool = ..., end: str = ...): ... def do_wordwrap(environment, s, width: int = ..., break_long_words: bool = ..., wrapstring: Optional[Any] = ...): ... def do_wordcount(s): ... def do_int(value, default: int = ..., base: int = ...): ... def do_float(value, default: float = ...): ... def do_format(value, *args, **kwargs): ... def do_trim(value): ... def do_striptags(value): ... def do_slice(value, slices, fill_with: Optional[Any] = ...): ... def do_batch(value, linecount, fill_with: Optional[Any] = ...): ... def do_round(value, precision: int = ..., method: str = ...): ... def do_groupby(environment, value, attribute): ... class _GroupTuple(NamedTuple): grouper: Any list: Any def do_sum(environment, iterable, attribute: Optional[Any] = ..., start: int = ...): ... def do_list(value): ... def do_mark_safe(value): ... def do_mark_unsafe(value): ... def do_reverse(value): ... def do_attr(environment, obj, name): ... def do_map(*args, **kwargs): ... def do_select(*args, **kwargs): ... def do_reject(*args, **kwargs): ... def do_selectattr(*args, **kwargs): ... def do_rejectattr(*args, **kwargs): ... FILTERS: Any ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/jinja2/lexer.pyi0000664000175000017500000000531400000000000025753 0ustar00davedave00000000000000from typing import Any, Optional, Tuple whitespace_re: Any string_re: Any integer_re: Any name_re: Any float_re: Any newline_re: Any TOKEN_ADD: Any TOKEN_ASSIGN: Any TOKEN_COLON: Any TOKEN_COMMA: Any TOKEN_DIV: Any TOKEN_DOT: Any TOKEN_EQ: Any TOKEN_FLOORDIV: Any TOKEN_GT: Any TOKEN_GTEQ: Any TOKEN_LBRACE: Any TOKEN_LBRACKET: Any TOKEN_LPAREN: Any TOKEN_LT: Any TOKEN_LTEQ: Any TOKEN_MOD: Any TOKEN_MUL: Any TOKEN_NE: Any TOKEN_PIPE: Any TOKEN_POW: Any TOKEN_RBRACE: Any TOKEN_RBRACKET: Any TOKEN_RPAREN: Any TOKEN_SEMICOLON: Any TOKEN_SUB: Any TOKEN_TILDE: Any TOKEN_WHITESPACE: Any TOKEN_FLOAT: Any TOKEN_INTEGER: Any TOKEN_NAME: Any TOKEN_STRING: Any TOKEN_OPERATOR: Any TOKEN_BLOCK_BEGIN: Any TOKEN_BLOCK_END: Any TOKEN_VARIABLE_BEGIN: Any TOKEN_VARIABLE_END: Any TOKEN_RAW_BEGIN: Any TOKEN_RAW_END: Any TOKEN_COMMENT_BEGIN: Any TOKEN_COMMENT_END: Any TOKEN_COMMENT: Any TOKEN_LINESTATEMENT_BEGIN: Any TOKEN_LINESTATEMENT_END: Any TOKEN_LINECOMMENT_BEGIN: Any TOKEN_LINECOMMENT_END: Any TOKEN_LINECOMMENT: Any TOKEN_DATA: Any TOKEN_INITIAL: Any TOKEN_EOF: Any operators: Any reverse_operators: Any operator_re: Any ignored_tokens: Any ignore_if_empty: Any def describe_token(token): ... def describe_token_expr(expr): ... def count_newlines(value): ... def compile_rules(environment): ... class Failure: message: Any error_class: Any def __init__(self, message, cls: Any = ...) -> None: ... def __call__(self, lineno, filename): ... class Token(Tuple[int, Any, Any]): lineno: Any type: Any value: Any def __new__(cls, lineno, type, value): ... def test(self, expr): ... def test_any(self, *iterable): ... class TokenStreamIterator: stream: Any def __init__(self, stream) -> None: ... def __iter__(self): ... def __next__(self): ... class TokenStream: name: Any filename: Any closed: bool current: Any def __init__(self, generator, name, filename) -> None: ... def __iter__(self): ... def __bool__(self): ... __nonzero__: Any eos: Any def push(self, token): ... def look(self): ... def skip(self, n: int = ...): ... def next_if(self, expr): ... def skip_if(self, expr): ... def __next__(self): ... def close(self): ... def expect(self, expr): ... def get_lexer(environment): ... class Lexer: newline_sequence: Any keep_trailing_newline: Any rules: Any def __init__(self, environment) -> None: ... def tokenize(self, source, name: Optional[Any] = ..., filename: Optional[Any] = ..., state: Optional[Any] = ...): ... def wrap(self, stream, name: Optional[Any] = ..., filename: Optional[Any] = ...): ... def tokeniter(self, source, name, filename: Optional[Any] = ..., state: Optional[Any] = ...): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/jinja2/loaders.pyi0000664000175000017500000000555300000000000026272 0ustar00davedave00000000000000import sys from types import ModuleType from typing import Any, Callable, Iterable, List, Optional, Text, Tuple, Union from .environment import Environment if sys.version_info >= (3, 7): from os import PathLike _SearchPath = Union[Text, PathLike[str], Iterable[Union[Text, PathLike[str]]]] else: _SearchPath = Union[Text, Iterable[Text]] def split_template_path(template: Text) -> List[Text]: ... class BaseLoader: has_source_access: bool def get_source(self, environment, template): ... def list_templates(self): ... def load(self, environment, name, globals: Optional[Any] = ...): ... class FileSystemLoader(BaseLoader): searchpath: Text encoding: Any followlinks: Any def __init__(self, searchpath: _SearchPath, encoding: Text = ..., followlinks: bool = ...) -> None: ... def get_source(self, environment: Environment, template: Text) -> Tuple[Text, Text, Callable[..., Any]]: ... def list_templates(self): ... class PackageLoader(BaseLoader): encoding: Text manager: Any filesystem_bound: Any provider: Any package_path: Any def __init__(self, package_name: Text, package_path: Text = ..., encoding: Text = ...) -> None: ... def get_source(self, environment: Environment, template: Text) -> Tuple[Text, Text, Callable[..., Any]]: ... def list_templates(self): ... class DictLoader(BaseLoader): mapping: Any def __init__(self, mapping) -> None: ... def get_source(self, environment: Environment, template: Text) -> Tuple[Text, Text, Callable[..., Any]]: ... def list_templates(self): ... class FunctionLoader(BaseLoader): load_func: Any def __init__(self, load_func) -> None: ... def get_source( self, environment: Environment, template: Text ) -> Tuple[Text, Optional[Text], Optional[Callable[..., Any]]]: ... class PrefixLoader(BaseLoader): mapping: Any delimiter: Any def __init__(self, mapping, delimiter: str = ...) -> None: ... def get_loader(self, template): ... def get_source(self, environment: Environment, template: Text) -> Tuple[Text, Text, Callable[..., Any]]: ... def load(self, environment, name, globals: Optional[Any] = ...): ... def list_templates(self): ... class ChoiceLoader(BaseLoader): loaders: Any def __init__(self, loaders) -> None: ... def get_source(self, environment: Environment, template: Text) -> Tuple[Text, Text, Callable[..., Any]]: ... def load(self, environment, name, globals: Optional[Any] = ...): ... def list_templates(self): ... class _TemplateModule(ModuleType): ... class ModuleLoader(BaseLoader): has_source_access: bool module: Any package_name: Any def __init__(self, path) -> None: ... @staticmethod def get_template_key(name): ... @staticmethod def get_module_filename(name): ... def load(self, environment, name, globals: Optional[Any] = ...): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/jinja2/meta.pyi0000664000175000017500000000052300000000000025557 0ustar00davedave00000000000000from typing import Any from jinja2.compiler import CodeGenerator class TrackingCodeGenerator(CodeGenerator): undeclared_identifiers: Any def __init__(self, environment) -> None: ... def write(self, x): ... def pull_locals(self, frame): ... def find_undeclared_variables(ast): ... def find_referenced_templates(ast): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/jinja2/nodes.pyi0000664000175000017500000001222700000000000025745 0ustar00davedave00000000000000import typing from typing import Any, Optional class Impossible(Exception): ... class NodeType(type): def __new__(cls, name, bases, d): ... class EvalContext: environment: Any autoescape: Any volatile: bool def __init__(self, environment, template_name: Optional[Any] = ...) -> None: ... def save(self): ... def revert(self, old): ... def get_eval_context(node, ctx): ... class Node: fields: Any attributes: Any abstract: bool def __init__(self, *fields, **attributes) -> None: ... def iter_fields(self, exclude: Optional[Any] = ..., only: Optional[Any] = ...): ... def iter_child_nodes(self, exclude: Optional[Any] = ..., only: Optional[Any] = ...): ... def find(self, node_type): ... def find_all(self, node_type): ... def set_ctx(self, ctx): ... def set_lineno(self, lineno, override: bool = ...): ... def set_environment(self, environment): ... def __eq__(self, other): ... def __ne__(self, other): ... __hash__: Any class Stmt(Node): abstract: bool class Helper(Node): abstract: bool class Template(Node): fields: Any class Output(Stmt): fields: Any class Extends(Stmt): fields: Any class For(Stmt): fields: Any class If(Stmt): fields: Any class Macro(Stmt): fields: Any name: str args: typing.List[Any] defaults: typing.List[Any] body: typing.List[Any] class CallBlock(Stmt): fields: Any class FilterBlock(Stmt): fields: Any class Block(Stmt): fields: Any class Include(Stmt): fields: Any class Import(Stmt): fields: Any class FromImport(Stmt): fields: Any class ExprStmt(Stmt): fields: Any class Assign(Stmt): fields: Any class AssignBlock(Stmt): fields: Any class Expr(Node): abstract: bool def as_const(self, eval_ctx: Optional[Any] = ...): ... def can_assign(self): ... class BinExpr(Expr): fields: Any operator: Any abstract: bool def as_const(self, eval_ctx: Optional[Any] = ...): ... class UnaryExpr(Expr): fields: Any operator: Any abstract: bool def as_const(self, eval_ctx: Optional[Any] = ...): ... class Name(Expr): fields: Any def can_assign(self): ... class Literal(Expr): abstract: bool class Const(Literal): fields: Any def as_const(self, eval_ctx: Optional[Any] = ...): ... @classmethod def from_untrusted(cls, value, lineno: Optional[Any] = ..., environment: Optional[Any] = ...): ... class TemplateData(Literal): fields: Any def as_const(self, eval_ctx: Optional[Any] = ...): ... class Tuple(Literal): fields: Any def as_const(self, eval_ctx: Optional[Any] = ...): ... def can_assign(self): ... class List(Literal): fields: Any def as_const(self, eval_ctx: Optional[Any] = ...): ... class Dict(Literal): fields: Any def as_const(self, eval_ctx: Optional[Any] = ...): ... class Pair(Helper): fields: Any def as_const(self, eval_ctx: Optional[Any] = ...): ... class Keyword(Helper): fields: Any def as_const(self, eval_ctx: Optional[Any] = ...): ... class CondExpr(Expr): fields: Any def as_const(self, eval_ctx: Optional[Any] = ...): ... class Filter(Expr): fields: Any def as_const(self, eval_ctx: Optional[Any] = ...): ... class Test(Expr): fields: Any class Call(Expr): fields: Any def as_const(self, eval_ctx: Optional[Any] = ...): ... class Getitem(Expr): fields: Any def as_const(self, eval_ctx: Optional[Any] = ...): ... def can_assign(self): ... class Getattr(Expr): fields: Any def as_const(self, eval_ctx: Optional[Any] = ...): ... def can_assign(self): ... class Slice(Expr): fields: Any def as_const(self, eval_ctx: Optional[Any] = ...): ... class Concat(Expr): fields: Any def as_const(self, eval_ctx: Optional[Any] = ...): ... class Compare(Expr): fields: Any def as_const(self, eval_ctx: Optional[Any] = ...): ... class Operand(Helper): fields: Any class Mul(BinExpr): operator: str class Div(BinExpr): operator: str class FloorDiv(BinExpr): operator: str class Add(BinExpr): operator: str class Sub(BinExpr): operator: str class Mod(BinExpr): operator: str class Pow(BinExpr): operator: str class And(BinExpr): operator: str def as_const(self, eval_ctx: Optional[Any] = ...): ... class Or(BinExpr): operator: str def as_const(self, eval_ctx: Optional[Any] = ...): ... class Not(UnaryExpr): operator: str class Neg(UnaryExpr): operator: str class Pos(UnaryExpr): operator: str class EnvironmentAttribute(Expr): fields: Any class ExtensionAttribute(Expr): fields: Any class ImportedName(Expr): fields: Any class InternalName(Expr): fields: Any def __init__(self) -> None: ... class MarkSafe(Expr): fields: Any def as_const(self, eval_ctx: Optional[Any] = ...): ... class MarkSafeIfAutoescape(Expr): fields: Any def as_const(self, eval_ctx: Optional[Any] = ...): ... class ContextReference(Expr): ... class Continue(Stmt): ... class Break(Stmt): ... class Scope(Stmt): fields: Any class EvalContextModifier(Stmt): fields: Any class ScopedEvalContextModifier(EvalContextModifier): fields: Any ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/jinja2/optimizer.pyi0000664000175000017500000000122500000000000026653 0ustar00davedave00000000000000from typing import Any from jinja2.visitor import NodeTransformer def optimize(node, environment): ... class Optimizer(NodeTransformer): environment: Any def __init__(self, environment) -> None: ... def visit_If(self, node): ... def fold(self, node): ... visit_Add: Any visit_Sub: Any visit_Mul: Any visit_Div: Any visit_FloorDiv: Any visit_Pow: Any visit_Mod: Any visit_And: Any visit_Or: Any visit_Pos: Any visit_Neg: Any visit_Not: Any visit_Compare: Any visit_Getitem: Any visit_Getattr: Any visit_Call: Any visit_Filter: Any visit_Test: Any visit_CondExpr: Any ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/jinja2/parser.pyi0000664000175000017500000000502000000000000026122 0ustar00davedave00000000000000from typing import Any, Optional class Parser: environment: Any stream: Any name: Any filename: Any closed: bool extensions: Any def __init__( self, environment, source, name: Optional[Any] = ..., filename: Optional[Any] = ..., state: Optional[Any] = ... ) -> None: ... def fail(self, msg, lineno: Optional[Any] = ..., exc: Any = ...): ... def fail_unknown_tag(self, name, lineno: Optional[Any] = ...): ... def fail_eof(self, end_tokens: Optional[Any] = ..., lineno: Optional[Any] = ...): ... def is_tuple_end(self, extra_end_rules: Optional[Any] = ...): ... def free_identifier(self, lineno: Optional[Any] = ...): ... def parse_statement(self): ... def parse_statements(self, end_tokens, drop_needle: bool = ...): ... def parse_set(self): ... def parse_for(self): ... def parse_if(self): ... def parse_block(self): ... def parse_extends(self): ... def parse_import_context(self, node, default): ... def parse_include(self): ... def parse_import(self): ... def parse_from(self): ... def parse_signature(self, node): ... def parse_call_block(self): ... def parse_filter_block(self): ... def parse_macro(self): ... def parse_print(self): ... def parse_assign_target(self, with_tuple: bool = ..., name_only: bool = ..., extra_end_rules: Optional[Any] = ...): ... def parse_expression(self, with_condexpr: bool = ...): ... def parse_condexpr(self): ... def parse_or(self): ... def parse_and(self): ... def parse_not(self): ... def parse_compare(self): ... def parse_add(self): ... def parse_sub(self): ... def parse_concat(self): ... def parse_mul(self): ... def parse_div(self): ... def parse_floordiv(self): ... def parse_mod(self): ... def parse_pow(self): ... def parse_unary(self, with_filter: bool = ...): ... def parse_primary(self): ... def parse_tuple( self, simplified: bool = ..., with_condexpr: bool = ..., extra_end_rules: Optional[Any] = ..., explicit_parentheses: bool = ..., ): ... def parse_list(self): ... def parse_dict(self): ... def parse_postfix(self, node): ... def parse_filter_expr(self, node): ... def parse_subscript(self, node): ... def parse_subscribed(self): ... def parse_call(self, node): ... def parse_filter(self, node, start_inline: bool = ...): ... def parse_test(self, node): ... def subparse(self, end_tokens: Optional[Any] = ...): ... def parse(self): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/jinja2/runtime.pyi0000664000175000017500000000660700000000000026325 0ustar00davedave00000000000000from typing import Any, Dict, Optional, Text, Union from jinja2.environment import Environment from jinja2.exceptions import TemplateNotFound as TemplateNotFound, TemplateRuntimeError as TemplateRuntimeError from jinja2.utils import Markup as Markup, concat as concat, escape as escape, missing as missing to_string: Any identity: Any def markup_join(seq): ... def unicode_join(seq): ... class TemplateReference: def __init__(self, context) -> None: ... def __getitem__(self, name): ... class Context: parent: Union[Context, Dict[str, Any]] vars: Dict[str, Any] environment: Environment eval_ctx: Any exported_vars: Any name: Text blocks: Dict[str, Any] def __init__( self, environment: Environment, parent: Union[Context, Dict[str, Any]], name: Text, blocks: Dict[str, Any] ) -> None: ... def super(self, name, current): ... def get(self, key, default: Optional[Any] = ...): ... def resolve(self, key): ... def get_exported(self): ... def get_all(self): ... def call(__self, __obj, *args, **kwargs): ... def derived(self, locals: Optional[Any] = ...): ... keys: Any values: Any items: Any iterkeys: Any itervalues: Any iteritems: Any def __contains__(self, name): ... def __getitem__(self, key): ... class BlockReference: name: Any def __init__(self, name, context, stack, depth) -> None: ... @property def super(self): ... def __call__(self): ... class LoopContext: index0: int depth0: Any def __init__(self, iterable, recurse: Optional[Any] = ..., depth0: int = ...) -> None: ... def cycle(self, *args): ... first: Any last: Any index: Any revindex: Any revindex0: Any depth: Any def __len__(self): ... def __iter__(self): ... def loop(self, iterable): ... __call__: Any @property def length(self): ... class LoopContextIterator: context: Any def __init__(self, context) -> None: ... def __iter__(self): ... def __next__(self): ... class Macro: name: Any arguments: Any defaults: Any catch_kwargs: Any catch_varargs: Any caller: Any def __init__(self, environment, func, name, arguments, defaults, catch_kwargs, catch_varargs, caller) -> None: ... def __call__(self, *args, **kwargs): ... class Undefined: def __init__(self, hint: Optional[Any] = ..., obj: Any = ..., name: Optional[Any] = ..., exc: Any = ...) -> None: ... def __getattr__(self, name): ... __add__: Any __radd__: Any __mul__: Any __rmul__: Any __div__: Any __rdiv__: Any __truediv__: Any __rtruediv__: Any __floordiv__: Any __rfloordiv__: Any __mod__: Any __rmod__: Any __pos__: Any __neg__: Any __call__: Any __getitem__: Any __lt__: Any __le__: Any __gt__: Any __ge__: Any __int__: Any __float__: Any __complex__: Any __pow__: Any __rpow__: Any def __eq__(self, other): ... def __ne__(self, other): ... def __hash__(self): ... def __len__(self): ... def __iter__(self): ... def __nonzero__(self): ... __bool__: Any def make_logging_undefined(logger: Optional[Any] = ..., base: Optional[Any] = ...): ... class DebugUndefined(Undefined): ... class StrictUndefined(Undefined): __iter__: Any __len__: Any __nonzero__: Any __eq__: Any __ne__: Any __bool__: Any __hash__: Any ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/jinja2/sandbox.pyi0000664000175000017500000000217200000000000026271 0ustar00davedave00000000000000from typing import Any from jinja2.environment import Environment MAX_RANGE: int UNSAFE_FUNCTION_ATTRIBUTES: Any UNSAFE_METHOD_ATTRIBUTES: Any UNSAFE_GENERATOR_ATTRIBUTES: Any def safe_range(*args): ... def unsafe(f): ... def is_internal_attribute(obj, attr): ... def modifies_known_mutable(obj, attr): ... class SandboxedEnvironment(Environment): sandboxed: bool default_binop_table: Any default_unop_table: Any intercepted_binops: Any intercepted_unops: Any def intercept_unop(self, operator): ... binop_table: Any unop_table: Any def __init__(self, *args, **kwargs) -> None: ... def is_safe_attribute(self, obj, attr, value): ... def is_safe_callable(self, obj): ... def call_binop(self, context, operator, left, right): ... def call_unop(self, context, operator, arg): ... def getitem(self, obj, argument): ... def getattr(self, obj, attribute): ... def unsafe_undefined(self, obj, attribute): ... def call(__self, __context, __obj, *args, **kwargs): ... class ImmutableSandboxedEnvironment(SandboxedEnvironment): def is_safe_attribute(self, obj, attr, value): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/jinja2/tests.pyi0000664000175000017500000000106100000000000025771 0ustar00davedave00000000000000from typing import Any number_re: Any regex_type: Any test_callable: Any def test_odd(value): ... def test_even(value): ... def test_divisibleby(value, num): ... def test_defined(value): ... def test_undefined(value): ... def test_none(value): ... def test_lower(value): ... def test_upper(value): ... def test_string(value): ... def test_mapping(value): ... def test_number(value): ... def test_sequence(value): ... def test_equalto(value, other): ... def test_sameas(value, other): ... def test_iterable(value): ... def test_escaped(value): ... TESTS: Any ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/jinja2/utils.pyi0000664000175000017500000000561500000000000026000 0ustar00davedave00000000000000from _typeshed import AnyPath from typing import IO, Any, Callable, Iterable, Optional, Protocol, Text, TypeVar, Union from typing_extensions import Literal from markupsafe import Markup as Markup, escape as escape, soft_unicode as soft_unicode missing: Any internal_code: Any concat: Any _CallableT = TypeVar("_CallableT", bound=Callable[..., Any]) class _ContextFunction(Protocol[_CallableT]): contextfunction: Literal[True] __call__: _CallableT class _EvalContextFunction(Protocol[_CallableT]): evalcontextfunction: Literal[True] __call__: _CallableT class _EnvironmentFunction(Protocol[_CallableT]): environmentfunction: Literal[True] __call__: _CallableT def contextfunction(f: _CallableT) -> _ContextFunction[_CallableT]: ... def evalcontextfunction(f: _CallableT) -> _EvalContextFunction[_CallableT]: ... def environmentfunction(f: _CallableT) -> _EnvironmentFunction[_CallableT]: ... def internalcode(f: _CallableT) -> _CallableT: ... def is_undefined(obj: object) -> bool: ... def select_autoescape( enabled_extensions: Iterable[str] = ..., disabled_extensions: Iterable[str] = ..., default_for_string: bool = ..., default: bool = ..., ) -> Callable[[str], bool]: ... def consume(iterable: Iterable[object]) -> None: ... def clear_caches() -> None: ... def import_string(import_name: str, silent: bool = ...) -> Any: ... def open_if_exists(filename: AnyPath, mode: str = ...) -> Optional[IO[Any]]: ... def object_type_repr(obj: object) -> str: ... def pformat(obj: object, verbose: bool = ...) -> str: ... def urlize( text: Union[Markup, Text], trim_url_limit: Optional[int] = ..., rel: Optional[Union[Markup, Text]] = ..., target: Optional[Union[Markup, Text]] = ..., ) -> str: ... def generate_lorem_ipsum(n: int = ..., html: bool = ..., min: int = ..., max: int = ...) -> Union[Markup, str]: ... def unicode_urlencode(obj: object, charset: str = ..., for_qs: bool = ...) -> str: ... class LRUCache: capacity: Any def __init__(self, capacity) -> None: ... def __getnewargs__(self): ... def copy(self): ... def get(self, key, default: Optional[Any] = ...): ... def setdefault(self, key, default: Optional[Any] = ...): ... def clear(self): ... def __contains__(self, key): ... def __len__(self): ... def __getitem__(self, key): ... def __setitem__(self, key, value): ... def __delitem__(self, key): ... def items(self): ... def iteritems(self): ... def values(self): ... def itervalue(self): ... def keys(self): ... def iterkeys(self): ... __iter__: Any def __reversed__(self): ... __copy__: Any class Cycler: items: Any def __init__(self, *items) -> None: ... pos: int def reset(self): ... @property def current(self): ... def __next__(self): ... class Joiner: sep: Any used: bool def __init__(self, sep: str = ...) -> None: ... def __call__(self): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/jinja2/visitor.pyi0000664000175000017500000000046200000000000026332 0ustar00davedave00000000000000class NodeVisitor: def get_visitor(self, node): ... def visit(self, node, *args, **kwargs): ... def generic_visit(self, node, *args, **kwargs): ... class NodeTransformer(NodeVisitor): def generic_visit(self, node, *args, **kwargs): ... def visit_list(self, node, *args, **kwargs): ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4503794 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/markdown/0000775000175000017500000000000000000000000024553 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/markdown/__init__.pyi0000664000175000017500000000022200000000000027031 0ustar00davedave00000000000000from .core import Markdown as Markdown, markdown as markdown, markdownFromFile as markdownFromFile from .extensions import Extension as Extension ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/markdown/__meta__.pyi0000664000175000017500000000005600000000000027021 0ustar00davedave00000000000000from typing import Any __version_info__: Any ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/markdown/blockparser.pyi0000664000175000017500000000071700000000000027612 0ustar00davedave00000000000000from typing import Any class State(list): def set(self, state) -> None: ... def reset(self) -> None: ... def isstate(self, state): ... class BlockParser: blockprocessors: Any state: Any md: Any def __init__(self, md) -> None: ... @property def markdown(self): ... root: Any def parseDocument(self, lines): ... def parseChunk(self, parent, text) -> None: ... def parseBlocks(self, parent, blocks) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/markdown/blockprocessors.pyi0000664000175000017500000000272200000000000030516 0ustar00davedave00000000000000from typing import Any, Pattern logger: Any def build_block_parser(md, **kwargs): ... class BlockProcessor: parser: Any tab_length: Any def __init__(self, parser) -> None: ... def lastChild(self, parent): ... def detab(self, text): ... def looseDetab(self, text, level: int = ...): ... def test(self, parent, block) -> None: ... def run(self, parent, blocks) -> None: ... class ListIndentProcessor(BlockProcessor): ITEM_TYPES: Any LIST_TYPES: Any INDENT_RE: Pattern def __init__(self, *args) -> None: ... def create_item(self, parent, block) -> None: ... def get_level(self, parent, block): ... class CodeBlockProcessor(BlockProcessor): ... class BlockQuoteProcessor(BlockProcessor): RE: Pattern def clean(self, line): ... class OListProcessor(BlockProcessor): TAG: str = ... STARTSWITH: str = ... LAZY_OL: bool = ... SIBLING_TAGS: Any RE: Pattern CHILD_RE: Pattern INDENT_RE: Pattern def __init__(self, parser) -> None: ... def get_items(self, block): ... class UListProcessor(OListProcessor): TAG: str = ... RE: Pattern def __init__(self, parser) -> None: ... class HashHeaderProcessor(BlockProcessor): RE: Pattern class SetextHeaderProcessor(BlockProcessor): RE: Pattern class HRProcessor(BlockProcessor): RE: str = ... SEARCH_RE: Pattern match: Any class EmptyBlockProcessor(BlockProcessor): ... class ParagraphProcessor(BlockProcessor): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/markdown/core.pyi0000664000175000017500000000477300000000000026241 0ustar00davedave00000000000000from typing import Any, BinaryIO, Callable, ClassVar, Dict, List, Mapping, Optional, Sequence, Text, TextIO, Union from typing_extensions import Literal from xml.etree.ElementTree import Element from .blockparser import BlockParser from .extensions import Extension from .util import HtmlStash, Registry class Markdown: preprocessors: Registry inlinePatterns: Registry treeprocessors: Registry postprocessors: Registry parser: BlockParser htmlStash: HtmlStash output_formats: ClassVar[Dict[Literal["xhtml", "html"], Callable[[Element], Text]]] output_format: Literal["xhtml", "html"] serializer: Callable[[Element], Text] tab_length: int block_level_elements: List[str] def __init__( self, *, extensions: Optional[Sequence[Union[str, Extension]]] = ..., extension_configs: Optional[Mapping[str, Mapping[str, Any]]] = ..., output_format: Optional[Literal["xhtml", "html"]] = ..., tab_length: Optional[int] = ..., ) -> None: ... def build_parser(self) -> Markdown: ... def registerExtensions( self, extensions: Sequence[Union[Extension, str]], configs: Mapping[str, Mapping[str, Any]] ) -> Markdown: ... def build_extension(self, ext_name: Text, configs: Mapping[str, str]) -> Extension: ... def registerExtension(self, extension: Extension) -> Markdown: ... def reset(self: Markdown) -> Markdown: ... def set_output_format(self, format: Literal["xhtml", "html"]) -> Markdown: ... def is_block_level(self, tag: str) -> bool: ... def convert(self, source: Text) -> Text: ... def convertFile( self, input: Optional[Union[str, TextIO, BinaryIO]] = ..., output: Optional[Union[str, TextIO, BinaryIO]] = ..., encoding: Optional[str] = ..., ) -> Markdown: ... def markdown( text: Text, *, extensions: Optional[Sequence[Union[str, Extension]]] = ..., extension_configs: Optional[Mapping[str, Mapping[str, Any]]] = ..., output_format: Optional[Literal["xhtml", "html"]] = ..., tab_length: Optional[int] = ..., ) -> Text: ... def markdownFromFile( *, input: Optional[Union[str, TextIO, BinaryIO]] = ..., output: Optional[Union[str, TextIO, BinaryIO]] = ..., encoding: Optional[str] = ..., extensions: Optional[Sequence[Union[str, Extension]]] = ..., extension_configs: Optional[Mapping[str, Mapping[str, Any]]] = ..., output_format: Optional[Literal["xhtml", "html"]] = ..., tab_length: Optional[int] = ..., ) -> None: ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4503794 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/markdown/extensions/0000775000175000017500000000000000000000000026752 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/markdown/extensions/__init__.pyi0000664000175000017500000000104500000000000031234 0ustar00davedave00000000000000from typing import Any, Dict, List, Mapping, Tuple from markdown.core import Markdown class Extension: config: Mapping[str, List[Any]] = ... def __init__(self, **kwargs: Any) -> None: ... def getConfig(self, key: str, default: Any = ...) -> Any: ... def getConfigs(self) -> Dict[str, Any]: ... def getConfigInfo(self) -> List[Tuple[str, str]]: ... def setConfig(self, key: str, value: Any) -> None: ... def setConfigs(self, items: Mapping[str, Any]) -> None: ... def extendMarkdown(self, md: Markdown) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/markdown/extensions/abbr.pyi0000664000175000017500000000065400000000000030410 0ustar00davedave00000000000000from typing import Any, Pattern from markdown.blockprocessors import BlockProcessor from markdown.extensions import Extension from markdown.inlinepatterns import InlineProcessor ABBR_REF_RE: Pattern class AbbrExtension(Extension): ... class AbbrPreprocessor(BlockProcessor): ... class AbbrInlineProcessor(InlineProcessor): title: Any def __init__(self, pattern, title) -> None: ... def makeExtension(**kwargs): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/markdown/extensions/admonition.pyi0000664000175000017500000000060100000000000031633 0ustar00davedave00000000000000from typing import Any, Pattern from markdown.blockprocessors import BlockProcessor from markdown.extensions import Extension class AdmonitionExtension(Extension): ... class AdmonitionProcessor(BlockProcessor): CLASSNAME: str = ... CLASSNAME_TITLE: str = ... RE: Pattern RE_SPACES: Any def get_class_and_title(self, match): ... def makeExtension(**kwargs): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/markdown/extensions/attr_list.pyi0000664000175000017500000000076200000000000031507 0ustar00davedave00000000000000from typing import Any, Pattern from markdown.extensions import Extension from markdown.treeprocessors import Treeprocessor def get_attrs(str): ... def isheader(elem): ... class AttrListTreeprocessor(Treeprocessor): BASE_RE: str = ... HEADER_RE: Pattern BLOCK_RE: Pattern INLINE_RE: Pattern NAME_RE: Pattern def assign_attrs(self, elem, attrs) -> None: ... def sanitize_name(self, name): ... class AttrListExtension(Extension): ... def makeExtension(**kwargs): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/markdown/extensions/codehilite.pyi0000664000175000017500000000172300000000000031611 0ustar00davedave00000000000000from typing import Any, Optional from markdown.extensions import Extension from markdown.treeprocessors import Treeprocessor pygments: bool def parse_hl_lines(expr): ... class CodeHilite: src: Any lang: Any linenums: Any guess_lang: Any css_class: Any style: Any noclasses: Any tab_length: Any hl_lines: Any use_pygments: Any def __init__( self, src: Optional[Any] = ..., linenums: Optional[Any] = ..., guess_lang: bool = ..., css_class: str = ..., lang: Optional[Any] = ..., style: str = ..., noclasses: bool = ..., tab_length: int = ..., hl_lines: Optional[Any] = ..., use_pygments: bool = ..., ) -> None: ... def hilite(self): ... class HiliteTreeprocessor(Treeprocessor): def code_unescape(self, text): ... class CodeHiliteExtension(Extension): def __init__(self, **kwargs) -> None: ... def makeExtension(**kwargs): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/markdown/extensions/def_list.pyi0000664000175000017500000000055000000000000031266 0ustar00davedave00000000000000from typing import Any, Pattern from markdown.blockprocessors import BlockProcessor, ListIndentProcessor from markdown.extensions import Extension class DefListProcessor(BlockProcessor): RE: Pattern NO_INDENT_RE: Pattern class DefListIndentProcessor(ListIndentProcessor): ... class DefListExtension(Extension): ... def makeExtension(**kwargs): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/markdown/extensions/extra.pyi0000664000175000017500000000030500000000000030616 0ustar00davedave00000000000000from typing import Any from markdown.extensions import Extension extensions: Any class ExtraExtension(Extension): def __init__(self, **kwargs) -> None: ... def makeExtension(**kwargs): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/markdown/extensions/fenced_code.pyi0000664000175000017500000000065400000000000031720 0ustar00davedave00000000000000from typing import Any, Pattern from markdown.extensions import Extension from markdown.preprocessors import Preprocessor class FencedCodeExtension(Extension): ... class FencedBlockPreprocessor(Preprocessor): FENCED_BLOCK_RE: Pattern CODE_WRAP: str = ... LANG_TAG: str = ... checked_for_codehilite: bool = ... codehilite_conf: Any def __init__(self, md) -> None: ... def makeExtension(**kwargs): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/markdown/extensions/footnotes.pyi0000664000175000017500000000332700000000000031522 0ustar00davedave00000000000000from typing import Any, Pattern from markdown.extensions import Extension from markdown.inlinepatterns import InlineProcessor from markdown.postprocessors import Postprocessor from markdown.preprocessors import Preprocessor from markdown.treeprocessors import Treeprocessor FN_BACKLINK_TEXT: Any NBSP_PLACEHOLDER: Any DEF_RE: Pattern TABBED_RE: Pattern RE_REF_ID: Any class FootnoteExtension(Extension): unique_prefix: int = ... found_refs: Any used_refs: Any def __init__(self, **kwargs) -> None: ... parser: Any md: Any footnotes: Any def reset(self) -> None: ... def unique_ref(self, reference, found: bool = ...): ... def findFootnotesPlaceholder(self, root): ... def setFootnote(self, id, text) -> None: ... def get_separator(self): ... def makeFootnoteId(self, id): ... def makeFootnoteRefId(self, id, found: bool = ...): ... def makeFootnotesDiv(self, root): ... class FootnotePreprocessor(Preprocessor): footnotes: Any def __init__(self, footnotes) -> None: ... def detectTabbed(self, lines): ... class FootnoteInlineProcessor(InlineProcessor): footnotes: Any def __init__(self, pattern, footnotes) -> None: ... class FootnotePostTreeprocessor(Treeprocessor): footnotes: Any def __init__(self, footnotes) -> None: ... def add_duplicates(self, li, duplicates) -> None: ... def get_num_duplicates(self, li): ... def handle_duplicates(self, parent) -> None: ... offset: int = ... class FootnoteTreeprocessor(Treeprocessor): footnotes: Any def __init__(self, footnotes) -> None: ... class FootnotePostprocessor(Postprocessor): footnotes: Any def __init__(self, footnotes) -> None: ... def makeExtension(**kwargs): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/markdown/extensions/legacy_attrs.pyi0000664000175000017500000000045400000000000032161 0ustar00davedave00000000000000from typing import Any, Pattern from markdown.extensions import Extension from markdown.treeprocessors import Treeprocessor ATTR_RE: Pattern class LegacyAttrs(Treeprocessor): def handleAttributes(self, el, txt): ... class LegacyAttrExtension(Extension): ... def makeExtension(**kwargs): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/markdown/extensions/legacy_em.pyi0000664000175000017500000000046200000000000031424 0ustar00davedave00000000000000from typing import Any from markdown.extensions import Extension from markdown.inlinepatterns import UnderscoreProcessor EMPHASIS_RE: str STRONG_RE: str STRONG_EM_RE: str class LegacyUnderscoreProcessor(UnderscoreProcessor): ... class LegacyEmExtension(Extension): ... def makeExtension(**kwargs): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/markdown/extensions/md_in_html.pyi0000664000175000017500000000040400000000000031605 0ustar00davedave00000000000000from typing import Any, Optional from markdown.blockprocessors import BlockProcessor from markdown.extensions import Extension class MarkdownInHtmlProcessor(BlockProcessor): ... class MarkdownInHtmlExtension(Extension): ... def makeExtension(**kwargs): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/markdown/extensions/meta.pyi0000664000175000017500000000055100000000000030424 0ustar00davedave00000000000000from typing import Any, Pattern from markdown.extensions import Extension from markdown.preprocessors import Preprocessor log: Any META_RE: Pattern META_MORE_RE: Pattern BEGIN_RE: Pattern END_RE: Pattern class MetaExtension(Extension): md: Any def reset(self) -> None: ... class MetaPreprocessor(Preprocessor): ... def makeExtension(**kwargs): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/markdown/extensions/nl2br.pyi0000664000175000017500000000022600000000000030514 0ustar00davedave00000000000000from typing import Any from markdown.extensions import Extension BR_RE: str class Nl2BrExtension(Extension): ... def makeExtension(**kwargs): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/markdown/extensions/sane_lists.pyi0000664000175000017500000000061000000000000031636 0ustar00davedave00000000000000from typing import Any, Pattern from markdown.blockprocessors import OListProcessor, UListProcessor from markdown.extensions import Extension class SaneOListProcessor(OListProcessor): def __init__(self, parser) -> None: ... class SaneUListProcessor(UListProcessor): def __init__(self, parser) -> None: ... class SaneListExtension(Extension): ... def makeExtension(**kwargs): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/markdown/extensions/smarty.pyi0000664000175000017500000000207000000000000031013 0ustar00davedave00000000000000from typing import Any, Pattern from markdown.extensions import Extension from markdown.inlinepatterns import HtmlInlineProcessor punctClass: str endOfWordClass: str closeClass: str openingQuotesBase: str substitutions: Any singleQuoteStartRe: Any doubleQuoteStartRe: Any doubleQuoteSetsRe: str singleQuoteSetsRe: str decadeAbbrRe: str openingDoubleQuotesRegex: Any closingDoubleQuotesRegex: str closingDoubleQuotesRegex2: Any openingSingleQuotesRegex: Any closingSingleQuotesRegex: Any closingSingleQuotesRegex2: Any remainingSingleQuotesRegex: str remainingDoubleQuotesRegex: str HTML_STRICT_RE: str class SubstituteTextPattern(HtmlInlineProcessor): replace: Any def __init__(self, pattern, replace, md) -> None: ... class SmartyExtension(Extension): substitutions: Any def __init__(self, **kwargs) -> None: ... def educateDashes(self, md) -> None: ... def educateEllipses(self, md) -> None: ... def educateAngledQuotes(self, md) -> None: ... def educateQuotes(self, md) -> None: ... inlinePatterns: Any def makeExtension(**kwargs): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/markdown/extensions/tables.pyi0000664000175000017500000000063600000000000030754 0ustar00davedave00000000000000from typing import Any from markdown.blockprocessors import BlockProcessor from markdown.extensions import Extension PIPE_NONE: int PIPE_LEFT: int PIPE_RIGHT: int class TableProcessor(BlockProcessor): RE_CODE_PIPES: Any RE_END_BORDER: Any border: bool = ... separator: str = ... def __init__(self, parser) -> None: ... class TableExtension(Extension): ... def makeExtension(**kwargs): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/markdown/extensions/toc.pyi0000664000175000017500000000223200000000000030261 0ustar00davedave00000000000000from typing import Any, Pattern from markdown.extensions import Extension from markdown.treeprocessors import Treeprocessor def slugify(value, separator): ... IDCOUNT_RE: Pattern def unique(id, ids): ... def get_name(el): ... def stashedHTML2text(text, md, strip_entities: bool = ...): ... def unescape(text): ... def nest_toc_tokens(toc_list): ... class TocTreeprocessor(Treeprocessor): marker: Any title: Any base_level: Any slugify: Any sep: Any use_anchors: Any anchorlink_class: Any use_permalinks: Any permalink_class: Any permalink_title: Any header_rgx: Any toc_top: int = ... toc_bottom: Any def __init__(self, md, config) -> None: ... def iterparent(self, node) -> None: ... def replace_marker(self, root, elem) -> None: ... def set_level(self, elem) -> None: ... def add_anchor(self, c, elem_id) -> None: ... def add_permalink(self, c, elem_id) -> None: ... def build_toc_div(self, toc_list): ... class TocExtension(Extension): TreeProcessorClass: Any def __init__(self, **kwargs) -> None: ... md: Any def reset(self) -> None: ... def makeExtension(**kwargs): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/markdown/extensions/wikilinks.pyi0000664000175000017500000000062400000000000031503 0ustar00davedave00000000000000from typing import Any from markdown.extensions import Extension from markdown.inlinepatterns import InlineProcessor def build_url(label, base, end): ... class WikiLinkExtension(Extension): def __init__(self, **kwargs) -> None: ... md: Any class WikiLinksInlineProcessor(InlineProcessor): config: Any def __init__(self, pattern, config) -> None: ... def makeExtension(**kwargs): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/markdown/inlinepatterns.pyi0000664000175000017500000000571600000000000030346 0ustar00davedave00000000000000from typing import Any, Match, Optional, Tuple, Union from xml.etree.ElementTree import Element def build_inlinepatterns(md, **kwargs): ... NOIMG: str BACKTICK_RE: str ESCAPE_RE: str EMPHASIS_RE: str STRONG_RE: str SMART_STRONG_RE: str SMART_EMPHASIS_RE: str SMART_STRONG_EM_RE: str EM_STRONG_RE: str EM_STRONG2_RE: str STRONG_EM_RE: str STRONG_EM2_RE: str STRONG_EM3_RE: str LINK_RE: str IMAGE_LINK_RE: str REFERENCE_RE: str IMAGE_REFERENCE_RE: str NOT_STRONG_RE: str AUTOLINK_RE: str AUTOMAIL_RE: str HTML_RE: str ENTITY_RE: str LINE_BREAK_RE: str def dequote(string): ... class EmStrongItem: ... class Pattern: ANCESTOR_EXCLUDES: Any pattern: Any compiled_re: Any md: Any def __init__(self, pattern, md: Optional[Any] = ...) -> None: ... @property def markdown(self): ... def getCompiledRegExp(self): ... def handleMatch(self, m: Match) -> Optional[Union[str, Element]]: ... def type(self): ... def unescape(self, text): ... class InlineProcessor(Pattern): safe_mode: bool = ... def __init__(self, pattern, md: Optional[Any] = ...) -> None: ... def handleMatch(self, m: Match, data) -> Union[Tuple[Element, int, int], Tuple[None, None, None]]: ... # type: ignore class SimpleTextPattern(Pattern): ... class SimpleTextInlineProcessor(InlineProcessor): ... class EscapeInlineProcessor(InlineProcessor): ... class SimpleTagPattern(Pattern): tag: Any def __init__(self, pattern, tag) -> None: ... class SimpleTagInlineProcessor(InlineProcessor): tag: Any def __init__(self, pattern, tag) -> None: ... class SubstituteTagPattern(SimpleTagPattern): ... class SubstituteTagInlineProcessor(SimpleTagInlineProcessor): ... class BacktickInlineProcessor(InlineProcessor): ESCAPED_BSLASH: Any tag: str = ... def __init__(self, pattern) -> None: ... class DoubleTagPattern(SimpleTagPattern): ... class DoubleTagInlineProcessor(SimpleTagInlineProcessor): ... class HtmlInlineProcessor(InlineProcessor): ... class AsteriskProcessor(InlineProcessor): PATTERNS: Any def build_single(self, m, tag, idx): ... def build_double(self, m, tags, idx): ... def build_double2(self, m, tags, idx): ... def parse_sub_patterns(self, data, parent, last, idx) -> None: ... def build_element(self, m, builder, tags, index): ... class UnderscoreProcessor(AsteriskProcessor): PATTERNS: Any class LinkInlineProcessor(InlineProcessor): RE_LINK: Any RE_TITLE_CLEAN: Any def getLink(self, data, index): ... def getText(self, data, index): ... class ImageInlineProcessor(LinkInlineProcessor): ... class ReferenceInlineProcessor(LinkInlineProcessor): NEWLINE_CLEANUP_RE: Pattern def evalId(self, data, index, text): ... def makeTag(self, href, title, text): ... class ShortReferenceInlineProcessor(ReferenceInlineProcessor): ... class ImageReferenceInlineProcessor(ReferenceInlineProcessor): ... class AutolinkInlineProcessor(InlineProcessor): ... class AutomailInlineProcessor(InlineProcessor): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/markdown/pep562.pyi0000664000175000017500000000042400000000000026317 0ustar00davedave00000000000000from typing import Any class Version: def __new__(cls, major, minor, micro, release: str = ..., pre: int = ..., post: int = ..., dev: int = ...): ... class Pep562: def __init__(self, name) -> None: ... def __dir__(self): ... def __getattr__(self, name): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/markdown/postprocessors.pyi0000664000175000017500000000062000000000000030404 0ustar00davedave00000000000000from typing import Any, Pattern from . import util def build_postprocessors(md, **kwargs): ... class Postprocessor(util.Processor): def run(self, text) -> None: ... class RawHtmlPostprocessor(Postprocessor): def isblocklevel(self, html): ... class AndSubstitutePostprocessor(Postprocessor): ... class UnescapePostprocessor(Postprocessor): RE: Pattern def unescape(self, m): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/markdown/preprocessors.pyi0000664000175000017500000000104600000000000030210 0ustar00davedave00000000000000from typing import Any, Iterable, List, Pattern from . import util def build_preprocessors(md, **kwargs): ... class Preprocessor(util.Processor): def run(self, lines: List[str]) -> List[str]: ... class NormalizeWhitespace(Preprocessor): ... class HtmlBlockPreprocessor(Preprocessor): right_tag_patterns: Any attrs_pattern: str = ... left_tag_pattern: Any attrs_re: Any left_tag_re: Any markdown_in_raw: bool = ... class ReferencePreprocessor(Preprocessor): TITLE: str = ... RE: Pattern TITLE_RE: Pattern ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/markdown/serializers.pyi0000664000175000017500000000013300000000000027627 0ustar00davedave00000000000000from typing import Any def to_html_string(element): ... def to_xhtml_string(element): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/markdown/treeprocessors.pyi0000664000175000017500000000072500000000000030364 0ustar00davedave00000000000000from typing import Any, Optional from . import util def build_treeprocessors(md, **kwargs): ... def isString(s): ... class Treeprocessor(util.Processor): def run(self, root) -> None: ... class InlineProcessor(Treeprocessor): inlinePatterns: Any ancestors: Any def __init__(self, md) -> None: ... stashed_nodes: Any parent_map: Any def run(self, tree, ancestors: Optional[Any] = ...): ... class PrettifyTreeprocessor(Treeprocessor): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/markdown/util.pyi0000664000175000017500000000306000000000000026252 0ustar00davedave00000000000000from collections import namedtuple from typing import Any, Optional, Pattern PY37: Any __deprecated__: Any BLOCK_LEVEL_ELEMENTS: Any STX: str ETX: str INLINE_PLACEHOLDER_PREFIX: Any INLINE_PLACEHOLDER: Any INLINE_PLACEHOLDER_RE: Pattern AMP_SUBSTITUTE: Any HTML_PLACEHOLDER: Any HTML_PLACEHOLDER_RE: Pattern TAG_PLACEHOLDER: Any INSTALLED_EXTENSIONS: Any RTL_BIDI_RANGES: Any def deprecated(message, stacklevel: int = ...): ... def isBlockLevel(tag): ... def parseBoolValue(value, fail_on_errors: bool = ..., preserve_none: bool = ...): ... def code_escape(text): ... class AtomicString(str): ... class Processor: md: Any def __init__(self, md: Optional[Any] = ...) -> None: ... @property def markdown(self): ... class HtmlStash: html_counter: int = ... rawHtmlBlocks: Any tag_counter: int = ... tag_data: Any def __init__(self) -> None: ... def store(self, html): ... def reset(self) -> None: ... def get_placeholder(self, key): ... def store_tag(self, tag, attrs, left_index, right_index): ... class Registry: def __init__(self) -> None: ... def __contains__(self, item): ... def __iter__(self) -> Any: ... def __getitem__(self, key): ... def __len__(self): ... def get_index_for_name(self, name): ... def register(self, item, name, priority) -> None: ... def deregister(self, name, strict: bool = ...) -> None: ... def __setitem__(self, key, value) -> None: ... def __delitem__(self, key) -> None: ... def add(self, key, value, location) -> None: ... def __getattr__(name): ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4503794 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/markupsafe/0000775000175000017500000000000000000000000025067 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/markupsafe/__init__.pyi0000664000175000017500000000545500000000000027362 0ustar00davedave00000000000000import string import sys from collections import Mapping from typing import Any, Callable, Iterable, List, Optional, Sequence, Text, Tuple, Union from markupsafe._compat import text_type from markupsafe._native import escape as escape, escape_silent as escape_silent, soft_unicode as soft_unicode class Markup(text_type): def __new__(cls, base: Text = ..., encoding: Optional[Text] = ..., errors: Text = ...) -> Markup: ... def __html__(self) -> Markup: ... def __add__(self, other: text_type) -> Markup: ... def __radd__(self, other: text_type) -> Markup: ... def __mul__(self, num: int) -> Markup: ... def __rmul__(self, num: int) -> Markup: ... def __mod__(self, *args: Any) -> Markup: ... def join(self, seq: Iterable[text_type]): ... def split(self, sep: Optional[text_type] = ..., maxsplit: int = ...) -> List[text_type]: ... def rsplit(self, sep: Optional[text_type] = ..., maxsplit: int = ...) -> List[text_type]: ... def splitlines(self, keepends: bool = ...) -> List[text_type]: ... def unescape(self) -> Text: ... def striptags(self) -> Text: ... @classmethod def escape(cls, s: text_type) -> Markup: ... # noqa: F811 def partition(self, sep: text_type) -> Tuple[Markup, Markup, Markup]: ... def rpartition(self, sep: text_type) -> Tuple[Markup, Markup, Markup]: ... def format(self, *args, **kwargs) -> Markup: ... def __html_format__(self, format_spec) -> Markup: ... def __getslice__(self, start: int, stop: int) -> Markup: ... def __getitem__(self, i: Union[int, slice]) -> Markup: ... def capitalize(self) -> Markup: ... def title(self) -> Markup: ... def lower(self) -> Markup: ... def upper(self) -> Markup: ... def swapcase(self) -> Markup: ... def replace(self, old: text_type, new: text_type, count: int = ...) -> Markup: ... def ljust(self, width: int, fillchar: text_type = ...) -> Markup: ... def rjust(self, width: int, fillchar: text_type = ...) -> Markup: ... def lstrip(self, chars: Optional[text_type] = ...) -> Markup: ... def rstrip(self, chars: Optional[text_type] = ...) -> Markup: ... def strip(self, chars: Optional[text_type] = ...) -> Markup: ... def center(self, width: int, fillchar: text_type = ...) -> Markup: ... def zfill(self, width: int) -> Markup: ... def translate( self, table: Union[Mapping[int, Union[int, text_type, None]], Sequence[Union[int, text_type, None]]] ) -> Markup: ... def expandtabs(self, tabsize: int = ...) -> Markup: ... class EscapeFormatter(string.Formatter): escape: Callable[[text_type], Markup] def __init__(self, escape: Callable[[text_type], Markup]) -> None: ... # noqa: F811 def format_field(self, value: text_type, format_spec: text_type) -> Markup: ... if sys.version_info >= (3,): soft_str = soft_unicode ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/markupsafe/_compat.pyi0000664000175000017500000000066300000000000027241 0ustar00davedave00000000000000import sys from typing import Iterator, Mapping, Tuple, TypeVar _K = TypeVar("_K") _V = TypeVar("_V") PY2: bool def iteritems(d: Mapping[_K, _V]) -> Iterator[Tuple[_K, _V]]: ... if sys.version_info >= (3,): text_type = str string_types = (str,) unichr = chr int_types = (int,) else: from __builtin__ import unichr as unichr text_type = unicode string_types = (str, unicode) int_types = (int, long) ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/markupsafe/_constants.pyi0000664000175000017500000000007600000000000027770 0ustar00davedave00000000000000from typing import Dict, Text HTML_ENTITIES: Dict[Text, int] ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/markupsafe/_native.pyi0000664000175000017500000000036200000000000027240 0ustar00davedave00000000000000from typing import Text, Union from . import Markup from ._compat import text_type def escape(s: Union[Markup, Text]) -> Markup: ... def escape_silent(s: Union[None, Markup, Text]) -> Markup: ... def soft_unicode(s: Text) -> text_type: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/markupsafe/_speedups.pyi0000664000175000017500000000036200000000000027602 0ustar00davedave00000000000000from typing import Text, Union from . import Markup from ._compat import text_type def escape(s: Union[Markup, Text]) -> Markup: ... def escape_silent(s: Union[None, Markup, Text]) -> Markup: ... def soft_unicode(s: Text) -> text_type: ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4503794 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/maxminddb/0000775000175000017500000000000000000000000024674 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/maxminddb/__init__.pyi0000664000175000017500000000026100000000000027155 0ustar00davedave00000000000000from typing import Text from maxminddb import reader def open_database(database: Text, mode: int = ...) -> reader.Reader: ... def Reader(database: Text) -> reader.Reader: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/maxminddb/compat.pyi0000664000175000017500000000030200000000000026675 0ustar00davedave00000000000000from typing import Any def compat_ip_address(address: object) -> Any: ... def int_from_byte(x: int) -> int: ... def int_from_bytes(x: bytes) -> int: ... def byte_from_int(x: int) -> bytes: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/maxminddb/const.pyi0000664000175000017500000000020200000000000026537 0ustar00davedave00000000000000MODE_AUTO: int = ... MODE_MMAP_EXT: int = ... MODE_MMAP: int = ... MODE_FILE: int = ... MODE_MEMORY: int = ... MODE_FD: int = ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/maxminddb/decoder.pyi0000664000175000017500000000032700000000000027026 0ustar00davedave00000000000000from typing import Any, Tuple class Decoder: def __init__(self, database_buffer: bytes, pointer_base: int = ..., pointer_test: bool = ...) -> None: ... def decode(self, offset: int) -> Tuple[Any, int]: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/maxminddb/errors.pyi0000664000175000017500000000005600000000000026734 0ustar00davedave00000000000000class InvalidDatabaseError(RuntimeError): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/maxminddb/extension.pyi0000664000175000017500000000214200000000000027432 0ustar00davedave00000000000000from typing import Any, Mapping, Sequence, Text from maxminddb.errors import InvalidDatabaseError as InvalidDatabaseError class Reader: closed: bool = ... def __init__(self, *args: Any, **kwargs: Any) -> None: ... def close(self, *args: Any, **kwargs: Any) -> Any: ... def get(self, *args: Any, **kwargs: Any) -> Any: ... def metadata(self, *args: Any, **kwargs: Any) -> Any: ... def __enter__(self, *args: Any, **kwargs: Any) -> Any: ... def __exit__(self, *args: Any, **kwargs: Any) -> Any: ... class extension: @property def node_count(self) -> int: ... @property def record_size(self) -> int: ... @property def ip_version(self) -> int: ... @property def database_type(self) -> Text: ... @property def languages(self) -> Sequence[Text]: ... @property def binary_format_major_version(self) -> int: ... @property def binary_format_minor_version(self) -> int: ... @property def build_epoch(self) -> int: ... @property def description(self) -> Mapping[Text, Text]: ... def __init__(self, **kwargs: Any) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/maxminddb/reader.pyi0000664000175000017500000000236500000000000026667 0ustar00davedave00000000000000from ipaddress import IPv4Address, IPv6Address from types import TracebackType from typing import Any, Mapping, Optional, Sequence, Text, Tuple, Type, Union class Reader: closed: bool = ... def __init__(self, database: bytes, mode: int = ...) -> None: ... def metadata(self) -> Metadata: ... def get(self, ip_address: Union[Text, IPv4Address, IPv6Address]) -> Optional[Any]: ... def get_with_prefix_len(self, ip_address: Union[Text, IPv4Address, IPv6Address]) -> Tuple[Optional[Any], int]: ... def close(self) -> None: ... def __enter__(self) -> Reader: ... def __exit__( self, exc_type: Optional[Type[BaseException]] = ..., exc_val: Optional[BaseException] = ..., exc_tb: Optional[TracebackType] = ..., ) -> None: ... class Metadata: node_count: int = ... record_size: int = ... ip_version: int = ... database_type: Text = ... languages: Sequence[Text] = ... binary_format_major_version: int = ... binary_format_minor_version: int = ... build_epoch: int = ... description: Mapping[Text, Text] = ... def __init__(self, **kwargs: Any) -> None: ... @property def node_byte_size(self) -> int: ... @property def search_tree_size(self) -> int: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/mock.pyi0000664000175000017500000003474300000000000024420 0ustar00davedave00000000000000import sys from typing import Any, Callable, Generic, List, Mapping, Optional, Sequence, Text, Tuple, Type, TypeVar, Union, overload _F = TypeVar("_F", bound=Callable[..., Any]) _T = TypeVar("_T") _TT = TypeVar("_TT", bound=Type[Any]) _R = TypeVar("_R") __all__ = [ "Mock", "MagicMock", "patch", "sentinel", "DEFAULT", "ANY", "call", "create_autospec", "AsyncMock", "FILTER_DIR", "NonCallableMock", "NonCallableMagicMock", "mock_open", "PropertyMock", "seal", ] __version__: str FILTER_DIR: Any class _slotted: ... class _SentinelObject: name: Any def __init__(self, name: Any) -> None: ... class _Sentinel: def __init__(self) -> None: ... def __getattr__(self, name: str) -> Any: ... sentinel: Any DEFAULT: Any class _Call(Tuple[Any, ...]): def __new__( cls, value: Any = ..., name: Optional[Any] = ..., parent: Optional[Any] = ..., two: bool = ..., from_kall: bool = ... ) -> Any: ... name: Any parent: Any from_kall: Any def __init__( self, value: Any = ..., name: Optional[Any] = ..., parent: Optional[Any] = ..., two: bool = ..., from_kall: bool = ... ) -> None: ... def __eq__(self, other: Any) -> bool: ... __ne__: Any def __call__(self, *args: Any, **kwargs: Any) -> _Call: ... def __getattr__(self, attr: Any) -> Any: ... def count(self, *args: Any, **kwargs: Any) -> Any: ... def index(self, *args: Any, **kwargs: Any) -> Any: ... def call_list(self) -> Any: ... call: _Call class _CallList(List[_Call]): def __contains__(self, value: Any) -> bool: ... class _MockIter: obj: Any def __init__(self, obj: Any) -> None: ... def __iter__(self) -> Any: ... def __next__(self) -> Any: ... class Base: def __init__(self, *args: Any, **kwargs: Any) -> None: ... class NonCallableMock(Base, Any): # type: ignore def __new__(__cls, *args: Any, **kw: Any) -> NonCallableMock: ... def __init__( self, spec: Union[List[str], object, Type[object], None] = ..., wraps: Optional[Any] = ..., name: Optional[str] = ..., spec_set: Union[List[str], object, Type[object], None] = ..., parent: Optional[NonCallableMock] = ..., _spec_state: Optional[Any] = ..., _new_name: str = ..., _new_parent: Optional[NonCallableMock] = ..., _spec_as_instance: bool = ..., _eat_self: Optional[bool] = ..., unsafe: bool = ..., **kwargs: Any, ) -> None: ... def __getattr__(self, name: str) -> Any: ... if sys.version_info >= (3, 8): def _calls_repr(self, prefix: str = ...) -> str: ... def assert_called_with(self, *args: Any, **kwargs: Any) -> None: ... def assert_not_called(self) -> None: ... def assert_called_once_with(self, *args: Any, **kwargs: Any) -> None: ... def _format_mock_failure_message(self, args: Any, kwargs: Any, action: str = ...) -> str: ... elif sys.version_info >= (3, 5): def assert_called_with(_mock_self, *args: Any, **kwargs: Any) -> None: ... def assert_not_called(_mock_self) -> None: ... def assert_called_once_with(_mock_self, *args: Any, **kwargs: Any) -> None: ... def _format_mock_failure_message(self, args: Any, kwargs: Any) -> str: ... if sys.version_info >= (3, 8): def assert_called(self) -> None: ... def assert_called_once(self) -> None: ... elif sys.version_info >= (3, 6): def assert_called(_mock_self) -> None: ... def assert_called_once(_mock_self) -> None: ... if sys.version_info >= (3, 6): def reset_mock(self, visited: Any = ..., *, return_value: bool = ..., side_effect: bool = ...) -> None: ... elif sys.version_info >= (3, 5): def reset_mock(self, visited: Any = ...) -> None: ... if sys.version_info >= (3, 7): def _extract_mock_name(self) -> str: ... def _get_call_signature_from_name(self, name: str) -> Any: ... def assert_any_call(self, *args: Any, **kwargs: Any) -> None: ... def assert_has_calls(self, calls: Sequence[_Call], any_order: bool = ...) -> None: ... def mock_add_spec(self, spec: Any, spec_set: bool = ...) -> None: ... def _mock_add_spec(self, spec: Any, spec_set: bool, _spec_as_instance: bool = ..., _eat_self: bool = ...) -> None: ... def attach_mock(self, mock: NonCallableMock, attribute: str) -> None: ... def configure_mock(self, **kwargs: Any) -> None: ... return_value: Any side_effect: Any called: bool call_count: int call_args: Any call_args_list: _CallList mock_calls: _CallList def _format_mock_call_signature(self, args: Any, kwargs: Any) -> str: ... def _call_matcher(self, _call: Tuple[_Call, ...]) -> _Call: ... def _get_child_mock(self, **kw: Any) -> NonCallableMock: ... class CallableMixin(Base): side_effect: Any def __init__( self, spec: Optional[Any] = ..., side_effect: Optional[Any] = ..., return_value: Any = ..., wraps: Optional[Any] = ..., name: Optional[Any] = ..., spec_set: Optional[Any] = ..., parent: Optional[Any] = ..., _spec_state: Optional[Any] = ..., _new_name: Any = ..., _new_parent: Optional[Any] = ..., **kwargs: Any, ) -> None: ... def __call__(_mock_self, *args: Any, **kwargs: Any) -> Any: ... class Mock(CallableMixin, NonCallableMock): ... class _patch(Generic[_T]): attribute_name: Any getter: Callable[[], Any] attribute: str new: _T new_callable: Any spec: Any create: bool has_local: Any spec_set: Any autospec: Any kwargs: Mapping[str, Any] additional_patchers: Any if sys.version_info >= (3, 8): @overload def __init__( self: _patch[Union[MagicMock, AsyncMock]], getter: Callable[[], Any], attribute: str, *, spec: Optional[Any], create: bool, spec_set: Optional[Any], autospec: Optional[Any], new_callable: Optional[Any], kwargs: Mapping[str, Any], ) -> None: ... # This overload also covers the case, where new==DEFAULT. In this case, self is _patch[Any]. # Ideally we'd be able to add an overload for it so that self is _patch[MagicMock], # but that's impossible with the current type system. @overload def __init__( self: _patch[_T], getter: Callable[[], Any], attribute: str, new: _T, spec: Optional[Any], create: bool, spec_set: Optional[Any], autospec: Optional[Any], new_callable: Optional[Any], kwargs: Mapping[str, Any], ) -> None: ... else: @overload def __init__( self: _patch[MagicMock], getter: Callable[[], Any], attribute: str, *, spec: Optional[Any], create: bool, spec_set: Optional[Any], autospec: Optional[Any], new_callable: Optional[Any], kwargs: Mapping[str, Any], ) -> None: ... @overload def __init__( self: _patch[_T], getter: Callable[[], Any], attribute: str, new: _T, spec: Optional[Any], create: bool, spec_set: Optional[Any], autospec: Optional[Any], new_callable: Optional[Any], kwargs: Mapping[str, Any], ) -> None: ... def copy(self) -> _patch[_T]: ... def __call__(self, func: Callable[..., _R]) -> Callable[..., _R]: ... def decorate_class(self, klass: _TT) -> _TT: ... def decorate_callable(self, func: _F) -> _F: ... def get_original(self) -> Tuple[Any, bool]: ... target: Any temp_original: Any is_local: bool def __enter__(self) -> _T: ... def __exit__(self, *exc_info: Any) -> None: ... def start(self) -> _T: ... def stop(self) -> None: ... class _patch_dict: in_dict: Any values: Any clear: Any def __init__(self, in_dict: Any, values: Any = ..., clear: Any = ..., **kwargs: Any) -> None: ... def __call__(self, f: Any) -> Any: ... def decorate_class(self, klass: Any) -> Any: ... def __enter__(self) -> Any: ... def __exit__(self, *args: Any) -> Any: ... start: Any stop: Any class _patcher: TEST_PREFIX: str dict: Type[_patch_dict] if sys.version_info >= (3, 8): @overload def __call__( # type: ignore self, target: Any, *, spec: Optional[Any] = ..., create: bool = ..., spec_set: Optional[Any] = ..., autospec: Optional[Any] = ..., new_callable: Optional[Any] = ..., **kwargs: Any, ) -> _patch[Union[MagicMock, AsyncMock]]: ... # This overload also covers the case, where new==DEFAULT. In this case, the return type is _patch[Any]. # Ideally we'd be able to add an overload for it so that the return type is _patch[MagicMock], # but that's impossible with the current type system. @overload def __call__( self, target: Any, new: _T, spec: Optional[Any] = ..., create: bool = ..., spec_set: Optional[Any] = ..., autospec: Optional[Any] = ..., new_callable: Optional[Any] = ..., **kwargs: Any, ) -> _patch[_T]: ... else: @overload def __call__( # type: ignore self, target: Any, *, spec: Optional[Any] = ..., create: bool = ..., spec_set: Optional[Any] = ..., autospec: Optional[Any] = ..., new_callable: Optional[Any] = ..., **kwargs: Any, ) -> _patch[MagicMock]: ... @overload def __call__( self, target: Any, new: _T, spec: Optional[Any] = ..., create: bool = ..., spec_set: Optional[Any] = ..., autospec: Optional[Any] = ..., new_callable: Optional[Any] = ..., **kwargs: Any, ) -> _patch[_T]: ... if sys.version_info >= (3, 8): @overload def object( # type: ignore self, target: Any, attribute: Text, *, spec: Optional[Any] = ..., create: bool = ..., spec_set: Optional[Any] = ..., autospec: Optional[Any] = ..., new_callable: Optional[Any] = ..., **kwargs: Any, ) -> _patch[Union[MagicMock, AsyncMock]]: ... @overload def object( self, target: Any, attribute: Text, new: _T = ..., spec: Optional[Any] = ..., create: bool = ..., spec_set: Optional[Any] = ..., autospec: Optional[Any] = ..., new_callable: Optional[Any] = ..., **kwargs: Any, ) -> _patch[_T]: ... else: @overload def object( # type: ignore self, target: Any, attribute: Text, *, spec: Optional[Any] = ..., create: bool = ..., spec_set: Optional[Any] = ..., autospec: Optional[Any] = ..., new_callable: Optional[Any] = ..., **kwargs: Any, ) -> _patch[MagicMock]: ... @overload def object( self, target: Any, attribute: Text, new: _T = ..., spec: Optional[Any] = ..., create: bool = ..., spec_set: Optional[Any] = ..., autospec: Optional[Any] = ..., new_callable: Optional[Any] = ..., **kwargs: Any, ) -> _patch[_T]: ... def multiple( self, target: Any, spec: Optional[Any] = ..., create: bool = ..., spec_set: Optional[Any] = ..., autospec: Optional[Any] = ..., new_callable: Optional[Any] = ..., **kwargs: _T, ) -> _patch[_T]: ... def stopall(self) -> None: ... patch: _patcher class MagicMixin: def __init__(self, *args: Any, **kw: Any) -> None: ... class NonCallableMagicMock(MagicMixin, NonCallableMock): def mock_add_spec(self, spec: Any, spec_set: bool = ...) -> None: ... class MagicMock(MagicMixin, Mock): def mock_add_spec(self, spec: Any, spec_set: bool = ...) -> None: ... if sys.version_info >= (3, 8): class AsyncMockMixin(Base): def __init__(self, *args: Any, **kwargs: Any) -> None: ... async def _execute_mock_call(self, *args: Any, **kwargs: Any) -> Any: ... def assert_awaited(self) -> None: ... def assert_awaited_once(self) -> None: ... def assert_awaited_with(self, *args: Any, **kwargs: Any) -> None: ... def assert_awaited_once_with(self, *args: Any, **kwargs: Any) -> None: ... def assert_any_await(self, *args: Any, **kwargs: Any) -> None: ... def assert_has_awaits(self, calls: _CallList, any_order: bool = ...) -> None: ... def assert_not_awaited(self) -> None: ... def reset_mock(self, *args, **kwargs) -> None: ... await_count: int await_args: Optional[_Call] await_args_list: _CallList class AsyncMagicMixin(MagicMixin): def __init__(self, *args: Any, **kw: Any) -> None: ... class AsyncMock(AsyncMockMixin, AsyncMagicMixin, Mock): ... class MagicProxy: name: Any parent: Any def __init__(self, name: Any, parent: Any) -> None: ... def __call__(self, *args: Any, **kwargs: Any) -> Any: ... def create_mock(self) -> Any: ... def __get__(self, obj: Any, _type: Optional[Any] = ...) -> Any: ... class _ANY: def __eq__(self, other: Any) -> bool: ... def __ne__(self, other: Any) -> bool: ... ANY: Any def create_autospec( spec: Any, spec_set: Any = ..., instance: Any = ..., _parent: Optional[Any] = ..., _name: Optional[Any] = ..., **kwargs: Any ) -> Any: ... class _SpecState: spec: Any ids: Any spec_set: Any parent: Any instance: Any name: Any def __init__( self, spec: Any, spec_set: Any = ..., parent: Optional[Any] = ..., name: Optional[Any] = ..., ids: Optional[Any] = ..., instance: Any = ..., ) -> None: ... def mock_open(mock: Optional[Any] = ..., read_data: Any = ...) -> Any: ... PropertyMock = Any if sys.version_info >= (3, 7): def seal(mock: Any) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/mypy_extensions.pyi0000664000175000017500000000422600000000000026735 0ustar00davedave00000000000000import abc import sys from typing import Any, Callable, Dict, Generic, ItemsView, KeysView, Mapping, Optional, Type, TypeVar, Union, ValuesView _T = TypeVar("_T") _U = TypeVar("_U") # Internal mypy fallback type for all typed dicts (does not exist at runtime) class _TypedDict(Mapping[str, object], metaclass=abc.ABCMeta): def copy(self: _T) -> _T: ... # Using NoReturn so that only calls using mypy plugin hook that specialize the signature # can go through. def setdefault(self, k: NoReturn, default: object) -> object: ... # Mypy plugin hook for 'pop' expects that 'default' has a type variable type. def pop(self, k: NoReturn, default: _T = ...) -> object: ... def update(self: _T, __m: _T) -> None: ... if sys.version_info < (3, 0): def has_key(self, k: str) -> bool: ... def viewitems(self) -> ItemsView[str, object]: ... def viewkeys(self) -> KeysView[str]: ... def viewvalues(self) -> ValuesView[object]: ... else: def items(self) -> ItemsView[str, object]: ... def keys(self) -> KeysView[str]: ... def values(self) -> ValuesView[object]: ... def __delitem__(self, k: NoReturn) -> None: ... def TypedDict(typename: str, fields: Dict[str, Type[_T]], total: bool = ...) -> Type[Dict[str, Any]]: ... def Arg(type: _T = ..., name: Optional[str] = ...) -> _T: ... def DefaultArg(type: _T = ..., name: Optional[str] = ...) -> _T: ... def NamedArg(type: _T = ..., name: Optional[str] = ...) -> _T: ... def DefaultNamedArg(type: _T = ..., name: Optional[str] = ...) -> _T: ... def VarArg(type: _T = ...) -> _T: ... def KwArg(type: _T = ...) -> _T: ... # Return type that indicates a function does not return. # This type is equivalent to the None type, but the no-op Union is necessary to # distinguish the None type from the None value. NoReturn = Union[None] # Deprecated: Use typing.NoReturn instead. # This is intended as a class decorator, but mypy rejects abstract classes # when a Type[_T] is expected, so we can't give it the type we want def trait(cls: Any) -> Any: ... def mypyc_attr(*attrs: str, **kwattrs: object) -> Callable[[_T], _T]: ... class FlexibleAlias(Generic[_T, _U]): ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4503794 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/nmap/0000775000175000017500000000000000000000000023664 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/nmap/__init__.pyi0000664000175000017500000000002400000000000026142 0ustar00davedave00000000000000from .nmap import * ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/nmap/nmap.pyi0000664000175000017500000000756100000000000025353 0ustar00davedave00000000000000from typing import Any, Callable, Dict, Iterable, Iterator, List, Optional, Text, Tuple, TypeVar from typing_extensions import TypedDict _T = TypeVar("_T") _Callback = Callable[[str, _Result], Any] class _Result(TypedDict): nmap: _ResultNmap scan: Dict[str, PortScannerHostDict] class _ResultNmap(TypedDict): command_line: str scaninfo: _ResultNmapInfo scanstats: _ResultNampStats class _ResultNmapInfo(TypedDict, total=False): error: str warning: str protocol: _ResultNampInfoProtocol class _ResultNampInfoProtocol(TypedDict): method: str services: str class _ResultNampStats(TypedDict): timestr: str elapsed: str uphosts: str downhosts: str totalhosts: str class _ResulHostUptime(TypedDict): seconds: str lastboot: str class _ResultHostNames(TypedDict): type: str name: str class _ResultHostPort(TypedDict): conf: str cpe: str extrainfo: str name: str product: str reason: str state: str version: str __last_modification__: str class PortScanner(object): def __init__(self, nmap_search_path: Iterable[str] = ...) -> None: ... def get_nmap_last_output(self) -> Text: ... def nmap_version(self) -> Tuple[int, int]: ... def listscan(self, hosts: str = ...) -> List[str]: ... def scan(self, hosts: Text = ..., ports: Optional[Text] = ..., arguments: Text = ..., sudo: bool = ...) -> _Result: ... def analyse_nmap_xml_scan( self, nmap_xml_output: Optional[str] = ..., nmap_err: str = ..., nmap_err_keep_trace: str = ..., nmap_warn_keep_trace: str = ..., ) -> _Result: ... def __getitem__(self, host: Text) -> PortScannerHostDict: ... def all_hosts(self) -> List[str]: ... def command_line(self) -> str: ... def scaninfo(self) -> _ResultNmapInfo: ... def scanstats(self) -> _ResultNampStats: ... def has_host(self, host: str) -> bool: ... def csv(self) -> str: ... def __scan_progressive__(self, hosts: Text, ports: Text, arguments: Text, callback: Optional[_Callback], sudo: bool) -> None: ... class PortScannerAsync(object): def __init__(self) -> None: ... def __del__(self) -> None: ... def scan( self, hosts: Text = ..., ports: Optional[Text] = ..., arguments: Text = ..., callback: Optional[_Callback] = ..., sudo: bool = ..., ) -> None: ... def stop(self) -> None: ... def wait(self, timeout: Optional[int] = ...) -> None: ... def still_scanning(self) -> bool: ... class PortScannerYield(PortScannerAsync): def __init__(self) -> None: ... def scan( # type: ignore self, hosts: str = ..., ports: Optional[str] = ..., arguments: str = ..., sudo: bool = ... ) -> Iterator[Tuple[str, _Result]]: ... def stop(self) -> None: ... def wait(self, timeout: Optional[int] = ...) -> None: ... def still_scanning(self) -> None: ... # type: ignore class PortScannerHostDict(Dict[str, Any]): def hostnames(self) -> List[_ResultHostNames]: ... def hostname(self) -> str: ... def state(self) -> str: ... def uptime(self) -> _ResulHostUptime: ... def all_protocols(self) -> List[str]: ... def all_tcp(self) -> List[int]: ... def has_tcp(self, port: int) -> bool: ... def tcp(self, port: int) -> _ResultHostPort: ... def all_udp(self) -> List[int]: ... def has_udp(self, port: int) -> bool: ... def udp(self, port: int) -> _ResultHostPort: ... def all_ip(self) -> List[int]: ... def has_ip(self, port: int) -> bool: ... def ip(self, port: int) -> _ResultHostPort: ... def all_sctp(self) -> List[int]: ... def has_sctp(self, port: int) -> bool: ... def sctp(self, port: int) -> _ResultHostPort: ... class PortScannerError(Exception): value: str def __init__(self, value: str) -> None: ... def convert_nmap_output_to_encoding(value: _T, code: str = ...) -> _T: ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4543793 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/paramiko/0000775000175000017500000000000000000000000024534 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/paramiko/__init__.pyi0000664000175000017500000000357700000000000027032 0ustar00davedave00000000000000from paramiko.agent import Agent as Agent, AgentKey as AgentKey from paramiko.channel import Channel as Channel from paramiko.client import ( AutoAddPolicy as AutoAddPolicy, MissingHostKeyPolicy as MissingHostKeyPolicy, RejectPolicy as RejectPolicy, SSHClient as SSHClient, WarningPolicy as WarningPolicy, ) from paramiko.common import io_sleep as io_sleep from paramiko.config import SSHConfig as SSHConfig from paramiko.dsskey import DSSKey as DSSKey from paramiko.ecdsakey import ECDSAKey as ECDSAKey from paramiko.ed25519key import Ed25519Key as Ed25519Key from paramiko.file import BufferedFile as BufferedFile from paramiko.hostkeys import HostKeys as HostKeys from paramiko.message import Message as Message from paramiko.pkey import PKey as PKey from paramiko.proxy import ProxyCommand as ProxyCommand from paramiko.rsakey import RSAKey as RSAKey from paramiko.server import ServerInterface as ServerInterface, SubsystemHandler as SubsystemHandler from paramiko.sftp import SFTPError as SFTPError from paramiko.sftp_attr import SFTPAttributes as SFTPAttributes from paramiko.sftp_client import SFTP as SFTP, SFTPClient as SFTPClient from paramiko.sftp_file import SFTPFile as SFTPFile from paramiko.sftp_handle import SFTPHandle as SFTPHandle from paramiko.sftp_server import SFTPServer as SFTPServer from paramiko.sftp_si import SFTPServerInterface as SFTPServerInterface from paramiko.ssh_exception import ( AuthenticationException as AuthenticationException, BadAuthenticationType as BadAuthenticationType, BadHostKeyException as BadHostKeyException, ChannelException as ChannelException, PasswordRequiredException as PasswordRequiredException, ProxyCommandFailure as ProxyCommandFailure, SSHException as SSHException, ) from paramiko.transport import SecurityOptions as SecurityOptions, Transport as Transport # Names in __all__ with no definition: # util ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/paramiko/_version.pyi0000664000175000017500000000010100000000000027073 0ustar00davedave00000000000000from typing import Tuple __version_info__: Tuple[int, int, int] ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/paramiko/_winapi.pyi0000664000175000017500000000513100000000000026705 0ustar00davedave00000000000000import builtins import ctypes.wintypes import sys from types import TracebackType from typing import Any, Optional, Type, TypeVar assert sys.platform == "win32" _T = TypeVar("_T") def format_system_message(errno: int) -> Optional[str]: ... class WindowsError(builtins.WindowsError): def __init__(self, value: Optional[int] = ...) -> None: ... @property def message(self) -> str: ... @property def code(self) -> int: ... def handle_nonzero_success(result: int) -> None: ... GMEM_MOVEABLE: int GlobalAlloc: Any GlobalLock: Any GlobalUnlock: Any GlobalSize: Any CreateFileMapping: Any MapViewOfFile: Any UnmapViewOfFile: Any RtlMoveMemory: Any class MemoryMap: name: str length: int security_attributes: Any = ... pos: int filemap: Any = ... view: Any = ... def __init__(self, name: str, length: int, security_attributes: Optional[Any] = ...) -> None: ... def __enter__(self: _T) -> _T: ... def seek(self, pos: int) -> None: ... def write(self, msg: bytes) -> None: ... def read(self, n: int) -> bytes: ... def __exit__( self, exc_type: Optional[Type[BaseException]], exc_val: Optional[BaseException], tb: Optional[TracebackType] ) -> None: ... READ_CONTROL: int STANDARD_RIGHTS_REQUIRED: int STANDARD_RIGHTS_READ: int STANDARD_RIGHTS_WRITE: int STANDARD_RIGHTS_EXECUTE: int STANDARD_RIGHTS_ALL: int POLICY_VIEW_LOCAL_INFORMATION: int POLICY_VIEW_AUDIT_INFORMATION: int POLICY_GET_PRIVATE_INFORMATION: int POLICY_TRUST_ADMIN: int POLICY_CREATE_ACCOUNT: int POLICY_CREATE_SECRET: int POLICY_CREATE_PRIVILEGE: int POLICY_SET_DEFAULT_QUOTA_LIMITS: int POLICY_SET_AUDIT_REQUIREMENTS: int POLICY_AUDIT_LOG_ADMIN: int POLICY_SERVER_ADMIN: int POLICY_LOOKUP_NAMES: int POLICY_NOTIFICATION: int POLICY_ALL_ACCESS: int POLICY_READ: int POLICY_WRITE: int POLICY_EXECUTE: int class TokenAccess: TOKEN_QUERY: int class TokenInformationClass: TokenUser: int class TOKEN_USER(ctypes.Structure): num: int class SECURITY_DESCRIPTOR(ctypes.Structure): SECURITY_DESCRIPTOR_CONTROL: Any REVISION: int class SECURITY_ATTRIBUTES(ctypes.Structure): nLength: int lpSecurityDescriptor: Any def __init__(self, *args: Any, **kwargs: Any) -> None: ... @property def descriptor(self) -> Any: ... @descriptor.setter def descriptor(self, value: Any) -> None: ... def GetTokenInformation(token: Any, information_class: Any) -> Any: ... def OpenProcessToken(proc_handle: Any, access: Any) -> Any: ... def get_current_user() -> TOKEN_USER: ... def get_security_attributes_for_user(user: Optional[TOKEN_USER] = ...) -> SECURITY_ATTRIBUTES: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/paramiko/agent.pyi0000664000175000017500000000401100000000000026351 0ustar00davedave00000000000000from socket import _RetAddress, socket from threading import Thread from typing import Dict, Protocol, Tuple from paramiko.channel import Channel from paramiko.message import Message from paramiko.pkey import PKey from paramiko.transport import Transport class _AgentProxy(Protocol): def connect(self) -> None: ... def close(self) -> None: ... cSSH2_AGENTC_REQUEST_IDENTITIES: bytes SSH2_AGENT_IDENTITIES_ANSWER: int cSSH2_AGENTC_SIGN_REQUEST: bytes SSH2_AGENT_SIGN_RESPONSE: int class AgentSSH: def __init__(self) -> None: ... def get_keys(self) -> Tuple[AgentKey, ...]: ... class AgentProxyThread(Thread): def __init__(self, agent: _AgentProxy) -> None: ... def run(self) -> None: ... class AgentLocalProxy(AgentProxyThread): def __init__(self, agent: AgentServerProxy) -> None: ... def get_connection(self) -> Tuple[socket, _RetAddress]: ... class AgentRemoteProxy(AgentProxyThread): def __init__(self, agent: AgentClientProxy, chan: Channel) -> None: ... def get_connection(self) -> Tuple[socket, _RetAddress]: ... class AgentClientProxy: thread: Thread def __init__(self, chanRemote: Channel) -> None: ... def __del__(self) -> None: ... def connect(self) -> None: ... def close(self) -> None: ... class AgentServerProxy(AgentSSH): thread: Thread def __init__(self, t: Transport) -> None: ... def __del__(self) -> None: ... def connect(self) -> None: ... def close(self) -> None: ... def get_env(self) -> Dict[str, str]: ... class AgentRequestHandler: def __init__(self, chanClient: Channel) -> None: ... def __del__(self) -> None: ... def close(self) -> None: ... class Agent(AgentSSH): def __init__(self) -> None: ... def close(self) -> None: ... class AgentKey(PKey): agent: AgentSSH blob: bytes public_blob: None name: str def __init__(self, agent: AgentSSH, blob: bytes) -> None: ... def asbytes(self) -> bytes: ... def get_name(self) -> str: ... def sign_ssh_data(self, data: bytes) -> Message: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/paramiko/auth_handler.pyi0000664000175000017500000000361600000000000027723 0ustar00davedave00000000000000from threading import Event from typing import Callable, List, Optional, Tuple from paramiko.message import Message from paramiko.pkey import PKey from paramiko.server import InteractiveQuery from paramiko.ssh_gss import _SSH_GSSAuth from paramiko.transport import Transport _InteractiveCallback = Callable[[str, str, List[Tuple[str, bool]]], List[str]] class AuthHandler: transport: Transport username: Optional[str] authenticated: bool auth_event: Optional[Event] auth_method: str banner: Optional[str] password: Optional[str] private_key: Optional[PKey] interactive_handler: Optional[_InteractiveCallback] submethods: Optional[str] auth_username: Optional[str] auth_fail_count: int gss_host: Optional[str] gss_deleg_creds: bool def __init__(self, transport: Transport) -> None: ... def is_authenticated(self) -> bool: ... def get_username(self) -> Optional[str]: ... def auth_none(self, username: str, event: Event) -> None: ... def auth_publickey(self, username: str, key: PKey, event: Event) -> None: ... def auth_password(self, username: str, password: str, event: Event) -> None: ... def auth_interactive(self, username: str, handler: _InteractiveCallback, event: Event, submethods: str = ...) -> None: ... def auth_gssapi_with_mic(self, username: str, gss_host: str, gss_deleg_creds: bool, event: Event) -> None: ... def auth_gssapi_keyex(self, username: str, event: Event) -> None: ... def abort(self) -> None: ... def wait_for_response(self, event: Event) -> List[str]: ... class GssapiWithMicAuthHandler: method: str sshgss: _SSH_GSSAuth def __init__(self, delegate: AuthHandler, sshgss: _SSH_GSSAuth) -> None: ... def abort(self) -> None: ... @property def transport(self) -> Transport: ... @property def auth_username(self) -> str: ... @property def gss_host(self) -> str: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/paramiko/ber.pyi0000664000175000017500000000114300000000000026026 0ustar00davedave00000000000000from typing import Any, Iterable, List, Union class BERException(Exception): ... class BER: content: bytes idx: int def __init__(self, content: bytes = ...) -> None: ... def asbytes(self) -> bytes: ... def decode(self) -> Union[None, int, List[int]]: ... def decode_next(self) -> Union[None, int, List[int]]: ... @staticmethod def decode_sequence(data: bytes) -> List[Union[int, List[int]]]: ... def encode_tlv(self, ident: int, val: bytes) -> None: ... def encode(self, x: Any) -> None: ... @staticmethod def encode_sequence(data: Iterable[str]) -> bytes: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/paramiko/buffered_pipe.pyi0000664000175000017500000000101000000000000030046 0ustar00davedave00000000000000from threading import Event from typing import Generic, Optional, Text, TypeVar _T = TypeVar("_T", Text, bytes) class PipeTimeout(IOError): ... class BufferedPipe(Generic[_T]): def __init__(self) -> None: ... def set_event(self, event: Event) -> None: ... def feed(self, data: _T) -> None: ... def read_ready(self) -> bool: ... def read(self, nbytes: int, timeout: Optional[float] = ...) -> _T: ... def empty(self) -> _T: ... def close(self) -> None: ... def __len__(self) -> int: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/paramiko/channel.pyi0000664000175000017500000000732400000000000026675 0ustar00davedave00000000000000from logging import Logger from threading import Condition, Event, Lock from typing import Any, Callable, Mapping, Optional, Tuple, TypeVar from paramiko.buffered_pipe import BufferedPipe, PipeTimeout from paramiko.file import BufferedFile from paramiko.message import Message from paramiko.transport import Transport from paramiko.util import ClosingContextManager _F = TypeVar("_F", bound=Callable[..., Any]) def open_only(func: _F) -> Callable[[_F], _F]: ... class Channel(ClosingContextManager): chanid: int remote_chanid: int transport: Optional[Transport] active: bool eof_received: int eof_sent: int in_buffer: BufferedPipe in_stderr_buffer: BufferedPipe timeout: Optional[float] closed: bool ultra_debug: bool lock: Lock out_buffer_cv: Condition in_window_size: int out_window_size: int in_max_packet_size: int out_max_packet_size: int in_window_threshold: int in_window_sofar: int status_event: Event logger: Logger event: Event event_ready: bool combine_stderr: bool exit_status: int origin_addr: None def __init__(self, chanid: int) -> None: ... def __del__(self) -> None: ... def get_pty( self, term: str = ..., width: int = ..., height: int = ..., width_pixels: int = ..., height_pixels: int = ... ) -> None: ... def invoke_shell(self) -> None: ... def exec_command(self, command: str) -> None: ... def invoke_subsystem(self, subsystem: str) -> None: ... def resize_pty(self, width: int = ..., height: int = ..., width_pixels: int = ..., height_pixels: int = ...) -> None: ... def update_environment(self, environment: Mapping[str, str]) -> None: ... def set_environment_variable(self, name: str, value: str) -> None: ... def exit_status_ready(self) -> bool: ... def recv_exit_status(self) -> int: ... def send_exit_status(self, status: int) -> None: ... def request_x11( self, screen_number: int = ..., auth_protocol: Optional[str] = ..., auth_cookie: Optional[str] = ..., single_connection: bool = ..., handler: Optional[Callable[[Channel, Tuple[str, int]], None]] = ..., ) -> bytes: ... def request_forward_agent(self, handler: Callable[[Channel], None]) -> bool: ... def get_transport(self) -> Transport: ... def set_name(self, name: str) -> None: ... def get_name(self) -> str: ... def get_id(self) -> int: ... def set_combine_stderr(self, combine: bool) -> bool: ... def settimeout(self, timeout: Optional[float]) -> None: ... def gettimeout(self) -> Optional[float]: ... def setblocking(self, blocking: bool) -> None: ... def getpeername(self) -> str: ... def close(self) -> None: ... def recv_ready(self) -> bool: ... def recv(self, nbytes: int) -> bytes: ... def recv_stderr_ready(self) -> bool: ... def recv_stderr(self, nbytes: int) -> bytes: ... def send_ready(self) -> bool: ... def send(self, s: bytes) -> int: ... def send_stderr(self, s: bytes) -> int: ... def sendall(self, s: bytes) -> None: ... def sendall_stderr(self, s: bytes) -> None: ... def makefile(self, *params: Any) -> ChannelFile: ... def makefile_stderr(self, *params: Any) -> ChannelStderrFile: ... def makefile_stdin(self, *params: Any) -> ChannelStdinFile: ... def fileno(self) -> int: ... def shutdown(self, how: int) -> None: ... def shutdown_read(self) -> None: ... def shutdown_write(self) -> None: ... class ChannelFile(BufferedFile): channel: Channel def __init__(self, channel: Channel, mode: str = ..., bufsize: int = ...) -> None: ... class ChannelStderrFile(ChannelFile): ... class ChannelStdinFile(ChannelFile): def close(self) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/paramiko/client.pyi0000664000175000017500000000556400000000000026547 0ustar00davedave00000000000000from socket import socket from typing import Any, Dict, Iterable, Mapping, NoReturn, Optional, Tuple, Type, Union from paramiko.agent import Agent from paramiko.channel import Channel, ChannelFile, ChannelStderrFile, ChannelStdinFile from paramiko.hostkeys import HostKeys from paramiko.pkey import PKey from paramiko.sftp_client import SFTPClient from paramiko.transport import Transport from paramiko.util import ClosingContextManager class SSHClient(ClosingContextManager): def __init__(self) -> None: ... def load_system_host_keys(self, filename: Optional[str] = ...) -> None: ... def load_host_keys(self, filename: str) -> None: ... def save_host_keys(self, filename: str) -> None: ... def get_host_keys(self) -> HostKeys: ... def set_log_channel(self, name: str) -> None: ... def set_missing_host_key_policy(self, policy: Union[Type[MissingHostKeyPolicy], MissingHostKeyPolicy]) -> None: ... def connect( self, hostname: str, port: int = ..., username: Optional[str] = ..., password: Optional[str] = ..., pkey: Optional[PKey] = ..., key_filename: Optional[str] = ..., timeout: Optional[float] = ..., allow_agent: bool = ..., look_for_keys: bool = ..., compress: bool = ..., sock: Optional[socket] = ..., gss_auth: bool = ..., gss_kex: bool = ..., gss_deleg_creds: bool = ..., gss_host: Optional[str] = ..., banner_timeout: Optional[float] = ..., auth_timeout: Optional[float] = ..., gss_trust_dns: bool = ..., passphrase: Optional[str] = ..., disabled_algorithms: Optional[Dict[str, Iterable[str]]] = ..., ) -> None: ... def close(self) -> None: ... def exec_command( self, command: str, bufsize: int = ..., timeout: Optional[float] = ..., get_pty: bool = ..., environment: Optional[Dict[str, str]] = ..., ) -> Tuple[ChannelStdinFile, ChannelFile, ChannelStderrFile]: ... def invoke_shell( self, term: str = ..., width: int = ..., height: int = ..., width_pixels: int = ..., height_pixels: int = ..., environment: Optional[Mapping[str, str]] = ..., ) -> Channel: ... def open_sftp(self) -> Optional[SFTPClient]: ... def get_transport(self) -> Optional[Transport]: ... class MissingHostKeyPolicy: def missing_host_key(self, client: SSHClient, hostname: str, key: PKey) -> None: ... class AutoAddPolicy(MissingHostKeyPolicy): def missing_host_key(self, client: SSHClient, hostname: str, key: PKey) -> None: ... class RejectPolicy(MissingHostKeyPolicy): def missing_host_key(self, client: SSHClient, hostname: str, key: PKey) -> NoReturn: ... class WarningPolicy(MissingHostKeyPolicy): def missing_host_key(self, client: SSHClient, hostname: str, key: PKey) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/paramiko/common.pyi0000664000175000017500000000613700000000000026556 0ustar00davedave00000000000000import sys from typing import Any, Dict, Protocol, Text, Union MSG_DISCONNECT: int MSG_IGNORE: int MSG_UNIMPLEMENTED: int MSG_DEBUG: int MSG_SERVICE_REQUEST: int MSG_SERVICE_ACCEPT: int MSG_KEXINIT: int MSG_NEWKEYS: int MSG_USERAUTH_REQUEST: int MSG_USERAUTH_FAILURE: int MSG_USERAUTH_SUCCESS: int MSG_USERAUTH_BANNER: int MSG_USERAUTH_PK_OK: int MSG_USERAUTH_INFO_REQUEST: int MSG_USERAUTH_INFO_RESPONSE: int MSG_USERAUTH_GSSAPI_RESPONSE: int MSG_USERAUTH_GSSAPI_TOKEN: int MSG_USERAUTH_GSSAPI_EXCHANGE_COMPLETE: int MSG_USERAUTH_GSSAPI_ERROR: int MSG_USERAUTH_GSSAPI_ERRTOK: int MSG_USERAUTH_GSSAPI_MIC: int HIGHEST_USERAUTH_MESSAGE_ID: int MSG_GLOBAL_REQUEST: int MSG_REQUEST_SUCCESS: int MSG_REQUEST_FAILURE: int MSG_CHANNEL_OPEN: int MSG_CHANNEL_OPEN_SUCCESS: int MSG_CHANNEL_OPEN_FAILURE: int MSG_CHANNEL_WINDOW_ADJUST: int MSG_CHANNEL_DATA: int MSG_CHANNEL_EXTENDED_DATA: int MSG_CHANNEL_EOF: int MSG_CHANNEL_CLOSE: int MSG_CHANNEL_REQUEST: int MSG_CHANNEL_SUCCESS: int MSG_CHANNEL_FAILURE: int cMSG_DISCONNECT: bytes cMSG_IGNORE: bytes cMSG_UNIMPLEMENTED: bytes cMSG_DEBUG: bytes cMSG_SERVICE_REQUEST: bytes cMSG_SERVICE_ACCEPT: bytes cMSG_KEXINIT: bytes cMSG_NEWKEYS: bytes cMSG_USERAUTH_REQUEST: bytes cMSG_USERAUTH_FAILURE: bytes cMSG_USERAUTH_SUCCESS: bytes cMSG_USERAUTH_BANNER: bytes cMSG_USERAUTH_PK_OK: bytes cMSG_USERAUTH_INFO_REQUEST: bytes cMSG_USERAUTH_INFO_RESPONSE: bytes cMSG_USERAUTH_GSSAPI_RESPONSE: bytes cMSG_USERAUTH_GSSAPI_TOKEN: bytes cMSG_USERAUTH_GSSAPI_EXCHANGE_COMPLETE: bytes cMSG_USERAUTH_GSSAPI_ERROR: bytes cMSG_USERAUTH_GSSAPI_ERRTOK: bytes cMSG_USERAUTH_GSSAPI_MIC: bytes cMSG_GLOBAL_REQUEST: bytes cMSG_REQUEST_SUCCESS: bytes cMSG_REQUEST_FAILURE: bytes cMSG_CHANNEL_OPEN: bytes cMSG_CHANNEL_OPEN_SUCCESS: bytes cMSG_CHANNEL_OPEN_FAILURE: bytes cMSG_CHANNEL_WINDOW_ADJUST: bytes cMSG_CHANNEL_DATA: bytes cMSG_CHANNEL_EXTENDED_DATA: bytes cMSG_CHANNEL_EOF: bytes cMSG_CHANNEL_CLOSE: bytes cMSG_CHANNEL_REQUEST: bytes cMSG_CHANNEL_SUCCESS: bytes cMSG_CHANNEL_FAILURE: bytes MSG_NAMES: Dict[int, str] AUTH_SUCCESSFUL: int AUTH_PARTIALLY_SUCCESSFUL: int AUTH_FAILED: int OPEN_SUCCEEDED: int OPEN_FAILED_ADMINISTRATIVELY_PROHIBITED: int OPEN_FAILED_CONNECT_FAILED: int OPEN_FAILED_UNKNOWN_CHANNEL_TYPE: int OPEN_FAILED_RESOURCE_SHORTAGE: int CONNECTION_FAILED_CODE: Dict[int, str] DISCONNECT_SERVICE_NOT_AVAILABLE: int DISCONNECT_AUTH_CANCELLED_BY_USER: int DISCONNECT_NO_MORE_AUTH_METHODS_AVAILABLE: int zero_byte: bytes one_byte: bytes four_byte: bytes max_byte: bytes cr_byte: bytes linefeed_byte: bytes crlf: bytes if sys.version_info < (3, 0): cr_byte_value: bytes linefeed_byte_value: bytes else: cr_byte_value: int linefeed_byte_value: int class _SupportsAsBytes(Protocol): def asbytes(self) -> bytes: ... _LikeBytes = Union[bytes, Text, _SupportsAsBytes] def asbytes(s: _LikeBytes) -> bytes: ... xffffffff: int x80000000: int o666: int o660: int o644: int o600: int o777: int o700: int o70: int DEBUG: int INFO: int WARNING: int ERROR: int CRITICAL: int io_sleep: float DEFAULT_WINDOW_SIZE: int DEFAULT_MAX_PACKET_SIZE: int MIN_WINDOW_SIZE: int MIN_PACKET_SIZE: int MAX_WINDOW_SIZE: int ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/paramiko/compress.pyi0000664000175000017500000000045000000000000027111 0ustar00davedave00000000000000from zlib import _Compress, _Decompress class ZlibCompressor: z: _Compress def __init__(self) -> None: ... def __call__(self, data: bytes) -> bytes: ... class ZlibDecompressor: z: _Decompress def __init__(self) -> None: ... def __call__(self, data: bytes) -> bytes: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/paramiko/config.pyi0000664000175000017500000000222200000000000026522 0ustar00davedave00000000000000from typing import IO, Any, Dict, Iterable, List, Optional, Pattern, Set from paramiko.ssh_exception import ConfigParseError as ConfigParseError, CouldNotCanonicalize as CouldNotCanonicalize SSH_PORT: int class SSHConfig: SETTINGS_REGEX: Pattern[str] TOKENS_BY_CONFIG_KEY: Dict[str, List[str]] def __init__(self) -> None: ... @classmethod def from_text(cls, text: str) -> SSHConfig: ... @classmethod def from_path(cls, path: str) -> SSHConfig: ... @classmethod def from_file(cls, flo: IO[str]) -> SSHConfig: ... def parse(self, file_obj: IO[str]) -> None: ... def lookup(self, hostname: str) -> SSHConfigDict: ... def canonicalize(self, hostname: str, options: SSHConfigDict, domains: Iterable[str]) -> str: ... def get_hostnames(self) -> Set[str]: ... class LazyFqdn: fqdn: Optional[str] config: SSHConfig host: Optional[str] def __init__(self, config: SSHConfigDict, host: Optional[str] = ...) -> None: ... class SSHConfigDict(Dict[str, str]): def __init__(self, *args: Any, **kwargs: Any) -> None: ... def as_bool(self, key: str) -> bool: ... def as_int(self, key: str) -> int: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/paramiko/dsskey.pyi0000664000175000017500000000233200000000000026561 0ustar00davedave00000000000000from typing import IO, Any, Callable, Optional, Tuple from paramiko.ber import BER from paramiko.message import Message from paramiko.pkey import PKey, PublicBlob class DSSKey(PKey): p: Optional[int] q: Optional[int] g: Optional[int] y: Optional[int] x: Optional[int] public_blob: None size: int def __init__( self, msg: Optional[Message] = ..., data: Optional[bytes] = ..., filename: Optional[str] = ..., password: Optional[str] = ..., vals: Optional[Tuple[int, int, int, int]] = ..., file_obj: Optional[IO[str]] = ..., ) -> None: ... def asbytes(self) -> bytes: ... def __hash__(self) -> int: ... def get_name(self) -> str: ... def get_bits(self) -> int: ... def can_sign(self) -> bool: ... def sign_ssh_data(self, data: bytes) -> Message: ... def verify_ssh_sig(self, data: bytes, msg: Message) -> bool: ... def write_private_key_file(self, filename: str, password: Optional[str] = ...) -> None: ... def write_private_key(self, file_obj: IO[str], password: Optional[str] = ...) -> None: ... @staticmethod def generate(bits: int = ..., progress_func: Optional[Callable[..., Any]] = ...) -> DSSKey: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/paramiko/ecdsakey.pyi0000664000175000017500000000444200000000000027053 0ustar00davedave00000000000000from typing import IO, Any, Callable, List, Optional, Sequence, Tuple, Type from cryptography.hazmat.primitives.asymmetric.ec2 import EllipticCurve, EllipticCurvePrivateKey, EllipticCurvePublicKey from cryptography.hazmat.primitives.hashes import HashAlgorithm from paramiko.message import Message from paramiko.pkey import PKey class _ECDSACurve: nist_name: str key_length: int key_format_identifier: str hash_object: Type[HashAlgorithm] curve_class: Type[EllipticCurve] def __init__(self, curve_class: Type[EllipticCurve], nist_name: str) -> None: ... class _ECDSACurveSet: ecdsa_curves: Sequence[_ECDSACurve] def __init__(self, ecdsa_curves: Sequence[_ECDSACurve]) -> None: ... def get_key_format_identifier_list(self) -> List[str]: ... def get_by_curve_class(self, curve_class: Type[Any]) -> Optional[_ECDSACurve]: ... def get_by_key_format_identifier(self, key_format_identifier: str) -> Optional[_ECDSACurve]: ... def get_by_key_length(self, key_length: int) -> Optional[_ECDSACurve]: ... class ECDSAKey(PKey): verifying_key: EllipticCurvePublicKey signing_key: EllipticCurvePrivateKey public_blob: None ecdsa_curve: Optional[_ECDSACurve] def __init__( self, msg: Optional[Message] = ..., data: Optional[bytes] = ..., filename: Optional[str] = ..., password: Optional[str] = ..., vals: Optional[Tuple[EllipticCurvePrivateKey, EllipticCurvePublicKey]] = ..., file_obj: Optional[IO[str]] = ..., validate_point: bool = ..., ) -> None: ... @classmethod def supported_key_format_identifiers(cls: Any) -> List[str]: ... def asbytes(self) -> bytes: ... def __hash__(self) -> int: ... def get_name(self) -> str: ... def get_bits(self) -> int: ... def can_sign(self) -> bool: ... def sign_ssh_data(self, data: bytes) -> Message: ... def verify_ssh_sig(self, data: bytes, msg: Message) -> bool: ... def write_private_key_file(self, filename: str, password: Optional[str] = ...) -> None: ... def write_private_key(self, file_obj: IO[str], password: Optional[str] = ...) -> None: ... @classmethod def generate( cls, curve: EllipticCurve = ..., progress_func: Optional[Callable[..., Any]] = ..., bits: Optional[int] = ... ) -> ECDSAKey: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/paramiko/ed25519key.pyi0000664000175000017500000000127700000000000026775 0ustar00davedave00000000000000from typing import IO, Any, Optional from paramiko.message import Message from paramiko.pkey import PKey class Ed25519Key(PKey): public_blob: None def __init__( self, msg: Optional[Message] = ..., data: Optional[bytes] = ..., filename: Optional[str] = ..., password: Optional[str] = ..., file_obj: Optional[IO[str]] = ..., ) -> None: ... def asbytes(self) -> bytes: ... def __hash__(self) -> int: ... def get_name(self) -> str: ... def get_bits(self) -> int: ... def can_sign(self) -> bool: ... def sign_ssh_data(self, data: bytes) -> Message: ... def verify_ssh_sig(self, data: bytes, msg: Message) -> bool: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/paramiko/file.pyi0000664000175000017500000000247600000000000026207 0ustar00davedave00000000000000from typing import AnyStr, Generic, Iterable, List, Optional, Tuple, Union from paramiko.util import ClosingContextManager class BufferedFile(ClosingContextManager, Generic[AnyStr]): SEEK_SET: int SEEK_CUR: int SEEK_END: int FLAG_READ: int FLAG_WRITE: int FLAG_APPEND: int FLAG_BINARY: int FLAG_BUFFERED: int FLAG_LINE_BUFFERED: int FLAG_UNIVERSAL_NEWLINE: int newlines: Union[None, AnyStr, Tuple[AnyStr, ...]] def __init__(self) -> None: ... def __del__(self) -> None: ... def __iter__(self) -> BufferedFile: ... def close(self) -> None: ... def flush(self) -> None: ... def __next__(self) -> AnyStr: ... def readable(self) -> bool: ... def writable(self) -> bool: ... def seekable(self) -> bool: ... def readinto(self, buff: bytearray) -> int: ... def read(self, size: Optional[int] = ...) -> AnyStr: ... def readline(self, size: Optional[int] = ...) -> AnyStr: ... def readlines(self, sizehint: Optional[int] = ...) -> List[AnyStr]: ... def seek(self, offset: int, whence: int = ...) -> None: ... def tell(self) -> int: ... def write(self, data: AnyStr) -> None: ... def writelines(self, sequence: Iterable[AnyStr]) -> None: ... def xreadlines(self) -> BufferedFile: ... @property def closed(self) -> bool: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/paramiko/hostkeys.pyi0000664000175000017500000000362600000000000027137 0ustar00davedave00000000000000import collections import typing from typing import Dict, Iterator, List, Optional from paramiko.pkey import PKey class _SubDict(typing.MutableMapping[str, PKey]): # Internal to HostKeys.lookup() def __init__(self, hostname: str, entries: List[HostKeyEntry], hostkeys: HostKeys) -> None: ... def __iter__(self) -> Iterator[str]: ... def __len__(self) -> int: ... def __delitem__(self, key: str) -> None: ... def __getitem__(self, key: str) -> PKey: ... def __setitem__(self, key: str, val: PKey) -> None: ... def keys(self) -> List[str]: ... # type: ignore class HostKeys(collections.MutableMapping): def __init__(self, filename: Optional[str] = ...) -> None: ... def add(self, hostname: str, keytype: str, key: PKey) -> None: ... def load(self, filename: str) -> None: ... def save(self, filename: str) -> None: ... def lookup(self, hostname: str) -> Optional[_SubDict]: ... def check(self, hostname: str, key: PKey) -> bool: ... def clear(self) -> None: ... def __iter__(self) -> Iterator[str]: ... def __len__(self) -> int: ... def __getitem__(self, key: str) -> _SubDict: ... def __delitem__(self, key: str) -> None: ... def __setitem__(self, hostname: str, entry: Dict[str, PKey]) -> None: ... def keys(self) -> List[str]: ... # type: ignore def values(self) -> List[_SubDict]: ... # type: ignore @staticmethod def hash_host(hostname: str, salt: Optional[str] = ...) -> str: ... class InvalidHostKey(Exception): line: str exc: Exception def __init__(self, line: str, exc: Exception) -> None: ... class HostKeyEntry: valid: bool hostnames: str key: PKey def __init__(self, hostnames: Optional[List[str]] = ..., key: Optional[PKey] = ...) -> None: ... @classmethod def from_line(cls, line: str, lineno: Optional[int] = ...) -> Optional[HostKeyEntry]: ... def to_line(self) -> Optional[str]: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/paramiko/kex_curve25519.pyi0000664000175000017500000000140300000000000027656 0ustar00davedave00000000000000import sys from _typeshed import ReadableBuffer as ReadableBuffer from typing import Any, Callable, Optional from cryptography.hazmat.primitives.asymmetric.x25519 import X25519PrivateKey from paramiko.message import Message from paramiko.transport import Transport if sys.version_info < (3, 0): from hashlib import _hash as _Hash else: from hashlib import _Hash c_MSG_KEXECDH_INIT: bytes c_MSG_KEXECDH_REPLY: bytes class KexCurve25519: hash_algo: Callable[[ReadableBuffer], _Hash] transport: Transport key: Optional[X25519PrivateKey] def __init__(self, transport: Transport) -> None: ... @classmethod def is_available(cls) -> bool: ... def start_kex(self) -> None: ... def parse_next(self, ptype: int, m: Message) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/paramiko/kex_ecdh_nist.pyi0000664000175000017500000000213000000000000030062 0ustar00davedave00000000000000import sys from _typeshed import ReadableBuffer from typing import Callable, Optional, Union from cryptography.hazmat.primitives.asymmetric.ec2 import EllipticCurve, EllipticCurvePrivateKey, EllipticCurvePublicKey from paramiko.message import Message from paramiko.transport import Transport if sys.version_info < (3, 0): from hashlib import _hash as _Hash else: from hashlib import _Hash c_MSG_KEXECDH_INIT: bytes c_MSG_KEXECDH_REPLY: bytes class KexNistp256: name: str hash_algo: Callable[[ReadableBuffer], _Hash] curve: EllipticCurve transport: Transport P: Union[int, EllipticCurvePrivateKey] Q_C: Optional[EllipticCurvePublicKey] Q_S: Optional[EllipticCurvePublicKey] def __init__(self, transport: Transport) -> None: ... def start_kex(self) -> None: ... def parse_next(self, ptype: int, m: Message) -> None: ... class KexNistp384(KexNistp256): name: str hash_algo: Callable[[ReadableBuffer], _Hash] curve: EllipticCurve class KexNistp521(KexNistp256): name: str hash_algo: Callable[[ReadableBuffer], _Hash] curve: EllipticCurve ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/paramiko/kex_gex.pyi0000664000175000017500000000177700000000000026725 0ustar00davedave00000000000000import sys from _typeshed import ReadableBuffer from typing import Callable, Optional from paramiko.message import Message from paramiko.transport import Transport if sys.version_info < (3, 0): from hashlib import _hash as _Hash else: from hashlib import _Hash c_MSG_KEXDH_GEX_REQUEST_OLD: bytes c_MSG_KEXDH_GEX_GROUP: bytes c_MSG_KEXDH_GEX_INIT: bytes c_MSG_KEXDH_GEX_REPLY: bytes c_MSG_KEXDH_GEX_REQUEST: bytes class KexGex: name: str min_bits: int max_bits: int preferred_bits: int hash_algo: Callable[[ReadableBuffer], _Hash] = ... transport: Transport p: Optional[int] q: Optional[int] g: Optional[int] x: Optional[int] e: Optional[int] f: Optional[int] old_style: bool def __init__(self, transport: Transport) -> None: ... def start_kex(self, _test_old_style: bool = ...) -> None: ... def parse_next(self, ptype: int, m: Message) -> None: ... class KexGexSHA256(KexGex): name: str hash_algo: Callable[[ReadableBuffer], _Hash] = ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/paramiko/kex_group1.pyi0000664000175000017500000000124700000000000027347 0ustar00davedave00000000000000import sys from _typeshed import ReadableBuffer from typing import Callable from paramiko.message import Message from paramiko.transport import Transport if sys.version_info < (3, 0): from hashlib import _hash as _Hash else: from hashlib import _Hash c_MSG_KEXDH_INIT: bytes c_MSG_KEXDH_REPLY: bytes b7fffffffffffffff: bytes b0000000000000000: bytes class KexGroup1: P: int G: int name: str hash_algo: Callable[[ReadableBuffer], _Hash] transport: Transport x: int e: int f: int def __init__(self, transport: Transport) -> None: ... def start_kex(self) -> None: ... def parse_next(self, ptype: int, m: Message) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/paramiko/kex_group14.pyi0000664000175000017500000000070500000000000027431 0ustar00davedave00000000000000import sys from _typeshed import ReadableBuffer from typing import Callable from paramiko.kex_group1 import KexGroup1 as KexGroup1 if sys.version_info < (3, 0): from hashlib import _hash as _Hash else: from hashlib import _Hash class KexGroup14(KexGroup1): P: int G: int name: str hash_algo: Callable[[ReadableBuffer], _Hash] class KexGroup14SHA256(KexGroup14): name: str hash_algo: Callable[[ReadableBuffer], _Hash] ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/paramiko/kex_group16.pyi0000664000175000017500000000054700000000000027437 0ustar00davedave00000000000000import sys from _typeshed import ReadableBuffer from typing import Callable from paramiko.kex_group1 import KexGroup1 as KexGroup1 if sys.version_info < (3, 0): from hashlib import _hash as _Hash else: from hashlib import _Hash class KexGroup16SHA512(KexGroup1): name: str P: int G: int hash_algo: Callable[[ReadableBuffer], _Hash] ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/paramiko/kex_gss.pyi0000664000175000017500000000300300000000000026716 0ustar00davedave00000000000000from typing import Optional from paramiko.message import Message from paramiko.ssh_gss import _SSH_GSSAuth from paramiko.transport import Transport MSG_KEXGSS_INIT: int MSG_KEXGSS_CONTINUE: int MSG_KEXGSS_COMPLETE: int MSG_KEXGSS_HOSTKEY: int MSG_KEXGSS_ERROR: int MSG_KEXGSS_GROUPREQ: int MSG_KEXGSS_GROUP: int c_MSG_KEXGSS_INIT: bytes c_MSG_KEXGSS_CONTINUE: bytes c_MSG_KEXGSS_COMPLETE: bytes c_MSG_KEXGSS_HOSTKEY: bytes c_MSG_KEXGSS_ERROR: bytes c_MSG_KEXGSS_GROUPREQ: bytes c_MSG_KEXGSS_GROUP: bytes class KexGSSGroup1: P: int G: int b7fffffffffffffff: bytes b0000000000000000: bytes NAME: str transport: Transport kexgss: _SSH_GSSAuth gss_host: Optional[str] x: int e: int f: int def __init__(self, transport: Transport) -> None: ... def start_kex(self) -> None: ... def parse_next(self, ptype: int, m: Message) -> None: ... class KexGSSGroup14(KexGSSGroup1): P: int G: int NAME: str class KexGSSGex: NAME: str min_bits: int max_bits: int preferred_bits: int transport: Transport kexgss: _SSH_GSSAuth gss_host: Optional[str] p: Optional[int] q: Optional[int] g: Optional[int] x: Optional[int] e: Optional[int] f: Optional[int] old_style: bool def __init__(self, transport: Transport) -> None: ... def start_kex(self) -> None: ... def parse_next(self, ptype: int, m: Message) -> None: ... class NullHostKey: key: str def __init__(self) -> None: ... def get_name(self) -> str: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/paramiko/message.pyi0000664000175000017500000000273000000000000026705 0ustar00davedave00000000000000import sys from typing import Any, Iterable, List, Optional, Text from .common import _LikeBytes if sys.version_info < (3, 0): from StringIO import StringIO BytesIO = StringIO[bytes] else: from io import BytesIO class Message: big_int: int packet: BytesIO seqno: int # only when packet.Packetizer.read_message() is used def __init__(self, content: Optional[bytes] = ...) -> None: ... def asbytes(self) -> bytes: ... def rewind(self) -> None: ... def get_remainder(self) -> bytes: ... def get_so_far(self) -> bytes: ... def get_bytes(self, n: int) -> bytes: ... def get_byte(self) -> bytes: ... def get_boolean(self) -> bool: ... def get_adaptive_int(self) -> int: ... def get_int(self) -> int: ... def get_int64(self) -> int: ... def get_mpint(self) -> int: ... def get_string(self) -> bytes: ... def get_text(self) -> Text: ... def get_binary(self) -> bytes: ... def get_list(self) -> List[str]: ... def add_bytes(self, b: bytes) -> Message: ... def add_byte(self, b: bytes) -> Message: ... def add_boolean(self, b: bool) -> Message: ... def add_int(self, n: int) -> Message: ... def add_adaptive_int(self, n: int) -> Message: ... def add_int64(self, n: int) -> Message: ... def add_mpint(self, z: int) -> Message: ... def add_string(self, s: _LikeBytes) -> Message: ... def add_list(self, l: Iterable[str]) -> Message: ... def add(self, *seq: Any) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/paramiko/packet.pyi0000664000175000017500000000421300000000000026526 0ustar00davedave00000000000000import sys from logging import Logger from socket import socket from typing import Any, Callable, Tuple from cryptography.hazmat.primitives.ciphers import Cipher from paramiko.compress import ZlibCompressor, ZlibDecompressor from paramiko.message import Message if sys.version_info < (3, 0): from hashlib import _hash as _Hash else: from hashlib import _Hash def compute_hmac(key: bytes, message: bytes, digest_class: _Hash) -> bytes: ... class NeedRekeyException(Exception): ... def first_arg(e: Exception) -> Any: ... class Packetizer: REKEY_PACKETS: int REKEY_BYTES: int REKEY_PACKETS_OVERFLOW_MAX: int REKEY_BYTES_OVERFLOW_MAX: int def __init__(self, socket: socket) -> None: ... @property def closed(self) -> bool: ... def set_log(self, log: Logger) -> None: ... def set_outbound_cipher( self, block_engine: Cipher, block_size: int, mac_engine: _Hash, mac_size: int, mac_key: bytes, sdctr: bool = ..., etm: bool = ..., ) -> None: ... def set_inbound_cipher( self, block_engine: Cipher, block_size: int, mac_engine: _Hash, mac_size: int, mac_key: bytes, etm: bool = ... ) -> None: ... def set_outbound_compressor(self, compressor: ZlibCompressor) -> None: ... def set_inbound_compressor(self, compressor: ZlibDecompressor) -> None: ... def close(self) -> None: ... def set_hexdump(self, hexdump: bool) -> None: ... def get_hexdump(self) -> bool: ... def get_mac_size_in(self) -> int: ... def get_mac_size_out(self) -> int: ... def need_rekey(self) -> bool: ... def set_keepalive(self, interval: int, callback: Callable[[], None]) -> None: ... def read_timer(self) -> None: ... def start_handshake(self, timeout: float) -> None: ... def handshake_timed_out(self) -> bool: ... def complete_handshake(self) -> None: ... def read_all(self, n: int, check_rekey: bool = ...) -> bytes: ... def write_all(self, out: bytes) -> None: ... def readline(self, timeout: float) -> str: ... def send_message(self, data: Message) -> None: ... def read_message(self) -> Tuple[int, Message]: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/paramiko/pipe.pyi0000664000175000017500000000166700000000000026226 0ustar00davedave00000000000000from typing import Protocol, Tuple class _BasePipe(Protocol): def clear(self) -> None: ... def set(self) -> None: ... class _Pipe(_BasePipe, Protocol): def close(self) -> None: ... def fileno(self) -> int: ... def set_forever(self) -> None: ... def make_pipe() -> _Pipe: ... class PosixPipe(object): def __init__(self) -> None: ... def close(self) -> None: ... def fileno(self) -> int: ... def clear(self) -> None: ... def set(self) -> None: ... def set_forever(self) -> None: ... class WindowsPipe(object): def __init__(self) -> None: ... def close(self) -> None: ... def fileno(self) -> int: ... def clear(self) -> None: ... def set(self) -> None: ... def set_forever(self) -> None: ... class OrPipe: def __init__(self, pipe: _Pipe) -> None: ... def set(self) -> None: ... def clear(self) -> None: ... def make_or_pipe(pipe: _Pipe) -> Tuple[OrPipe, OrPipe]: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/paramiko/pkey.pyi0000664000175000017500000000341000000000000026225 0ustar00davedave00000000000000from typing import IO, Any, Optional, Pattern, Text, Union from paramiko.message import Message OPENSSH_AUTH_MAGIC: bytes = ... def _unpad_openssh(data: bytes) -> bytes: ... class PKey: public_blob: Optional[PublicBlob] BEGIN_TAG: Pattern[str] END_TAG: Pattern[str] def __init__(self, msg: Optional[Message] = ..., data: Optional[str] = ...) -> None: ... def asbytes(self) -> bytes: ... def __cmp__(self, other: object) -> int: ... def __eq__(self, other: object) -> bool: ... def get_name(self) -> str: ... def get_bits(self) -> int: ... def can_sign(self) -> bool: ... def get_fingerprint(self) -> bytes: ... def get_base64(self) -> str: ... def sign_ssh_data(self, data: bytes) -> Message: ... def verify_ssh_sig(self, data: bytes, msg: Message) -> bool: ... @classmethod def from_private_key_file(cls: Any, filename: str, password: Optional[str] = ...) -> PKey: ... @classmethod def from_private_key(cls, file_obj: IO[str], password: Optional[str] = ...) -> PKey: ... def write_private_key_file(self, filename: str, password: Optional[str] = ...) -> None: ... def write_private_key(self, file_obj: IO[str], password: Optional[str] = ...) -> None: ... def load_certificate(self, value: Union[Message, str]) -> None: ... class PublicBlob: key_type: str key_blob: str comment: str def __init__(self, type_: str, blob: bytes, comment: Optional[str] = ...) -> None: ... @classmethod def from_file(cls, filename: str) -> PublicBlob: ... @classmethod def from_string(cls, string: str) -> PublicBlob: ... @classmethod def from_message(cls, message: Message) -> PublicBlob: ... def __eq__(self, other: object) -> bool: ... def __ne__(self, other: object) -> bool: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/paramiko/primes.pyi0000664000175000017500000000046400000000000026562 0ustar00davedave00000000000000from typing import Dict, List, Tuple class ModulusPack: pack: Dict[int, List[Tuple[int, int]]] discarded: List[Tuple[int, str]] def __init__(self) -> None: ... def read_file(self, filename: str) -> None: ... def get_modulus(self, min: int, prefer: int, max: int) -> Tuple[int, int]: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/paramiko/proxy.pyi0000664000175000017500000000077000000000000026444 0ustar00davedave00000000000000from subprocess import Popen from typing import List, Optional from paramiko.util import ClosingContextManager class ProxyCommand(ClosingContextManager): cmd: List[str] process: Popen timeout: Optional[float] def __init__(self, command_line: str) -> None: ... def send(self, content: bytes) -> int: ... def recv(self, size: int) -> bytes: ... def close(self) -> None: ... @property def closed(self) -> bool: ... def settimeout(self, timeout: float) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/paramiko/py3compat.pyi0000664000175000017500000000203500000000000027176 0ustar00davedave00000000000000import sys from typing import Any, Iterable, Sequence, Text, Type, TypeVar, Union _T = TypeVar("_T") PY2: bool string_types: Union[Type, Sequence[Type]] text_type: Union[Type, Sequence[Type]] bytes_types: Union[Type, Sequence[Type]] bytes = bytes integer_types: Union[Type, Sequence[Type]] long = int def input(prompt: Any) -> str: ... def decodebytes(s: bytes) -> bytes: ... def encodebytes(s: bytes) -> bytes: ... if sys.version_info < (3, 0): import __builtin__ as builtins import cStringIO StringIO = cStringIO.StringIO BytesIO = StringIO else: import builtins as builtins import io StringIO = io.StringIO BytesIO = io.BytesIO def byte_ord(c: Union[int, str]) -> int: ... def byte_chr(c: int) -> bytes: ... def byte_mask(c: int, mask: int) -> bytes: ... def b(s: Union[bytes, str], encoding: str = ...) -> bytes: ... def u(s: Union[bytes, str], encoding: str = ...) -> Text: ... def b2s(s: Union[bytes, str]) -> str: ... def is_callable(c: Any) -> bool: ... def next(c: Iterable[_T]) -> _T: ... MAXSIZE: int ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/paramiko/rsakey.pyi0000664000175000017500000000250300000000000026555 0ustar00davedave00000000000000from typing import IO, Any, Callable, Optional, Union from cryptography.hazmat.primitives.asymmetric.rsa import RSAPrivateKey, RSAPublicKey, RSAPublicNumbers from paramiko.message import Message from paramiko.pkey import PKey class RSAKey(PKey): key: Union[None, RSAPublicKey, RSAPrivateKey] public_blob: None def __init__( self, msg: Optional[Message] = ..., data: Optional[bytes] = ..., filename: Optional[str] = ..., password: Optional[str] = ..., key: Union[None, RSAPublicKey, RSAPrivateKey] = ..., file_obj: Optional[IO[str]] = ..., ) -> None: ... @property def size(self) -> int: ... @property def public_numbers(self) -> RSAPublicNumbers: ... def asbytes(self) -> bytes: ... def __hash__(self) -> int: ... def get_name(self) -> str: ... def get_bits(self) -> int: ... def can_sign(self) -> bool: ... def sign_ssh_data(self, data: bytes) -> Message: ... def verify_ssh_sig(self, data: bytes, msg: Message) -> bool: ... def write_private_key_file(self, filename: str, password: Optional[str] = ...) -> None: ... def write_private_key(self, file_obj: IO[str], password: Optional[str] = ...) -> None: ... @staticmethod def generate(bits: int, progress_func: Optional[Callable[..., Any]] = ...) -> RSAKey: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/paramiko/server.pyi0000664000175000017500000000576600000000000026603 0ustar00davedave00000000000000import threading from typing import Any, List, Optional, Tuple, Union from paramiko.channel import Channel from paramiko.message import Message from paramiko.pkey import PKey from paramiko.transport import Transport class ServerInterface: def check_channel_request(self, kind: str, chanid: int) -> int: ... def get_allowed_auths(self, username: str) -> str: ... def check_auth_none(self, username: str) -> int: ... def check_auth_password(self, username: str, password: str) -> int: ... def check_auth_publickey(self, username: str, key: PKey) -> int: ... def check_auth_interactive(self, username: str, submethods: str) -> Union[int, InteractiveQuery]: ... def check_auth_interactive_response(self, responses: List[str]) -> Union[int, InteractiveQuery]: ... def check_auth_gssapi_with_mic(self, username: str, gss_authenticated: int = ..., cc_file: Optional[str] = ...) -> int: ... def check_auth_gssapi_keyex(self, username: str, gss_authenticated: int = ..., cc_file: Optional[str] = ...) -> int: ... def enable_auth_gssapi(self) -> bool: ... def check_port_forward_request(self, address: str, port: int) -> int: ... def cancel_port_forward_request(self, address: str, port: int) -> None: ... def check_global_request(self, kind: str, msg: Message) -> Union[bool, Tuple[Any, ...]]: ... def check_channel_pty_request( self, channel: Channel, term: str, width: int, height: int, pixelwidth: int, pixelheight: int, modes: str ) -> bool: ... def check_channel_shell_request(self, channel: Channel) -> bool: ... def check_channel_exec_request(self, channel: Channel, command: bytes) -> bool: ... def check_channel_subsystem_request(self, channel: Channel, name: str) -> bool: ... def check_channel_window_change_request( self, channel: Channel, width: int, height: int, pixelwidth: int, pixelheight: int ) -> bool: ... def check_channel_x11_request( self, channel: Channel, single_connection: bool, auth_protocol: str, auth_cookie: bytes, screen_number: int ) -> bool: ... def check_channel_forward_agent_request(self, channel: Channel) -> bool: ... def check_channel_direct_tcpip_request(self, chanid: int, origin: Tuple[str, int], destination: Tuple[str, int]) -> int: ... def check_channel_env_request(self, channel: Channel, name: str, value: str) -> bool: ... def get_banner(self) -> Tuple[Optional[str], Optional[str]]: ... class InteractiveQuery: name: str instructions: str prompts: List[Tuple[str, bool]] def __init__(self, name: str = ..., instructions: str = ..., *prompts: Union[str, Tuple[str, bool]]) -> None: ... def add_prompt(self, prompt: str, echo: bool = ...) -> None: ... class SubsystemHandler(threading.Thread): def __init__(self, channel: Channel, name: str, server: ServerInterface) -> None: ... def get_server(self) -> ServerInterface: ... def start_subsystem(self, name: str, transport: Transport, channel: Channel) -> None: ... def finish_subsystem(self) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/paramiko/sftp.pyi0000664000175000017500000000205100000000000026231 0ustar00davedave00000000000000from logging import Logger from typing import Dict, List, Optional from paramiko.channel import Channel CMD_INIT: int CMD_VERSION: int CMD_OPEN: int CMD_CLOSE: int CMD_READ: int CMD_WRITE: int CMD_LSTAT: int CMD_FSTAT: int CMD_SETSTAT: int CMD_FSETSTAT: int CMD_OPENDIR: int CMD_READDIR: int CMD_REMOVE: int CMD_MKDIR: int CMD_RMDIR: int CMD_REALPATH: int CMD_STAT: int CMD_RENAME: int CMD_READLINK: int CMD_SYMLINK: int CMD_STATUS: int CMD_HANDLE: int CMD_DATA: int CMD_NAME: int CMD_ATTRS: int CMD_EXTENDED: int CMD_EXTENDED_REPLY: int SFTP_OK: int SFTP_EOF: int SFTP_NO_SUCH_FILE: int SFTP_PERMISSION_DENIED: int SFTP_FAILURE: int SFTP_BAD_MESSAGE: int SFTP_NO_CONNECTION: int SFTP_CONNECTION_LOST: int SFTP_OP_UNSUPPORTED: int SFTP_DESC: List[str] SFTP_FLAG_READ: int SFTP_FLAG_WRITE: int SFTP_FLAG_APPEND: int SFTP_FLAG_CREATE: int SFTP_FLAG_TRUNC: int SFTP_FLAG_EXCL: int CMD_NAMES: Dict[int, str] class SFTPError(Exception): ... class BaseSFTP: logger: Logger sock: Optional[Channel] ultra_debug: bool def __init__(self) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/paramiko/sftp_attr.pyi0000664000175000017500000000123300000000000027264 0ustar00davedave00000000000000from os import stat_result from typing import Dict, Optional class SFTPAttributes: FLAG_SIZE: int FLAG_UIDGID: int FLAG_PERMISSIONS: int FLAG_AMTIME: int FLAG_EXTENDED: int st_size: Optional[int] st_uid: Optional[int] st_gid: Optional[int] st_mode: Optional[int] st_atime: Optional[int] st_mtime: Optional[int] filename: str # only when from_stat() is used longname: str # only when from_stat() is used attr: Dict[str, str] def __init__(self) -> None: ... @classmethod def from_stat(cls, obj: stat_result, filename: Optional[str] = ...) -> SFTPAttributes: ... def asbytes(self) -> bytes: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/paramiko/sftp_client.pyi0000664000175000017500000000607500000000000027601 0ustar00davedave00000000000000from logging import Logger from typing import IO, Any, Callable, Iterator, List, Optional, Text, Tuple, Union from paramiko.channel import Channel from paramiko.sftp import BaseSFTP from paramiko.sftp_attr import SFTPAttributes from paramiko.sftp_file import SFTPFile from paramiko.transport import Transport from paramiko.util import ClosingContextManager _Callback = Callable[[int, int], Any] b_slash: bytes class SFTPClient(BaseSFTP, ClosingContextManager): sock: Channel ultra_debug: bool request_number: int logger: Logger def __init__(self, sock: Channel) -> None: ... @classmethod def from_transport( cls, t: Transport, window_size: Optional[int] = ..., max_packet_size: Optional[int] = ... ) -> Optional[SFTPClient]: ... def close(self) -> None: ... def get_channel(self) -> Optional[Channel]: ... def listdir(self, path: str = ...) -> List[str]: ... def listdir_attr(self, path: str = ...) -> List[SFTPAttributes]: ... def listdir_iter(self, path: Union[bytes, Text] = ..., read_aheads: int = ...) -> Iterator[SFTPAttributes]: ... def open(self, filename: Union[bytes, Text], mode: str = ..., bufsize: int = ...) -> SFTPFile: ... file = open def remove(self, path: Union[bytes, Text]) -> None: ... unlink = remove def rename(self, oldpath: Union[bytes, Text], newpath: Union[bytes, Text]) -> None: ... def posix_rename(self, oldpath: Union[bytes, Text], newpath: Union[bytes, Text]) -> None: ... def mkdir(self, path: Union[bytes, Text], mode: int = ...) -> None: ... def rmdir(self, path: Union[bytes, Text]) -> None: ... def stat(self, path: Union[bytes, Text]) -> SFTPAttributes: ... def lstat(self, path: Union[bytes, Text]) -> SFTPAttributes: ... def symlink(self, source: Union[bytes, Text], dest: Union[bytes, Text]) -> None: ... def chmod(self, path: Union[bytes, Text], mode: int) -> None: ... def chown(self, path: Union[bytes, Text], uid: int, gid: int) -> None: ... def utime(self, path: Union[bytes, Text], times: Optional[Tuple[float, float]]) -> None: ... def truncate(self, path: Union[bytes, Text], size: int) -> None: ... def readlink(self, path: Union[bytes, Text]) -> Optional[Text]: ... def normalize(self, path: Union[bytes, Text]) -> Text: ... def chdir(self, path: Union[None, bytes, Text] = ...) -> None: ... def getcwd(self) -> Optional[Text]: ... def putfo( self, fl: IO[bytes], remotepath: Union[bytes, Text], file_size: int = ..., callback: Optional[_Callback] = ..., confirm: bool = ..., ) -> SFTPAttributes: ... def put( self, localpath: Union[bytes, Text], remotepath: Union[bytes, Text], callback: Optional[_Callback] = ..., confirm: bool = ..., ) -> SFTPAttributes: ... def getfo(self, remotepath: Union[bytes, Text], fl: IO[bytes], callback: Optional[_Callback] = ...) -> int: ... def get(self, remotepath: Union[bytes, Text], localpath: Union[bytes, Text], callback: Optional[_Callback] = ...) -> None: ... class SFTP(SFTPClient): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/paramiko/sftp_file.pyi0000664000175000017500000000251400000000000027234 0ustar00davedave00000000000000from typing import Iterator, Optional, Sequence, Tuple from paramiko.file import BufferedFile from paramiko.sftp_attr import SFTPAttributes from paramiko.sftp_client import SFTPClient from paramiko.sftp_handle import SFTPHandle class SFTPFile(BufferedFile): MAX_REQUEST_SIZE: int sftp: SFTPClient handle: SFTPHandle pipelined: bool def __init__(self, sftp: SFTPClient, handle: bytes, mode: str = ..., bufsize: int = ...) -> None: ... def __del__(self) -> None: ... def close(self) -> None: ... def settimeout(self, timeout: float) -> None: ... def gettimeout(self) -> float: ... def setblocking(self, blocking: bool) -> None: ... def seekable(self) -> bool: ... def seek(self, offset: int, whence: int = ...) -> None: ... def stat(self) -> SFTPAttributes: ... def chmod(self, mode: int) -> None: ... def chown(self, uid: int, gid: int) -> None: ... def utime(self, times: Optional[Tuple[float, float]]) -> None: ... def truncate(self, size: int) -> None: ... def check(self, hash_algorithm: str, offset: int = ..., length: int = ..., block_size: int = ...) -> bytes: ... def set_pipelined(self, pipelined: bool = ...) -> None: ... def prefetch(self, file_size: Optional[int] = ...) -> None: ... def readv(self, chunks: Sequence[Tuple[int, int]]) -> Iterator[bytes]: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/paramiko/sftp_handle.pyi0000664000175000017500000000102300000000000027542 0ustar00davedave00000000000000from typing import Union from paramiko.sftp_attr import SFTPAttributes from paramiko.sftp_server import SFTPServer from paramiko.util import ClosingContextManager class SFTPHandle(ClosingContextManager): def __init__(self, flags: int = ...) -> None: ... def close(self) -> None: ... def read(self, offset: int, length: int) -> Union[bytes, int]: ... def write(self, offset: int, data: bytes) -> int: ... def stat(self) -> Union[int, SFTPAttributes]: ... def chattr(self, attr: SFTPAttributes) -> int: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/paramiko/sftp_server.pyi0000664000175000017500000000210600000000000027620 0ustar00davedave00000000000000from logging import Logger from typing import Any, Dict, Optional, Type from paramiko.channel import Channel from paramiko.server import ServerInterface, SubsystemHandler from paramiko.sftp import BaseSFTP from paramiko.sftp_attr import SFTPAttributes from paramiko.sftp_handle import SFTPHandle from paramiko.sftp_si import SFTPServerInterface from paramiko.transport import Transport class SFTPServer(BaseSFTP, SubsystemHandler): logger: Logger ultra_debug: bool next_handle: int file_table: Dict[bytes, SFTPHandle] folder_table: Dict[bytes, SFTPHandle] server: SFTPServerInterface sock: Optional[Channel] def __init__( self, channel: Channel, name: str, server: ServerInterface, sftp_si: Type[SFTPServerInterface], *largs: Any, **kwargs: Any ) -> None: ... def start_subsystem(self, name: str, transport: Transport, channel: Channel) -> None: ... def finish_subsystem(self) -> None: ... @staticmethod def convert_errno(e: int) -> int: ... @staticmethod def set_file_attr(filename: str, attr: SFTPAttributes) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/paramiko/sftp_si.pyi0000664000175000017500000000225100000000000026726 0ustar00davedave00000000000000from typing import Any, List, Union from paramiko.server import ServerInterface from paramiko.sftp_attr import SFTPAttributes from paramiko.sftp_handle import SFTPHandle class SFTPServerInterface: def __init__(self, server: ServerInterface, *largs: Any, **kwargs: Any) -> None: ... def session_started(self) -> None: ... def session_ended(self) -> None: ... def open(self, path: str, flags: int, attr: SFTPAttributes) -> Union[SFTPHandle, int]: ... def list_folder(self, path: str) -> Union[List[SFTPAttributes], int]: ... def stat(self, path: str) -> Union[SFTPAttributes, int]: ... def lstat(self, path: str) -> Union[SFTPAttributes, int]: ... def remove(self, path: str) -> int: ... def rename(self, oldpath: str, newpath: str) -> int: ... def posix_rename(self, oldpath: str, newpath: str) -> int: ... def mkdir(self, path: str, attr: SFTPAttributes) -> int: ... def rmdir(self, path: str) -> int: ... def chattr(self, path: str, attr: SFTPAttributes) -> int: ... def canonicalize(self, path: str) -> str: ... def readlink(self, path: str) -> Union[str, int]: ... def symlink(self, target_path: str, path: str) -> int: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/paramiko/ssh_exception.pyi0000664000175000017500000000265600000000000030143 0ustar00davedave00000000000000import socket from typing import List, Mapping, Tuple, Union from paramiko.pkey import PKey class SSHException(Exception): ... class AuthenticationException(SSHException): ... class PasswordRequiredException(AuthenticationException): ... class BadAuthenticationType(AuthenticationException): allowed_types: List[str] explanation: str def __init__(self, explanation: str, types: List[str]) -> None: ... class PartialAuthentication(AuthenticationException): allowed_types: List[str] def __init__(self, types: List[str]) -> None: ... class ChannelException(SSHException): code: int text: str def __init__(self, code: int, text: str) -> None: ... class BadHostKeyException(SSHException): hostname: str key: PKey expected_key: PKey def __init__(self, hostname: str, got_key: PKey, expected_key: PKey) -> None: ... class ProxyCommandFailure(SSHException): command: str error: str def __init__(self, command: str, error: str) -> None: ... class NoValidConnectionsError(socket.error): errors: Mapping[Union[Tuple[str, int], Tuple[str, int, int, int]], Exception] def __init__(self, errors: Mapping[Union[Tuple[str, int], Tuple[str, int, int, int]], Exception]) -> None: ... def __reduce__(self) -> Tuple[type, Tuple[Mapping[Union[Tuple[str, int], Tuple[str, int, int, int]], Exception]]]: ... class CouldNotCanonicalize(SSHException): ... class ConfigParseError(SSHException): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/paramiko/ssh_gss.pyi0000664000175000017500000000532600000000000026736 0ustar00davedave00000000000000from typing import Any, Optional, Tuple, Type from paramiko.ssh_exception import SSHException GSS_AUTH_AVAILABLE: bool GSS_EXCEPTIONS: Tuple[Type[Exception], ...] def GSSAuth(auth_method: str, gss_deleg_creds: bool = ...) -> _SSH_GSSAuth: ... class _SSH_GSSAuth: cc_file: None def __init__(self, auth_method: str, gss_deleg_creds: bool) -> None: ... def set_service(self, service: str) -> None: ... def set_username(self, username: str) -> None: ... def ssh_gss_oids(self, mode: str = ...) -> bytes: ... def ssh_check_mech(self, desired_mech: str) -> bool: ... class _SSH_GSSAPI_OLD(_SSH_GSSAuth): def __init__(self, auth_method: str, gss_deleg_creds: bool) -> None: ... def ssh_init_sec_context( self, target: str, desired_mech: Optional[str] = ..., username: Optional[str] = ..., recv_token: Optional[str] = ... ) -> Optional[str]: ... def ssh_get_mic(self, session_id: bytes, gss_kex: bool = ...) -> Any: ... def ssh_accept_sec_context(self, hostname: str, recv_token: str, username: Optional[str] = ...) -> Optional[str]: ... def ssh_check_mic(self, mic_token: str, session_id: bytes, username: Optional[str] = ...) -> None: ... @property def credentials_delegated(self) -> bool: ... def save_client_creds(self, client_token: str) -> None: ... _SSH_GSSAPI = _SSH_GSSAPI_OLD class _SSH_GSSAPI_NEW(_SSH_GSSAuth): def __init__(self, auth_method: str, gss_deleg_creds: bool) -> None: ... def ssh_init_sec_context( self, target: str, desired_mech: Optional[str] = ..., username: Optional[str] = ..., recv_token: Optional[str] = ... ) -> str: ... def ssh_get_mic(self, session_id: bytes, gss_kex: bool = ...) -> Any: ... def ssh_accept_sec_context(self, hostname: str, recv_token: str, username: Optional[str] = ...) -> Optional[str]: ... def ssh_check_mic(self, mic_token: str, session_id: bytes, username: Optional[str] = ...) -> None: ... @property def credentials_delegated(self) -> bool: ... def save_client_creds(self, client_token: str) -> None: ... class _SSH_SSPI(_SSH_GSSAuth): def __init__(self, auth_method: str, gss_deleg_creds: bool) -> None: ... def ssh_init_sec_context( self, target: str, desired_mech: Optional[str] = ..., username: Optional[str] = ..., recv_token: Optional[str] = ... ) -> str: ... def ssh_get_mic(self, session_id: bytes, gss_kex: bool = ...) -> Any: ... def ssh_accept_sec_context(self, hostname: str, username: str, recv_token: str) -> Optional[str]: ... def ssh_check_mic(self, mic_token: str, session_id: bytes, username: Optional[str] = ...) -> None: ... @property def credentials_delegated(self) -> bool: ... def save_client_creds(self, client_token: str) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/paramiko/transport.pyi0000664000175000017500000001741100000000000027317 0ustar00davedave00000000000000from logging import Logger from socket import socket from threading import Condition, Event, Lock, Thread from types import ModuleType from typing import Any, Callable, Dict, Iterable, List, Optional, Protocol, Sequence, Tuple, Type, Union from paramiko.auth_handler import AuthHandler, _InteractiveCallback from paramiko.channel import Channel from paramiko.compress import ZlibCompressor, ZlibDecompressor from paramiko.message import Message from paramiko.packet import NeedRekeyException, Packetizer from paramiko.pkey import PKey from paramiko.primes import ModulusPack from paramiko.server import ServerInterface, SubsystemHandler from paramiko.sftp_client import SFTPClient from paramiko.ssh_gss import _SSH_GSSAuth from paramiko.util import ClosingContextManager _Addr = Tuple[str, int] class _KexEngine(Protocol): def start_kex(self) -> None: ... def parse_next(self, ptype: int, m: Message) -> None: ... class Transport(Thread, ClosingContextManager): active: bool hostname: Optional[str] sock: socket packetizer: Packetizer local_version: str remote_version: str local_cipher: str local_kex_init: Optional[bytes] local_mac: Optional[str] local_compression: Optional[str] session_id: Optional[bytes] host_key_type: Optional[str] host_key: Optional[PKey] use_gss_kex: bool gss_kex_used: bool kexgss_ctxt: Optional[_SSH_GSSAuth] gss_host: str kex_engine: Optional[_KexEngine] H: Optional[bytes] K: Optional[int] initial_kex_done: bool in_kex: bool authenticated: bool lock: Lock channel_events: Dict[int, Event] channels_seen: Dict[int, bool] default_max_packet_size: int default_window_size: int saved_exception: Optional[Exception] clear_to_send: Event clear_to_send_lock: Lock clear_to_send_timeout: float log_name: str logger: Logger auth_handler: Optional[AuthHandler] global_response: Optional[Message] completion_event: Optional[Event] banner_timeout: float handshake_timeout: float auth_timeout: float disabled_algorithms: Optional[Dict[str, Iterable[str]]] server_mode: bool server_object: Optional[ServerInterface] server_key_dict: Dict[str, PKey] server_accepts: List[Channel] server_accept_cv: Condition subsystem_table: Dict[str, Tuple[Type[SubsystemHandler], Tuple[Any, ...], Dict[str, Any]]] sys: ModuleType def __init__( self, sock: Union[str, Tuple[str, int], socket], default_window_size: int = ..., default_max_packet_size: int = ..., gss_kex: bool = ..., gss_deleg_creds: bool = ..., disabled_algorithms: Optional[Dict[str, Iterable[str]]] = ..., ) -> None: ... @property def preferred_ciphers(self) -> Sequence[str]: ... @property def preferred_macs(self) -> Sequence[str]: ... @property def preferred_keys(self) -> Sequence[str]: ... @property def preferred_kex(self) -> Sequence[str]: ... @property def preferred_compression(self) -> Sequence[str]: ... def atfork(self) -> None: ... def get_security_options(self) -> SecurityOptions: ... def set_gss_host(self, gss_host: Optional[str], trust_dns: bool = ..., gssapi_requested: bool = ...) -> None: ... def start_client(self, event: Optional[Event] = ..., timeout: Optional[float] = ...) -> None: ... def start_server(self, event: Event = ..., server: Optional[ServerInterface] = ...) -> None: ... def add_server_key(self, key: PKey) -> None: ... def get_server_key(self) -> Optional[PKey]: ... @staticmethod def load_server_moduli(filename: Optional[str] = ...) -> bool: ... def close(self) -> None: ... def get_remote_server_key(self) -> PKey: ... def is_active(self) -> bool: ... def open_session( self, window_size: Optional[int] = ..., max_packet_size: Optional[int] = ..., timeout: Optional[float] = ... ) -> Channel: ... def open_x11_channel(self, src_addr: _Addr = ...) -> Channel: ... def open_forward_agent_channel(self) -> Channel: ... def open_forwarded_tcpip_channel(self, src_addr: _Addr, dest_addr: _Addr) -> Channel: ... def open_channel( self, kind: str, dest_addr: Optional[_Addr] = ..., src_addr: Optional[_Addr] = ..., window_size: Optional[int] = ..., max_packet_size: Optional[int] = ..., timeout: Optional[float] = ..., ) -> Channel: ... def request_port_forward( self, address: str, port: int, handler: Optional[Callable[[Channel, _Addr, _Addr], None]] = ... ) -> int: ... def cancel_port_forward(self, address: str, port: int) -> None: ... def open_sftp_client(self) -> Optional[SFTPClient]: ... def send_ignore(self, byte_count: int = ...) -> None: ... def renegotiate_keys(self) -> None: ... def set_keepalive(self, interval: int) -> None: ... def global_request(self, kind: str, data: Optional[Iterable[Any]] = ..., wait: bool = ...) -> Optional[Message]: ... def accept(self, timeout: Optional[float] = ...) -> Optional[Channel]: ... def connect( self, hostkey: Optional[PKey] = ..., username: str = ..., password: Optional[str] = ..., pkey: Optional[PKey] = ..., gss_host: Optional[str] = ..., gss_auth: bool = ..., gss_kex: bool = ..., gss_deleg_creds: bool = ..., gss_trust_dns: bool = ..., ) -> None: ... def get_exception(self) -> Optional[Exception]: ... def set_subsystem_handler(self, name: str, handler: Type[SubsystemHandler], *larg: Any, **kwarg: Any) -> None: ... def is_authenticated(self) -> bool: ... def get_username(self) -> Optional[str]: ... def get_banner(self) -> Optional[str]: ... def auth_none(self, username: str) -> List[str]: ... def auth_password(self, username: str, password: str, event: Optional[Event] = ..., fallback: bool = ...) -> List[str]: ... def auth_publickey(self, username: str, key: PKey, event: Optional[Event] = ...) -> List[str]: ... def auth_interactive(self, username: str, handler: _InteractiveCallback, submethods: str = ...) -> List[str]: ... def auth_interactive_dumb( self, username: str, handler: Optional[_InteractiveCallback] = ..., submethods: str = ... ) -> List[str]: ... def auth_gssapi_with_mic(self, username: str, gss_host: str, gss_deleg_creds: bool) -> List[str]: ... def auth_gssapi_keyex(self, username: str) -> List[str]: ... def set_log_channel(self, name: str) -> None: ... def get_log_channel(self) -> str: ... def set_hexdump(self, hexdump: bool) -> None: ... def get_hexdump(self) -> bool: ... def use_compression(self, compress: bool = ...) -> None: ... def getpeername(self) -> Tuple[str, int]: ... def stop_thread(self) -> None: ... def run(self) -> None: ... class SecurityOptions: def __init__(self, transport: Transport) -> None: ... @property def ciphers(self) -> Sequence[str]: ... @ciphers.setter def ciphers(self, x: Sequence[str]) -> None: ... @property def digests(self) -> Sequence[str]: ... @digests.setter def digests(self, x: Sequence[str]) -> None: ... @property def key_types(self) -> Sequence[str]: ... @key_types.setter def key_types(self, x: Sequence[str]) -> None: ... @property def kex(self) -> Sequence[str]: ... @kex.setter def kex(self, x: Sequence[str]) -> None: ... @property def compression(self) -> Sequence[str]: ... @compression.setter def compression(self, x: Sequence[str]) -> None: ... class ChannelMap: def __init__(self) -> None: ... def put(self, chanid: int, chan: Channel) -> None: ... def get(self, chanid: int) -> Channel: ... def delete(self, chanid: int) -> None: ... def values(self) -> List[Channel]: ... def __len__(self) -> int: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/paramiko/util.pyi0000664000175000017500000000353000000000000026235 0ustar00davedave00000000000000import sys from logging import Logger, LogRecord from types import TracebackType from typing import IO, AnyStr, Callable, Generic, List, Optional, Protocol, Text, Type, TypeVar, Union from paramiko.config import SSHConfig, SSHConfigDict from paramiko.hostkeys import HostKeys if sys.version_info < (3, 0): from hashlib import _hash as _Hash else: from hashlib import _Hash class SupportsClose(Protocol): def close(self) -> None: ... _T = TypeVar("_T") _TC = TypeVar("_TC", bound=SupportsClose) def inflate_long(s: bytes, always_positive: bool = ...) -> int: ... deflate_zero: int deflate_ff: int def deflate_long(n: int, add_sign_padding: bool = ...) -> bytes: ... def format_binary(data: bytes, prefix: str = ...) -> List[str]: ... def format_binary_line(data: bytes) -> str: ... def safe_string(s: bytes) -> bytes: ... def bit_length(n: int) -> int: ... def tb_strings() -> List[str]: ... def generate_key_bytes(hash_alg: Type[_Hash], salt: bytes, key: Union[bytes, str], nbytes: int) -> bytes: ... def load_host_keys(filename: str) -> HostKeys: ... def parse_ssh_config(file_obj: IO[str]) -> SSHConfig: ... def lookup_ssh_host_config(hostname: str, config: SSHConfig) -> SSHConfigDict: ... def mod_inverse(x: int, m: int) -> int: ... def get_thread_id() -> int: ... def log_to_file(filename: str, level: int = ...) -> None: ... class PFilter: def filter(self, record: LogRecord) -> bool: ... def get_logger(name: str) -> Logger: ... def retry_on_signal(function: Callable[[], _T]) -> _T: ... def constant_time_bytes_eq(a: AnyStr, b: AnyStr) -> bool: ... class ClosingContextManager: def __enter__(self: _TC) -> _TC: ... def __exit__( self: _TC, type: Optional[Type[BaseException]], value: Optional[BaseException], traceback: Optional[TracebackType] ) -> None: ... def clamp_value(minimum: int, val: int, maximum: int) -> int: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/paramiko/win_pageant.pyi0000664000175000017500000000053500000000000027556 0ustar00davedave00000000000000import ctypes.wintypes import sys assert sys.platform == "win32" win32con_WM_COPYDATA: int def can_talk_to_agent(): ... class COPYDATASTRUCT(ctypes.Structure): ... class PageantConnection: def __init__(self) -> None: ... def send(self, data: bytes) -> None: ... def recv(self, n: int) -> bytes: ... def close(self) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/polib.pyi0000664000175000017500000001320400000000000024561 0ustar00davedave00000000000000import textwrap from typing import IO, Any, Callable, Dict, Generic, List, Optional, Text, Tuple, Type, TypeVar, Union, overload _TB = TypeVar("_TB", bound="_BaseEntry") _TP = TypeVar("_TP", bound="POFile") _TM = TypeVar("_TM", bound="MOFile") default_encoding: str # wrapwidth: int # encoding: str # check_for_duplicates: bool @overload def pofile(pofile: Text, *, klass: Type[_TP], **kwargs: Any) -> _TP: ... @overload def pofile(pofile: Text, **kwargs: Any) -> POFile: ... @overload def mofile(mofile: Text, *, klass: Type[_TM], **kwargs: Any) -> _TM: ... @overload def mofile(mofile: Text, **kwargs: Any) -> MOFile: ... def detect_encoding(file: Union[bytes, Text], binary_mode: bool = ...) -> str: ... def escape(st: Text) -> Text: ... def unescape(st: Text) -> Text: ... class _BaseFile(List[_TB]): fpath: Text wrapwidth: int encoding: Text check_for_duplicates: bool header: Text metadata: Dict[Text, Text] metadata_is_fuzzy: bool def __init__(self, *args: Any, **kwargs: Any) -> None: ... def __unicode__(self) -> Text: ... def __contains__(self, entry: _TB) -> bool: ... # type: ignore # AttributeError otherwise def __eq__(self, other: object) -> bool: ... def append(self, entry: _TB) -> None: ... def insert(self, index: int, entry: _TB) -> None: ... def metadata_as_entry(self) -> POEntry: ... def save(self, fpath: Optional[Text] = ..., repr_method: str = ...) -> None: ... def find(self, st: Text, by: str = ..., include_obsolete_entries: bool = ..., msgctxt: bool = ...) -> Optional[_TB]: ... def ordered_metadata(self) -> List[Text]: ... def to_binary(self) -> bytes: ... class POFile(_BaseFile): def __unicode__(self) -> Text: ... def save_as_mofile(self, fpath: Text) -> None: ... def percent_translated(self) -> int: ... def translated_entries(self) -> List[POEntry]: ... def untranslated_entries(self) -> List[POEntry]: ... def fuzzy_entries(self) -> List[POEntry]: ... def obsolete_entries(self) -> List[POEntry]: ... def merge(self, refpot: POFile) -> None: ... class MOFile(_BaseFile): MAGIC: int MAGIC_SWAPPED: int magic_number: Optional[int] version: int def __init__(self, *args: Any, **kwargs: Any) -> None: ... def save_as_pofile(self, fpath: str) -> None: ... def save(self, fpath: Optional[Text] = ...) -> None: ... # type: ignore # binary file does not allow argument repr_method def percent_translated(self) -> int: ... def translated_entries(self) -> List[MOEntry]: ... def untranslated_entries(self) -> List[MOEntry]: ... def fuzzy_entries(self) -> List[MOEntry]: ... def obsolete_entries(self) -> List[MOEntry]: ... class _BaseEntry(object): msgid: Text msgstr: Text msgid_plural: List[Text] msgstr_plural: List[Text] msgctxt: Text obsolete: bool encoding: str def __init__(self, *args: Any, **kwargs: Any) -> None: ... def __unicode__(self, wrapwidth: int = ...) -> Text: ... def __eq__(self, other: object) -> bool: ... class POEntry(_BaseEntry): comment: Text tcomment: Text occurrences: List[Tuple[str, int]] flags: List[Text] previous_msgctxt: Optional[Text] previous_msgid: Optional[Text] previous_msgid_plural: Optional[Text] linenum: Optional[int] def __init__(self, *args: Any, **kwargs: Any) -> None: ... def __unicode__(self, wrapwidth: int = ...) -> Text: ... def __cmp__(self, other: POEntry) -> int: ... def __gt__(self, other: POEntry) -> bool: ... def __lt__(self, other: POEntry) -> bool: ... def __ge__(self, other: POEntry) -> bool: ... def __le__(self, other: POEntry) -> bool: ... def __eq__(self, other: Any) -> bool: ... def __ne__(self, other: Any) -> bool: ... def translated(self) -> bool: ... def merge(self, other: POEntry) -> None: ... @property def fuzzy(self) -> bool: ... @property def msgid_with_context(self) -> Text: ... def __hash__(self) -> int: ... class MOEntry(_BaseEntry): comment: Text tcomment: Text occurrences: List[Tuple[str, int]] flags: List[Text] previous_msgctxt: Optional[Text] previous_msgid: Optional[Text] previous_msgid_plural: Optional[Text] def __init__(self, *args: Any, **kwargs: Any) -> None: ... def __hash__(self) -> int: ... class _POFileParser(Generic[_TP]): fhandle: IO[Text] instance: _TP transitions: Dict[Tuple[str, str], Tuple[Callable[[], bool], str]] current_line: int current_entry: POEntry current_state: str current_token: Optional[str] msgstr_index: int entry_obsolete: int def __init__(self, pofile: Text, *args: Any, **kwargs: Any) -> None: ... def parse(self) -> _TP: ... def add(self, symbol: str, states: List[str], next_state: str) -> None: ... def process(self, symbol: str) -> None: ... def handle_he(self) -> bool: ... def handle_tc(self) -> bool: ... def handle_gc(self) -> bool: ... def handle_oc(self) -> bool: ... def handle_fl(self) -> bool: ... def handle_pp(self) -> bool: ... def handle_pm(self) -> bool: ... def handle_pc(self) -> bool: ... def handle_ct(self) -> bool: ... def handle_mi(self) -> bool: ... def handle_mp(self) -> bool: ... def handle_ms(self) -> bool: ... def handle_mx(self) -> bool: ... def handle_mc(self) -> bool: ... class _MOFileParser(Generic[_TM]): fhandle: IO[bytes] instance: _TM def __init__(self, mofile: Text, *args: Any, **kwargs: Any) -> None: ... def __del__(self) -> None: ... def parse(self) -> _TM: ... class TextWrapper(textwrap.TextWrapper): drop_whitespace: bool def __init__(self, *args: Any, **kwargs: Any) -> None: ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4543793 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/pyVmomi/0000775000175000017500000000000000000000000024371 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/pyVmomi/__init__.pyi0000664000175000017500000000000000000000000026641 0ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4543793 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/pyVmomi/vim/0000775000175000017500000000000000000000000025164 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/pyVmomi/vim/__init__.pyi0000664000175000017500000000422500000000000027451 0ustar00davedave00000000000000from datetime import datetime from enum import Enum from typing import Any, List from ..vmodl.query import PropertyCollector from .event import EventManager from .option import OptionManager from .view import ViewManager def __getattr__(name: str) -> Any: ... # incomplete class ManagedObject: ... class ManagedEntity(ManagedObject): _moId: str obj: None name: str def __getattr__(self, name: str) -> Any: ... # incomplete class ServiceInstanceContent: setting: OptionManager propertyCollector: PropertyCollector rootFolder: Folder viewManager: ViewManager perfManager: PerformanceManager eventManager: EventManager def __getattr__(self, name: str) -> Any: ... # incomplete class ServiceInstance: content: ServiceInstanceContent def CurrentTime(self) -> datetime: ... def __getattr__(self, name: str) -> Any: ... # incomplete class PerformanceManager: class MetricId: counterId: int instance: str def __init__(self, counterId: int, instance: str): ... class PerfCounterInfo: key: int groupInfo: Any nameInfo: Any rollupType: Any def __getattr__(self, name: str) -> Any: ... # incomplete class QuerySpec: entity: ManagedEntity metricId: List[PerformanceManager.MetricId] intervalId: int maxSample: int startTime: datetime def __getattr__(self, name: str) -> Any: ... # incomplete class EntityMetricBase: entity: ManagedEntity def QueryPerfCounterByLevel(self, collection_level: int) -> List[PerformanceManager.PerfCounterInfo]: ... def QueryPerf(self, querySpec: List[PerformanceManager.QuerySpec]) -> List[PerformanceManager.EntityMetricBase]: ... def __getattr__(self, name: str) -> Any: ... # incomplete class ClusterComputeResource(ManagedEntity): ... class ComputeResource(ManagedEntity): ... class Datacenter(ManagedEntity): ... class Datastore(ManagedEntity): ... class Folder(ManagedEntity): ... class HostSystem(ManagedEntity): ... class VirtualMachine(ManagedEntity): ... class VirtualMachinePowerState(Enum): poweredOff: int poweredOn: int suspended: int ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/pyVmomi/vim/event.pyi0000664000175000017500000000061300000000000027030 0ustar00davedave00000000000000from datetime import datetime from typing import Any, List def __getattr__(name: str) -> Any: ... # incomplete class Event: createdTime: datetime class EventFilterSpec: class ByTime: def __init__(self, beginTime: datetime): ... time: EventFilterSpec.ByTime class EventManager: latestEvent: Event def QueryEvents(self, filer: EventFilterSpec) -> List[Event]: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/pyVmomi/vim/fault.pyi0000664000175000017500000000030300000000000027016 0ustar00davedave00000000000000from typing import Any def __getattr__(name: str) -> Any: ... # incomplete class InvalidName(Exception): ... class RestrictedByAdministrator(Exception): ... class NoPermission(Exception): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/pyVmomi/vim/option.pyi0000664000175000017500000000031400000000000027215 0ustar00davedave00000000000000from typing import Any, List def __getattr__(name: str) -> Any: ... # incomplete class OptionManager: def QueryOptions(self, name: str) -> List[OptionValue]: ... class OptionValue: value: Any ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/pyVmomi/vim/view.pyi0000664000175000017500000000111200000000000026654 0ustar00davedave00000000000000from typing import Any, List, Type from pyVmomi.vim import ManagedEntity def __getattr__(name: str) -> Any: ... # incomplete class ContainerView: def Destroy(self) -> None: ... class ViewManager: # Doc says the `type` parameter of CreateContainerView is a `List[str]`, # but in practice it seems to be `List[Type[ManagedEntity]]` # Source: https://pubs.vmware.com/vi-sdk/visdk250/ReferenceGuide/vim.view.ViewManager.html @staticmethod def CreateContainerView(container: ManagedEntity, type: List[Type[ManagedEntity]], recursive: bool) -> ContainerView: ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4543793 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/pyVmomi/vmodl/0000775000175000017500000000000000000000000025512 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/pyVmomi/vmodl/__init__.pyi0000664000175000017500000000011200000000000027766 0ustar00davedave00000000000000from typing import Any class DynamicProperty: name: str val: Any ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/pyVmomi/vmodl/fault.pyi0000664000175000017500000000016400000000000027351 0ustar00davedave00000000000000from typing import Any def __getattr__(name: str) -> Any: ... # incomplete class InvalidArgument(Exception): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/pyVmomi/vmodl/query.pyi0000664000175000017500000000262600000000000027410 0ustar00davedave00000000000000from typing import Any, List, Optional, Type from pyVmomi.vim import ManagedEntity from pyVmomi.vim.view import ContainerView from pyVmomi.vmodl import DynamicProperty class PropertyCollector: class PropertySpec: all: bool type: Type[ManagedEntity] pathSet: List[str] class TraversalSpec: path: str skip: bool type: Type[ContainerView] def __getattr__(self, name: str) -> Any: ... # incomplete class RetrieveOptions: maxObjects: int class ObjectSpec: skip: bool selectSet: List[PropertyCollector.TraversalSpec] obj: Any class FilterSpec: propSet: List[PropertyCollector.PropertySpec] objectSet: List[PropertyCollector.ObjectSpec] def __getattr__(self, name: str) -> Any: ... # incomplete class ObjectContent: obj: ManagedEntity propSet: List[DynamicProperty] def __getattr__(self, name: str) -> Any: ... # incomplete class RetrieveResult: objects: List[PropertyCollector.ObjectContent] token: Optional[str] def RetrievePropertiesEx( self, specSet: List[PropertyCollector.FilterSpec], options: PropertyCollector.RetrieveOptions ) -> PropertyCollector.RetrieveResult: ... def ContinueRetrievePropertiesEx(self, token: str) -> PropertyCollector.RetrieveResult: ... def __getattr__(self, name: str) -> Any: ... # incomplete ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/pycurl.pyi0000664000175000017500000003267300000000000025005 0ustar00davedave00000000000000# TODO(MichalPokorny): more precise types from typing import Any, List, Text, Tuple GLOBAL_ACK_EINTR: int GLOBAL_ALL: int GLOBAL_DEFAULT: int GLOBAL_NOTHING: int GLOBAL_SSL: int GLOBAL_WIN32: int def global_init(option: int) -> None: ... def global_cleanup() -> None: ... version: str def version_info() -> Tuple[int, str, int, str, int, str, int, str, Tuple[str, ...], Any, int, Any]: ... class error(Exception): ... class Curl(object): def close(self) -> None: ... def setopt(self, option: int, value: Any) -> None: ... def setopt_string(self, option: int, value: str) -> None: ... def perform(self) -> None: ... def perform_rb(self) -> bytes: ... def perform_rs(self) -> Text: ... def getinfo(self, info: Any) -> Any: ... def getinfo_raw(self, info: Any) -> Any: ... def reset(self) -> None: ... def unsetopt(self, option: int) -> Any: ... def pause(self, bitmask: Any) -> Any: ... def errstr(self) -> str: ... # TODO(MichalPokorny): wat? USERPWD: int class CurlMulti(object): def close(self) -> None: ... def add_handle(self, obj: Curl) -> None: ... def remove_handle(self, obj: Curl) -> None: ... def perform(self) -> Tuple[Any, int]: ... def fdset(self) -> Tuple[List[Any], List[Any], List[Any]]: ... def select(self, timeout: float = ...) -> int: ... def info_read(self, max_objects: int = ...) -> Tuple[int, List[Any], List[Any]]: ... def socket_action(self, sockfd: int, ev_bitmask: int) -> Tuple[int, int]: ... class CurlShare(object): def close(self) -> None: ... def setopt(self, option: int, value: Any) -> Any: ... ACCEPTTIMEOUT_MS: int ACCEPT_ENCODING: int ADDRESS_SCOPE: int APPCONNECT_TIME: int APPEND: int AUTOREFERER: int BUFFERSIZE: int CAINFO: int CAPATH: int CLOSESOCKETFUNCTION: int COMPILE_LIBCURL_VERSION_NUM: int COMPILE_PY_VERSION_HEX: int CONDITION_UNMET: int CONNECTTIMEOUT: int CONNECTTIMEOUT_MS: int CONNECT_ONLY: int CONNECT_TIME: int CONNECT_TO: int CONTENT_LENGTH_DOWNLOAD: int CONTENT_LENGTH_UPLOAD: int CONTENT_TYPE: int COOKIE: int COOKIEFILE: int COOKIEJAR: int COOKIELIST: int COOKIESESSION: int COPYPOSTFIELDS: int CRLF: int CRLFILE: int CSELECT_ERR: int CSELECT_IN: int CSELECT_OUT: int CURL_HTTP_VERSION_1_0: int CURL_HTTP_VERSION_1_1: int CURL_HTTP_VERSION_2: int CURL_HTTP_VERSION_2_0: int CURL_HTTP_VERSION_LAST: int CURL_HTTP_VERSION_NONE: int CUSTOMREQUEST: int DEBUGFUNCTION: int DEFAULT_PROTOCOL: int DIRLISTONLY: int DNS_CACHE_TIMEOUT: int DNS_SERVERS: int DNS_USE_GLOBAL_CACHE: int EFFECTIVE_URL: int EGDSOCKET: int ENCODING: int EXPECT_100_TIMEOUT_MS: int FAILONERROR: int FILE: int FOLLOWLOCATION: int FORBID_REUSE: int FORM_BUFFER: int FORM_BUFFERPTR: int FORM_CONTENTS: int FORM_CONTENTTYPE: int FORM_FILE: int FORM_FILENAME: int FRESH_CONNECT: int FTPAPPEND: int FTPAUTH_DEFAULT: int FTPAUTH_SSL: int FTPAUTH_TLS: int FTPLISTONLY: int FTPMETHOD_DEFAULT: int FTPMETHOD_MULTICWD: int FTPMETHOD_NOCWD: int FTPMETHOD_SINGLECWD: int FTPPORT: int FTPSSLAUTH: int FTPSSL_ALL: int FTPSSL_CONTROL: int FTPSSL_NONE: int FTPSSL_TRY: int FTP_ACCOUNT: int FTP_ALTERNATIVE_TO_USER: int FTP_CREATE_MISSING_DIRS: int FTP_ENTRY_PATH: int FTP_FILEMETHOD: int FTP_RESPONSE_TIMEOUT: int FTP_SKIP_PASV_IP: int FTP_SSL: int FTP_SSL_CCC: int FTP_USE_EPRT: int FTP_USE_EPSV: int FTP_USE_PRET: int GSSAPI_DELEGATION: int GSSAPI_DELEGATION_FLAG: int GSSAPI_DELEGATION_NONE: int GSSAPI_DELEGATION_POLICY_FLAG: int HEADER: int HEADERFUNCTION: int HEADEROPT: int HEADER_SEPARATE: int HEADER_SIZE: int HEADER_UNIFIED: int HTTP200ALIASES: int HTTPAUTH: int HTTPAUTH_ANY: int HTTPAUTH_ANYSAFE: int HTTPAUTH_AVAIL: int HTTPAUTH_BASIC: int HTTPAUTH_DIGEST: int HTTPAUTH_DIGEST_IE: int HTTPAUTH_GSSNEGOTIATE: int HTTPAUTH_NEGOTIATE: int HTTPAUTH_NONE: int HTTPAUTH_NTLM: int HTTPAUTH_NTLM_WB: int HTTPAUTH_ONLY: int HTTPGET: int HTTPHEADER: int HTTPPOST: int HTTPPROXYTUNNEL: int HTTP_CODE: int HTTP_CONNECTCODE: int HTTP_CONTENT_DECODING: int HTTP_TRANSFER_DECODING: int HTTP_VERSION: int IGNORE_CONTENT_LENGTH: int INFILE: int INFILESIZE: int INFILESIZE_LARGE: int INFOTYPE_DATA_IN: int INFOTYPE_DATA_OUT: int INFOTYPE_HEADER_IN: int INFOTYPE_HEADER_OUT: int INFOTYPE_SSL_DATA_IN: int INFOTYPE_SSL_DATA_OUT: int INFOTYPE_TEXT: int INFO_CERTINFO: int INFO_COOKIELIST: int INFO_FILETIME: int INFO_HTTP_VERSION: int INFO_RTSP_CLIENT_CSEQ: int INFO_RTSP_CSEQ_RECV: int INFO_RTSP_SERVER_CSEQ: int INFO_RTSP_SESSION_ID: int INTERFACE: int IOCMD_NOP: int IOCMD_RESTARTREAD: int IOCTLFUNCTION: int IOE_FAILRESTART: int IOE_OK: int IOE_UNKNOWNCMD: int IPRESOLVE: int IPRESOLVE_V4: int IPRESOLVE_V6: int IPRESOLVE_WHATEVER: int ISSUERCERT: int KEYPASSWD: int KHMATCH_MISMATCH: int KHMATCH_MISSING: int KHMATCH_OK: int KHSTAT_DEFER: int KHSTAT_FINE: int KHSTAT_FINE_ADD_TO_FILE: int KHSTAT_REJECT: int KHTYPE_DSS: int KHTYPE_RSA: int KHTYPE_RSA1: int KHTYPE_UNKNOWN: int KRB4LEVEL: int KRBLEVEL: int LASTSOCKET: int LOCALPORT: int LOCALPORTRANGE: int LOCAL_IP: int LOCAL_PORT: int LOCK_DATA_COOKIE: int LOCK_DATA_DNS: int LOCK_DATA_SSL_SESSION: int LOGIN_OPTIONS: int LOW_SPEED_LIMIT: int LOW_SPEED_TIME: int MAIL_AUTH: int MAIL_FROM: int MAIL_RCPT: int MAXCONNECTS: int MAXFILESIZE: int MAXFILESIZE_LARGE: int MAXREDIRS: int MAX_RECV_SPEED_LARGE: int MAX_SEND_SPEED_LARGE: int M_CHUNK_LENGTH_PENALTY_SIZE: int M_CONTENT_LENGTH_PENALTY_SIZE: int M_MAXCONNECTS: int M_MAX_HOST_CONNECTIONS: int M_MAX_PIPELINE_LENGTH: int M_MAX_TOTAL_CONNECTIONS: int M_PIPELINING: int M_PIPELINING_SERVER_BL: int M_PIPELINING_SITE_BL: int M_SOCKETFUNCTION: int M_TIMERFUNCTION: int NAMELOOKUP_TIME: int NETRC: int NETRC_FILE: int NETRC_IGNORED: int NETRC_OPTIONAL: int NETRC_REQUIRED: int NEW_DIRECTORY_PERMS: int NEW_FILE_PERMS: int NOBODY: int NOPROGRESS: int NOPROXY: int NOSIGNAL: int NUM_CONNECTS: int OPENSOCKETFUNCTION: int OPT_CERTINFO: int OPT_COOKIELIST: int OPT_FILETIME: int OPT_RTSP_CLIENT_CSEQ: int OPT_RTSP_REQUEST: int OPT_RTSP_SERVER_CSEQ: int OPT_RTSP_SESSION_ID: int OPT_RTSP_STREAM_URI: int OPT_RTSP_TRANSPORT: int OS_ERRNO: int PASSWORD: int PATH_AS_IS: int PAUSE_ALL: int PAUSE_CONT: int PAUSE_RECV: int PAUSE_SEND: int PINNEDPUBLICKEY: int PIPEWAIT: int PIPE_MULTIPLEX: int PIPE_NOTHING: int POLL_IN: int POLL_INOUT: int POLL_NONE: int POLL_OUT: int POLL_REMOVE: int PORT: int POST: int POST301: int POSTFIELDS: int POSTFIELDSIZE: int POSTFIELDSIZE_LARGE: int POSTQUOTE: int POSTREDIR: int PREQUOTE: int PRETRANSFER_TIME: int PRE_PROXY: int PRIMARY_IP: int PRIMARY_PORT: int PROGRESSFUNCTION: int PROTOCOLS: int PROTO_ALL: int PROTO_DICT: int PROTO_FILE: int PROTO_FTP: int PROTO_FTPS: int PROTO_GOPHER: int PROTO_HTTP: int PROTO_HTTPS: int PROTO_IMAP: int PROTO_IMAPS: int PROTO_LDAP: int PROTO_LDAPS: int PROTO_POP3: int PROTO_POP3S: int PROTO_RTMP: int PROTO_RTMPE: int PROTO_RTMPS: int PROTO_RTMPT: int PROTO_RTMPTE: int PROTO_RTMPTS: int PROTO_RTSP: int PROTO_SCP: int PROTO_SFTP: int PROTO_SMB: int PROTO_SMBS: int PROTO_SMTP: int PROTO_SMTPS: int PROTO_TELNET: int PROTO_TFTP: int PROXY: int PROXYAUTH: int PROXYAUTH_AVAIL: int PROXYHEADER: int PROXYPASSWORD: int PROXYPORT: int PROXYTYPE: int PROXYTYPE_HTTP: int PROXYTYPE_HTTP_1_0: int PROXYTYPE_SOCKS4: int PROXYTYPE_SOCKS4A: int PROXYTYPE_SOCKS5: int PROXYTYPE_SOCKS5_HOSTNAME: int PROXYUSERNAME: int PROXYUSERPWD: int PROXY_CAINFO: int PROXY_CAPATH: int PROXY_SERVICE_NAME: int PROXY_SSLCERT: int PROXY_SSLCERTTYPE: int PROXY_SSLKEY: int PROXY_SSLKEYTYPE: int PROXY_SSL_VERIFYHOST: int PROXY_SSL_VERIFYPEER: int PROXY_TRANSFER_MODE: int PUT: int QUOTE: int RANDOM_FILE: int RANGE: int READDATA: int READFUNCTION: int READFUNC_ABORT: int READFUNC_PAUSE: int REDIRECT_COUNT: int REDIRECT_TIME: int REDIRECT_URL: int REDIR_POST_301: int REDIR_POST_302: int REDIR_POST_303: int REDIR_POST_ALL: int REDIR_PROTOCOLS: int REFERER: int REQUEST_SIZE: int RESOLVE: int RESPONSE_CODE: int RESUME_FROM: int RESUME_FROM_LARGE: int RTSPREQ_ANNOUNCE: int RTSPREQ_DESCRIBE: int RTSPREQ_GET_PARAMETER: int RTSPREQ_LAST: int RTSPREQ_NONE: int RTSPREQ_OPTIONS: int RTSPREQ_PAUSE: int RTSPREQ_PLAY: int RTSPREQ_RECEIVE: int RTSPREQ_RECORD: int RTSPREQ_SETUP: int RTSPREQ_SET_PARAMETER: int RTSPREQ_TEARDOWN: int SASL_IR: int SEEKFUNCTION: int SEEKFUNC_CANTSEEK: int SEEKFUNC_FAIL: int SEEKFUNC_OK: int SERVICE_NAME: int SHARE: int SH_SHARE: int SH_UNSHARE: int SIZE_DOWNLOAD: int SIZE_UPLOAD: int SOCKET_BAD: int SOCKET_TIMEOUT: int SOCKOPTFUNCTION: int SOCKOPT_ALREADY_CONNECTED: int SOCKOPT_ERROR: int SOCKOPT_OK: int SOCKS5_GSSAPI_NEC: int SOCKS5_GSSAPI_SERVICE: int SOCKTYPE_ACCEPT: int SOCKTYPE_IPCXN: int SPEED_DOWNLOAD: int SPEED_UPLOAD: int SSH_AUTH_AGENT: int SSH_AUTH_ANY: int SSH_AUTH_DEFAULT: int SSH_AUTH_HOST: int SSH_AUTH_KEYBOARD: int SSH_AUTH_NONE: int SSH_AUTH_PASSWORD: int SSH_AUTH_PUBLICKEY: int SSH_AUTH_TYPES: int SSH_HOST_PUBLIC_KEY_MD5: int SSH_KEYFUNCTION: int SSH_KNOWNHOSTS: int SSH_PRIVATE_KEYFILE: int SSH_PUBLIC_KEYFILE: int SSLCERT: int SSLCERTPASSWD: int SSLCERTTYPE: int SSLENGINE: int SSLENGINE_DEFAULT: int SSLKEY: int SSLKEYPASSWD: int SSLKEYTYPE: int SSLOPT_ALLOW_BEAST: int SSLOPT_NO_REVOKE: int SSLVERSION: int SSLVERSION_DEFAULT: int SSLVERSION_SSLv2: int SSLVERSION_SSLv3: int SSLVERSION_TLSv1: int SSLVERSION_TLSv1_0: int SSLVERSION_TLSv1_1: int SSLVERSION_TLSv1_2: int SSLVERSION_MAX_DEFAULT: int SSL_CIPHER_LIST: int SSL_ENABLE_ALPN: int SSL_ENABLE_NPN: int SSL_ENGINES: int SSL_FALSESTART: int SSL_OPTIONS: int SSL_SESSIONID_CACHE: int SSL_VERIFYHOST: int SSL_VERIFYPEER: int SSL_VERIFYRESULT: int SSL_VERIFYSTATUS: int STARTTRANSFER_TIME: int STDERR: int TCP_FASTOPEN: int TCP_KEEPALIVE: int TCP_KEEPIDLE: int TCP_KEEPINTVL: int TCP_NODELAY: int TELNETOPTIONS: int TFTP_BLKSIZE: int TIMECONDITION: int TIMECONDITION_IFMODSINCE: int TIMECONDITION_IFUNMODSINCE: int TIMECONDITION_LASTMOD: int TIMECONDITION_NONE: int TIMEOUT: int TIMEOUT_MS: int TIMEVALUE: int TLSAUTH_PASSWORD: int TLSAUTH_TYPE: int TLSAUTH_USERNAME: int TOTAL_TIME: int TRANSFERTEXT: int TRANSFER_ENCODING: int UNIX_SOCKET_PATH: int UNRESTRICTED_AUTH: int UPLOAD: int URL: int USERAGENT: int USERNAME: int USERPWD: int USESSL_ALL: int USESSL_CONTROL: int USESSL_NONE: int USESSL_TRY: int USE_SSL: int VERBOSE: int VERSION_ASYNCHDNS: int VERSION_CONV: int VERSION_CURLDEBUG: int VERSION_DEBUG: int VERSION_FIRST: int VERSION_GSSAPI: int VERSION_GSSNEGOTIATE: int VERSION_HTTP2: int VERSION_IDN: int VERSION_IPV6: int VERSION_KERBEROS4: int VERSION_KERBEROS5: int VERSION_LARGEFILE: int VERSION_LIBZ: int VERSION_NTLM: int VERSION_NTLM_WB: int VERSION_PSL: int VERSION_SPNEGO: int VERSION_SSL: int VERSION_SSPI: int VERSION_TLSAUTH_SRP: int VERSION_UNIX_SOCKETS: int WILDCARDMATCH: int WRITEDATA: int WRITEFUNCTION: int WRITEFUNC_PAUSE: int WRITEHEADER: int XFERINFOFUNCTION: int XOAUTH2_BEARER: int E_ABORTED_BY_CALLBACK: int E_AGAIN: int E_ALREADY_COMPLETE: int E_BAD_CALLING_ORDER: int E_BAD_CONTENT_ENCODING: int E_BAD_DOWNLOAD_RESUME: int E_BAD_FUNCTION_ARGUMENT: int E_BAD_PASSWORD_ENTERED: int E_CALL_MULTI_PERFORM: int E_CHUNK_FAILED: int E_CONV_FAILED: int E_CONV_REQD: int E_COULDNT_CONNECT: int E_COULDNT_RESOLVE_HOST: int E_COULDNT_RESOLVE_PROXY: int E_FAILED_INIT: int E_FILESIZE_EXCEEDED: int E_FILE_COULDNT_READ_FILE: int E_FTP_ACCEPT_FAILED: int E_FTP_ACCEPT_TIMEOUT: int E_FTP_ACCESS_DENIED: int E_FTP_BAD_DOWNLOAD_RESUME: int E_FTP_BAD_FILE_LIST: int E_FTP_CANT_GET_HOST: int E_FTP_CANT_RECONNECT: int E_FTP_COULDNT_GET_SIZE: int E_FTP_COULDNT_RETR_FILE: int E_FTP_COULDNT_SET_ASCII: int E_FTP_COULDNT_SET_BINARY: int E_FTP_COULDNT_SET_TYPE: int E_FTP_COULDNT_STOR_FILE: int E_FTP_COULDNT_USE_REST: int E_FTP_PARTIAL_FILE: int E_FTP_PORT_FAILED: int E_FTP_PRET_FAILED: int E_FTP_QUOTE_ERROR: int E_FTP_SSL_FAILED: int E_FTP_USER_PASSWORD_INCORRECT: int E_FTP_WEIRD_227_FORMAT: int E_FTP_WEIRD_PASS_REPLY: int E_FTP_WEIRD_PASV_REPLY: int E_FTP_WEIRD_SERVER_REPLY: int E_FTP_WEIRD_USER_REPLY: int E_FTP_WRITE_ERROR: int E_FUNCTION_NOT_FOUND: int E_GOT_NOTHING: int E_HTTP2: int E_HTTP_NOT_FOUND: int E_HTTP_PORT_FAILED: int E_HTTP_POST_ERROR: int E_HTTP_RANGE_ERROR: int E_HTTP_RETURNED_ERROR: int E_INTERFACE_FAILED: int E_LDAP_CANNOT_BIND: int E_LDAP_INVALID_URL: int E_LDAP_SEARCH_FAILED: int E_LIBRARY_NOT_FOUND: int E_LOGIN_DENIED: int E_MALFORMAT_USER: int E_MULTI_ADDED_ALREADY: int E_MULTI_BAD_EASY_HANDLE: int E_MULTI_BAD_HANDLE: int E_MULTI_BAD_SOCKET: int E_MULTI_CALL_MULTI_PERFORM: int E_MULTI_CALL_MULTI_SOCKET: int E_MULTI_INTERNAL_ERROR: int E_MULTI_OK: int E_MULTI_OUT_OF_MEMORY: int E_MULTI_UNKNOWN_OPTION: int E_NOT_BUILT_IN: int E_NO_CONNECTION_AVAILABLE: int E_OK: int E_OPERATION_TIMEDOUT: int E_OPERATION_TIMEOUTED: int E_OUT_OF_MEMORY: int E_PARTIAL_FILE: int E_PEER_FAILED_VERIFICATION: int E_QUOTE_ERROR: int E_RANGE_ERROR: int E_READ_ERROR: int E_RECV_ERROR: int E_REMOTE_ACCESS_DENIED: int E_REMOTE_DISK_FULL: int E_REMOTE_FILE_EXISTS: int E_REMOTE_FILE_NOT_FOUND: int E_RTSP_CSEQ_ERROR: int E_RTSP_SESSION_ERROR: int E_SEND_ERROR: int E_SEND_FAIL_REWIND: int E_SHARE_IN_USE: int E_SSH: int E_SSL_CACERT: int E_SSL_CACERT_BADFILE: int E_SSL_CERTPROBLEM: int E_SSL_CIPHER: int E_SSL_CONNECT_ERROR: int E_SSL_CRL_BADFILE: int E_SSL_ENGINE_INITFAILED: int E_SSL_ENGINE_NOTFOUND: int E_SSL_ENGINE_SETFAILED: int E_SSL_INVALIDCERTSTATUS: int E_SSL_ISSUER_ERROR: int E_SSL_PEER_CERTIFICATE: int E_SSL_PINNEDPUBKEYNOTMATCH: int E_SSL_SHUTDOWN_FAILED: int E_TELNET_OPTION_SYNTAX: int E_TFTP_DISKFULL: int E_TFTP_EXISTS: int E_TFTP_ILLEGAL: int E_TFTP_NOSUCHUSER: int E_TFTP_NOTFOUND: int E_TFTP_PERM: int E_TFTP_UNKNOWNID: int E_TOO_MANY_REDIRECTS: int E_UNKNOWN_OPTION: int E_UNKNOWN_TELNET_OPTION: int E_UNSUPPORTED_PROTOCOL: int E_UPLOAD_FAILED: int E_URL_MALFORMAT: int E_URL_MALFORMAT_USER: int E_USE_SSL_FAILED: int E_WRITE_ERROR: int ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4543793 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/pymysql/0000775000175000017500000000000000000000000024447 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/pymysql/__init__.pyi0000664000175000017500000000313100000000000026727 0ustar00davedave00000000000000import sys from typing import Callable, FrozenSet, Tuple from .connections import Connection as _Connection from .constants import FIELD_TYPE as FIELD_TYPE from .converters import escape_dict as escape_dict, escape_sequence as escape_sequence, escape_string as escape_string from .err import ( DatabaseError as DatabaseError, DataError as DataError, Error as Error, IntegrityError as IntegrityError, InterfaceError as InterfaceError, InternalError as InternalError, MySQLError as MySQLError, NotSupportedError as NotSupportedError, OperationalError as OperationalError, ProgrammingError as ProgrammingError, Warning as Warning, ) from .times import ( Date as Date, DateFromTicks as DateFromTicks, Time as Time, TimeFromTicks as TimeFromTicks, Timestamp as Timestamp, TimestampFromTicks as TimestampFromTicks, ) threadsafety: int apilevel: str paramstyle: str class DBAPISet(FrozenSet[int]): def __ne__(self, other) -> bool: ... def __eq__(self, other) -> bool: ... def __hash__(self) -> int: ... STRING: DBAPISet BINARY: DBAPISet NUMBER: DBAPISet DATE: DBAPISet TIME: DBAPISet TIMESTAMP: DBAPISet DATETIME: DBAPISet ROWID: DBAPISet if sys.version_info >= (3, 0): def Binary(x) -> bytes: ... else: def Binary(x) -> bytearray: ... def Connect(*args, **kwargs) -> _Connection: ... def get_client_info() -> str: ... connect: Callable[..., _Connection] Connection: Callable[..., _Connection] __version__: str version_info: Tuple[int, int, int, str, int] NULL: str def thread_safe() -> bool: ... def install_as_MySQLdb() -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/pymysql/charset.pyi0000664000175000017500000000050700000000000026625 0ustar00davedave00000000000000from typing import Any MBLENGTH: Any class Charset: is_default: Any def __init__(self, id, name, collation, is_default): ... class Charsets: def __init__(self): ... def add(self, c): ... def by_id(self, id): ... def by_name(self, name): ... def charset_by_name(name): ... def charset_by_id(id): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/pymysql/connections.pyi0000664000175000017500000001277300000000000027526 0ustar00davedave00000000000000from socket import SocketType from typing import Any, AnyStr, Mapping, Optional, Tuple, Type from .charset import charset_by_id as charset_by_id, charset_by_name as charset_by_name from .constants import CLIENT as CLIENT, COMMAND as COMMAND, FIELD_TYPE as FIELD_TYPE, SERVER_STATUS as SERVER_STATUS from .cursors import Cursor from .util import byte2int as byte2int, int2byte as int2byte SSL_ENABLED: Any DEFAULT_USER: Any DEBUG: Any DEFAULT_CHARSET: Any def dump_packet(data): ... def pack_int24(n): ... def lenenc_int(i: int) -> bytes: ... class MysqlPacket: connection: Any def __init__(self, data, encoding): ... def get_all_data(self): ... def read(self, size): ... def read_all(self): ... def advance(self, length): ... def rewind(self, position: int = ...): ... def get_bytes(self, position, length: int = ...): ... def read_string(self) -> bytes: ... def read_uint8(self) -> Any: ... def read_uint16(self) -> Any: ... def read_uint24(self) -> Any: ... def read_uint32(self) -> Any: ... def read_uint64(self) -> Any: ... def read_length_encoded_integer(self) -> int: ... def read_length_coded_string(self) -> bytes: ... def read_struct(self, fmt: str) -> Tuple[Any, ...]: ... def is_ok_packet(self) -> bool: ... def is_eof_packet(self) -> bool: ... def is_auth_switch_request(self) -> bool: ... def is_extra_auth_data(self) -> bool: ... def is_resultset_packet(self) -> bool: ... def is_load_local_packet(self) -> bool: ... def is_error_packet(self) -> bool: ... def check_error(self): ... def raise_for_error(self) -> None: ... def dump(self): ... class FieldDescriptorPacket(MysqlPacket): def __init__(self, data, encoding): ... def description(self): ... def get_column_length(self): ... class Connection: ssl: Any host: Any port: Any user: Any password: Any db: Any unix_socket: Any bind_address: Any charset: Any use_unicode: Any client_flag: Any cursorclass: Any connect_timeout: Any messages: Any encoders: Any decoders: Any host_info: Any sql_mode: Any init_command: Any max_allowed_packet: int server_public_key: bytes def __init__( self, host: Optional[str] = ..., user: Optional[Any] = ..., password: str = ..., database: Optional[Any] = ..., port: int = ..., unix_socket: Optional[Any] = ..., charset: str = ..., sql_mode: Optional[Any] = ..., read_default_file: Optional[Any] = ..., conv=..., use_unicode: Optional[bool] = ..., client_flag: int = ..., cursorclass: Optional[Type[Cursor]] = ..., init_command: Optional[Any] = ..., connect_timeout: Optional[int] = ..., ssl: Optional[Mapping] = ..., read_default_group: Optional[Any] = ..., compress: Optional[Any] = ..., named_pipe: Optional[Any] = ..., autocommit: Optional[bool] = ..., db: Optional[Any] = ..., passwd: Optional[Any] = ..., local_infile: Optional[Any] = ..., max_allowed_packet: int = ..., defer_connect: Optional[bool] = ..., auth_plugin_map: Optional[Mapping] = ..., read_timeout: Optional[float] = ..., write_timeout: Optional[float] = ..., bind_address: Optional[Any] = ..., binary_prefix: Optional[bool] = ..., program_name: Optional[Any] = ..., server_public_key: Optional[bytes] = ..., ): ... socket: Any rfile: Any wfile: Any def close(self) -> None: ... @property def open(self) -> bool: ... def autocommit(self, value) -> None: ... def get_autocommit(self) -> bool: ... def commit(self) -> None: ... def begin(self) -> None: ... def rollback(self) -> None: ... def select_db(self, db) -> None: ... def escape(self, obj, mapping: Optional[Mapping] = ...): ... def literal(self, obj): ... def escape_string(self, s: AnyStr) -> AnyStr: ... def cursor(self, cursor: Optional[Type[Cursor]] = ...) -> Cursor: ... def query(self, sql, unbuffered: bool = ...) -> int: ... def next_result(self, unbuffered: bool = ...) -> int: ... def affected_rows(self): ... def kill(self, thread_id): ... def ping(self, reconnect: bool = ...) -> None: ... def set_charset(self, charset) -> None: ... def connect(self, sock: Optional[SocketType] = ...) -> None: ... def write_packet(self, payload) -> None: ... def _read_packet(self, packet_type=...): ... def insert_id(self): ... def thread_id(self): ... def character_set_name(self): ... def get_host_info(self): ... def get_proto_info(self): ... def get_server_info(self): ... def show_warnings(self): ... Warning: Any Error: Any InterfaceError: Any DatabaseError: Any DataError: Any OperationalError: Any IntegrityError: Any InternalError: Any ProgrammingError: Any NotSupportedError: Any class MySQLResult: connection: Any affected_rows: Any insert_id: Any server_status: Any warning_count: Any message: Any field_count: Any description: Any rows: Any has_next: Any def __init__(self, connection: Connection) -> None: ... first_packet: Any def read(self) -> None: ... def init_unbuffered_query(self) -> None: ... class LoadLocalFile: filename: Any connection: Connection def __init__(self, filename: Any, connection: Connection) -> None: ... def send_data(self) -> None: ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4543793 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/pymysql/constants/0000775000175000017500000000000000000000000026463 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/pymysql/constants/CLIENT.pyi0000664000175000017500000000046400000000000030170 0ustar00davedave00000000000000LONG_PASSWORD: int FOUND_ROWS: int LONG_FLAG: int CONNECT_WITH_DB: int NO_SCHEMA: int COMPRESS: int ODBC: int LOCAL_FILES: int IGNORE_SPACE: int PROTOCOL_41: int INTERACTIVE: int SSL: int IGNORE_SIGPIPE: int TRANSACTIONS: int SECURE_CONNECTION: int MULTI_STATEMENTS: int MULTI_RESULTS: int CAPABILITIES: int ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/pymysql/constants/COMMAND.pyi0000664000175000017500000000062700000000000030271 0ustar00davedave00000000000000COM_SLEEP: int COM_QUIT: int COM_INIT_DB: int COM_QUERY: int COM_FIELD_LIST: int COM_CREATE_DB: int COM_DROP_DB: int COM_REFRESH: int COM_SHUTDOWN: int COM_STATISTICS: int COM_PROCESS_INFO: int COM_CONNECT: int COM_PROCESS_KILL: int COM_DEBUG: int COM_PING: int COM_TIME: int COM_DELAYED_INSERT: int COM_CHANGE_USER: int COM_BINLOG_DUMP: int COM_TABLE_DUMP: int COM_CONNECT_OUT: int COM_REGISTER_SLAVE: int ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/pymysql/constants/ER.pyi0000664000175000017500000002602000000000000027514 0ustar00davedave00000000000000ERROR_FIRST: int HASHCHK: int NISAMCHK: int NO: int YES: int CANT_CREATE_FILE: int CANT_CREATE_TABLE: int CANT_CREATE_DB: int DB_CREATE_EXISTS: int DB_DROP_EXISTS: int DB_DROP_DELETE: int DB_DROP_RMDIR: int CANT_DELETE_FILE: int CANT_FIND_SYSTEM_REC: int CANT_GET_STAT: int CANT_GET_WD: int CANT_LOCK: int CANT_OPEN_FILE: int FILE_NOT_FOUND: int CANT_READ_DIR: int CANT_SET_WD: int CHECKREAD: int DISK_FULL: int DUP_KEY: int ERROR_ON_CLOSE: int ERROR_ON_READ: int ERROR_ON_RENAME: int ERROR_ON_WRITE: int FILE_USED: int FILSORT_ABORT: int FORM_NOT_FOUND: int GET_ERRNO: int ILLEGAL_HA: int KEY_NOT_FOUND: int NOT_FORM_FILE: int NOT_KEYFILE: int OLD_KEYFILE: int OPEN_AS_READONLY: int OUTOFMEMORY: int OUT_OF_SORTMEMORY: int UNEXPECTED_EOF: int CON_COUNT_ERROR: int OUT_OF_RESOURCES: int BAD_HOST_ERROR: int HANDSHAKE_ERROR: int DBACCESS_DENIED_ERROR: int ACCESS_DENIED_ERROR: int NO_DB_ERROR: int UNKNOWN_COM_ERROR: int BAD_NULL_ERROR: int BAD_DB_ERROR: int TABLE_EXISTS_ERROR: int BAD_TABLE_ERROR: int NON_UNIQ_ERROR: int SERVER_SHUTDOWN: int BAD_FIELD_ERROR: int WRONG_FIELD_WITH_GROUP: int WRONG_GROUP_FIELD: int WRONG_SUM_SELECT: int WRONG_VALUE_COUNT: int TOO_LONG_IDENT: int DUP_FIELDNAME: int DUP_KEYNAME: int DUP_ENTRY: int WRONG_FIELD_SPEC: int PARSE_ERROR: int EMPTY_QUERY: int NONUNIQ_TABLE: int INVALID_DEFAULT: int MULTIPLE_PRI_KEY: int TOO_MANY_KEYS: int TOO_MANY_KEY_PARTS: int TOO_LONG_KEY: int KEY_COLUMN_DOES_NOT_EXITS: int BLOB_USED_AS_KEY: int TOO_BIG_FIELDLENGTH: int WRONG_AUTO_KEY: int READY: int NORMAL_SHUTDOWN: int GOT_SIGNAL: int SHUTDOWN_COMPLETE: int FORCING_CLOSE: int IPSOCK_ERROR: int NO_SUCH_INDEX: int WRONG_FIELD_TERMINATORS: int BLOBS_AND_NO_TERMINATED: int TEXTFILE_NOT_READABLE: int FILE_EXISTS_ERROR: int LOAD_INFO: int ALTER_INFO: int WRONG_SUB_KEY: int CANT_REMOVE_ALL_FIELDS: int CANT_DROP_FIELD_OR_KEY: int INSERT_INFO: int UPDATE_TABLE_USED: int NO_SUCH_THREAD: int KILL_DENIED_ERROR: int NO_TABLES_USED: int TOO_BIG_SET: int NO_UNIQUE_LOGFILE: int TABLE_NOT_LOCKED_FOR_WRITE: int TABLE_NOT_LOCKED: int BLOB_CANT_HAVE_DEFAULT: int WRONG_DB_NAME: int WRONG_TABLE_NAME: int TOO_BIG_SELECT: int UNKNOWN_ERROR: int UNKNOWN_PROCEDURE: int WRONG_PARAMCOUNT_TO_PROCEDURE: int WRONG_PARAMETERS_TO_PROCEDURE: int UNKNOWN_TABLE: int FIELD_SPECIFIED_TWICE: int INVALID_GROUP_FUNC_USE: int UNSUPPORTED_EXTENSION: int TABLE_MUST_HAVE_COLUMNS: int RECORD_FILE_FULL: int UNKNOWN_CHARACTER_SET: int TOO_MANY_TABLES: int TOO_MANY_FIELDS: int TOO_BIG_ROWSIZE: int STACK_OVERRUN: int WRONG_OUTER_JOIN: int NULL_COLUMN_IN_INDEX: int CANT_FIND_UDF: int CANT_INITIALIZE_UDF: int UDF_NO_PATHS: int UDF_EXISTS: int CANT_OPEN_LIBRARY: int CANT_FIND_DL_ENTRY: int FUNCTION_NOT_DEFINED: int HOST_IS_BLOCKED: int HOST_NOT_PRIVILEGED: int PASSWORD_ANONYMOUS_USER: int PASSWORD_NOT_ALLOWED: int PASSWORD_NO_MATCH: int UPDATE_INFO: int CANT_CREATE_THREAD: int WRONG_VALUE_COUNT_ON_ROW: int CANT_REOPEN_TABLE: int INVALID_USE_OF_NULL: int REGEXP_ERROR: int MIX_OF_GROUP_FUNC_AND_FIELDS: int NONEXISTING_GRANT: int TABLEACCESS_DENIED_ERROR: int COLUMNACCESS_DENIED_ERROR: int ILLEGAL_GRANT_FOR_TABLE: int GRANT_WRONG_HOST_OR_USER: int NO_SUCH_TABLE: int NONEXISTING_TABLE_GRANT: int NOT_ALLOWED_COMMAND: int SYNTAX_ERROR: int DELAYED_CANT_CHANGE_LOCK: int TOO_MANY_DELAYED_THREADS: int ABORTING_CONNECTION: int NET_PACKET_TOO_LARGE: int NET_READ_ERROR_FROM_PIPE: int NET_FCNTL_ERROR: int NET_PACKETS_OUT_OF_ORDER: int NET_UNCOMPRESS_ERROR: int NET_READ_ERROR: int NET_READ_INTERRUPTED: int NET_ERROR_ON_WRITE: int NET_WRITE_INTERRUPTED: int TOO_LONG_STRING: int TABLE_CANT_HANDLE_BLOB: int TABLE_CANT_HANDLE_AUTO_INCREMENT: int DELAYED_INSERT_TABLE_LOCKED: int WRONG_COLUMN_NAME: int WRONG_KEY_COLUMN: int WRONG_MRG_TABLE: int DUP_UNIQUE: int BLOB_KEY_WITHOUT_LENGTH: int PRIMARY_CANT_HAVE_NULL: int TOO_MANY_ROWS: int REQUIRES_PRIMARY_KEY: int NO_RAID_COMPILED: int UPDATE_WITHOUT_KEY_IN_SAFE_MODE: int KEY_DOES_NOT_EXITS: int CHECK_NO_SUCH_TABLE: int CHECK_NOT_IMPLEMENTED: int CANT_DO_THIS_DURING_AN_TRANSACTION: int ERROR_DURING_COMMIT: int ERROR_DURING_ROLLBACK: int ERROR_DURING_FLUSH_LOGS: int ERROR_DURING_CHECKPOINT: int NEW_ABORTING_CONNECTION: int DUMP_NOT_IMPLEMENTED: int FLUSH_MASTER_BINLOG_CLOSED: int INDEX_REBUILD: int MASTER: int MASTER_NET_READ: int MASTER_NET_WRITE: int FT_MATCHING_KEY_NOT_FOUND: int LOCK_OR_ACTIVE_TRANSACTION: int UNKNOWN_SYSTEM_VARIABLE: int CRASHED_ON_USAGE: int CRASHED_ON_REPAIR: int WARNING_NOT_COMPLETE_ROLLBACK: int TRANS_CACHE_FULL: int SLAVE_MUST_STOP: int SLAVE_NOT_RUNNING: int BAD_SLAVE: int MASTER_INFO: int SLAVE_THREAD: int TOO_MANY_USER_CONNECTIONS: int SET_CONSTANTS_ONLY: int LOCK_WAIT_TIMEOUT: int LOCK_TABLE_FULL: int READ_ONLY_TRANSACTION: int DROP_DB_WITH_READ_LOCK: int CREATE_DB_WITH_READ_LOCK: int WRONG_ARGUMENTS: int NO_PERMISSION_TO_CREATE_USER: int UNION_TABLES_IN_DIFFERENT_DIR: int LOCK_DEADLOCK: int TABLE_CANT_HANDLE_FT: int CANNOT_ADD_FOREIGN: int NO_REFERENCED_ROW: int ROW_IS_REFERENCED: int CONNECT_TO_MASTER: int QUERY_ON_MASTER: int ERROR_WHEN_EXECUTING_COMMAND: int WRONG_USAGE: int WRONG_NUMBER_OF_COLUMNS_IN_SELECT: int CANT_UPDATE_WITH_READLOCK: int MIXING_NOT_ALLOWED: int DUP_ARGUMENT: int USER_LIMIT_REACHED: int SPECIFIC_ACCESS_DENIED_ERROR: int LOCAL_VARIABLE: int GLOBAL_VARIABLE: int NO_DEFAULT: int WRONG_VALUE_FOR_VAR: int WRONG_TYPE_FOR_VAR: int VAR_CANT_BE_READ: int CANT_USE_OPTION_HERE: int NOT_SUPPORTED_YET: int MASTER_FATAL_ERROR_READING_BINLOG: int SLAVE_IGNORED_TABLE: int INCORRECT_GLOBAL_LOCAL_VAR: int WRONG_FK_DEF: int KEY_REF_DO_NOT_MATCH_TABLE_REF: int OPERAND_COLUMNS: int SUBQUERY_NO_1_ROW: int UNKNOWN_STMT_HANDLER: int CORRUPT_HELP_DB: int CYCLIC_REFERENCE: int AUTO_CONVERT: int ILLEGAL_REFERENCE: int DERIVED_MUST_HAVE_ALIAS: int SELECT_REDUCED: int TABLENAME_NOT_ALLOWED_HERE: int NOT_SUPPORTED_AUTH_MODE: int SPATIAL_CANT_HAVE_NULL: int COLLATION_CHARSET_MISMATCH: int SLAVE_WAS_RUNNING: int SLAVE_WAS_NOT_RUNNING: int TOO_BIG_FOR_UNCOMPRESS: int ZLIB_Z_MEM_ERROR: int ZLIB_Z_BUF_ERROR: int ZLIB_Z_DATA_ERROR: int CUT_VALUE_GROUP_CONCAT: int WARN_TOO_FEW_RECORDS: int WARN_TOO_MANY_RECORDS: int WARN_NULL_TO_NOTNULL: int WARN_DATA_OUT_OF_RANGE: int WARN_DATA_TRUNCATED: int WARN_USING_OTHER_HANDLER: int CANT_AGGREGATE_2COLLATIONS: int DROP_USER: int REVOKE_GRANTS: int CANT_AGGREGATE_3COLLATIONS: int CANT_AGGREGATE_NCOLLATIONS: int VARIABLE_IS_NOT_STRUCT: int UNKNOWN_COLLATION: int SLAVE_IGNORED_SSL_PARAMS: int SERVER_IS_IN_SECURE_AUTH_MODE: int WARN_FIELD_RESOLVED: int BAD_SLAVE_UNTIL_COND: int MISSING_SKIP_SLAVE: int UNTIL_COND_IGNORED: int WRONG_NAME_FOR_INDEX: int WRONG_NAME_FOR_CATALOG: int WARN_QC_RESIZE: int BAD_FT_COLUMN: int UNKNOWN_KEY_CACHE: int WARN_HOSTNAME_WONT_WORK: int UNKNOWN_STORAGE_ENGINE: int WARN_DEPRECATED_SYNTAX: int NON_UPDATABLE_TABLE: int FEATURE_DISABLED: int OPTION_PREVENTS_STATEMENT: int DUPLICATED_VALUE_IN_TYPE: int TRUNCATED_WRONG_VALUE: int TOO_MUCH_AUTO_TIMESTAMP_COLS: int INVALID_ON_UPDATE: int UNSUPPORTED_PS: int GET_ERRMSG: int GET_TEMPORARY_ERRMSG: int UNKNOWN_TIME_ZONE: int WARN_INVALID_TIMESTAMP: int INVALID_CHARACTER_STRING: int WARN_ALLOWED_PACKET_OVERFLOWED: int CONFLICTING_DECLARATIONS: int SP_NO_RECURSIVE_CREATE: int SP_ALREADY_EXISTS: int SP_DOES_NOT_EXIST: int SP_DROP_FAILED: int SP_STORE_FAILED: int SP_LILABEL_MISMATCH: int SP_LABEL_REDEFINE: int SP_LABEL_MISMATCH: int SP_UNINIT_VAR: int SP_BADSELECT: int SP_BADRETURN: int SP_BADSTATEMENT: int UPDATE_LOG_DEPRECATED_IGNORED: int UPDATE_LOG_DEPRECATED_TRANSLATED: int QUERY_INTERRUPTED: int SP_WRONG_NO_OF_ARGS: int SP_COND_MISMATCH: int SP_NORETURN: int SP_NORETURNEND: int SP_BAD_CURSOR_QUERY: int SP_BAD_CURSOR_SELECT: int SP_CURSOR_MISMATCH: int SP_CURSOR_ALREADY_OPEN: int SP_CURSOR_NOT_OPEN: int SP_UNDECLARED_VAR: int SP_WRONG_NO_OF_FETCH_ARGS: int SP_FETCH_NO_DATA: int SP_DUP_PARAM: int SP_DUP_VAR: int SP_DUP_COND: int SP_DUP_CURS: int SP_CANT_ALTER: int SP_SUBSELECT_NYI: int STMT_NOT_ALLOWED_IN_SF_OR_TRG: int SP_VARCOND_AFTER_CURSHNDLR: int SP_CURSOR_AFTER_HANDLER: int SP_CASE_NOT_FOUND: int FPARSER_TOO_BIG_FILE: int FPARSER_BAD_HEADER: int FPARSER_EOF_IN_COMMENT: int FPARSER_ERROR_IN_PARAMETER: int FPARSER_EOF_IN_UNKNOWN_PARAMETER: int VIEW_NO_EXPLAIN: int FRM_UNKNOWN_TYPE: int WRONG_OBJECT: int NONUPDATEABLE_COLUMN: int VIEW_SELECT_DERIVED: int VIEW_SELECT_CLAUSE: int VIEW_SELECT_VARIABLE: int VIEW_SELECT_TMPTABLE: int VIEW_WRONG_LIST: int WARN_VIEW_MERGE: int WARN_VIEW_WITHOUT_KEY: int VIEW_INVALID: int SP_NO_DROP_SP: int SP_GOTO_IN_HNDLR: int TRG_ALREADY_EXISTS: int TRG_DOES_NOT_EXIST: int TRG_ON_VIEW_OR_TEMP_TABLE: int TRG_CANT_CHANGE_ROW: int TRG_NO_SUCH_ROW_IN_TRG: int NO_DEFAULT_FOR_FIELD: int DIVISION_BY_ZERO: int TRUNCATED_WRONG_VALUE_FOR_FIELD: int ILLEGAL_VALUE_FOR_TYPE: int VIEW_NONUPD_CHECK: int VIEW_CHECK_FAILED: int PROCACCESS_DENIED_ERROR: int RELAY_LOG_FAIL: int PASSWD_LENGTH: int UNKNOWN_TARGET_BINLOG: int IO_ERR_LOG_INDEX_READ: int BINLOG_PURGE_PROHIBITED: int FSEEK_FAIL: int BINLOG_PURGE_FATAL_ERR: int LOG_IN_USE: int LOG_PURGE_UNKNOWN_ERR: int RELAY_LOG_INIT: int NO_BINARY_LOGGING: int RESERVED_SYNTAX: int WSAS_FAILED: int DIFF_GROUPS_PROC: int NO_GROUP_FOR_PROC: int ORDER_WITH_PROC: int LOGGING_PROHIBIT_CHANGING_OF: int NO_FILE_MAPPING: int WRONG_MAGIC: int PS_MANY_PARAM: int KEY_PART_0: int VIEW_CHECKSUM: int VIEW_MULTIUPDATE: int VIEW_NO_INSERT_FIELD_LIST: int VIEW_DELETE_MERGE_VIEW: int CANNOT_USER: int XAER_NOTA: int XAER_INVAL: int XAER_RMFAIL: int XAER_OUTSIDE: int XAER_RMERR: int XA_RBROLLBACK: int NONEXISTING_PROC_GRANT: int PROC_AUTO_GRANT_FAIL: int PROC_AUTO_REVOKE_FAIL: int DATA_TOO_LONG: int SP_BAD_SQLSTATE: int STARTUP: int LOAD_FROM_FIXED_SIZE_ROWS_TO_VAR: int CANT_CREATE_USER_WITH_GRANT: int WRONG_VALUE_FOR_TYPE: int TABLE_DEF_CHANGED: int SP_DUP_HANDLER: int SP_NOT_VAR_ARG: int SP_NO_RETSET: int CANT_CREATE_GEOMETRY_OBJECT: int FAILED_ROUTINE_BREAK_BINLOG: int BINLOG_UNSAFE_ROUTINE: int BINLOG_CREATE_ROUTINE_NEED_SUPER: int EXEC_STMT_WITH_OPEN_CURSOR: int STMT_HAS_NO_OPEN_CURSOR: int COMMIT_NOT_ALLOWED_IN_SF_OR_TRG: int NO_DEFAULT_FOR_VIEW_FIELD: int SP_NO_RECURSION: int TOO_BIG_SCALE: int TOO_BIG_PRECISION: int M_BIGGER_THAN_D: int WRONG_LOCK_OF_SYSTEM_TABLE: int CONNECT_TO_FOREIGN_DATA_SOURCE: int QUERY_ON_FOREIGN_DATA_SOURCE: int FOREIGN_DATA_SOURCE_DOESNT_EXIST: int FOREIGN_DATA_STRING_INVALID_CANT_CREATE: int FOREIGN_DATA_STRING_INVALID: int CANT_CREATE_FEDERATED_TABLE: int TRG_IN_WRONG_SCHEMA: int STACK_OVERRUN_NEED_MORE: int TOO_LONG_BODY: int WARN_CANT_DROP_DEFAULT_KEYCACHE: int TOO_BIG_DISPLAYWIDTH: int XAER_DUPID: int DATETIME_FUNCTION_OVERFLOW: int CANT_UPDATE_USED_TABLE_IN_SF_OR_TRG: int VIEW_PREVENT_UPDATE: int PS_NO_RECURSION: int SP_CANT_SET_AUTOCOMMIT: int MALFORMED_DEFINER: int VIEW_FRM_NO_USER: int VIEW_OTHER_USER: int NO_SUCH_USER: int FORBID_SCHEMA_CHANGE: int ROW_IS_REFERENCED_2: int NO_REFERENCED_ROW_2: int SP_BAD_VAR_SHADOW: int TRG_NO_DEFINER: int OLD_FILE_FORMAT: int SP_RECURSION_LIMIT: int SP_PROC_TABLE_CORRUPT: int SP_WRONG_NAME: int TABLE_NEEDS_UPGRADE: int SP_NO_AGGREGATE: int MAX_PREPARED_STMT_COUNT_REACHED: int VIEW_RECURSIVE: int NON_GROUPING_FIELD_USED: int TABLE_CANT_HANDLE_SPKEYS: int NO_TRIGGERS_ON_SYSTEM_SCHEMA: int USERNAME: int HOSTNAME: int WRONG_STRING_LENGTH: int ERROR_LAST: int ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/pymysql/constants/FIELD_TYPE.pyi0000664000175000017500000000054200000000000030673 0ustar00davedave00000000000000DECIMAL: int TINY: int SHORT: int LONG: int FLOAT: int DOUBLE: int NULL: int TIMESTAMP: int LONGLONG: int INT24: int DATE: int TIME: int DATETIME: int YEAR: int NEWDATE: int VARCHAR: int BIT: int NEWDECIMAL: int ENUM: int SET: int TINY_BLOB: int MEDIUM_BLOB: int LONG_BLOB: int BLOB: int VAR_STRING: int STRING: int GEOMETRY: int CHAR: int INTERVAL: int ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/pymysql/constants/FLAG.pyi0000664000175000017500000000034200000000000027716 0ustar00davedave00000000000000from typing import Any NOT_NULL: Any PRI_KEY: Any UNIQUE_KEY: Any MULTIPLE_KEY: Any BLOB: Any UNSIGNED: Any ZEROFILL: Any BINARY: Any ENUM: Any AUTO_INCREMENT: Any TIMESTAMP: Any SET: Any PART_KEY: Any GROUP: Any UNIQUE: Any ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/pymysql/constants/SERVER_STATUS.pyi0000664000175000017500000000051300000000000031316 0ustar00davedave00000000000000SERVER_STATUS_IN_TRANS: int SERVER_STATUS_AUTOCOMMIT: int SERVER_MORE_RESULTS_EXISTS: int SERVER_QUERY_NO_GOOD_INDEX_USED: int SERVER_QUERY_NO_INDEX_USED: int SERVER_STATUS_CURSOR_EXISTS: int SERVER_STATUS_LAST_ROW_SENT: int SERVER_STATUS_DB_DROPPED: int SERVER_STATUS_NO_BACKSLASH_ESCAPES: int SERVER_STATUS_METADATA_CHANGED: int ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/pymysql/constants/__init__.pyi0000664000175000017500000000000000000000000030733 0ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/pymysql/converters.pyi0000664000175000017500000000246300000000000027371 0ustar00davedave00000000000000from typing import Any from .charset import charset_by_id as charset_by_id from .constants import FIELD_TYPE as FIELD_TYPE, FLAG as FLAG PYTHON3: Any ESCAPE_REGEX: Any ESCAPE_MAP: Any def escape_item(val, charset): ... def escape_dict(val, charset): ... def escape_sequence(val, charset): ... def escape_set(val, charset): ... def escape_bool(value): ... def escape_object(value): ... escape_int: Any escape_long: Any def escape_float(value): ... def escape_string(value): ... def escape_unicode(value): ... def escape_None(value): ... def escape_timedelta(obj): ... def escape_time(obj): ... def escape_datetime(obj): ... def escape_date(obj): ... def escape_struct_time(obj): ... def convert_datetime(connection, field, obj): ... def convert_timedelta(connection, field, obj): ... def convert_time(connection, field, obj): ... def convert_date(connection, field, obj): ... def convert_mysql_timestamp(connection, field, timestamp): ... def convert_set(s): ... def convert_bit(connection, field, b): ... def convert_characters(connection, field, data): ... def convert_int(connection, field, data): ... def convert_long(connection, field, data): ... def convert_float(connection, field, data): ... encoders: Any decoders: Any conversions: Any def convert_decimal(connection, field, data): ... def escape_decimal(obj): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/pymysql/cursors.pyi0000664000175000017500000000420400000000000026672 0ustar00davedave00000000000000from typing import Any, Dict, Iterable, Iterator, List, Optional, Text, Tuple, TypeVar, Union from .connections import Connection _Gen = Union[Tuple[Any, ...], Dict[Text, Any]] _QueryArgs = Union[Tuple[Any, ...], List[Any], Dict[Text, Any], None] _SelfT = TypeVar("_SelfT") class Cursor: connection: Connection description: Tuple[Text, ...] rownumber: int rowcount: int arraysize: int messages: Any errorhandler: Any lastrowid: int def __init__(self, connection: Connection) -> None: ... def __del__(self) -> None: ... def close(self) -> None: ... def setinputsizes(self, *args) -> None: ... def setoutputsizes(self, *args) -> None: ... def nextset(self) -> Optional[bool]: ... def mogrify(self, query: Text, args: _QueryArgs = ...) -> str: ... def execute(self, query: Text, args: _QueryArgs = ...) -> int: ... def executemany(self, query: Text, args: Iterable[_QueryArgs]) -> Optional[int]: ... def callproc(self, procname: Text, args: Iterable[Any] = ...) -> Any: ... def fetchone(self) -> Optional[_Gen]: ... def fetchmany(self, size: Optional[int] = ...) -> Union[Optional[_Gen], List[_Gen]]: ... def fetchall(self) -> Optional[Tuple[_Gen, ...]]: ... def scroll(self, value: int, mode: Text = ...) -> None: ... def __iter__(self) -> Iterator[_Gen]: ... def __enter__(self: _SelfT) -> _SelfT: ... def __exit__(self, *exc_info: Any) -> None: ... class DictCursor(Cursor): def fetchone(self) -> Optional[Dict[Text, Any]]: ... def fetchmany(self, size: Optional[int] = ...) -> Optional[Tuple[Dict[Text, Any], ...]]: ... def fetchall(self) -> Optional[Tuple[Dict[Text, Any], ...]]: ... class DictCursorMixin: dict_type: Any class SSCursor(Cursor): # fetchall return type is incompatible with the supertype. def fetchall(self) -> List[_Gen]: ... # type: ignore def fetchall_unbuffered(self) -> Iterator[_Gen]: ... def __iter__(self) -> Iterator[_Gen]: ... def fetchmany(self, size: Optional[int] = ...) -> List[_Gen]: ... def scroll(self, value: int, mode: Text = ...) -> None: ... class SSDictCursor(DictCursorMixin, SSCursor): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/pymysql/err.pyi0000664000175000017500000000113600000000000025763 0ustar00davedave00000000000000import builtins from typing import Dict, NoReturn, Type from .constants import ER as ER class MySQLError(Exception): ... class Warning(builtins.Warning, MySQLError): ... class Error(MySQLError): ... class InterfaceError(Error): ... class DatabaseError(Error): ... class DataError(DatabaseError): ... class OperationalError(DatabaseError): ... class IntegrityError(DatabaseError): ... class InternalError(DatabaseError): ... class ProgrammingError(DatabaseError): ... class NotSupportedError(DatabaseError): ... error_map: Dict[int, Type[DatabaseError]] def raise_mysql_exception(data) -> NoReturn: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/pymysql/times.pyi0000664000175000017500000000025200000000000026312 0ustar00davedave00000000000000from typing import Any Date: Any Time: Any TimeDelta: Any Timestamp: Any def DateFromTicks(ticks): ... def TimeFromTicks(ticks): ... def TimestampFromTicks(ticks): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/pymysql/util.pyi0000664000175000017500000000010200000000000026140 0ustar00davedave00000000000000def byte2int(b): ... def int2byte(i): ... def join_bytes(bs): ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4543793 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/pynamodb/0000775000175000017500000000000000000000000024542 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/pynamodb/__init__.pyi0000664000175000017500000000002100000000000027015 0ustar00davedave00000000000000__license__: str ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/pynamodb/attributes.pyi0000664000175000017500000001036600000000000027461 0ustar00davedave00000000000000from datetime import datetime from typing import Any, Callable, Dict, Generic, Iterable, List, Mapping, Optional, Set, Text, Type, TypeVar, Union _T = TypeVar("_T") _KT = TypeVar("_KT") _VT = TypeVar("_VT") _MT = TypeVar("_MT", bound=MapAttribute[Any, Any]) class Attribute(Generic[_T]): attr_name: Optional[Text] attr_type: Text null: bool default: Any is_hash_key: bool is_range_key: bool def __init__( self, hash_key: bool = ..., range_key: bool = ..., null: Optional[bool] = ..., default: Optional[Union[_T, Callable[..., _T]]] = ..., attr_name: Optional[Text] = ..., ) -> None: ... def __set__(self, instance: Any, value: Optional[_T]) -> None: ... def serialize(self, value: Any) -> Any: ... def deserialize(self, value: Any) -> Any: ... def get_value(self, value: Any) -> Any: ... def between(self, lower: Any, upper: Any) -> Any: ... def is_in(self, *values: Any) -> Any: ... def exists(self) -> Any: ... def does_not_exist(self) -> Any: ... def is_type(self) -> Any: ... def startswith(self, prefix: str) -> Any: ... def contains(self, item: Any) -> Any: ... def append(self, other: Any) -> Any: ... def prepend(self, other: Any) -> Any: ... def set(self, value: Any) -> Any: ... def remove(self) -> Any: ... def add(self, *values: Any) -> Any: ... def delete(self, *values: Any) -> Any: ... class SetMixin(object): def serialize(self, value): ... def deserialize(self, value): ... class BinaryAttribute(Attribute[bytes]): def __get__(self, instance: Any, owner: Any) -> bytes: ... class BinarySetAttribute(SetMixin, Attribute[Set[bytes]]): def __get__(self, instance: Any, owner: Any) -> Set[bytes]: ... class UnicodeSetAttribute(SetMixin, Attribute[Set[Text]]): def element_serialize(self, value: Any) -> Any: ... def element_deserialize(self, value: Any) -> Any: ... def __get__(self, instance: Any, owner: Any) -> Set[Text]: ... class UnicodeAttribute(Attribute[Text]): def __get__(self, instance: Any, owner: Any) -> Text: ... class JSONAttribute(Attribute[Any]): def __get__(self, instance: Any, owner: Any) -> Any: ... class LegacyBooleanAttribute(Attribute[bool]): def __get__(self, instance: Any, owner: Any) -> bool: ... class BooleanAttribute(Attribute[bool]): def __get__(self, instance: Any, owner: Any) -> bool: ... class NumberSetAttribute(SetMixin, Attribute[Set[float]]): def __get__(self, instance: Any, owner: Any) -> Set[float]: ... class NumberAttribute(Attribute[float]): def __get__(self, instance: Any, owner: Any) -> float: ... class UTCDateTimeAttribute(Attribute[datetime]): def __get__(self, instance: Any, owner: Any) -> datetime: ... class NullAttribute(Attribute[None]): def __get__(self, instance: Any, owner: Any) -> None: ... class MapAttributeMeta(type): def __init__(self, name, bases, attrs) -> None: ... class MapAttribute(Attribute[Mapping[_KT, _VT]], metaclass=MapAttributeMeta): attribute_values: Any def __init__( self, hash_key: bool = ..., range_key: bool = ..., null: Optional[bool] = ..., default: Optional[Union[Any, Callable[..., Any]]] = ..., attr_name: Optional[Text] = ..., **attrs, ) -> None: ... def __iter__(self) -> Iterable[_VT]: ... def __getattr__(self, attr: str) -> _VT: ... def __getitem__(self, item: _KT) -> _VT: ... def __set__(self, instance: Any, value: Union[None, MapAttribute[_KT, _VT], Mapping[_KT, _VT]]) -> None: ... def __get__(self: _MT, instance: Any, owner: Any) -> _MT: ... def is_type_safe(self, key: Any, value: Any) -> bool: ... def validate(self) -> bool: ... class ListAttribute(Attribute[List[_T]]): element_type: Any def __init__( self, hash_key: bool = ..., range_key: bool = ..., null: Optional[bool] = ..., default: Optional[Union[Any, Callable[..., Any]]] = ..., attr_name: Optional[Text] = ..., of: Optional[Type[_T]] = ..., ) -> None: ... def __get__(self, instance: Any, owner: Any) -> List[_T]: ... DESERIALIZE_CLASS_MAP: Dict[Text, Attribute[Any]] SERIALIZE_CLASS_MAP: Dict[Type[Any], Attribute[Any]] SERIALIZE_KEY_MAP: Dict[Type[Any], Text] ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4543793 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/pynamodb/connection/0000775000175000017500000000000000000000000026701 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/pynamodb/connection/__init__.pyi0000664000175000017500000000020700000000000031162 0ustar00davedave00000000000000from pynamodb.connection.base import Connection as Connection from pynamodb.connection.table import TableConnection as TableConnection ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/pynamodb/connection/base.pyi0000664000175000017500000001371100000000000030341 0ustar00davedave00000000000000from typing import Any, Dict, Optional, Text BOTOCORE_EXCEPTIONS: Any log: Any class MetaTable: data: Dict[Any, Any] def __init__(self, data: Dict[Any, Any]) -> None: ... @property def range_keyname(self) -> Optional[Text]: ... @property def hash_keyname(self) -> Text: ... def get_index_hash_keyname(self, index_name: Text) -> Optional[Text]: ... def get_item_attribute_map(self, attributes, item_key: Any = ..., pythonic_key: bool = ...): ... def get_attribute_type(self, attribute_name, value: Optional[Any] = ...): ... def get_identifier_map(self, hash_key, range_key: Optional[Any] = ..., key: Any = ...): ... def get_exclusive_start_key_map(self, exclusive_start_key): ... class Connection: host: Any region: Any session_cls: Any def __init__( self, region: Optional[Any] = ..., host: Optional[Any] = ..., session_cls: Optional[Any] = ..., request_timeout_seconds: Optional[Any] = ..., max_retry_attempts: Optional[Any] = ..., base_backoff_ms: Optional[Any] = ..., ) -> None: ... def dispatch(self, operation_name, operation_kwargs): ... @property def session(self): ... @property def requests_session(self): ... @property def client(self): ... def get_meta_table(self, table_name: Text, refresh: bool = ...): ... def create_table( self, table_name: Text, attribute_definitions: Optional[Any] = ..., key_schema: Optional[Any] = ..., read_capacity_units: Optional[Any] = ..., write_capacity_units: Optional[Any] = ..., global_secondary_indexes: Optional[Any] = ..., local_secondary_indexes: Optional[Any] = ..., stream_specification: Optional[Any] = ..., ): ... def delete_table(self, table_name: Text): ... def update_table( self, table_name: Text, read_capacity_units: Optional[Any] = ..., write_capacity_units: Optional[Any] = ..., global_secondary_index_updates: Optional[Any] = ..., ): ... def list_tables(self, exclusive_start_table_name: Optional[Any] = ..., limit: Optional[Any] = ...): ... def describe_table(self, table_name: Text): ... def get_conditional_operator(self, operator): ... def get_item_attribute_map(self, table_name: Text, attributes, item_key: Any = ..., pythonic_key: bool = ...): ... def get_expected_map(self, table_name: Text, expected): ... def parse_attribute(self, attribute, return_type: bool = ...): ... def get_attribute_type(self, table_name: Text, attribute_name, value: Optional[Any] = ...): ... def get_identifier_map(self, table_name: Text, hash_key, range_key: Optional[Any] = ..., key: Any = ...): ... def get_query_filter_map(self, table_name: Text, query_filters): ... def get_consumed_capacity_map(self, return_consumed_capacity): ... def get_return_values_map(self, return_values): ... def get_item_collection_map(self, return_item_collection_metrics): ... def get_exclusive_start_key_map(self, table_name: Text, exclusive_start_key): ... def delete_item( self, table_name: Text, hash_key, range_key: Optional[Any] = ..., expected: Optional[Any] = ..., conditional_operator: Optional[Any] = ..., return_values: Optional[Any] = ..., return_consumed_capacity: Optional[Any] = ..., return_item_collection_metrics: Optional[Any] = ..., ): ... def update_item( self, table_name: Text, hash_key, range_key: Optional[Any] = ..., attribute_updates: Optional[Any] = ..., expected: Optional[Any] = ..., return_consumed_capacity: Optional[Any] = ..., conditional_operator: Optional[Any] = ..., return_item_collection_metrics: Optional[Any] = ..., return_values: Optional[Any] = ..., ): ... def put_item( self, table_name: Text, hash_key, range_key: Optional[Any] = ..., attributes: Optional[Any] = ..., expected: Optional[Any] = ..., conditional_operator: Optional[Any] = ..., return_values: Optional[Any] = ..., return_consumed_capacity: Optional[Any] = ..., return_item_collection_metrics: Optional[Any] = ..., ): ... def batch_write_item( self, table_name: Text, put_items: Optional[Any] = ..., delete_items: Optional[Any] = ..., return_consumed_capacity: Optional[Any] = ..., return_item_collection_metrics: Optional[Any] = ..., ): ... def batch_get_item( self, table_name: Text, keys, consistent_read: Optional[Any] = ..., return_consumed_capacity: Optional[Any] = ..., attributes_to_get: Optional[Any] = ..., ): ... def get_item( self, table_name: Text, hash_key, range_key: Optional[Any] = ..., consistent_read: bool = ..., attributes_to_get: Optional[Any] = ..., ): ... def scan( self, table_name: Text, attributes_to_get: Optional[Any] = ..., limit: Optional[Any] = ..., conditional_operator: Optional[Any] = ..., scan_filter: Optional[Any] = ..., return_consumed_capacity: Optional[Any] = ..., exclusive_start_key: Optional[Any] = ..., segment: Optional[Any] = ..., total_segments: Optional[Any] = ..., ): ... def query( self, table_name: Text, hash_key, attributes_to_get: Optional[Any] = ..., consistent_read: bool = ..., exclusive_start_key: Optional[Any] = ..., index_name: Optional[Any] = ..., key_conditions: Optional[Any] = ..., query_filters: Optional[Any] = ..., conditional_operator: Optional[Any] = ..., limit: Optional[Any] = ..., return_consumed_capacity: Optional[Any] = ..., scan_index_forward: Optional[Any] = ..., select: Optional[Any] = ..., ): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/pynamodb/connection/table.pyi0000664000175000017500000000736100000000000030522 0ustar00davedave00000000000000from typing import Any, Optional class TableConnection: table_name: Any connection: Any def __init__( self, table_name, region: Optional[Any] = ..., host: Optional[Any] = ..., session_cls: Optional[Any] = ..., request_timeout_seconds: Optional[Any] = ..., max_retry_attempts: Optional[Any] = ..., base_backoff_ms: Optional[Any] = ..., ) -> None: ... def delete_item( self, hash_key, range_key: Optional[Any] = ..., expected: Optional[Any] = ..., conditional_operator: Optional[Any] = ..., return_values: Optional[Any] = ..., return_consumed_capacity: Optional[Any] = ..., return_item_collection_metrics: Optional[Any] = ..., ): ... def update_item( self, hash_key, range_key: Optional[Any] = ..., attribute_updates: Optional[Any] = ..., expected: Optional[Any] = ..., conditional_operator: Optional[Any] = ..., return_consumed_capacity: Optional[Any] = ..., return_item_collection_metrics: Optional[Any] = ..., return_values: Optional[Any] = ..., ): ... def put_item( self, hash_key, range_key: Optional[Any] = ..., attributes: Optional[Any] = ..., expected: Optional[Any] = ..., conditional_operator: Optional[Any] = ..., return_values: Optional[Any] = ..., return_consumed_capacity: Optional[Any] = ..., return_item_collection_metrics: Optional[Any] = ..., ): ... def batch_write_item( self, put_items: Optional[Any] = ..., delete_items: Optional[Any] = ..., return_consumed_capacity: Optional[Any] = ..., return_item_collection_metrics: Optional[Any] = ..., ): ... def batch_get_item( self, keys, consistent_read: Optional[Any] = ..., return_consumed_capacity: Optional[Any] = ..., attributes_to_get: Optional[Any] = ..., ): ... def get_item( self, hash_key, range_key: Optional[Any] = ..., consistent_read: bool = ..., attributes_to_get: Optional[Any] = ... ): ... def scan( self, attributes_to_get: Optional[Any] = ..., limit: Optional[Any] = ..., conditional_operator: Optional[Any] = ..., scan_filter: Optional[Any] = ..., return_consumed_capacity: Optional[Any] = ..., segment: Optional[Any] = ..., total_segments: Optional[Any] = ..., exclusive_start_key: Optional[Any] = ..., ): ... def query( self, hash_key, attributes_to_get: Optional[Any] = ..., consistent_read: bool = ..., exclusive_start_key: Optional[Any] = ..., index_name: Optional[Any] = ..., key_conditions: Optional[Any] = ..., query_filters: Optional[Any] = ..., limit: Optional[Any] = ..., return_consumed_capacity: Optional[Any] = ..., scan_index_forward: Optional[Any] = ..., conditional_operator: Optional[Any] = ..., select: Optional[Any] = ..., ): ... def describe_table(self): ... def delete_table(self): ... def update_table( self, read_capacity_units: Optional[Any] = ..., write_capacity_units: Optional[Any] = ..., global_secondary_index_updates: Optional[Any] = ..., ): ... def create_table( self, attribute_definitions: Optional[Any] = ..., key_schema: Optional[Any] = ..., read_capacity_units: Optional[Any] = ..., write_capacity_units: Optional[Any] = ..., global_secondary_indexes: Optional[Any] = ..., local_secondary_indexes: Optional[Any] = ..., stream_specification: Optional[Any] = ..., ): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/pynamodb/connection/util.pyi0000664000175000017500000000010300000000000030373 0ustar00davedave00000000000000from typing import Text def pythonic(var_name: Text) -> Text: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/pynamodb/constants.pyi0000664000175000017500000000573600000000000027314 0ustar00davedave00000000000000from typing import Any BATCH_WRITE_ITEM: str DESCRIBE_TABLE: str BATCH_GET_ITEM: str CREATE_TABLE: str UPDATE_TABLE: str DELETE_TABLE: str LIST_TABLES: str UPDATE_ITEM: str DELETE_ITEM: str GET_ITEM: str PUT_ITEM: str QUERY: str SCAN: str GLOBAL_SECONDARY_INDEX_UPDATES: str RETURN_ITEM_COLL_METRICS: str EXCLUSIVE_START_TABLE_NAME: str RETURN_CONSUMED_CAPACITY: str COMPARISON_OPERATOR: str SCAN_INDEX_FORWARD: str ATTR_DEFINITIONS: str ATTR_VALUE_LIST: str TABLE_DESCRIPTION: str UNPROCESSED_KEYS: str UNPROCESSED_ITEMS: str CONSISTENT_READ: str DELETE_REQUEST: str RETURN_VALUES: str REQUEST_ITEMS: str ATTRS_TO_GET: str ATTR_UPDATES: str TABLE_STATUS: str SCAN_FILTER: str TABLE_NAME: str KEY_SCHEMA: str ATTR_NAME: str ATTR_TYPE: str ITEM_COUNT: str CAMEL_COUNT: str PUT_REQUEST: str INDEX_NAME: str ATTRIBUTES: str TABLE_KEY: str RESPONSES: str RANGE_KEY: str KEY_TYPE: str ACTION: str UPDATE: str EXISTS: str SELECT: str ACTIVE: str LIMIT: str ITEMS: str ITEM: str KEYS: str UTC: str KEY: str DEFAULT_ENCODING: str DEFAULT_REGION: str DATETIME_FORMAT: str SERVICE_NAME: str HTTP_OK: int HTTP_BAD_REQUEST: int PROVISIONED_THROUGHPUT: str READ_CAPACITY_UNITS: str WRITE_CAPACITY_UNITS: str STRING_SHORT: str STRING_SET_SHORT: str NUMBER_SHORT: str NUMBER_SET_SHORT: str BINARY_SHORT: str BINARY_SET_SHORT: str MAP_SHORT: str LIST_SHORT: str BOOLEAN: str BOOLEAN_SHORT: str STRING: str STRING_SET: str NUMBER: str NUMBER_SET: str BINARY: str BINARY_SET: str MAP: str LIST: str SHORT_ATTR_TYPES: Any ATTR_TYPE_MAP: Any LOCAL_SECONDARY_INDEX: str LOCAL_SECONDARY_INDEXES: str GLOBAL_SECONDARY_INDEX: str GLOBAL_SECONDARY_INDEXES: str PROJECTION: str PROJECTION_TYPE: str NON_KEY_ATTRIBUTES: str KEYS_ONLY: str ALL: str INCLUDE: str STREAM_VIEW_TYPE: str STREAM_SPECIFICATION: str STREAM_ENABLED: str STREAM_NEW_IMAGE: str STREAM_OLD_IMAGE: str STREAM_NEW_AND_OLD_IMAGE: str STREAM_KEYS_ONLY: str EXCLUSIVE_START_KEY: str LAST_EVALUATED_KEY: str QUERY_FILTER: str BEGINS_WITH: str BETWEEN: str EQ: str NE: str LE: str LT: str GE: str GT: str IN: str KEY_CONDITIONS: str COMPARISON_OPERATOR_VALUES: Any QUERY_OPERATOR_MAP: Any NOT_NULL: str NULL: str CONTAINS: str NOT_CONTAINS: str ALL_ATTRIBUTES: str ALL_PROJECTED_ATTRIBUTES: str SPECIFIC_ATTRIBUTES: str COUNT: str SELECT_VALUES: Any SCAN_OPERATOR_MAP: Any QUERY_FILTER_OPERATOR_MAP: Any DELETE_FILTER_OPERATOR_MAP: Any UPDATE_FILTER_OPERATOR_MAP: Any PUT_FILTER_OPERATOR_MAP: Any SEGMENT: str TOTAL_SEGMENTS: str SCAN_FILTER_VALUES: Any QUERY_FILTER_VALUES: Any DELETE_FILTER_VALUES: Any VALUE: str EXPECTED: str CONSUMED_CAPACITY: str CAPACITY_UNITS: str INDEXES: str TOTAL: str NONE: str RETURN_CONSUMED_CAPACITY_VALUES: Any SIZE: str RETURN_ITEM_COLL_METRICS_VALUES: Any ALL_OLD: str UPDATED_OLD: str ALL_NEW: str UPDATED_NEW: str RETURN_VALUES_VALUES: Any PUT: str DELETE: str ADD: str ATTR_UPDATE_ACTIONS: Any BATCH_GET_PAGE_LIMIT: int BATCH_WRITE_PAGE_LIMIT: int META_CLASS_NAME: str REGION: str HOST: str CONDITIONAL_OPERATOR: str AND: str OR: str CONDITIONAL_OPERATORS: Any ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/pynamodb/exceptions.pyi0000664000175000017500000000156700000000000027457 0ustar00davedave00000000000000from typing import Any, Optional, Text class PynamoDBException(Exception): msg: str cause: Any def __init__(self, msg: Optional[Text] = ..., cause: Optional[Exception] = ...) -> None: ... class PynamoDBConnectionError(PynamoDBException): ... class DeleteError(PynamoDBConnectionError): ... class QueryError(PynamoDBConnectionError): ... class ScanError(PynamoDBConnectionError): ... class PutError(PynamoDBConnectionError): ... class UpdateError(PynamoDBConnectionError): ... class GetError(PynamoDBConnectionError): ... class TableError(PynamoDBConnectionError): ... class DoesNotExist(PynamoDBException): ... class TableDoesNotExist(PynamoDBException): def __init__(self, table_name) -> None: ... class VerboseClientError(Exception): MSG_TEMPLATE: Any def __init__(self, error_response, operation_name, verbose_properties: Optional[Any] = ...) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/pynamodb/indexes.pyi0000664000175000017500000000203400000000000026723 0ustar00davedave00000000000000from typing import Any, Optional class IndexMeta(type): def __init__(self, name, bases, attrs) -> None: ... class Index(metaclass=IndexMeta): Meta: Any def __init__(self) -> None: ... @classmethod def count(cls, hash_key, consistent_read: bool = ..., **filters) -> int: ... @classmethod def query( cls, hash_key, scan_index_forward: Optional[Any] = ..., consistent_read: bool = ..., limit: Optional[Any] = ..., last_evaluated_key: Optional[Any] = ..., attributes_to_get: Optional[Any] = ..., **filters, ): ... class GlobalSecondaryIndex(Index): ... class LocalSecondaryIndex(Index): ... class Projection(object): projection_type: Any non_key_attributes: Any class KeysOnlyProjection(Projection): projection_type: Any class IncludeProjection(Projection): projection_type: Any non_key_attributes: Any def __init__(self, non_attr_keys: Optional[Any] = ...) -> None: ... class AllProjection(Projection): projection_type: Any ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/pynamodb/models.pyi0000664000175000017500000001310600000000000026551 0ustar00davedave00000000000000from typing import Any, Dict, Generic, Iterable, Iterator, List, Optional, Sequence, Text, Tuple, Type, TypeVar, Union from .attributes import Attribute from .exceptions import DoesNotExist as DoesNotExist log: Any class DefaultMeta: ... class ResultSet(object): results: Any operation: Any arguments: Any def __init__(self, results, operation, arguments) -> None: ... def __iter__(self): ... class MetaModel(type): def __init__(self, name: Text, bases: Tuple[type, ...], attrs: Dict[Any, Any]) -> None: ... _T = TypeVar("_T", bound="Model") KeyType = Union[Text, bytes, float, int, Tuple[Any, ...]] class Model(metaclass=MetaModel): DoesNotExist = DoesNotExist attribute_values: Dict[Text, Any] def __init__(self, hash_key: Optional[KeyType] = ..., range_key: Optional[Any] = ..., **attrs) -> None: ... @classmethod def has_map_or_list_attributes(cls: Type[_T]) -> bool: ... @classmethod def batch_get( cls: Type[_T], items: Iterable[Union[KeyType, Iterable[KeyType]]], consistent_read: Optional[bool] = ..., attributes_to_get: Optional[Sequence[Text]] = ..., ) -> Iterator[_T]: ... @classmethod def batch_write(cls: Type[_T], auto_commit: bool = ...) -> BatchWrite[_T]: ... def delete(self, condition: Optional[Any] = ..., conditional_operator: Optional[Text] = ..., **expected_values) -> Any: ... def update( self, attributes: Optional[Dict[Text, Dict[Text, Any]]] = ..., actions: Optional[List[Any]] = ..., condition: Optional[Any] = ..., conditional_operator: Optional[Text] = ..., **expected_values, ) -> Any: ... def update_item( self, attribute: Text, value: Optional[Any] = ..., action: Optional[Text] = ..., conditional_operator: Optional[Text] = ..., **expected_values, ): ... def save( self, condition: Optional[Any] = ..., conditional_operator: Optional[Text] = ..., **expected_values ) -> Dict[str, Any]: ... def refresh(self, consistent_read: bool = ...): ... @classmethod def get(cls: Type[_T], hash_key: KeyType, range_key: Optional[KeyType] = ..., consistent_read: bool = ...) -> _T: ... @classmethod def from_raw_data(cls: Type[_T], data) -> _T: ... @classmethod def count( cls: Type[_T], hash_key: Optional[KeyType] = ..., consistent_read: bool = ..., index_name: Optional[Text] = ..., limit: Optional[int] = ..., **filters, ) -> int: ... @classmethod def query( cls: Type[_T], hash_key: KeyType, consistent_read: bool = ..., index_name: Optional[Text] = ..., scan_index_forward: Optional[Any] = ..., conditional_operator: Optional[Text] = ..., limit: Optional[int] = ..., last_evaluated_key: Optional[Any] = ..., attributes_to_get: Optional[Iterable[Text]] = ..., page_size: Optional[int] = ..., **filters, ) -> Iterator[_T]: ... @classmethod def rate_limited_scan( cls: Type[_T], # TODO: annotate Condition class filter_condition: Optional[Any] = ..., attributes_to_get: Optional[Sequence[Text]] = ..., segment: Optional[int] = ..., total_segments: Optional[int] = ..., limit: Optional[int] = ..., conditional_operator: Optional[Text] = ..., last_evaluated_key: Optional[Any] = ..., page_size: Optional[int] = ..., timeout_seconds: Optional[int] = ..., read_capacity_to_consume_per_second: int = ..., allow_rate_limited_scan_without_consumed_capacity: Optional[bool] = ..., max_sleep_between_retry: int = ..., max_consecutive_exceptions: int = ..., consistent_read: Optional[bool] = ..., index_name: Optional[str] = ..., **filters: Any, ) -> Iterator[_T]: ... @classmethod def scan( cls: Type[_T], segment: Optional[int] = ..., total_segments: Optional[int] = ..., limit: Optional[int] = ..., conditional_operator: Optional[Text] = ..., last_evaluated_key: Optional[Any] = ..., page_size: Optional[int] = ..., **filters, ) -> Iterator[_T]: ... @classmethod def exists(cls: Type[_T]) -> bool: ... @classmethod def delete_table(cls): ... @classmethod def describe_table(cls): ... @classmethod def create_table( cls: Type[_T], wait: bool = ..., read_capacity_units: Optional[Any] = ..., write_capacity_units: Optional[Any] = ... ): ... @classmethod def dumps(cls): ... @classmethod def dump(cls, filename): ... @classmethod def loads(cls, data): ... @classmethod def load(cls, filename): ... @classmethod def add_throttle_record(cls, records): ... @classmethod def get_throttle(cls): ... @classmethod def get_attributes(cls) -> Dict[str, Attribute[Any]]: ... @classmethod def _get_attributes(cls) -> Dict[str, Attribute[Any]]: ... class ModelContextManager(Generic[_T]): model: Type[_T] auto_commit: bool max_operations: int pending_operations: List[Dict[Text, Any]] def __init__(self, model: Type[_T], auto_commit: bool = ...) -> None: ... def __enter__(self) -> ModelContextManager[_T]: ... class BatchWrite(ModelContextManager[_T]): def save(self, put_item: _T) -> None: ... def delete(self, del_item: _T) -> None: ... def __enter__(self) -> BatchWrite[_T]: ... def __exit__(self, exc_type, exc_val, exc_tb) -> None: ... pending_operations: Any def commit(self) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/pynamodb/settings.pyi0000664000175000017500000000022100000000000027120 0ustar00davedave00000000000000from typing import Any log: Any default_settings_dict: Any OVERRIDE_SETTINGS_PATH: Any override_settings: Any def get_settings_value(key): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/pynamodb/throttle.pyi0000664000175000017500000000073000000000000027132 0ustar00davedave00000000000000from typing import Any, Optional log: Any class ThrottleBase: capacity: Any window: Any records: Any sleep_interval: Any def __init__(self, capacity, window: int = ..., initial_sleep: Optional[Any] = ...) -> None: ... def add_record(self, record): ... def throttle(self): ... class NoThrottle(ThrottleBase): def __init__(self) -> None: ... def add_record(self, record): ... class Throttle(ThrottleBase): def throttle(self): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/pynamodb/types.pyi0000664000175000017500000000007100000000000026427 0ustar00davedave00000000000000STRING: str NUMBER: str BINARY: str HASH: str RANGE: str ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/pyre_extensions.pyi0000664000175000017500000000041300000000000026710 0ustar00davedave00000000000000from typing import Any, List, Optional, Type, TypeVar _T = TypeVar("_T") def none_throws(optional: Optional[_T], message: str = ...) -> _T: ... def safe_cast(new_type: Type[_T], value: Any) -> _T: ... def ParameterSpecification(__name: str) -> List[Type[Any]]: ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4543793 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/pytz/0000775000175000017500000000000000000000000023737 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/pytz/__init__.pyi0000664000175000017500000000354400000000000026227 0ustar00davedave00000000000000import datetime from typing import List, Mapping, Optional, Set, Union class BaseTzInfo(datetime.tzinfo): zone: str = ... def localize(self, dt: datetime.datetime, is_dst: Optional[bool] = ...) -> datetime.datetime: ... def normalize(self, dt: datetime.datetime) -> datetime.datetime: ... class _UTCclass(BaseTzInfo): def tzname(self, dt: Optional[datetime.datetime]) -> str: ... def utcoffset(self, dt: Optional[datetime.datetime]) -> datetime.timedelta: ... def dst(self, dt: Optional[datetime.datetime]) -> datetime.timedelta: ... class _StaticTzInfo(BaseTzInfo): def tzname(self, dt: Optional[datetime.datetime], is_dst: Optional[bool] = ...) -> str: ... def utcoffset(self, dt: Optional[datetime.datetime], is_dst: Optional[bool] = ...) -> datetime.timedelta: ... def dst(self, dt: Optional[datetime.datetime], is_dst: Optional[bool] = ...) -> datetime.timedelta: ... class _DstTzInfo(BaseTzInfo): def tzname(self, dt: Optional[datetime.datetime], is_dst: Optional[bool] = ...) -> str: ... def utcoffset(self, dt: Optional[datetime.datetime], is_dst: Optional[bool] = ...) -> Optional[datetime.timedelta]: ... def dst(self, dt: Optional[datetime.datetime], is_dst: Optional[bool] = ...) -> Optional[datetime.timedelta]: ... class UnknownTimeZoneError(KeyError): ... class InvalidTimeError(Exception): ... class AmbiguousTimeError(InvalidTimeError): ... class NonExistentTimeError(InvalidTimeError): ... utc: _UTCclass UTC: _UTCclass def timezone(zone: str) -> Union[_UTCclass, _StaticTzInfo, _DstTzInfo]: ... def FixedOffset(offset: int) -> Union[_UTCclass, datetime.tzinfo]: ... all_timezones: List[str] all_timezones_set: Set[str] common_timezones: List[str] common_timezones_set: Set[str] country_timezones: Mapping[str, List[str]] country_names: Mapping[str, str] ZERO: datetime.timedelta HOUR: datetime.timedelta VERSION: str ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4543793 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/redis/0000775000175000017500000000000000000000000024037 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/redis/__init__.pyi0000664000175000017500000000147500000000000026330 0ustar00davedave00000000000000from . import client, connection, exceptions, utils Redis = client.Redis StrictRedis = client.StrictRedis BlockingConnectionPool = connection.BlockingConnectionPool ConnectionPool = connection.ConnectionPool Connection = connection.Connection SSLConnection = connection.SSLConnection UnixDomainSocketConnection = connection.UnixDomainSocketConnection from_url = utils.from_url AuthenticationError = exceptions.AuthenticationError BusyLoadingError = exceptions.BusyLoadingError ConnectionError = exceptions.ConnectionError DataError = exceptions.DataError InvalidResponse = exceptions.InvalidResponse PubSubError = exceptions.PubSubError ReadOnlyError = exceptions.ReadOnlyError RedisError = exceptions.RedisError ResponseError = exceptions.ResponseError TimeoutError = exceptions.TimeoutError WatchError = exceptions.WatchError ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/redis/client.pyi0000664000175000017500000006266200000000000026054 0ustar00davedave00000000000000from datetime import timedelta from typing import ( Any, Callable, Dict, Generic, Iterable, Iterator, List, Mapping, Optional, Sequence, Set, Text, Tuple, TypeVar, Union, overload, ) from typing_extensions import Literal from .connection import ConnectionPool SYM_EMPTY: Any def list_or_args(keys, args): ... def timestamp_to_datetime(response): ... def string_keys_to_dict(key_string, callback): ... def dict_merge(*dicts): ... def parse_debug_object(response): ... def parse_object(response, infotype): ... def parse_info(response): ... SENTINEL_STATE_TYPES: Any def parse_sentinel_state(item): ... def parse_sentinel_master(response): ... def parse_sentinel_masters(response): ... def parse_sentinel_slaves_and_sentinels(response): ... def parse_sentinel_get_master(response): ... def pairs_to_dict(response): ... def pairs_to_dict_typed(response, type_info): ... def zset_score_pairs(response, **options): ... def sort_return_tuples(response, **options): ... def int_or_none(response): ... def float_or_none(response): ... def bool_ok(response): ... def parse_client_list(response, **options): ... def parse_config_get(response, **options): ... def parse_scan(response, **options): ... def parse_hscan(response, **options): ... def parse_zscan(response, **options): ... def parse_slowlog_get(response, **options): ... _Value = Union[bytes, float, int, Text] _Key = Union[Text, bytes] # Lib returns str or bytes depending on Python version and value of decode_responses _StrType = TypeVar("_StrType", bound=Union[Text, bytes]) class Redis(Generic[_StrType]): RESPONSE_CALLBACKS: Any @overload @classmethod def from_url( cls, url: Text, host: Optional[Text] = ..., port: Optional[int] = ..., db: Optional[int] = ..., password: Optional[Text] = ..., socket_timeout: Optional[float] = ..., socket_connect_timeout: Optional[float] = ..., socket_keepalive: Optional[bool] = ..., socket_keepalive_options: Optional[Mapping[str, Union[int, str]]] = ..., connection_pool: Optional[ConnectionPool] = ..., unix_socket_path: Optional[Text] = ..., encoding: Text = ..., encoding_errors: Text = ..., charset: Optional[Text] = ..., errors: Optional[Text] = ..., decode_responses: Optional[bool] = ..., retry_on_timeout: bool = ..., ssl: bool = ..., ssl_keyfile: Optional[Text] = ..., ssl_certfile: Optional[Text] = ..., ssl_cert_reqs: Optional[Union[str, int]] = ..., ssl_ca_certs: Optional[Text] = ..., ssl_check_hostname: bool = ..., max_connections: Optional[int] = ..., single_connection_client: bool = ..., health_check_interval: float = ..., client_name: Optional[Text] = ..., username: Optional[Text] = ..., ) -> Redis[bytes]: ... @overload @classmethod def from_url( cls, url: Text, host: Optional[Text] = ..., port: Optional[int] = ..., db: Optional[int] = ..., password: Optional[Text] = ..., socket_timeout: Optional[float] = ..., socket_connect_timeout: Optional[float] = ..., socket_keepalive: Optional[bool] = ..., socket_keepalive_options: Optional[Mapping[str, Union[int, str]]] = ..., connection_pool: Optional[ConnectionPool] = ..., unix_socket_path: Optional[Text] = ..., encoding: Text = ..., encoding_errors: Text = ..., charset: Optional[Text] = ..., decode_responses: Literal[True] = ..., errors: Optional[Text] = ..., retry_on_timeout: bool = ..., ssl: bool = ..., ssl_keyfile: Optional[Text] = ..., ssl_certfile: Optional[Text] = ..., ssl_cert_reqs: Optional[Union[str, int]] = ..., ssl_ca_certs: Optional[Text] = ..., ssl_check_hostname: bool = ..., max_connections: Optional[int] = ..., single_connection_client: bool = ..., health_check_interval: float = ..., client_name: Optional[Text] = ..., username: Optional[Text] = ..., ) -> Redis[str]: ... connection_pool: Any response_callbacks: Any @overload def __new__( cls, host: Text = ..., port: int = ..., db: int = ..., password: Optional[Text] = ..., socket_timeout: Optional[float] = ..., socket_connect_timeout: Optional[float] = ..., socket_keepalive: Optional[bool] = ..., socket_keepalive_options: Optional[Mapping[str, Union[int, str]]] = ..., connection_pool: Optional[ConnectionPool] = ..., unix_socket_path: Optional[Text] = ..., encoding: Text = ..., encoding_errors: Text = ..., charset: Optional[Text] = ..., errors: Optional[Text] = ..., retry_on_timeout: bool = ..., ssl: bool = ..., ssl_keyfile: Optional[Text] = ..., ssl_certfile: Optional[Text] = ..., ssl_cert_reqs: Optional[Union[str, int]] = ..., ssl_ca_certs: Optional[Text] = ..., ssl_check_hostname: bool = ..., max_connections: Optional[int] = ..., single_connection_client: bool = ..., health_check_interval: float = ..., client_name: Optional[Text] = ..., username: Optional[Text] = ..., ) -> Redis[bytes]: ... @overload def __new__( cls, host: Text = ..., port: int = ..., db: int = ..., password: Optional[Text] = ..., socket_timeout: Optional[float] = ..., socket_connect_timeout: Optional[float] = ..., socket_keepalive: Optional[bool] = ..., socket_keepalive_options: Optional[Mapping[str, Union[int, str]]] = ..., connection_pool: Optional[ConnectionPool] = ..., unix_socket_path: Optional[Text] = ..., encoding: Text = ..., encoding_errors: Text = ..., charset: Optional[Text] = ..., errors: Optional[Text] = ..., decode_responses: Literal[True] = ..., retry_on_timeout: bool = ..., ssl: bool = ..., ssl_keyfile: Optional[Text] = ..., ssl_certfile: Optional[Text] = ..., ssl_cert_reqs: Optional[Union[str, int]] = ..., ssl_ca_certs: Optional[Text] = ..., ssl_check_hostname: bool = ..., max_connections: Optional[int] = ..., single_connection_client: bool = ..., health_check_interval: float = ..., client_name: Optional[Text] = ..., username: Optional[Text] = ..., ) -> Redis[str]: ... @overload def __init__( self: Redis[str], host: Text = ..., port: int = ..., db: int = ..., password: Optional[Text] = ..., socket_timeout: Optional[float] = ..., socket_connect_timeout: Optional[float] = ..., socket_keepalive: Optional[bool] = ..., socket_keepalive_options: Optional[Mapping[str, Union[int, str]]] = ..., connection_pool: Optional[ConnectionPool] = ..., unix_socket_path: Optional[Text] = ..., encoding: Text = ..., encoding_errors: Text = ..., charset: Optional[Text] = ..., errors: Optional[Text] = ..., decode_responses: Literal[True] = ..., retry_on_timeout: bool = ..., ssl: bool = ..., ssl_keyfile: Optional[Text] = ..., ssl_certfile: Optional[Text] = ..., ssl_cert_reqs: Optional[Union[str, int]] = ..., ssl_ca_certs: Optional[Text] = ..., ssl_check_hostname: bool = ..., max_connections: Optional[int] = ..., single_connection_client: bool = ..., health_check_interval: float = ..., client_name: Optional[Text] = ..., username: Optional[Text] = ..., ) -> None: ... @overload def __init__( self: Redis[bytes], host: Text = ..., port: int = ..., db: int = ..., password: Optional[Text] = ..., socket_timeout: Optional[float] = ..., socket_connect_timeout: Optional[float] = ..., socket_keepalive: Optional[bool] = ..., socket_keepalive_options: Optional[Mapping[str, Union[int, str]]] = ..., connection_pool: Optional[ConnectionPool] = ..., unix_socket_path: Optional[Text] = ..., encoding: Text = ..., encoding_errors: Text = ..., charset: Optional[Text] = ..., errors: Optional[Text] = ..., decode_responses: Optional[bool] = ..., retry_on_timeout: bool = ..., ssl: bool = ..., ssl_keyfile: Optional[Text] = ..., ssl_certfile: Optional[Text] = ..., ssl_cert_reqs: Optional[Union[str, int]] = ..., ssl_ca_certs: Optional[Text] = ..., ssl_check_hostname: bool = ..., max_connections: Optional[int] = ..., single_connection_client: bool = ..., health_check_interval: float = ..., client_name: Optional[Text] = ..., username: Optional[Text] = ..., ) -> None: ... def set_response_callback(self, command, callback): ... def pipeline(self, transaction: bool = ..., shard_hint: Any = ...) -> Pipeline: ... def transaction(self, func, *watches, **kwargs): ... def lock(self, name, timeout=..., sleep=..., blocking_timeout=..., lock_class=..., thread_local=...): ... def pubsub(self, shard_hint: Any = ..., ignore_subscribe_messages: bool = ...) -> PubSub: ... def execute_command(self, *args, **options): ... def parse_response(self, connection, command_name, **options): ... def acl_cat(self, category: Optional[Text] = ...) -> List[str]: ... def acl_deluser(self, username: Text) -> int: ... def acl_genpass(self) -> Text: ... def acl_getuser(self, username: Text) -> Optional[Any]: ... def acl_list(self) -> List[Text]: ... def acl_load(self) -> bool: ... def acl_setuser( self, username: Text = ..., enabled: bool = ..., nopass: bool = ..., passwords: Optional[Sequence[Text]] = ..., hashed_passwords: Optional[Sequence[Text]] = ..., categories: Optional[Sequence[Text]] = ..., commands: Optional[Sequence[Text]] = ..., keys: Optional[Sequence[Text]] = ..., reset: bool = ..., reset_keys: bool = ..., reset_passwords: bool = ..., ) -> bool: ... def acl_users(self) -> List[Text]: ... def acl_whoami(self) -> Text: ... def bgrewriteaof(self): ... def bgsave(self): ... def client_id(self) -> int: ... def client_kill(self, address: Text) -> bool: ... def client_list(self) -> List[Dict[str, str]]: ... def client_getname(self) -> Optional[str]: ... def client_setname(self, name: Text) -> bool: ... def readwrite(self) -> bool: ... def readonly(self) -> bool: ... def config_get(self, pattern=...): ... def config_set(self, name, value): ... def config_resetstat(self): ... def config_rewrite(self): ... def dbsize(self) -> int: ... def debug_object(self, key): ... def echo(self, value): ... def flushall(self) -> bool: ... def flushdb(self) -> bool: ... def info(self, section: Optional[_Key] = ...) -> Mapping[str, Any]: ... def lastsave(self): ... def object(self, infotype, key): ... def ping(self) -> bool: ... def save(self) -> bool: ... def sentinel(self, *args): ... def sentinel_get_master_addr_by_name(self, service_name): ... def sentinel_master(self, service_name): ... def sentinel_masters(self): ... def sentinel_monitor(self, name, ip, port, quorum): ... def sentinel_remove(self, name): ... def sentinel_sentinels(self, service_name): ... def sentinel_set(self, name, option, value): ... def sentinel_slaves(self, service_name): ... def shutdown(self): ... def slaveof(self, host=..., port=...): ... def slowlog_get(self, num=...): ... def slowlog_len(self): ... def slowlog_reset(self): ... def time(self): ... def append(self, key, value): ... def bitcount(self, key: _Key, start: Optional[int] = ..., end: Optional[int] = ...) -> int: ... def bitop(self, operation, dest, *keys): ... def bitpos(self, key, bit, start=..., end=...): ... def decr(self, name, amount=...): ... def delete(self, *names: _Key) -> int: ... def __delitem__(self, _Key): ... def dump(self, name): ... def exists(self, *names: _Key) -> int: ... __contains__: Any def expire(self, name: _Key, time: Union[int, timedelta]) -> bool: ... def expireat(self, name, when): ... def get(self, name: _Key) -> Optional[_StrType]: ... def __getitem__(self, name): ... def getbit(self, name: _Key, offset: int) -> int: ... def getrange(self, key, start, end): ... def getset(self, name, value) -> Optional[_StrType]: ... def incr(self, name, amount=...): ... def incrby(self, name, amount=...): ... def incrbyfloat(self, name, amount=...): ... def keys(self, pattern=...): ... def mget(self, keys, *args): ... def mset(self, *args, **kwargs): ... def msetnx(self, *args, **kwargs): ... def move(self, name, db): ... def persist(self, name): ... def pexpire(self, name, time): ... def pexpireat(self, name, when): ... def psetex(self, name, time_ms, value): ... def pttl(self, name): ... def randomkey(self): ... def rename(self, src, dst): ... def renamenx(self, src, dst): ... def restore(self, name, ttl, value): ... def set( self, name: _Key, value: _Value, ex: Union[None, int, timedelta] = ..., px: Union[None, int, timedelta] = ..., nx: bool = ..., xx: bool = ..., keepttl: bool = ..., ) -> Optional[bool]: ... def __setitem__(self, name, value): ... def setbit(self, name: _Key, offset: int, value: int) -> int: ... def setex(self, name: _Key, time: Union[int, timedelta], value: _Value) -> bool: ... def setnx(self, name, value): ... def setrange(self, name, offset, value): ... def strlen(self, name): ... def substr(self, name, start, end=...): ... def ttl(self, name: _Key) -> int: ... def type(self, name): ... def watch(self, *names): ... def unlink(self, *names: _Key) -> int: ... def unwatch(self): ... def blpop(self, keys: Union[_Value, Iterable[_Value]], timeout: int = ...) -> Optional[Tuple[_StrType, _StrType]]: ... def brpop(self, keys: Union[_Value, Iterable[_Value]], timeout: int = ...) -> Optional[Tuple[_StrType, _StrType]]: ... def brpoplpush(self, src, dst, timeout=...): ... def lindex(self, name: _Key, index: int) -> Optional[_StrType]: ... def linsert( self, name: _Key, where: Literal["BEFORE", "AFTER", "before", "after"], refvalue: _Value, value: _Value ) -> int: ... def llen(self, name: _Key) -> int: ... def lpop(self, name): ... def lpush(self, name: _Value, *values: _Value) -> int: ... def lpushx(self, name, value): ... def lrange(self, name: _Key, start: int, end: int) -> List[_StrType]: ... def lrem(self, name: _Key, count: int, value: _Value) -> int: ... def lset(self, name: _Key, index: int, value: _Value) -> bool: ... def ltrim(self, name: _Key, start: int, end: int) -> bool: ... def rpop(self, name): ... def rpoplpush(self, src, dst): ... def rpush(self, name: _Value, *values: _Value) -> int: ... def rpushx(self, name, value): ... @overload def sort( self, name: _Key, start: Optional[int] = ..., num: Optional[int] = ..., by: Optional[_Key] = ..., get: Optional[Union[_Key, Sequence[_Key]]] = ..., desc: bool = ..., alpha: bool = ..., store: None = ..., groups: bool = ..., ) -> List[_StrType]: ... @overload def sort( self, name: _Key, start: Optional[int] = ..., num: Optional[int] = ..., by: Optional[_Key] = ..., get: Optional[Union[_Key, Sequence[_Key]]] = ..., desc: bool = ..., alpha: bool = ..., *, store: _Key, groups: bool = ..., ) -> int: ... @overload def sort( self, name: _Key, start: Optional[int], num: Optional[int], by: Optional[_Key], get: Optional[Union[_Key, Sequence[_Key]]], desc: bool, alpha: bool, store: _Key, groups: bool = ..., ) -> int: ... def scan(self, cursor: int = ..., match: Optional[_Key] = ..., count: Optional[int] = ...) -> Tuple[int, List[_StrType]]: ... def scan_iter(self, match: Optional[Text] = ..., count: Optional[int] = ...) -> Iterator[_StrType]: ... def sscan(self, name: _Key, cursor: int = ..., match: Text = ..., count: int = ...) -> Tuple[int, List[_StrType]]: ... def sscan_iter(self, name, match=..., count=...): ... def hscan( self, name: _Key, cursor: int = ..., match: Text = ..., count: int = ... ) -> Tuple[int, Dict[_StrType, _StrType]]: ... def hscan_iter(self, name, match=..., count=...): ... def zscan(self, name, cursor=..., match=..., count=..., score_cast_func=...): ... def zscan_iter(self, name, match=..., count=..., score_cast_func=...): ... def sadd(self, name: _Key, *values: _Value) -> int: ... def scard(self, name: _Key) -> int: ... def sdiff(self, keys, *args): ... def sdiffstore(self, dest, keys, *args): ... def sinter(self, keys: _Key, *args: _Key) -> Set[_Value]: ... def sinterstore(self, dest, keys, *args): ... def sismember(self, name: _Key, value: _Value) -> bool: ... def smembers(self, name: _Key) -> Set[_Value]: ... def smove(self, src, dst, value): ... def spop(self, name, count: Optional[int] = ...): ... @overload def srandmember(self, name: _Key, number: None = ...) -> Optional[_Value]: ... @overload def srandmember(self, name: _Key, number: int) -> List[_Value]: ... def srem(self, name: _Key, *values: _Value) -> int: ... def sunion(self, keys, *args): ... def sunionstore(self, dest, keys, *args): ... def xack(self, name, groupname, *ids): ... def xadd(self, name, fields, id=..., maxlen=..., approximate=...): ... def xclaim( self, name, groupname, consumername, min_idle_time, message_ids, idle=..., time=..., retrycount=..., force=..., justid=..., ): ... def xdel(self, name, *ids): ... def xgroup_create(self, name, groupname, id=..., mkstream=...): ... def xgroup_delconsumer(self, name, groupname, consumername): ... def xgroup_destroy(self, name, groupname): ... def xgroup_setid(self, name, groupname, id): ... def xinfo_consumers(self, name, groupname): ... def xinfo_groups(self, name): ... def xinfo_stream(self, name): ... def xlen(self, name: _Key) -> int: ... def xpending(self, name, groupname): ... def xpending_range(self, name, groupname, min, max, count, consumername=...): ... def xrange(self, name, min=..., max=..., count=...): ... def xread(self, streams, count=..., block=...): ... def xreadgroup(self, groupname, consumername, streams, count=..., block=..., noack=...): ... def xrevrange(self, name, max=..., min=..., count=...): ... def xtrim(self, name, maxlen, approximate=...): ... def zadd( self, name: _Key, mapping: Mapping[_Key, _Value], nx: bool = ..., xx: bool = ..., ch: bool = ..., incr: bool = ... ) -> int: ... def zcard(self, name): ... def zcount(self, name: _Key, min: _Value, max: _Value) -> int: ... def zincrby(self, name, value, amount=...): ... def zinterstore(self, dest, keys, aggregate=...): ... def zlexcount(self, name, min, max): ... def zpopmax(self, name, count=...): ... def zpopmin(self, name, count=...): ... def bzpopmax(self, keys, timeout=...): ... def bzpopmin(self, keys, timeout=...): ... def zrange(self, name, start, end, desc=..., withscores=..., score_cast_func=...): ... def zrangebylex(self, name, min, max, start=..., num=...): ... def zrangebyscore(self, name, min, max, start=..., num=..., withscores=..., score_cast_func=...): ... def zrank(self, name: _Key, value: _Key) -> Optional[int]: ... def zrem(self, name, *values): ... def zremrangebylex(self, name, min, max): ... def zremrangebyrank(self, name, min, max): ... def zremrangebyscore(self, name: _Key, min: _Value, max: _Value) -> int: ... def zrevrange(self, name, start, end, withscores=..., score_cast_func=...): ... def zrevrangebyscore(self, name, max, min, start=..., num=..., withscores=..., score_cast_func=...): ... def zrevrank(self, name, value): ... def zscore(self, name, value): ... def zunionstore(self, dest, keys, aggregate=...): ... def pfadd(self, name: _Key, *values: _Value) -> int: ... def pfcount(self, name: _Key) -> int: ... def pfmerge(self, dest: _Key, *sources: _Key) -> bool: ... def hdel(self, name: _Key, *keys: _Key) -> int: ... def hexists(self, name: _Key, key: _Key) -> bool: ... def hget(self, name: _Key, key: _Key) -> Optional[_StrType]: ... def hgetall(self, name: _Key) -> Dict[_StrType, _StrType]: ... def hincrby(self, name: _Key, key: _Key, amount: int = ...) -> int: ... def hincrbyfloat(self, name: _Key, key: _Key, amount: float = ...) -> float: ... def hkeys(self, name: _Key) -> List[_StrType]: ... def hlen(self, name: _Key) -> int: ... def hset( self, name: _Key, key: Optional[_Key], value: Optional[_Value], mapping: Optional[Mapping[_Value, _Value]] = ... ) -> int: ... def hsetnx(self, name: _Key, key: _Key, value: _Value) -> int: ... def hmset(self, name: _Key, mapping: Mapping[_Value, _Value]) -> bool: ... def hmget(self, name: _Key, keys: Union[_Key, Iterable[_Key]], *args: _Key) -> List[Optional[_StrType]]: ... def hvals(self, name: _Key) -> List[_StrType]: ... def publish(self, channel: _Key, message: _Key) -> int: ... def eval(self, script, numkeys, *keys_and_args): ... def evalsha(self, sha, numkeys, *keys_and_args): ... def script_exists(self, *args): ... def script_flush(self): ... def script_kill(self): ... def script_load(self, script): ... def register_script(self, script: Union[Text, _StrType]) -> Script: ... def pubsub_channels(self, pattern: _Key = ...) -> List[Text]: ... def pubsub_numsub(self, *args: _Key) -> List[Tuple[Text, int]]: ... def pubsub_numpat(self) -> int: ... def monitor(self) -> Monitor: ... def cluster(self, cluster_arg: str, *args: Any) -> Any: ... def __enter__(self) -> Redis: ... def __exit__(self, exc_type, exc_value, traceback): ... def client(self) -> Redis: ... StrictRedis = Redis class PubSub: PUBLISH_MESSAGE_TYPES: Any UNSUBSCRIBE_MESSAGE_TYPES: Any connection_pool: Any shard_hint: Any ignore_subscribe_messages: Any connection: Any encoding: Any encoding_errors: Any decode_responses: Any def __init__(self, connection_pool, shard_hint=..., ignore_subscribe_messages=...) -> None: ... def __del__(self): ... channels: Any patterns: Any def reset(self): ... def close(self) -> None: ... def on_connect(self, connection): ... def encode(self, value): ... @property def subscribed(self): ... def execute_command(self, *args, **kwargs): ... def parse_response(self, block=...): ... def psubscribe(self, *args: _Key, **kwargs: Callable[[Any], None]): ... def punsubscribe(self, *args: _Key) -> None: ... def subscribe(self, *args: _Key, **kwargs: Callable[[Any], None]) -> None: ... def unsubscribe(self, *args: _Key) -> None: ... def listen(self): ... def get_message(self, ignore_subscribe_messages: bool = ..., timeout: float = ...) -> Optional[Dict[str, Any]]: ... def handle_message(self, response, ignore_subscribe_messages: bool = ...) -> Optional[Dict[str, Any]]: ... def run_in_thread(self, sleep_time=...): ... def ping(self, message: Optional[_Value] = ...) -> None: ... class BasePipeline: UNWATCH_COMMANDS: Any connection_pool: Any connection: Any response_callbacks: Any transaction: Any shard_hint: Any watching: Any def __init__(self, connection_pool, response_callbacks, transaction, shard_hint) -> None: ... def __enter__(self): ... def __exit__(self, exc_type, exc_value, traceback): ... def __del__(self): ... def __len__(self): ... command_stack: Any scripts: Any explicit_transaction: Any def reset(self): ... def multi(self) -> None: ... def execute_command(self, *args, **kwargs): ... def immediate_execute_command(self, *args, **options): ... def pipeline_execute_command(self, *args, **options): ... def raise_first_error(self, commands, response): ... def annotate_exception(self, exception, number, command): ... def parse_response(self, connection, command_name, **options): ... def load_scripts(self): ... def execute(self, raise_on_error: bool = ...) -> List[Any]: ... def watch(self, *names: _Key) -> bool: ... def unwatch(self): ... def script_load_for_pipeline(self, script): ... class StrictPipeline(BasePipeline, StrictRedis): ... class Pipeline(BasePipeline, Redis): ... class Script: registered_client: Any script: Any sha: Any def __init__(self, registered_client, script) -> None: ... def __call__(self, keys=..., args=..., client=...): ... class Monitor(object): def __init__(self, connection_pool) -> None: ... def __enter__(self) -> Monitor: ... def __exit__(self, *args: Any) -> None: ... def next_command(self) -> Dict[Text, Any]: ... def listen(self) -> Iterable[Dict[Text, Any]]: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/redis/connection.pyi0000664000175000017500000001273300000000000026727 0ustar00davedave00000000000000from typing import Any, List, Mapping, Optional, Text, Tuple, Type, Union ssl_available: Any hiredis_version: Any HIREDIS_SUPPORTS_CALLABLE_ERRORS: Any HIREDIS_SUPPORTS_BYTE_BUFFER: Any msg: Any HIREDIS_USE_BYTE_BUFFER: Any SYM_STAR: Any SYM_DOLLAR: Any SYM_CRLF: Any SYM_EMPTY: Any SERVER_CLOSED_CONNECTION_ERROR: Any class BaseParser: EXCEPTION_CLASSES: Any def parse_error(self, response): ... class SocketBuffer: socket_read_size: Any bytes_written: Any bytes_read: Any def __init__(self, socket, socket_read_size, socket_timeout) -> None: ... @property def length(self): ... def read(self, length): ... def readline(self): ... def purge(self): ... def close(self): ... def can_read(self, timeout): ... class PythonParser(BaseParser): encoding: Any socket_read_size: Any def __init__(self, socket_read_size) -> None: ... def __del__(self): ... def on_connect(self, connection): ... def on_disconnect(self): ... def can_read(self, timeout): ... def read_response(self): ... class HiredisParser(BaseParser): socket_read_size: Any def __init__(self, socket_read_size) -> None: ... def __del__(self): ... def on_connect(self, connection): ... def on_disconnect(self): ... def can_read(self, timeout): ... def read_from_socket(self, timeout=..., raise_on_timeout: bool = ...) -> bool: ... def read_response(self): ... DefaultParser: Any class Encoder: def __init__(self, encoding, encoding_errors, decode_responses: bool) -> None: ... def encode(self, value: Union[Text, bytes, memoryview, bool, float]) -> bytes: ... def decode(self, value: Union[Text, bytes, memoryview], force: bool = ...) -> Text: ... class Connection: description_format: Any pid: Any host: Any port: Any db: Any password: Any socket_timeout: Any socket_connect_timeout: Any socket_keepalive: Any socket_keepalive_options: Any retry_on_timeout: Any encoding: Any encoding_errors: Any decode_responses: Any def __init__( self, host: Text = ..., port: int = ..., db: int = ..., password: Optional[Text] = ..., socket_timeout: Optional[float] = ..., socket_connect_timeout: Optional[float] = ..., socket_keepalive: bool = ..., socket_keepalive_options: Optional[Mapping[str, Union[int, str]]] = ..., socket_type: int = ..., retry_on_timeout: bool = ..., encoding: Text = ..., encoding_errors: Text = ..., decode_responses: bool = ..., parser_class: Type[BaseParser] = ..., socket_read_size: int = ..., health_check_interval: int = ..., client_name: Optional[Text] = ..., username: Optional[Text] = ..., ) -> None: ... def __del__(self): ... def register_connect_callback(self, callback): ... def clear_connect_callbacks(self): ... def connect(self): ... def on_connect(self): ... def disconnect(self): ... def check_health(self) -> None: ... def send_packed_command(self, command, check_health: bool = ...): ... def send_command(self, *args): ... def can_read(self, timeout=...): ... def read_response(self): ... def pack_command(self, *args): ... def pack_commands(self, commands): ... def repr_pieces(self) -> List[Tuple[Text, Text]]: ... class SSLConnection(Connection): description_format: Any keyfile: Any certfile: Any cert_reqs: Any ca_certs: Any def __init__( self, ssl_keyfile=..., ssl_certfile=..., ssl_cert_reqs=..., ssl_ca_certs=..., ssl_check_hostname: bool = ..., **kwargs ) -> None: ... class UnixDomainSocketConnection(Connection): description_format: Any pid: Any path: Any db: Any password: Any socket_timeout: Any retry_on_timeout: Any encoding: Any encoding_errors: Any decode_responses: Any def __init__( self, path=..., db: int = ..., username=..., password=..., socket_timeout=..., encoding=..., encoding_errors=..., decode_responses=..., retry_on_timeout=..., parser_class=..., socket_read_size: int = ..., health_check_interval: int = ..., client_name=..., ) -> None: ... def repr_pieces(self) -> List[Tuple[Text, Text]]: ... def to_bool(value: object) -> bool: ... class ConnectionPool: @classmethod def from_url(cls, url: Text, db: Optional[int] = ..., decode_components: bool = ..., **kwargs) -> ConnectionPool: ... connection_class: Any connection_kwargs: Any max_connections: Any def __init__(self, connection_class=..., max_connections=..., **connection_kwargs) -> None: ... pid: Any def reset(self): ... def get_connection(self, command_name, *keys, **options): ... def make_connection(self): ... def release(self, connection): ... def disconnect(self, inuse_connections: bool = ...): ... def get_encoder(self) -> Encoder: ... def owns_connection(self, connection: Connection) -> bool: ... class BlockingConnectionPool(ConnectionPool): queue_class: Any timeout: Any def __init__(self, max_connections=..., timeout=..., connection_class=..., queue_class=..., **connection_kwargs) -> None: ... pid: Any pool: Any def reset(self): ... def make_connection(self): ... def get_connection(self, command_name, *keys, **options): ... def release(self, connection): ... def disconnect(self): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/redis/exceptions.pyi0000664000175000017500000000107100000000000026742 0ustar00davedave00000000000000class RedisError(Exception): ... def __unicode__(self): ... class AuthenticationError(RedisError): ... class ConnectionError(RedisError): ... class TimeoutError(RedisError): ... class BusyLoadingError(ConnectionError): ... class InvalidResponse(RedisError): ... class ResponseError(RedisError): ... class DataError(RedisError): ... class PubSubError(RedisError): ... class WatchError(RedisError): ... class NoScriptError(ResponseError): ... class ExecAbortError(ResponseError): ... class ReadOnlyError(ResponseError): ... class LockError(RedisError, ValueError): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/redis/utils.pyi0000664000175000017500000000021000000000000025713 0ustar00davedave00000000000000from typing import Any HIREDIS_AVAILABLE: Any def from_url(url, db=..., **kwargs): ... def pipeline(redis_obj): ... class dummy: ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4543793 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/requests/0000775000175000017500000000000000000000000024604 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/requests/__init__.pyi0000664000175000017500000000164000000000000027067 0ustar00davedave00000000000000import logging from typing import Any, Text from .api import ( delete as delete, get as get, head as head, options as options, patch as patch, post as post, put as put, request as request, ) from .exceptions import ( ConnectionError as ConnectionError, HTTPError as HTTPError, ReadTimeout as ReadTimeout, RequestException as RequestException, Timeout as Timeout, TooManyRedirects as TooManyRedirects, URLRequired as URLRequired, ) from .models import PreparedRequest as PreparedRequest, Request as Request, Response as Response from .sessions import Session as Session, session as session from .status_codes import codes as codes __title__: Any __build__: Any __license__: Any __copyright__: Any __version__: Any class NullHandler(logging.Handler): def emit(self, record): ... def check_compatibility(urllib3_version: Text, chardet_version: Text) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/requests/adapters.pyi0000664000175000017500000000555500000000000027144 0ustar00davedave00000000000000from typing import Any, Container, Mapping, Optional, Text, Tuple, Union from . import cookies, exceptions, models, structures, utils from .packages.urllib3 import exceptions as urllib3_exceptions, poolmanager, response from .packages.urllib3.util import retry PreparedRequest = models.PreparedRequest Response = models.Response PoolManager = poolmanager.PoolManager proxy_from_url = poolmanager.proxy_from_url HTTPResponse = response.HTTPResponse Retry = retry.Retry DEFAULT_CA_BUNDLE_PATH = utils.DEFAULT_CA_BUNDLE_PATH get_encoding_from_headers = utils.get_encoding_from_headers prepend_scheme_if_needed = utils.prepend_scheme_if_needed get_auth_from_url = utils.get_auth_from_url urldefragauth = utils.urldefragauth CaseInsensitiveDict = structures.CaseInsensitiveDict ConnectTimeoutError = urllib3_exceptions.ConnectTimeoutError MaxRetryError = urllib3_exceptions.MaxRetryError ProtocolError = urllib3_exceptions.ProtocolError ReadTimeoutError = urllib3_exceptions.ReadTimeoutError ResponseError = urllib3_exceptions.ResponseError extract_cookies_to_jar = cookies.extract_cookies_to_jar ConnectionError = exceptions.ConnectionError ConnectTimeout = exceptions.ConnectTimeout ReadTimeout = exceptions.ReadTimeout SSLError = exceptions.SSLError ProxyError = exceptions.ProxyError RetryError = exceptions.RetryError DEFAULT_POOLBLOCK: Any DEFAULT_POOLSIZE: Any DEFAULT_RETRIES: Any class BaseAdapter: def __init__(self) -> None: ... def send( self, request: PreparedRequest, stream: bool = ..., timeout: Union[None, float, Tuple[float, float], Tuple[float, None]] = ..., verify: Union[bool, str] = ..., cert: Union[None, Union[bytes, Text], Container[Union[bytes, Text]]] = ..., proxies: Optional[Mapping[str, str]] = ..., ) -> Response: ... def close(self) -> None: ... class HTTPAdapter(BaseAdapter): __attrs__: Any max_retries: Any config: Any proxy_manager: Any def __init__(self, pool_connections=..., pool_maxsize=..., max_retries=..., pool_block=...) -> None: ... poolmanager: Any def init_poolmanager(self, connections, maxsize, block=..., **pool_kwargs): ... def proxy_manager_for(self, proxy, **proxy_kwargs): ... def cert_verify(self, conn, url, verify, cert): ... def build_response(self, req, resp): ... def get_connection(self, url, proxies=...): ... def close(self): ... def request_url(self, request, proxies): ... def add_headers(self, request, **kwargs): ... def proxy_headers(self, proxy): ... def send( self, request: PreparedRequest, stream: bool = ..., timeout: Union[None, float, Tuple[float, float], Tuple[float, None]] = ..., verify: Union[bool, str] = ..., cert: Union[None, Union[bytes, Text], Container[Union[bytes, Text]]] = ..., proxies: Optional[Mapping[str, str]] = ..., ) -> Response: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/requests/api.pyi0000664000175000017500000000230000000000000026073 0ustar00davedave00000000000000from _typeshed import SupportsItems from typing import Iterable, Optional, Text, Tuple, Union from .models import Response from .sessions import _Data _ParamsMappingKeyType = Union[Text, bytes, int, float] _ParamsMappingValueType = Union[Text, bytes, int, float, Iterable[Union[Text, bytes, int, float]], None] def request(method: str, url: str, **kwargs) -> Response: ... def get( url: Union[Text, bytes], params: Optional[ Union[ SupportsItems[_ParamsMappingKeyType, _ParamsMappingValueType], Tuple[_ParamsMappingKeyType, _ParamsMappingValueType], Iterable[Tuple[_ParamsMappingKeyType, _ParamsMappingValueType]], Union[Text, bytes], ] ] = ..., **kwargs, ) -> Response: ... def options(url: Union[Text, bytes], **kwargs) -> Response: ... def head(url: Union[Text, bytes], **kwargs) -> Response: ... def post(url: Union[Text, bytes], data: _Data = ..., json=..., **kwargs) -> Response: ... def put(url: Union[Text, bytes], data: _Data = ..., json=..., **kwargs) -> Response: ... def patch(url: Union[Text, bytes], data: _Data = ..., json=..., **kwargs) -> Response: ... def delete(url: Union[Text, bytes], **kwargs) -> Response: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/requests/auth.pyi0000664000175000017500000000217400000000000026274 0ustar00davedave00000000000000from typing import Any, Text, Union from . import cookies, models, status_codes, utils extract_cookies_to_jar = cookies.extract_cookies_to_jar parse_dict_header = utils.parse_dict_header to_native_string = utils.to_native_string CONTENT_TYPE_FORM_URLENCODED: Any CONTENT_TYPE_MULTI_PART: Any def _basic_auth_str(username: Union[bytes, Text], password: Union[bytes, Text]) -> str: ... class AuthBase: def __call__(self, r: models.PreparedRequest) -> models.PreparedRequest: ... class HTTPBasicAuth(AuthBase): username: Any password: Any def __init__(self, username, password) -> None: ... def __call__(self, r): ... class HTTPProxyAuth(HTTPBasicAuth): def __call__(self, r): ... class HTTPDigestAuth(AuthBase): username: Any password: Any last_nonce: Any nonce_count: Any chal: Any pos: Any num_401_calls: Any def __init__(self, username, password) -> None: ... def build_digest_header(self, method, url): ... def handle_redirect(self, r, **kwargs): ... def handle_401(self, r, **kwargs): ... def __call__(self, r): ... def init_per_thread_state(self) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/requests/compat.pyi0000664000175000017500000000007200000000000026611 0ustar00davedave00000000000000import collections OrderedDict = collections.OrderedDict ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/requests/cookies.pyi0000664000175000017500000000376100000000000026772 0ustar00davedave00000000000000import sys from typing import Any, MutableMapping if sys.version_info < (3, 0): from cookielib import CookieJar else: from http.cookiejar import CookieJar class MockRequest: type: Any def __init__(self, request) -> None: ... def get_type(self): ... def get_host(self): ... def get_origin_req_host(self): ... def get_full_url(self): ... def is_unverifiable(self): ... def has_header(self, name): ... def get_header(self, name, default=...): ... def add_header(self, key, val): ... def add_unredirected_header(self, name, value): ... def get_new_headers(self): ... @property def unverifiable(self): ... @property def origin_req_host(self): ... @property def host(self): ... class MockResponse: def __init__(self, headers) -> None: ... def info(self): ... def getheaders(self, name): ... def extract_cookies_to_jar(jar, request, response): ... def get_cookie_header(jar, request): ... def remove_cookie_by_name(cookiejar, name, domain=..., path=...): ... class CookieConflictError(RuntimeError): ... class RequestsCookieJar(CookieJar, MutableMapping[Any, Any]): def get(self, name, default=..., domain=..., path=...): ... def set(self, name, value, **kwargs): ... def iterkeys(self): ... def keys(self): ... def itervalues(self): ... def values(self): ... def iteritems(self): ... def items(self): ... def list_domains(self): ... def list_paths(self): ... def multiple_domains(self): ... def get_dict(self, domain=..., path=...): ... def __getitem__(self, name): ... def __setitem__(self, name, value): ... def __delitem__(self, name): ... def set_cookie(self, cookie, *args, **kwargs): ... def update(self, other): ... def copy(self): ... def get_policy(self): ... def create_cookie(name, value, **kwargs): ... def morsel_to_cookie(morsel): ... def cookiejar_from_dict(cookie_dict, cookiejar=..., overwrite=...): ... def merge_cookies(cookiejar, cookies): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/requests/exceptions.pyi0000664000175000017500000000235300000000000027513 0ustar00davedave00000000000000from typing import Any from .packages.urllib3.exceptions import HTTPError as BaseHTTPError class RequestException(IOError): response: Any request: Any def __init__(self, *args, **kwargs) -> None: ... class HTTPError(RequestException): ... class ConnectionError(RequestException): ... class ProxyError(ConnectionError): ... class SSLError(ConnectionError): ... class Timeout(RequestException): ... class ConnectTimeout(ConnectionError, Timeout): ... class ReadTimeout(Timeout): ... class URLRequired(RequestException): ... class TooManyRedirects(RequestException): ... class MissingSchema(RequestException, ValueError): ... class InvalidSchema(RequestException, ValueError): ... class InvalidURL(RequestException, ValueError): ... class InvalidHeader(RequestException, ValueError): ... class InvalidProxyURL(InvalidURL): ... class ChunkedEncodingError(RequestException): ... class ContentDecodingError(RequestException, BaseHTTPError): ... class StreamConsumedError(RequestException, TypeError): ... class RetryError(RequestException): ... class UnrewindableBodyError(RequestException): ... class RequestsWarning(Warning): ... class FileModeWarning(RequestsWarning, DeprecationWarning): ... class RequestsDependencyWarning(RequestsWarning): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/requests/hooks.pyi0000664000175000017500000000016500000000000026454 0ustar00davedave00000000000000from typing import Any HOOKS: Any def default_hooks(): ... def dispatch_hook(key, hooks, hook_data, **kwargs): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/requests/models.pyi0000664000175000017500000001074200000000000026616 0ustar00davedave00000000000000import datetime from typing import Any, Dict, Iterator, List, Optional, Text, Union from . import auth, cookies, exceptions, hooks, status_codes, structures, utils from .cookies import RequestsCookieJar from .packages.urllib3 import exceptions as urllib3_exceptions, fields, filepost, util default_hooks = hooks.default_hooks CaseInsensitiveDict = structures.CaseInsensitiveDict HTTPBasicAuth = auth.HTTPBasicAuth cookiejar_from_dict = cookies.cookiejar_from_dict get_cookie_header = cookies.get_cookie_header RequestField = fields.RequestField encode_multipart_formdata = filepost.encode_multipart_formdata parse_url = util.parse_url DecodeError = urllib3_exceptions.DecodeError ReadTimeoutError = urllib3_exceptions.ReadTimeoutError ProtocolError = urllib3_exceptions.ProtocolError LocationParseError = urllib3_exceptions.LocationParseError HTTPError = exceptions.HTTPError MissingSchema = exceptions.MissingSchema InvalidURL = exceptions.InvalidURL ChunkedEncodingError = exceptions.ChunkedEncodingError ContentDecodingError = exceptions.ContentDecodingError ConnectionError = exceptions.ConnectionError StreamConsumedError = exceptions.StreamConsumedError guess_filename = utils.guess_filename get_auth_from_url = utils.get_auth_from_url requote_uri = utils.requote_uri stream_decode_response_unicode = utils.stream_decode_response_unicode to_key_val_list = utils.to_key_val_list parse_header_links = utils.parse_header_links iter_slices = utils.iter_slices guess_json_utf = utils.guess_json_utf super_len = utils.super_len to_native_string = utils.to_native_string codes = status_codes.codes REDIRECT_STATI: Any DEFAULT_REDIRECT_LIMIT: Any CONTENT_CHUNK_SIZE: Any ITER_CHUNK_SIZE: Any class RequestEncodingMixin: @property def path_url(self): ... class RequestHooksMixin: def register_hook(self, event, hook): ... def deregister_hook(self, event, hook): ... class Request(RequestHooksMixin): hooks: Any method: Any url: Any headers: Any files: Any data: Any json: Any params: Any auth: Any cookies: Any def __init__( self, method=..., url=..., headers=..., files=..., data=..., params=..., auth=..., cookies=..., hooks=..., json=... ) -> None: ... def prepare(self) -> PreparedRequest: ... class PreparedRequest(RequestEncodingMixin, RequestHooksMixin): method: Optional[Union[str, Text]] url: Optional[Union[str, Text]] headers: CaseInsensitiveDict[str] body: Optional[Union[bytes, Text]] hooks: Any def __init__(self) -> None: ... def prepare( self, method=..., url=..., headers=..., files=..., data=..., params=..., auth=..., cookies=..., hooks=..., json=... ) -> None: ... def copy(self) -> PreparedRequest: ... def prepare_method(self, method) -> None: ... def prepare_url(self, url, params) -> None: ... def prepare_headers(self, headers) -> None: ... def prepare_body(self, data, files, json=...) -> None: ... def prepare_content_length(self, body) -> None: ... def prepare_auth(self, auth, url=...) -> None: ... def prepare_cookies(self, cookies) -> None: ... def prepare_hooks(self, hooks) -> None: ... class Response: __attrs__: Any _content: Optional[bytes] # undocumented status_code: int headers: CaseInsensitiveDict[str] raw: Any url: str encoding: str history: List[Response] reason: str cookies: RequestsCookieJar elapsed: datetime.timedelta request: PreparedRequest def __init__(self) -> None: ... def __bool__(self) -> bool: ... def __nonzero__(self) -> bool: ... def __iter__(self) -> Iterator[bytes]: ... def __enter__(self) -> Response: ... def __exit__(self, *args: Any) -> None: ... @property def next(self) -> Optional[PreparedRequest]: ... @property def ok(self) -> bool: ... @property def is_redirect(self) -> bool: ... @property def is_permanent_redirect(self) -> bool: ... @property def apparent_encoding(self) -> str: ... def iter_content(self, chunk_size: Optional[int] = ..., decode_unicode: bool = ...) -> Iterator[Any]: ... def iter_lines( self, chunk_size: Optional[int] = ..., decode_unicode: bool = ..., delimiter: Optional[Union[Text, bytes]] = ... ) -> Iterator[Any]: ... @property def content(self) -> bytes: ... @property def text(self) -> str: ... def json(self, **kwargs) -> Any: ... @property def links(self) -> Dict[Any, Any]: ... def raise_for_status(self) -> None: ... def close(self) -> None: ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4543793 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/requests/packages/0000775000175000017500000000000000000000000026362 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/requests/packages/__init__.pyi0000664000175000017500000000023600000000000030645 0ustar00davedave00000000000000class VendorAlias: def __init__(self, package_names) -> None: ... def find_module(self, fullname, path=...): ... def load_module(self, name): ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4543793 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/requests/packages/urllib3/0000775000175000017500000000000000000000000027736 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/requests/packages/urllib3/__init__.pyi0000664000175000017500000000147100000000000032223 0ustar00davedave00000000000000import logging from typing import Any from . import connectionpool, filepost, poolmanager, response from .util import request as _request, retry, timeout, url __license__: Any HTTPConnectionPool = connectionpool.HTTPConnectionPool HTTPSConnectionPool = connectionpool.HTTPSConnectionPool connection_from_url = connectionpool.connection_from_url encode_multipart_formdata = filepost.encode_multipart_formdata PoolManager = poolmanager.PoolManager ProxyManager = poolmanager.ProxyManager proxy_from_url = poolmanager.proxy_from_url HTTPResponse = response.HTTPResponse make_headers = _request.make_headers get_host = url.get_host Timeout = timeout.Timeout Retry = retry.Retry class NullHandler(logging.Handler): def emit(self, record): ... def add_stderr_logger(level=...): ... def disable_warnings(category=...): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/requests/packages/urllib3/_collections.pyi0000664000175000017500000000277700000000000033153 0ustar00davedave00000000000000from collections import MutableMapping from typing import Any, NoReturn, TypeVar _KT = TypeVar("_KT") _VT = TypeVar("_VT") class RLock: def __enter__(self): ... def __exit__(self, exc_type, exc_value, traceback): ... class RecentlyUsedContainer(MutableMapping[_KT, _VT]): ContainerCls: Any dispose_func: Any lock: Any def __init__(self, maxsize=..., dispose_func=...) -> None: ... def __getitem__(self, key): ... def __setitem__(self, key, value): ... def __delitem__(self, key): ... def __len__(self): ... def __iter__(self): ... def clear(self): ... def keys(self): ... class HTTPHeaderDict(MutableMapping[str, str]): def __init__(self, headers=..., **kwargs) -> None: ... def __setitem__(self, key, val): ... def __getitem__(self, key): ... def __delitem__(self, key): ... def __contains__(self, key): ... def __eq__(self, other): ... def __iter__(self) -> NoReturn: ... def __len__(self) -> int: ... def __ne__(self, other): ... values: Any get: Any update: Any iterkeys: Any itervalues: Any def pop(self, key, default=...): ... def discard(self, key): ... def add(self, key, val): ... def extend(self, *args, **kwargs): ... def getlist(self, key): ... getheaders: Any getallmatchingheaders: Any iget: Any def copy(self): ... def iteritems(self): ... def itermerged(self): ... def items(self): ... @classmethod def from_httplib(cls, message, duplicates=...): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/requests/packages/urllib3/connection.pyi0000664000175000017500000000356300000000000032627 0ustar00davedave00000000000000import ssl import sys from typing import Any from . import exceptions, util from .packages import ssl_match_hostname from .util import ssl_ if sys.version_info < (3, 0): from httplib import HTTPConnection as _HTTPConnection, HTTPException as HTTPException class ConnectionError(Exception): ... else: from builtins import ConnectionError as ConnectionError from http.client import HTTPConnection as _HTTPConnection, HTTPException as HTTPException class DummyConnection: ... BaseSSLError = ssl.SSLError ConnectTimeoutError = exceptions.ConnectTimeoutError SystemTimeWarning = exceptions.SystemTimeWarning SecurityWarning = exceptions.SecurityWarning match_hostname = ssl_match_hostname.match_hostname resolve_cert_reqs = ssl_.resolve_cert_reqs resolve_ssl_version = ssl_.resolve_ssl_version ssl_wrap_socket = ssl_.ssl_wrap_socket assert_fingerprint = ssl_.assert_fingerprint connection = util.connection port_by_scheme: Any RECENT_DATE: Any class HTTPConnection(_HTTPConnection): default_port: Any default_socket_options: Any is_verified: Any source_address: Any socket_options: Any def __init__(self, *args, **kw) -> None: ... def connect(self): ... class HTTPSConnection(HTTPConnection): default_port: Any key_file: Any cert_file: Any def __init__(self, host, port=..., key_file=..., cert_file=..., strict=..., timeout=..., **kw) -> None: ... sock: Any def connect(self): ... class VerifiedHTTPSConnection(HTTPSConnection): cert_reqs: Any ca_certs: Any ssl_version: Any assert_fingerprint: Any key_file: Any cert_file: Any assert_hostname: Any def set_cert(self, key_file=..., cert_file=..., cert_reqs=..., ca_certs=..., assert_hostname=..., assert_fingerprint=...): ... sock: Any auto_open: Any is_verified: Any def connect(self): ... UnverifiedHTTPSConnection = HTTPSConnection ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/requests/packages/urllib3/connectionpool.pyi0000664000175000017500000000614200000000000033515 0ustar00davedave00000000000000from typing import Any from . import connection, exceptions, request, response from .connection import BaseSSLError as BaseSSLError, ConnectionError as ConnectionError, HTTPException as HTTPException from .packages import ssl_match_hostname from .util import connection as _connection, retry, timeout, url ClosedPoolError = exceptions.ClosedPoolError ProtocolError = exceptions.ProtocolError EmptyPoolError = exceptions.EmptyPoolError HostChangedError = exceptions.HostChangedError LocationValueError = exceptions.LocationValueError MaxRetryError = exceptions.MaxRetryError ProxyError = exceptions.ProxyError ReadTimeoutError = exceptions.ReadTimeoutError SSLError = exceptions.SSLError TimeoutError = exceptions.TimeoutError InsecureRequestWarning = exceptions.InsecureRequestWarning CertificateError = ssl_match_hostname.CertificateError port_by_scheme = connection.port_by_scheme DummyConnection = connection.DummyConnection HTTPConnection = connection.HTTPConnection HTTPSConnection = connection.HTTPSConnection VerifiedHTTPSConnection = connection.VerifiedHTTPSConnection RequestMethods = request.RequestMethods HTTPResponse = response.HTTPResponse is_connection_dropped = _connection.is_connection_dropped Retry = retry.Retry Timeout = timeout.Timeout get_host = url.get_host xrange: Any log: Any class ConnectionPool: scheme: Any QueueCls: Any host: Any port: Any def __init__(self, host, port=...) -> None: ... def __enter__(self): ... def __exit__(self, exc_type, exc_val, exc_tb): ... def close(self): ... class HTTPConnectionPool(ConnectionPool, RequestMethods): scheme: Any ConnectionCls: Any strict: Any timeout: Any retries: Any pool: Any block: Any proxy: Any proxy_headers: Any num_connections: Any num_requests: Any conn_kw: Any def __init__( self, host, port=..., strict=..., timeout=..., maxsize=..., block=..., headers=..., retries=..., _proxy=..., _proxy_headers=..., **conn_kw, ) -> None: ... def close(self): ... def is_same_host(self, url): ... def urlopen( self, method, url, body=..., headers=..., retries=..., redirect=..., assert_same_host=..., timeout=..., pool_timeout=..., release_conn=..., **response_kw, ): ... class HTTPSConnectionPool(HTTPConnectionPool): scheme: Any ConnectionCls: Any key_file: Any cert_file: Any cert_reqs: Any ca_certs: Any ssl_version: Any assert_hostname: Any assert_fingerprint: Any def __init__( self, host, port=..., strict=..., timeout=..., maxsize=..., block=..., headers=..., retries=..., _proxy=..., _proxy_headers=..., key_file=..., cert_file=..., cert_reqs=..., ca_certs=..., ssl_version=..., assert_hostname=..., assert_fingerprint=..., **conn_kw, ) -> None: ... def connection_from_url(url, **kw): ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4543793 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/requests/packages/urllib3/contrib/0000775000175000017500000000000000000000000031376 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000020600000000000011453 xustar0000000000000000112 path=jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/requests/packages/urllib3/contrib/__init__.pyi 22 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/requests/packages/urllib3/contrib/__init__.p0000664000175000017500000000000000000000000033304 0ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/requests/packages/urllib3/exceptions.pyi0000664000175000017500000000260500000000000032645 0ustar00davedave00000000000000from typing import Any class HTTPError(Exception): ... class HTTPWarning(Warning): ... class PoolError(HTTPError): pool: Any def __init__(self, pool, message) -> None: ... def __reduce__(self): ... class RequestError(PoolError): url: Any def __init__(self, pool, url, message) -> None: ... def __reduce__(self): ... class SSLError(HTTPError): ... class ProxyError(HTTPError): ... class DecodeError(HTTPError): ... class ProtocolError(HTTPError): ... ConnectionError: Any class MaxRetryError(RequestError): reason: Any def __init__(self, pool, url, reason=...) -> None: ... class HostChangedError(RequestError): retries: Any def __init__(self, pool, url, retries=...) -> None: ... class TimeoutStateError(HTTPError): ... class TimeoutError(HTTPError): ... class ReadTimeoutError(TimeoutError, RequestError): ... class ConnectTimeoutError(TimeoutError): ... class EmptyPoolError(PoolError): ... class ClosedPoolError(PoolError): ... class LocationValueError(ValueError, HTTPError): ... class LocationParseError(LocationValueError): location: Any def __init__(self, location) -> None: ... class ResponseError(HTTPError): GENERIC_ERROR: Any SPECIFIC_ERROR: Any class SecurityWarning(HTTPWarning): ... class InsecureRequestWarning(SecurityWarning): ... class SystemTimeWarning(SecurityWarning): ... class InsecurePlatformWarning(SecurityWarning): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/requests/packages/urllib3/fields.pyi0000664000175000017500000000067200000000000031734 0ustar00davedave00000000000000from typing import Any def guess_content_type(filename, default=...): ... def format_header_param(name, value): ... class RequestField: data: Any headers: Any def __init__(self, name, data, filename=..., headers=...) -> None: ... @classmethod def from_tuples(cls, fieldname, value): ... def render_headers(self): ... def make_multipart(self, content_disposition=..., content_type=..., content_location=...): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/requests/packages/urllib3/filepost.pyi0000664000175000017500000000036400000000000032311 0ustar00davedave00000000000000from typing import Any from . import fields RequestField = fields.RequestField writer: Any def choose_boundary(): ... def iter_field_objects(fields): ... def iter_fields(fields): ... def encode_multipart_formdata(fields, boundary=...): ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4543793 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/requests/packages/urllib3/packages/0000775000175000017500000000000000000000000031514 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000020700000000000011454 xustar0000000000000000113 path=jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/requests/packages/urllib3/packages/__init__.pyi 22 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/requests/packages/urllib3/packages/__init__.0000664000175000017500000000000000000000000033242 0ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000022400000000000011453 xustar0000000000000000120 path=jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/requests/packages/urllib3/packages/ssl_match_hostname/ 28 mtime=1696238359.4543793 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/requests/packages/urllib3/packages/ssl_match0000775000175000017500000000000000000000000033412 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000023200000000000011452 xustar0000000000000000132 path=jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/requests/packages/urllib3/packages/ssl_match_hostname/__init__.pyi 22 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/requests/packages/urllib3/packages/ssl_match0000664000175000017500000000013000000000000033406 0ustar00davedave00000000000000import ssl CertificateError = ssl.CertificateError match_hostname = ssl.match_hostname ././@PaxHeader0000000000000000000000000000024100000000000011452 xustar0000000000000000139 path=jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/requests/packages/urllib3/packages/ssl_match_hostname/_implementation.pyi 22 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/requests/packages/urllib3/packages/ssl_match0000664000175000017500000000012100000000000033406 0ustar00davedave00000000000000class CertificateError(ValueError): ... def match_hostname(cert, hostname): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/requests/packages/urllib3/poolmanager.pyi0000664000175000017500000000243500000000000032771 0ustar00davedave00000000000000from typing import Any from .request import RequestMethods class PoolManager(RequestMethods): proxy: Any connection_pool_kw: Any pools: Any def __init__(self, num_pools=..., headers=..., **connection_pool_kw) -> None: ... def __enter__(self): ... def __exit__(self, exc_type, exc_val, exc_tb): ... def clear(self): ... def connection_from_host(self, host, port=..., scheme=...): ... def connection_from_url(self, url): ... # TODO: This was the original signature -- copied another one from base class to fix complaint. # def urlopen(self, method, url, redirect=True, **kw): ... def urlopen(self, method, url, body=..., headers=..., encode_multipart=..., multipart_boundary=..., **kw): ... class ProxyManager(PoolManager): proxy: Any proxy_headers: Any def __init__(self, proxy_url, num_pools=..., headers=..., proxy_headers=..., **connection_pool_kw) -> None: ... def connection_from_host(self, host, port=..., scheme=...): ... # TODO: This was the original signature -- copied another one from base class to fix complaint. # def urlopen(self, method, url, redirect=True, **kw): ... def urlopen(self, method, url, body=..., headers=..., encode_multipart=..., multipart_boundary=..., **kw): ... def proxy_from_url(url, **kw): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/requests/packages/urllib3/request.pyi0000664000175000017500000000102600000000000032150 0ustar00davedave00000000000000from typing import Any class RequestMethods: headers: Any def __init__(self, headers=...) -> None: ... def urlopen(self, method, url, body=..., headers=..., encode_multipart=..., multipart_boundary=..., **kw): ... def request(self, method, url, fields=..., headers=..., **urlopen_kw): ... def request_encode_url(self, method, url, fields=..., **urlopen_kw): ... def request_encode_body( self, method, url, fields=..., headers=..., encode_multipart=..., multipart_boundary=..., **urlopen_kw ): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/requests/packages/urllib3/response.pyi0000664000175000017500000000337400000000000032326 0ustar00davedave00000000000000import io from typing import Any from . import _collections, exceptions from .connection import BaseSSLError as BaseSSLError, HTTPException as HTTPException from .util import response HTTPHeaderDict = _collections.HTTPHeaderDict ProtocolError = exceptions.ProtocolError DecodeError = exceptions.DecodeError ReadTimeoutError = exceptions.ReadTimeoutError binary_type = bytes # six.binary_type PY3 = True # six.PY3 is_fp_closed = response.is_fp_closed class DeflateDecoder: def __init__(self) -> None: ... def __getattr__(self, name): ... def decompress(self, data): ... class GzipDecoder: def __init__(self) -> None: ... def __getattr__(self, name): ... def decompress(self, data): ... class HTTPResponse(io.IOBase): CONTENT_DECODERS: Any REDIRECT_STATUSES: Any headers: Any status: Any version: Any reason: Any strict: Any decode_content: Any def __init__( self, body=..., headers=..., status=..., version=..., reason=..., strict=..., preload_content=..., decode_content=..., original_response=..., pool=..., connection=..., ) -> None: ... def get_redirect_location(self): ... def release_conn(self): ... @property def data(self): ... def tell(self): ... def read(self, amt=..., decode_content=..., cache_content=...): ... def stream(self, amt=..., decode_content=...): ... @classmethod def from_httplib(cls, r, **response_kw): ... def getheaders(self): ... def getheader(self, name, default=...): ... def close(self): ... @property def closed(self): ... def fileno(self): ... def flush(self): ... def readable(self): ... def readinto(self, b): ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4583795 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/requests/packages/urllib3/util/0000775000175000017500000000000000000000000030713 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/requests/packages/urllib3/util/__init__.pyi0000664000175000017500000000114700000000000033200 0ustar00davedave00000000000000import ssl from . import connection, request, response, retry, ssl_, timeout, url is_connection_dropped = connection.is_connection_dropped make_headers = request.make_headers is_fp_closed = response.is_fp_closed SSLContext = ssl.SSLContext HAS_SNI = ssl_.HAS_SNI assert_fingerprint = ssl_.assert_fingerprint resolve_cert_reqs = ssl_.resolve_cert_reqs resolve_ssl_version = ssl_.resolve_ssl_version ssl_wrap_socket = ssl_.ssl_wrap_socket current_time = timeout.current_time Timeout = timeout.Timeout Retry = retry.Retry get_host = url.get_host parse_url = url.parse_url split_first = url.split_first Url = url.Url ././@PaxHeader0000000000000000000000000000020500000000000011452 xustar0000000000000000111 path=jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/requests/packages/urllib3/util/connection.pyi 22 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/requests/packages/urllib3/util/connection.py0000664000175000017500000000027400000000000033427 0ustar00davedave00000000000000from typing import Any poll: Any select: Any HAS_IPV6: bool def is_connection_dropped(conn): ... def create_connection(address, timeout=..., source_address=..., socket_options=...): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/requests/packages/urllib3/util/request.pyi0000664000175000017500000000034300000000000033126 0ustar00davedave00000000000000from typing import Any # from ..packages import six # b = six.b ACCEPT_ENCODING: Any def make_headers( keep_alive=..., accept_encoding=..., user_agent=..., basic_auth=..., proxy_basic_auth=..., disable_cache=... ): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/requests/packages/urllib3/util/response.pyi0000664000175000017500000000003300000000000033270 0ustar00davedave00000000000000def is_fp_closed(obj): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/requests/packages/urllib3/util/retry.pyi0000664000175000017500000000221100000000000032577 0ustar00davedave00000000000000from typing import Any from .. import exceptions ConnectTimeoutError = exceptions.ConnectTimeoutError MaxRetryError = exceptions.MaxRetryError ProtocolError = exceptions.ProtocolError ReadTimeoutError = exceptions.ReadTimeoutError ResponseError = exceptions.ResponseError log: Any class Retry: DEFAULT_METHOD_WHITELIST: Any BACKOFF_MAX: Any total: Any connect: Any read: Any redirect: Any status_forcelist: Any method_whitelist: Any backoff_factor: Any raise_on_redirect: Any def __init__( self, total=..., connect=..., read=..., redirect=..., method_whitelist=..., status_forcelist=..., backoff_factor=..., raise_on_redirect=..., _observed_errors=..., ) -> None: ... def new(self, **kw): ... @classmethod def from_int(cls, retries, redirect=..., default=...): ... def get_backoff_time(self): ... def sleep(self): ... def is_forced_retry(self, method, status_code): ... def is_exhausted(self): ... def increment(self, method=..., url=..., response=..., error=..., _pool=..., _stacktrace=...): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/requests/packages/urllib3/util/ssl_.pyi0000664000175000017500000000126300000000000032400 0ustar00davedave00000000000000import ssl from typing import Any from .. import exceptions SSLError = exceptions.SSLError InsecurePlatformWarning = exceptions.InsecurePlatformWarning SSLContext = ssl.SSLContext HAS_SNI: Any create_default_context: Any OP_NO_SSLv2: Any OP_NO_SSLv3: Any OP_NO_COMPRESSION: Any def assert_fingerprint(cert, fingerprint): ... def resolve_cert_reqs(candidate): ... def resolve_ssl_version(candidate): ... def create_urllib3_context(ssl_version=..., cert_reqs=..., options=..., ciphers=...): ... def ssl_wrap_socket( sock, keyfile=..., certfile=..., cert_reqs=..., ca_certs=..., server_hostname=..., ssl_version=..., ciphers=..., ssl_context=..., ): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/requests/packages/urllib3/util/timeout.pyi0000664000175000017500000000076300000000000033132 0ustar00davedave00000000000000from typing import Any from .. import exceptions TimeoutStateError = exceptions.TimeoutStateError def current_time(): ... class Timeout: DEFAULT_TIMEOUT: Any total: Any def __init__(self, total=..., connect=..., read=...) -> None: ... @classmethod def from_float(cls, timeout): ... def clone(self): ... def start_connect(self): ... def get_connect_duration(self): ... @property def connect_timeout(self): ... @property def read_timeout(self): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/requests/packages/urllib3/util/url.pyi0000664000175000017500000000075400000000000032246 0ustar00davedave00000000000000from typing import Any from .. import exceptions LocationParseError = exceptions.LocationParseError url_attrs: Any class Url: slots: Any def __new__(cls, scheme=..., auth=..., host=..., port=..., path=..., query=..., fragment=...): ... @property def hostname(self): ... @property def request_uri(self): ... @property def netloc(self): ... @property def url(self): ... def split_first(s, delims): ... def parse_url(url): ... def get_host(url): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/requests/sessions.pyi0000664000175000017500000001116700000000000027203 0ustar00davedave00000000000000from typing import IO, Any, Callable, Iterable, List, Mapping, MutableMapping, Optional, Text, Tuple, Union from . import adapters, auth as _auth, compat, cookies, exceptions, hooks, models, status_codes, structures, utils from .models import Response from .packages.urllib3 import _collections BaseAdapter = adapters.BaseAdapter OrderedDict = compat.OrderedDict cookiejar_from_dict = cookies.cookiejar_from_dict extract_cookies_to_jar = cookies.extract_cookies_to_jar RequestsCookieJar = cookies.RequestsCookieJar merge_cookies = cookies.merge_cookies Request = models.Request PreparedRequest = models.PreparedRequest DEFAULT_REDIRECT_LIMIT = models.DEFAULT_REDIRECT_LIMIT default_hooks = hooks.default_hooks dispatch_hook = hooks.dispatch_hook to_key_val_list = utils.to_key_val_list default_headers = utils.default_headers to_native_string = utils.to_native_string TooManyRedirects = exceptions.TooManyRedirects InvalidSchema = exceptions.InvalidSchema ChunkedEncodingError = exceptions.ChunkedEncodingError ContentDecodingError = exceptions.ContentDecodingError RecentlyUsedContainer = _collections.RecentlyUsedContainer CaseInsensitiveDict = structures.CaseInsensitiveDict HTTPAdapter = adapters.HTTPAdapter requote_uri = utils.requote_uri get_environ_proxies = utils.get_environ_proxies get_netrc_auth = utils.get_netrc_auth should_bypass_proxies = utils.should_bypass_proxies get_auth_from_url = utils.get_auth_from_url codes = status_codes.codes REDIRECT_STATI = models.REDIRECT_STATI def merge_setting(request_setting, session_setting, dict_class=...): ... def merge_hooks(request_hooks, session_hooks, dict_class=...): ... class SessionRedirectMixin: def resolve_redirects(self, resp, req, stream=..., timeout=..., verify=..., cert=..., proxies=...): ... def rebuild_auth(self, prepared_request, response): ... def rebuild_proxies(self, prepared_request, proxies): ... _Data = Union[None, Text, bytes, Mapping[str, Any], Mapping[Text, Any], Iterable[Tuple[Text, Optional[Text]]], IO] _Hook = Callable[[Response], Any] _Hooks = MutableMapping[Text, List[_Hook]] _HooksInput = MutableMapping[Text, Union[Iterable[_Hook], _Hook]] class Session(SessionRedirectMixin): __attrs__: Any headers: CaseInsensitiveDict[Text] auth: Union[None, Tuple[Text, Text], _auth.AuthBase, Callable[[Request], Request]] proxies: MutableMapping[Text, Text] hooks: _Hooks params: Union[bytes, MutableMapping[Text, Text]] stream: bool verify: Union[None, bool, Text] cert: Union[None, Text, Tuple[Text, Text]] max_redirects: int trust_env: bool cookies: RequestsCookieJar adapters: MutableMapping[Any, Any] redirect_cache: RecentlyUsedContainer[Any, Any] def __init__(self) -> None: ... def __enter__(self) -> Session: ... def __exit__(self, *args) -> None: ... def prepare_request(self, request): ... def request( self, method: str, url: Union[str, bytes, Text], params: Union[None, bytes, MutableMapping[Text, Text]] = ..., data: _Data = ..., headers: Optional[MutableMapping[Text, Text]] = ..., cookies: Union[None, RequestsCookieJar, MutableMapping[Text, Text]] = ..., files: Optional[MutableMapping[Text, IO[Any]]] = ..., auth: Union[None, Tuple[Text, Text], _auth.AuthBase, Callable[[Request], Request]] = ..., timeout: Union[None, float, Tuple[float, float], Tuple[float, None]] = ..., allow_redirects: Optional[bool] = ..., proxies: Optional[MutableMapping[Text, Text]] = ..., hooks: Optional[_HooksInput] = ..., stream: Optional[bool] = ..., verify: Union[None, bool, Text] = ..., cert: Union[Text, Tuple[Text, Text], None] = ..., json: Optional[Any] = ..., ) -> Response: ... def get(self, url: Union[Text, bytes], **kwargs) -> Response: ... def options(self, url: Union[Text, bytes], **kwargs) -> Response: ... def head(self, url: Union[Text, bytes], **kwargs) -> Response: ... def post(self, url: Union[Text, bytes], data: _Data = ..., json: Optional[Any] = ..., **kwargs) -> Response: ... def put(self, url: Union[Text, bytes], data: _Data = ..., **kwargs) -> Response: ... def patch(self, url: Union[Text, bytes], data: _Data = ..., **kwargs) -> Response: ... def delete(self, url: Union[Text, bytes], **kwargs) -> Response: ... def send(self, request: PreparedRequest, **kwargs) -> Response: ... def merge_environment_settings(self, url, proxies, stream, verify, cert): ... def get_adapter(self, url): ... def close(self) -> None: ... def mount(self, prefix: Union[Text, bytes], adapter: BaseAdapter) -> None: ... def session() -> Session: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/requests/status_codes.pyi0000664000175000017500000000004300000000000030024 0ustar00davedave00000000000000from typing import Any codes: Any ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/requests/structures.pyi0000664000175000017500000000171000000000000027551 0ustar00davedave00000000000000from typing import Any, Dict, Generic, Iterable, Iterator, Mapping, MutableMapping, Optional, Tuple, TypeVar, Union _VT = TypeVar("_VT") class CaseInsensitiveDict(MutableMapping[str, _VT], Generic[_VT]): def __init__(self, data: Optional[Union[Mapping[str, _VT], Iterable[Tuple[str, _VT]]]] = ..., **kwargs: _VT) -> None: ... def lower_items(self) -> Iterator[Tuple[str, _VT]]: ... def __setitem__(self, key: str, value: _VT) -> None: ... def __getitem__(self, key: str) -> _VT: ... def __delitem__(self, key: str) -> None: ... def __iter__(self) -> Iterator[str]: ... def __len__(self) -> int: ... def copy(self) -> CaseInsensitiveDict[_VT]: ... class LookupDict(Dict[str, _VT]): name: Any def __init__(self, name: Any = ...) -> None: ... def __getitem__(self, key: str) -> Optional[_VT]: ... # type: ignore def __getattr__(self, attr: str) -> _VT: ... def __setattr__(self, attr: str, value: _VT) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/requests/utils.pyi0000664000175000017500000000370500000000000026474 0ustar00davedave00000000000000from typing import Any, AnyStr, Dict, Iterable, Mapping, Optional, Text, Tuple from . import compat, cookies, exceptions, structures OrderedDict = compat.OrderedDict RequestsCookieJar = cookies.RequestsCookieJar cookiejar_from_dict = cookies.cookiejar_from_dict CaseInsensitiveDict = structures.CaseInsensitiveDict InvalidURL = exceptions.InvalidURL NETRC_FILES: Any DEFAULT_CA_BUNDLE_PATH: Any DEFAULT_PORTS: Any def dict_to_sequence(d): ... def super_len(o): ... def get_netrc_auth(url, raise_errors: bool = ...): ... def guess_filename(obj): ... def extract_zipped_paths(path): ... def from_key_val_list(value): ... def to_key_val_list(value): ... def parse_list_header(value): ... def parse_dict_header(value): ... def unquote_header_value(value, is_filename=...): ... def dict_from_cookiejar(cj): ... def add_dict_to_cookiejar(cj, cookie_dict): ... def get_encodings_from_content(content): ... def get_encoding_from_headers(headers): ... def stream_decode_response_unicode(iterator, r): ... def iter_slices(string, slice_length): ... def get_unicode_from_response(r): ... UNRESERVED_SET: Any def unquote_unreserved(uri): ... def requote_uri(uri): ... def address_in_network(ip, net): ... def dotted_netmask(mask): ... def is_ipv4_address(string_ip): ... def is_valid_cidr(string_network): ... def set_environ(env_name, value): ... def should_bypass_proxies(url, no_proxy: Optional[Iterable[AnyStr]]) -> bool: ... def get_environ_proxies(url, no_proxy: Optional[Iterable[AnyStr]] = ...) -> Dict[Any, Any]: ... def select_proxy(url: Text, proxies: Optional[Mapping[Any, Any]]): ... def default_user_agent(name=...): ... def default_headers(): ... def parse_header_links(value): ... def guess_json_utf(data): ... def prepend_scheme_if_needed(url, new_scheme): ... def get_auth_from_url(url): ... def to_native_string(string, encoding=...): ... def urldefragauth(url): ... def rewind_body(prepared_request): ... def check_header_validity(header: Tuple[AnyStr, AnyStr]) -> None: ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4583795 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/retry/0000775000175000017500000000000000000000000024076 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/retry/__init__.pyi0000664000175000017500000000004000000000000026352 0ustar00davedave00000000000000from .api import retry as retry ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/retry/api.pyi0000664000175000017500000000164700000000000025402 0ustar00davedave00000000000000from logging import Logger from typing import Any, Callable, Dict, Optional, Sequence, Tuple, Type, TypeVar, Union _T = TypeVar("_T", bound=Callable[..., Any]) _Decorator = Callable[[_T], _T] _R = TypeVar("_R") def retry_call( f: Callable[..., _R], fargs: Optional[Sequence[Any]] = ..., fkwargs: Optional[Dict[str, Any]] = ..., exceptions: Union[Type[Exception], Tuple[Type[Exception], ...]] = ..., tries: int = ..., delay: float = ..., max_delay: Optional[float] = ..., backoff: float = ..., jitter: Union[Tuple[float, float], float] = ..., logger: Optional[Logger] = ..., ) -> _R: ... def retry( exceptions: Union[Type[Exception], Tuple[Type[Exception], ...]] = ..., tries: int = ..., delay: float = ..., max_delay: Optional[float] = ..., backoff: float = ..., jitter: Union[Tuple[float, float], float] = ..., logger: Optional[Logger] = ..., ) -> _Decorator: ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4583795 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/simplejson/0000775000175000017500000000000000000000000025114 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/simplejson/__init__.pyi0000664000175000017500000000103200000000000027372 0ustar00davedave00000000000000from typing import IO, Any, Text, Union from simplejson.decoder import JSONDecoder as JSONDecoder from simplejson.encoder import JSONEncoder as JSONEncoder, JSONEncoderForHTML as JSONEncoderForHTML from simplejson.scanner import JSONDecodeError as JSONDecodeError _LoadsString = Union[Text, bytes, bytearray] def dumps(obj: Any, *args: Any, **kwds: Any) -> str: ... def dump(obj: Any, fp: IO[str], *args: Any, **kwds: Any) -> None: ... def loads(s: _LoadsString, **kwds: Any) -> Any: ... def load(fp: IO[str], **kwds: Any) -> Any: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/simplejson/decoder.pyi0000664000175000017500000000034500000000000027246 0ustar00davedave00000000000000from typing import Match class JSONDecoder(object): def __init__(self, **kwargs): ... def decode(self, s: str, _w: Match[str], _PY3: bool): ... def raw_decode(self, s: str, idx: int, _w: Match[str], _PY3: bool): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/simplejson/encoder.pyi0000664000175000017500000000041000000000000027251 0ustar00davedave00000000000000from typing import Any class JSONEncoder(object): def __init__(self, *args, **kwargs): ... def encode(self, o: Any): ... def default(self, o: Any): ... def iterencode(self, o: Any, _one_shot: bool): ... class JSONEncoderForHTML(JSONEncoder): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/simplejson/scanner.pyi0000664000175000017500000000040600000000000027270 0ustar00davedave00000000000000from typing import Optional class JSONDecodeError(ValueError): msg: str = ... doc: str = ... pos: int = ... end: Optional[int] = ... lineno: int = ... colno: int = ... endlineno: Optional[int] = ... endcolno: Optional[int] = ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/singledispatch.pyi0000664000175000017500000000116000000000000026453 0ustar00davedave00000000000000from typing import Any, Callable, Generic, Mapping, TypeVar, overload _T = TypeVar("_T") class _SingleDispatchCallable(Generic[_T]): registry: Mapping[Any, Callable[..., _T]] def dispatch(self, cls: Any) -> Callable[..., _T]: ... @overload def register(self, cls: Any) -> Callable[[Callable[..., _T]], Callable[..., _T]]: ... @overload def register(self, cls: Any, func: Callable[..., _T]) -> Callable[..., _T]: ... def _clear_cache(self) -> None: ... def __call__(self, *args: Any, **kwargs: Any) -> _T: ... def singledispatch(func: Callable[..., _T]) -> _SingleDispatchCallable[_T]: ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4583795 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/slugify/0000775000175000017500000000000000000000000024413 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/slugify/__init__.pyi0000664000175000017500000000005600000000000026676 0ustar00davedave00000000000000from .slugify import * from .special import * ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/slugify/slugify.pyi0000664000175000017500000000106100000000000026616 0ustar00davedave00000000000000from typing import Iterable, Optional def smart_truncate( string: str, max_length: int = ..., word_boundary: bool = ..., separator: str = ..., save_order: bool = ... ) -> str: ... def slugify( text: str, entities: bool = ..., decimal: bool = ..., hexadecimal: bool = ..., max_length: int = ..., word_boundary: bool = ..., separator: str = ..., save_order: bool = ..., stopwords: Iterable[str] = ..., regex_pattern: Optional[str] = ..., lowercase: bool = ..., replacements: Iterable[str] = ..., ) -> str: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/slugify/special.pyi0000664000175000017500000000042700000000000026561 0ustar00davedave00000000000000from typing import Sequence, Tuple def add_uppercase_char(char_list: Sequence[Tuple[str, str]]) -> Sequence[Tuple[str, str]]: ... CYRILLIC: Sequence[Tuple[str, str]] GERMAN: Sequence[Tuple[str, str]] GREEK: Sequence[Tuple[str, str]] PRE_TRANSLATIONS: Sequence[Tuple[str, str]] ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/tabulate.pyi0000664000175000017500000000260500000000000025260 0ustar00davedave00000000000000from typing import Any, Callable, Container, Dict, Iterable, List, Mapping, NamedTuple, Optional, Sequence, Union PRESERVE_WHITESPACE: bool WIDE_CHARS_MODE: bool tabulate_formats: List[str] class Line(NamedTuple): begin: str hline: str sep: str end: str class DataRow(NamedTuple): begin: str sep: str end: str _TableFormatLine = Union[None, Line, Callable[[List[int], List[str]], str]] _TableFormatRow = Union[None, DataRow, Callable[[List[Any], List[int], List[str]], str]] class TableFormat(NamedTuple): lineabove: _TableFormatLine linebelowheader: _TableFormatLine linebetweenrows: _TableFormatLine linebelow: _TableFormatLine headerrow: _TableFormatRow datarow: _TableFormatRow padding: int with_header_hide: Optional[Container[str]] def simple_separated_format(separator: str) -> TableFormat: ... def tabulate( tabular_data: Union[Mapping[str, Iterable[Any]], Iterable[Iterable[Any]]], headers: Union[str, Dict[str, str], Sequence[str]] = ..., tablefmt: Union[str, TableFormat] = ..., floatfmt: Union[str, Iterable[str]] = ..., numalign: Optional[str] = ..., stralign: Optional[str] = ..., missingval: Union[str, Iterable[str]] = ..., showindex: Union[str, bool, Iterable[Any]] = ..., disable_numparse: Union[bool, Iterable[int]] = ..., colalign: Optional[Iterable[Optional[str]]] = ..., ) -> str: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/termcolor.pyi0000664000175000017500000000053600000000000025466 0ustar00davedave00000000000000from typing import Any, Iterable, Optional, Text def colored( text: Text, color: Optional[Text] = ..., on_color: Optional[Text] = ..., attrs: Optional[Iterable[Text]] = ... ) -> Text: ... def cprint( text: Text, color: Optional[Text] = ..., on_color: Optional[Text] = ..., attrs: Optional[Iterable[Text]] = ..., **kwargs: Any ) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/toml.pyi0000664000175000017500000000127100000000000024430 0ustar00davedave00000000000000import sys from _typeshed import StrPath, SupportsWrite from typing import IO, Any, List, Mapping, MutableMapping, Text, Type, Union if sys.version_info >= (3, 6): _PathLike = StrPath elif sys.version_info >= (3, 4): import pathlib _PathLike = Union[StrPath, pathlib.PurePath] else: _PathLike = StrPath class TomlDecodeError(Exception): ... def load(f: Union[_PathLike, List[Text], IO[str]], _dict: Type[MutableMapping[str, Any]] = ...) -> MutableMapping[str, Any]: ... def loads(s: Text, _dict: Type[MutableMapping[str, Any]] = ...) -> MutableMapping[str, Any]: ... def dump(o: Mapping[str, Any], f: SupportsWrite[str]) -> str: ... def dumps(o: Mapping[str, Any]) -> str: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/typing_extensions.pyi0000664000175000017500000000643600000000000027256 0ustar00davedave00000000000000import abc import sys from typing import ( TYPE_CHECKING as TYPE_CHECKING, Any, Callable, ClassVar as ClassVar, ContextManager as ContextManager, Counter as Counter, DefaultDict as DefaultDict, Deque as Deque, Dict, ItemsView, KeysView, Mapping, NewType as NewType, NoReturn as NoReturn, Optional, Text as Text, Tuple, Type as Type, TypeVar, ValuesView, overload as overload, ) _T = TypeVar("_T") _F = TypeVar("_F", bound=Callable[..., Any]) _TC = TypeVar("_TC", bound=Type[object]) class _SpecialForm: def __getitem__(self, typeargs: Any) -> Any: ... def runtime_checkable(cls: _TC) -> _TC: ... # This alias for above is kept here for backwards compatibility. runtime = runtime_checkable Protocol: _SpecialForm = ... Final: _SpecialForm = ... def final(f: _F) -> _F: ... Literal: _SpecialForm = ... def IntVar(__name: str) -> Any: ... # returns a new TypeVar # Internal mypy fallback type for all typed dicts (does not exist at runtime) class _TypedDict(Mapping[str, object], metaclass=abc.ABCMeta): def copy(self: _T) -> _T: ... # Using NoReturn so that only calls using mypy plugin hook that specialize the signature # can go through. def setdefault(self, k: NoReturn, default: object) -> object: ... # Mypy plugin hook for 'pop' expects that 'default' has a type variable type. def pop(self, k: NoReturn, default: _T = ...) -> object: ... def update(self: _T, __m: _T) -> None: ... if sys.version_info < (3, 0): def has_key(self, k: str) -> bool: ... def viewitems(self) -> ItemsView[str, object]: ... def viewkeys(self) -> KeysView[str]: ... def viewvalues(self) -> ValuesView[object]: ... else: def items(self) -> ItemsView[str, object]: ... def keys(self) -> KeysView[str]: ... def values(self) -> ValuesView[object]: ... def __delitem__(self, k: NoReturn) -> None: ... # TypedDict is a (non-subscriptable) special form. TypedDict: object = ... if sys.version_info >= (3, 3): from typing import ChainMap as ChainMap if sys.version_info >= (3, 5): from typing import ( AsyncContextManager as AsyncContextManager, AsyncIterable as AsyncIterable, AsyncIterator as AsyncIterator, Awaitable as Awaitable, Coroutine as Coroutine, ) if sys.version_info >= (3, 6): from typing import AsyncGenerator as AsyncGenerator def get_type_hints( obj: Callable[..., Any], globalns: Optional[Dict[str, Any]] = ..., localns: Optional[Dict[str, Any]] = ..., include_extras: bool = ..., ) -> Dict[str, Any]: ... if sys.version_info >= (3, 7): def get_args(tp: Any) -> Tuple[Any, ...]: ... def get_origin(tp: Any) -> Optional[Any]: ... Annotated: _SpecialForm = ... _AnnotatedAlias: Any = ... # undocumented # TypeAlias is a (non-subscriptable) special form. class TypeAlias: ... @runtime_checkable class SupportsIndex(Protocol, metaclass=abc.ABCMeta): @abc.abstractmethod def __index__(self) -> int: ... # PEP 612 support for Python < 3.9 if sys.version_info >= (3, 10): from typing import Concatenate as Concatenate, ParamSpec as ParamSpec else: class ParamSpec: __name__: str def __init__(self, name: str) -> None: ... Concatenate: _SpecialForm = ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4583795 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/tzlocal/0000775000175000017500000000000000000000000024401 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/tzlocal/__init__.pyi0000664000175000017500000000015000000000000026657 0ustar00davedave00000000000000from pytz import BaseTzInfo def reload_localzone() -> None: ... def get_localzone() -> BaseTzInfo: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/ujson.pyi0000664000175000017500000000165200000000000024616 0ustar00davedave00000000000000from typing import IO, Any, AnyStr __version__: str def encode( obj: Any, ensure_ascii: bool = ..., double_precision: int = ..., encode_html_chars: bool = ..., escape_forward_slashes: bool = ..., sort_keys: bool = ..., indent: int = ..., ) -> str: ... def dumps( obj: Any, ensure_ascii: bool = ..., double_precision: int = ..., encode_html_chars: bool = ..., escape_forward_slashes: bool = ..., sort_keys: bool = ..., indent: int = ..., ) -> str: ... def dump( obj: Any, fp: IO[str], ensure_ascii: bool = ..., double_precision: int = ..., encode_html_chars: bool = ..., escape_forward_slashes: bool = ..., sort_keys: bool = ..., indent: int = ..., ) -> None: ... def decode(s: AnyStr, precise_float: bool = ...) -> Any: ... def loads(s: AnyStr, precise_float: bool = ...) -> Any: ... def load(fp: IO[AnyStr], precise_float: bool = ...) -> Any: ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4583795 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/werkzeug/0000775000175000017500000000000000000000000024574 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/werkzeug/__init__.pyi0000664000175000017500000001227300000000000027063 0ustar00davedave00000000000000from types import ModuleType from typing import Any from werkzeug import ( _internal, datastructures, debug, exceptions, formparser, http, local, security, serving, test, testapp, urls, useragents, utils, wrappers, wsgi, ) class module(ModuleType): def __getattr__(self, name): ... def __dir__(self): ... __version__: Any run_simple = serving.run_simple test_app = testapp.test_app UserAgent = useragents.UserAgent _easteregg = _internal._easteregg DebuggedApplication = debug.DebuggedApplication MultiDict = datastructures.MultiDict CombinedMultiDict = datastructures.CombinedMultiDict Headers = datastructures.Headers EnvironHeaders = datastructures.EnvironHeaders ImmutableList = datastructures.ImmutableList ImmutableDict = datastructures.ImmutableDict ImmutableMultiDict = datastructures.ImmutableMultiDict TypeConversionDict = datastructures.TypeConversionDict ImmutableTypeConversionDict = datastructures.ImmutableTypeConversionDict Accept = datastructures.Accept MIMEAccept = datastructures.MIMEAccept CharsetAccept = datastructures.CharsetAccept LanguageAccept = datastructures.LanguageAccept RequestCacheControl = datastructures.RequestCacheControl ResponseCacheControl = datastructures.ResponseCacheControl ETags = datastructures.ETags HeaderSet = datastructures.HeaderSet WWWAuthenticate = datastructures.WWWAuthenticate Authorization = datastructures.Authorization FileMultiDict = datastructures.FileMultiDict CallbackDict = datastructures.CallbackDict FileStorage = datastructures.FileStorage OrderedMultiDict = datastructures.OrderedMultiDict ImmutableOrderedMultiDict = datastructures.ImmutableOrderedMultiDict escape = utils.escape environ_property = utils.environ_property append_slash_redirect = utils.append_slash_redirect redirect = utils.redirect cached_property = utils.cached_property import_string = utils.import_string dump_cookie = http.dump_cookie parse_cookie = http.parse_cookie unescape = utils.unescape format_string = utils.format_string find_modules = utils.find_modules header_property = utils.header_property html = utils.html xhtml = utils.xhtml HTMLBuilder = utils.HTMLBuilder validate_arguments = utils.validate_arguments ArgumentValidationError = utils.ArgumentValidationError bind_arguments = utils.bind_arguments secure_filename = utils.secure_filename BaseResponse = wrappers.BaseResponse BaseRequest = wrappers.BaseRequest Request = wrappers.Request Response = wrappers.Response AcceptMixin = wrappers.AcceptMixin ETagRequestMixin = wrappers.ETagRequestMixin ETagResponseMixin = wrappers.ETagResponseMixin ResponseStreamMixin = wrappers.ResponseStreamMixin CommonResponseDescriptorsMixin = wrappers.CommonResponseDescriptorsMixin UserAgentMixin = wrappers.UserAgentMixin AuthorizationMixin = wrappers.AuthorizationMixin WWWAuthenticateMixin = wrappers.WWWAuthenticateMixin CommonRequestDescriptorsMixin = wrappers.CommonRequestDescriptorsMixin Local = local.Local LocalManager = local.LocalManager LocalProxy = local.LocalProxy LocalStack = local.LocalStack release_local = local.release_local generate_password_hash = security.generate_password_hash check_password_hash = security.check_password_hash Client = test.Client EnvironBuilder = test.EnvironBuilder create_environ = test.create_environ run_wsgi_app = test.run_wsgi_app get_current_url = wsgi.get_current_url get_host = wsgi.get_host pop_path_info = wsgi.pop_path_info peek_path_info = wsgi.peek_path_info SharedDataMiddleware = wsgi.SharedDataMiddleware DispatcherMiddleware = wsgi.DispatcherMiddleware ClosingIterator = wsgi.ClosingIterator FileWrapper = wsgi.FileWrapper make_line_iter = wsgi.make_line_iter LimitedStream = wsgi.LimitedStream responder = wsgi.responder wrap_file = wsgi.wrap_file extract_path_info = wsgi.extract_path_info parse_etags = http.parse_etags parse_date = http.parse_date http_date = http.http_date cookie_date = http.cookie_date parse_cache_control_header = http.parse_cache_control_header is_resource_modified = http.is_resource_modified parse_accept_header = http.parse_accept_header parse_set_header = http.parse_set_header quote_etag = http.quote_etag unquote_etag = http.unquote_etag generate_etag = http.generate_etag dump_header = http.dump_header parse_list_header = http.parse_list_header parse_dict_header = http.parse_dict_header parse_authorization_header = http.parse_authorization_header parse_www_authenticate_header = http.parse_www_authenticate_header remove_entity_headers = http.remove_entity_headers is_entity_header = http.is_entity_header remove_hop_by_hop_headers = http.remove_hop_by_hop_headers parse_options_header = http.parse_options_header dump_options_header = http.dump_options_header is_hop_by_hop_header = http.is_hop_by_hop_header unquote_header_value = http.unquote_header_value quote_header_value = http.quote_header_value HTTP_STATUS_CODES = http.HTTP_STATUS_CODES url_decode = urls.url_decode url_encode = urls.url_encode url_quote = urls.url_quote url_quote_plus = urls.url_quote_plus url_unquote = urls.url_unquote url_unquote_plus = urls.url_unquote_plus url_fix = urls.url_fix Href = urls.Href iri_to_uri = urls.iri_to_uri uri_to_iri = urls.uri_to_iri parse_form_data = formparser.parse_form_data abort = exceptions.Aborter Aborter = exceptions.Aborter ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/werkzeug/_compat.pyi0000664000175000017500000000236700000000000026751 0ustar00davedave00000000000000import sys from typing import Any, Optional, Text if sys.version_info >= (3,): from io import BytesIO as BytesIO, StringIO as StringIO NativeStringIO = StringIO else: import cStringIO from StringIO import StringIO as StringIO BytesIO = cStringIO.StringIO NativeStringIO = BytesIO PY2: Any WIN: Any unichr: Any text_type: Any string_types: Any integer_types: Any iterkeys: Any itervalues: Any iteritems: Any iterlists: Any iterlistvalues: Any int_to_byte: Any iter_bytes: Any def fix_tuple_repr(obj): ... def implements_iterator(cls): ... def implements_to_string(cls): ... def native_string_result(func): ... def implements_bool(cls): ... range_type: Any def make_literal_wrapper(reference): ... def normalize_string_tuple(tup): ... def try_coerce_native(s): ... wsgi_get_bytes: Any def wsgi_decoding_dance(s, charset: Text = ..., errors: Text = ...): ... def wsgi_encoding_dance(s, charset: Text = ..., errors: Text = ...): ... def to_bytes(x, charset: Text = ..., errors: Text = ...): ... def to_native(x, charset: Text = ..., errors: Text = ...): ... def reraise(tp, value, tb: Optional[Any] = ...): ... imap: Any izip: Any ifilter: Any def to_unicode(x, charset: Text = ..., errors: Text = ..., allow_none_charset: bool = ...): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/werkzeug/_internal.pyi0000664000175000017500000000120400000000000027267 0ustar00davedave00000000000000from typing import Any, Optional class _Missing: def __reduce__(self): ... class _DictAccessorProperty: read_only: Any name: Any default: Any load_func: Any dump_func: Any __doc__: Any def __init__( self, name, default: Optional[Any] = ..., load_func: Optional[Any] = ..., dump_func: Optional[Any] = ..., read_only: Optional[Any] = ..., doc: Optional[Any] = ..., ): ... def __get__(self, obj, type: Optional[Any] = ...): ... def __set__(self, obj, value): ... def __delete__(self, obj): ... def _easteregg(app: Optional[Any] = ...): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/werkzeug/_reloader.pyi0000664000175000017500000000147200000000000027257 0ustar00davedave00000000000000from typing import Any, Optional class ReloaderLoop: name: Any extra_files: Any interval: float def __init__(self, extra_files: Optional[Any] = ..., interval: float = ...): ... def run(self): ... def restart_with_reloader(self): ... def trigger_reload(self, filename): ... def log_reload(self, filename): ... class StatReloaderLoop(ReloaderLoop): name: Any def run(self): ... class WatchdogReloaderLoop(ReloaderLoop): observable_paths: Any name: Any observer_class: Any event_handler: Any should_reload: Any def __init__(self, *args, **kwargs): ... def trigger_reload(self, filename): ... def run(self): ... reloader_loops: Any def run_with_reloader(main_func, extra_files: Optional[Any] = ..., interval: float = ..., reloader_type: str = ...): ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4583795 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/werkzeug/contrib/0000775000175000017500000000000000000000000026234 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/werkzeug/contrib/__init__.pyi0000664000175000017500000000000000000000000030504 0ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/werkzeug/contrib/atom.pyi0000664000175000017500000000216000000000000027716 0ustar00davedave00000000000000from typing import Any, Optional XHTML_NAMESPACE: Any def format_iso8601(obj): ... class AtomFeed: default_generator: Any title: Any title_type: Any url: Any feed_url: Any id: Any updated: Any author: Any icon: Any logo: Any rights: Any rights_type: Any subtitle: Any subtitle_type: Any generator: Any links: Any entries: Any def __init__(self, title: Optional[Any] = ..., entries: Optional[Any] = ..., **kwargs): ... def add(self, *args, **kwargs): ... def generate(self): ... def to_string(self): ... def get_response(self): ... def __call__(self, environ, start_response): ... class FeedEntry: title: Any title_type: Any content: Any content_type: Any url: Any id: Any updated: Any summary: Any summary_type: Any author: Any published: Any rights: Any links: Any categories: Any xml_base: Any def __init__(self, title: Optional[Any] = ..., content: Optional[Any] = ..., feed_url: Optional[Any] = ..., **kwargs): ... def generate(self): ... def to_string(self): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/werkzeug/contrib/cache.pyi0000664000175000017500000000645700000000000030036 0ustar00davedave00000000000000from typing import Any, Optional class BaseCache: default_timeout: float def __init__(self, default_timeout: float = ...): ... def get(self, key): ... def delete(self, key): ... def get_many(self, *keys): ... def get_dict(self, *keys): ... def set(self, key, value, timeout: Optional[float] = ...): ... def add(self, key, value, timeout: Optional[float] = ...): ... def set_many(self, mapping, timeout: Optional[float] = ...): ... def delete_many(self, *keys): ... def has(self, key): ... def clear(self): ... def inc(self, key, delta=...): ... def dec(self, key, delta=...): ... class NullCache(BaseCache): ... class SimpleCache(BaseCache): clear: Any def __init__(self, threshold: int = ..., default_timeout: float = ...): ... def get(self, key): ... def set(self, key, value, timeout: Optional[float] = ...): ... def add(self, key, value, timeout: Optional[float] = ...): ... def delete(self, key): ... def has(self, key): ... class MemcachedCache(BaseCache): key_prefix: Any def __init__(self, servers: Optional[Any] = ..., default_timeout: float = ..., key_prefix: Optional[Any] = ...): ... def get(self, key): ... def get_dict(self, *keys): ... def add(self, key, value, timeout: Optional[float] = ...): ... def set(self, key, value, timeout: Optional[float] = ...): ... def get_many(self, *keys): ... def set_many(self, mapping, timeout: Optional[float] = ...): ... def delete(self, key): ... def delete_many(self, *keys): ... def has(self, key): ... def clear(self): ... def inc(self, key, delta=...): ... def dec(self, key, delta=...): ... def import_preferred_memcache_lib(self, servers): ... GAEMemcachedCache: Any class RedisCache(BaseCache): key_prefix: Any def __init__( self, host: str = ..., port: int = ..., password: Optional[Any] = ..., db: int = ..., default_timeout: float = ..., key_prefix: Optional[Any] = ..., **kwargs, ): ... def dump_object(self, value): ... def load_object(self, value): ... def get(self, key): ... def get_many(self, *keys): ... def set(self, key, value, timeout: Optional[float] = ...): ... def add(self, key, value, timeout: Optional[float] = ...): ... def set_many(self, mapping, timeout: Optional[float] = ...): ... def delete(self, key): ... def delete_many(self, *keys): ... def has(self, key): ... def clear(self): ... def inc(self, key, delta=...): ... def dec(self, key, delta=...): ... class FileSystemCache(BaseCache): def __init__(self, cache_dir, threshold: int = ..., default_timeout: float = ..., mode: int = ...): ... def clear(self): ... def get(self, key): ... def add(self, key, value, timeout: Optional[float] = ...): ... def set(self, key, value, timeout: Optional[float] = ...): ... def delete(self, key): ... def has(self, key): ... class UWSGICache(BaseCache): cache: Any def __init__(self, default_timeout: float = ..., cache: str = ...): ... def get(self, key): ... def delete(self, key): ... def set(self, key, value, timeout: Optional[float] = ...): ... def add(self, key, value, timeout: Optional[float] = ...): ... def clear(self): ... def has(self, key): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/werkzeug/contrib/fixers.pyi0000664000175000017500000000316200000000000030261 0ustar00davedave00000000000000from _typeshed.wsgi import StartResponse, WSGIApplication, WSGIEnvironment from typing import Any, Iterable, List, Mapping, Optional, Set, Text from ..middleware.proxy_fix import ProxyFix as ProxyFix class CGIRootFix(object): app: WSGIApplication app_root: Text def __init__(self, app: WSGIApplication, app_root: Text = ...) -> None: ... def __call__(self, environ: WSGIEnvironment, start_response: StartResponse) -> Iterable[bytes]: ... class LighttpdCGIRootFix(CGIRootFix): ... class PathInfoFromRequestUriFix(object): app: WSGIApplication def __init__(self, app: WSGIApplication) -> None: ... def __call__(self, environ: WSGIEnvironment, start_response: StartResponse) -> Iterable[bytes]: ... class HeaderRewriterFix(object): app: WSGIApplication remove_headers: Set[Text] add_headers: List[Text] def __init__( self, app: WSGIApplication, remove_headers: Optional[Iterable[Text]] = ..., add_headers: Optional[Iterable[Text]] = ... ) -> None: ... def __call__(self, environ: WSGIEnvironment, start_response: StartResponse) -> Iterable[bytes]: ... class InternetExplorerFix(object): app: WSGIApplication fix_vary: bool fix_attach: bool def __init__(self, app: WSGIApplication, fix_vary: bool = ..., fix_attach: bool = ...) -> None: ... def fix_headers(self, environ: WSGIEnvironment, headers: Mapping[str, str], status: Optional[Any] = ...) -> None: ... def run_fixed(self, environ: WSGIEnvironment, start_response: StartResponse) -> Iterable[bytes]: ... def __call__(self, environ: WSGIEnvironment, start_response: StartResponse) -> Iterable[bytes]: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/werkzeug/contrib/iterio.pyi0000664000175000017500000000226200000000000030254 0ustar00davedave00000000000000from typing import Any, Optional, Text, Union greenlet: Any class IterIO: def __new__(cls, obj, sentinel: Union[Text, bytes] = ...): ... def __iter__(self): ... def tell(self): ... def isatty(self): ... def seek(self, pos, mode: int = ...): ... def truncate(self, size: Optional[Any] = ...): ... def write(self, s): ... def writelines(self, list): ... def read(self, n: int = ...): ... def readlines(self, sizehint: int = ...): ... def readline(self, length: Optional[Any] = ...): ... def flush(self): ... def __next__(self): ... class IterI(IterIO): sentinel: Any def __new__(cls, func, sentinel: Union[Text, bytes] = ...): ... closed: Any def close(self): ... def write(self, s): ... def writelines(self, list): ... def flush(self): ... class IterO(IterIO): sentinel: Any closed: Any pos: Any def __new__(cls, gen, sentinel: Union[Text, bytes] = ...): ... def __iter__(self): ... def close(self): ... def seek(self, pos, mode: int = ...): ... def read(self, n: int = ...): ... def readline(self, length: Optional[Any] = ...): ... def readlines(self, sizehint: int = ...): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/werkzeug/contrib/jsrouting.pyi0000664000175000017500000000050500000000000031003 0ustar00davedave00000000000000from typing import Any def dumps(*args): ... def render_template(name_parts, rules, converters): ... def generate_map(map, name: str = ...): ... def generate_adapter(adapter, name: str = ..., map_name: str = ...): ... def js_to_url_function(converter): ... def NumberConverter_js_to_url(conv): ... js_to_url_functions: Any ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/werkzeug/contrib/limiter.pyi0000664000175000017500000000030000000000000030415 0ustar00davedave00000000000000from typing import Any class StreamLimitMiddleware: app: Any maximum_size: Any def __init__(self, app, maximum_size=...): ... def __call__(self, environ, start_response): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/werkzeug/contrib/lint.pyi0000664000175000017500000000004000000000000027717 0ustar00davedave00000000000000from ..middleware.lint import * ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/werkzeug/contrib/profiler.pyi0000664000175000017500000000047300000000000030605 0ustar00davedave00000000000000from _typeshed import SupportsWrite from typing import AnyStr, Generic, Tuple from ..middleware.profiler import * class MergeStream(Generic[AnyStr]): streams: Tuple[SupportsWrite[AnyStr], ...] def __init__(self, *streams: SupportsWrite[AnyStr]) -> None: ... def write(self, data: AnyStr) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/werkzeug/contrib/securecookie.pyi0000664000175000017500000000227400000000000031444 0ustar00davedave00000000000000from hashlib import sha1 as _default_hash from hmac import new as hmac from typing import Any, Optional from werkzeug.contrib.sessions import ModificationTrackingDict class UnquoteError(Exception): ... class SecureCookie(ModificationTrackingDict[Any, Any]): hash_method: Any serialization_method: Any quote_base64: Any secret_key: Any new: Any def __init__(self, data: Optional[Any] = ..., secret_key: Optional[Any] = ..., new: bool = ...): ... @property def should_save(self): ... @classmethod def quote(cls, value): ... @classmethod def unquote(cls, value): ... def serialize(self, expires: Optional[Any] = ...): ... @classmethod def unserialize(cls, string, secret_key): ... @classmethod def load_cookie(cls, request, key: str = ..., secret_key: Optional[Any] = ...): ... def save_cookie( self, response, key: str = ..., expires: Optional[Any] = ..., session_expires: Optional[Any] = ..., max_age: Optional[Any] = ..., path: str = ..., domain: Optional[Any] = ..., secure: Optional[Any] = ..., httponly: bool = ..., force: bool = ..., ): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/werkzeug/contrib/sessions.pyi0000664000175000017500000000403200000000000030624 0ustar00davedave00000000000000from typing import Any, Optional, Text, TypeVar from werkzeug.datastructures import CallbackDict _K = TypeVar("_K") _V = TypeVar("_V") def generate_key(salt: Optional[Any] = ...): ... class ModificationTrackingDict(CallbackDict[_K, _V]): modified: Any def __init__(self, *args, **kwargs): ... def copy(self): ... def __copy__(self): ... class Session(ModificationTrackingDict[_K, _V]): sid: Any new: Any def __init__(self, data, sid, new: bool = ...): ... @property def should_save(self): ... class SessionStore: session_class: Any def __init__(self, session_class: Optional[Any] = ...): ... def is_valid_key(self, key): ... def generate_key(self, salt: Optional[Any] = ...): ... def new(self): ... def save(self, session): ... def save_if_modified(self, session): ... def delete(self, session): ... def get(self, sid): ... class FilesystemSessionStore(SessionStore): path: Any filename_template: str renew_missing: Any mode: Any def __init__( self, path: Optional[Any] = ..., filename_template: Text = ..., session_class: Optional[Any] = ..., renew_missing: bool = ..., mode: int = ..., ): ... def get_session_filename(self, sid): ... def save(self, session): ... def delete(self, session): ... def get(self, sid): ... def list(self): ... class SessionMiddleware: app: Any store: Any cookie_name: Any cookie_age: Any cookie_expires: Any cookie_path: Any cookie_domain: Any cookie_secure: Any cookie_httponly: Any environ_key: Any def __init__( self, app, store, cookie_name: str = ..., cookie_age: Optional[Any] = ..., cookie_expires: Optional[Any] = ..., cookie_path: str = ..., cookie_domain: Optional[Any] = ..., cookie_secure: Optional[Any] = ..., cookie_httponly: bool = ..., environ_key: str = ..., ): ... def __call__(self, environ, start_response): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/werkzeug/contrib/testtools.pyi0000664000175000017500000000027400000000000031022 0ustar00davedave00000000000000from werkzeug.wrappers import Response class ContentAccessors: def xml(self): ... def lxml(self): ... def json(self): ... class TestResponse(Response, ContentAccessors): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/werkzeug/contrib/wrappers.pyi0000664000175000017500000000113300000000000030620 0ustar00davedave00000000000000from typing import Any def is_known_charset(charset): ... class JSONRequestMixin: def json(self): ... class ProtobufRequestMixin: protobuf_check_initialization: Any def parse_protobuf(self, proto_type): ... class RoutingArgsRequestMixin: routing_args: Any routing_vars: Any class ReverseSlashBehaviorRequestMixin: def path(self): ... def script_root(self): ... class DynamicCharsetRequestMixin: default_charset: Any def unknown_charset(self, charset): ... def charset(self): ... class DynamicCharsetResponseMixin: default_charset: Any charset: Any ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/werkzeug/datastructures.pyi0000664000175000017500000003634300000000000030405 0ustar00davedave00000000000000from _typeshed import SupportsWrite from typing import ( IO, Any, Callable, Container, Dict, Generic, Iterable, Iterator, List, Mapping, MutableSet, NoReturn, Optional, Text, Tuple, Type, TypeVar, Union, overload, ) _K = TypeVar("_K") _V = TypeVar("_V") _R = TypeVar("_R") _D = TypeVar("_D") def is_immutable(self) -> NoReturn: ... def iter_multi_items(mapping): ... def native_itermethods(names): ... class ImmutableListMixin(Generic[_V]): def __hash__(self) -> int: ... def __reduce_ex__(self: _D, protocol) -> Tuple[Type[_D], List[_V]]: ... def __delitem__(self, key: _V) -> NoReturn: ... def __iadd__(self, other: Any) -> NoReturn: ... def __imul__(self, other: Any) -> NoReturn: ... def __setitem__(self, key: str, value: Any) -> NoReturn: ... def append(self, item: Any) -> NoReturn: ... def remove(self, item: Any) -> NoReturn: ... def extend(self, iterable: Any) -> NoReturn: ... def insert(self, pos: int, value: Any) -> NoReturn: ... def pop(self, index: int = ...) -> NoReturn: ... def reverse(self) -> NoReturn: ... def sort(self, cmp: Optional[Any] = ..., key: Optional[Any] = ..., reverse: Optional[Any] = ...) -> NoReturn: ... class ImmutableList(ImmutableListMixin[_V], List[_V]): ... # type: ignore class ImmutableDictMixin(object): @classmethod def fromkeys(cls, *args, **kwargs): ... def __reduce_ex__(self, protocol): ... def __hash__(self) -> int: ... def setdefault(self, key, default: Optional[Any] = ...): ... def update(self, *args, **kwargs): ... def pop(self, key, default: Optional[Any] = ...): ... def popitem(self): ... def __setitem__(self, key, value): ... def __delitem__(self, key): ... def clear(self): ... class ImmutableMultiDictMixin(ImmutableDictMixin): def __reduce_ex__(self, protocol): ... def add(self, key, value): ... def popitemlist(self): ... def poplist(self, key): ... def setlist(self, key, new_list): ... def setlistdefault(self, key, default_list: Optional[Any] = ...): ... class UpdateDictMixin(object): on_update: Any def setdefault(self, key, default: Optional[Any] = ...): ... def pop(self, key, default=...): ... __setitem__: Any __delitem__: Any clear: Any popitem: Any update: Any class TypeConversionDict(Dict[_K, _V]): @overload def get(self, key: _K, *, type: None = ...) -> Optional[_V]: ... @overload def get(self, key: _K, default: _D, type: None = ...) -> Union[_V, _D]: ... @overload def get(self, key: _K, *, type: Callable[[_V], _R]) -> Optional[_R]: ... @overload def get(self, key: _K, default: _D, type: Callable[[_V], _R]) -> Union[_R, _D]: ... class ImmutableTypeConversionDict(ImmutableDictMixin, TypeConversionDict[_K, _V]): # type: ignore def copy(self) -> TypeConversionDict[_K, _V]: ... def __copy__(self) -> ImmutableTypeConversionDict[_K, _V]: ... class ViewItems: def __init__(self, multi_dict, method, repr_name, *a, **kw): ... def __iter__(self): ... class MultiDict(TypeConversionDict[_K, _V]): def __init__(self, mapping: Optional[Any] = ...): ... def __getitem__(self, key): ... def __setitem__(self, key, value): ... def add(self, key, value): ... def getlist(self, key, type: Optional[Any] = ...): ... def setlist(self, key, new_list): ... def setdefault(self, key, default: Optional[Any] = ...): ... def setlistdefault(self, key, default_list: Optional[Any] = ...): ... def items(self, multi: bool = ...): ... def lists(self): ... def keys(self): ... __iter__: Any def values(self): ... def listvalues(self): ... def copy(self): ... def deepcopy(self, memo: Optional[Any] = ...): ... def to_dict(self, flat: bool = ...): ... def update(self, other_dict): ... def pop(self, key, default=...): ... def popitem(self): ... def poplist(self, key): ... def popitemlist(self): ... def __copy__(self): ... def __deepcopy__(self, memo): ... class _omd_bucket: prev: Any key: Any value: Any next: Any def __init__(self, omd, key, value): ... def unlink(self, omd): ... class OrderedMultiDict(MultiDict[_K, _V]): def __init__(self, mapping: Optional[Any] = ...): ... def __eq__(self, other): ... def __ne__(self, other): ... def __reduce_ex__(self, protocol): ... def __getitem__(self, key): ... def __setitem__(self, key, value): ... def __delitem__(self, key): ... def keys(self): ... __iter__: Any def values(self): ... def items(self, multi: bool = ...): ... def lists(self): ... def listvalues(self): ... def add(self, key, value): ... def getlist(self, key, type: Optional[Any] = ...): ... def setlist(self, key, new_list): ... def setlistdefault(self, key, default_list: Optional[Any] = ...): ... def update(self, mapping): ... def poplist(self, key): ... def pop(self, key, default=...): ... def popitem(self): ... def popitemlist(self): ... class Headers(object): def __init__(self, defaults: Optional[Any] = ...): ... def __getitem__(self, key, _get_mode: bool = ...): ... def __eq__(self, other): ... def __ne__(self, other): ... @overload def get(self, key: str, *, type: None = ...) -> Optional[str]: ... @overload def get(self, key: str, default: _D, type: None = ...) -> Union[str, _D]: ... @overload def get(self, key: str, *, type: Callable[[str], _R]) -> Optional[_R]: ... @overload def get(self, key: str, default: _D, type: Callable[[str], _R]) -> Union[_R, _D]: ... @overload def get(self, key: str, *, as_bytes: bool) -> Any: ... @overload def get(self, key: str, *, type: None, as_bytes: bool) -> Any: ... @overload def get(self, key: str, *, type: Callable[[Any], _R], as_bytes: bool) -> Optional[_R]: ... @overload def get(self, key: str, default: Any, type: None, as_bytes: bool) -> Any: ... @overload def get(self, key: str, default: _D, type: Callable[[Any], _R], as_bytes: bool) -> Union[_R, _D]: ... def getlist(self, key, type: Optional[Any] = ..., as_bytes: bool = ...): ... def get_all(self, name): ... def items(self, lower: bool = ...): ... def keys(self, lower: bool = ...): ... def values(self): ... def extend(self, iterable): ... def __delitem__(self, key: Any) -> None: ... def remove(self, key): ... def pop(self, **kwargs): ... def popitem(self): ... def __contains__(self, key): ... has_key: Any def __iter__(self): ... def __len__(self): ... def add(self, _key, _value, **kw): ... def add_header(self, _key, _value, **_kw): ... def clear(self): ... def set(self, _key, _value, **kw): ... def setdefault(self, key, value): ... def __setitem__(self, key, value): ... def to_list(self, charset: Text = ...): ... def to_wsgi_list(self): ... def copy(self): ... def __copy__(self): ... class ImmutableHeadersMixin: def __delitem__(self, key: str) -> None: ... def __setitem__(self, key, value): ... set: Any def add(self, *args, **kwargs): ... remove: Any add_header: Any def extend(self, iterable): ... def insert(self, pos, value): ... def pop(self, **kwargs): ... def popitem(self): ... def setdefault(self, key, default): ... class EnvironHeaders(ImmutableHeadersMixin, Headers): environ: Any def __init__(self, environ): ... def __eq__(self, other): ... def __getitem__(self, key, _get_mode: bool = ...): ... def __len__(self): ... def __iter__(self): ... def copy(self): ... class CombinedMultiDict(ImmutableMultiDictMixin, MultiDict[_K, _V]): # type: ignore def __reduce_ex__(self, protocol): ... dicts: Any def __init__(self, dicts: Optional[Any] = ...): ... @classmethod def fromkeys(cls): ... def __getitem__(self, key): ... def get(self, key, default: Optional[Any] = ..., type: Optional[Any] = ...): ... def getlist(self, key, type: Optional[Any] = ...): ... def keys(self): ... __iter__: Any def items(self, multi: bool = ...): ... def values(self): ... def lists(self): ... def listvalues(self): ... def copy(self): ... def to_dict(self, flat: bool = ...): ... def __len__(self): ... def __contains__(self, key): ... has_key: Any class FileMultiDict(MultiDict[_K, _V]): def add_file(self, name, file, filename: Optional[Any] = ..., content_type: Optional[Any] = ...): ... class ImmutableDict(ImmutableDictMixin, Dict[_K, _V]): # type: ignore def copy(self): ... def __copy__(self): ... class ImmutableMultiDict(ImmutableMultiDictMixin, MultiDict[_K, _V]): # type: ignore def copy(self): ... def __copy__(self): ... class ImmutableOrderedMultiDict(ImmutableMultiDictMixin, OrderedMultiDict[_K, _V]): # type: ignore def copy(self): ... def __copy__(self): ... class Accept(ImmutableList[Tuple[str, float]]): provided: bool def __init__(self, values: Union[None, Accept, Iterable[Tuple[str, float]]] = ...) -> None: ... @overload def __getitem__(self, key: int) -> Tuple[str, float]: ... @overload def __getitem__(self, s: slice) -> List[Tuple[str, float]]: ... @overload def __getitem__(self, key: str) -> float: ... def quality(self, key: str) -> float: ... def __contains__(self, value: str) -> bool: ... # type: ignore def index(self, key: Union[str, Tuple[str, float]]) -> int: ... # type: ignore def find(self, key: Union[str, Tuple[str, float]]) -> int: ... def values(self) -> Iterator[str]: ... def to_header(self) -> str: ... @overload def best_match(self, matches: Iterable[str], default: None = ...) -> Optional[str]: ... @overload def best_match(self, matches: Iterable[str], default: _D) -> Union[str, _D]: ... @property def best(self) -> Optional[str]: ... class MIMEAccept(Accept): @property def accept_html(self) -> bool: ... @property def accept_xhtml(self) -> bool: ... @property def accept_json(self) -> bool: ... class LanguageAccept(Accept): ... class CharsetAccept(Accept): ... def cache_property(key, empty, type): ... class _CacheControl(UpdateDictMixin, Dict[str, Any]): no_cache: Any no_store: Any max_age: Any no_transform: Any on_update: Any provided: Any def __init__(self, values=..., on_update: Optional[Any] = ...): ... def to_header(self): ... class RequestCacheControl(ImmutableDictMixin, _CacheControl): # type: ignore max_stale: Any min_fresh: Any no_transform: Any only_if_cached: Any class ResponseCacheControl(_CacheControl): public: Any private: Any must_revalidate: Any proxy_revalidate: Any s_maxage: Any class CallbackDict(UpdateDictMixin, Dict[_K, _V]): on_update: Any def __init__(self, initial: Optional[Any] = ..., on_update: Optional[Any] = ...): ... class HeaderSet(MutableSet[str]): on_update: Any def __init__(self, headers: Optional[Any] = ..., on_update: Optional[Any] = ...): ... def add(self, header): ... def remove(self, header): ... def update(self, iterable): ... def discard(self, header): ... def find(self, header): ... def index(self, header): ... def clear(self): ... def as_set(self, preserve_casing: bool = ...): ... def to_header(self): ... def __getitem__(self, idx): ... def __delitem__(self, idx): ... def __setitem__(self, idx, value): ... def __contains__(self, header): ... def __len__(self): ... def __iter__(self): ... def __nonzero__(self): ... class ETags(Container[str], Iterable[str]): star_tag: Any def __init__(self, strong_etags: Optional[Any] = ..., weak_etags: Optional[Any] = ..., star_tag: bool = ...): ... def as_set(self, include_weak: bool = ...): ... def is_weak(self, etag): ... def contains_weak(self, etag): ... def contains(self, etag): ... def contains_raw(self, etag): ... def to_header(self): ... def __call__(self, etag: Optional[Any] = ..., data: Optional[Any] = ..., include_weak: bool = ...): ... def __bool__(self): ... __nonzero__: Any def __iter__(self): ... def __contains__(self, etag): ... class IfRange: etag: Any date: Any def __init__(self, etag: Optional[Any] = ..., date: Optional[Any] = ...): ... def to_header(self): ... class Range: units: Any ranges: Any def __init__(self, units, ranges): ... def range_for_length(self, length): ... def make_content_range(self, length): ... def to_header(self): ... def to_content_range_header(self, length): ... class ContentRange: on_update: Any units: Optional[str] start: Any stop: Any length: Any def __init__(self, units: Optional[str], start, stop, length: Optional[Any] = ..., on_update: Optional[Any] = ...): ... def set(self, start, stop, length: Optional[Any] = ..., units: Optional[str] = ...): ... def unset(self) -> None: ... def to_header(self): ... def __nonzero__(self): ... __bool__: Any class Authorization(ImmutableDictMixin, Dict[str, Any]): # type: ignore type: str def __init__(self, auth_type: str, data: Optional[Mapping[str, Any]] = ...) -> None: ... @property def username(self) -> Optional[str]: ... @property def password(self) -> Optional[str]: ... @property def realm(self) -> Optional[str]: ... @property def nonce(self) -> Optional[str]: ... @property def uri(self) -> Optional[str]: ... @property def nc(self) -> Optional[str]: ... @property def cnonce(self) -> Optional[str]: ... @property def response(self) -> Optional[str]: ... @property def opaque(self) -> Optional[str]: ... @property def qop(self) -> Optional[str]: ... class WWWAuthenticate(UpdateDictMixin, Dict[str, Any]): on_update: Any def __init__(self, auth_type: Optional[Any] = ..., values: Optional[Any] = ..., on_update: Optional[Any] = ...): ... def set_basic(self, realm: str = ...): ... def set_digest( self, realm, nonce, qop=..., opaque: Optional[Any] = ..., algorithm: Optional[Any] = ..., stale: bool = ... ): ... def to_header(self): ... @staticmethod def auth_property(name, doc: Optional[Any] = ...): ... type: Any realm: Any domain: Any nonce: Any opaque: Any algorithm: Any qop: Any stale: Any class FileStorage(object): name: Optional[Text] stream: IO[bytes] filename: Optional[Text] headers: Headers def __init__( self, stream: Optional[IO[bytes]] = ..., filename: Union[None, Text, bytes] = ..., name: Optional[Text] = ..., content_type: Optional[Text] = ..., content_length: Optional[int] = ..., headers: Optional[Headers] = ..., ): ... @property def content_type(self) -> Optional[Text]: ... @property def content_length(self) -> int: ... @property def mimetype(self) -> str: ... @property def mimetype_params(self) -> Dict[str, str]: ... def save(self, dst: Union[Text, SupportsWrite[bytes]], buffer_size: int = ...): ... def close(self) -> None: ... def __nonzero__(self) -> bool: ... def __bool__(self) -> bool: ... def __getattr__(self, name: Text) -> Any: ... def __iter__(self) -> Iterator[bytes]: ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4623795 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/werkzeug/debug/0000775000175000017500000000000000000000000025662 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/werkzeug/debug/__init__.pyi0000664000175000017500000000255000000000000030146 0ustar00davedave00000000000000from typing import Any, Optional from werkzeug.wrappers import BaseRequest as Request, BaseResponse as Response PIN_TIME: Any def hash_pin(pin): ... def get_machine_id(): ... class _ConsoleFrame: console: Any id: Any def __init__(self, namespace): ... def get_pin_and_cookie_name(app): ... class DebuggedApplication: app: Any evalex: Any frames: Any tracebacks: Any request_key: Any console_path: Any console_init_func: Any show_hidden_frames: Any secret: Any pin_logging: Any pin: Any def __init__( self, app, evalex: bool = ..., request_key: str = ..., console_path: str = ..., console_init_func: Optional[Any] = ..., show_hidden_frames: bool = ..., lodgeit_url: Optional[Any] = ..., pin_security: bool = ..., pin_logging: bool = ..., ): ... @property def pin_cookie_name(self): ... def debug_application(self, environ, start_response): ... def execute_command(self, request, command, frame): ... def display_console(self, request): ... def paste_traceback(self, request, traceback): ... def get_resource(self, request, filename): ... def check_pin_trust(self, environ): ... def pin_auth(self, request): ... def log_pin_request(self): ... def __call__(self, environ, start_response): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/werkzeug/debug/console.pyi0000664000175000017500000000226700000000000030056 0ustar00davedave00000000000000import code from typing import Any, Optional class HTMLStringO: def __init__(self): ... def isatty(self): ... def close(self): ... def flush(self): ... def seek(self, n, mode: int = ...): ... def readline(self): ... def reset(self): ... def write(self, x): ... def writelines(self, x): ... class ThreadedStream: @staticmethod def push(): ... @staticmethod def fetch(): ... @staticmethod def displayhook(obj): ... def __setattr__(self, name, value): ... def __dir__(self): ... def __getattribute__(self, name): ... class _ConsoleLoader: def __init__(self): ... def register(self, code, source): ... def get_source_by_code(self, code): ... class _InteractiveConsole(code.InteractiveInterpreter): globals: Any more: Any buffer: Any def __init__(self, globals, locals): ... def runsource(self, source): ... def runcode(self, code): ... def showtraceback(self): ... def showsyntaxerror(self, filename: Optional[Any] = ...): ... def write(self, data): ... class Console: def __init__(self, globals: Optional[Any] = ..., locals: Optional[Any] = ...): ... def eval(self, code): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/werkzeug/debug/repr.pyi0000664000175000017500000000151600000000000027360 0ustar00davedave00000000000000from typing import Any, Optional deque: Any missing: Any RegexType: Any HELP_HTML: Any OBJECT_DUMP_HTML: Any def debug_repr(obj): ... def dump(obj=...): ... class _Helper: def __call__(self, topic: Optional[Any] = ...): ... helper: Any class DebugReprGenerator: def __init__(self): ... list_repr: Any tuple_repr: Any set_repr: Any frozenset_repr: Any deque_repr: Any def regex_repr(self, obj): ... def string_repr(self, obj, limit: int = ...): ... def dict_repr(self, d, recursive, limit: int = ...): ... def object_repr(self, obj): ... def dispatch_repr(self, obj, recursive): ... def fallback_repr(self): ... def repr(self, obj): ... def dump_object(self, obj): ... def dump_locals(self, d): ... def render_object_dump(self, items, title, repr: Optional[Any] = ...): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/werkzeug/debug/tbtools.pyi0000664000175000017500000000322700000000000030077 0ustar00davedave00000000000000from typing import Any, Optional UTF8_COOKIE: Any system_exceptions: Any HEADER: Any FOOTER: Any PAGE_HTML: Any CONSOLE_HTML: Any SUMMARY_HTML: Any FRAME_HTML: Any SOURCE_LINE_HTML: Any def render_console_html(secret, evalex_trusted: bool = ...): ... def get_current_traceback(ignore_system_exceptions: bool = ..., show_hidden_frames: bool = ..., skip: int = ...): ... class Line: lineno: Any code: Any in_frame: Any current: Any def __init__(self, lineno, code): ... def classes(self): ... def render(self): ... class Traceback: exc_type: Any exc_value: Any exception_type: Any frames: Any def __init__(self, exc_type, exc_value, tb): ... def filter_hidden_frames(self): ... def is_syntax_error(self): ... def exception(self): ... def log(self, logfile: Optional[Any] = ...): ... def paste(self): ... def render_summary(self, include_title: bool = ...): ... def render_full(self, evalex: bool = ..., secret: Optional[Any] = ..., evalex_trusted: bool = ...): ... def generate_plaintext_traceback(self): ... def plaintext(self): ... id: Any class Frame: lineno: Any function_name: Any locals: Any globals: Any filename: Any module: Any loader: Any code: Any hide: Any info: Any def __init__(self, exc_type, exc_value, tb): ... def render(self): ... def render_line_context(self): ... def get_annotated_lines(self): ... def eval(self, code, mode: str = ...): ... def sourcelines(self): ... def get_context_lines(self, context: int = ...): ... @property def current_line(self): ... def console(self): ... id: Any ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/werkzeug/exceptions.pyi0000664000175000017500000001151600000000000027504 0ustar00davedave00000000000000import datetime from _typeshed.wsgi import StartResponse, WSGIEnvironment from typing import Any, Dict, Iterable, List, NoReturn, Optional, Protocol, Text, Tuple, Type, Union from werkzeug.wrappers import Response class _EnvironContainer(Protocol): @property def environ(self) -> WSGIEnvironment: ... class HTTPException(Exception): code: Optional[int] description: Optional[Text] response: Optional[Response] def __init__(self, description: Optional[Text] = ..., response: Optional[Response] = ...) -> None: ... @classmethod def wrap(cls, exception: Type[Exception], name: Optional[str] = ...) -> Any: ... @property def name(self) -> str: ... def get_description(self, environ: Optional[WSGIEnvironment] = ...) -> Text: ... def get_body(self, environ: Optional[WSGIEnvironment] = ...) -> Text: ... def get_headers(self, environ: Optional[WSGIEnvironment] = ...) -> List[Tuple[str, str]]: ... def get_response(self, environ: Optional[Union[WSGIEnvironment, _EnvironContainer]] = ...) -> Response: ... def __call__(self, environ: WSGIEnvironment, start_response: StartResponse) -> Iterable[bytes]: ... default_exceptions: Dict[int, Type[HTTPException]] class BadRequest(HTTPException): code: int description: Text class ClientDisconnected(BadRequest): ... class SecurityError(BadRequest): ... class BadHost(BadRequest): ... class Unauthorized(HTTPException): code: int description: Text www_authenticate: Optional[Iterable[object]] def __init__( self, description: Optional[Text] = ..., response: Optional[Response] = ..., www_authenticate: Union[None, Tuple[object, ...], List[object], object] = ..., ) -> None: ... class Forbidden(HTTPException): code: int description: Text class NotFound(HTTPException): code: int description: Text class MethodNotAllowed(HTTPException): code: int description: Text valid_methods: Any def __init__(self, valid_methods: Optional[Any] = ..., description: Optional[Any] = ...): ... class NotAcceptable(HTTPException): code: int description: Text class RequestTimeout(HTTPException): code: int description: Text class Conflict(HTTPException): code: int description: Text class Gone(HTTPException): code: int description: Text class LengthRequired(HTTPException): code: int description: Text class PreconditionFailed(HTTPException): code: int description: Text class RequestEntityTooLarge(HTTPException): code: int description: Text class RequestURITooLarge(HTTPException): code: int description: Text class UnsupportedMediaType(HTTPException): code: int description: Text class RequestedRangeNotSatisfiable(HTTPException): code: int description: Text length: Any units: str def __init__(self, length: Optional[Any] = ..., units: str = ..., description: Optional[Any] = ...): ... class ExpectationFailed(HTTPException): code: int description: Text class ImATeapot(HTTPException): code: int description: Text class UnprocessableEntity(HTTPException): code: int description: Text class Locked(HTTPException): code: int description: Text class FailedDependency(HTTPException): code: int description: Text class PreconditionRequired(HTTPException): code: int description: Text class _RetryAfter(HTTPException): retry_after: Union[None, int, datetime.datetime] def __init__( self, description: Optional[Text] = ..., response: Optional[Response] = ..., retry_after: Union[None, int, datetime.datetime] = ..., ) -> None: ... class TooManyRequests(_RetryAfter): code: int description: Text class RequestHeaderFieldsTooLarge(HTTPException): code: int description: Text class UnavailableForLegalReasons(HTTPException): code: int description: Text class InternalServerError(HTTPException): def __init__( self, description: Optional[Text] = ..., response: Optional[Response] = ..., original_exception: Optional[Exception] = ... ) -> None: ... code: int description: Text class NotImplemented(HTTPException): code: int description: Text class BadGateway(HTTPException): code: int description: Text class ServiceUnavailable(_RetryAfter): code: int description: Text class GatewayTimeout(HTTPException): code: int description: Text class HTTPVersionNotSupported(HTTPException): code: int description: Text class Aborter: mapping: Any def __init__(self, mapping: Optional[Any] = ..., extra: Optional[Any] = ...) -> None: ... def __call__(self, code: Union[int, Response], *args: Any, **kwargs: Any) -> NoReturn: ... def abort(status: Union[int, Response], *args: Any, **kwargs: Any) -> NoReturn: ... class BadRequestKeyError(BadRequest, KeyError): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/werkzeug/filesystem.pyi0000664000175000017500000000025100000000000027501 0ustar00davedave00000000000000from typing import Any has_likely_buggy_unicode_filesystem: Any class BrokenFilesystemWarning(RuntimeWarning, UnicodeWarning): ... def get_filesystem_encoding(): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/werkzeug/formparser.pyi0000664000175000017500000000716600000000000027511 0ustar00davedave00000000000000from _typeshed.wsgi import WSGIEnvironment from typing import ( IO, Any, Callable, Dict, Generator, Iterable, Mapping, NoReturn, Optional, Protocol, Text, Tuple, TypeVar, Union, ) from .datastructures import Headers _Dict = Any _ParseFunc = Callable[[IO[bytes], str, Optional[int], Mapping[str, str]], Tuple[IO[bytes], _Dict, _Dict]] _F = TypeVar("_F", bound=Callable[..., Any]) class _StreamFactory(Protocol): def __call__( self, total_content_length: Optional[int], filename: str, content_type: str, content_length: Optional[int] = ... ) -> IO[bytes]: ... def default_stream_factory( total_content_length: Optional[int], filename: str, content_type: str, content_length: Optional[int] = ... ) -> IO[bytes]: ... def parse_form_data( environ: WSGIEnvironment, stream_factory: Optional[_StreamFactory] = ..., charset: Text = ..., errors: Text = ..., max_form_memory_size: Optional[int] = ..., max_content_length: Optional[int] = ..., cls: Optional[Callable[[], _Dict]] = ..., silent: bool = ..., ) -> Tuple[IO[bytes], _Dict, _Dict]: ... def exhaust_stream(f: _F) -> _F: ... class FormDataParser(object): stream_factory: _StreamFactory charset: Text errors: Text max_form_memory_size: Optional[int] max_content_length: Optional[int] cls: Callable[[], _Dict] silent: bool def __init__( self, stream_factory: Optional[_StreamFactory] = ..., charset: Text = ..., errors: Text = ..., max_form_memory_size: Optional[int] = ..., max_content_length: Optional[int] = ..., cls: Optional[Callable[[], _Dict]] = ..., silent: bool = ..., ) -> None: ... def get_parse_func(self, mimetype: str, options: Any) -> Optional[_ParseFunc]: ... def parse_from_environ(self, environ: WSGIEnvironment) -> Tuple[IO[bytes], _Dict, _Dict]: ... def parse( self, stream: IO[bytes], mimetype: Text, content_length: Optional[int], options: Optional[Mapping[str, str]] = ... ) -> Tuple[IO[bytes], _Dict, _Dict]: ... parse_functions: Dict[Text, _ParseFunc] def is_valid_multipart_boundary(boundary: str) -> bool: ... def parse_multipart_headers(iterable: Iterable[Union[Text, bytes]]) -> Headers: ... class MultiPartParser(object): charset: Text errors: Text max_form_memory_size: Optional[int] stream_factory: _StreamFactory cls: Callable[[], _Dict] buffer_size: int def __init__( self, stream_factory: Optional[_StreamFactory] = ..., charset: Text = ..., errors: Text = ..., max_form_memory_size: Optional[int] = ..., cls: Optional[Callable[[], _Dict]] = ..., buffer_size: int = ..., ) -> None: ... def fail(self, message: Text) -> NoReturn: ... def get_part_encoding(self, headers: Mapping[str, str]) -> Optional[str]: ... def get_part_charset(self, headers: Mapping[str, str]) -> Text: ... def start_file_streaming( self, filename: Union[Text, bytes], headers: Mapping[str, str], total_content_length: Optional[int] ) -> Tuple[Text, IO[bytes]]: ... def in_memory_threshold_reached(self, bytes: Any) -> NoReturn: ... def validate_boundary(self, boundary: Optional[str]) -> None: ... def parse_lines( self, file: Any, boundary: bytes, content_length: int, cap_at_buffer: bool = ... ) -> Generator[Tuple[str, Any], None, None]: ... def parse_parts(self, file: Any, boundary: bytes, content_length: int) -> Generator[Tuple[str, Any], None, None]: ... def parse(self, file: Any, boundary: bytes, content_length: int) -> Tuple[_Dict, _Dict]: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/werkzeug/http.pyi0000664000175000017500000001232700000000000026303 0ustar00davedave00000000000000import sys from _typeshed.wsgi import WSGIEnvironment from datetime import datetime, timedelta from typing import ( Any, Callable, Dict, Iterable, List, Mapping, Optional, SupportsInt, Text, Tuple, Type, TypeVar, Union, overload, ) from .datastructures import ( Accept, Authorization, ContentRange, ETags, Headers, HeaderSet, IfRange, Range, RequestCacheControl, TypeConversionDict, WWWAuthenticate, ) if sys.version_info < (3,): _Str = TypeVar("_Str", str, unicode) _ToBytes = Union[bytes, bytearray, buffer, unicode] _ETagData = Union[str, unicode, bytearray, buffer, memoryview] else: _Str = str _ToBytes = Union[bytes, bytearray, memoryview, str] _ETagData = Union[bytes, bytearray, memoryview] _T = TypeVar("_T") _U = TypeVar("_U") HTTP_STATUS_CODES: Dict[int, str] def wsgi_to_bytes(data: Union[bytes, Text]) -> bytes: ... def bytes_to_wsgi(data: bytes) -> str: ... def quote_header_value(value: Any, extra_chars: str = ..., allow_token: bool = ...) -> str: ... def unquote_header_value(value: _Str, is_filename: bool = ...) -> _Str: ... def dump_options_header(header: Optional[_Str], options: Mapping[_Str, Any]) -> _Str: ... def dump_header(iterable: Union[Iterable[Any], Dict[_Str, Any]], allow_token: bool = ...) -> _Str: ... def parse_list_header(value: _Str) -> List[_Str]: ... @overload def parse_dict_header(value: Union[bytes, Text]) -> Dict[Text, Optional[Text]]: ... @overload def parse_dict_header(value: Union[bytes, Text], cls: Type[_T]) -> _T: ... @overload def parse_options_header(value: None, multiple: bool = ...) -> Tuple[str, Dict[str, Optional[str]]]: ... @overload def parse_options_header(value: _Str) -> Tuple[_Str, Dict[_Str, Optional[_Str]]]: ... # actually returns Tuple[_Str, Dict[_Str, Optional[_Str]], ...] @overload def parse_options_header(value: _Str, multiple: bool = ...) -> Tuple[Any, ...]: ... @overload def parse_accept_header(value: Optional[Text]) -> Accept: ... @overload def parse_accept_header(value: Optional[_Str], cls: Callable[[Optional[List[Tuple[str, float]]]], _T]) -> _T: ... @overload def parse_cache_control_header( value: Union[None, bytes, Text], on_update: Optional[Callable[[RequestCacheControl], Any]] = ... ) -> RequestCacheControl: ... @overload def parse_cache_control_header( value: Union[None, bytes, Text], on_update: _T, cls: Callable[[Dict[Text, Optional[Text]], _T], _U] ) -> _U: ... @overload def parse_cache_control_header( value: Union[None, bytes, Text], *, cls: Callable[[Dict[Text, Optional[Text]], None], _U] ) -> _U: ... def parse_set_header(value: Text, on_update: Optional[Callable[[HeaderSet], Any]] = ...) -> HeaderSet: ... def parse_authorization_header(value: Union[None, bytes, Text]) -> Optional[Authorization]: ... def parse_www_authenticate_header( value: Union[None, bytes, Text], on_update: Optional[Callable[[WWWAuthenticate], Any]] = ... ) -> WWWAuthenticate: ... def parse_if_range_header(value: Optional[Text]) -> IfRange: ... def parse_range_header(value: Optional[Text], make_inclusive: bool = ...) -> Optional[Range]: ... def parse_content_range_header( value: Optional[Text], on_update: Optional[Callable[[ContentRange], Any]] = ... ) -> Optional[ContentRange]: ... def quote_etag(etag: _Str, weak: bool = ...) -> _Str: ... def unquote_etag(etag: Optional[_Str]) -> Tuple[Optional[_Str], Optional[_Str]]: ... def parse_etags(value: Optional[Text]) -> ETags: ... def generate_etag(data: _ETagData) -> str: ... def parse_date(value: Optional[str]) -> Optional[datetime]: ... def cookie_date(expires: Union[None, float, datetime] = ...) -> str: ... def http_date(timestamp: Union[None, float, datetime] = ...) -> str: ... def parse_age(value: Optional[SupportsInt] = ...) -> Optional[timedelta]: ... def dump_age(age: Union[None, timedelta, SupportsInt]) -> Optional[str]: ... def is_resource_modified( environ: WSGIEnvironment, etag: Optional[Text] = ..., data: Optional[_ETagData] = ..., last_modified: Union[None, Text, datetime] = ..., ignore_if_range: bool = ..., ) -> bool: ... def remove_entity_headers(headers: Union[List[Tuple[Text, Text]], Headers], allowed: Iterable[Text] = ...) -> None: ... def remove_hop_by_hop_headers(headers: Union[List[Tuple[Text, Text]], Headers]) -> None: ... def is_entity_header(header: Text) -> bool: ... def is_hop_by_hop_header(header: Text) -> bool: ... @overload def parse_cookie( header: Union[None, WSGIEnvironment, Text, bytes], charset: Text = ..., errors: Text = ... ) -> TypeConversionDict[Any, Any]: ... @overload def parse_cookie( header: Union[None, WSGIEnvironment, Text, bytes], charset: Text = ..., errors: Text = ..., cls: Optional[Callable[[Iterable[Tuple[Text, Text]]], _T]] = ..., ) -> _T: ... def dump_cookie( key: _ToBytes, value: _ToBytes = ..., max_age: Union[None, float, timedelta] = ..., expires: Union[None, Text, float, datetime] = ..., path: Union[None, Tuple[Any, ...], str, bytes] = ..., domain: Union[None, str, bytes] = ..., secure: bool = ..., httponly: bool = ..., charset: Text = ..., sync_expires: bool = ..., ) -> str: ... def is_byte_range_valid(start: Optional[int], stop: Optional[int], length: Optional[int]) -> bool: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/werkzeug/local.pyi0000664000175000017500000000441300000000000026413 0ustar00davedave00000000000000from typing import Any, Optional def release_local(local): ... class Local: def __init__(self): ... def __iter__(self): ... def __call__(self, proxy): ... def __release_local__(self): ... def __getattr__(self, name): ... def __setattr__(self, name, value): ... def __delattr__(self, name): ... class LocalStack: def __init__(self): ... def __release_local__(self): ... def _get__ident_func__(self): ... def _set__ident_func__(self, value): ... __ident_func__: Any def __call__(self): ... def push(self, obj): ... def pop(self): ... @property def top(self): ... class LocalManager: locals: Any ident_func: Any def __init__(self, locals: Optional[Any] = ..., ident_func: Optional[Any] = ...): ... def get_ident(self): ... def cleanup(self): ... def make_middleware(self, app): ... def middleware(self, func): ... class LocalProxy: def __init__(self, local, name: Optional[Any] = ...): ... @property def __dict__(self): ... def __bool__(self): ... def __unicode__(self): ... def __dir__(self): ... def __getattr__(self, name): ... def __setitem__(self, key, value): ... def __delitem__(self, key): ... __getslice__: Any def __setslice__(self, i, j, seq): ... def __delslice__(self, i, j): ... __setattr__: Any __delattr__: Any __lt__: Any __le__: Any __eq__: Any __ne__: Any __gt__: Any __ge__: Any __cmp__: Any __hash__: Any __call__: Any __len__: Any __getitem__: Any __iter__: Any __contains__: Any __add__: Any __sub__: Any __mul__: Any __floordiv__: Any __mod__: Any __divmod__: Any __pow__: Any __lshift__: Any __rshift__: Any __and__: Any __xor__: Any __or__: Any __div__: Any __truediv__: Any __neg__: Any __pos__: Any __abs__: Any __invert__: Any __complex__: Any __int__: Any __long__: Any __float__: Any __oct__: Any __hex__: Any __index__: Any __coerce__: Any __enter__: Any __exit__: Any __radd__: Any __rsub__: Any __rmul__: Any __rdiv__: Any __rtruediv__: Any __rfloordiv__: Any __rmod__: Any __rdivmod__: Any __copy__: Any __deepcopy__: Any ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4623795 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/werkzeug/middleware/0000775000175000017500000000000000000000000026711 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/werkzeug/middleware/__init__.pyi0000664000175000017500000000000000000000000031161 0ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/werkzeug/middleware/dispatcher.pyi0000664000175000017500000000070300000000000031562 0ustar00davedave00000000000000from _typeshed.wsgi import StartResponse, WSGIApplication, WSGIEnvironment from typing import Iterable, Mapping, Optional, Text class DispatcherMiddleware(object): app: WSGIApplication mounts: Mapping[Text, WSGIApplication] def __init__(self, app: WSGIApplication, mounts: Optional[Mapping[Text, WSGIApplication]] = ...) -> None: ... def __call__(self, environ: WSGIEnvironment, start_response: StartResponse) -> Iterable[bytes]: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/werkzeug/middleware/http_proxy.pyi0000664000175000017500000000121400000000000031652 0ustar00davedave00000000000000from _typeshed.wsgi import StartResponse, WSGIApplication, WSGIEnvironment from typing import Any, Dict, Iterable, Mapping, MutableMapping, Text _Opts = Mapping[Text, Any] _MutableOpts = MutableMapping[Text, Any] class ProxyMiddleware(object): app: WSGIApplication targets: Dict[Text, _MutableOpts] def __init__( self, app: WSGIApplication, targets: Mapping[Text, _MutableOpts], chunk_size: int = ..., timeout: int = ... ) -> None: ... def proxy_to(self, opts: _Opts, path: Text, prefix: Text) -> WSGIApplication: ... def __call__(self, environ: WSGIEnvironment, start_response: StartResponse) -> Iterable[bytes]: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/werkzeug/middleware/lint.pyi0000664000175000017500000000452500000000000030410 0ustar00davedave00000000000000import sys from _typeshed import SupportsWrite from _typeshed.wsgi import StartResponse, WSGIApplication, WSGIEnvironment from typing import Any, Iterable, Iterator, List, Mapping, Optional, Protocol, Tuple from ..datastructures import Headers class WSGIWarning(Warning): ... class HTTPWarning(Warning): ... def check_string(context: str, obj: object, stacklevel: int = ...) -> None: ... class _SupportsReadEtc(Protocol): def read(self, __size: int = ...) -> bytes: ... def readline(self, __size: int = ...) -> bytes: ... def __iter__(self) -> Iterator[bytes]: ... def close(self) -> Any: ... class InputStream(object): def __init__(self, stream: _SupportsReadEtc) -> None: ... def read(self, __size: int = ...) -> bytes: ... def readline(self, __size: int = ...) -> bytes: ... def __iter__(self) -> Iterator[bytes]: ... def close(self) -> None: ... class _SupportsWriteEtc(Protocol): def write(self, __s: str) -> Any: ... def flush(self) -> Any: ... def close(self) -> Any: ... class ErrorStream(object): def __init__(self, stream: _SupportsWriteEtc) -> None: ... def write(self, s: str) -> None: ... def flush(self) -> None: ... def writelines(self, seq: Iterable[str]) -> None: ... def close(self) -> None: ... class GuardedWrite(object): def __init__(self, write: SupportsWrite[str], chunks: List[int]) -> None: ... def __call__(self, s: str) -> None: ... class GuardedIterator(object): closed: bool headers_set: bool chunks: List[int] def __init__(self, iterator: Iterable[str], headers_set: bool, chunks: List[int]) -> None: ... def __iter__(self) -> GuardedIterator: ... if sys.version_info < (3,): def next(self) -> str: ... else: def __next__(self) -> str: ... def close(self) -> None: ... class LintMiddleware(object): def __init__(self, app: WSGIApplication) -> None: ... def check_environ(self, environ: WSGIEnvironment) -> None: ... def check_start_response( self, status: str, headers: List[Tuple[str, str]], exc_info: Optional[Tuple[Any, ...]] ) -> Tuple[int, Headers]: ... def check_headers(self, headers: Mapping[str, str]) -> None: ... def check_iterator(self, app_iter: Iterable[bytes]) -> None: ... def __call__(self, environ: WSGIEnvironment, start_response: StartResponse) -> GuardedIterator: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/werkzeug/middleware/profiler.pyi0000664000175000017500000000107100000000000031255 0ustar00davedave00000000000000from _typeshed.wsgi import StartResponse, WSGIApplication, WSGIEnvironment from typing import IO, Iterable, List, Optional, Text, Tuple, Union class ProfilerMiddleware(object): def __init__( self, app: WSGIApplication, stream: IO[str] = ..., sort_by: Tuple[Text, Text] = ..., restrictions: Iterable[Union[str, float]] = ..., profile_dir: Optional[Text] = ..., filename_format: Text = ..., ) -> None: ... def __call__(self, environ: WSGIEnvironment, start_response: StartResponse) -> List[bytes]: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/werkzeug/middleware/proxy_fix.pyi0000664000175000017500000000131000000000000031456 0ustar00davedave00000000000000from _typeshed.wsgi import StartResponse, WSGIApplication, WSGIEnvironment from typing import Iterable, Optional class ProxyFix(object): app: WSGIApplication x_for: int x_proto: int x_host: int x_port: int x_prefix: int num_proxies: int def __init__( self, app: WSGIApplication, num_proxies: Optional[int] = ..., x_for: int = ..., x_proto: int = ..., x_host: int = ..., x_port: int = ..., x_prefix: int = ..., ) -> None: ... def get_remote_addr(self, forwarded_for: Iterable[str]) -> Optional[str]: ... def __call__(self, environ: WSGIEnvironment, start_response: StartResponse) -> Iterable[bytes]: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/werkzeug/middleware/shared_data.pyi0000664000175000017500000000241700000000000031677 0ustar00davedave00000000000000import datetime from _typeshed.wsgi import StartResponse, WSGIApplication, WSGIEnvironment from typing import IO, Callable, Iterable, List, Mapping, Optional, Text, Tuple, Union _V = Union[Tuple[Text, Text], Text] _Opener = Callable[[], Tuple[IO[bytes], datetime.datetime, int]] _Loader = Callable[[Optional[Text]], Union[Tuple[None, None], Tuple[Text, _Opener]]] class SharedDataMiddleware(object): app: WSGIApplication exports: List[Tuple[Text, _Loader]] cache: bool cache_timeout: float def __init__( self, app: WSGIApplication, exports: Union[Mapping[Text, _V], Iterable[Tuple[Text, _V]]], disallow: Optional[Text] = ..., cache: bool = ..., cache_timeout: float = ..., fallback_mimetype: Text = ..., ) -> None: ... def is_allowed(self, filename: Text) -> bool: ... def get_file_loader(self, filename: Text) -> _Loader: ... def get_package_loader(self, package: Text, package_path: Text) -> _Loader: ... def get_directory_loader(self, directory: Text) -> _Loader: ... def generate_etag(self, mtime: datetime.datetime, file_size: int, real_filename: Union[Text, bytes]) -> str: ... def __call__(self, environment: WSGIEnvironment, start_response: StartResponse) -> WSGIApplication: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/werkzeug/posixemulation.pyi0000664000175000017500000000030700000000000030377 0ustar00davedave00000000000000from typing import Any from ._compat import to_unicode as to_unicode from .filesystem import get_filesystem_encoding as get_filesystem_encoding can_rename_open_file: Any def rename(src, dst): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/werkzeug/routing.pyi0000664000175000017500000001522200000000000027010 0ustar00davedave00000000000000from typing import Any, Optional, Text from werkzeug.exceptions import HTTPException def parse_converter_args(argstr): ... def parse_rule(rule): ... class RoutingException(Exception): ... class RequestRedirect(HTTPException, RoutingException): code: Any new_url: Any def __init__(self, new_url): ... def get_response(self, environ): ... class RequestSlash(RoutingException): ... class RequestAliasRedirect(RoutingException): matched_values: Any def __init__(self, matched_values): ... class BuildError(RoutingException, LookupError): endpoint: Any values: Any method: Any adapter: Optional[MapAdapter] def __init__(self, endpoint, values, method, adapter: Optional[MapAdapter] = ...) -> None: ... @property def suggested(self) -> Optional[Rule]: ... def closest_rule(self, adapter: Optional[MapAdapter]) -> Optional[Rule]: ... class ValidationError(ValueError): ... class RuleFactory: def get_rules(self, map): ... class Subdomain(RuleFactory): subdomain: Any rules: Any def __init__(self, subdomain, rules): ... def get_rules(self, map): ... class Submount(RuleFactory): path: Any rules: Any def __init__(self, path, rules): ... def get_rules(self, map): ... class EndpointPrefix(RuleFactory): prefix: Any rules: Any def __init__(self, prefix, rules): ... def get_rules(self, map): ... class RuleTemplate: rules: Any def __init__(self, rules): ... def __call__(self, *args, **kwargs): ... class RuleTemplateFactory(RuleFactory): rules: Any context: Any def __init__(self, rules, context): ... def get_rules(self, map): ... class Rule(RuleFactory): rule: Any is_leaf: Any map: Any strict_slashes: Any subdomain: Any host: Any defaults: Any build_only: Any alias: Any methods: Any endpoint: Any redirect_to: Any arguments: Any def __init__( self, string, defaults: Optional[Any] = ..., subdomain: Optional[Any] = ..., methods: Optional[Any] = ..., build_only: bool = ..., endpoint: Optional[Any] = ..., strict_slashes: Optional[Any] = ..., redirect_to: Optional[Any] = ..., alias: bool = ..., host: Optional[Any] = ..., ): ... def empty(self): ... def get_empty_kwargs(self): ... def get_rules(self, map): ... def refresh(self): ... def bind(self, map, rebind: bool = ...): ... def get_converter(self, variable_name, converter_name, args, kwargs): ... def compile(self): ... def match(self, path, method: Optional[Any] = ...): ... def build(self, values, append_unknown: bool = ...): ... def provides_defaults_for(self, rule): ... def suitable_for(self, values, method: Optional[Any] = ...): ... def match_compare_key(self): ... def build_compare_key(self): ... def __eq__(self, other): ... def __ne__(self, other): ... class BaseConverter: regex: Any weight: Any map: Any def __init__(self, map): ... def to_python(self, value): ... def to_url(self, value) -> str: ... class UnicodeConverter(BaseConverter): regex: Any def __init__(self, map, minlength: int = ..., maxlength: Optional[Any] = ..., length: Optional[Any] = ...): ... class AnyConverter(BaseConverter): regex: Any def __init__(self, map, *items): ... class PathConverter(BaseConverter): regex: Any weight: Any class NumberConverter(BaseConverter): weight: Any fixed_digits: Any min: Any max: Any def __init__(self, map, fixed_digits: int = ..., min: Optional[Any] = ..., max: Optional[Any] = ...): ... def to_python(self, value): ... def to_url(self, value) -> str: ... class IntegerConverter(NumberConverter): regex: Any num_convert: Any class FloatConverter(NumberConverter): regex: Any num_convert: Any def __init__(self, map, min: Optional[Any] = ..., max: Optional[Any] = ...): ... class UUIDConverter(BaseConverter): regex: Any def to_python(self, value): ... def to_url(self, value) -> str: ... DEFAULT_CONVERTERS: Any class Map: default_converters: Any default_subdomain: Any charset: Text encoding_errors: Text strict_slashes: Any redirect_defaults: Any host_matching: Any converters: Any sort_parameters: Any sort_key: Any def __init__( self, rules: Optional[Any] = ..., default_subdomain: str = ..., charset: Text = ..., strict_slashes: bool = ..., redirect_defaults: bool = ..., converters: Optional[Any] = ..., sort_parameters: bool = ..., sort_key: Optional[Any] = ..., encoding_errors: Text = ..., host_matching: bool = ..., ): ... def is_endpoint_expecting(self, endpoint, *arguments): ... def iter_rules(self, endpoint: Optional[Any] = ...): ... def add(self, rulefactory): ... def bind( self, server_name, script_name: Optional[Any] = ..., subdomain: Optional[Any] = ..., url_scheme: str = ..., default_method: str = ..., path_info: Optional[Any] = ..., query_args: Optional[Any] = ..., ): ... def bind_to_environ(self, environ, server_name: Optional[Any] = ..., subdomain: Optional[Any] = ...): ... def update(self): ... class MapAdapter: map: Any server_name: Any script_name: Any subdomain: Any url_scheme: Any path_info: Any default_method: Any query_args: Any def __init__( self, map, server_name, script_name, subdomain, url_scheme, path_info, default_method, query_args: Optional[Any] = ... ): ... def dispatch( self, view_func, path_info: Optional[Any] = ..., method: Optional[Any] = ..., catch_http_exceptions: bool = ... ): ... def match( self, path_info: Optional[Any] = ..., method: Optional[Any] = ..., return_rule: bool = ..., query_args: Optional[Any] = ..., ): ... def test(self, path_info: Optional[Any] = ..., method: Optional[Any] = ...): ... def allowed_methods(self, path_info: Optional[Any] = ...): ... def get_host(self, domain_part): ... def get_default_redirect(self, rule, method, values, query_args): ... def encode_query_args(self, query_args): ... def make_redirect_url(self, path_info, query_args: Optional[Any] = ..., domain_part: Optional[Any] = ...): ... def make_alias_redirect_url(self, path, endpoint, values, method, query_args): ... def build( self, endpoint, values: Optional[Any] = ..., method: Optional[Any] = ..., force_external: bool = ..., append_unknown: bool = ..., ): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/werkzeug/script.pyi0000664000175000017500000000140000000000000026616 0ustar00davedave00000000000000from typing import Any, Optional argument_types: Any converters: Any def run(namespace: Optional[Any] = ..., action_prefix: str = ..., args: Optional[Any] = ...): ... def fail(message, code: int = ...): ... def find_actions(namespace, action_prefix): ... def print_usage(actions): ... def analyse_action(func): ... def make_shell(init_func: Optional[Any] = ..., banner: Optional[Any] = ..., use_ipython: bool = ...): ... def make_runserver( app_factory, hostname: str = ..., port: int = ..., use_reloader: bool = ..., use_debugger: bool = ..., use_evalex: bool = ..., threaded: bool = ..., processes: int = ..., static_files: Optional[Any] = ..., extra_files: Optional[Any] = ..., ssl_context: Optional[Any] = ..., ): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/werkzeug/security.pyi0000664000175000017500000000101400000000000027162 0ustar00davedave00000000000000from typing import Any, Optional SALT_CHARS: Any DEFAULT_PBKDF2_ITERATIONS: Any def pbkdf2_hex(data, salt, iterations=..., keylen: Optional[Any] = ..., hashfunc: Optional[Any] = ...): ... def pbkdf2_bin(data, salt, iterations=..., keylen: Optional[Any] = ..., hashfunc: Optional[Any] = ...): ... def safe_str_cmp(a, b): ... def gen_salt(length): ... def generate_password_hash(password, method: str = ..., salt_length: int = ...): ... def check_password_hash(pwhash, password): ... def safe_join(directory, filename): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/werkzeug/serving.pyi0000664000175000017500000000773100000000000027004 0ustar00davedave00000000000000import sys from typing import Any, Optional if sys.version_info < (3,): from BaseHTTPServer import BaseHTTPRequestHandler, HTTPServer from SocketServer import ThreadingMixIn else: from http.server import BaseHTTPRequestHandler, HTTPServer from socketserver import ThreadingMixIn if sys.platform == "win32": class ForkingMixIn(object): ... else: if sys.version_info < (3,): from SocketServer import ForkingMixIn as ForkingMixIn else: from socketserver import ForkingMixIn as ForkingMixIn class _SslDummy: def __getattr__(self, name): ... ssl: Any LISTEN_QUEUE: Any can_open_by_fd: Any class WSGIRequestHandler(BaseHTTPRequestHandler): @property def server_version(self): ... def make_environ(self): ... environ: Any close_connection: Any def run_wsgi(self): ... def handle(self): ... def initiate_shutdown(self): ... def connection_dropped(self, error, environ: Optional[Any] = ...): ... raw_requestline: Any def handle_one_request(self): ... def send_response(self, code, message: Optional[Any] = ...): ... def version_string(self): ... def address_string(self): ... def port_integer(self): ... def log_request(self, code: object = ..., size: object = ...) -> None: ... def log_error(self, *args): ... def log_message(self, format, *args): ... def log(self, type, message, *args): ... BaseRequestHandler: Any def generate_adhoc_ssl_pair(cn: Optional[Any] = ...): ... def make_ssl_devcert(base_path, host: Optional[Any] = ..., cn: Optional[Any] = ...): ... def generate_adhoc_ssl_context(): ... def load_ssl_context(cert_file, pkey_file: Optional[Any] = ..., protocol: Optional[Any] = ...): ... class _SSLContext: def __init__(self, protocol): ... def load_cert_chain(self, certfile, keyfile: Optional[Any] = ..., password: Optional[Any] = ...): ... def wrap_socket(self, sock, **kwargs): ... def is_ssl_error(error: Optional[Any] = ...): ... def select_ip_version(host, port): ... class BaseWSGIServer(HTTPServer): multithread: Any multiprocess: Any request_queue_size: Any address_family: Any app: Any passthrough_errors: Any shutdown_signal: Any host: Any port: Any socket: Any server_address: Any ssl_context: Any def __init__( self, host, port, app, handler: Optional[Any] = ..., passthrough_errors: bool = ..., ssl_context: Optional[Any] = ..., fd: Optional[Any] = ..., ): ... def log(self, type, message, *args): ... def serve_forever(self): ... def handle_error(self, request, client_address): ... def get_request(self): ... class ThreadedWSGIServer(ThreadingMixIn, BaseWSGIServer): multithread: Any daemon_threads: Any class ForkingWSGIServer(ForkingMixIn, BaseWSGIServer): multiprocess: Any max_children: Any def __init__( self, host, port, app, processes: int = ..., handler: Optional[Any] = ..., passthrough_errors: bool = ..., ssl_context: Optional[Any] = ..., fd: Optional[Any] = ..., ): ... def make_server( host: Optional[Any] = ..., port: Optional[Any] = ..., app: Optional[Any] = ..., threaded: bool = ..., processes: int = ..., request_handler: Optional[Any] = ..., passthrough_errors: bool = ..., ssl_context: Optional[Any] = ..., fd: Optional[Any] = ..., ): ... def is_running_from_reloader(): ... def run_simple( hostname, port, application, use_reloader: bool = ..., use_debugger: bool = ..., use_evalex: bool = ..., extra_files: Optional[Any] = ..., reloader_interval: int = ..., reloader_type: str = ..., threaded: bool = ..., processes: int = ..., request_handler: Optional[Any] = ..., static_files: Optional[Any] = ..., passthrough_errors: bool = ..., ssl_context: Optional[Any] = ..., ): ... def run_with_reloader(*args, **kwargs): ... def main(): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/werkzeug/test.pyi0000664000175000017500000001377200000000000026310 0ustar00davedave00000000000000import sys from _typeshed.wsgi import WSGIEnvironment from typing import Any, Generic, Optional, Text, Tuple, Type, TypeVar, overload from typing_extensions import Literal if sys.version_info < (3,): from cookielib import CookieJar from urllib2 import Request as U2Request else: from http.cookiejar import CookieJar from urllib.request import Request as U2Request def stream_encode_multipart( values, use_tempfile: int = ..., threshold=..., boundary: Optional[Any] = ..., charset: Text = ... ): ... def encode_multipart(values, boundary: Optional[Any] = ..., charset: Text = ...): ... def File(fd, filename: Optional[Any] = ..., mimetype: Optional[Any] = ...): ... class _TestCookieHeaders: headers: Any def __init__(self, headers): ... def getheaders(self, name): ... def get_all(self, name, default: Optional[Any] = ...): ... class _TestCookieResponse: headers: Any def __init__(self, headers): ... def info(self): ... class _TestCookieJar(CookieJar): def inject_wsgi(self, environ): ... def extract_wsgi(self, environ, headers): ... class EnvironBuilder: server_protocol: Any wsgi_version: Any request_class: Any charset: Text path: Any base_url: Any query_string: Any args: Any method: Any headers: Any content_type: Any errors_stream: Any multithread: Any multiprocess: Any run_once: Any environ_base: Any environ_overrides: Any input_stream: Any content_length: Any closed: Any def __init__( self, path: str = ..., base_url: Optional[Any] = ..., query_string: Optional[Any] = ..., method: str = ..., input_stream: Optional[Any] = ..., content_type: Optional[Any] = ..., content_length: Optional[Any] = ..., errors_stream: Optional[Any] = ..., multithread: bool = ..., multiprocess: bool = ..., run_once: bool = ..., headers: Optional[Any] = ..., data: Optional[Any] = ..., environ_base: Optional[Any] = ..., environ_overrides: Optional[Any] = ..., charset: Text = ..., ): ... form: Any files: Any @property def server_name(self) -> str: ... @property def server_port(self) -> int: ... def __del__(self) -> None: ... def close(self) -> None: ... def get_environ(self) -> WSGIEnvironment: ... def get_request(self, cls: Optional[Any] = ...): ... class ClientRedirectError(Exception): ... # Response type for the client below. # By default _R is Tuple[Iterable[Any], Union[Text, int], datastructures.Headers] _R = TypeVar("_R") class Client(Generic[_R]): application: Any response_wrapper: Optional[Type[_R]] cookie_jar: Any allow_subdomain_redirects: Any def __init__( self, application, response_wrapper: Optional[Type[_R]] = ..., use_cookies: bool = ..., allow_subdomain_redirects: bool = ..., ): ... def set_cookie( self, server_name, key, value: str = ..., max_age: Optional[Any] = ..., expires: Optional[Any] = ..., path: str = ..., domain: Optional[Any] = ..., secure: Optional[Any] = ..., httponly: bool = ..., charset: Text = ..., ): ... def delete_cookie(self, server_name, key, path: str = ..., domain: Optional[Any] = ...): ... def run_wsgi_app(self, environ, buffered: bool = ...): ... def resolve_redirect(self, response, new_location, environ, buffered: bool = ...): ... @overload def open(self, *args, as_tuple: Literal[True], **kwargs) -> Tuple[WSGIEnvironment, _R]: ... @overload def open(self, *args, as_tuple: Literal[False] = ..., **kwargs) -> _R: ... @overload def open(self, *args, as_tuple: bool, **kwargs) -> Any: ... @overload def get(self, *args, as_tuple: Literal[True], **kw) -> Tuple[WSGIEnvironment, _R]: ... @overload def get(self, *args, as_tuple: Literal[False] = ..., **kw) -> _R: ... @overload def get(self, *args, as_tuple: bool, **kw) -> Any: ... @overload def patch(self, *args, as_tuple: Literal[True], **kw) -> Tuple[WSGIEnvironment, _R]: ... @overload def patch(self, *args, as_tuple: Literal[False] = ..., **kw) -> _R: ... @overload def patch(self, *args, as_tuple: bool, **kw) -> Any: ... @overload def post(self, *args, as_tuple: Literal[True], **kw) -> Tuple[WSGIEnvironment, _R]: ... @overload def post(self, *args, as_tuple: Literal[False] = ..., **kw) -> _R: ... @overload def post(self, *args, as_tuple: bool, **kw) -> Any: ... @overload def head(self, *args, as_tuple: Literal[True], **kw) -> Tuple[WSGIEnvironment, _R]: ... @overload def head(self, *args, as_tuple: Literal[False] = ..., **kw) -> _R: ... @overload def head(self, *args, as_tuple: bool, **kw) -> Any: ... @overload def put(self, *args, as_tuple: Literal[True], **kw) -> Tuple[WSGIEnvironment, _R]: ... @overload def put(self, *args, as_tuple: Literal[False] = ..., **kw) -> _R: ... @overload def put(self, *args, as_tuple: bool, **kw) -> Any: ... @overload def delete(self, *args, as_tuple: Literal[True], **kw) -> Tuple[WSGIEnvironment, _R]: ... @overload def delete(self, *args, as_tuple: Literal[False] = ..., **kw) -> _R: ... @overload def delete(self, *args, as_tuple: bool, **kw) -> Any: ... @overload def options(self, *args, as_tuple: Literal[True], **kw) -> Tuple[WSGIEnvironment, _R]: ... @overload def options(self, *args, as_tuple: Literal[False] = ..., **kw) -> _R: ... @overload def options(self, *args, as_tuple: bool, **kw) -> Any: ... @overload def trace(self, *args, as_tuple: Literal[True], **kw) -> Tuple[WSGIEnvironment, _R]: ... @overload def trace(self, *args, as_tuple: Literal[False] = ..., **kw) -> _R: ... @overload def trace(self, *args, as_tuple: bool, **kw) -> Any: ... def create_environ(*args, **kwargs): ... def run_wsgi_app(app, environ, buffered: bool = ...): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/werkzeug/testapp.pyi0000664000175000017500000000034200000000000026776 0ustar00davedave00000000000000from typing import Any from werkzeug.wrappers import BaseRequest as Request, BaseResponse as Response logo: Any TEMPLATE: Any def iter_sys_path(): ... def render_testapp(req): ... def test_app(environ, start_response): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/werkzeug/urls.pyi0000664000175000017500000000552200000000000026310 0ustar00davedave00000000000000from typing import Any, NamedTuple, Optional, Text class _URLTuple(NamedTuple): scheme: Any netloc: Any path: Any query: Any fragment: Any class BaseURL(_URLTuple): def replace(self, **kwargs): ... @property def host(self): ... @property def ascii_host(self): ... @property def port(self): ... @property def auth(self): ... @property def username(self): ... @property def raw_username(self): ... @property def password(self): ... @property def raw_password(self): ... def decode_query(self, *args, **kwargs): ... def join(self, *args, **kwargs): ... def to_url(self): ... def decode_netloc(self): ... def to_uri_tuple(self): ... def to_iri_tuple(self): ... def get_file_location(self, pathformat: Optional[Any] = ...): ... class URL(BaseURL): def encode_netloc(self): ... def encode(self, charset: Text = ..., errors: Text = ...): ... class BytesURL(BaseURL): def encode_netloc(self): ... def decode(self, charset: Text = ..., errors: Text = ...): ... def url_parse(url, scheme: Optional[Any] = ..., allow_fragments: bool = ...): ... def url_quote(string, charset: Text = ..., errors: Text = ..., safe: str = ..., unsafe: str = ...): ... def url_quote_plus(string, charset: Text = ..., errors: Text = ..., safe: str = ...): ... def url_unparse(components): ... def url_unquote(string, charset: Text = ..., errors: Text = ..., unsafe: str = ...): ... def url_unquote_plus(s, charset: Text = ..., errors: Text = ...): ... def url_fix(s, charset: Text = ...): ... def uri_to_iri(uri, charset: Text = ..., errors: Text = ...): ... def iri_to_uri(iri, charset: Text = ..., errors: Text = ..., safe_conversion: bool = ...): ... def url_decode( s, charset: Text = ..., decode_keys: bool = ..., include_empty: bool = ..., errors: Text = ..., separator: str = ..., cls: Optional[Any] = ..., ): ... def url_decode_stream( stream, charset: Text = ..., decode_keys: bool = ..., include_empty: bool = ..., errors: Text = ..., separator: str = ..., cls: Optional[Any] = ..., limit: Optional[Any] = ..., return_iterator: bool = ..., ): ... def url_encode( obj, charset: Text = ..., encode_keys: bool = ..., sort: bool = ..., key: Optional[Any] = ..., separator: bytes = ... ): ... def url_encode_stream( obj, stream: Optional[Any] = ..., charset: Text = ..., encode_keys: bool = ..., sort: bool = ..., key: Optional[Any] = ..., separator: bytes = ..., ): ... def url_join(base, url, allow_fragments: bool = ...): ... class Href: base: Any charset: Text sort: Any key: Any def __init__(self, base: str = ..., charset: Text = ..., sort: bool = ..., key: Optional[Any] = ...): ... def __getattr__(self, name): ... def __call__(self, *path, **query): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/werkzeug/useragents.pyi0000664000175000017500000000065700000000000027507 0ustar00davedave00000000000000from typing import Any, Optional class UserAgentParser: platforms: Any browsers: Any def __init__(self): ... def __call__(self, user_agent): ... class UserAgent: string: Any platform: Optional[str] browser: Optional[str] version: Optional[str] language: Optional[str] def __init__(self, environ_or_string): ... def to_header(self): ... def __nonzero__(self): ... __bool__: Any ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/werkzeug/utils.pyi0000664000175000017500000000365200000000000026465 0ustar00davedave00000000000000from typing import Any, Optional, Text, Type, TypeVar, overload from werkzeug._internal import _DictAccessorProperty from werkzeug.wrappers import Response class cached_property(property): __name__: Any __module__: Any __doc__: Any func: Any def __init__(self, func, name: Optional[Any] = ..., doc: Optional[Any] = ...): ... def __set__(self, obj, value): ... def __get__(self, obj, type: Optional[Any] = ...): ... class environ_property(_DictAccessorProperty): read_only: Any def lookup(self, obj): ... class header_property(_DictAccessorProperty): def lookup(self, obj): ... class HTMLBuilder: def __init__(self, dialect): ... def __call__(self, s): ... def __getattr__(self, tag): ... html: Any xhtml: Any def get_content_type(mimetype, charset): ... def format_string(string, context): ... def secure_filename(filename: Text) -> Text: ... def escape(s, quote: Optional[Any] = ...): ... def unescape(s): ... # 'redirect' returns a werkzeug Response, unless you give it # another Response type to use instead. _RC = TypeVar("_RC", bound=Response) @overload def redirect(location, code: int = ..., Response: None = ...) -> Response: ... @overload def redirect(location, code: int = ..., Response: Type[_RC] = ...) -> _RC: ... def append_slash_redirect(environ, code: int = ...): ... def import_string(import_name, silent: bool = ...): ... def find_modules(import_path, include_packages: bool = ..., recursive: bool = ...): ... def validate_arguments(func, args, kwargs, drop_extra: bool = ...): ... def bind_arguments(func, args, kwargs): ... class ArgumentValidationError(ValueError): missing: Any extra: Any extra_positional: Any def __init__(self, missing: Optional[Any] = ..., extra: Optional[Any] = ..., extra_positional: Optional[Any] = ...): ... class ImportStringError(ImportError): import_name: Any exception: Any def __init__(self, import_name, exception): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/werkzeug/wrappers.pyi0000664000175000017500000002163300000000000027167 0ustar00davedave00000000000000from _typeshed.wsgi import InputStream, WSGIEnvironment from datetime import datetime from typing import ( Any, Callable, Iterable, Iterator, Mapping, MutableMapping, Optional, Sequence, Text, Tuple, Type, TypeVar, Union, overload, ) from typing_extensions import Literal from .datastructures import ( Accept, Authorization, CharsetAccept, CombinedMultiDict, EnvironHeaders, Headers, HeaderSet, ImmutableMultiDict, ImmutableTypeConversionDict, LanguageAccept, MIMEAccept, MultiDict, ) from .useragents import UserAgent class BaseRequest: charset: str encoding_errors: str max_content_length: Optional[int] max_form_memory_size: int parameter_storage_class: Type[Any] list_storage_class: Type[Any] dict_storage_class: Type[Any] form_data_parser_class: Type[Any] trusted_hosts: Optional[Sequence[Text]] disable_data_descriptor: Any environ: WSGIEnvironment = ... shallow: Any def __init__(self, environ: WSGIEnvironment, populate_request: bool = ..., shallow: bool = ...) -> None: ... @property def url_charset(self) -> str: ... @classmethod def from_values(cls, *args, **kwargs) -> BaseRequest: ... @classmethod def application(cls, f): ... @property def want_form_data_parsed(self): ... def make_form_data_parser(self): ... def close(self) -> None: ... def __enter__(self): ... def __exit__(self, exc_type, exc_value, tb): ... @property def stream(self) -> InputStream: ... input_stream: InputStream args: ImmutableMultiDict[Any, Any] @property def data(self) -> bytes: ... @overload def get_data(self, cache: bool = ..., as_text: Literal[False] = ..., parse_form_data: bool = ...) -> bytes: ... @overload def get_data(self, cache: bool, as_text: Literal[True], parse_form_data: bool = ...) -> Text: ... @overload def get_data(self, *, as_text: Literal[True], parse_form_data: bool = ...) -> Text: ... @overload def get_data(self, cache: bool, as_text: bool, parse_form_data: bool = ...) -> Any: ... @overload def get_data(self, *, as_text: bool, parse_form_data: bool = ...) -> Any: ... form: ImmutableMultiDict[Any, Any] values: CombinedMultiDict[Any, Any] files: MultiDict[Any, Any] @property def cookies(self) -> ImmutableTypeConversionDict[str, str]: ... headers: EnvironHeaders path: Text full_path: Text script_root: Text url: Text base_url: Text url_root: Text host_url: Text host: Text query_string: bytes method: Text @property def access_route(self) -> Sequence[str]: ... @property def remote_addr(self) -> str: ... remote_user: Text scheme: str is_xhr: bool is_secure: bool is_multithread: bool is_multiprocess: bool is_run_once: bool _OnCloseT = TypeVar("_OnCloseT", bound=Callable[[], Any]) _SelfT = TypeVar("_SelfT", bound=BaseResponse) class BaseResponse: charset: str default_status: int default_mimetype: Optional[str] implicit_sequence_conversion: bool autocorrect_location_header: bool automatically_set_content_length: bool headers: Headers status_code: int status: str direct_passthrough: bool response: Iterable[bytes] def __init__( self, response: Optional[Union[str, bytes, bytearray, Iterable[str], Iterable[bytes]]] = ..., status: Optional[Union[Text, int]] = ..., headers: Optional[Union[Headers, Mapping[Text, Text], Sequence[Tuple[Text, Text]]]] = ..., mimetype: Optional[Text] = ..., content_type: Optional[Text] = ..., direct_passthrough: bool = ..., ) -> None: ... def call_on_close(self, func: _OnCloseT) -> _OnCloseT: ... @classmethod def force_type(cls: Type[_SelfT], response: object, environ: Optional[WSGIEnvironment] = ...) -> _SelfT: ... @classmethod def from_app(cls: Type[_SelfT], app: Any, environ: WSGIEnvironment, buffered: bool = ...) -> _SelfT: ... @overload def get_data(self, as_text: Literal[False] = ...) -> bytes: ... @overload def get_data(self, as_text: Literal[True]) -> Text: ... @overload def get_data(self, as_text: bool) -> Any: ... def set_data(self, value: Union[bytes, Text]) -> None: ... data: Any def calculate_content_length(self) -> Optional[int]: ... def make_sequence(self) -> None: ... def iter_encoded(self) -> Iterator[bytes]: ... def set_cookie( self, key: str, value: Union[str, bytes] = ..., max_age: Optional[int] = ..., expires: Optional[int] = ..., path: str = ..., domain: Optional[str] = ..., secure: bool = ..., httponly: bool = ..., samesite: Optional[str] = ..., ) -> None: ... def delete_cookie(self, key, path: str = ..., domain: Optional[Any] = ...): ... @property def is_streamed(self) -> bool: ... @property def is_sequence(self) -> bool: ... def close(self) -> None: ... def __enter__(self): ... def __exit__(self, exc_type, exc_value, tb): ... # The no_etag argument if fictional, but required for compatibility with # ETagResponseMixin def freeze(self, no_etag: bool = ...) -> None: ... def get_wsgi_headers(self, environ): ... def get_app_iter(self, environ): ... def get_wsgi_response(self, environ): ... def __call__(self, environ, start_response): ... class AcceptMixin(object): @property def accept_mimetypes(self) -> MIMEAccept: ... @property def accept_charsets(self) -> CharsetAccept: ... @property def accept_encodings(self) -> Accept: ... @property def accept_languages(self) -> LanguageAccept: ... class ETagRequestMixin: @property def cache_control(self): ... @property def if_match(self): ... @property def if_none_match(self): ... @property def if_modified_since(self): ... @property def if_unmodified_since(self): ... @property def if_range(self): ... @property def range(self): ... class UserAgentMixin: @property def user_agent(self) -> UserAgent: ... class AuthorizationMixin: @property def authorization(self) -> Optional[Authorization]: ... class StreamOnlyMixin: disable_data_descriptor: Any want_form_data_parsed: Any class ETagResponseMixin: @property def cache_control(self): ... status_code: Any def make_conditional(self, request_or_environ, accept_ranges: bool = ..., complete_length: Optional[Any] = ...): ... def add_etag(self, overwrite: bool = ..., weak: bool = ...): ... def set_etag(self, etag, weak: bool = ...): ... def get_etag(self): ... def freeze(self, no_etag: bool = ...) -> None: ... accept_ranges: Any content_range: Any class ResponseStream: mode: Any response: Any closed: Any def __init__(self, response): ... def write(self, value): ... def writelines(self, seq): ... def close(self): ... def flush(self): ... def isatty(self): ... @property def encoding(self): ... class ResponseStreamMixin: @property def stream(self) -> ResponseStream: ... class CommonRequestDescriptorsMixin: @property def content_type(self) -> Optional[str]: ... @property def content_length(self) -> Optional[int]: ... @property def content_encoding(self) -> Optional[str]: ... @property def content_md5(self) -> Optional[str]: ... @property def referrer(self) -> Optional[str]: ... @property def date(self) -> Optional[datetime]: ... @property def max_forwards(self) -> Optional[int]: ... @property def mimetype(self) -> str: ... @property def mimetype_params(self) -> Mapping[str, str]: ... @property def pragma(self) -> HeaderSet: ... class CommonResponseDescriptorsMixin: mimetype: Optional[str] = ... @property def mimetype_params(self) -> MutableMapping[str, str]: ... location: Optional[str] = ... age: Any = ... # get: Optional[datetime.timedelta] content_type: Optional[str] = ... content_length: Optional[int] = ... content_location: Optional[str] = ... content_encoding: Optional[str] = ... content_md5: Optional[str] = ... date: Any = ... # get: Optional[datetime.datetime] expires: Any = ... # get: Optional[datetime.datetime] last_modified: Any = ... # get: Optional[datetime.datetime] retry_after: Any = ... # get: Optional[datetime.datetime] vary: Optional[str] = ... content_language: Optional[str] = ... allow: Optional[str] = ... class WWWAuthenticateMixin: @property def www_authenticate(self): ... class Request(BaseRequest, AcceptMixin, ETagRequestMixin, UserAgentMixin, AuthorizationMixin, CommonRequestDescriptorsMixin): ... class PlainRequest(StreamOnlyMixin, Request): ... class Response(BaseResponse, ETagResponseMixin, ResponseStreamMixin, CommonResponseDescriptorsMixin, WWWAuthenticateMixin): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/werkzeug/wsgi.pyi0000664000175000017500000000572600000000000026302 0ustar00davedave00000000000000from _typeshed import SupportsRead from _typeshed.wsgi import InputStream, WSGIEnvironment from typing import Any, Iterable, Optional, Text from .middleware.dispatcher import DispatcherMiddleware as DispatcherMiddleware from .middleware.http_proxy import ProxyMiddleware as ProxyMiddleware from .middleware.shared_data import SharedDataMiddleware as SharedDataMiddleware def responder(f): ... def get_current_url( environ, root_only: bool = ..., strip_querystring: bool = ..., host_only: bool = ..., trusted_hosts: Optional[Any] = ... ): ... def host_is_trusted(hostname, trusted_list): ... def get_host(environ, trusted_hosts: Optional[Any] = ...): ... def get_content_length(environ: WSGIEnvironment) -> Optional[int]: ... def get_input_stream(environ: WSGIEnvironment, safe_fallback: bool = ...) -> InputStream: ... def get_query_string(environ): ... def get_path_info(environ, charset: Text = ..., errors: Text = ...): ... def get_script_name(environ, charset: Text = ..., errors: Text = ...): ... def pop_path_info(environ, charset: Text = ..., errors: Text = ...): ... def peek_path_info(environ, charset: Text = ..., errors: Text = ...): ... def extract_path_info( environ_or_baseurl, path_or_url, charset: Text = ..., errors: Text = ..., collapse_http_schemes: bool = ... ): ... class ClosingIterator: def __init__(self, iterable, callbacks: Optional[Any] = ...): ... def __iter__(self): ... def __next__(self): ... def close(self): ... def wrap_file(environ: WSGIEnvironment, file: SupportsRead[bytes], buffer_size: int = ...) -> Iterable[bytes]: ... class FileWrapper: file: SupportsRead[bytes] buffer_size: int def __init__(self, file: SupportsRead[bytes], buffer_size: int = ...) -> None: ... def close(self) -> None: ... def seekable(self) -> bool: ... def seek(self, offset: int, whence: int = ...) -> None: ... def tell(self) -> Optional[int]: ... def __iter__(self) -> FileWrapper: ... def __next__(self) -> bytes: ... class _RangeWrapper: iterable: Any byte_range: Any start_byte: Any end_byte: Any read_length: Any seekable: Any end_reached: Any def __init__(self, iterable, start_byte: int = ..., byte_range: Optional[Any] = ...): ... def __iter__(self): ... def __next__(self): ... def close(self): ... def make_line_iter(stream, limit: Optional[Any] = ..., buffer_size=..., cap_at_buffer: bool = ...): ... def make_chunk_iter(stream, separator, limit: Optional[Any] = ..., buffer_size=..., cap_at_buffer: bool = ...): ... class LimitedStream: limit: Any def __init__(self, stream, limit): ... def __iter__(self): ... @property def is_exhausted(self): ... def on_exhausted(self): ... def on_disconnect(self): ... def exhaust(self, chunk_size=...): ... def read(self, size: Optional[Any] = ...): ... def readline(self, size: Optional[Any] = ...): ... def readlines(self, size: Optional[Any] = ...): ... def tell(self): ... def __next__(self): ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4623795 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/yaml/0000775000175000017500000000000000000000000023673 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/yaml/__init__.pyi0000664000175000017500000001463700000000000026170 0ustar00davedave00000000000000import sys from typing import IO, Any, Iterator, Optional, Sequence, Text, Union, overload from yaml.dumper import * # noqa: F403 from yaml.error import * # noqa: F403 from yaml.events import * # noqa: F403 from yaml.loader import * # noqa: F403 from yaml.nodes import * # noqa: F403 from yaml.tokens import * # noqa: F403 from . import resolver as resolver # Help mypy a bit; this is implied by loader and dumper from .cyaml import * if sys.version_info < (3,): _Str = Union[Text, str] else: _Str = str # FIXME: the functions really return py2:unicode/py3:str if encoding is None, otherwise py2:str/py3:bytes. Waiting for python/mypy#5621 _Yaml = Any __with_libyaml__: Any __version__: str def scan(stream, Loader=...): ... def parse(stream, Loader=...): ... def compose(stream, Loader=...): ... def compose_all(stream, Loader=...): ... def load(stream: Union[bytes, IO[bytes], Text, IO[Text]], Loader=...) -> Any: ... def load_all(stream: Union[bytes, IO[bytes], Text, IO[Text]], Loader=...) -> Iterator[Any]: ... def full_load(stream: Union[bytes, IO[bytes], Text, IO[Text]]) -> Any: ... def full_load_all(stream: Union[bytes, IO[bytes], Text, IO[Text]]) -> Iterator[Any]: ... def safe_load(stream: Union[bytes, IO[bytes], Text, IO[Text]]) -> Any: ... def safe_load_all(stream: Union[bytes, IO[bytes], Text, IO[Text]]) -> Iterator[Any]: ... def unsafe_load(stream: Union[bytes, IO[bytes], Text, IO[Text]]) -> Any: ... def unsafe_load_all(stream: Union[bytes, IO[bytes], Text, IO[Text]]) -> Iterator[Any]: ... def emit(events, stream=..., Dumper=..., canonical=..., indent=..., width=..., allow_unicode=..., line_break=...): ... @overload def serialize_all( nodes, stream: IO[str], Dumper=..., canonical=..., indent=..., width=..., allow_unicode=..., line_break=..., encoding=..., explicit_start=..., explicit_end=..., version=..., tags=..., ) -> None: ... @overload def serialize_all( nodes, stream: None = ..., Dumper=..., canonical=..., indent=..., width=..., allow_unicode=..., line_break=..., encoding: Optional[_Str] = ..., explicit_start=..., explicit_end=..., version=..., tags=..., ) -> _Yaml: ... @overload def serialize( node, stream: IO[str], Dumper=..., *, canonical=..., indent=..., width=..., allow_unicode=..., line_break=..., encoding=..., explicit_start=..., explicit_end=..., version=..., tags=..., ) -> None: ... @overload def serialize( node, stream: None = ..., Dumper=..., *, canonical=..., indent=..., width=..., allow_unicode=..., line_break=..., encoding: Optional[_Str] = ..., explicit_start=..., explicit_end=..., version=..., tags=..., ) -> _Yaml: ... @overload def dump_all( documents: Sequence[Any], stream: IO[str], Dumper=..., default_style=..., default_flow_style=..., canonical=..., indent=..., width=..., allow_unicode=..., line_break=..., encoding=..., explicit_start=..., explicit_end=..., version=..., tags=..., sort_keys: bool = ..., ) -> None: ... @overload def dump_all( documents: Sequence[Any], stream: None = ..., Dumper=..., default_style=..., default_flow_style=..., canonical=..., indent=..., width=..., allow_unicode=..., line_break=..., encoding: Optional[_Str] = ..., explicit_start=..., explicit_end=..., version=..., tags=..., sort_keys: bool = ..., ) -> _Yaml: ... @overload def dump( data: Any, stream: IO[str], Dumper=..., *, default_style=..., default_flow_style=..., canonical=..., indent=..., width=..., allow_unicode=..., line_break=..., encoding=..., explicit_start=..., explicit_end=..., version=..., tags=..., sort_keys: bool = ..., ) -> None: ... @overload def dump( data: Any, stream: None = ..., Dumper=..., *, default_style=..., default_flow_style=..., canonical=..., indent=..., width=..., allow_unicode=..., line_break=..., encoding: Optional[_Str] = ..., explicit_start=..., explicit_end=..., version=..., tags=..., sort_keys: bool = ..., ) -> _Yaml: ... @overload def safe_dump_all( documents: Sequence[Any], stream: IO[str], *, default_style=..., default_flow_style=..., canonical=..., indent=..., width=..., allow_unicode=..., line_break=..., encoding=..., explicit_start=..., explicit_end=..., version=..., tags=..., sort_keys: bool = ..., ) -> None: ... @overload def safe_dump_all( documents: Sequence[Any], stream: None = ..., *, default_style=..., default_flow_style=..., canonical=..., indent=..., width=..., allow_unicode=..., line_break=..., encoding: Optional[_Str] = ..., explicit_start=..., explicit_end=..., version=..., tags=..., sort_keys: bool = ..., ) -> _Yaml: ... @overload def safe_dump( data: Any, stream: IO[str], *, default_style=..., default_flow_style=..., canonical=..., indent=..., width=..., allow_unicode=..., line_break=..., encoding=..., explicit_start=..., explicit_end=..., version=..., tags=..., sort_keys: bool = ..., ) -> None: ... @overload def safe_dump( data: Any, stream: None = ..., *, default_style=..., default_flow_style=..., canonical=..., indent=..., width=..., allow_unicode=..., line_break=..., encoding: Optional[_Str] = ..., explicit_start=..., explicit_end=..., version=..., tags=..., sort_keys: bool = ..., ) -> _Yaml: ... def add_implicit_resolver(tag, regexp, first=..., Loader=..., Dumper=...): ... def add_path_resolver(tag, path, kind=..., Loader=..., Dumper=...): ... def add_constructor(tag, constructor, Loader=...): ... def add_multi_constructor(tag_prefix, multi_constructor, Loader=...): ... def add_representer(data_type, representer, Dumper=...): ... def add_multi_representer(data_type, multi_representer, Dumper=...): ... class YAMLObjectMetaclass(type): def __init__(self, name, bases, kwds) -> None: ... class YAMLObject(metaclass=YAMLObjectMetaclass): yaml_loader: Any yaml_dumper: Any yaml_tag: Any yaml_flow_style: Any @classmethod def from_yaml(cls, loader, node): ... @classmethod def to_yaml(cls, dumper, data): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/yaml/composer.pyi0000664000175000017500000000076000000000000026250 0ustar00davedave00000000000000from typing import Any from yaml.error import MarkedYAMLError class ComposerError(MarkedYAMLError): ... class Composer: anchors: Any def __init__(self) -> None: ... def check_node(self): ... def get_node(self): ... def get_single_node(self): ... def compose_document(self): ... def compose_node(self, parent, index): ... def compose_scalar_node(self, anchor): ... def compose_sequence_node(self, anchor): ... def compose_mapping_node(self, anchor): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/yaml/constructor.pyi0000664000175000017500000000702300000000000027005 0ustar00davedave00000000000000import sys from typing import Any from yaml.error import MarkedYAMLError class ConstructorError(MarkedYAMLError): ... class BaseConstructor: yaml_constructors: Any yaml_multi_constructors: Any constructed_objects: Any recursive_objects: Any state_generators: Any deep_construct: Any def __init__(self) -> None: ... def check_data(self): ... def get_data(self): ... def get_single_data(self): ... def construct_document(self, node): ... def construct_object(self, node, deep=...): ... def construct_scalar(self, node): ... def construct_sequence(self, node, deep=...): ... def construct_mapping(self, node, deep=...): ... def construct_pairs(self, node, deep=...): ... @classmethod def add_constructor(cls, tag, constructor): ... @classmethod def add_multi_constructor(cls, tag_prefix, multi_constructor): ... class SafeConstructor(BaseConstructor): def construct_scalar(self, node): ... def flatten_mapping(self, node): ... def construct_mapping(self, node, deep=...): ... def construct_yaml_null(self, node): ... bool_values: Any def construct_yaml_bool(self, node): ... def construct_yaml_int(self, node): ... inf_value: Any nan_value: Any def construct_yaml_float(self, node): ... def construct_yaml_binary(self, node): ... timestamp_regexp: Any def construct_yaml_timestamp(self, node): ... def construct_yaml_omap(self, node): ... def construct_yaml_pairs(self, node): ... def construct_yaml_set(self, node): ... def construct_yaml_str(self, node): ... def construct_yaml_seq(self, node): ... def construct_yaml_map(self, node): ... def construct_yaml_object(self, node, cls): ... def construct_undefined(self, node): ... class FullConstructor(SafeConstructor): def construct_python_str(self, node): ... def construct_python_unicode(self, node): ... def construct_python_bytes(self, node): ... def construct_python_long(self, node): ... def construct_python_complex(self, node): ... def construct_python_tuple(self, node): ... def find_python_module(self, name, mark, unsafe=...): ... def find_python_name(self, name, mark, unsafe=...): ... def construct_python_name(self, suffix, node): ... def construct_python_module(self, suffix, node): ... def make_python_instance(self, suffix, node, args=..., kwds=..., newobj=..., unsafe=...): ... def set_python_instance_state(self, instance, state): ... def construct_python_object(self, suffix, node): ... def construct_python_object_apply(self, suffix, node, newobj=...): ... def construct_python_object_new(self, suffix, node): ... class Constructor(SafeConstructor): def construct_python_str(self, node): ... def construct_python_unicode(self, node): ... def construct_python_long(self, node): ... def construct_python_complex(self, node): ... def construct_python_tuple(self, node): ... def find_python_module(self, name, mark): ... def find_python_name(self, name, mark): ... def construct_python_name(self, suffix, node): ... def construct_python_module(self, suffix, node): ... if sys.version_info < (3, 0): class classobj: ... def make_python_instance(self, suffix, node, args=..., kwds=..., newobj=...): ... def set_python_instance_state(self, instance, state): ... def construct_python_object(self, suffix, node): ... def construct_python_object_apply(self, suffix, node, newobj=...): ... def construct_python_object_new(self, suffix, node): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/yaml/cyaml.pyi0000664000175000017500000000436400000000000025532 0ustar00davedave00000000000000from _typeshed import SupportsRead from typing import IO, Any, Mapping, Optional, Sequence, Text, Union from yaml.constructor import BaseConstructor, Constructor, SafeConstructor from yaml.representer import BaseRepresenter, Representer, SafeRepresenter from yaml.resolver import BaseResolver, Resolver from yaml.serializer import Serializer _Readable = SupportsRead[Union[Text, bytes]] class CParser: def __init__(self, stream: Union[str, bytes, _Readable]) -> None: ... class CBaseLoader(CParser, BaseConstructor, BaseResolver): def __init__(self, stream: Union[str, bytes, _Readable]) -> None: ... class CLoader(CParser, SafeConstructor, Resolver): def __init__(self, stream: Union[str, bytes, _Readable]) -> None: ... class CSafeLoader(CParser, SafeConstructor, Resolver): def __init__(self, stream: Union[str, bytes, _Readable]) -> None: ... class CDangerLoader(CParser, Constructor, Resolver): ... # undocumented class CEmitter(object): def __init__( self, stream: IO[Any], canonical: Optional[Any] = ..., indent: Optional[int] = ..., width: Optional[int] = ..., allow_unicode: Optional[Any] = ..., line_break: Optional[str] = ..., encoding: Optional[Text] = ..., explicit_start: Optional[Any] = ..., explicit_end: Optional[Any] = ..., version: Optional[Sequence[int]] = ..., tags: Optional[Mapping[Text, Text]] = ..., ) -> None: ... class CBaseDumper(CEmitter, BaseRepresenter, BaseResolver): def __init__( self, stream: IO[Any], default_style: Optional[str] = ..., default_flow_style: Optional[bool] = ..., canonical: Optional[Any] = ..., indent: Optional[int] = ..., width: Optional[int] = ..., allow_unicode: Optional[Any] = ..., line_break: Optional[str] = ..., encoding: Optional[Text] = ..., explicit_start: Optional[Any] = ..., explicit_end: Optional[Any] = ..., version: Optional[Sequence[int]] = ..., tags: Optional[Mapping[Text, Text]] = ..., ) -> None: ... class CDumper(CEmitter, SafeRepresenter, Resolver): ... CSafeDumper = CDumper class CDangerDumper(CEmitter, Serializer, Representer, Resolver): ... # undocumented ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/yaml/dumper.pyi0000664000175000017500000000301400000000000025710 0ustar00davedave00000000000000from yaml.emitter import Emitter from yaml.representer import BaseRepresenter, Representer, SafeRepresenter from yaml.resolver import BaseResolver, Resolver from yaml.serializer import Serializer class BaseDumper(Emitter, Serializer, BaseRepresenter, BaseResolver): def __init__( self, stream, default_style=..., default_flow_style=..., canonical=..., indent=..., width=..., allow_unicode=..., line_break=..., encoding=..., explicit_start=..., explicit_end=..., version=..., tags=..., sort_keys: bool = ..., ) -> None: ... class SafeDumper(Emitter, Serializer, SafeRepresenter, Resolver): def __init__( self, stream, default_style=..., default_flow_style=..., canonical=..., indent=..., width=..., allow_unicode=..., line_break=..., encoding=..., explicit_start=..., explicit_end=..., version=..., tags=..., sort_keys: bool = ..., ) -> None: ... class Dumper(Emitter, Serializer, Representer, Resolver): def __init__( self, stream, default_style=..., default_flow_style=..., canonical=..., indent=..., width=..., allow_unicode=..., line_break=..., encoding=..., explicit_start=..., explicit_end=..., version=..., tags=..., sort_keys: bool = ..., ) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/yaml/emitter.pyi0000664000175000017500000000733200000000000026074 0ustar00davedave00000000000000from typing import Any from yaml.error import YAMLError class EmitterError(YAMLError): ... class ScalarAnalysis: scalar: Any empty: Any multiline: Any allow_flow_plain: Any allow_block_plain: Any allow_single_quoted: Any allow_double_quoted: Any allow_block: Any def __init__( self, scalar, empty, multiline, allow_flow_plain, allow_block_plain, allow_single_quoted, allow_double_quoted, allow_block ) -> None: ... class Emitter: DEFAULT_TAG_PREFIXES: Any stream: Any encoding: Any states: Any state: Any events: Any event: Any indents: Any indent: Any flow_level: Any root_context: Any sequence_context: Any mapping_context: Any simple_key_context: Any line: Any column: Any whitespace: Any indention: Any open_ended: Any canonical: Any allow_unicode: Any best_indent: Any best_width: Any best_line_break: Any tag_prefixes: Any prepared_anchor: Any prepared_tag: Any analysis: Any style: Any def __init__(self, stream, canonical=..., indent=..., width=..., allow_unicode=..., line_break=...) -> None: ... def dispose(self): ... def emit(self, event): ... def need_more_events(self): ... def need_events(self, count): ... def increase_indent(self, flow=..., indentless=...): ... def expect_stream_start(self): ... def expect_nothing(self): ... def expect_first_document_start(self): ... def expect_document_start(self, first=...): ... def expect_document_end(self): ... def expect_document_root(self): ... def expect_node(self, root=..., sequence=..., mapping=..., simple_key=...): ... def expect_alias(self): ... def expect_scalar(self): ... def expect_flow_sequence(self): ... def expect_first_flow_sequence_item(self): ... def expect_flow_sequence_item(self): ... def expect_flow_mapping(self): ... def expect_first_flow_mapping_key(self): ... def expect_flow_mapping_key(self): ... def expect_flow_mapping_simple_value(self): ... def expect_flow_mapping_value(self): ... def expect_block_sequence(self): ... def expect_first_block_sequence_item(self): ... def expect_block_sequence_item(self, first=...): ... def expect_block_mapping(self): ... def expect_first_block_mapping_key(self): ... def expect_block_mapping_key(self, first=...): ... def expect_block_mapping_simple_value(self): ... def expect_block_mapping_value(self): ... def check_empty_sequence(self): ... def check_empty_mapping(self): ... def check_empty_document(self): ... def check_simple_key(self): ... def process_anchor(self, indicator): ... def process_tag(self): ... def choose_scalar_style(self): ... def process_scalar(self): ... def prepare_version(self, version): ... def prepare_tag_handle(self, handle): ... def prepare_tag_prefix(self, prefix): ... def prepare_tag(self, tag): ... def prepare_anchor(self, anchor): ... def analyze_scalar(self, scalar): ... def flush_stream(self): ... def write_stream_start(self): ... def write_stream_end(self): ... def write_indicator(self, indicator, need_whitespace, whitespace=..., indention=...): ... def write_indent(self): ... def write_line_break(self, data=...): ... def write_version_directive(self, version_text): ... def write_tag_directive(self, handle_text, prefix_text): ... def write_single_quoted(self, text, split=...): ... ESCAPE_REPLACEMENTS: Any def write_double_quoted(self, text, split=...): ... def determine_block_hints(self, text): ... def write_folded(self, text): ... def write_literal(self, text): ... def write_plain(self, text, split=...): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/yaml/error.pyi0000664000175000017500000000102700000000000025547 0ustar00davedave00000000000000from typing import Any class Mark: name: Any index: Any line: Any column: Any buffer: Any pointer: Any def __init__(self, name, index, line, column, buffer, pointer) -> None: ... def get_snippet(self, indent=..., max_length=...): ... class YAMLError(Exception): ... class MarkedYAMLError(YAMLError): context: Any context_mark: Any problem: Any problem_mark: Any note: Any def __init__(self, context=..., context_mark=..., problem=..., problem_mark=..., note=...) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/yaml/events.pyi0000664000175000017500000000317600000000000025731 0ustar00davedave00000000000000from typing import Any class Event: start_mark: Any end_mark: Any def __init__(self, start_mark=..., end_mark=...) -> None: ... class NodeEvent(Event): anchor: Any start_mark: Any end_mark: Any def __init__(self, anchor, start_mark=..., end_mark=...) -> None: ... class CollectionStartEvent(NodeEvent): anchor: Any tag: Any implicit: Any start_mark: Any end_mark: Any flow_style: Any def __init__(self, anchor, tag, implicit, start_mark=..., end_mark=..., flow_style=...) -> None: ... class CollectionEndEvent(Event): ... class StreamStartEvent(Event): start_mark: Any end_mark: Any encoding: Any def __init__(self, start_mark=..., end_mark=..., encoding=...) -> None: ... class StreamEndEvent(Event): ... class DocumentStartEvent(Event): start_mark: Any end_mark: Any explicit: Any version: Any tags: Any def __init__(self, start_mark=..., end_mark=..., explicit=..., version=..., tags=...) -> None: ... class DocumentEndEvent(Event): start_mark: Any end_mark: Any explicit: Any def __init__(self, start_mark=..., end_mark=..., explicit=...) -> None: ... class AliasEvent(NodeEvent): ... class ScalarEvent(NodeEvent): anchor: Any tag: Any implicit: Any value: Any start_mark: Any end_mark: Any style: Any def __init__(self, anchor, tag, implicit, value, start_mark=..., end_mark=..., style=...) -> None: ... class SequenceStartEvent(CollectionStartEvent): ... class SequenceEndEvent(CollectionEndEvent): ... class MappingStartEvent(CollectionStartEvent): ... class MappingEndEvent(CollectionEndEvent): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/yaml/loader.pyi0000664000175000017500000000137700000000000025674 0ustar00davedave00000000000000from yaml.composer import Composer from yaml.constructor import BaseConstructor, Constructor, FullConstructor, SafeConstructor from yaml.parser import Parser from yaml.reader import Reader from yaml.resolver import BaseResolver, Resolver from yaml.scanner import Scanner class BaseLoader(Reader, Scanner, Parser, Composer, BaseConstructor, BaseResolver): def __init__(self, stream) -> None: ... class FullLoader(Reader, Scanner, Parser, Composer, FullConstructor, Resolver): def __init__(self, stream) -> None: ... class SafeLoader(Reader, Scanner, Parser, Composer, SafeConstructor, Resolver): def __init__(self, stream) -> None: ... class Loader(Reader, Scanner, Parser, Composer, Constructor, Resolver): def __init__(self, stream) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/yaml/nodes.pyi0000664000175000017500000000125500000000000025531 0ustar00davedave00000000000000from typing import Any class Node: tag: Any value: Any start_mark: Any end_mark: Any def __init__(self, tag, value, start_mark, end_mark) -> None: ... class ScalarNode(Node): id: Any tag: Any value: Any start_mark: Any end_mark: Any style: Any def __init__(self, tag, value, start_mark=..., end_mark=..., style=...) -> None: ... class CollectionNode(Node): tag: Any value: Any start_mark: Any end_mark: Any flow_style: Any def __init__(self, tag, value, start_mark=..., end_mark=..., flow_style=...) -> None: ... class SequenceNode(CollectionNode): id: Any class MappingNode(CollectionNode): id: Any ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/yaml/parser.pyi0000664000175000017500000000320000000000000025705 0ustar00davedave00000000000000from typing import Any from yaml.error import MarkedYAMLError class ParserError(MarkedYAMLError): ... class Parser: DEFAULT_TAGS: Any current_event: Any yaml_version: Any tag_handles: Any states: Any marks: Any state: Any def __init__(self) -> None: ... def dispose(self): ... def check_event(self, *choices): ... def peek_event(self): ... def get_event(self): ... def parse_stream_start(self): ... def parse_implicit_document_start(self): ... def parse_document_start(self): ... def parse_document_end(self): ... def parse_document_content(self): ... def process_directives(self): ... def parse_block_node(self): ... def parse_flow_node(self): ... def parse_block_node_or_indentless_sequence(self): ... def parse_node(self, block=..., indentless_sequence=...): ... def parse_block_sequence_first_entry(self): ... def parse_block_sequence_entry(self): ... def parse_indentless_sequence_entry(self): ... def parse_block_mapping_first_key(self): ... def parse_block_mapping_key(self): ... def parse_block_mapping_value(self): ... def parse_flow_sequence_first_entry(self): ... def parse_flow_sequence_entry(self, first=...): ... def parse_flow_sequence_entry_mapping_key(self): ... def parse_flow_sequence_entry_mapping_value(self): ... def parse_flow_sequence_entry_mapping_end(self): ... def parse_flow_mapping_first_key(self): ... def parse_flow_mapping_key(self, first=...): ... def parse_flow_mapping_value(self): ... def parse_flow_mapping_empty_value(self): ... def process_empty_scalar(self, mark): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/yaml/reader.pyi0000664000175000017500000000150000000000000025654 0ustar00davedave00000000000000from typing import Any from yaml.error import YAMLError class ReaderError(YAMLError): name: Any character: Any position: Any encoding: Any reason: Any def __init__(self, name, position, character, encoding, reason) -> None: ... class Reader: name: Any stream: Any stream_pointer: Any eof: Any buffer: Any pointer: Any raw_buffer: Any raw_decode: Any encoding: Any index: Any line: Any column: Any def __init__(self, stream) -> None: ... def peek(self, index=...): ... def prefix(self, length=...): ... def forward(self, length=...): ... def get_mark(self): ... def determine_encoding(self): ... NON_PRINTABLE: Any def check_printable(self, data): ... def update(self, length): ... def update_raw(self, size=...): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/yaml/representer.pyi0000664000175000017500000000421100000000000026752 0ustar00davedave00000000000000import sys from typing import Any from yaml.error import YAMLError class RepresenterError(YAMLError): ... class BaseRepresenter: yaml_representers: Any yaml_multi_representers: Any default_style: Any default_flow_style: Any sort_keys: bool represented_objects: Any object_keeper: Any alias_key: Any def __init__(self, default_style=..., default_flow_style=..., sort_keys: bool = ...) -> None: ... def represent(self, data): ... if sys.version_info < (3, 0): def get_classobj_bases(self, cls): ... def represent_data(self, data): ... @classmethod def add_representer(cls, data_type, representer): ... @classmethod def add_multi_representer(cls, data_type, representer): ... def represent_scalar(self, tag, value, style=...): ... def represent_sequence(self, tag, sequence, flow_style=...): ... def represent_mapping(self, tag, mapping, flow_style=...): ... def ignore_aliases(self, data): ... class SafeRepresenter(BaseRepresenter): def ignore_aliases(self, data): ... def represent_none(self, data): ... def represent_str(self, data): ... if sys.version_info < (3, 0): def represent_unicode(self, data): ... def represent_long(self, data): ... def represent_bool(self, data): ... def represent_int(self, data): ... inf_value: Any def represent_float(self, data): ... def represent_list(self, data): ... def represent_dict(self, data): ... def represent_set(self, data): ... def represent_date(self, data): ... def represent_datetime(self, data): ... def represent_yaml_object(self, tag, data, cls, flow_style=...): ... def represent_undefined(self, data): ... class Representer(SafeRepresenter): def represent_str(self, data): ... if sys.version_info < (3, 0): def represent_unicode(self, data): ... def represent_long(self, data): ... def represent_instance(self, data): ... def represent_complex(self, data): ... def represent_tuple(self, data): ... def represent_name(self, data): ... def represent_module(self, data): ... def represent_object(self, data): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/yaml/resolver.pyi0000664000175000017500000000142200000000000026256 0ustar00davedave00000000000000from typing import Any from yaml.error import YAMLError class ResolverError(YAMLError): ... class BaseResolver: DEFAULT_SCALAR_TAG: Any DEFAULT_SEQUENCE_TAG: Any DEFAULT_MAPPING_TAG: Any yaml_implicit_resolvers: Any yaml_path_resolvers: Any resolver_exact_paths: Any resolver_prefix_paths: Any def __init__(self) -> None: ... @classmethod def add_implicit_resolver(cls, tag, regexp, first): ... @classmethod def add_path_resolver(cls, tag, path, kind=...): ... def descend_resolver(self, current_node, current_index): ... def ascend_resolver(self): ... def check_resolver_prefix(self, depth, path, kind, current_node, current_index): ... def resolve(self, kind, value, implicit): ... class Resolver(BaseResolver): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/yaml/scanner.pyi0000664000175000017500000000676500000000000026065 0ustar00davedave00000000000000from typing import Any from yaml.error import MarkedYAMLError class ScannerError(MarkedYAMLError): ... class SimpleKey: token_number: Any required: Any index: Any line: Any column: Any mark: Any def __init__(self, token_number, required, index, line, column, mark) -> None: ... class Scanner: done: Any flow_level: Any tokens: Any tokens_taken: Any indent: Any indents: Any allow_simple_key: Any possible_simple_keys: Any def __init__(self) -> None: ... def check_token(self, *choices): ... def peek_token(self): ... def get_token(self): ... def need_more_tokens(self): ... def fetch_more_tokens(self): ... def next_possible_simple_key(self): ... def stale_possible_simple_keys(self): ... def save_possible_simple_key(self): ... def remove_possible_simple_key(self): ... def unwind_indent(self, column): ... def add_indent(self, column): ... def fetch_stream_start(self): ... def fetch_stream_end(self): ... def fetch_directive(self): ... def fetch_document_start(self): ... def fetch_document_end(self): ... def fetch_document_indicator(self, TokenClass): ... def fetch_flow_sequence_start(self): ... def fetch_flow_mapping_start(self): ... def fetch_flow_collection_start(self, TokenClass): ... def fetch_flow_sequence_end(self): ... def fetch_flow_mapping_end(self): ... def fetch_flow_collection_end(self, TokenClass): ... def fetch_flow_entry(self): ... def fetch_block_entry(self): ... def fetch_key(self): ... def fetch_value(self): ... def fetch_alias(self): ... def fetch_anchor(self): ... def fetch_tag(self): ... def fetch_literal(self): ... def fetch_folded(self): ... def fetch_block_scalar(self, style): ... def fetch_single(self): ... def fetch_double(self): ... def fetch_flow_scalar(self, style): ... def fetch_plain(self): ... def check_directive(self): ... def check_document_start(self): ... def check_document_end(self): ... def check_block_entry(self): ... def check_key(self): ... def check_value(self): ... def check_plain(self): ... def scan_to_next_token(self): ... def scan_directive(self): ... def scan_directive_name(self, start_mark): ... def scan_yaml_directive_value(self, start_mark): ... def scan_yaml_directive_number(self, start_mark): ... def scan_tag_directive_value(self, start_mark): ... def scan_tag_directive_handle(self, start_mark): ... def scan_tag_directive_prefix(self, start_mark): ... def scan_directive_ignored_line(self, start_mark): ... def scan_anchor(self, TokenClass): ... def scan_tag(self): ... def scan_block_scalar(self, style): ... def scan_block_scalar_indicators(self, start_mark): ... def scan_block_scalar_ignored_line(self, start_mark): ... def scan_block_scalar_indentation(self): ... def scan_block_scalar_breaks(self, indent): ... def scan_flow_scalar(self, style): ... ESCAPE_REPLACEMENTS: Any ESCAPE_CODES: Any def scan_flow_scalar_non_spaces(self, double, start_mark): ... def scan_flow_scalar_spaces(self, double, start_mark): ... def scan_flow_scalar_breaks(self, double, start_mark): ... def scan_plain(self): ... def scan_plain_spaces(self, indent, start_mark): ... def scan_tag_handle(self, name, start_mark): ... def scan_tag_uri(self, name, start_mark): ... def scan_uri_escapes(self, name, start_mark): ... def scan_line_break(self): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/yaml/serializer.pyi0000664000175000017500000000123200000000000026565 0ustar00davedave00000000000000from typing import Any from yaml.error import YAMLError class SerializerError(YAMLError): ... class Serializer: ANCHOR_TEMPLATE: Any use_encoding: Any use_explicit_start: Any use_explicit_end: Any use_version: Any use_tags: Any serialized_nodes: Any anchors: Any last_anchor_id: Any closed: Any def __init__(self, encoding=..., explicit_start=..., explicit_end=..., version=..., tags=...) -> None: ... def open(self): ... def close(self): ... def serialize(self, node): ... def anchor_node(self, node): ... def generate_anchor(self, node): ... def serialize_node(self, node, parent, index): ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/2and3/yaml/tokens.pyi0000664000175000017500000000340000000000000025716 0ustar00davedave00000000000000from typing import Any class Token: start_mark: Any end_mark: Any def __init__(self, start_mark, end_mark) -> None: ... class DirectiveToken(Token): id: Any name: Any value: Any start_mark: Any end_mark: Any def __init__(self, name, value, start_mark, end_mark) -> None: ... class DocumentStartToken(Token): id: Any class DocumentEndToken(Token): id: Any class StreamStartToken(Token): id: Any start_mark: Any end_mark: Any encoding: Any def __init__(self, start_mark=..., end_mark=..., encoding=...) -> None: ... class StreamEndToken(Token): id: Any class BlockSequenceStartToken(Token): id: Any class BlockMappingStartToken(Token): id: Any class BlockEndToken(Token): id: Any class FlowSequenceStartToken(Token): id: Any class FlowMappingStartToken(Token): id: Any class FlowSequenceEndToken(Token): id: Any class FlowMappingEndToken(Token): id: Any class KeyToken(Token): id: Any class ValueToken(Token): id: Any class BlockEntryToken(Token): id: Any class FlowEntryToken(Token): id: Any class AliasToken(Token): id: Any value: Any start_mark: Any end_mark: Any def __init__(self, value, start_mark, end_mark) -> None: ... class AnchorToken(Token): id: Any value: Any start_mark: Any end_mark: Any def __init__(self, value, start_mark, end_mark) -> None: ... class TagToken(Token): id: Any value: Any start_mark: Any end_mark: Any def __init__(self, value, start_mark, end_mark) -> None: ... class ScalarToken(Token): id: Any value: Any plain: Any start_mark: Any end_mark: Any style: Any def __init__(self, value, plain, start_mark, end_mark, style=...) -> None: ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4623795 jedi-0.19.1/jedi/third_party/typeshed/third_party/3/0000775000175000017500000000000000000000000022164 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4623795 jedi-0.19.1/jedi/third_party/typeshed/third_party/3/aiofiles/0000775000175000017500000000000000000000000023757 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/3/aiofiles/__init__.pyi0000664000175000017500000000004500000000000026240 0ustar00davedave00000000000000from .threadpool import open as open ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/3/aiofiles/base.pyi0000664000175000017500000000272200000000000025417 0ustar00davedave00000000000000from types import CodeType, FrameType, TracebackType, coroutine from typing import Any, Coroutine, Generator, Generic, Iterator, Optional, Type, TypeVar, Union _T = TypeVar("_T") _T_co = TypeVar("_T_co", covariant=True) _V_co = TypeVar("_V_co", covariant=True) _T_contra = TypeVar("_T_contra", contravariant=True) class AsyncBase(Generic[_T]): def __init__(self, file: str, loop: Any, executor: Any) -> None: ... async def __aiter__(self) -> Iterator[_T]: ... async def __anext__(self) -> _T: ... class AiofilesContextManager(Generic[_T_co, _T_contra, _V_co]): def __init__(self, coro: Coroutine[_T_co, _T_contra, _V_co]) -> None: ... def send(self, value: _T_contra) -> _T_co: ... def throw( self, typ: Type[BaseException], val: Union[BaseException, object] = ..., tb: Optional[TracebackType] = ... ) -> _T_co: ... def close(self) -> None: ... @property def gi_frame(self) -> FrameType: ... @property def gi_running(self) -> bool: ... @property def gi_code(self) -> CodeType: ... def __next__(self) -> _T_co: ... @coroutine def __iter__(self) -> Iterator[Coroutine[_T_co, _T_contra, _V_co]]: ... def __await__(self) -> Generator[Any, None, _V_co]: ... async def __anext__(self) -> _V_co: ... async def __aenter__(self) -> _V_co: ... async def __aexit__( self, exc_type: Optional[Type[BaseException]], exc_val: Optional[BaseException], exc_tb: Optional[TracebackType] ) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/3/aiofiles/os.pyi0000664000175000017500000000202000000000000025115 0ustar00davedave00000000000000import sys from _typeshed import AnyPath from os import stat_result from typing import Optional, Sequence, Union, overload _FdOrAnyPath = Union[int, AnyPath] async def stat(path: _FdOrAnyPath, *, dir_fd: Optional[int] = ..., follow_symlinks: bool = ...) -> stat_result: ... async def rename(src: AnyPath, dst: AnyPath, *, src_dir_fd: Optional[int] = ..., dst_dir_fd: Optional[int] = ...) -> None: ... async def remove(path: AnyPath, *, dir_fd: Optional[int] = ...) -> None: ... async def mkdir(path: AnyPath, mode: int = ..., *, dir_fd: Optional[int] = ...) -> None: ... async def rmdir(path: AnyPath, *, dir_fd: Optional[int] = ...) -> None: ... if sys.platform != "win32": @overload async def sendfile(__out_fd: int, __in_fd: int, offset: Optional[int], count: int) -> int: ... @overload async def sendfile( __out_fd: int, __in_fd: int, offset: int, count: int, headers: Sequence[bytes] = ..., trailers: Sequence[bytes] = ..., flags: int = ..., ) -> int: ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4623795 jedi-0.19.1/jedi/third_party/typeshed/third_party/3/aiofiles/threadpool/0000775000175000017500000000000000000000000026120 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/3/aiofiles/threadpool/__init__.pyi0000664000175000017500000000537400000000000030413 0ustar00davedave00000000000000from _typeshed import AnyPath, OpenBinaryMode, OpenBinaryModeReading, OpenBinaryModeUpdating, OpenBinaryModeWriting, OpenTextMode from asyncio import AbstractEventLoop from typing import Any, Callable, Optional, TypeVar, Union, overload from typing_extensions import Literal from ..base import AiofilesContextManager from .binary import AsyncBufferedIOBase, AsyncBufferedReader, AsyncFileIO, _UnknownAsyncBinaryIO from .text import AsyncTextIOWrapper _OpenFile = TypeVar("_OpenFile", bound=Union[AnyPath, int]) _Opener = Callable[[str, int], int] # Text mode: always returns AsyncTextIOWrapper @overload def open( file: _OpenFile, mode: OpenTextMode = ..., buffering: int = ..., encoding: Optional[str] = ..., errors: Optional[str] = ..., newline: Optional[str] = ..., closefd: bool = ..., opener: Optional[_Opener] = ..., *, loop: Optional[AbstractEventLoop] = ..., executor: Optional[Any] = ..., ) -> AiofilesContextManager[None, None, AsyncTextIOWrapper]: ... # Unbuffered binary: returns a FileIO @overload def open( file: _OpenFile, mode: OpenBinaryMode, buffering: Literal[0], encoding: None = ..., errors: None = ..., newline: None = ..., closefd: bool = ..., opener: Optional[_Opener] = ..., *, loop: Optional[AbstractEventLoop] = ..., executor: Optional[Any] = ..., ) -> AiofilesContextManager[None, None, AsyncFileIO]: ... # Buffered binary reading/updating: AsyncBufferedReader @overload def open( file: _OpenFile, mode: Union[OpenBinaryModeReading, OpenBinaryModeUpdating], buffering: Literal[-1, 1] = ..., encoding: None = ..., errors: None = ..., newline: None = ..., closefd: bool = ..., opener: Optional[_Opener] = ..., *, loop: Optional[AbstractEventLoop] = ..., executor: Optional[Any] = ..., ) -> AiofilesContextManager[None, None, AsyncBufferedReader]: ... # Buffered binary writing: AsyncBufferedIOBase @overload def open( file: _OpenFile, mode: OpenBinaryModeWriting, buffering: Literal[-1, 1] = ..., encoding: None = ..., errors: None = ..., newline: None = ..., closefd: bool = ..., opener: Optional[_Opener] = ..., *, loop: Optional[AbstractEventLoop] = ..., executor: Optional[Any] = ..., ) -> AiofilesContextManager[None, None, AsyncBufferedIOBase]: ... # Buffering cannot be determined: fall back to _UnknownAsyncBinaryIO @overload def open( file: _OpenFile, mode: OpenBinaryMode, buffering: int, encoding: None = ..., errors: None = ..., newline: None = ..., closefd: bool = ..., opener: Optional[_Opener] = ..., *, loop: Optional[AbstractEventLoop] = ..., executor: Optional[Any] = ..., ) -> AiofilesContextManager[None, None, _UnknownAsyncBinaryIO]: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/3/aiofiles/threadpool/binary.pyi0000664000175000017500000000312300000000000030126 0ustar00davedave00000000000000from _typeshed import AnyPath, ReadableBuffer, WriteableBuffer from io import FileIO from typing import Iterable, List, Optional, Union from ..base import AsyncBase class _UnknownAsyncBinaryIO(AsyncBase[bytes]): async def close(self) -> None: ... async def flush(self) -> None: ... async def isatty(self) -> bool: ... async def read(self, __size: int = ...) -> bytes: ... async def readinto(self, __buffer: WriteableBuffer) -> Optional[int]: ... async def readline(self, __size: Optional[int] = ...) -> bytes: ... async def readlines(self, __hint: int = ...) -> List[bytes]: ... async def seek(self, __offset: int, __whence: int = ...) -> int: ... async def seekable(self) -> bool: ... async def tell(self) -> int: ... async def truncate(self, __size: Optional[int] = ...) -> int: ... async def writable(self) -> bool: ... async def write(self, __b: ReadableBuffer) -> int: ... async def writelines(self, __lines: Iterable[ReadableBuffer]) -> None: ... def fileno(self) -> int: ... def readable(self) -> bool: ... @property def closed(self) -> bool: ... @property def mode(self) -> str: ... @property def name(self) -> Union[AnyPath, int]: ... class AsyncBufferedIOBase(_UnknownAsyncBinaryIO): async def read1(self, __size: int = ...) -> bytes: ... def detach(self) -> FileIO: ... @property def raw(self) -> FileIO: ... class AsyncBufferedReader(AsyncBufferedIOBase): async def peek(self, __size: int = ...) -> bytes: ... class AsyncFileIO(_UnknownAsyncBinaryIO): async def readall(self) -> bytes: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/3/aiofiles/threadpool/text.pyi0000664000175000017500000000261000000000000027626 0ustar00davedave00000000000000from _typeshed import AnyPath from typing import BinaryIO, Iterable, List, Optional, Tuple, Union from ..base import AsyncBase class AsyncTextIOWrapper(AsyncBase[str]): async def close(self) -> None: ... async def flush(self) -> None: ... async def isatty(self) -> bool: ... async def read(self, __size: Optional[int] = ...) -> str: ... async def readline(self, __size: int = ...) -> str: ... async def readlines(self, __hint: int = ...) -> List[str]: ... async def seek(self, __offset: int, __whence: int = ...) -> int: ... async def seekable(self) -> bool: ... async def tell(self) -> int: ... async def truncate(self, __size: Optional[int] = ...) -> int: ... async def writable(self) -> bool: ... async def write(self, __b: str) -> int: ... async def writelines(self, __lines: Iterable[str]) -> None: ... def detach(self) -> BinaryIO: ... def fileno(self) -> int: ... def readable(self) -> bool: ... @property def buffer(self) -> BinaryIO: ... @property def closed(self) -> bool: ... @property def encoding(self) -> str: ... @property def errors(self) -> Optional[str]: ... @property def line_buffering(self) -> bool: ... @property def newlines(self) -> Union[str, Tuple[str, ...], None]: ... @property def name(self) -> Union[AnyPath, int]: ... @property def mode(self) -> str: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/3/contextvars.pyi0000664000175000017500000000257500000000000025300 0ustar00davedave00000000000000import sys from typing import Any, Callable, ClassVar, Generic, Iterator, Mapping, TypeVar if sys.version_info >= (3, 9): from types import GenericAlias _T = TypeVar("_T") class ContextVar(Generic[_T]): def __init__(self, name: str, *, default: _T = ...) -> None: ... @property def name(self) -> str: ... def get(self, default: _T = ...) -> _T: ... def set(self, value: _T) -> Token[_T]: ... def reset(self, token: Token[_T]) -> None: ... if sys.version_info >= (3, 9): def __class_getitem__(cls, item: Any) -> GenericAlias: ... class Token(Generic[_T]): @property def var(self) -> ContextVar[_T]: ... @property def old_value(self) -> Any: ... # returns either _T or MISSING, but that's hard to express MISSING: ClassVar[object] if sys.version_info >= (3, 9): def __class_getitem__(cls, item: Any) -> GenericAlias: ... def copy_context() -> Context: ... # It doesn't make sense to make this generic, because for most Contexts each ContextVar will have # a different value. class Context(Mapping[ContextVar[Any], Any]): def __init__(self) -> None: ... def run(self, callable: Callable[..., _T], *args: Any, **kwargs: Any) -> _T: ... def copy(self) -> Context: ... def __getitem__(self, key: ContextVar[Any]) -> Any: ... def __iter__(self) -> Iterator[ContextVar[Any]]: ... def __len__(self) -> int: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/3/dataclasses.pyi0000664000175000017500000000526100000000000025202 0ustar00davedave00000000000000import sys from typing import Any, Callable, Dict, Generic, Iterable, List, Mapping, Optional, Tuple, Type, TypeVar, Union, overload if sys.version_info >= (3, 9): from types import GenericAlias _T = TypeVar("_T") class _MISSING_TYPE: ... MISSING: _MISSING_TYPE @overload def asdict(obj: Any) -> Dict[str, Any]: ... @overload def asdict(obj: Any, *, dict_factory: Callable[[List[Tuple[str, Any]]], _T]) -> _T: ... @overload def astuple(obj: Any) -> Tuple[Any, ...]: ... @overload def astuple(obj: Any, *, tuple_factory: Callable[[List[Any]], _T]) -> _T: ... @overload def dataclass(_cls: Type[_T]) -> Type[_T]: ... @overload def dataclass(_cls: None) -> Callable[[Type[_T]], Type[_T]]: ... @overload def dataclass( *, init: bool = ..., repr: bool = ..., eq: bool = ..., order: bool = ..., unsafe_hash: bool = ..., frozen: bool = ... ) -> Callable[[Type[_T]], Type[_T]]: ... class Field(Generic[_T]): name: str type: Type[_T] default: _T default_factory: Callable[[], _T] repr: bool hash: Optional[bool] init: bool compare: bool metadata: Mapping[str, Any] if sys.version_info >= (3, 9): def __class_getitem__(cls, item: Any) -> GenericAlias: ... # NOTE: Actual return type is 'Field[_T]', but we want to help type checkers # to understand the magic that happens at runtime. @overload # `default` and `default_factory` are optional and mutually exclusive. def field( *, default: _T, init: bool = ..., repr: bool = ..., hash: Optional[bool] = ..., compare: bool = ..., metadata: Optional[Mapping[str, Any]] = ..., ) -> _T: ... @overload def field( *, default_factory: Callable[[], _T], init: bool = ..., repr: bool = ..., hash: Optional[bool] = ..., compare: bool = ..., metadata: Optional[Mapping[str, Any]] = ..., ) -> _T: ... @overload def field( *, init: bool = ..., repr: bool = ..., hash: Optional[bool] = ..., compare: bool = ..., metadata: Optional[Mapping[str, Any]] = ..., ) -> Any: ... def fields(class_or_instance: Any) -> Tuple[Field[Any], ...]: ... def is_dataclass(obj: Any) -> bool: ... class FrozenInstanceError(AttributeError): ... class InitVar(Generic[_T]): if sys.version_info >= (3, 9): def __class_getitem__(cls, type: Any) -> GenericAlias: ... def make_dataclass( cls_name: str, fields: Iterable[Union[str, Tuple[str, type], Tuple[str, type, Field[Any]]]], *, bases: Tuple[type, ...] = ..., namespace: Optional[Dict[str, Any]] = ..., init: bool = ..., repr: bool = ..., eq: bool = ..., order: bool = ..., unsafe_hash: bool = ..., frozen: bool = ..., ) -> type: ... def replace(obj: _T, **changes: Any) -> _T: ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4623795 jedi-0.19.1/jedi/third_party/typeshed/third_party/3/docutils/0000775000175000017500000000000000000000000024012 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/3/docutils/__init__.pyi0000664000175000017500000000007700000000000026300 0ustar00davedave00000000000000from typing import Any def __getattr__(name: str) -> Any: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/3/docutils/examples.pyi0000664000175000017500000000012000000000000026344 0ustar00davedave00000000000000from typing import Any html_parts: Any def __getattr__(name: str) -> Any: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/3/docutils/nodes.pyi0000664000175000017500000000031300000000000025642 0ustar00davedave00000000000000from typing import Any, List class reference: def __init__(self, rawsource: str = ..., text: str = ..., *children: List[Any], **attributes: Any) -> None: ... def __getattr__(name: str) -> Any: ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4623795 jedi-0.19.1/jedi/third_party/typeshed/third_party/3/docutils/parsers/0000775000175000017500000000000000000000000025471 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/3/docutils/parsers/__init__.pyi0000664000175000017500000000007700000000000027757 0ustar00davedave00000000000000from typing import Any def __getattr__(name: str) -> Any: ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4623795 jedi-0.19.1/jedi/third_party/typeshed/third_party/3/docutils/parsers/rst/0000775000175000017500000000000000000000000026301 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/3/docutils/parsers/rst/__init__.pyi0000664000175000017500000000007700000000000030567 0ustar00davedave00000000000000from typing import Any def __getattr__(name: str) -> Any: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/3/docutils/parsers/rst/nodes.pyi0000664000175000017500000000007700000000000030140 0ustar00davedave00000000000000from typing import Any def __getattr__(name: str) -> Any: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/3/docutils/parsers/rst/roles.pyi0000664000175000017500000000064200000000000030152 0ustar00davedave00000000000000from typing import Any, Callable, Dict, List, Tuple import docutils.nodes import docutils.parsers.rst.states _RoleFn = Callable[ [str, str, str, int, docutils.parsers.rst.states.Inliner, Dict[str, Any], List[str]], Tuple[List[docutils.nodes.reference], List[docutils.nodes.reference]], ] def register_local_role(name: str, role_fn: _RoleFn) -> None: ... def __getattr__(name: str) -> Any: ... # incomplete ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/3/docutils/parsers/rst/states.pyi0000664000175000017500000000016300000000000030327 0ustar00davedave00000000000000from typing import Any class Inliner: def __init__(self) -> None: ... def __getattr__(name: str) -> Any: ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4623795 jedi-0.19.1/jedi/third_party/typeshed/third_party/3/filelock/0000775000175000017500000000000000000000000023754 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/3/filelock/__init__.pyi0000664000175000017500000000337500000000000026246 0ustar00davedave00000000000000import sys from logging import Logger from types import TracebackType from typing import Optional, Type, Union def logger() -> Logger: ... class Timeout(TimeoutError): def __init__(self, lock_file: str) -> None: ... def __str__(self) -> str: ... class _Acquire_ReturnProxy: def __init__(self, lock: str) -> None: ... def __enter__(self) -> str: ... def __exit__( self, exc_type: Optional[Type[BaseException]], exc_val: Optional[BaseException], traceback: Optional[TracebackType] ) -> None: ... class BaseFileLock: def __init__(self, lock_file: str, timeout: Union[float, int, str] = ...) -> None: ... @property def lock_file(self) -> str: ... @property def timeout(self) -> float: ... @timeout.setter def timeout(self, value: Union[int, str, float]) -> None: ... @property def is_locked(self) -> bool: ... def acquire(self, timeout: Optional[float] = ..., poll_intervall: float = ...) -> _Acquire_ReturnProxy: ... def release(self, force: bool = ...) -> None: ... def __enter__(self) -> BaseFileLock: ... def __exit__( self, exc_type: Optional[Type[BaseException]], exc_val: Optional[BaseException], traceback: Optional[TracebackType] ) -> None: ... def __del__(self) -> None: ... class WindowsFileLock(BaseFileLock): def _acquire(self) -> None: ... def _release(self) -> None: ... class UnixFileLock(BaseFileLock): def _acquire(self) -> None: ... def _release(self) -> None: ... class SoftFileLock(BaseFileLock): def _acquire(self) -> None: ... def _release(self) -> None: ... if sys.platform == "win32": FileLock = WindowsFileLock elif sys.platform == "linux" or sys.platform == "darwin": FileLock = UnixFileLock else: FileLock = SoftFileLock ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4623795 jedi-0.19.1/jedi/third_party/typeshed/third_party/3/freezegun/0000775000175000017500000000000000000000000024156 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/3/freezegun/__init__.pyi0000664000175000017500000000005400000000000026437 0ustar00davedave00000000000000from .api import freeze_time as freeze_time ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/3/freezegun/api.pyi0000664000175000017500000000433200000000000025454 0ustar00davedave00000000000000from datetime import date, datetime, timedelta from numbers import Real from typing import Any, Awaitable, Callable, Iterator, Optional, Sequence, Type, TypeVar, Union, overload _T = TypeVar("_T") _Freezable = Union[str, datetime, date, timedelta] class TickingDateTimeFactory(object): def __init__(self, time_to_freeze: datetime, start: datetime) -> None: ... def __call__(self) -> datetime: ... class FrozenDateTimeFactory(object): def __init__(self, time_to_freeze: datetime) -> None: ... def __call__(self) -> datetime: ... def tick(self, delta: Union[float, Real, timedelta] = ...) -> None: ... def move_to(self, target_datetime: Optional[_Freezable]) -> None: ... class StepTickTimeFactory(object): def __init__(self, time_to_freeze: datetime, step_width: float) -> None: ... def __call__(self) -> datetime: ... def tick(self, delta: Optional[timedelta] = ...) -> None: ... def update_step_width(self, step_width: float) -> None: ... def move_to(self, target_datetime: Optional[_Freezable]) -> None: ... class _freeze_time: def __init__( self, time_to_freeze_str: Optional[_Freezable], tz_offset: float, ignore: Sequence[str], tick: bool, as_arg: bool, auto_tick_seconds: float, ) -> None: ... @overload def __call__(self, func: Type[_T]) -> Type[_T]: ... @overload def __call__(self, func: Callable[..., Awaitable[_T]]) -> Callable[..., Awaitable[_T]]: ... @overload def __call__(self, func: Callable[..., _T]) -> Callable[..., _T]: ... def __enter__(self) -> Any: ... def __exit__(self, *args: Any) -> None: ... def start(self) -> Any: ... def stop(self) -> None: ... def decorate_class(self, klass: Type[_T]) -> _T: ... def decorate_coroutine(self, coroutine: _T) -> _T: ... def decorate_callable(self, func: Callable[..., _T]) -> Callable[..., _T]: ... def freeze_time( time_to_freeze: Optional[Union[_Freezable, Callable[..., _Freezable], Iterator[_Freezable]]] = ..., tz_offset: Optional[float] = ..., ignore: Optional[Sequence[str]] = ..., tick: Optional[bool] = ..., as_arg: Optional[bool] = ..., auto_tick_seconds: Optional[float] = ..., ) -> _freeze_time: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/3/frozendict.pyi0000664000175000017500000000157700000000000025070 0ustar00davedave00000000000000import collections from typing import Any, Dict, Generic, Iterable, Iterator, Mapping, Tuple, Type, TypeVar, overload _S = TypeVar("_S") _KT = TypeVar("_KT") _VT = TypeVar("_VT") class frozendict(Mapping[_KT, _VT], Generic[_KT, _VT]): dict_cls: Type[Dict] = ... @overload def __init__(self, **kwargs: _VT) -> None: ... @overload def __init__(self, mapping: Mapping[_KT, _VT]) -> None: ... @overload def __init__(self, iterable: Iterable[Tuple[_KT, _VT]]) -> None: ... def __getitem__(self, key: _KT) -> _VT: ... def __contains__(self, key: object) -> bool: ... def copy(self: _S, **add_or_replace: _VT) -> _S: ... def __iter__(self) -> Iterator[_KT]: ... def __len__(self) -> int: ... def __repr__(self) -> str: ... def __hash__(self) -> int: ... class FrozenOrderedDict(frozendict): dict_cls: Type[collections.OrderedDict] = ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4623795 jedi-0.19.1/jedi/third_party/typeshed/third_party/3/jwt/0000775000175000017500000000000000000000000022770 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/3/jwt/__init__.pyi0000664000175000017500000000327400000000000025260 0ustar00davedave00000000000000from typing import Any, Dict, Mapping, Optional, Union from cryptography.hazmat.primitives.asymmetric import rsa from . import algorithms def decode( jwt: Union[str, bytes], key: Union[str, bytes, rsa.RSAPublicKey, rsa.RSAPrivateKey] = ..., verify: bool = ..., algorithms: Optional[Any] = ..., options: Optional[Mapping[Any, Any]] = ..., **kwargs: Any, ) -> Dict[str, Any]: ... def encode( payload: Mapping[str, Any], key: Union[str, bytes, rsa.RSAPublicKey, rsa.RSAPrivateKey], algorithm: str = ..., headers: Optional[Mapping[str, Any]] = ..., json_encoder: Optional[Any] = ..., ) -> bytes: ... def register_algorithm(alg_id: str, alg_obj: algorithms.Algorithm[Any]) -> None: ... def unregister_algorithm(alg_id: str) -> None: ... class PyJWTError(Exception): ... class InvalidTokenError(PyJWTError): ... class DecodeError(InvalidTokenError): ... class ExpiredSignatureError(InvalidTokenError): ... class InvalidAudienceError(InvalidTokenError): ... class InvalidIssuerError(InvalidTokenError): ... class InvalidIssuedAtError(InvalidTokenError): ... class ImmatureSignatureError(InvalidTokenError): ... class InvalidKeyError(PyJWTError): ... class InvalidAlgorithmError(InvalidTokenError): ... class MissingRequiredClaimError(InvalidTokenError): ... class InvalidSignatureError(DecodeError): ... # Compatibility aliases (deprecated) ExpiredSignature = ExpiredSignatureError InvalidAudience = InvalidAudienceError InvalidIssuer = InvalidIssuerError # These aren't actually documented, but the package # exports them in __init__.py, so we should at least # make sure that mypy doesn't raise spurious errors # if they're used. get_unverified_header: Any PyJWT: Any PyJWS: Any ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/3/jwt/algorithms.pyi0000664000175000017500000001031300000000000025662 0ustar00davedave00000000000000import sys from hashlib import _Hash from typing import Any, ClassVar, Dict, Generic, Optional, Set, TypeVar, Union from cryptography.hazmat.primitives import hashes from cryptography.hazmat.primitives.asymmetric.ec import ( EllipticCurvePrivateKey, EllipticCurvePrivateKeyWithSerialization, EllipticCurvePrivateNumbers, EllipticCurvePublicKey, EllipticCurvePublicKeyWithSerialization, EllipticCurvePublicNumbers, ) from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PrivateKey, Ed25519PublicKey from cryptography.hazmat.primitives.asymmetric.rsa import ( RSAPrivateKey, RSAPrivateKeyWithSerialization, RSAPrivateNumbers, RSAPublicKey, RSAPublicKeyWithSerialization, RSAPublicNumbers, ) from cryptography.hazmat.primitives.asymmetric.utils import Prehashed from cryptography.hazmat.primitives.hashes import HashAlgorithm requires_cryptography = Set[str] def get_default_algorithms() -> Dict[str, Algorithm[Any]]: ... _K = TypeVar("_K") class Algorithm(Generic[_K]): def prepare_key(self, key: _K) -> _K: ... def sign(self, msg: bytes, key: _K) -> bytes: ... def verify(self, msg: bytes, key: _K, sig: bytes) -> bool: ... @staticmethod def to_jwk(key_obj: _K) -> str: ... @staticmethod def from_jwk(jwk: str) -> _K: ... class NoneAlgorithm(Algorithm[None]): def prepare_key(self, key: Optional[str]) -> None: ... class _HashAlg: def __call__(self, arg: Union[bytes, bytearray, memoryview] = ...) -> _Hash: ... class HMACAlgorithm(Algorithm[bytes]): SHA256: ClassVar[_HashAlg] SHA384: ClassVar[_HashAlg] SHA512: ClassVar[_HashAlg] hash_alg: _HashAlg def __init__(self, hash_alg: _HashAlg) -> None: ... def prepare_key(self, key: Union[str, bytes]) -> bytes: ... @staticmethod def to_jwk(key_obj: Union[str, bytes]) -> str: ... @staticmethod def from_jwk(jwk: Union[str, bytes]) -> bytes: ... # Only defined if cryptography is installed. class RSAAlgorithm(Algorithm[Any]): SHA256: ClassVar[hashes.SHA256] SHA384: ClassVar[hashes.SHA384] SHA512: ClassVar[hashes.SHA512] hash_alg: Union[HashAlgorithm, Prehashed] def __init__(self, hash_alg: Union[HashAlgorithm, Prehashed]) -> None: ... def prepare_key(self, key: Union[bytes, str, RSAPrivateKey, RSAPublicKey]) -> Union[RSAPrivateKey, RSAPublicKey]: ... @staticmethod def from_jwk(jwk: Union[str, bytes, Dict[str, Any]]) -> Union[RSAPrivateKey, RSAPublicKey]: ... def sign(self, msg: bytes, key: RSAPrivateKey) -> bytes: ... def verify(self, msg: bytes, key: RSAPublicKey, sig: bytes) -> bool: ... # Only defined if cryptography is installed. class ECAlgorithm(Algorithm[Any]): SHA256: ClassVar[hashes.SHA256] SHA384: ClassVar[hashes.SHA384] SHA512: ClassVar[hashes.SHA512] hash_alg: Union[HashAlgorithm, Prehashed] def __init__(self, hash_alg: Union[HashAlgorithm, Prehashed]) -> None: ... def prepare_key( self, key: Union[bytes, str, EllipticCurvePrivateKey, EllipticCurvePublicKey] ) -> Union[EllipticCurvePrivateKey, EllipticCurvePublicKey]: ... @staticmethod def to_jwk(key_obj: Union[EllipticCurvePrivateKeyWithSerialization, EllipticCurvePublicKeyWithSerialization]) -> str: ... @staticmethod def from_jwk(jwk: Union[str, bytes]) -> Union[EllipticCurvePrivateKey, EllipticCurvePublicKey]: ... def sign(self, msg: bytes, key: EllipticCurvePrivateKey) -> bytes: ... def verify(self, msg: bytes, key: EllipticCurvePublicKey, sig: bytes) -> bool: ... # Only defined if cryptography is installed. Types should be tightened when # cryptography gets type hints. # See https://github.com/python/typeshed/issues/2542 class RSAPSSAlgorithm(RSAAlgorithm): def sign(self, msg: bytes, key: Any) -> bytes: ... def verify(self, msg: bytes, key: Any, sig: bytes) -> bool: ... # Only defined if cryptography is installed. class Ed25519Algorithm(Algorithm[Any]): def __init__(self, **kwargs: Any) -> None: ... def prepare_key(self, key: Union[str, bytes, Ed25519PrivateKey, Ed25519PublicKey]) -> Any: ... def sign(self, msg: Union[str, bytes], key: Ed25519PrivateKey) -> bytes: ... def verify(self, msg: Union[str, bytes], key: Ed25519PublicKey, sig: Union[str, bytes]) -> bool: ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4623795 jedi-0.19.1/jedi/third_party/typeshed/third_party/3/jwt/contrib/0000775000175000017500000000000000000000000024430 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/3/jwt/contrib/__init__.pyi0000664000175000017500000000000000000000000026700 0ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4623795 jedi-0.19.1/jedi/third_party/typeshed/third_party/3/jwt/contrib/algorithms/0000775000175000017500000000000000000000000026601 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/3/jwt/contrib/algorithms/__init__.pyi0000664000175000017500000000000000000000000031051 0ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/3/jwt/contrib/algorithms/py_ecdsa.pyi0000664000175000017500000000037300000000000031116 0ustar00davedave00000000000000import hashlib from typing import Any from jwt.algorithms import Algorithm class ECAlgorithm(Algorithm[Any]): SHA256: hashlib._Hash SHA384: hashlib._Hash SHA512: hashlib._Hash def __init__(self, hash_alg: hashlib._Hash) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/3/jwt/contrib/algorithms/pycrypto.pyi0000664000175000017500000000037400000000000031221 0ustar00davedave00000000000000import hashlib from typing import Any from jwt.algorithms import Algorithm class RSAAlgorithm(Algorithm[Any]): SHA256: hashlib._Hash SHA384: hashlib._Hash SHA512: hashlib._Hash def __init__(self, hash_alg: hashlib._Hash) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/3/orjson.pyi0000664000175000017500000000122000000000000024214 0ustar00davedave00000000000000from typing import Any, Callable, Optional, Union __version__: str def dumps(__obj: Any, default: Optional[Callable[[Any], Any]] = ..., option: Optional[int] = ...) -> bytes: ... def loads(__obj: Union[bytes, bytearray, str]) -> Any: ... class JSONDecodeError(ValueError): ... class JSONEncodeError(TypeError): ... OPT_APPEND_NEWLINE: int OPT_INDENT_2: int OPT_NAIVE_UTC: int OPT_NON_STR_KEYS: int OPT_OMIT_MICROSECONDS: int OPT_PASSTHROUGH_DATACLASS: int OPT_PASSTHROUGH_DATETIME: int OPT_PASSTHROUGH_SUBCLASS: int OPT_SERIALIZE_DATACLASS: int OPT_SERIALIZE_NUMPY: int OPT_SERIALIZE_UUID: int OPT_SORT_KEYS: int OPT_STRICT_INTEGER: int OPT_UTC_Z: int ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4623795 jedi-0.19.1/jedi/third_party/typeshed/third_party/3/pkg_resources/0000775000175000017500000000000000000000000025037 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/3/pkg_resources/__init__.pyi0000664000175000017500000002751100000000000027327 0ustar00davedave00000000000000import importlib.abc import types import zipimport from abc import ABCMeta from typing import IO, Any, Callable, Dict, Generator, Iterable, List, Optional, Sequence, Set, Tuple, TypeVar, Union, overload _T = TypeVar("_T") _NestedStr = Union[str, Iterable[Union[str, Iterable[Any]]]] _InstallerType = Callable[[Requirement], Optional[Distribution]] _EPDistType = Union[Distribution, Requirement, str] _MetadataType = Optional[IResourceProvider] _PkgReqType = Union[str, Requirement] _DistFinderType = Callable[[_Importer, str, bool], Generator[Distribution, None, None]] _NSHandlerType = Callable[[_Importer, str, str, types.ModuleType], str] def declare_namespace(name: str) -> None: ... def fixup_namespace_packages(path_item: str) -> None: ... class WorkingSet: entries: List[str] def __init__(self, entries: Optional[Iterable[str]] = ...) -> None: ... def require(self, *requirements: _NestedStr) -> Sequence[Distribution]: ... def run_script(self, requires: str, script_name: str) -> None: ... def iter_entry_points(self, group: str, name: Optional[str] = ...) -> Generator[EntryPoint, None, None]: ... def add_entry(self, entry: str) -> None: ... def __contains__(self, dist: Distribution) -> bool: ... def __iter__(self) -> Generator[Distribution, None, None]: ... def find(self, req: Requirement) -> Optional[Distribution]: ... def resolve( self, requirements: Iterable[Requirement], env: Optional[Environment] = ..., installer: Optional[_InstallerType] = ... ) -> List[Distribution]: ... def add(self, dist: Distribution, entry: Optional[str] = ..., insert: bool = ..., replace: bool = ...) -> None: ... def subscribe(self, callback: Callable[[Distribution], None]) -> None: ... def find_plugins( self, plugin_env: Environment, full_env: Optional[Environment] = ..., fallback: bool = ... ) -> Tuple[List[Distribution], Dict[Distribution, Exception]]: ... working_set: WorkingSet def require(*requirements: _NestedStr) -> Sequence[Distribution]: ... def run_script(requires: str, script_name: str) -> None: ... def iter_entry_points(group: str, name: Optional[str] = ...) -> Generator[EntryPoint, None, None]: ... def add_activation_listener(callback: Callable[[Distribution], None]) -> None: ... class Environment: def __init__( self, search_path: Optional[Sequence[str]] = ..., platform: Optional[str] = ..., python: Optional[str] = ... ) -> None: ... def __getitem__(self, project_name: str) -> List[Distribution]: ... def __iter__(self) -> Generator[str, None, None]: ... def add(self, dist: Distribution) -> None: ... def remove(self, dist: Distribution) -> None: ... def can_add(self, dist: Distribution) -> bool: ... def __add__(self, other: Union[Distribution, Environment]) -> Environment: ... def __iadd__(self, other: Union[Distribution, Environment]) -> Environment: ... @overload def best_match(self, req: Requirement, working_set: WorkingSet) -> Distribution: ... @overload def best_match(self, req: Requirement, working_set: WorkingSet, installer: Callable[[Requirement], _T] = ...) -> _T: ... @overload def obtain(self, requirement: Requirement) -> None: ... @overload def obtain(self, requirement: Requirement, installer: Callable[[Requirement], _T] = ...) -> _T: ... def scan(self, search_path: Optional[Sequence[str]] = ...) -> None: ... def parse_requirements(strs: Union[str, Iterable[str]]) -> Generator[Requirement, None, None]: ... class Requirement: unsafe_name: str project_name: str key: str extras: Tuple[str, ...] specs: List[Tuple[str, str]] # TODO: change this to Optional[packaging.markers.Marker] once we can import # packaging.markers marker: Optional[Any] @staticmethod def parse(s: Union[str, Iterable[str]]) -> Requirement: ... def __contains__(self, item: Union[Distribution, str, Tuple[str, ...]]) -> bool: ... def __eq__(self, other_requirement: Any) -> bool: ... def load_entry_point(dist: _EPDistType, group: str, name: str) -> Any: ... def get_entry_info(dist: _EPDistType, group: str, name: str) -> Optional[EntryPoint]: ... @overload def get_entry_map(dist: _EPDistType) -> Dict[str, Dict[str, EntryPoint]]: ... @overload def get_entry_map(dist: _EPDistType, group: str) -> Dict[str, EntryPoint]: ... class EntryPoint: name: str module_name: str attrs: Tuple[str, ...] extras: Tuple[str, ...] dist: Optional[Distribution] def __init__( self, name: str, module_name: str, attrs: Tuple[str, ...] = ..., extras: Tuple[str, ...] = ..., dist: Optional[Distribution] = ..., ) -> None: ... @classmethod def parse(cls, src: str, dist: Optional[Distribution] = ...) -> EntryPoint: ... @classmethod def parse_group( cls, group: str, lines: Union[str, Sequence[str]], dist: Optional[Distribution] = ... ) -> Dict[str, EntryPoint]: ... @classmethod def parse_map( cls, data: Union[Dict[str, Union[str, Sequence[str]]], str, Sequence[str]], dist: Optional[Distribution] = ... ) -> Dict[str, EntryPoint]: ... def load(self, require: bool = ..., env: Optional[Environment] = ..., installer: Optional[_InstallerType] = ...) -> Any: ... def require(self, env: Optional[Environment] = ..., installer: Optional[_InstallerType] = ...) -> None: ... def resolve(self) -> Any: ... def find_distributions(path_item: str, only: bool = ...) -> Generator[Distribution, None, None]: ... def get_distribution(dist: Union[Requirement, str, Distribution]) -> Distribution: ... class Distribution(IResourceProvider, IMetadataProvider): PKG_INFO: str location: str project_name: str key: str extras: List[str] version: str parsed_version: Tuple[str, ...] py_version: str platform: Optional[str] precedence: int def __init__( self, location: Optional[str] = ..., metadata: _MetadataType = ..., project_name: Optional[str] = ..., version: Optional[str] = ..., py_version: str = ..., platform: Optional[str] = ..., precedence: int = ..., ) -> None: ... @classmethod def from_location( cls, location: str, basename: str, metadata: _MetadataType = ..., **kw: Union[str, None, int] ) -> Distribution: ... @classmethod def from_filename(cls, filename: str, metadata: _MetadataType = ..., **kw: Union[str, None, int]) -> Distribution: ... def activate(self, path: Optional[List[str]] = ...) -> None: ... def as_requirement(self) -> Requirement: ... def requires(self, extras: Tuple[str, ...] = ...) -> List[Requirement]: ... def clone(self, **kw: Union[str, int, None]) -> Requirement: ... def egg_name(self) -> str: ... def __cmp__(self, other: Any) -> bool: ... def get_entry_info(self, group: str, name: str) -> Optional[EntryPoint]: ... @overload def get_entry_map(self) -> Dict[str, Dict[str, EntryPoint]]: ... @overload def get_entry_map(self, group: str) -> Dict[str, EntryPoint]: ... def load_entry_point(self, group: str, name: str) -> Any: ... EGG_DIST: int BINARY_DIST: int SOURCE_DIST: int CHECKOUT_DIST: int DEVELOP_DIST: int def resource_exists(package_or_requirement: _PkgReqType, resource_name: str) -> bool: ... def resource_stream(package_or_requirement: _PkgReqType, resource_name: str) -> IO[bytes]: ... def resource_string(package_or_requirement: _PkgReqType, resource_name: str) -> bytes: ... def resource_isdir(package_or_requirement: _PkgReqType, resource_name: str) -> bool: ... def resource_listdir(package_or_requirement: _PkgReqType, resource_name: str) -> List[str]: ... def resource_filename(package_or_requirement: _PkgReqType, resource_name: str) -> str: ... def set_extraction_path(path: str) -> None: ... def cleanup_resources(force: bool = ...) -> List[str]: ... class IResourceManager: def resource_exists(self, package_or_requirement: _PkgReqType, resource_name: str) -> bool: ... def resource_stream(self, package_or_requirement: _PkgReqType, resource_name: str) -> IO[bytes]: ... def resource_string(self, package_or_requirement: _PkgReqType, resource_name: str) -> bytes: ... def resource_isdir(self, package_or_requirement: _PkgReqType, resource_name: str) -> bool: ... def resource_listdir(self, package_or_requirement: _PkgReqType, resource_name: str) -> List[str]: ... def resource_filename(self, package_or_requirement: _PkgReqType, resource_name: str) -> str: ... def set_extraction_path(self, path: str) -> None: ... def cleanup_resources(self, force: bool = ...) -> List[str]: ... def get_cache_path(self, archive_name: str, names: Iterable[str] = ...) -> str: ... def extraction_error(self) -> None: ... def postprocess(self, tempname: str, filename: str) -> None: ... @overload def get_provider(package_or_requirement: str) -> IResourceProvider: ... @overload def get_provider(package_or_requirement: Requirement) -> Distribution: ... class IMetadataProvider: def has_metadata(self, name: str) -> bool: ... def metadata_isdir(self, name: str) -> bool: ... def metadata_listdir(self, name: str) -> List[str]: ... def get_metadata(self, name: str) -> str: ... def get_metadata_lines(self, name: str) -> Generator[str, None, None]: ... def run_script(self, script_name: str, namespace: Dict[str, Any]) -> None: ... class ResolutionError(Exception): ... class DistributionNotFound(ResolutionError): @property def req(self) -> Requirement: ... @property def requirers(self) -> Set[str]: ... @property def requirers_str(self) -> str: ... def report(self) -> str: ... class VersionConflict(ResolutionError): @property def dist(self) -> Any: ... @property def req(self) -> Any: ... def report(self) -> str: ... def with_context(self, required_by: Set[Union[Distribution, str]]) -> VersionConflict: ... class ContextualVersionConflict(VersionConflict): @property def required_by(self) -> Set[Union[Distribution, str]]: ... class UnknownExtra(ResolutionError): ... class ExtractionError(Exception): manager: IResourceManager cache_path: str original_error: Exception class _Importer(importlib.abc.MetaPathFinder, importlib.abc.InspectLoader, metaclass=ABCMeta): ... def register_finder(importer_type: type, distribution_finder: _DistFinderType) -> None: ... def register_loader_type(loader_type: type, provider_factory: Callable[[types.ModuleType], IResourceProvider]) -> None: ... def register_namespace_handler(importer_type: type, namespace_handler: _NSHandlerType) -> None: ... class IResourceProvider(IMetadataProvider): ... class NullProvider: ... class EggProvider(NullProvider): ... class DefaultProvider(EggProvider): ... class PathMetadata(DefaultProvider, IResourceProvider): def __init__(self, path: str, egg_info: str) -> None: ... class ZipProvider(EggProvider): ... class EggMetadata(ZipProvider, IResourceProvider): def __init__(self, zipimporter: zipimport.zipimporter) -> None: ... class EmptyProvider(NullProvider): ... empty_provider: EmptyProvider class FileMetadata(EmptyProvider, IResourceProvider): def __init__(self, path_to_pkg_info: str) -> None: ... def parse_version(v: str) -> Tuple[str, ...]: ... def yield_lines(strs: _NestedStr) -> Generator[str, None, None]: ... def split_sections(strs: _NestedStr) -> Generator[Tuple[Optional[str], str], None, None]: ... def safe_name(name: str) -> str: ... def safe_version(version: str) -> str: ... def safe_extra(extra: str) -> str: ... def to_filename(name_or_version: str) -> str: ... def get_build_platform() -> str: ... def get_platform() -> str: ... def get_supported_platform() -> str: ... def compatible_platforms(provided: Optional[str], required: Optional[str]) -> bool: ... def get_default_cache() -> str: ... def get_importer(path_item: str) -> _Importer: ... def ensure_directory(path: str) -> None: ... def normalize_path(filename: str) -> str: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/3/pkg_resources/py31compat.pyi0000664000175000017500000000007000000000000027557 0ustar00davedave00000000000000import os needs_makedirs: bool makedirs = os.makedirs ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4623795 jedi-0.19.1/jedi/third_party/typeshed/third_party/3/pyrfc3339/0000775000175000017500000000000000000000000023631 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/3/pyrfc3339/__init__.pyi0000664000175000017500000000011700000000000026112 0ustar00davedave00000000000000from .generator import generate as generate from .parser import parse as parse ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/3/pyrfc3339/generator.pyi0000664000175000017500000000021300000000000026336 0ustar00davedave00000000000000from datetime import datetime def generate(dt: datetime, utc: bool = ..., accept_naive: bool = ..., microseconds: bool = ...) -> str: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/3/pyrfc3339/parser.pyi0000664000175000017500000000016600000000000025653 0ustar00davedave00000000000000from datetime import datetime def parse(timestamp: str, utc: bool = ..., produce_naive: bool = ...) -> datetime: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/3/pyrfc3339/utils.pyi0000664000175000017500000000067700000000000025526 0ustar00davedave00000000000000from datetime import datetime, timedelta, tzinfo from typing import Optional class FixedOffset(tzinfo): def __init__(self, hours: float, minutes: float) -> None: ... def dst(self, dt: Optional[datetime]) -> timedelta: ... def utcoffset(self, dt: Optional[datetime]) -> timedelta: ... def tzname(self, dt: Optional[datetime]) -> str: ... def timedelta_seconds(td: timedelta) -> int: ... def timezone(utcoffset: float) -> str: ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4623795 jedi-0.19.1/jedi/third_party/typeshed/third_party/3/six/0000775000175000017500000000000000000000000022767 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/3/six/__init__.pyi0000664000175000017500000001011100000000000025243 0ustar00davedave00000000000000from __future__ import print_function import types import typing import unittest from builtins import next as next from functools import wraps as wraps from io import BytesIO as BytesIO, StringIO as StringIO from typing import ( Any, AnyStr, Callable, Dict, ItemsView, Iterable, KeysView, Mapping, NoReturn, Optional, Pattern, Tuple, Type, TypeVar, Union, ValuesView, overload, ) from . import moves as moves _T = TypeVar("_T") _K = TypeVar("_K") _V = TypeVar("_V") __version__: str # TODO make constant, then move this stub to 2and3 # https://github.com/python/typeshed/issues/17 PY2 = False PY3 = True PY34: bool string_types = (str,) integer_types = (int,) class_types = (type,) text_type = str binary_type = bytes MAXSIZE: int def callable(obj: object) -> bool: ... def get_unbound_function(unbound: types.FunctionType) -> types.FunctionType: ... def create_bound_method(func: types.FunctionType, obj: object) -> types.MethodType: ... def create_unbound_method(func: types.FunctionType, cls: type) -> types.FunctionType: ... Iterator = object def get_method_function(meth: types.MethodType) -> types.FunctionType: ... def get_method_self(meth: types.MethodType) -> Optional[object]: ... def get_function_closure(fun: types.FunctionType) -> Optional[Tuple[types._Cell, ...]]: ... def get_function_code(fun: types.FunctionType) -> types.CodeType: ... def get_function_defaults(fun: types.FunctionType) -> Optional[Tuple[Any, ...]]: ... def get_function_globals(fun: types.FunctionType) -> Dict[str, Any]: ... def iterkeys(d: Mapping[_K, _V]) -> typing.Iterator[_K]: ... def itervalues(d: Mapping[_K, _V]) -> typing.Iterator[_V]: ... def iteritems(d: Mapping[_K, _V]) -> typing.Iterator[Tuple[_K, _V]]: ... # def iterlists def viewkeys(d: Mapping[_K, _V]) -> KeysView[_K]: ... def viewvalues(d: Mapping[_K, _V]) -> ValuesView[_V]: ... def viewitems(d: Mapping[_K, _V]) -> ItemsView[_K, _V]: ... def b(s: str) -> binary_type: ... def u(s: str) -> text_type: ... unichr = chr def int2byte(i: int) -> bytes: ... def byte2int(bs: binary_type) -> int: ... def indexbytes(buf: binary_type, i: int) -> int: ... def iterbytes(buf: binary_type) -> typing.Iterator[int]: ... def assertCountEqual(self: unittest.TestCase, first: Iterable[_T], second: Iterable[_T], msg: Optional[str] = ...) -> None: ... @overload def assertRaisesRegex(self: unittest.TestCase, msg: Optional[str] = ...) -> Any: ... @overload def assertRaisesRegex(self: unittest.TestCase, callable_obj: Callable[..., Any], *args: Any, **kwargs: Any) -> Any: ... def assertRegex( self: unittest.TestCase, text: AnyStr, expected_regex: Union[AnyStr, Pattern[AnyStr]], msg: Optional[str] = ... ) -> None: ... exec_ = exec def reraise( tp: Optional[Type[BaseException]], value: Optional[BaseException], tb: Optional[types.TracebackType] = ... ) -> NoReturn: ... def raise_from(value: Union[BaseException, Type[BaseException]], from_value: Optional[BaseException]) -> NoReturn: ... print_ = print def with_metaclass(meta: type, *bases: type) -> type: ... def add_metaclass(metaclass: type) -> Callable[[_T], _T]: ... def ensure_binary(s: Union[bytes, str], encoding: str = ..., errors: str = ...) -> bytes: ... def ensure_str(s: Union[bytes, str], encoding: str = ..., errors: str = ...) -> str: ... def ensure_text(s: Union[bytes, str], encoding: str = ..., errors: str = ...) -> str: ... def python_2_unicode_compatible(klass: _T) -> _T: ... class _LazyDescriptor: name: str def __init__(self, name: str) -> None: ... def __get__(self, obj: Optional[object], type: Optional[type] = ...) -> Any: ... class MovedModule(_LazyDescriptor): mod: str def __init__(self, name: str, old: str, new: Optional[str] = ...) -> None: ... def __getattr__(self, attr: str) -> Any: ... class MovedAttribute(_LazyDescriptor): mod: str attr: str def __init__( self, name: str, old_mod: str, new_mod: str, old_attr: Optional[str] = ..., new_attr: Optional[str] = ... ) -> None: ... def add_move(move: Union[MovedModule, MovedAttribute]) -> None: ... def remove_move(name: str) -> None: ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4663794 jedi-0.19.1/jedi/third_party/typeshed/third_party/3/six/moves/0000775000175000017500000000000000000000000024120 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/3/six/moves/BaseHTTPServer.pyi0000664000175000017500000000003200000000000027377 0ustar00davedave00000000000000from http.server import * ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/3/six/moves/CGIHTTPServer.pyi0000664000175000017500000000003200000000000027127 0ustar00davedave00000000000000from http.server import * ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/3/six/moves/SimpleHTTPServer.pyi0000664000175000017500000000003200000000000027756 0ustar00davedave00000000000000from http.server import * ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/3/six/moves/__init__.pyi0000664000175000017500000000447300000000000026412 0ustar00davedave00000000000000# Stubs for six.moves # # Note: Commented out items means they weren't implemented at the time. # Uncomment them when the modules have been added to the typeshed. import importlib import shlex from builtins import filter as filter, input as input, map as map, range as range, zip as zip from collections import UserDict as UserDict, UserList as UserList, UserString as UserString from functools import reduce as reduce from io import StringIO as StringIO from itertools import filterfalse as filterfalse, zip_longest as zip_longest from os import getcwd as getcwd, getcwdb as getcwdb from sys import intern as intern # import tkinter.font as tkinter_font # import tkinter.messagebox as tkinter_messagebox # import tkinter.simpledialog as tkinter_tksimpledialog # import tkinter.dnd as tkinter_dnd # import tkinter.colorchooser as tkinter_colorchooser # import tkinter.scrolledtext as tkinter_scrolledtext # import tkinter.simpledialog as tkinter_simpledialog # import tkinter.tix as tkinter_tix # import copyreg as copyreg # import dbm.gnu as dbm_gnu from . import ( BaseHTTPServer as BaseHTTPServer, CGIHTTPServer as CGIHTTPServer, SimpleHTTPServer as SimpleHTTPServer, _dummy_thread as _dummy_thread, _thread as _thread, builtins as builtins, configparser as configparser, cPickle as cPickle, email_mime_base as email_mime_base, email_mime_multipart as email_mime_multipart, email_mime_nonmultipart as email_mime_nonmultipart, email_mime_text as email_mime_text, html_entities as html_entities, html_parser as html_parser, http_client as http_client, http_cookiejar as http_cookiejar, http_cookies as http_cookies, queue as queue, reprlib as reprlib, socketserver as socketserver, tkinter as tkinter, tkinter_commondialog as tkinter_commondialog, tkinter_constants as tkinter_constants, tkinter_dialog as tkinter_dialog, tkinter_filedialog as tkinter_filedialog, tkinter_tkfiledialog as tkinter_tkfiledialog, tkinter_ttk as tkinter_ttk, urllib as urllib, urllib_error as urllib_error, urllib_parse as urllib_parse, urllib_robotparser as urllib_robotparser, ) # import xmlrpc.client as xmlrpc_client # import xmlrpc.server as xmlrpc_server xrange = range reload_module = importlib.reload cStringIO = StringIO shlex_quote = shlex.quote ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/3/six/moves/_dummy_thread.pyi0000664000175000017500000000003400000000000027461 0ustar00davedave00000000000000from _dummy_thread import * ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/3/six/moves/_thread.pyi0000664000175000017500000000002600000000000026247 0ustar00davedave00000000000000from _thread import * ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/3/six/moves/builtins.pyi0000664000175000017500000000002700000000000026473 0ustar00davedave00000000000000from builtins import * ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/3/six/moves/cPickle.pyi0000664000175000017500000000002500000000000026212 0ustar00davedave00000000000000from pickle import * ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/3/six/moves/collections_abc.pyi0000664000175000017500000000003600000000000027765 0ustar00davedave00000000000000from collections.abc import * ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/3/six/moves/configparser.pyi0000664000175000017500000000003300000000000027321 0ustar00davedave00000000000000from configparser import * ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/3/six/moves/email_mime_base.pyi0000664000175000017500000000003600000000000027732 0ustar00davedave00000000000000from email.mime.base import * ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/3/six/moves/email_mime_multipart.pyi0000664000175000017500000000004300000000000031037 0ustar00davedave00000000000000from email.mime.multipart import * ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/3/six/moves/email_mime_nonmultipart.pyi0000664000175000017500000000004600000000000031555 0ustar00davedave00000000000000from email.mime.nonmultipart import * ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/3/six/moves/email_mime_text.pyi0000664000175000017500000000003600000000000030004 0ustar00davedave00000000000000from email.mime.text import * ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/3/six/moves/html_entities.pyi0000664000175000017500000000003400000000000027510 0ustar00davedave00000000000000from html.entities import * ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/3/six/moves/html_parser.pyi0000664000175000017500000000003200000000000027156 0ustar00davedave00000000000000from html.parser import * ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/3/six/moves/http_client.pyi0000664000175000017500000000003200000000000027153 0ustar00davedave00000000000000from http.client import * ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/3/six/moves/http_cookiejar.pyi0000664000175000017500000000003500000000000027646 0ustar00davedave00000000000000from http.cookiejar import * ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/3/six/moves/http_cookies.pyi0000664000175000017500000000003300000000000027332 0ustar00davedave00000000000000from http.cookies import * ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/3/six/moves/queue.pyi0000664000175000017500000000002400000000000025763 0ustar00davedave00000000000000from queue import * ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/3/six/moves/reprlib.pyi0000664000175000017500000000002600000000000026300 0ustar00davedave00000000000000from reprlib import * ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/3/six/moves/socketserver.pyi0000664000175000017500000000003300000000000027356 0ustar00davedave00000000000000from socketserver import * ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/3/six/moves/tkinter.pyi0000664000175000017500000000002600000000000026321 0ustar00davedave00000000000000from tkinter import * ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/3/six/moves/tkinter_commondialog.pyi0000664000175000017500000000004300000000000031050 0ustar00davedave00000000000000from tkinter.commondialog import * ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/3/six/moves/tkinter_constants.pyi0000664000175000017500000000004000000000000030411 0ustar00davedave00000000000000from tkinter.constants import * ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/3/six/moves/tkinter_dialog.pyi0000664000175000017500000000003500000000000027640 0ustar00davedave00000000000000from tkinter.dialog import * ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/3/six/moves/tkinter_filedialog.pyi0000664000175000017500000000004100000000000030475 0ustar00davedave00000000000000from tkinter.filedialog import * ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/3/six/moves/tkinter_tkfiledialog.pyi0000664000175000017500000000004100000000000031034 0ustar00davedave00000000000000from tkinter.filedialog import * ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/3/six/moves/tkinter_ttk.pyi0000664000175000017500000000003200000000000027200 0ustar00davedave00000000000000from tkinter.ttk import * ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4663794 jedi-0.19.1/jedi/third_party/typeshed/third_party/3/six/moves/urllib/0000775000175000017500000000000000000000000025411 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/3/six/moves/urllib/__init__.pyi0000664000175000017500000000033100000000000027670 0ustar00davedave00000000000000import six.moves.urllib.error as error import six.moves.urllib.parse as parse import six.moves.urllib.request as request import six.moves.urllib.response as response import six.moves.urllib.robotparser as robotparser ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/3/six/moves/urllib/error.pyi0000664000175000017500000000016400000000000027266 0ustar00davedave00000000000000from urllib.error import ContentTooShortError as ContentTooShortError, HTTPError as HTTPError, URLError as URLError ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/3/six/moves/urllib/parse.pyi0000664000175000017500000000172500000000000027253 0ustar00davedave00000000000000# Stubs for six.moves.urllib.parse # # Note: Commented out items means they weren't implemented at the time. # Uncomment them when the modules have been added to the typeshed. # from urllib.parse import splitquery as splitquery # from urllib.parse import splittag as splittag # from urllib.parse import splituser as splituser from urllib.parse import ( ParseResult as ParseResult, SplitResult as SplitResult, parse_qs as parse_qs, parse_qsl as parse_qsl, quote as quote, quote_plus as quote_plus, unquote as unquote, unquote_plus as unquote_plus, unquote_to_bytes as unquote_to_bytes, urldefrag as urldefrag, urlencode as urlencode, urljoin as urljoin, urlparse as urlparse, urlsplit as urlsplit, urlunparse as urlunparse, urlunsplit as urlunsplit, uses_fragment as uses_fragment, uses_netloc as uses_netloc, uses_params as uses_params, uses_query as uses_query, uses_relative as uses_relative, ) ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/3/six/moves/urllib/request.pyi0000664000175000017500000000314700000000000027631 0ustar00davedave00000000000000# Stubs for six.moves.urllib.request # # Note: Commented out items means they weren't implemented at the time. # Uncomment them when the modules have been added to the typeshed. # from urllib.request import proxy_bypass as proxy_bypass from urllib.request import ( AbstractBasicAuthHandler as AbstractBasicAuthHandler, AbstractDigestAuthHandler as AbstractDigestAuthHandler, BaseHandler as BaseHandler, CacheFTPHandler as CacheFTPHandler, FancyURLopener as FancyURLopener, FileHandler as FileHandler, FTPHandler as FTPHandler, HTTPBasicAuthHandler as HTTPBasicAuthHandler, HTTPCookieProcessor as HTTPCookieProcessor, HTTPDefaultErrorHandler as HTTPDefaultErrorHandler, HTTPDigestAuthHandler as HTTPDigestAuthHandler, HTTPErrorProcessor as HTTPErrorProcessor, HTTPHandler as HTTPHandler, HTTPPasswordMgr as HTTPPasswordMgr, HTTPPasswordMgrWithDefaultRealm as HTTPPasswordMgrWithDefaultRealm, HTTPRedirectHandler as HTTPRedirectHandler, HTTPSHandler as HTTPSHandler, OpenerDirector as OpenerDirector, ProxyBasicAuthHandler as ProxyBasicAuthHandler, ProxyDigestAuthHandler as ProxyDigestAuthHandler, ProxyHandler as ProxyHandler, Request as Request, UnknownHandler as UnknownHandler, URLopener as URLopener, build_opener as build_opener, getproxies as getproxies, install_opener as install_opener, parse_http_list as parse_http_list, parse_keqv_list as parse_keqv_list, pathname2url as pathname2url, url2pathname as url2pathname, urlcleanup as urlcleanup, urlopen as urlopen, urlretrieve as urlretrieve, ) ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/3/six/moves/urllib/response.pyi0000664000175000017500000000060500000000000027773 0ustar00davedave00000000000000# Stubs for six.moves.urllib.response # # Note: Commented out items means they weren't implemented at the time. # Uncomment them when the modules have been added to the typeshed. # from urllib.response import addbase as addbase # from urllib.response import addclosehook as addclosehook # from urllib.response import addinfo as addinfo from urllib.response import addinfourl as addinfourl ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/3/six/moves/urllib/robotparser.pyi0000664000175000017500000000010200000000000030467 0ustar00davedave00000000000000from urllib.robotparser import RobotFileParser as RobotFileParser ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/3/six/moves/urllib_error.pyi0000664000175000017500000000003300000000000027341 0ustar00davedave00000000000000from urllib.error import * ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/3/six/moves/urllib_parse.pyi0000664000175000017500000000003300000000000027322 0ustar00davedave00000000000000from urllib.parse import * ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/3/six/moves/urllib_request.pyi0000664000175000017500000000003600000000000027703 0ustar00davedave00000000000000from .urllib.request import * ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/3/six/moves/urllib_response.pyi0000664000175000017500000000003700000000000030052 0ustar00davedave00000000000000from .urllib.response import * ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/3/six/moves/urllib_robotparser.pyi0000664000175000017500000000004100000000000030551 0ustar00davedave00000000000000from urllib.robotparser import * ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4663794 jedi-0.19.1/jedi/third_party/typeshed/third_party/3/typed_ast/0000775000175000017500000000000000000000000024160 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/3/typed_ast/__init__.pyi0000664000175000017500000000000000000000000026430 0ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/3/typed_ast/ast27.pyi0000664000175000017500000001544500000000000025654 0ustar00davedave00000000000000import typing from typing import Any, Iterator, Optional, Union class NodeVisitor: def visit(self, node: AST) -> Any: ... def generic_visit(self, node: AST) -> None: ... class NodeTransformer(NodeVisitor): def generic_visit(self, node: AST) -> None: ... def parse(source: Union[str, bytes], filename: Union[str, bytes] = ..., mode: str = ...) -> AST: ... def copy_location(new_node: AST, old_node: AST) -> AST: ... def dump(node: AST, annotate_fields: bool = ..., include_attributes: bool = ...) -> str: ... def fix_missing_locations(node: AST) -> AST: ... def get_docstring(node: AST, clean: bool = ...) -> Optional[bytes]: ... def increment_lineno(node: AST, n: int = ...) -> AST: ... def iter_child_nodes(node: AST) -> Iterator[AST]: ... def iter_fields(node: AST) -> Iterator[typing.Tuple[str, Any]]: ... def literal_eval(node_or_string: Union[str, AST]) -> Any: ... def walk(node: AST) -> Iterator[AST]: ... PyCF_ONLY_AST: int # ast classes identifier = str class AST: _attributes: typing.Tuple[str, ...] _fields: typing.Tuple[str, ...] def __init__(self, *args: Any, **kwargs: Any) -> None: ... class mod(AST): ... class Module(mod): body: typing.List[stmt] type_ignores: typing.List[TypeIgnore] class Interactive(mod): body: typing.List[stmt] class Expression(mod): body: expr class FunctionType(mod): argtypes: typing.List[expr] returns: expr class Suite(mod): body: typing.List[stmt] class stmt(AST): lineno: int col_offset: int class FunctionDef(stmt): name: identifier args: arguments body: typing.List[stmt] decorator_list: typing.List[expr] type_comment: Optional[str] class ClassDef(stmt): name: identifier bases: typing.List[expr] body: typing.List[stmt] decorator_list: typing.List[expr] class Return(stmt): value: Optional[expr] class Delete(stmt): targets: typing.List[expr] class Assign(stmt): targets: typing.List[expr] value: expr type_comment: Optional[str] class AugAssign(stmt): target: expr op: operator value: expr class Print(stmt): dest: Optional[expr] values: typing.List[expr] nl: bool class For(stmt): target: expr iter: expr body: typing.List[stmt] orelse: typing.List[stmt] type_comment: Optional[str] class While(stmt): test: expr body: typing.List[stmt] orelse: typing.List[stmt] class If(stmt): test: expr body: typing.List[stmt] orelse: typing.List[stmt] class With(stmt): context_expr: expr optional_vars: Optional[expr] body: typing.List[stmt] type_comment: Optional[str] class Raise(stmt): type: Optional[expr] inst: Optional[expr] tback: Optional[expr] class TryExcept(stmt): body: typing.List[stmt] handlers: typing.List[ExceptHandler] orelse: typing.List[stmt] class TryFinally(stmt): body: typing.List[stmt] finalbody: typing.List[stmt] class Assert(stmt): test: expr msg: Optional[expr] class Import(stmt): names: typing.List[alias] class ImportFrom(stmt): module: Optional[identifier] names: typing.List[alias] level: Optional[int] class Exec(stmt): body: expr globals: Optional[expr] locals: Optional[expr] class Global(stmt): names: typing.List[identifier] class Expr(stmt): value: expr class Pass(stmt): ... class Break(stmt): ... class Continue(stmt): ... class slice(AST): ... _slice = slice # this lets us type the variable named 'slice' below class Slice(slice): lower: Optional[expr] upper: Optional[expr] step: Optional[expr] class ExtSlice(slice): dims: typing.List[slice] class Index(slice): value: expr class Ellipsis(slice): ... class expr(AST): lineno: int col_offset: int class BoolOp(expr): op: boolop values: typing.List[expr] class BinOp(expr): left: expr op: operator right: expr class UnaryOp(expr): op: unaryop operand: expr class Lambda(expr): args: arguments body: expr class IfExp(expr): test: expr body: expr orelse: expr class Dict(expr): keys: typing.List[expr] values: typing.List[expr] class Set(expr): elts: typing.List[expr] class ListComp(expr): elt: expr generators: typing.List[comprehension] class SetComp(expr): elt: expr generators: typing.List[comprehension] class DictComp(expr): key: expr value: expr generators: typing.List[comprehension] class GeneratorExp(expr): elt: expr generators: typing.List[comprehension] class Yield(expr): value: Optional[expr] class Compare(expr): left: expr ops: typing.List[cmpop] comparators: typing.List[expr] class Call(expr): func: expr args: typing.List[expr] keywords: typing.List[keyword] starargs: Optional[expr] kwargs: Optional[expr] class Repr(expr): value: expr class Num(expr): n: Union[int, float, complex] class Str(expr): s: Union[str, bytes] kind: str class Attribute(expr): value: expr attr: identifier ctx: expr_context class Subscript(expr): value: expr slice: _slice ctx: expr_context class Name(expr): id: identifier ctx: expr_context class List(expr): elts: typing.List[expr] ctx: expr_context class Tuple(expr): elts: typing.List[expr] ctx: expr_context class expr_context(AST): ... class AugLoad(expr_context): ... class AugStore(expr_context): ... class Del(expr_context): ... class Load(expr_context): ... class Param(expr_context): ... class Store(expr_context): ... class boolop(AST): ... class And(boolop): ... class Or(boolop): ... class operator(AST): ... class Add(operator): ... class BitAnd(operator): ... class BitOr(operator): ... class BitXor(operator): ... class Div(operator): ... class FloorDiv(operator): ... class LShift(operator): ... class Mod(operator): ... class Mult(operator): ... class Pow(operator): ... class RShift(operator): ... class Sub(operator): ... class unaryop(AST): ... class Invert(unaryop): ... class Not(unaryop): ... class UAdd(unaryop): ... class USub(unaryop): ... class cmpop(AST): ... class Eq(cmpop): ... class Gt(cmpop): ... class GtE(cmpop): ... class In(cmpop): ... class Is(cmpop): ... class IsNot(cmpop): ... class Lt(cmpop): ... class LtE(cmpop): ... class NotEq(cmpop): ... class NotIn(cmpop): ... class comprehension(AST): target: expr iter: expr ifs: typing.List[expr] class ExceptHandler(AST): type: Optional[expr] name: Optional[expr] body: typing.List[stmt] lineno: int col_offset: int class arguments(AST): args: typing.List[expr] vararg: Optional[identifier] kwarg: Optional[identifier] defaults: typing.List[expr] type_comments: typing.List[Optional[str]] class keyword(AST): arg: identifier value: expr class alias(AST): name: identifier asname: Optional[identifier] class TypeIgnore(AST): lineno: int ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/3/typed_ast/ast3.pyi0000664000175000017500000001741200000000000025562 0ustar00davedave00000000000000import typing from typing import Any, Iterator, Optional, Union class NodeVisitor: def visit(self, node: AST) -> Any: ... def generic_visit(self, node: AST) -> None: ... class NodeTransformer(NodeVisitor): def generic_visit(self, node: AST) -> None: ... def parse(source: Union[str, bytes], filename: Union[str, bytes] = ..., mode: str = ..., feature_version: int = ...) -> AST: ... def copy_location(new_node: AST, old_node: AST) -> AST: ... def dump(node: AST, annotate_fields: bool = ..., include_attributes: bool = ...) -> str: ... def fix_missing_locations(node: AST) -> AST: ... def get_docstring(node: AST, clean: bool = ...) -> Optional[str]: ... def increment_lineno(node: AST, n: int = ...) -> AST: ... def iter_child_nodes(node: AST) -> Iterator[AST]: ... def iter_fields(node: AST) -> Iterator[typing.Tuple[str, Any]]: ... def literal_eval(node_or_string: Union[str, AST]) -> Any: ... def walk(node: AST) -> Iterator[AST]: ... PyCF_ONLY_AST: int # ast classes identifier = str class AST: _attributes: typing.Tuple[str, ...] _fields: typing.Tuple[str, ...] def __init__(self, *args: Any, **kwargs: Any) -> None: ... class mod(AST): ... class Module(mod): body: typing.List[stmt] type_ignores: typing.List[TypeIgnore] class Interactive(mod): body: typing.List[stmt] class Expression(mod): body: expr class FunctionType(mod): argtypes: typing.List[expr] returns: expr class Suite(mod): body: typing.List[stmt] class stmt(AST): lineno: int col_offset: int class FunctionDef(stmt): name: identifier args: arguments body: typing.List[stmt] decorator_list: typing.List[expr] returns: Optional[expr] type_comment: Optional[str] class AsyncFunctionDef(stmt): name: identifier args: arguments body: typing.List[stmt] decorator_list: typing.List[expr] returns: Optional[expr] type_comment: Optional[str] class ClassDef(stmt): name: identifier bases: typing.List[expr] keywords: typing.List[keyword] body: typing.List[stmt] decorator_list: typing.List[expr] class Return(stmt): value: Optional[expr] class Delete(stmt): targets: typing.List[expr] class Assign(stmt): targets: typing.List[expr] value: expr type_comment: Optional[str] class AugAssign(stmt): target: expr op: operator value: expr class AnnAssign(stmt): target: expr annotation: expr value: Optional[expr] simple: int class For(stmt): target: expr iter: expr body: typing.List[stmt] orelse: typing.List[stmt] type_comment: Optional[str] class AsyncFor(stmt): target: expr iter: expr body: typing.List[stmt] orelse: typing.List[stmt] type_comment: Optional[str] class While(stmt): test: expr body: typing.List[stmt] orelse: typing.List[stmt] class If(stmt): test: expr body: typing.List[stmt] orelse: typing.List[stmt] class With(stmt): items: typing.List[withitem] body: typing.List[stmt] type_comment: Optional[str] class AsyncWith(stmt): items: typing.List[withitem] body: typing.List[stmt] type_comment: Optional[str] class Raise(stmt): exc: Optional[expr] cause: Optional[expr] class Try(stmt): body: typing.List[stmt] handlers: typing.List[ExceptHandler] orelse: typing.List[stmt] finalbody: typing.List[stmt] class Assert(stmt): test: expr msg: Optional[expr] class Import(stmt): names: typing.List[alias] class ImportFrom(stmt): module: Optional[identifier] names: typing.List[alias] level: Optional[int] class Global(stmt): names: typing.List[identifier] class Nonlocal(stmt): names: typing.List[identifier] class Expr(stmt): value: expr class Pass(stmt): ... class Break(stmt): ... class Continue(stmt): ... class slice(AST): ... _slice = slice # this lets us type the variable named 'slice' below class Slice(slice): lower: Optional[expr] upper: Optional[expr] step: Optional[expr] class ExtSlice(slice): dims: typing.List[slice] class Index(slice): value: expr class expr(AST): lineno: int col_offset: int class BoolOp(expr): op: boolop values: typing.List[expr] class BinOp(expr): left: expr op: operator right: expr class UnaryOp(expr): op: unaryop operand: expr class Lambda(expr): args: arguments body: expr class IfExp(expr): test: expr body: expr orelse: expr class Dict(expr): keys: typing.List[expr] values: typing.List[expr] class Set(expr): elts: typing.List[expr] class ListComp(expr): elt: expr generators: typing.List[comprehension] class SetComp(expr): elt: expr generators: typing.List[comprehension] class DictComp(expr): key: expr value: expr generators: typing.List[comprehension] class GeneratorExp(expr): elt: expr generators: typing.List[comprehension] class Await(expr): value: expr class Yield(expr): value: Optional[expr] class YieldFrom(expr): value: expr class Compare(expr): left: expr ops: typing.List[cmpop] comparators: typing.List[expr] class Call(expr): func: expr args: typing.List[expr] keywords: typing.List[keyword] class Num(expr): n: Union[float, int, complex] class Str(expr): s: str kind: str class FormattedValue(expr): value: expr conversion: typing.Optional[int] format_spec: typing.Optional[expr] class JoinedStr(expr): values: typing.List[expr] class Bytes(expr): s: bytes class NameConstant(expr): value: Any class Ellipsis(expr): ... class Attribute(expr): value: expr attr: identifier ctx: expr_context class Subscript(expr): value: expr slice: _slice ctx: expr_context class Starred(expr): value: expr ctx: expr_context class Name(expr): id: identifier ctx: expr_context class List(expr): elts: typing.List[expr] ctx: expr_context class Tuple(expr): elts: typing.List[expr] ctx: expr_context class expr_context(AST): ... class AugLoad(expr_context): ... class AugStore(expr_context): ... class Del(expr_context): ... class Load(expr_context): ... class Param(expr_context): ... class Store(expr_context): ... class boolop(AST): ... class And(boolop): ... class Or(boolop): ... class operator(AST): ... class Add(operator): ... class BitAnd(operator): ... class BitOr(operator): ... class BitXor(operator): ... class Div(operator): ... class FloorDiv(operator): ... class LShift(operator): ... class Mod(operator): ... class Mult(operator): ... class MatMult(operator): ... class Pow(operator): ... class RShift(operator): ... class Sub(operator): ... class unaryop(AST): ... class Invert(unaryop): ... class Not(unaryop): ... class UAdd(unaryop): ... class USub(unaryop): ... class cmpop(AST): ... class Eq(cmpop): ... class Gt(cmpop): ... class GtE(cmpop): ... class In(cmpop): ... class Is(cmpop): ... class IsNot(cmpop): ... class Lt(cmpop): ... class LtE(cmpop): ... class NotEq(cmpop): ... class NotIn(cmpop): ... class comprehension(AST): target: expr iter: expr ifs: typing.List[expr] is_async: int class ExceptHandler(AST): type: Optional[expr] name: Optional[identifier] body: typing.List[stmt] lineno: int col_offset: int class arguments(AST): args: typing.List[arg] vararg: Optional[arg] kwonlyargs: typing.List[arg] kw_defaults: typing.List[expr] kwarg: Optional[arg] defaults: typing.List[expr] class arg(AST): arg: identifier annotation: Optional[expr] lineno: int col_offset: int type_comment: typing.Optional[str] class keyword(AST): arg: Optional[identifier] value: expr class alias(AST): name: identifier asname: Optional[identifier] class withitem(AST): context_expr: expr optional_vars: Optional[expr] class TypeIgnore(AST): lineno: int ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/3/typed_ast/conversions.pyi0000664000175000017500000000010700000000000027251 0ustar00davedave00000000000000from . import ast3, ast27 def py2to3(ast: ast27.AST) -> ast3.AST: ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4663794 jedi-0.19.1/jedi/third_party/typeshed/third_party/3/waitress/0000775000175000017500000000000000000000000024025 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/3/waitress/__init__.pyi0000664000175000017500000000046400000000000026313 0ustar00davedave00000000000000from typing import Any, Tuple from waitress.server import create_server as create_server def serve(app: Any, **kw: Any) -> None: ... def serve_paste(app: Any, global_conf: Any, **kw: Any) -> int: ... def profile(cmd: Any, globals: Any, locals: Any, sort_order: Tuple[str, ...], callers: bool) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/3/waitress/adjustments.pyi0000664000175000017500000000416200000000000027114 0ustar00davedave00000000000000from socket import SocketType from typing import Any, Dict, FrozenSet, Iterable, List, Optional, Sequence, Set, Tuple, Union from .compat import HAS_IPV6 as HAS_IPV6, PY2 as PY2, WIN as WIN, string_types as string_types from .proxy_headers import PROXY_HEADERS as PROXY_HEADERS truthy: FrozenSet KNOWN_PROXY_HEADERS: FrozenSet def asbool(s: Optional[Union[bool, str, int]]) -> bool: ... def asoctal(s: str) -> int: ... def aslist_cronly(value: str) -> List[str]: ... def aslist(value: str) -> List[str]: ... def asset(value: Optional[str]) -> Set[str]: ... def slash_fixed_str(s: Optional[str]) -> str: ... def str_iftruthy(s: Optional[str]) -> Optional[str]: ... def as_socket_list(sockets: Sequence[object]) -> List[SocketType]: ... class _str_marker(str): ... class _int_marker(int): ... class _bool_marker: ... class Adjustments: host: _str_marker = ... port: _int_marker = ... listen: List[str] = ... threads: int = ... trusted_proxy: Optional[str] = ... trusted_proxy_count: Optional[int] = ... trusted_proxy_headers: Set[str] = ... log_untrusted_proxy_headers: bool = ... clear_untrusted_proxy_headers: Union[_bool_marker, bool] = ... url_scheme: str = ... url_prefix: str = ... ident: str = ... backlog: int = ... recv_bytes: int = ... send_bytes: int = ... outbuf_overflow: int = ... outbuf_high_watermark: int = ... inbuf_overflow: int = ... connection_limit: int = ... cleanup_interval: int = ... channel_timeout: int = ... log_socket_errors: bool = ... max_request_header_size: int = ... max_request_body_size: int = ... expose_tracebacks: bool = ... unix_socket: Optional[str] = ... unix_socket_perms: int = ... socket_options: List[Tuple[int, int, int]] = ... asyncore_loop_timeout: int = ... asyncore_use_poll: bool = ... ipv4: bool = ... ipv6: bool = ... sockets: List[SocketType] = ... def __init__(self, **kw: Any) -> None: ... @classmethod def parse_args(cls, argv: str) -> Tuple[Dict[str, Any], Any]: ... @classmethod def check_sockets(cls, sockets: Iterable[SocketType]) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/3/waitress/buffers.pyi0000664000175000017500000000420300000000000026203 0ustar00davedave00000000000000from io import BufferedIOBase, BufferedRandom, BytesIO from typing import Any, Callable, Optional COPY_BYTES: int STRBUF_LIMIT: int class FileBasedBuffer: remain: int = ... file: BytesIO = ... def __init__(self, file: BytesIO, from_buffer: Optional[BytesIO] = ...) -> None: ... def __len__(self) -> int: ... def __nonzero__(self) -> bool: ... __bool__: Callable[[], bool] = ... def append(self, s: Any) -> None: ... def get(self, numbytes: int = ..., skip: bool = ...) -> bytes: ... def skip(self, numbytes: int, allow_prune: int = ...) -> None: ... def newfile(self) -> Any: ... def prune(self) -> None: ... def getfile(self) -> Any: ... def close(self) -> None: ... class TempfileBasedBuffer(FileBasedBuffer): def __init__(self, from_buffer: Optional[BytesIO] = ...) -> None: ... def newfile(self) -> BufferedRandom: ... class BytesIOBasedBuffer(FileBasedBuffer): file: BytesIO = ... def __init__(self, from_buffer: Optional[BytesIO] = ...) -> None: ... def newfile(self) -> BytesIO: ... class ReadOnlyFileBasedBuffer(FileBasedBuffer): file: BytesIO = ... block_size: int = ... def __init__(self, file: BytesIO, block_size: int = ...) -> None: ... remain: int = ... def prepare(self, size: Optional[int] = ...) -> int: ... def get(self, numbytes: int = ..., skip: bool = ...) -> bytes: ... def __iter__(self) -> ReadOnlyFileBasedBuffer: ... def next(self) -> Optional[bytes]: ... __next__: Callable[[], Optional[bytes]] = ... def append(self, s: Any) -> None: ... class OverflowableBuffer: overflowed: bool = ... buf: Optional[BufferedIOBase] = ... strbuf: bytes = ... overflow: int = ... def __init__(self, overflow: int) -> None: ... def __len__(self) -> int: ... def __nonzero__(self) -> bool: ... __bool__: Callable[[], bool] = ... def append(self, s: bytes) -> None: ... def get(self, numbytes: int = ..., skip: bool = ...) -> bytes: ... def skip(self, numbytes: int, allow_prune: bool = ...) -> None: ... def prune(self) -> None: ... def getfile(self) -> BytesIO: ... def close(self) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/3/waitress/channel.pyi0000664000175000017500000000346300000000000026166 0ustar00davedave00000000000000from socket import SocketType from threading import Condition, Lock from typing import Mapping, Optional, Sequence, Tuple from waitress.adjustments import Adjustments from waitress.buffers import OverflowableBuffer from waitress.parser import HTTPRequestParser from waitress.server import BaseWSGIServer from waitress.task import ErrorTask, WSGITask from . import wasyncore as wasyncore class ClientDisconnected(Exception): ... class HTTPChannel(wasyncore.dispatcher): task_class: WSGITask = ... error_task_class: ErrorTask = ... parser_class: HTTPRequestParser = ... request: HTTPRequestParser = ... last_activity: float = ... will_close: bool = ... close_when_flushed: bool = ... requests: Sequence[HTTPRequestParser] = ... sent_continue: bool = ... total_outbufs_len: int = ... current_outbuf_count: int = ... server: BaseWSGIServer = ... adj: Adjustments = ... outbufs: Sequence[OverflowableBuffer] = ... creation_time: float = ... sendbuf_len: int = ... task_lock: Lock = ... outbuf_lock: Condition = ... addr: Tuple[str, int] = ... def __init__( self, server: BaseWSGIServer, sock: SocketType, addr: str, adj: Adjustments, map: Optional[Mapping[int, SocketType]] = ... ) -> None: ... def writable(self) -> bool: ... def handle_write(self) -> None: ... def readable(self) -> bool: ... def handle_read(self) -> None: ... def received(self, data: bytes) -> bool: ... connected: bool = ... def handle_close(self) -> None: ... def add_channel(self, map: Optional[Mapping[int, SocketType]] = ...) -> None: ... def del_channel(self, map: Optional[Mapping[int, SocketType]] = ...) -> None: ... def write_soon(self, data: bytes) -> int: ... def service(self) -> None: ... def cancel(self) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/3/waitress/compat.pyi0000664000175000017500000000131700000000000026035 0ustar00davedave00000000000000import sys from io import TextIOWrapper from typing import Any, Optional, Tuple PY2: bool PY3: bool WIN: bool string_types: Tuple[ str, ] integer_types: Tuple[ int, ] class_types: Tuple[ type, ] text_type = str binary_type = bytes long = int def unquote_bytes_to_wsgi(bytestring: bytes) -> str: ... def text_(s: str, encoding: str = ..., errors: str = ...) -> str: ... def tostr(s: str) -> str: ... def tobytes(s: str) -> bytes: ... exec_: Any def reraise(tp: Any, value: BaseException, tb: Optional[str] = ...) -> None: ... MAXINT: int HAS_IPV6: bool IPPROTO_IPV6: int IPV6_V6ONLY: int def set_nonblocking(fd: TextIOWrapper) -> None: ... ResourceWarning: Warning def qualname(cls: Any) -> str: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/3/waitress/parser.pyi0000664000175000017500000000264200000000000026050 0ustar00davedave00000000000000from io import BytesIO from typing import Mapping, Optional, Pattern, Sequence, Tuple, Union from waitress.adjustments import Adjustments from waitress.receiver import ChunkedReceiver, FixedStreamReceiver from waitress.utilities import Error from .rfc7230 import HEADER_FIELD as HEADER_FIELD class ParsingError(Exception): ... class TransferEncodingNotImplemented(Exception): ... class HTTPRequestParser: completed: bool = ... empty: bool = ... expect_continue: bool = ... headers_finished: bool = ... header_plus: bytes = ... chunked: bool = ... content_length: int = ... header_bytes_received: int = ... body_bytes_received: int = ... body_rcv: Optional[Union[ChunkedReceiver, FixedStreamReceiver]] = ... version: str = ... error: Optional[Error] = ... connection_close: bool = ... headers: Mapping[str, str] = ... adj: Adjustments = ... def __init__(self, adj: Adjustments) -> None: ... def received(self, data: bytes) -> int: ... first_line: str = ... command: bytes = ... url_scheme: str = ... def parse_header(self, header_plus: bytes) -> None: ... def get_body_stream(self) -> BytesIO: ... def close(self) -> None: ... def split_uri(uri: bytes) -> Tuple[str, str, bytes, str, str]: ... def get_header_lines(header: bytes) -> Sequence[bytes]: ... first_line_re: Pattern def crack_first_line(line: str) -> Tuple[bytes, bytes, bytes]: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/3/waitress/proxy_headers.pyi0000664000175000017500000000211400000000000027422 0ustar00davedave00000000000000from collections import namedtuple from logging import Logger from typing import Any, Callable, Mapping, Optional, Sequence, Set from .utilities import BadRequest as BadRequest PROXY_HEADERS: frozenset Forwarded = namedtuple("Forwarded", ["by", "for_", "host", "proto"]) class MalformedProxyHeader(Exception): header: str = ... reason: str = ... value: str = ... def __init__(self, header: str, reason: str, value: str) -> None: ... def proxy_headers_middleware( app: Any, trusted_proxy: Optional[str] = ..., trusted_proxy_count: int = ..., trusted_proxy_headers: Optional[Set[str]] = ..., clear_untrusted: bool = ..., log_untrusted: bool = ..., logger: Logger = ..., ) -> Callable[..., Any]: ... def parse_proxy_headers( environ: Mapping[str, str], trusted_proxy_count: int, trusted_proxy_headers: Set[str], logger: Logger = ... ) -> Set[str]: ... def strip_brackets(addr: str) -> str: ... def clear_untrusted_headers( environ: Mapping[str, str], untrusted_headers: Sequence[str], log_warning: bool = ..., logger: Logger = ... ) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/3/waitress/receiver.pyi0000664000175000017500000000202400000000000026352 0ustar00davedave00000000000000from io import BytesIO from typing import Optional from waitress.buffers import OverflowableBuffer from waitress.utilities import BadRequest class FixedStreamReceiver: completed: bool = ... error: None = ... remain: int = ... buf: OverflowableBuffer = ... def __init__(self, cl: int, buf: OverflowableBuffer) -> None: ... def __len__(self) -> int: ... def received(self, data: bytes) -> int: ... def getfile(self) -> BytesIO: ... def getbuf(self) -> OverflowableBuffer: ... class ChunkedReceiver: chunk_remainder: int = ... validate_chunk_end: bool = ... control_line: bytes = ... chunk_end: bytes = ... all_chunks_received: bool = ... trailer: bytes = ... completed: bool = ... error: Optional[BadRequest] = ... buf: OverflowableBuffer = ... def __init__(self, buf: OverflowableBuffer) -> None: ... def __len__(self) -> int: ... def received(self, s: bytes) -> int: ... def getfile(self) -> BytesIO: ... def getbuf(self) -> OverflowableBuffer: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/3/waitress/rfc7230.pyi0000664000175000017500000000034200000000000025635 0ustar00davedave00000000000000from typing import Pattern from .compat import tobytes as tobytes WS: str OWS: str RWS: str BWS = str TCHAR: str OBS_TEXT: str TOKEN: str VCHAR: str FIELD_VCHAR: str FIELD_CONTENT: str FIELD_VALUE: str HEADER_FIELD: Pattern ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/3/waitress/runner.pyi0000664000175000017500000000072500000000000026065 0ustar00davedave00000000000000from io import TextIOWrapper from typing import Any, Callable, Optional, Pattern, Sequence, Tuple HELP: str RUNNER_PATTERN: Pattern def match(obj_name: str) -> Tuple[str, str]: ... def resolve(module_name: str, object_name: str) -> Any: ... def show_help(stream: TextIOWrapper, name: str, error: Optional[str] = ...) -> None: ... def show_exception(stream: TextIOWrapper) -> None: ... def run(argv: Sequence[str] = ..., _serve: Callable[..., Any] = ...) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/3/waitress/server.pyi0000664000175000017500000000665400000000000026071 0ustar00davedave00000000000000from socket import SocketType from typing import Any, Optional, Sequence, Tuple, Union from waitress.adjustments import Adjustments from waitress.channel import HTTPChannel from waitress.task import Task, ThreadedTaskDispatcher from . import wasyncore def create_server( application: Any, map: Optional[Any] = ..., _start: bool = ..., _sock: Optional[SocketType] = ..., _dispatcher: Optional[ThreadedTaskDispatcher] = ..., **kw: Any, ) -> Union[MultiSocketServer, BaseWSGIServer]: ... class MultiSocketServer: asyncore: Any = ... adj: Adjustments = ... map: Any = ... effective_listen: Sequence[Tuple[str, int]] = ... task_dispatcher: ThreadedTaskDispatcher = ... def __init__( self, map: Optional[Any] = ..., adj: Optional[Adjustments] = ..., effective_listen: Optional[Sequence[Tuple[str, int]]] = ..., dispatcher: Optional[ThreadedTaskDispatcher] = ..., ) -> None: ... def print_listen(self, format_str: str) -> None: ... def run(self) -> None: ... def close(self) -> None: ... class BaseWSGIServer(wasyncore.dispatcher): channel_class: HTTPChannel = ... next_channel_cleanup: int = ... socketmod: SocketType = ... asyncore: Any = ... sockinfo: Tuple[int, int, int, Tuple[str, int]] = ... family: int = ... socktype: int = ... application: Any = ... adj: Adjustments = ... trigger: int = ... task_dispatcher: ThreadedTaskDispatcher = ... server_name: str = ... active_channels: HTTPChannel = ... def __init__( self, application: Any, map: Optional[Any] = ..., _start: bool = ..., _sock: Optional[Any] = ..., dispatcher: Optional[ThreadedTaskDispatcher] = ..., adj: Optional[Adjustments] = ..., sockinfo: Optional[Any] = ..., bind_socket: bool = ..., **kw: Any, ) -> None: ... def bind_server_socket(self) -> None: ... def get_server_name(self, ip: str) -> str: ... def getsockname(self) -> Any: ... accepting: bool = ... def accept_connections(self) -> None: ... def add_task(self, task: Task) -> None: ... def readable(self) -> bool: ... def writable(self) -> bool: ... def handle_read(self) -> None: ... def handle_connect(self) -> None: ... def handle_accept(self) -> None: ... def run(self) -> None: ... def pull_trigger(self) -> None: ... def set_socket_options(self, conn: Any) -> None: ... def fix_addr(self, addr: Any) -> Any: ... def maintenance(self, now: int) -> None: ... def print_listen(self, format_str: str) -> None: ... def close(self) -> None: ... class TcpWSGIServer(BaseWSGIServer): def bind_server_socket(self) -> None: ... def getsockname(self) -> Tuple[str, Tuple[str, int]]: ... def set_socket_options(self, conn: SocketType) -> None: ... class UnixWSGIServer(BaseWSGIServer): def __init__( self, application: Any, map: Optional[Any] = ..., _start: bool = ..., _sock: Optional[Any] = ..., dispatcher: Optional[Any] = ..., adj: Optional[Adjustments] = ..., sockinfo: Optional[Any] = ..., **kw: Any, ) -> None: ... def bind_server_socket(self) -> None: ... def getsockname(self) -> Tuple[str, Tuple[str, int]]: ... def fix_addr(self, addr: Any) -> Tuple[str, None]: ... def get_server_name(self, ip: Any) -> str: ... WSGIServer: TcpWSGIServer ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/3/waitress/task.pyi0000664000175000017500000000425000000000000025513 0ustar00davedave00000000000000from logging import Logger from threading import Condition, Lock from typing import Any, Deque, Mapping, Optional, Sequence, Set, Tuple from .channel import HTTPChannel from .utilities import Error rename_headers: Mapping[str, str] hop_by_hop: frozenset class ThreadedTaskDispatcher: stop_count: int = ... active_count: int = ... logger: Logger = ... queue_logger: Logger = ... threads: Set = ... queue: Deque[Task] = ... lock: Lock = ... queue_cv: Condition = ... thread_exit_cv: Condition = ... def __init__(self) -> None: ... def start_new_thread(self, target: Any, args: Any) -> None: ... def handler_thread(self, thread_no: int) -> None: ... def set_thread_count(self, count: int) -> None: ... def add_task(self, task: Task) -> None: ... def shutdown(self, cancel_pending: bool = ..., timeout: int = ...) -> bool: ... class Task: close_on_finish: bool = ... status: str = ... wrote_header: bool = ... start_time: int = ... content_length: Optional[int] = ... content_bytes_written: int = ... logged_write_excess: bool = ... logged_write_no_body: bool = ... complete: bool = ... chunked_response: bool = ... logger: Logger = ... channel: HTTPChannel = ... request: Error = ... response_headers: Sequence[Tuple[str, str]] = ... version: str = ... def __init__(self, channel: HTTPChannel, request: Error) -> None: ... def service(self) -> None: ... @property def has_body(self) -> bool: ... def build_response_header(self) -> bytes: ... def remove_content_length_header(self) -> None: ... def start(self) -> None: ... def finish(self) -> None: ... def write(self, data: bytes) -> None: ... class ErrorTask(Task): complete: bool = ... status: str = ... close_on_finish: bool = ... content_length: int = ... def execute(self) -> None: ... class WSGITask(Task): environ: Optional[Any] = ... response_headers: Sequence[Tuple[str, str]] = ... complete: bool = ... status: str = ... content_length: int = ... close_on_finish: bool = ... def execute(self) -> None: ... def get_environment(self) -> Any: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/3/waitress/trigger.pyi0000664000175000017500000000206700000000000026220 0ustar00davedave00000000000000import sys from socket import SocketType from threading import Lock from typing import Callable, Mapping, Optional from typing_extensions import Literal from . import wasyncore as wasyncore class _triggerbase: kind: Optional[str] = ... lock: Lock = ... thunks: Callable[[None], None] = ... def __init__(self) -> None: ... def readable(self) -> Literal[True]: ... def writable(self) -> Literal[False]: ... def handle_connect(self) -> None: ... def handle_close(self) -> None: ... def close(self) -> None: ... def pull_trigger(self, thunk: Optional[Callable[[None], None]] = ...) -> None: ... def handle_read(self) -> None: ... if sys.platform == "linux" or sys.platform == "darwin": class trigger(_triggerbase, wasyncore.file_dispatcher): kind: str = ... def __init__(self, map: Mapping[str, _triggerbase]) -> None: ... else: class trigger(_triggerbase, wasyncore.dispatcher): kind: str = ... trigger: SocketType = ... def __init__(self, map: Mapping[str, _triggerbase]) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/3/waitress/utilities.pyi0000664000175000017500000000352300000000000026566 0ustar00davedave00000000000000from logging import Logger from typing import Any, Callable, Mapping, Match, Pattern, Sequence, Tuple from .rfc7230 import OBS_TEXT as OBS_TEXT, VCHAR as VCHAR logger: Logger queue_logger: Logger def find_double_newline(s: bytes) -> int: ... def concat(*args: Any) -> str: ... def join(seq: Any, field: str = ...) -> str: ... def group(s: Any) -> str: ... short_days: Sequence[str] long_days: Sequence[str] short_day_reg: str long_day_reg: str daymap: Mapping[str, int] hms_reg: str months: Sequence[str] monmap: Mapping[str, int] months_reg: str rfc822_date: str rfc822_reg: Pattern def unpack_rfc822(m: Match) -> Tuple[int, int, int, int, int, int, int, int, int]: ... rfc850_date: str rfc850_reg: Pattern def unpack_rfc850(m: Match) -> Tuple[int, int, int, int, int, int, int, int, int]: ... weekdayname: Sequence[str] monthname: Sequence[str] def build_http_date(when: int) -> str: ... def parse_http_date(d: str) -> int: ... vchar_re: str obs_text_re: str qdtext_re: str quoted_pair_re: str quoted_string_re: str quoted_string: Pattern quoted_pair: Pattern def undquote(value: str) -> str: ... def cleanup_unix_socket(path: str) -> None: ... class Error: code: int = ... reason: str = ... body: str = ... def __init__(self, body: str) -> None: ... def to_response(self) -> Tuple[str, Sequence[Tuple[str, str]], str]: ... def wsgi_response(self, environ: Any, start_response: Callable[[str, Sequence[Tuple[str, str]]], None]) -> str: ... class BadRequest(Error): code: int = ... reason: str = ... class RequestHeaderFieldsTooLarge(BadRequest): code: int = ... reason: str = ... class RequestEntityTooLarge(BadRequest): code: int = ... reason: str = ... class InternalServerError(Error): code: int = ... reason: str = ... class ServerNotImplemented(Error): code: int = ... reason: str = ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238277.0 jedi-0.19.1/jedi/third_party/typeshed/third_party/3/waitress/wasyncore.pyi0000664000175000017500000000773300000000000026574 0ustar00davedave00000000000000from io import BytesIO from logging import Logger from socket import SocketType from typing import Any, Callable, Mapping, Optional, Tuple from . import compat as compat, utilities as utilities socket_map: Mapping[int, SocketType] map: Mapping[int, SocketType] class ExitNow(Exception): ... def read(obj: dispatcher) -> None: ... def write(obj: dispatcher) -> None: ... def readwrite(obj: dispatcher, flags: int) -> None: ... def poll(timeout: float = ..., map: Optional[Mapping[int, SocketType]] = ...) -> None: ... def poll2(timeout: float = ..., map: Optional[Mapping[int, SocketType]] = ...) -> None: ... poll3 = poll2 def loop( timeout: float = ..., use_poll: bool = ..., map: Optional[Mapping[int, SocketType]] = ..., count: Optional[int] = ... ) -> None: ... def compact_traceback() -> Tuple[Tuple[str, str, str], BaseException, BaseException, str]: ... class dispatcher: debug: bool = ... connected: bool = ... accepting: bool = ... connecting: bool = ... closing: bool = ... addr: Optional[Tuple[str, int]] = ... ignore_log_types: frozenset = ... logger: Logger = ... compact_traceback: Callable[[], Tuple[Tuple[str, str, str], BaseException, BaseException, str]] = ... socket: Optional[SocketType] = ... def __init__(self, sock: Optional[SocketType] = ..., map: Optional[Mapping[int, SocketType]] = ...) -> None: ... def add_channel(self, map: Optional[Mapping[int, SocketType]] = ...) -> None: ... def del_channel(self, map: Optional[Mapping[int, SocketType]] = ...) -> None: ... family_and_type: Tuple[int, int] = ... def create_socket(self, family: int = ..., type: int = ...) -> None: ... def set_socket(self, sock: SocketType, map: Optional[Mapping[int, SocketType]] = ...) -> None: ... def set_reuse_addr(self) -> None: ... def readable(self) -> bool: ... def writable(self) -> bool: ... def listen(self, num: int) -> None: ... def bind(self, addr: Tuple[str, int]) -> None: ... def connect(self, address: Tuple[str, int]) -> None: ... def accept(self) -> Optional[Tuple[SocketType, Tuple[str, int]]]: ... def send(self, data: bytes) -> int: ... def recv(self, buffer_size: int) -> bytes: ... def close(self) -> None: ... def log(self, message: str) -> None: ... def log_info(self, message: str, type: str = ...) -> None: ... def handle_read_event(self) -> None: ... def handle_connect_event(self) -> None: ... def handle_write_event(self) -> None: ... def handle_expt_event(self) -> None: ... def handle_error(self) -> None: ... def handle_expt(self) -> None: ... def handle_read(self) -> None: ... def handle_write(self) -> None: ... def handle_connect(self) -> None: ... def handle_accept(self) -> None: ... def handle_accepted(self, sock: SocketType, addr: Any) -> None: ... def handle_close(self) -> None: ... class dispatcher_with_send(dispatcher): out_buffer: bytes = ... def __init__(self, sock: Optional[SocketType] = ..., map: Optional[Mapping[int, SocketType]] = ...) -> None: ... def initiate_send(self) -> None: ... handle_write: Callable[[], None] = ... def writable(self) -> bool: ... def send(self, data: bytes) -> None: ... # type: ignore def close_all(map: Optional[Mapping[int, SocketType]] = ..., ignore_all: bool = ...) -> None: ... class file_wrapper: fd: BytesIO = ... def __init__(self, fd: BytesIO) -> None: ... def __del__(self) -> None: ... def recv(self, *args: Any) -> bytes: ... def send(self, *args: Any) -> bytes: ... def getsockopt(self, level: int, optname: int, buflen: Optional[bool] = ...) -> int: ... read: Callable[..., bytes] = ... write: Callable[..., bytes] = ... def close(self) -> None: ... def fileno(self) -> BytesIO: ... class file_dispatcher(dispatcher): connected: bool = ... def __init__(self, fd: BytesIO, map: Optional[Mapping[int, SocketType]] = ...) -> None: ... socket: SocketType = ... def set_file(self, fd: BytesIO) -> None: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/jedi/utils.py0000664000175000017500000001111000000000000015017 0ustar00davedave00000000000000""" Utilities for end-users. """ import __main__ from collections import namedtuple import logging import traceback import re import os import sys from jedi import Interpreter READLINE_DEBUG = False def setup_readline(namespace_module=__main__, fuzzy=False): """ This function sets up :mod:`readline` to use Jedi in a Python interactive shell. If you want to use a custom ``PYTHONSTARTUP`` file (typically ``$HOME/.pythonrc.py``), you can add this piece of code:: try: from jedi.utils import setup_readline except ImportError: # Fallback to the stdlib readline completer if it is installed. # Taken from http://docs.python.org/2/library/rlcompleter.html print("Jedi is not installed, falling back to readline") try: import readline import rlcompleter readline.parse_and_bind("tab: complete") except ImportError: print("Readline is not installed either. No tab completion is enabled.") else: setup_readline() This will fallback to the readline completer if Jedi is not installed. The readline completer will only complete names in the global namespace, so for example:: ran will complete to ``range``. With Jedi the following code:: range(10).cou will complete to ``range(10).count``, this does not work with the default cPython :mod:`readline` completer. You will also need to add ``export PYTHONSTARTUP=$HOME/.pythonrc.py`` to your shell profile (usually ``.bash_profile`` or ``.profile`` if you use bash). """ if READLINE_DEBUG: logging.basicConfig( filename='/tmp/jedi.log', filemode='a', level=logging.DEBUG ) class JediRL: def complete(self, text, state): """ This complete stuff is pretty weird, a generator would make a lot more sense, but probably due to backwards compatibility this is still the way how it works. The only important part is stuff in the ``state == 0`` flow, everything else has been copied from the ``rlcompleter`` std. library module. """ if state == 0: sys.path.insert(0, os.getcwd()) # Calling python doesn't have a path, so add to sys.path. try: logging.debug("Start REPL completion: " + repr(text)) interpreter = Interpreter(text, [namespace_module.__dict__]) completions = interpreter.complete(fuzzy=fuzzy) logging.debug("REPL completions: %s", completions) self.matches = [ text[:len(text) - c._like_name_length] + c.name_with_symbols for c in completions ] except: logging.error("REPL Completion error:\n" + traceback.format_exc()) raise finally: sys.path.pop(0) try: return self.matches[state] except IndexError: return None try: # Need to import this one as well to make sure it's executed before # this code. This didn't use to be an issue until 3.3. Starting with # 3.4 this is different, it always overwrites the completer if it's not # already imported here. import rlcompleter # noqa: F401 import readline except ImportError: print("Jedi: Module readline not available.") else: readline.set_completer(JediRL().complete) readline.parse_and_bind("tab: complete") # jedi itself does the case matching readline.parse_and_bind("set completion-ignore-case on") # because it's easier to hit the tab just once readline.parse_and_bind("set show-all-if-unmodified") readline.parse_and_bind("set show-all-if-ambiguous on") # don't repeat all the things written in the readline all the time readline.parse_and_bind("set completion-prefix-display-length 2") # No delimiters, Jedi handles that. readline.set_completer_delims('') def version_info(): """ Returns a namedtuple of Jedi's version, similar to Python's ``sys.version_info``. """ Version = namedtuple('Version', 'major, minor, micro') from jedi import __version__ tupl = re.findall(r'[a-z]+|\d+', __version__) return Version(*[x if i == 3 else int(x) for i, x in enumerate(tupl)]) ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.3903792 jedi-0.19.1/jedi.egg-info/0000775000175000017500000000000000000000000015005 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238359.0 jedi-0.19.1/jedi.egg-info/PKG-INFO0000664000175000017500000006153300000000000016112 0ustar00davedave00000000000000Metadata-Version: 2.1 Name: jedi Version: 0.19.1 Summary: An autocompletion tool for Python that can be used for text editors. Home-page: https://github.com/davidhalter/jedi Author: David Halter Author-email: davidhalter88@gmail.com Maintainer: David Halter Maintainer-email: davidhalter88@gmail.com License: MIT Project-URL: Documentation, https://jedi.readthedocs.io/en/latest/ Description: #################################################################################### Jedi - an awesome autocompletion, static analysis and refactoring library for Python #################################################################################### .. image:: http://isitmaintained.com/badge/open/davidhalter/jedi.svg :target: https://github.com/davidhalter/jedi/issues :alt: The percentage of open issues and pull requests .. image:: http://isitmaintained.com/badge/resolution/davidhalter/jedi.svg :target: https://github.com/davidhalter/jedi/issues :alt: The resolution time is the median time an issue or pull request stays open. .. image:: https://github.com/davidhalter/jedi/workflows/ci/badge.svg?branch=master :target: https://github.com/davidhalter/jedi/actions :alt: Tests .. image:: https://pepy.tech/badge/jedi :target: https://pepy.tech/project/jedi :alt: PyPI Downloads Jedi is a static analysis tool for Python that is typically used in IDEs/editors plugins. Jedi has a focus on autocompletion and goto functionality. Other features include refactoring, code search and finding references. Jedi has a simple API to work with. There is a reference implementation as a `VIM-Plugin `_. Autocompletion in your REPL is also possible, IPython uses it natively and for the CPython REPL you can install it. Jedi is well tested and bugs should be rare. Jedi can currently be used with the following editors/projects: - Vim (jedi-vim_, YouCompleteMe_, deoplete-jedi_, completor.vim_) - `Visual Studio Code`_ (via `Python Extension `_) - Emacs (Jedi.el_, company-mode_, elpy_, anaconda-mode_, ycmd_) - Sublime Text (SublimeJEDI_ [ST2 + ST3], anaconda_ [only ST3]) - TextMate_ (Not sure if it's actually working) - Kate_ version 4.13+ supports it natively, you have to enable it, though. [`see `_] - Atom_ (autocomplete-python-jedi_) - `GNOME Builder`_ (with support for GObject Introspection) - Gedit (gedi_) - wdb_ - Web Debugger - `Eric IDE`_ - `IPython 6.0.0+ `_ - `xonsh shell `_ has `jedi extension `_ and many more! There are a few language servers that use Jedi: - `jedi-language-server `_ - `python-language-server `_ (currently unmaintained) - `python-lsp-server `_ (fork from python-language-server) - `anakin-language-server `_ Here are some pictures taken from jedi-vim_: .. image:: https://github.com/davidhalter/jedi/raw/master/docs/_screenshots/screenshot_complete.png Completion for almost anything: .. image:: https://github.com/davidhalter/jedi/raw/master/docs/_screenshots/screenshot_function.png Documentation: .. image:: https://github.com/davidhalter/jedi/raw/master/docs/_screenshots/screenshot_pydoc.png Get the latest version from `github `_ (master branch should always be kind of stable/working). Docs are available at `https://jedi.readthedocs.org/en/latest/ `_. Pull requests with enhancements and/or fixes are awesome and most welcome. Jedi uses `semantic versioning `_. If you want to stay **up-to-date** with releases, please **subscribe** to this mailing list: https://groups.google.com/g/jedi-announce. To subscribe you can simply send an empty email to ``jedi-announce+subscribe@googlegroups.com``. Issues & Questions ================== You can file issues and questions in the `issue tracker `. Alternatively you can also ask on `Stack Overflow `_ with the label ``python-jedi``. Installation ============ `Check out the docs `_. Features and Limitations ======================== Jedi's features are listed here: `Features `_. You can run Jedi on Python 3.6+ but it should also understand code that is older than those versions. Additionally you should be able to use `Virtualenvs `_ very well. Tips on how to use Jedi efficiently can be found `here `_. API --- You can find a comprehensive documentation for the `API here `_. Autocompletion / Goto / Documentation ------------------------------------- There are the following commands: - ``jedi.Script.goto`` - ``jedi.Script.infer`` - ``jedi.Script.help`` - ``jedi.Script.complete`` - ``jedi.Script.get_references`` - ``jedi.Script.get_signatures`` - ``jedi.Script.get_context`` The returned objects are very powerful and are really all you might need. Autocompletion in your REPL (IPython, etc.) ------------------------------------------- Jedi is a dependency of IPython. Autocompletion in IPython with Jedi is therefore possible without additional configuration. Here is an `example video `_ how REPL completion can look like. For the ``python`` shell you can enable tab completion in a `REPL `_. Static Analysis --------------- For a lot of forms of static analysis, you can try to use ``jedi.Script(...).get_names``. It will return a list of names that you can then filter and work with. There is also a way to list the syntax errors in a file: ``jedi.Script.get_syntax_errors``. Refactoring ----------- Jedi supports the following refactorings: - ``jedi.Script.inline`` - ``jedi.Script.rename`` - ``jedi.Script.extract_function`` - ``jedi.Script.extract_variable`` Code Search ----------- There is support for module search with ``jedi.Script.search``, and project search for ``jedi.Project.search``. The way to search is either by providing a name like ``foo`` or by using dotted syntax like ``foo.bar``. Additionally you can provide the API type like ``class foo.bar.Bar``. There are also the functions ``jedi.Script.complete_search`` and ``jedi.Project.complete_search``. Development =========== There's a pretty good and extensive `development documentation `_. Testing ======= The test suite uses ``pytest``:: pip install pytest If you want to test only a specific Python version (e.g. Python 3.8), it is as easy as:: python3.8 -m pytest For more detailed information visit the `testing documentation `_. Acknowledgements ================ Thanks a lot to all the `contributors `_! .. _jedi-vim: https://github.com/davidhalter/jedi-vim .. _youcompleteme: https://github.com/ycm-core/YouCompleteMe .. _deoplete-jedi: https://github.com/zchee/deoplete-jedi .. _completor.vim: https://github.com/maralla/completor.vim .. _Jedi.el: https://github.com/tkf/emacs-jedi .. _company-mode: https://github.com/syohex/emacs-company-jedi .. _elpy: https://github.com/jorgenschaefer/elpy .. _anaconda-mode: https://github.com/proofit404/anaconda-mode .. _ycmd: https://github.com/abingham/emacs-ycmd .. _sublimejedi: https://github.com/srusskih/SublimeJEDI .. _anaconda: https://github.com/DamnWidget/anaconda .. _wdb: https://github.com/Kozea/wdb .. _TextMate: https://github.com/lawrenceakka/python-jedi.tmbundle .. _Kate: https://kate-editor.org .. _Atom: https://atom.io/ .. _autocomplete-python-jedi: https://atom.io/packages/autocomplete-python-jedi .. _GNOME Builder: https://wiki.gnome.org/Apps/Builder .. _Visual Studio Code: https://code.visualstudio.com/ .. _gedi: https://github.com/isamert/gedi .. _Eric IDE: https://eric-ide.python-projects.org .. :changelog: Changelog --------- Unreleased ++++++++++ 0.19.1 (2023-10-02) +++++++++++++++++++ - Python 3.12 support (Thanks Peter!) 0.19.0 (2023-07-29) +++++++++++++++++++ - Python 3.11 support - Massive improvements in performance for ``Interpreter`` (e.g. IPython) users. This especially affects ``pandas`` users with large datasets. - Add ``jedi.settings.allow_unsafe_interpreter_executions`` to make it easier for IPython users to avoid unsafe executions. 0.18.2 (2022-11-21) +++++++++++++++++++ - Added dataclass-equivalent for attrs.define - Find fixtures from Pytest entrypoints; Examples of pytest plugins installed like this are pytest-django, pytest-sugar and Faker. - Fixed Project.search, when a venv was involved, which is why for example `:Pyimport django.db` did not work in some cases in jedi-vim. - And many smaller bugfixes 0.18.1 (2021-11-17) +++++++++++++++++++ - Implict namespaces are now a separate types in ``Name().type`` - Python 3.10 support - Mostly bugfixes 0.18.0 (2020-12-25) +++++++++++++++++++ - Dropped Python 2 and Python 3.5 - Using ``pathlib.Path()`` as an output instead of ``str`` in most places: - ``Project.path`` - ``Script.path`` - ``Definition.module_path`` - ``Refactoring.get_renames`` - ``Refactoring.get_changed_files`` - Functions with ``@property`` now return ``property`` instead of ``function`` in ``Name().type`` - Started using annotations - Better support for the walrus operator - Project attributes are now read accessible - Removed all deprecations This is likely going to be the last minor release before 1.0. 0.17.2 (2020-07-17) +++++++++++++++++++ - Added an option to pass environment variables to ``Environment`` - ``Project(...).path`` exists now - Support for Python 3.9 - A few bugfixes This will be the last release that supports Python 2 and Python 3.5. ``0.18.0`` will be Python 3.6+. 0.17.1 (2020-06-20) +++++++++++++++++++ - Django ``Model`` meta class support - Django Manager support (completion on Managers/QuerySets) - Added Django Stubs to Jedi, thanks to all contributors of the `Django Stubs `_ project - Added ``SyntaxError.get_message`` - Python 3.9 support - Bugfixes (mostly towards Generics) 0.17.0 (2020-04-14) +++++++++++++++++++ - Added ``Project`` support. This allows a user to specify which folders Jedi should work with. - Added support for Refactoring. The following refactorings have been implemented: ``Script.rename``, ``Script.inline``, ``Script.extract_variable`` and ``Script.extract_function``. - Added ``Script.get_syntax_errors`` to display syntax errors in the current script. - Added code search capabilities both for individual files and projects. The new functions are ``Project.search``, ``Project.complete_search``, ``Script.search`` and ``Script.complete_search``. - Added ``Script.help`` to make it easier to display a help window to people. Now returns pydoc information as well for Python keywords/operators. This means that on the class keyword it will now return the docstring of Python's builtin function ``help('class')``. - The API documentation is now way more readable and complete. Check it out under https://jedi.readthedocs.io. A lot of it has been rewritten. - Removed Python 3.4 support - Many bugfixes This is likely going to be the last minor version that supports Python 2 and Python3.5. Bugfixes will be provided in 0.17.1+. The next minor/major version will probably be Jedi 1.0.0. 0.16.0 (2020-01-26) +++++++++++++++++++ - **Added** ``Script.get_context`` to get information where you currently are. - Completions/type inference of **Pytest fixtures**. - Tensorflow, Numpy and Pandas completions should now be about **4-10x faster** after the first time they are used. - Dict key completions are working now. e.g. ``d = {1000: 3}; d[10`` will expand to ``1000``. - Completion for "proxies" works now. These are classes that have a ``__getattr__(self, name)`` method that does a ``return getattr(x, name)``. after loading them initially. - Goto on a function/attribute in a class now goes to the definition in its super class. - Big **Script API Changes**: - The line and column parameters of ``jedi.Script`` are now deprecated - ``completions`` deprecated, use ``complete`` instead - ``goto_assignments`` deprecated, use ``goto`` instead - ``goto_definitions`` deprecated, use ``infer`` instead - ``call_signatures`` deprecated, use ``get_signatures`` instead - ``usages`` deprecated, use ``get_references`` instead - ``jedi.names`` deprecated, use ``jedi.Script(...).get_names()`` - ``BaseName.goto_assignments`` renamed to ``BaseName.goto`` - Add follow_imports to ``Name.goto``. Now its signature matches ``Script.goto``. - **Python 2 support deprecated**. For this release it is best effort. Python 2 has reached the end of its life and now it's just about a smooth transition. Bugs for Python 2 will not be fixed anymore and a third of the tests are already skipped. - Removed ``settings.no_completion_duplicates``. It wasn't tested and nobody was probably using it anyway. - Removed ``settings.use_filesystem_cache`` and ``settings.additional_dynamic_modules``, they have no usage anymore. Pretty much nobody was probably using them. 0.15.2 (2019-12-20) +++++++++++++++++++ - Signatures are now detected a lot better - Add fuzzy completions with ``Script(...).completions(fuzzy=True)`` - Files bigger than one MB (about 20kLOC) get cropped to avoid getting stuck completely. - Many small Bugfixes - A big refactoring around contexts/values 0.15.1 (2019-08-13) +++++++++++++++++++ - Small bugfix and removal of a print statement 0.15.0 (2019-08-11) +++++++++++++++++++ - Added file path completions, there's a **new** ``Completion.type`` now: ``path``. Example: ``'/ho`` -> ``'/home/`` - ``*args``/``**kwargs`` resolving. If possible Jedi replaces the parameters with the actual alternatives. - Better support for enums/dataclasses - When using Interpreter, properties are now executed, since a lot of people have complained about this. Discussion in #1299, #1347. New APIs: - ``Name.get_signatures() -> List[Signature]``. Signatures are similar to ``CallSignature``. ``Name.params`` is therefore deprecated. - ``Signature.to_string()`` to format signatures. - ``Signature.params -> List[ParamName]``, ParamName has the following additional attributes ``infer_default()``, ``infer_annotation()``, ``to_string()``, and ``kind``. - ``Name.execute() -> List[Name]``, makes it possible to infer return values of functions. 0.14.1 (2019-07-13) +++++++++++++++++++ - CallSignature.index should now be working a lot better - A couple of smaller bugfixes 0.14.0 (2019-06-20) +++++++++++++++++++ - Added ``goto_*(prefer_stubs=True)`` as well as ``goto_*(prefer_stubs=True)`` - Stubs are used now for type inference - Typeshed is used for better type inference - Reworked Name.full_name, should have more correct return values 0.13.3 (2019-02-24) +++++++++++++++++++ - Fixed an issue with embedded Python, see https://github.com/davidhalter/jedi-vim/issues/870 0.13.2 (2018-12-15) +++++++++++++++++++ - Fixed a bug that led to Jedi spawning a lot of subprocesses. 0.13.1 (2018-10-02) +++++++++++++++++++ - Bugfixes, because tensorflow completions were still slow. 0.13.0 (2018-10-02) +++++++++++++++++++ - A small release. Some bug fixes. - Remove Python 3.3 support. Python 3.3 support has been dropped by the Python foundation. - Default environments are now using the same Python version as the Python process. In 0.12.x, we used to load the latest Python version on the system. - Added ``include_builtins`` as a parameter to usages. - ``goto_assignments`` has a new ``follow_builtin_imports`` parameter that changes the previous behavior slightly. 0.12.1 (2018-06-30) +++++++++++++++++++ - This release forces you to upgrade parso. If you don't, nothing will work anymore. Otherwise changes should be limited to bug fixes. Unfortunately Jedi still uses a few internals of parso that make it hard to keep compatibility over multiple releases. Parso >=0.3.0 is going to be needed. 0.12.0 (2018-04-15) +++++++++++++++++++ - Virtualenv/Environment support - F-String Completion/Goto Support - Cannot crash with segfaults anymore - Cleaned up import logic - Understand async/await and autocomplete it (including async generators) - Better namespace completions - Passing tests for Windows (including CI for Windows) - Remove Python 2.6 support 0.11.1 (2017-12-14) +++++++++++++++++++ - Parso update - the caching layer was broken - Better usages - a lot of internal code was ripped out and improved. 0.11.0 (2017-09-20) +++++++++++++++++++ - Split Jedi's parser into a separate project called ``parso``. - Avoiding side effects in REPL completion. - Numpy docstring support should be much better. - Moved the `settings.*recursion*` away, they are no longer usable. 0.10.2 (2017-04-05) +++++++++++++++++++ - Python Packaging sucks. Some files were not included in 0.10.1. 0.10.1 (2017-04-05) +++++++++++++++++++ - Fixed a few very annoying bugs. - Prepared the parser to be factored out of Jedi. 0.10.0 (2017-02-03) +++++++++++++++++++ - Actual semantic completions for the complete Python syntax. - Basic type inference for ``yield from`` PEP 380. - PEP 484 support (most of the important features of it). Thanks Claude! (@reinhrst) - Added ``get_line_code`` to ``Name`` and ``Completion`` objects. - Completely rewritten the type inference engine. - A new and better parser for (fast) parsing diffs of Python code. 0.9.0 (2015-04-10) ++++++++++++++++++ - The import logic has been rewritten to look more like Python's. There is now an ``InferState.modules`` import cache, which resembles ``sys.modules``. - Integrated the parser of 2to3. This will make refactoring possible. It will also be possible to check for error messages (like compiling an AST would give) in the future. - With the new parser, the type inference also completely changed. It's now simpler and more readable. - Completely rewritten REPL completion. - Added ``jedi.names``, a command to do static analysis. Thanks to that sourcegraph guys for sponsoring this! - Alpha version of the linter. 0.8.1 (2014-07-23) +++++++++++++++++++ - Bugfix release, the last release forgot to include files that improve autocompletion for builtin libraries. Fixed. 0.8.0 (2014-05-05) +++++++++++++++++++ - Memory Consumption for compiled modules (e.g. builtins, sys) has been reduced drastically. Loading times are down as well (it takes basically as long as an import). - REPL completion is starting to become usable. - Various small API changes. Generally this release focuses on stability and refactoring of internal APIs. - Introducing operator precedence, which makes calculating correct Array indices and ``__getattr__`` strings possible. 0.7.0 (2013-08-09) ++++++++++++++++++ - Switched from LGPL to MIT license. - Added an Interpreter class to the API to make autocompletion in REPL possible. - Added autocompletion support for namespace packages. - Add sith.py, a new random testing method. 0.6.0 (2013-05-14) ++++++++++++++++++ - Much faster parser with builtin part caching. - A test suite, thanks @tkf. 0.5 versions (2012) +++++++++++++++++++ - Initial development. Keywords: python completion refactoring vim Platform: any Classifier: Development Status :: 4 - Beta Classifier: Environment :: Plugins Classifier: Intended Audience :: Developers Classifier: License :: OSI Approved :: MIT License Classifier: Operating System :: OS Independent Classifier: Programming Language :: Python :: 3 Classifier: Programming Language :: Python :: 3.6 Classifier: Programming Language :: Python :: 3.7 Classifier: Programming Language :: Python :: 3.8 Classifier: Programming Language :: Python :: 3.9 Classifier: Programming Language :: Python :: 3.10 Classifier: Programming Language :: Python :: 3.11 Classifier: Programming Language :: Python :: 3.12 Classifier: Topic :: Software Development :: Libraries :: Python Modules Classifier: Topic :: Text Editors :: Integrated Development Environments (IDE) Classifier: Topic :: Utilities Requires-Python: >=3.6 Provides-Extra: docs Provides-Extra: qa Provides-Extra: testing ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238359.0 jedi-0.19.1/jedi.egg-info/SOURCES.txt0000664000175000017500000037072400000000000016706 0ustar00davedave00000000000000.coveragerc AUTHORS.txt CHANGELOG.rst LICENSE.txt MANIFEST.in README.rst conftest.py pytest.ini setup.cfg setup.py sith.py docs/Makefile docs/README.md docs/conf.py docs/global.rst docs/index.rst docs/_screenshots/screenshot_complete.png docs/_screenshots/screenshot_function.png docs/_screenshots/screenshot_pydoc.png docs/_static/custom_style.css docs/_static/logo-src.txt docs/_static/logo.png docs/_templates/ghbuttons.html docs/_templates/sidebarlogo.html docs/docs/acknowledgements.rst docs/docs/api-classes.rst docs/docs/api.rst docs/docs/changelog.rst docs/docs/development.rst docs/docs/features.rst docs/docs/installation.rst docs/docs/settings.rst docs/docs/testing.rst docs/docs/usage.rst jedi/__init__.py jedi/__main__.py jedi/_compatibility.py jedi/cache.py jedi/common.py jedi/debug.py jedi/file_io.py jedi/parser_utils.py jedi/settings.py jedi/utils.py jedi.egg-info/PKG-INFO jedi.egg-info/SOURCES.txt jedi.egg-info/dependency_links.txt jedi.egg-info/requires.txt jedi.egg-info/top_level.txt jedi/api/__init__.py jedi/api/classes.py jedi/api/completion.py jedi/api/completion_cache.py jedi/api/environment.py jedi/api/errors.py jedi/api/exceptions.py jedi/api/file_name.py jedi/api/helpers.py jedi/api/interpreter.py jedi/api/keywords.py jedi/api/project.py jedi/api/replstartup.py jedi/api/strings.py jedi/api/refactoring/__init__.py jedi/api/refactoring/extract.py jedi/inference/__init__.py jedi/inference/analysis.py jedi/inference/arguments.py jedi/inference/base_value.py jedi/inference/cache.py jedi/inference/context.py jedi/inference/docstring_utils.py jedi/inference/docstrings.py jedi/inference/dynamic_params.py jedi/inference/filters.py jedi/inference/finder.py jedi/inference/flow_analysis.py jedi/inference/helpers.py jedi/inference/imports.py jedi/inference/lazy_value.py jedi/inference/names.py jedi/inference/param.py jedi/inference/parser_cache.py jedi/inference/recursion.py jedi/inference/references.py jedi/inference/signature.py jedi/inference/star_args.py jedi/inference/syntax_tree.py jedi/inference/sys_path.py jedi/inference/utils.py jedi/inference/compiled/__init__.py jedi/inference/compiled/access.py jedi/inference/compiled/getattr_static.py jedi/inference/compiled/mixed.py jedi/inference/compiled/value.py jedi/inference/compiled/subprocess/__init__.py jedi/inference/compiled/subprocess/__main__.py jedi/inference/compiled/subprocess/functions.py jedi/inference/gradual/__init__.py jedi/inference/gradual/annotation.py jedi/inference/gradual/base.py jedi/inference/gradual/conversion.py jedi/inference/gradual/generics.py jedi/inference/gradual/stub_value.py jedi/inference/gradual/type_var.py jedi/inference/gradual/typeshed.py jedi/inference/gradual/typing.py jedi/inference/gradual/utils.py jedi/inference/value/__init__.py jedi/inference/value/decorator.py jedi/inference/value/dynamic_arrays.py jedi/inference/value/function.py jedi/inference/value/instance.py jedi/inference/value/iterable.py jedi/inference/value/klass.py jedi/inference/value/module.py jedi/inference/value/namespace.py jedi/plugins/__init__.py jedi/plugins/django.py jedi/plugins/flask.py jedi/plugins/pytest.py jedi/plugins/registry.py jedi/plugins/stdlib.py jedi/third_party/django-stubs/LICENSE.txt jedi/third_party/django-stubs/django-stubs/__init__.pyi jedi/third_party/django-stubs/django-stubs/shortcuts.pyi jedi/third_party/django-stubs/django-stubs/apps/__init__.pyi jedi/third_party/django-stubs/django-stubs/apps/config.pyi jedi/third_party/django-stubs/django-stubs/apps/registry.pyi jedi/third_party/django-stubs/django-stubs/conf/__init__.pyi jedi/third_party/django-stubs/django-stubs/conf/global_settings.pyi jedi/third_party/django-stubs/django-stubs/conf/locale/__init__.pyi jedi/third_party/django-stubs/django-stubs/conf/urls/__init__.pyi jedi/third_party/django-stubs/django-stubs/conf/urls/i18n.pyi jedi/third_party/django-stubs/django-stubs/conf/urls/static.pyi jedi/third_party/django-stubs/django-stubs/contrib/__init__.pyi jedi/third_party/django-stubs/django-stubs/contrib/admin/__init__.pyi jedi/third_party/django-stubs/django-stubs/contrib/admin/actions.pyi jedi/third_party/django-stubs/django-stubs/contrib/admin/apps.pyi jedi/third_party/django-stubs/django-stubs/contrib/admin/checks.pyi jedi/third_party/django-stubs/django-stubs/contrib/admin/decorators.pyi jedi/third_party/django-stubs/django-stubs/contrib/admin/filters.pyi jedi/third_party/django-stubs/django-stubs/contrib/admin/forms.pyi jedi/third_party/django-stubs/django-stubs/contrib/admin/helpers.pyi jedi/third_party/django-stubs/django-stubs/contrib/admin/models.pyi jedi/third_party/django-stubs/django-stubs/contrib/admin/options.pyi jedi/third_party/django-stubs/django-stubs/contrib/admin/sites.pyi jedi/third_party/django-stubs/django-stubs/contrib/admin/tests.pyi jedi/third_party/django-stubs/django-stubs/contrib/admin/utils.pyi jedi/third_party/django-stubs/django-stubs/contrib/admin/widgets.pyi jedi/third_party/django-stubs/django-stubs/contrib/admin/templatetags/__init__.pyi jedi/third_party/django-stubs/django-stubs/contrib/admin/templatetags/admin_list.pyi jedi/third_party/django-stubs/django-stubs/contrib/admin/templatetags/admin_modify.pyi jedi/third_party/django-stubs/django-stubs/contrib/admin/templatetags/admin_static.pyi jedi/third_party/django-stubs/django-stubs/contrib/admin/templatetags/admin_urls.pyi jedi/third_party/django-stubs/django-stubs/contrib/admin/templatetags/base.pyi jedi/third_party/django-stubs/django-stubs/contrib/admin/templatetags/log.pyi jedi/third_party/django-stubs/django-stubs/contrib/admin/views/__init__.pyi jedi/third_party/django-stubs/django-stubs/contrib/admin/views/autocomplete.pyi jedi/third_party/django-stubs/django-stubs/contrib/admin/views/decorators.pyi jedi/third_party/django-stubs/django-stubs/contrib/admin/views/main.pyi jedi/third_party/django-stubs/django-stubs/contrib/admindocs/__init__.pyi jedi/third_party/django-stubs/django-stubs/contrib/admindocs/middleware.pyi jedi/third_party/django-stubs/django-stubs/contrib/admindocs/urls.pyi jedi/third_party/django-stubs/django-stubs/contrib/admindocs/utils.pyi jedi/third_party/django-stubs/django-stubs/contrib/admindocs/views.pyi jedi/third_party/django-stubs/django-stubs/contrib/auth/__init__.pyi jedi/third_party/django-stubs/django-stubs/contrib/auth/admin.pyi jedi/third_party/django-stubs/django-stubs/contrib/auth/apps.pyi jedi/third_party/django-stubs/django-stubs/contrib/auth/backends.pyi jedi/third_party/django-stubs/django-stubs/contrib/auth/base_user.pyi jedi/third_party/django-stubs/django-stubs/contrib/auth/checks.pyi jedi/third_party/django-stubs/django-stubs/contrib/auth/context_processors.pyi jedi/third_party/django-stubs/django-stubs/contrib/auth/decorators.pyi jedi/third_party/django-stubs/django-stubs/contrib/auth/forms.pyi jedi/third_party/django-stubs/django-stubs/contrib/auth/hashers.pyi jedi/third_party/django-stubs/django-stubs/contrib/auth/middleware.pyi jedi/third_party/django-stubs/django-stubs/contrib/auth/mixins.pyi jedi/third_party/django-stubs/django-stubs/contrib/auth/models.pyi jedi/third_party/django-stubs/django-stubs/contrib/auth/password_validation.pyi jedi/third_party/django-stubs/django-stubs/contrib/auth/signals.pyi jedi/third_party/django-stubs/django-stubs/contrib/auth/tokens.pyi jedi/third_party/django-stubs/django-stubs/contrib/auth/urls.pyi jedi/third_party/django-stubs/django-stubs/contrib/auth/validators.pyi jedi/third_party/django-stubs/django-stubs/contrib/auth/views.pyi jedi/third_party/django-stubs/django-stubs/contrib/auth/handlers/__init__.pyi jedi/third_party/django-stubs/django-stubs/contrib/auth/handlers/modwsgi.pyi jedi/third_party/django-stubs/django-stubs/contrib/auth/management/__init__.pyi jedi/third_party/django-stubs/django-stubs/contrib/auth/management/commands/__init__.pyi jedi/third_party/django-stubs/django-stubs/contrib/auth/management/commands/changepassword.pyi jedi/third_party/django-stubs/django-stubs/contrib/auth/management/commands/createsuperuser.pyi jedi/third_party/django-stubs/django-stubs/contrib/contenttypes/__init__.pyi jedi/third_party/django-stubs/django-stubs/contrib/contenttypes/admin.pyi jedi/third_party/django-stubs/django-stubs/contrib/contenttypes/apps.pyi jedi/third_party/django-stubs/django-stubs/contrib/contenttypes/checks.pyi jedi/third_party/django-stubs/django-stubs/contrib/contenttypes/fields.pyi jedi/third_party/django-stubs/django-stubs/contrib/contenttypes/forms.pyi jedi/third_party/django-stubs/django-stubs/contrib/contenttypes/models.pyi jedi/third_party/django-stubs/django-stubs/contrib/contenttypes/views.pyi jedi/third_party/django-stubs/django-stubs/contrib/contenttypes/management/__init__.pyi jedi/third_party/django-stubs/django-stubs/contrib/contenttypes/management/commands/__init__.pyi jedi/third_party/django-stubs/django-stubs/contrib/contenttypes/management/commands/remove_stale_contenttypes.pyi jedi/third_party/django-stubs/django-stubs/contrib/flatpages/__init__.pyi jedi/third_party/django-stubs/django-stubs/contrib/flatpages/forms.pyi jedi/third_party/django-stubs/django-stubs/contrib/flatpages/middleware.pyi jedi/third_party/django-stubs/django-stubs/contrib/flatpages/models.pyi jedi/third_party/django-stubs/django-stubs/contrib/flatpages/sitemaps.pyi jedi/third_party/django-stubs/django-stubs/contrib/flatpages/urls.pyi jedi/third_party/django-stubs/django-stubs/contrib/flatpages/views.pyi jedi/third_party/django-stubs/django-stubs/contrib/flatpages/templatetags/__init__.pyi jedi/third_party/django-stubs/django-stubs/contrib/flatpages/templatetags/flatpages.pyi jedi/third_party/django-stubs/django-stubs/contrib/gis/__init__.pyi jedi/third_party/django-stubs/django-stubs/contrib/gis/db/__init__.pyi jedi/third_party/django-stubs/django-stubs/contrib/gis/db/models/__init__.pyi jedi/third_party/django-stubs/django-stubs/contrib/gis/db/models/fields.pyi jedi/third_party/django-stubs/django-stubs/contrib/humanize/__init__.pyi jedi/third_party/django-stubs/django-stubs/contrib/humanize/templatetags/__init__.pyi jedi/third_party/django-stubs/django-stubs/contrib/humanize/templatetags/humanize.pyi jedi/third_party/django-stubs/django-stubs/contrib/messages/__init__.pyi jedi/third_party/django-stubs/django-stubs/contrib/messages/api.pyi jedi/third_party/django-stubs/django-stubs/contrib/messages/constants.pyi jedi/third_party/django-stubs/django-stubs/contrib/messages/context_processors.pyi jedi/third_party/django-stubs/django-stubs/contrib/messages/middleware.pyi jedi/third_party/django-stubs/django-stubs/contrib/messages/utils.pyi jedi/third_party/django-stubs/django-stubs/contrib/messages/views.pyi jedi/third_party/django-stubs/django-stubs/contrib/messages/storage/__init__.pyi jedi/third_party/django-stubs/django-stubs/contrib/messages/storage/base.pyi jedi/third_party/django-stubs/django-stubs/contrib/messages/storage/cookie.pyi jedi/third_party/django-stubs/django-stubs/contrib/messages/storage/fallback.pyi jedi/third_party/django-stubs/django-stubs/contrib/messages/storage/session.pyi jedi/third_party/django-stubs/django-stubs/contrib/postgres/__init__.pyi jedi/third_party/django-stubs/django-stubs/contrib/postgres/constraints.pyi jedi/third_party/django-stubs/django-stubs/contrib/postgres/functions.pyi jedi/third_party/django-stubs/django-stubs/contrib/postgres/indexes.pyi jedi/third_party/django-stubs/django-stubs/contrib/postgres/lookups.pyi jedi/third_party/django-stubs/django-stubs/contrib/postgres/operations.pyi jedi/third_party/django-stubs/django-stubs/contrib/postgres/search.pyi jedi/third_party/django-stubs/django-stubs/contrib/postgres/signals.pyi jedi/third_party/django-stubs/django-stubs/contrib/postgres/validators.pyi jedi/third_party/django-stubs/django-stubs/contrib/postgres/aggregates/__init__.pyi jedi/third_party/django-stubs/django-stubs/contrib/postgres/aggregates/general.pyi jedi/third_party/django-stubs/django-stubs/contrib/postgres/aggregates/mixins.pyi jedi/third_party/django-stubs/django-stubs/contrib/postgres/aggregates/statistics.pyi jedi/third_party/django-stubs/django-stubs/contrib/postgres/fields/__init__.pyi jedi/third_party/django-stubs/django-stubs/contrib/postgres/fields/array.pyi jedi/third_party/django-stubs/django-stubs/contrib/postgres/fields/citext.pyi jedi/third_party/django-stubs/django-stubs/contrib/postgres/fields/hstore.pyi jedi/third_party/django-stubs/django-stubs/contrib/postgres/fields/jsonb.pyi jedi/third_party/django-stubs/django-stubs/contrib/postgres/fields/mixins.pyi jedi/third_party/django-stubs/django-stubs/contrib/postgres/fields/ranges.pyi jedi/third_party/django-stubs/django-stubs/contrib/redirects/__init__.pyi jedi/third_party/django-stubs/django-stubs/contrib/redirects/middleware.pyi jedi/third_party/django-stubs/django-stubs/contrib/redirects/models.pyi jedi/third_party/django-stubs/django-stubs/contrib/sessions/__init__.pyi jedi/third_party/django-stubs/django-stubs/contrib/sessions/base_session.pyi jedi/third_party/django-stubs/django-stubs/contrib/sessions/exceptions.pyi jedi/third_party/django-stubs/django-stubs/contrib/sessions/middleware.pyi jedi/third_party/django-stubs/django-stubs/contrib/sessions/models.pyi jedi/third_party/django-stubs/django-stubs/contrib/sessions/serializers.pyi jedi/third_party/django-stubs/django-stubs/contrib/sessions/backends/__init__.pyi jedi/third_party/django-stubs/django-stubs/contrib/sessions/backends/base.pyi jedi/third_party/django-stubs/django-stubs/contrib/sessions/backends/cache.pyi jedi/third_party/django-stubs/django-stubs/contrib/sessions/backends/cached_db.pyi jedi/third_party/django-stubs/django-stubs/contrib/sessions/backends/db.pyi jedi/third_party/django-stubs/django-stubs/contrib/sessions/backends/file.pyi jedi/third_party/django-stubs/django-stubs/contrib/sessions/backends/signed_cookies.pyi jedi/third_party/django-stubs/django-stubs/contrib/sessions/management/__init__.pyi jedi/third_party/django-stubs/django-stubs/contrib/sessions/management/commands/__init__.pyi jedi/third_party/django-stubs/django-stubs/contrib/sessions/management/commands/clearsessions.pyi jedi/third_party/django-stubs/django-stubs/contrib/sitemaps/__init__.pyi jedi/third_party/django-stubs/django-stubs/contrib/sitemaps/views.pyi jedi/third_party/django-stubs/django-stubs/contrib/sitemaps/management/__init__.pyi jedi/third_party/django-stubs/django-stubs/contrib/sitemaps/management/commands/__init__.pyi jedi/third_party/django-stubs/django-stubs/contrib/sitemaps/management/commands/ping_google.pyi jedi/third_party/django-stubs/django-stubs/contrib/sites/__init__.pyi jedi/third_party/django-stubs/django-stubs/contrib/sites/apps.pyi jedi/third_party/django-stubs/django-stubs/contrib/sites/management.pyi jedi/third_party/django-stubs/django-stubs/contrib/sites/managers.pyi jedi/third_party/django-stubs/django-stubs/contrib/sites/middleware.pyi jedi/third_party/django-stubs/django-stubs/contrib/sites/models.pyi jedi/third_party/django-stubs/django-stubs/contrib/sites/requests.pyi jedi/third_party/django-stubs/django-stubs/contrib/sites/shortcuts.pyi jedi/third_party/django-stubs/django-stubs/contrib/staticfiles/__init__.pyi jedi/third_party/django-stubs/django-stubs/contrib/staticfiles/apps.pyi jedi/third_party/django-stubs/django-stubs/contrib/staticfiles/checks.pyi jedi/third_party/django-stubs/django-stubs/contrib/staticfiles/finders.pyi jedi/third_party/django-stubs/django-stubs/contrib/staticfiles/handlers.pyi jedi/third_party/django-stubs/django-stubs/contrib/staticfiles/storage.pyi jedi/third_party/django-stubs/django-stubs/contrib/staticfiles/testing.pyi jedi/third_party/django-stubs/django-stubs/contrib/staticfiles/urls.pyi jedi/third_party/django-stubs/django-stubs/contrib/staticfiles/utils.pyi jedi/third_party/django-stubs/django-stubs/contrib/staticfiles/views.pyi jedi/third_party/django-stubs/django-stubs/contrib/staticfiles/management/__init__.pyi jedi/third_party/django-stubs/django-stubs/contrib/staticfiles/management/commands/__init__.pyi jedi/third_party/django-stubs/django-stubs/contrib/staticfiles/management/commands/collectstatic.pyi jedi/third_party/django-stubs/django-stubs/contrib/staticfiles/management/commands/findstatic.pyi jedi/third_party/django-stubs/django-stubs/contrib/staticfiles/management/commands/runserver.pyi jedi/third_party/django-stubs/django-stubs/contrib/staticfiles/templatetags/__init__.pyi jedi/third_party/django-stubs/django-stubs/contrib/staticfiles/templatetags/staticfiles.pyi jedi/third_party/django-stubs/django-stubs/contrib/syndication/__init__.pyi jedi/third_party/django-stubs/django-stubs/contrib/syndication/views.pyi jedi/third_party/django-stubs/django-stubs/core/__init__.pyi jedi/third_party/django-stubs/django-stubs/core/exceptions.pyi jedi/third_party/django-stubs/django-stubs/core/paginator.pyi jedi/third_party/django-stubs/django-stubs/core/signals.pyi jedi/third_party/django-stubs/django-stubs/core/signing.pyi jedi/third_party/django-stubs/django-stubs/core/validators.pyi jedi/third_party/django-stubs/django-stubs/core/wsgi.pyi jedi/third_party/django-stubs/django-stubs/core/cache/__init__.pyi jedi/third_party/django-stubs/django-stubs/core/cache/utils.pyi jedi/third_party/django-stubs/django-stubs/core/cache/backends/__init__.pyi jedi/third_party/django-stubs/django-stubs/core/cache/backends/base.pyi jedi/third_party/django-stubs/django-stubs/core/cache/backends/db.pyi jedi/third_party/django-stubs/django-stubs/core/cache/backends/dummy.pyi jedi/third_party/django-stubs/django-stubs/core/cache/backends/filebased.pyi jedi/third_party/django-stubs/django-stubs/core/cache/backends/locmem.pyi jedi/third_party/django-stubs/django-stubs/core/cache/backends/memcached.pyi jedi/third_party/django-stubs/django-stubs/core/checks/__init__.pyi jedi/third_party/django-stubs/django-stubs/core/checks/caches.pyi jedi/third_party/django-stubs/django-stubs/core/checks/database.pyi jedi/third_party/django-stubs/django-stubs/core/checks/messages.pyi jedi/third_party/django-stubs/django-stubs/core/checks/model_checks.pyi jedi/third_party/django-stubs/django-stubs/core/checks/registry.pyi jedi/third_party/django-stubs/django-stubs/core/checks/templates.pyi jedi/third_party/django-stubs/django-stubs/core/checks/translation.pyi jedi/third_party/django-stubs/django-stubs/core/checks/urls.pyi jedi/third_party/django-stubs/django-stubs/core/checks/security/__init__.pyi jedi/third_party/django-stubs/django-stubs/core/checks/security/base.pyi jedi/third_party/django-stubs/django-stubs/core/checks/security/csrf.pyi jedi/third_party/django-stubs/django-stubs/core/checks/security/sessions.pyi jedi/third_party/django-stubs/django-stubs/core/files/__init__.pyi jedi/third_party/django-stubs/django-stubs/core/files/base.pyi jedi/third_party/django-stubs/django-stubs/core/files/images.pyi jedi/third_party/django-stubs/django-stubs/core/files/locks.pyi jedi/third_party/django-stubs/django-stubs/core/files/move.pyi jedi/third_party/django-stubs/django-stubs/core/files/storage.pyi jedi/third_party/django-stubs/django-stubs/core/files/temp.pyi jedi/third_party/django-stubs/django-stubs/core/files/uploadedfile.pyi jedi/third_party/django-stubs/django-stubs/core/files/uploadhandler.pyi jedi/third_party/django-stubs/django-stubs/core/files/utils.pyi jedi/third_party/django-stubs/django-stubs/core/handlers/__init__.pyi jedi/third_party/django-stubs/django-stubs/core/handlers/base.pyi jedi/third_party/django-stubs/django-stubs/core/handlers/exception.pyi jedi/third_party/django-stubs/django-stubs/core/handlers/wsgi.pyi jedi/third_party/django-stubs/django-stubs/core/mail/__init__.pyi jedi/third_party/django-stubs/django-stubs/core/mail/message.pyi jedi/third_party/django-stubs/django-stubs/core/mail/utils.pyi jedi/third_party/django-stubs/django-stubs/core/mail/backends/__init__.pyi jedi/third_party/django-stubs/django-stubs/core/mail/backends/base.pyi jedi/third_party/django-stubs/django-stubs/core/mail/backends/console.pyi jedi/third_party/django-stubs/django-stubs/core/mail/backends/dummy.pyi jedi/third_party/django-stubs/django-stubs/core/mail/backends/filebased.pyi jedi/third_party/django-stubs/django-stubs/core/mail/backends/locmem.pyi jedi/third_party/django-stubs/django-stubs/core/mail/backends/smtp.pyi jedi/third_party/django-stubs/django-stubs/core/management/__init__.pyi jedi/third_party/django-stubs/django-stubs/core/management/base.pyi jedi/third_party/django-stubs/django-stubs/core/management/color.pyi jedi/third_party/django-stubs/django-stubs/core/management/sql.pyi jedi/third_party/django-stubs/django-stubs/core/management/templates.pyi jedi/third_party/django-stubs/django-stubs/core/management/utils.pyi jedi/third_party/django-stubs/django-stubs/core/management/commands/__init__.pyi jedi/third_party/django-stubs/django-stubs/core/management/commands/dumpdata.pyi jedi/third_party/django-stubs/django-stubs/core/management/commands/loaddata.pyi jedi/third_party/django-stubs/django-stubs/core/management/commands/makemessages.pyi jedi/third_party/django-stubs/django-stubs/core/management/commands/runserver.pyi jedi/third_party/django-stubs/django-stubs/core/management/commands/testserver.pyi jedi/third_party/django-stubs/django-stubs/core/serializers/__init__.pyi jedi/third_party/django-stubs/django-stubs/core/serializers/base.pyi jedi/third_party/django-stubs/django-stubs/core/serializers/json.pyi jedi/third_party/django-stubs/django-stubs/core/serializers/python.pyi jedi/third_party/django-stubs/django-stubs/core/servers/__init__.pyi jedi/third_party/django-stubs/django-stubs/core/servers/basehttp.pyi jedi/third_party/django-stubs/django-stubs/db/__init__.pyi jedi/third_party/django-stubs/django-stubs/db/transaction.pyi jedi/third_party/django-stubs/django-stubs/db/utils.pyi jedi/third_party/django-stubs/django-stubs/db/backends/__init__.pyi jedi/third_party/django-stubs/django-stubs/db/backends/ddl_references.pyi jedi/third_party/django-stubs/django-stubs/db/backends/signals.pyi jedi/third_party/django-stubs/django-stubs/db/backends/utils.pyi jedi/third_party/django-stubs/django-stubs/db/backends/base/__init__.pyi jedi/third_party/django-stubs/django-stubs/db/backends/base/base.pyi jedi/third_party/django-stubs/django-stubs/db/backends/base/client.pyi jedi/third_party/django-stubs/django-stubs/db/backends/base/creation.pyi jedi/third_party/django-stubs/django-stubs/db/backends/base/features.pyi jedi/third_party/django-stubs/django-stubs/db/backends/base/introspection.pyi jedi/third_party/django-stubs/django-stubs/db/backends/base/operations.pyi jedi/third_party/django-stubs/django-stubs/db/backends/base/schema.pyi jedi/third_party/django-stubs/django-stubs/db/backends/base/validation.pyi jedi/third_party/django-stubs/django-stubs/db/backends/dummy/__init__.pyi jedi/third_party/django-stubs/django-stubs/db/backends/dummy/base.pyi jedi/third_party/django-stubs/django-stubs/db/backends/mysql/__init__.pyi jedi/third_party/django-stubs/django-stubs/db/backends/mysql/client.pyi jedi/third_party/django-stubs/django-stubs/db/backends/postgresql/__init__.pyi jedi/third_party/django-stubs/django-stubs/db/backends/postgresql/base.pyi jedi/third_party/django-stubs/django-stubs/db/backends/postgresql/client.pyi jedi/third_party/django-stubs/django-stubs/db/backends/postgresql/creation.pyi jedi/third_party/django-stubs/django-stubs/db/backends/postgresql/operations.pyi jedi/third_party/django-stubs/django-stubs/db/backends/sqlite3/__init__.pyi jedi/third_party/django-stubs/django-stubs/db/backends/sqlite3/base.pyi jedi/third_party/django-stubs/django-stubs/db/backends/sqlite3/creation.pyi jedi/third_party/django-stubs/django-stubs/db/backends/sqlite3/features.pyi jedi/third_party/django-stubs/django-stubs/db/backends/sqlite3/introspection.pyi jedi/third_party/django-stubs/django-stubs/db/backends/sqlite3/operations.pyi jedi/third_party/django-stubs/django-stubs/db/backends/sqlite3/schema.pyi jedi/third_party/django-stubs/django-stubs/db/migrations/__init__.pyi jedi/third_party/django-stubs/django-stubs/db/migrations/autodetector.pyi jedi/third_party/django-stubs/django-stubs/db/migrations/exceptions.pyi jedi/third_party/django-stubs/django-stubs/db/migrations/executor.pyi jedi/third_party/django-stubs/django-stubs/db/migrations/graph.pyi jedi/third_party/django-stubs/django-stubs/db/migrations/loader.pyi jedi/third_party/django-stubs/django-stubs/db/migrations/migration.pyi jedi/third_party/django-stubs/django-stubs/db/migrations/optimizer.pyi jedi/third_party/django-stubs/django-stubs/db/migrations/questioner.pyi jedi/third_party/django-stubs/django-stubs/db/migrations/recorder.pyi jedi/third_party/django-stubs/django-stubs/db/migrations/serializer.pyi jedi/third_party/django-stubs/django-stubs/db/migrations/state.pyi jedi/third_party/django-stubs/django-stubs/db/migrations/topological_sort.pyi jedi/third_party/django-stubs/django-stubs/db/migrations/utils.pyi jedi/third_party/django-stubs/django-stubs/db/migrations/writer.pyi jedi/third_party/django-stubs/django-stubs/db/migrations/operations/__init__.pyi jedi/third_party/django-stubs/django-stubs/db/migrations/operations/base.pyi jedi/third_party/django-stubs/django-stubs/db/migrations/operations/fields.pyi jedi/third_party/django-stubs/django-stubs/db/migrations/operations/models.pyi jedi/third_party/django-stubs/django-stubs/db/migrations/operations/special.pyi jedi/third_party/django-stubs/django-stubs/db/migrations/operations/utils.pyi jedi/third_party/django-stubs/django-stubs/db/models/__init__.pyi jedi/third_party/django-stubs/django-stubs/db/models/aggregates.pyi jedi/third_party/django-stubs/django-stubs/db/models/base.pyi jedi/third_party/django-stubs/django-stubs/db/models/constraints.pyi jedi/third_party/django-stubs/django-stubs/db/models/deletion.pyi jedi/third_party/django-stubs/django-stubs/db/models/enums.pyi jedi/third_party/django-stubs/django-stubs/db/models/expressions.pyi jedi/third_party/django-stubs/django-stubs/db/models/indexes.pyi jedi/third_party/django-stubs/django-stubs/db/models/lookups.pyi jedi/third_party/django-stubs/django-stubs/db/models/manager.pyi jedi/third_party/django-stubs/django-stubs/db/models/options.pyi jedi/third_party/django-stubs/django-stubs/db/models/query.pyi jedi/third_party/django-stubs/django-stubs/db/models/query_utils.pyi jedi/third_party/django-stubs/django-stubs/db/models/signals.pyi jedi/third_party/django-stubs/django-stubs/db/models/utils.pyi jedi/third_party/django-stubs/django-stubs/db/models/fields/__init__.pyi jedi/third_party/django-stubs/django-stubs/db/models/fields/files.pyi jedi/third_party/django-stubs/django-stubs/db/models/fields/mixins.pyi jedi/third_party/django-stubs/django-stubs/db/models/fields/proxy.pyi jedi/third_party/django-stubs/django-stubs/db/models/fields/related.pyi jedi/third_party/django-stubs/django-stubs/db/models/fields/related_descriptors.pyi jedi/third_party/django-stubs/django-stubs/db/models/fields/related_lookups.pyi jedi/third_party/django-stubs/django-stubs/db/models/fields/reverse_related.pyi jedi/third_party/django-stubs/django-stubs/db/models/functions/__init__.pyi jedi/third_party/django-stubs/django-stubs/db/models/functions/comparison.pyi jedi/third_party/django-stubs/django-stubs/db/models/functions/datetime.pyi jedi/third_party/django-stubs/django-stubs/db/models/functions/math.pyi jedi/third_party/django-stubs/django-stubs/db/models/functions/mixins.pyi jedi/third_party/django-stubs/django-stubs/db/models/functions/text.pyi jedi/third_party/django-stubs/django-stubs/db/models/functions/window.pyi jedi/third_party/django-stubs/django-stubs/db/models/sql/__init__.pyi jedi/third_party/django-stubs/django-stubs/db/models/sql/compiler.pyi jedi/third_party/django-stubs/django-stubs/db/models/sql/constants.pyi jedi/third_party/django-stubs/django-stubs/db/models/sql/datastructures.pyi jedi/third_party/django-stubs/django-stubs/db/models/sql/query.pyi jedi/third_party/django-stubs/django-stubs/db/models/sql/subqueries.pyi jedi/third_party/django-stubs/django-stubs/db/models/sql/where.pyi jedi/third_party/django-stubs/django-stubs/dispatch/__init__.pyi jedi/third_party/django-stubs/django-stubs/dispatch/dispatcher.pyi jedi/third_party/django-stubs/django-stubs/forms/__init__.pyi jedi/third_party/django-stubs/django-stubs/forms/boundfield.pyi jedi/third_party/django-stubs/django-stubs/forms/fields.pyi jedi/third_party/django-stubs/django-stubs/forms/forms.pyi jedi/third_party/django-stubs/django-stubs/forms/formsets.pyi jedi/third_party/django-stubs/django-stubs/forms/models.pyi jedi/third_party/django-stubs/django-stubs/forms/renderers.pyi jedi/third_party/django-stubs/django-stubs/forms/utils.pyi jedi/third_party/django-stubs/django-stubs/forms/widgets.pyi jedi/third_party/django-stubs/django-stubs/http/__init__.pyi jedi/third_party/django-stubs/django-stubs/http/cookie.pyi jedi/third_party/django-stubs/django-stubs/http/multipartparser.pyi jedi/third_party/django-stubs/django-stubs/http/request.pyi jedi/third_party/django-stubs/django-stubs/http/response.pyi jedi/third_party/django-stubs/django-stubs/middleware/__init__.pyi jedi/third_party/django-stubs/django-stubs/middleware/cache.pyi jedi/third_party/django-stubs/django-stubs/middleware/clickjacking.pyi jedi/third_party/django-stubs/django-stubs/middleware/common.pyi jedi/third_party/django-stubs/django-stubs/middleware/csrf.pyi jedi/third_party/django-stubs/django-stubs/middleware/gzip.pyi jedi/third_party/django-stubs/django-stubs/middleware/http.pyi jedi/third_party/django-stubs/django-stubs/middleware/locale.pyi jedi/third_party/django-stubs/django-stubs/middleware/security.pyi jedi/third_party/django-stubs/django-stubs/template/__init__.pyi jedi/third_party/django-stubs/django-stubs/template/base.pyi jedi/third_party/django-stubs/django-stubs/template/context.pyi jedi/third_party/django-stubs/django-stubs/template/context_processors.pyi jedi/third_party/django-stubs/django-stubs/template/defaultfilters.pyi jedi/third_party/django-stubs/django-stubs/template/defaulttags.pyi jedi/third_party/django-stubs/django-stubs/template/engine.pyi jedi/third_party/django-stubs/django-stubs/template/exceptions.pyi jedi/third_party/django-stubs/django-stubs/template/library.pyi jedi/third_party/django-stubs/django-stubs/template/loader.pyi jedi/third_party/django-stubs/django-stubs/template/loader_tags.pyi jedi/third_party/django-stubs/django-stubs/template/response.pyi jedi/third_party/django-stubs/django-stubs/template/smartif.pyi jedi/third_party/django-stubs/django-stubs/template/utils.pyi jedi/third_party/django-stubs/django-stubs/template/backends/__init__.pyi jedi/third_party/django-stubs/django-stubs/template/backends/base.pyi jedi/third_party/django-stubs/django-stubs/template/backends/django.pyi jedi/third_party/django-stubs/django-stubs/template/backends/dummy.pyi jedi/third_party/django-stubs/django-stubs/template/backends/jinja2.pyi jedi/third_party/django-stubs/django-stubs/template/backends/utils.pyi jedi/third_party/django-stubs/django-stubs/template/loaders/__init__.pyi jedi/third_party/django-stubs/django-stubs/template/loaders/app_directories.pyi jedi/third_party/django-stubs/django-stubs/template/loaders/base.pyi jedi/third_party/django-stubs/django-stubs/template/loaders/cached.pyi jedi/third_party/django-stubs/django-stubs/template/loaders/filesystem.pyi jedi/third_party/django-stubs/django-stubs/template/loaders/locmem.pyi jedi/third_party/django-stubs/django-stubs/templatetags/__init__.pyi jedi/third_party/django-stubs/django-stubs/templatetags/cache.pyi jedi/third_party/django-stubs/django-stubs/templatetags/i18n.pyi jedi/third_party/django-stubs/django-stubs/templatetags/l10n.pyi jedi/third_party/django-stubs/django-stubs/templatetags/static.pyi jedi/third_party/django-stubs/django-stubs/templatetags/tz.pyi jedi/third_party/django-stubs/django-stubs/test/__init__.pyi jedi/third_party/django-stubs/django-stubs/test/client.pyi jedi/third_party/django-stubs/django-stubs/test/html.pyi jedi/third_party/django-stubs/django-stubs/test/runner.pyi jedi/third_party/django-stubs/django-stubs/test/selenium.pyi jedi/third_party/django-stubs/django-stubs/test/signals.pyi jedi/third_party/django-stubs/django-stubs/test/testcases.pyi jedi/third_party/django-stubs/django-stubs/test/utils.pyi jedi/third_party/django-stubs/django-stubs/urls/__init__.pyi jedi/third_party/django-stubs/django-stubs/urls/base.pyi jedi/third_party/django-stubs/django-stubs/urls/conf.pyi jedi/third_party/django-stubs/django-stubs/urls/converters.pyi jedi/third_party/django-stubs/django-stubs/urls/exceptions.pyi jedi/third_party/django-stubs/django-stubs/urls/resolvers.pyi jedi/third_party/django-stubs/django-stubs/urls/utils.pyi jedi/third_party/django-stubs/django-stubs/utils/__init__.pyi jedi/third_party/django-stubs/django-stubs/utils/_os.pyi jedi/third_party/django-stubs/django-stubs/utils/archive.pyi jedi/third_party/django-stubs/django-stubs/utils/autoreload.pyi jedi/third_party/django-stubs/django-stubs/utils/baseconv.pyi jedi/third_party/django-stubs/django-stubs/utils/cache.pyi jedi/third_party/django-stubs/django-stubs/utils/crypto.pyi jedi/third_party/django-stubs/django-stubs/utils/datastructures.pyi jedi/third_party/django-stubs/django-stubs/utils/dateformat.pyi jedi/third_party/django-stubs/django-stubs/utils/dateparse.pyi jedi/third_party/django-stubs/django-stubs/utils/dates.pyi jedi/third_party/django-stubs/django-stubs/utils/datetime_safe.pyi jedi/third_party/django-stubs/django-stubs/utils/deconstruct.pyi jedi/third_party/django-stubs/django-stubs/utils/decorators.pyi jedi/third_party/django-stubs/django-stubs/utils/deprecation.pyi jedi/third_party/django-stubs/django-stubs/utils/duration.pyi jedi/third_party/django-stubs/django-stubs/utils/encoding.pyi jedi/third_party/django-stubs/django-stubs/utils/feedgenerator.pyi jedi/third_party/django-stubs/django-stubs/utils/formats.pyi jedi/third_party/django-stubs/django-stubs/utils/functional.pyi jedi/third_party/django-stubs/django-stubs/utils/hashable.pyi jedi/third_party/django-stubs/django-stubs/utils/html.pyi jedi/third_party/django-stubs/django-stubs/utils/http.pyi jedi/third_party/django-stubs/django-stubs/utils/inspect.pyi jedi/third_party/django-stubs/django-stubs/utils/ipv6.pyi jedi/third_party/django-stubs/django-stubs/utils/itercompat.pyi jedi/third_party/django-stubs/django-stubs/utils/jslex.pyi jedi/third_party/django-stubs/django-stubs/utils/log.pyi jedi/third_party/django-stubs/django-stubs/utils/lorem_ipsum.pyi jedi/third_party/django-stubs/django-stubs/utils/module_loading.pyi jedi/third_party/django-stubs/django-stubs/utils/numberformat.pyi jedi/third_party/django-stubs/django-stubs/utils/regex_helper.pyi jedi/third_party/django-stubs/django-stubs/utils/safestring.pyi jedi/third_party/django-stubs/django-stubs/utils/six.pyi jedi/third_party/django-stubs/django-stubs/utils/termcolors.pyi jedi/third_party/django-stubs/django-stubs/utils/text.pyi jedi/third_party/django-stubs/django-stubs/utils/timesince.pyi jedi/third_party/django-stubs/django-stubs/utils/timezone.pyi jedi/third_party/django-stubs/django-stubs/utils/topological_sort.pyi jedi/third_party/django-stubs/django-stubs/utils/tree.pyi jedi/third_party/django-stubs/django-stubs/utils/version.pyi jedi/third_party/django-stubs/django-stubs/utils/xmlutils.pyi jedi/third_party/django-stubs/django-stubs/utils/translation/__init__.pyi jedi/third_party/django-stubs/django-stubs/utils/translation/reloader.pyi jedi/third_party/django-stubs/django-stubs/utils/translation/template.pyi jedi/third_party/django-stubs/django-stubs/utils/translation/trans_null.pyi jedi/third_party/django-stubs/django-stubs/utils/translation/trans_real.pyi jedi/third_party/django-stubs/django-stubs/views/__init__.pyi jedi/third_party/django-stubs/django-stubs/views/csrf.pyi jedi/third_party/django-stubs/django-stubs/views/debug.pyi jedi/third_party/django-stubs/django-stubs/views/defaults.pyi jedi/third_party/django-stubs/django-stubs/views/i18n.pyi jedi/third_party/django-stubs/django-stubs/views/static.pyi jedi/third_party/django-stubs/django-stubs/views/decorators/__init__.pyi jedi/third_party/django-stubs/django-stubs/views/decorators/cache.pyi jedi/third_party/django-stubs/django-stubs/views/decorators/clickjacking.pyi jedi/third_party/django-stubs/django-stubs/views/decorators/csrf.pyi jedi/third_party/django-stubs/django-stubs/views/decorators/debug.pyi jedi/third_party/django-stubs/django-stubs/views/decorators/gzip.pyi jedi/third_party/django-stubs/django-stubs/views/decorators/http.pyi jedi/third_party/django-stubs/django-stubs/views/decorators/vary.pyi jedi/third_party/django-stubs/django-stubs/views/generic/__init__.pyi jedi/third_party/django-stubs/django-stubs/views/generic/base.pyi jedi/third_party/django-stubs/django-stubs/views/generic/dates.pyi jedi/third_party/django-stubs/django-stubs/views/generic/detail.pyi jedi/third_party/django-stubs/django-stubs/views/generic/edit.pyi jedi/third_party/django-stubs/django-stubs/views/generic/list.pyi jedi/third_party/typeshed/LICENSE jedi/third_party/typeshed/stdlib/2/BaseHTTPServer.pyi jedi/third_party/typeshed/stdlib/2/CGIHTTPServer.pyi jedi/third_party/typeshed/stdlib/2/ConfigParser.pyi jedi/third_party/typeshed/stdlib/2/Cookie.pyi jedi/third_party/typeshed/stdlib/2/HTMLParser.pyi jedi/third_party/typeshed/stdlib/2/Queue.pyi jedi/third_party/typeshed/stdlib/2/SimpleHTTPServer.pyi jedi/third_party/typeshed/stdlib/2/SocketServer.pyi jedi/third_party/typeshed/stdlib/2/StringIO.pyi jedi/third_party/typeshed/stdlib/2/UserDict.pyi jedi/third_party/typeshed/stdlib/2/UserList.pyi jedi/third_party/typeshed/stdlib/2/UserString.pyi jedi/third_party/typeshed/stdlib/2/__builtin__.pyi jedi/third_party/typeshed/stdlib/2/_ast.pyi jedi/third_party/typeshed/stdlib/2/_collections.pyi jedi/third_party/typeshed/stdlib/2/_functools.pyi jedi/third_party/typeshed/stdlib/2/_hotshot.pyi jedi/third_party/typeshed/stdlib/2/_io.pyi jedi/third_party/typeshed/stdlib/2/_json.pyi jedi/third_party/typeshed/stdlib/2/_md5.pyi jedi/third_party/typeshed/stdlib/2/_sha.pyi jedi/third_party/typeshed/stdlib/2/_sha256.pyi jedi/third_party/typeshed/stdlib/2/_sha512.pyi jedi/third_party/typeshed/stdlib/2/_socket.pyi jedi/third_party/typeshed/stdlib/2/_sre.pyi jedi/third_party/typeshed/stdlib/2/_struct.pyi jedi/third_party/typeshed/stdlib/2/_symtable.pyi jedi/third_party/typeshed/stdlib/2/_threading_local.pyi jedi/third_party/typeshed/stdlib/2/_winreg.pyi jedi/third_party/typeshed/stdlib/2/abc.pyi jedi/third_party/typeshed/stdlib/2/ast.pyi jedi/third_party/typeshed/stdlib/2/atexit.pyi jedi/third_party/typeshed/stdlib/2/builtins.pyi jedi/third_party/typeshed/stdlib/2/cPickle.pyi jedi/third_party/typeshed/stdlib/2/cStringIO.pyi jedi/third_party/typeshed/stdlib/2/collections.pyi jedi/third_party/typeshed/stdlib/2/commands.pyi jedi/third_party/typeshed/stdlib/2/compileall.pyi jedi/third_party/typeshed/stdlib/2/cookielib.pyi jedi/third_party/typeshed/stdlib/2/copy_reg.pyi jedi/third_party/typeshed/stdlib/2/dircache.pyi jedi/third_party/typeshed/stdlib/2/dummy_thread.pyi jedi/third_party/typeshed/stdlib/2/exceptions.pyi jedi/third_party/typeshed/stdlib/2/fcntl.pyi jedi/third_party/typeshed/stdlib/2/fnmatch.pyi jedi/third_party/typeshed/stdlib/2/functools.pyi jedi/third_party/typeshed/stdlib/2/future_builtins.pyi jedi/third_party/typeshed/stdlib/2/gc.pyi jedi/third_party/typeshed/stdlib/2/getopt.pyi jedi/third_party/typeshed/stdlib/2/getpass.pyi jedi/third_party/typeshed/stdlib/2/gettext.pyi jedi/third_party/typeshed/stdlib/2/glob.pyi jedi/third_party/typeshed/stdlib/2/gzip.pyi jedi/third_party/typeshed/stdlib/2/hashlib.pyi jedi/third_party/typeshed/stdlib/2/heapq.pyi jedi/third_party/typeshed/stdlib/2/htmlentitydefs.pyi jedi/third_party/typeshed/stdlib/2/httplib.pyi jedi/third_party/typeshed/stdlib/2/imp.pyi jedi/third_party/typeshed/stdlib/2/importlib.pyi jedi/third_party/typeshed/stdlib/2/inspect.pyi jedi/third_party/typeshed/stdlib/2/io.pyi jedi/third_party/typeshed/stdlib/2/itertools.pyi jedi/third_party/typeshed/stdlib/2/json.pyi jedi/third_party/typeshed/stdlib/2/markupbase.pyi jedi/third_party/typeshed/stdlib/2/md5.pyi jedi/third_party/typeshed/stdlib/2/mimetools.pyi jedi/third_party/typeshed/stdlib/2/mutex.pyi jedi/third_party/typeshed/stdlib/2/ntpath.pyi jedi/third_party/typeshed/stdlib/2/nturl2path.pyi jedi/third_party/typeshed/stdlib/2/os2emxpath.pyi jedi/third_party/typeshed/stdlib/2/pipes.pyi jedi/third_party/typeshed/stdlib/2/platform.pyi jedi/third_party/typeshed/stdlib/2/popen2.pyi jedi/third_party/typeshed/stdlib/2/posix.pyi jedi/third_party/typeshed/stdlib/2/posixpath.pyi jedi/third_party/typeshed/stdlib/2/random.pyi jedi/third_party/typeshed/stdlib/2/re.pyi jedi/third_party/typeshed/stdlib/2/repr.pyi jedi/third_party/typeshed/stdlib/2/resource.pyi jedi/third_party/typeshed/stdlib/2/rfc822.pyi jedi/third_party/typeshed/stdlib/2/robotparser.pyi jedi/third_party/typeshed/stdlib/2/runpy.pyi jedi/third_party/typeshed/stdlib/2/sets.pyi jedi/third_party/typeshed/stdlib/2/sha.pyi jedi/third_party/typeshed/stdlib/2/shelve.pyi jedi/third_party/typeshed/stdlib/2/shlex.pyi jedi/third_party/typeshed/stdlib/2/signal.pyi jedi/third_party/typeshed/stdlib/2/smtplib.pyi jedi/third_party/typeshed/stdlib/2/spwd.pyi jedi/third_party/typeshed/stdlib/2/sre_constants.pyi jedi/third_party/typeshed/stdlib/2/sre_parse.pyi jedi/third_party/typeshed/stdlib/2/stat.pyi jedi/third_party/typeshed/stdlib/2/string.pyi jedi/third_party/typeshed/stdlib/2/stringold.pyi jedi/third_party/typeshed/stdlib/2/strop.pyi jedi/third_party/typeshed/stdlib/2/subprocess.pyi jedi/third_party/typeshed/stdlib/2/symbol.pyi jedi/third_party/typeshed/stdlib/2/sys.pyi jedi/third_party/typeshed/stdlib/2/tempfile.pyi jedi/third_party/typeshed/stdlib/2/textwrap.pyi jedi/third_party/typeshed/stdlib/2/thread.pyi jedi/third_party/typeshed/stdlib/2/toaiff.pyi jedi/third_party/typeshed/stdlib/2/tokenize.pyi jedi/third_party/typeshed/stdlib/2/types.pyi jedi/third_party/typeshed/stdlib/2/typing.pyi jedi/third_party/typeshed/stdlib/2/unittest.pyi jedi/third_party/typeshed/stdlib/2/urllib.pyi jedi/third_party/typeshed/stdlib/2/urllib2.pyi jedi/third_party/typeshed/stdlib/2/urlparse.pyi jedi/third_party/typeshed/stdlib/2/user.pyi jedi/third_party/typeshed/stdlib/2/whichdb.pyi jedi/third_party/typeshed/stdlib/2/xmlrpclib.pyi jedi/third_party/typeshed/stdlib/2/distutils/__init__.pyi jedi/third_party/typeshed/stdlib/2/distutils/archive_util.pyi jedi/third_party/typeshed/stdlib/2/distutils/bcppcompiler.pyi jedi/third_party/typeshed/stdlib/2/distutils/ccompiler.pyi jedi/third_party/typeshed/stdlib/2/distutils/cmd.pyi jedi/third_party/typeshed/stdlib/2/distutils/config.pyi jedi/third_party/typeshed/stdlib/2/distutils/core.pyi jedi/third_party/typeshed/stdlib/2/distutils/cygwinccompiler.pyi jedi/third_party/typeshed/stdlib/2/distutils/debug.pyi jedi/third_party/typeshed/stdlib/2/distutils/dep_util.pyi jedi/third_party/typeshed/stdlib/2/distutils/dir_util.pyi jedi/third_party/typeshed/stdlib/2/distutils/dist.pyi jedi/third_party/typeshed/stdlib/2/distutils/emxccompiler.pyi jedi/third_party/typeshed/stdlib/2/distutils/errors.pyi jedi/third_party/typeshed/stdlib/2/distutils/extension.pyi jedi/third_party/typeshed/stdlib/2/distutils/fancy_getopt.pyi jedi/third_party/typeshed/stdlib/2/distutils/file_util.pyi jedi/third_party/typeshed/stdlib/2/distutils/filelist.pyi jedi/third_party/typeshed/stdlib/2/distutils/log.pyi jedi/third_party/typeshed/stdlib/2/distutils/msvccompiler.pyi jedi/third_party/typeshed/stdlib/2/distutils/spawn.pyi jedi/third_party/typeshed/stdlib/2/distutils/sysconfig.pyi jedi/third_party/typeshed/stdlib/2/distutils/text_file.pyi jedi/third_party/typeshed/stdlib/2/distutils/unixccompiler.pyi jedi/third_party/typeshed/stdlib/2/distutils/util.pyi jedi/third_party/typeshed/stdlib/2/distutils/version.pyi jedi/third_party/typeshed/stdlib/2/distutils/command/__init__.pyi jedi/third_party/typeshed/stdlib/2/distutils/command/bdist.pyi jedi/third_party/typeshed/stdlib/2/distutils/command/bdist_dumb.pyi jedi/third_party/typeshed/stdlib/2/distutils/command/bdist_msi.pyi jedi/third_party/typeshed/stdlib/2/distutils/command/bdist_packager.pyi jedi/third_party/typeshed/stdlib/2/distutils/command/bdist_rpm.pyi jedi/third_party/typeshed/stdlib/2/distutils/command/bdist_wininst.pyi jedi/third_party/typeshed/stdlib/2/distutils/command/build.pyi jedi/third_party/typeshed/stdlib/2/distutils/command/build_clib.pyi jedi/third_party/typeshed/stdlib/2/distutils/command/build_ext.pyi jedi/third_party/typeshed/stdlib/2/distutils/command/build_py.pyi jedi/third_party/typeshed/stdlib/2/distutils/command/build_scripts.pyi jedi/third_party/typeshed/stdlib/2/distutils/command/check.pyi jedi/third_party/typeshed/stdlib/2/distutils/command/clean.pyi jedi/third_party/typeshed/stdlib/2/distutils/command/config.pyi jedi/third_party/typeshed/stdlib/2/distutils/command/install.pyi jedi/third_party/typeshed/stdlib/2/distutils/command/install_data.pyi jedi/third_party/typeshed/stdlib/2/distutils/command/install_egg_info.pyi jedi/third_party/typeshed/stdlib/2/distutils/command/install_headers.pyi jedi/third_party/typeshed/stdlib/2/distutils/command/install_lib.pyi jedi/third_party/typeshed/stdlib/2/distutils/command/install_scripts.pyi jedi/third_party/typeshed/stdlib/2/distutils/command/register.pyi jedi/third_party/typeshed/stdlib/2/distutils/command/sdist.pyi jedi/third_party/typeshed/stdlib/2/distutils/command/upload.pyi jedi/third_party/typeshed/stdlib/2/email/MIMEText.pyi jedi/third_party/typeshed/stdlib/2/email/__init__.pyi jedi/third_party/typeshed/stdlib/2/email/_parseaddr.pyi jedi/third_party/typeshed/stdlib/2/email/base64mime.pyi jedi/third_party/typeshed/stdlib/2/email/charset.pyi jedi/third_party/typeshed/stdlib/2/email/encoders.pyi jedi/third_party/typeshed/stdlib/2/email/feedparser.pyi jedi/third_party/typeshed/stdlib/2/email/generator.pyi jedi/third_party/typeshed/stdlib/2/email/header.pyi jedi/third_party/typeshed/stdlib/2/email/iterators.pyi jedi/third_party/typeshed/stdlib/2/email/message.pyi jedi/third_party/typeshed/stdlib/2/email/parser.pyi jedi/third_party/typeshed/stdlib/2/email/quoprimime.pyi jedi/third_party/typeshed/stdlib/2/email/utils.pyi jedi/third_party/typeshed/stdlib/2/email/mime/__init__.pyi jedi/third_party/typeshed/stdlib/2/email/mime/application.pyi jedi/third_party/typeshed/stdlib/2/email/mime/audio.pyi jedi/third_party/typeshed/stdlib/2/email/mime/base.pyi jedi/third_party/typeshed/stdlib/2/email/mime/image.pyi jedi/third_party/typeshed/stdlib/2/email/mime/message.pyi jedi/third_party/typeshed/stdlib/2/email/mime/multipart.pyi jedi/third_party/typeshed/stdlib/2/email/mime/nonmultipart.pyi jedi/third_party/typeshed/stdlib/2/email/mime/text.pyi jedi/third_party/typeshed/stdlib/2/encodings/__init__.pyi jedi/third_party/typeshed/stdlib/2/encodings/utf_8.pyi jedi/third_party/typeshed/stdlib/2/multiprocessing/__init__.pyi jedi/third_party/typeshed/stdlib/2/multiprocessing/pool.pyi jedi/third_party/typeshed/stdlib/2/multiprocessing/process.pyi jedi/third_party/typeshed/stdlib/2/multiprocessing/util.pyi jedi/third_party/typeshed/stdlib/2/multiprocessing/dummy/__init__.pyi jedi/third_party/typeshed/stdlib/2/multiprocessing/dummy/connection.pyi jedi/third_party/typeshed/stdlib/2/os/__init__.pyi jedi/third_party/typeshed/stdlib/2/os/path.pyi jedi/third_party/typeshed/stdlib/2and3/__future__.pyi jedi/third_party/typeshed/stdlib/2and3/_bisect.pyi jedi/third_party/typeshed/stdlib/2and3/_codecs.pyi jedi/third_party/typeshed/stdlib/2and3/_csv.pyi jedi/third_party/typeshed/stdlib/2and3/_curses.pyi jedi/third_party/typeshed/stdlib/2and3/_dummy_threading.pyi jedi/third_party/typeshed/stdlib/2and3/_heapq.pyi jedi/third_party/typeshed/stdlib/2and3/_msi.pyi jedi/third_party/typeshed/stdlib/2and3/_random.pyi jedi/third_party/typeshed/stdlib/2and3/_warnings.pyi jedi/third_party/typeshed/stdlib/2and3/_weakref.pyi jedi/third_party/typeshed/stdlib/2and3/_weakrefset.pyi jedi/third_party/typeshed/stdlib/2and3/aifc.pyi jedi/third_party/typeshed/stdlib/2and3/antigravity.pyi jedi/third_party/typeshed/stdlib/2and3/argparse.pyi jedi/third_party/typeshed/stdlib/2and3/array.pyi jedi/third_party/typeshed/stdlib/2and3/asynchat.pyi jedi/third_party/typeshed/stdlib/2and3/asyncore.pyi jedi/third_party/typeshed/stdlib/2and3/audioop.pyi jedi/third_party/typeshed/stdlib/2and3/base64.pyi jedi/third_party/typeshed/stdlib/2and3/bdb.pyi jedi/third_party/typeshed/stdlib/2and3/binascii.pyi jedi/third_party/typeshed/stdlib/2and3/binhex.pyi jedi/third_party/typeshed/stdlib/2and3/bisect.pyi jedi/third_party/typeshed/stdlib/2and3/bz2.pyi jedi/third_party/typeshed/stdlib/2and3/cProfile.pyi jedi/third_party/typeshed/stdlib/2and3/calendar.pyi jedi/third_party/typeshed/stdlib/2and3/cgi.pyi jedi/third_party/typeshed/stdlib/2and3/cgitb.pyi jedi/third_party/typeshed/stdlib/2and3/chunk.pyi jedi/third_party/typeshed/stdlib/2and3/cmath.pyi jedi/third_party/typeshed/stdlib/2and3/cmd.pyi jedi/third_party/typeshed/stdlib/2and3/code.pyi jedi/third_party/typeshed/stdlib/2and3/codecs.pyi jedi/third_party/typeshed/stdlib/2and3/codeop.pyi jedi/third_party/typeshed/stdlib/2and3/colorsys.pyi jedi/third_party/typeshed/stdlib/2and3/contextlib.pyi jedi/third_party/typeshed/stdlib/2and3/copy.pyi jedi/third_party/typeshed/stdlib/2and3/crypt.pyi jedi/third_party/typeshed/stdlib/2and3/csv.pyi jedi/third_party/typeshed/stdlib/2and3/datetime.pyi jedi/third_party/typeshed/stdlib/2and3/decimal.pyi jedi/third_party/typeshed/stdlib/2and3/difflib.pyi jedi/third_party/typeshed/stdlib/2and3/dis.pyi jedi/third_party/typeshed/stdlib/2and3/doctest.pyi jedi/third_party/typeshed/stdlib/2and3/dummy_threading.pyi jedi/third_party/typeshed/stdlib/2and3/errno.pyi jedi/third_party/typeshed/stdlib/2and3/filecmp.pyi jedi/third_party/typeshed/stdlib/2and3/fileinput.pyi jedi/third_party/typeshed/stdlib/2and3/formatter.pyi jedi/third_party/typeshed/stdlib/2and3/fractions.pyi jedi/third_party/typeshed/stdlib/2and3/ftplib.pyi jedi/third_party/typeshed/stdlib/2and3/genericpath.pyi jedi/third_party/typeshed/stdlib/2and3/grp.pyi jedi/third_party/typeshed/stdlib/2and3/hmac.pyi jedi/third_party/typeshed/stdlib/2and3/imaplib.pyi jedi/third_party/typeshed/stdlib/2and3/imghdr.pyi jedi/third_party/typeshed/stdlib/2and3/keyword.pyi jedi/third_party/typeshed/stdlib/2and3/linecache.pyi jedi/third_party/typeshed/stdlib/2and3/locale.pyi jedi/third_party/typeshed/stdlib/2and3/macpath.pyi jedi/third_party/typeshed/stdlib/2and3/mailbox.pyi jedi/third_party/typeshed/stdlib/2and3/mailcap.pyi jedi/third_party/typeshed/stdlib/2and3/marshal.pyi jedi/third_party/typeshed/stdlib/2and3/math.pyi jedi/third_party/typeshed/stdlib/2and3/mimetypes.pyi jedi/third_party/typeshed/stdlib/2and3/mmap.pyi jedi/third_party/typeshed/stdlib/2and3/modulefinder.pyi jedi/third_party/typeshed/stdlib/2and3/msvcrt.pyi jedi/third_party/typeshed/stdlib/2and3/netrc.pyi jedi/third_party/typeshed/stdlib/2and3/nis.pyi jedi/third_party/typeshed/stdlib/2and3/numbers.pyi jedi/third_party/typeshed/stdlib/2and3/opcode.pyi jedi/third_party/typeshed/stdlib/2and3/operator.pyi jedi/third_party/typeshed/stdlib/2and3/optparse.pyi jedi/third_party/typeshed/stdlib/2and3/parser.pyi jedi/third_party/typeshed/stdlib/2and3/pdb.pyi jedi/third_party/typeshed/stdlib/2and3/pickle.pyi jedi/third_party/typeshed/stdlib/2and3/pickletools.pyi jedi/third_party/typeshed/stdlib/2and3/pkgutil.pyi jedi/third_party/typeshed/stdlib/2and3/plistlib.pyi jedi/third_party/typeshed/stdlib/2and3/poplib.pyi jedi/third_party/typeshed/stdlib/2and3/pprint.pyi jedi/third_party/typeshed/stdlib/2and3/profile.pyi jedi/third_party/typeshed/stdlib/2and3/pstats.pyi jedi/third_party/typeshed/stdlib/2and3/pty.pyi jedi/third_party/typeshed/stdlib/2and3/pwd.pyi jedi/third_party/typeshed/stdlib/2and3/py_compile.pyi jedi/third_party/typeshed/stdlib/2and3/pyclbr.pyi jedi/third_party/typeshed/stdlib/2and3/pydoc.pyi jedi/third_party/typeshed/stdlib/2and3/quopri.pyi jedi/third_party/typeshed/stdlib/2and3/readline.pyi jedi/third_party/typeshed/stdlib/2and3/rlcompleter.pyi jedi/third_party/typeshed/stdlib/2and3/sched.pyi jedi/third_party/typeshed/stdlib/2and3/select.pyi jedi/third_party/typeshed/stdlib/2and3/shutil.pyi jedi/third_party/typeshed/stdlib/2and3/site.pyi jedi/third_party/typeshed/stdlib/2and3/smtpd.pyi jedi/third_party/typeshed/stdlib/2and3/sndhdr.pyi jedi/third_party/typeshed/stdlib/2and3/socket.pyi jedi/third_party/typeshed/stdlib/2and3/sre_compile.pyi jedi/third_party/typeshed/stdlib/2and3/ssl.pyi jedi/third_party/typeshed/stdlib/2and3/stringprep.pyi jedi/third_party/typeshed/stdlib/2and3/struct.pyi jedi/third_party/typeshed/stdlib/2and3/sunau.pyi jedi/third_party/typeshed/stdlib/2and3/symtable.pyi jedi/third_party/typeshed/stdlib/2and3/sysconfig.pyi jedi/third_party/typeshed/stdlib/2and3/syslog.pyi jedi/third_party/typeshed/stdlib/2and3/tabnanny.pyi jedi/third_party/typeshed/stdlib/2and3/tarfile.pyi jedi/third_party/typeshed/stdlib/2and3/telnetlib.pyi jedi/third_party/typeshed/stdlib/2and3/termios.pyi jedi/third_party/typeshed/stdlib/2and3/this.pyi jedi/third_party/typeshed/stdlib/2and3/threading.pyi jedi/third_party/typeshed/stdlib/2and3/time.pyi jedi/third_party/typeshed/stdlib/2and3/timeit.pyi jedi/third_party/typeshed/stdlib/2and3/token.pyi jedi/third_party/typeshed/stdlib/2and3/trace.pyi jedi/third_party/typeshed/stdlib/2and3/traceback.pyi jedi/third_party/typeshed/stdlib/2and3/tty.pyi jedi/third_party/typeshed/stdlib/2and3/turtle.pyi jedi/third_party/typeshed/stdlib/2and3/unicodedata.pyi jedi/third_party/typeshed/stdlib/2and3/uu.pyi jedi/third_party/typeshed/stdlib/2and3/uuid.pyi jedi/third_party/typeshed/stdlib/2and3/warnings.pyi jedi/third_party/typeshed/stdlib/2and3/wave.pyi jedi/third_party/typeshed/stdlib/2and3/weakref.pyi jedi/third_party/typeshed/stdlib/2and3/webbrowser.pyi jedi/third_party/typeshed/stdlib/2and3/winsound.pyi jedi/third_party/typeshed/stdlib/2and3/xdrlib.pyi jedi/third_party/typeshed/stdlib/2and3/zipfile.pyi jedi/third_party/typeshed/stdlib/2and3/zipimport.pyi jedi/third_party/typeshed/stdlib/2and3/zlib.pyi jedi/third_party/typeshed/stdlib/2and3/_typeshed/__init__.pyi jedi/third_party/typeshed/stdlib/2and3/_typeshed/wsgi.pyi jedi/third_party/typeshed/stdlib/2and3/_typeshed/xml.pyi jedi/third_party/typeshed/stdlib/2and3/ctypes/__init__.pyi jedi/third_party/typeshed/stdlib/2and3/ctypes/util.pyi jedi/third_party/typeshed/stdlib/2and3/ctypes/wintypes.pyi jedi/third_party/typeshed/stdlib/2and3/curses/__init__.pyi jedi/third_party/typeshed/stdlib/2and3/curses/ascii.pyi jedi/third_party/typeshed/stdlib/2and3/curses/panel.pyi jedi/third_party/typeshed/stdlib/2and3/curses/textpad.pyi jedi/third_party/typeshed/stdlib/2and3/ensurepip/__init__.pyi jedi/third_party/typeshed/stdlib/2and3/lib2to3/__init__.pyi jedi/third_party/typeshed/stdlib/2and3/lib2to3/pygram.pyi jedi/third_party/typeshed/stdlib/2and3/lib2to3/pytree.pyi jedi/third_party/typeshed/stdlib/2and3/lib2to3/pgen2/__init__.pyi jedi/third_party/typeshed/stdlib/2and3/lib2to3/pgen2/driver.pyi jedi/third_party/typeshed/stdlib/2and3/lib2to3/pgen2/grammar.pyi jedi/third_party/typeshed/stdlib/2and3/lib2to3/pgen2/literals.pyi jedi/third_party/typeshed/stdlib/2and3/lib2to3/pgen2/parse.pyi jedi/third_party/typeshed/stdlib/2and3/lib2to3/pgen2/pgen.pyi jedi/third_party/typeshed/stdlib/2and3/lib2to3/pgen2/token.pyi jedi/third_party/typeshed/stdlib/2and3/lib2to3/pgen2/tokenize.pyi jedi/third_party/typeshed/stdlib/2and3/logging/__init__.pyi jedi/third_party/typeshed/stdlib/2and3/logging/config.pyi jedi/third_party/typeshed/stdlib/2and3/logging/handlers.pyi jedi/third_party/typeshed/stdlib/2and3/msilib/__init__.pyi jedi/third_party/typeshed/stdlib/2and3/msilib/schema.pyi jedi/third_party/typeshed/stdlib/2and3/msilib/sequence.pyi jedi/third_party/typeshed/stdlib/2and3/msilib/text.pyi jedi/third_party/typeshed/stdlib/2and3/pydoc_data/__init__.pyi jedi/third_party/typeshed/stdlib/2and3/pydoc_data/topics.pyi jedi/third_party/typeshed/stdlib/2and3/pyexpat/__init__.pyi jedi/third_party/typeshed/stdlib/2and3/pyexpat/errors.pyi jedi/third_party/typeshed/stdlib/2and3/pyexpat/model.pyi jedi/third_party/typeshed/stdlib/2and3/sqlite3/__init__.pyi jedi/third_party/typeshed/stdlib/2and3/sqlite3/dbapi2.pyi jedi/third_party/typeshed/stdlib/2and3/wsgiref/__init__.pyi jedi/third_party/typeshed/stdlib/2and3/wsgiref/handlers.pyi jedi/third_party/typeshed/stdlib/2and3/wsgiref/headers.pyi jedi/third_party/typeshed/stdlib/2and3/wsgiref/simple_server.pyi jedi/third_party/typeshed/stdlib/2and3/wsgiref/types.pyi jedi/third_party/typeshed/stdlib/2and3/wsgiref/util.pyi jedi/third_party/typeshed/stdlib/2and3/wsgiref/validate.pyi jedi/third_party/typeshed/stdlib/2and3/xml/__init__.pyi jedi/third_party/typeshed/stdlib/2and3/xml/dom/NodeFilter.pyi jedi/third_party/typeshed/stdlib/2and3/xml/dom/__init__.pyi jedi/third_party/typeshed/stdlib/2and3/xml/dom/domreg.pyi jedi/third_party/typeshed/stdlib/2and3/xml/dom/expatbuilder.pyi jedi/third_party/typeshed/stdlib/2and3/xml/dom/minicompat.pyi jedi/third_party/typeshed/stdlib/2and3/xml/dom/minidom.pyi jedi/third_party/typeshed/stdlib/2and3/xml/dom/pulldom.pyi jedi/third_party/typeshed/stdlib/2and3/xml/dom/xmlbuilder.pyi jedi/third_party/typeshed/stdlib/2and3/xml/etree/ElementInclude.pyi jedi/third_party/typeshed/stdlib/2and3/xml/etree/ElementPath.pyi jedi/third_party/typeshed/stdlib/2and3/xml/etree/ElementTree.pyi jedi/third_party/typeshed/stdlib/2and3/xml/etree/__init__.pyi jedi/third_party/typeshed/stdlib/2and3/xml/etree/cElementTree.pyi jedi/third_party/typeshed/stdlib/2and3/xml/parsers/__init__.pyi jedi/third_party/typeshed/stdlib/2and3/xml/parsers/expat/__init__.pyi jedi/third_party/typeshed/stdlib/2and3/xml/parsers/expat/errors.pyi jedi/third_party/typeshed/stdlib/2and3/xml/parsers/expat/model.pyi jedi/third_party/typeshed/stdlib/2and3/xml/sax/__init__.pyi jedi/third_party/typeshed/stdlib/2and3/xml/sax/handler.pyi jedi/third_party/typeshed/stdlib/2and3/xml/sax/saxutils.pyi jedi/third_party/typeshed/stdlib/2and3/xml/sax/xmlreader.pyi jedi/third_party/typeshed/stdlib/3/_ast.pyi jedi/third_party/typeshed/stdlib/3/_bootlocale.pyi jedi/third_party/typeshed/stdlib/3/_compat_pickle.pyi jedi/third_party/typeshed/stdlib/3/_compression.pyi jedi/third_party/typeshed/stdlib/3/_decimal.pyi jedi/third_party/typeshed/stdlib/3/_dummy_thread.pyi jedi/third_party/typeshed/stdlib/3/_imp.pyi jedi/third_party/typeshed/stdlib/3/_importlib_modulespec.pyi jedi/third_party/typeshed/stdlib/3/_json.pyi jedi/third_party/typeshed/stdlib/3/_markupbase.pyi jedi/third_party/typeshed/stdlib/3/_operator.pyi jedi/third_party/typeshed/stdlib/3/_osx_support.pyi jedi/third_party/typeshed/stdlib/3/_posixsubprocess.pyi jedi/third_party/typeshed/stdlib/3/_pydecimal.pyi jedi/third_party/typeshed/stdlib/3/_sitebuiltins.pyi jedi/third_party/typeshed/stdlib/3/_stat.pyi jedi/third_party/typeshed/stdlib/3/_thread.pyi jedi/third_party/typeshed/stdlib/3/_threading_local.pyi jedi/third_party/typeshed/stdlib/3/_tkinter.pyi jedi/third_party/typeshed/stdlib/3/_tracemalloc.pyi jedi/third_party/typeshed/stdlib/3/_winapi.pyi jedi/third_party/typeshed/stdlib/3/abc.pyi jedi/third_party/typeshed/stdlib/3/ast.pyi jedi/third_party/typeshed/stdlib/3/atexit.pyi jedi/third_party/typeshed/stdlib/3/builtins.pyi jedi/third_party/typeshed/stdlib/3/compileall.pyi jedi/third_party/typeshed/stdlib/3/configparser.pyi jedi/third_party/typeshed/stdlib/3/copyreg.pyi jedi/third_party/typeshed/stdlib/3/enum.pyi jedi/third_party/typeshed/stdlib/3/faulthandler.pyi jedi/third_party/typeshed/stdlib/3/fcntl.pyi jedi/third_party/typeshed/stdlib/3/fnmatch.pyi jedi/third_party/typeshed/stdlib/3/functools.pyi jedi/third_party/typeshed/stdlib/3/gc.pyi jedi/third_party/typeshed/stdlib/3/getopt.pyi jedi/third_party/typeshed/stdlib/3/getpass.pyi jedi/third_party/typeshed/stdlib/3/gettext.pyi jedi/third_party/typeshed/stdlib/3/glob.pyi jedi/third_party/typeshed/stdlib/3/gzip.pyi jedi/third_party/typeshed/stdlib/3/hashlib.pyi jedi/third_party/typeshed/stdlib/3/heapq.pyi jedi/third_party/typeshed/stdlib/3/imp.pyi jedi/third_party/typeshed/stdlib/3/inspect.pyi jedi/third_party/typeshed/stdlib/3/io.pyi jedi/third_party/typeshed/stdlib/3/ipaddress.pyi jedi/third_party/typeshed/stdlib/3/itertools.pyi jedi/third_party/typeshed/stdlib/3/lzma.pyi jedi/third_party/typeshed/stdlib/3/macurl2path.pyi jedi/third_party/typeshed/stdlib/3/nntplib.pyi jedi/third_party/typeshed/stdlib/3/ntpath.pyi jedi/third_party/typeshed/stdlib/3/nturl2path.pyi jedi/third_party/typeshed/stdlib/3/pathlib.pyi jedi/third_party/typeshed/stdlib/3/pipes.pyi jedi/third_party/typeshed/stdlib/3/platform.pyi jedi/third_party/typeshed/stdlib/3/posix.pyi jedi/third_party/typeshed/stdlib/3/posixpath.pyi jedi/third_party/typeshed/stdlib/3/queue.pyi jedi/third_party/typeshed/stdlib/3/random.pyi jedi/third_party/typeshed/stdlib/3/re.pyi jedi/third_party/typeshed/stdlib/3/reprlib.pyi jedi/third_party/typeshed/stdlib/3/resource.pyi jedi/third_party/typeshed/stdlib/3/runpy.pyi jedi/third_party/typeshed/stdlib/3/secrets.pyi jedi/third_party/typeshed/stdlib/3/selectors.pyi jedi/third_party/typeshed/stdlib/3/shelve.pyi jedi/third_party/typeshed/stdlib/3/shlex.pyi jedi/third_party/typeshed/stdlib/3/signal.pyi jedi/third_party/typeshed/stdlib/3/smtplib.pyi jedi/third_party/typeshed/stdlib/3/socketserver.pyi jedi/third_party/typeshed/stdlib/3/spwd.pyi jedi/third_party/typeshed/stdlib/3/sre_constants.pyi jedi/third_party/typeshed/stdlib/3/sre_parse.pyi jedi/third_party/typeshed/stdlib/3/stat.pyi jedi/third_party/typeshed/stdlib/3/statistics.pyi jedi/third_party/typeshed/stdlib/3/string.pyi jedi/third_party/typeshed/stdlib/3/subprocess.pyi jedi/third_party/typeshed/stdlib/3/symbol.pyi jedi/third_party/typeshed/stdlib/3/sys.pyi jedi/third_party/typeshed/stdlib/3/tempfile.pyi jedi/third_party/typeshed/stdlib/3/textwrap.pyi jedi/third_party/typeshed/stdlib/3/tokenize.pyi jedi/third_party/typeshed/stdlib/3/tracemalloc.pyi jedi/third_party/typeshed/stdlib/3/types.pyi jedi/third_party/typeshed/stdlib/3/typing.pyi jedi/third_party/typeshed/stdlib/3/winreg.pyi jedi/third_party/typeshed/stdlib/3/xxlimited.pyi jedi/third_party/typeshed/stdlib/3/zipapp.pyi jedi/third_party/typeshed/stdlib/3.7/_py_abc.pyi jedi/third_party/typeshed/stdlib/3.7/contextvars.pyi jedi/third_party/typeshed/stdlib/3.7/dataclasses.pyi jedi/third_party/typeshed/stdlib/3.9/graphlib.pyi jedi/third_party/typeshed/stdlib/3.9/zoneinfo/__init__.pyi jedi/third_party/typeshed/stdlib/3/asyncio/__init__.pyi jedi/third_party/typeshed/stdlib/3/asyncio/base_events.pyi jedi/third_party/typeshed/stdlib/3/asyncio/base_futures.pyi jedi/third_party/typeshed/stdlib/3/asyncio/base_subprocess.pyi jedi/third_party/typeshed/stdlib/3/asyncio/base_tasks.pyi jedi/third_party/typeshed/stdlib/3/asyncio/compat.pyi jedi/third_party/typeshed/stdlib/3/asyncio/constants.pyi jedi/third_party/typeshed/stdlib/3/asyncio/coroutines.pyi jedi/third_party/typeshed/stdlib/3/asyncio/events.pyi jedi/third_party/typeshed/stdlib/3/asyncio/exceptions.pyi jedi/third_party/typeshed/stdlib/3/asyncio/format_helpers.pyi jedi/third_party/typeshed/stdlib/3/asyncio/futures.pyi jedi/third_party/typeshed/stdlib/3/asyncio/locks.pyi jedi/third_party/typeshed/stdlib/3/asyncio/log.pyi jedi/third_party/typeshed/stdlib/3/asyncio/proactor_events.pyi jedi/third_party/typeshed/stdlib/3/asyncio/protocols.pyi jedi/third_party/typeshed/stdlib/3/asyncio/queues.pyi jedi/third_party/typeshed/stdlib/3/asyncio/runners.pyi jedi/third_party/typeshed/stdlib/3/asyncio/selector_events.pyi jedi/third_party/typeshed/stdlib/3/asyncio/sslproto.pyi jedi/third_party/typeshed/stdlib/3/asyncio/staggered.pyi jedi/third_party/typeshed/stdlib/3/asyncio/streams.pyi jedi/third_party/typeshed/stdlib/3/asyncio/subprocess.pyi jedi/third_party/typeshed/stdlib/3/asyncio/tasks.pyi jedi/third_party/typeshed/stdlib/3/asyncio/threads.pyi jedi/third_party/typeshed/stdlib/3/asyncio/transports.pyi jedi/third_party/typeshed/stdlib/3/asyncio/trsock.pyi jedi/third_party/typeshed/stdlib/3/asyncio/unix_events.pyi jedi/third_party/typeshed/stdlib/3/asyncio/windows_events.pyi jedi/third_party/typeshed/stdlib/3/asyncio/windows_utils.pyi jedi/third_party/typeshed/stdlib/3/collections/__init__.pyi jedi/third_party/typeshed/stdlib/3/collections/abc.pyi jedi/third_party/typeshed/stdlib/3/concurrent/__init__.pyi jedi/third_party/typeshed/stdlib/3/concurrent/futures/__init__.pyi jedi/third_party/typeshed/stdlib/3/concurrent/futures/_base.pyi jedi/third_party/typeshed/stdlib/3/concurrent/futures/process.pyi jedi/third_party/typeshed/stdlib/3/concurrent/futures/thread.pyi jedi/third_party/typeshed/stdlib/3/dbm/__init__.pyi jedi/third_party/typeshed/stdlib/3/dbm/dumb.pyi jedi/third_party/typeshed/stdlib/3/dbm/gnu.pyi jedi/third_party/typeshed/stdlib/3/dbm/ndbm.pyi jedi/third_party/typeshed/stdlib/3/distutils/__init__.pyi jedi/third_party/typeshed/stdlib/3/distutils/archive_util.pyi jedi/third_party/typeshed/stdlib/3/distutils/bcppcompiler.pyi jedi/third_party/typeshed/stdlib/3/distutils/ccompiler.pyi jedi/third_party/typeshed/stdlib/3/distutils/cmd.pyi jedi/third_party/typeshed/stdlib/3/distutils/config.pyi jedi/third_party/typeshed/stdlib/3/distutils/core.pyi jedi/third_party/typeshed/stdlib/3/distutils/cygwinccompiler.pyi jedi/third_party/typeshed/stdlib/3/distutils/debug.pyi jedi/third_party/typeshed/stdlib/3/distutils/dep_util.pyi jedi/third_party/typeshed/stdlib/3/distutils/dir_util.pyi jedi/third_party/typeshed/stdlib/3/distutils/dist.pyi jedi/third_party/typeshed/stdlib/3/distutils/errors.pyi jedi/third_party/typeshed/stdlib/3/distutils/extension.pyi jedi/third_party/typeshed/stdlib/3/distutils/fancy_getopt.pyi jedi/third_party/typeshed/stdlib/3/distutils/file_util.pyi jedi/third_party/typeshed/stdlib/3/distutils/filelist.pyi jedi/third_party/typeshed/stdlib/3/distutils/log.pyi jedi/third_party/typeshed/stdlib/3/distutils/msvccompiler.pyi jedi/third_party/typeshed/stdlib/3/distutils/spawn.pyi jedi/third_party/typeshed/stdlib/3/distutils/sysconfig.pyi jedi/third_party/typeshed/stdlib/3/distutils/text_file.pyi jedi/third_party/typeshed/stdlib/3/distutils/unixccompiler.pyi jedi/third_party/typeshed/stdlib/3/distutils/util.pyi jedi/third_party/typeshed/stdlib/3/distutils/version.pyi jedi/third_party/typeshed/stdlib/3/distutils/command/__init__.pyi jedi/third_party/typeshed/stdlib/3/distutils/command/bdist.pyi jedi/third_party/typeshed/stdlib/3/distutils/command/bdist_dumb.pyi jedi/third_party/typeshed/stdlib/3/distutils/command/bdist_msi.pyi jedi/third_party/typeshed/stdlib/3/distutils/command/bdist_packager.pyi jedi/third_party/typeshed/stdlib/3/distutils/command/bdist_rpm.pyi jedi/third_party/typeshed/stdlib/3/distutils/command/bdist_wininst.pyi jedi/third_party/typeshed/stdlib/3/distutils/command/build.pyi jedi/third_party/typeshed/stdlib/3/distutils/command/build_clib.pyi jedi/third_party/typeshed/stdlib/3/distutils/command/build_ext.pyi jedi/third_party/typeshed/stdlib/3/distutils/command/build_py.pyi jedi/third_party/typeshed/stdlib/3/distutils/command/build_scripts.pyi jedi/third_party/typeshed/stdlib/3/distutils/command/check.pyi jedi/third_party/typeshed/stdlib/3/distutils/command/clean.pyi jedi/third_party/typeshed/stdlib/3/distutils/command/config.pyi jedi/third_party/typeshed/stdlib/3/distutils/command/install.pyi jedi/third_party/typeshed/stdlib/3/distutils/command/install_data.pyi jedi/third_party/typeshed/stdlib/3/distutils/command/install_egg_info.pyi jedi/third_party/typeshed/stdlib/3/distutils/command/install_headers.pyi jedi/third_party/typeshed/stdlib/3/distutils/command/install_lib.pyi jedi/third_party/typeshed/stdlib/3/distutils/command/install_scripts.pyi jedi/third_party/typeshed/stdlib/3/distutils/command/register.pyi jedi/third_party/typeshed/stdlib/3/distutils/command/sdist.pyi jedi/third_party/typeshed/stdlib/3/distutils/command/upload.pyi jedi/third_party/typeshed/stdlib/3/email/__init__.pyi jedi/third_party/typeshed/stdlib/3/email/charset.pyi jedi/third_party/typeshed/stdlib/3/email/contentmanager.pyi jedi/third_party/typeshed/stdlib/3/email/encoders.pyi jedi/third_party/typeshed/stdlib/3/email/errors.pyi jedi/third_party/typeshed/stdlib/3/email/feedparser.pyi jedi/third_party/typeshed/stdlib/3/email/generator.pyi jedi/third_party/typeshed/stdlib/3/email/header.pyi jedi/third_party/typeshed/stdlib/3/email/headerregistry.pyi jedi/third_party/typeshed/stdlib/3/email/iterators.pyi jedi/third_party/typeshed/stdlib/3/email/message.pyi jedi/third_party/typeshed/stdlib/3/email/parser.pyi jedi/third_party/typeshed/stdlib/3/email/policy.pyi jedi/third_party/typeshed/stdlib/3/email/utils.pyi jedi/third_party/typeshed/stdlib/3/email/mime/__init__.pyi jedi/third_party/typeshed/stdlib/3/email/mime/application.pyi jedi/third_party/typeshed/stdlib/3/email/mime/audio.pyi jedi/third_party/typeshed/stdlib/3/email/mime/base.pyi jedi/third_party/typeshed/stdlib/3/email/mime/image.pyi jedi/third_party/typeshed/stdlib/3/email/mime/message.pyi jedi/third_party/typeshed/stdlib/3/email/mime/multipart.pyi jedi/third_party/typeshed/stdlib/3/email/mime/nonmultipart.pyi jedi/third_party/typeshed/stdlib/3/email/mime/text.pyi jedi/third_party/typeshed/stdlib/3/encodings/__init__.pyi jedi/third_party/typeshed/stdlib/3/encodings/utf_8.pyi jedi/third_party/typeshed/stdlib/3/html/__init__.pyi jedi/third_party/typeshed/stdlib/3/html/entities.pyi jedi/third_party/typeshed/stdlib/3/html/parser.pyi jedi/third_party/typeshed/stdlib/3/http/__init__.pyi jedi/third_party/typeshed/stdlib/3/http/client.pyi jedi/third_party/typeshed/stdlib/3/http/cookiejar.pyi jedi/third_party/typeshed/stdlib/3/http/cookies.pyi jedi/third_party/typeshed/stdlib/3/http/server.pyi jedi/third_party/typeshed/stdlib/3/importlib/__init__.pyi jedi/third_party/typeshed/stdlib/3/importlib/abc.pyi jedi/third_party/typeshed/stdlib/3/importlib/machinery.pyi jedi/third_party/typeshed/stdlib/3/importlib/metadata.pyi jedi/third_party/typeshed/stdlib/3/importlib/resources.pyi jedi/third_party/typeshed/stdlib/3/importlib/util.pyi jedi/third_party/typeshed/stdlib/3/json/__init__.pyi jedi/third_party/typeshed/stdlib/3/json/decoder.pyi jedi/third_party/typeshed/stdlib/3/json/encoder.pyi jedi/third_party/typeshed/stdlib/3/json/tool.pyi jedi/third_party/typeshed/stdlib/3/multiprocessing/__init__.pyi jedi/third_party/typeshed/stdlib/3/multiprocessing/connection.pyi jedi/third_party/typeshed/stdlib/3/multiprocessing/context.pyi jedi/third_party/typeshed/stdlib/3/multiprocessing/managers.pyi jedi/third_party/typeshed/stdlib/3/multiprocessing/pool.pyi jedi/third_party/typeshed/stdlib/3/multiprocessing/process.pyi jedi/third_party/typeshed/stdlib/3/multiprocessing/queues.pyi jedi/third_party/typeshed/stdlib/3/multiprocessing/shared_memory.pyi jedi/third_party/typeshed/stdlib/3/multiprocessing/sharedctypes.pyi jedi/third_party/typeshed/stdlib/3/multiprocessing/spawn.pyi jedi/third_party/typeshed/stdlib/3/multiprocessing/synchronize.pyi jedi/third_party/typeshed/stdlib/3/multiprocessing/dummy/__init__.pyi jedi/third_party/typeshed/stdlib/3/multiprocessing/dummy/connection.pyi jedi/third_party/typeshed/stdlib/3/os/__init__.pyi jedi/third_party/typeshed/stdlib/3/os/path.pyi jedi/third_party/typeshed/stdlib/3/tkinter/__init__.pyi jedi/third_party/typeshed/stdlib/3/tkinter/commondialog.pyi jedi/third_party/typeshed/stdlib/3/tkinter/constants.pyi jedi/third_party/typeshed/stdlib/3/tkinter/dialog.pyi jedi/third_party/typeshed/stdlib/3/tkinter/filedialog.pyi jedi/third_party/typeshed/stdlib/3/tkinter/font.pyi jedi/third_party/typeshed/stdlib/3/tkinter/messagebox.pyi jedi/third_party/typeshed/stdlib/3/tkinter/ttk.pyi jedi/third_party/typeshed/stdlib/3/unittest/__init__.pyi jedi/third_party/typeshed/stdlib/3/unittest/async_case.pyi jedi/third_party/typeshed/stdlib/3/unittest/case.pyi jedi/third_party/typeshed/stdlib/3/unittest/loader.pyi jedi/third_party/typeshed/stdlib/3/unittest/main.pyi jedi/third_party/typeshed/stdlib/3/unittest/mock.pyi jedi/third_party/typeshed/stdlib/3/unittest/result.pyi jedi/third_party/typeshed/stdlib/3/unittest/runner.pyi jedi/third_party/typeshed/stdlib/3/unittest/signals.pyi jedi/third_party/typeshed/stdlib/3/unittest/suite.pyi jedi/third_party/typeshed/stdlib/3/unittest/util.pyi jedi/third_party/typeshed/stdlib/3/urllib/__init__.pyi jedi/third_party/typeshed/stdlib/3/urllib/error.pyi jedi/third_party/typeshed/stdlib/3/urllib/parse.pyi jedi/third_party/typeshed/stdlib/3/urllib/request.pyi jedi/third_party/typeshed/stdlib/3/urllib/response.pyi jedi/third_party/typeshed/stdlib/3/urllib/robotparser.pyi jedi/third_party/typeshed/stdlib/3/venv/__init__.pyi jedi/third_party/typeshed/stdlib/3/xmlrpc/__init__.pyi jedi/third_party/typeshed/stdlib/3/xmlrpc/client.pyi jedi/third_party/typeshed/stdlib/3/xmlrpc/server.pyi jedi/third_party/typeshed/third_party/2/enum.pyi jedi/third_party/typeshed/third_party/2/ipaddress.pyi jedi/third_party/typeshed/third_party/2/pathlib2.pyi jedi/third_party/typeshed/third_party/2/pymssql.pyi jedi/third_party/typeshed/third_party/2/OpenSSL/__init__.pyi jedi/third_party/typeshed/third_party/2/OpenSSL/crypto.pyi jedi/third_party/typeshed/third_party/2/concurrent/__init__.pyi jedi/third_party/typeshed/third_party/2/concurrent/futures/__init__.pyi jedi/third_party/typeshed/third_party/2/concurrent/futures/_base.pyi jedi/third_party/typeshed/third_party/2/concurrent/futures/process.pyi jedi/third_party/typeshed/third_party/2/concurrent/futures/thread.pyi jedi/third_party/typeshed/third_party/2/fb303/FacebookService.pyi jedi/third_party/typeshed/third_party/2/fb303/__init__.pyi jedi/third_party/typeshed/third_party/2/kazoo/__init__.pyi jedi/third_party/typeshed/third_party/2/kazoo/client.pyi jedi/third_party/typeshed/third_party/2/kazoo/exceptions.pyi jedi/third_party/typeshed/third_party/2/kazoo/recipe/__init__.pyi jedi/third_party/typeshed/third_party/2/kazoo/recipe/watchers.pyi jedi/third_party/typeshed/third_party/2/routes/__init__.pyi jedi/third_party/typeshed/third_party/2/routes/mapper.pyi jedi/third_party/typeshed/third_party/2/routes/util.pyi jedi/third_party/typeshed/third_party/2/scribe/__init__.pyi jedi/third_party/typeshed/third_party/2/scribe/scribe.pyi jedi/third_party/typeshed/third_party/2/scribe/ttypes.pyi jedi/third_party/typeshed/third_party/2/six/__init__.pyi jedi/third_party/typeshed/third_party/2/six/moves/BaseHTTPServer.pyi jedi/third_party/typeshed/third_party/2/six/moves/CGIHTTPServer.pyi jedi/third_party/typeshed/third_party/2/six/moves/SimpleHTTPServer.pyi jedi/third_party/typeshed/third_party/2/six/moves/__init__.pyi jedi/third_party/typeshed/third_party/2/six/moves/_dummy_thread.pyi jedi/third_party/typeshed/third_party/2/six/moves/_thread.pyi jedi/third_party/typeshed/third_party/2/six/moves/cPickle.pyi jedi/third_party/typeshed/third_party/2/six/moves/collections_abc.pyi jedi/third_party/typeshed/third_party/2/six/moves/configparser.pyi jedi/third_party/typeshed/third_party/2/six/moves/email_mime_base.pyi jedi/third_party/typeshed/third_party/2/six/moves/email_mime_multipart.pyi jedi/third_party/typeshed/third_party/2/six/moves/email_mime_nonmultipart.pyi jedi/third_party/typeshed/third_party/2/six/moves/email_mime_text.pyi jedi/third_party/typeshed/third_party/2/six/moves/html_entities.pyi jedi/third_party/typeshed/third_party/2/six/moves/html_parser.pyi jedi/third_party/typeshed/third_party/2/six/moves/http_client.pyi jedi/third_party/typeshed/third_party/2/six/moves/http_cookiejar.pyi jedi/third_party/typeshed/third_party/2/six/moves/http_cookies.pyi jedi/third_party/typeshed/third_party/2/six/moves/queue.pyi jedi/third_party/typeshed/third_party/2/six/moves/reprlib.pyi jedi/third_party/typeshed/third_party/2/six/moves/socketserver.pyi jedi/third_party/typeshed/third_party/2/six/moves/urllib_error.pyi jedi/third_party/typeshed/third_party/2/six/moves/urllib_parse.pyi jedi/third_party/typeshed/third_party/2/six/moves/urllib_request.pyi jedi/third_party/typeshed/third_party/2/six/moves/urllib_response.pyi jedi/third_party/typeshed/third_party/2/six/moves/urllib_robotparser.pyi jedi/third_party/typeshed/third_party/2/six/moves/xmlrpc_client.pyi jedi/third_party/typeshed/third_party/2/six/moves/urllib/__init__.pyi jedi/third_party/typeshed/third_party/2/six/moves/urllib/error.pyi jedi/third_party/typeshed/third_party/2/six/moves/urllib/parse.pyi jedi/third_party/typeshed/third_party/2/six/moves/urllib/request.pyi jedi/third_party/typeshed/third_party/2/six/moves/urllib/response.pyi jedi/third_party/typeshed/third_party/2/six/moves/urllib/robotparser.pyi jedi/third_party/typeshed/third_party/2/tornado/__init__.pyi jedi/third_party/typeshed/third_party/2/tornado/concurrent.pyi jedi/third_party/typeshed/third_party/2/tornado/gen.pyi jedi/third_party/typeshed/third_party/2/tornado/httpclient.pyi jedi/third_party/typeshed/third_party/2/tornado/httpserver.pyi jedi/third_party/typeshed/third_party/2/tornado/httputil.pyi jedi/third_party/typeshed/third_party/2/tornado/ioloop.pyi jedi/third_party/typeshed/third_party/2/tornado/locks.pyi jedi/third_party/typeshed/third_party/2/tornado/netutil.pyi jedi/third_party/typeshed/third_party/2/tornado/process.pyi jedi/third_party/typeshed/third_party/2/tornado/tcpserver.pyi jedi/third_party/typeshed/third_party/2/tornado/testing.pyi jedi/third_party/typeshed/third_party/2/tornado/util.pyi jedi/third_party/typeshed/third_party/2/tornado/web.pyi jedi/third_party/typeshed/third_party/2and3/backports_abc.pyi jedi/third_party/typeshed/third_party/2and3/certifi.pyi jedi/third_party/typeshed/third_party/2and3/croniter.pyi jedi/third_party/typeshed/third_party/2and3/dateparser.pyi jedi/third_party/typeshed/third_party/2and3/decorator.pyi jedi/third_party/typeshed/third_party/2and3/first.pyi jedi/third_party/typeshed/third_party/2and3/gflags.pyi jedi/third_party/typeshed/third_party/2and3/itsdangerous.pyi jedi/third_party/typeshed/third_party/2and3/mock.pyi jedi/third_party/typeshed/third_party/2and3/mypy_extensions.pyi jedi/third_party/typeshed/third_party/2and3/polib.pyi jedi/third_party/typeshed/third_party/2and3/pycurl.pyi jedi/third_party/typeshed/third_party/2and3/pyre_extensions.pyi jedi/third_party/typeshed/third_party/2and3/singledispatch.pyi jedi/third_party/typeshed/third_party/2and3/tabulate.pyi jedi/third_party/typeshed/third_party/2and3/termcolor.pyi jedi/third_party/typeshed/third_party/2and3/toml.pyi jedi/third_party/typeshed/third_party/2and3/typing_extensions.pyi jedi/third_party/typeshed/third_party/2and3/ujson.pyi jedi/third_party/typeshed/third_party/2and3/atomicwrites/__init__.pyi jedi/third_party/typeshed/third_party/2and3/attr/__init__.pyi jedi/third_party/typeshed/third_party/2and3/attr/_version_info.pyi jedi/third_party/typeshed/third_party/2and3/attr/converters.pyi jedi/third_party/typeshed/third_party/2and3/attr/exceptions.pyi jedi/third_party/typeshed/third_party/2and3/attr/filters.pyi jedi/third_party/typeshed/third_party/2and3/attr/validators.pyi jedi/third_party/typeshed/third_party/2and3/backports/__init__.pyi jedi/third_party/typeshed/third_party/2and3/backports/ssl_match_hostname.pyi jedi/third_party/typeshed/third_party/2and3/bleach/__init__.pyi jedi/third_party/typeshed/third_party/2and3/bleach/callbacks.pyi jedi/third_party/typeshed/third_party/2and3/bleach/linkifier.pyi jedi/third_party/typeshed/third_party/2and3/bleach/sanitizer.pyi jedi/third_party/typeshed/third_party/2and3/bleach/utils.pyi jedi/third_party/typeshed/third_party/2and3/boto/__init__.pyi jedi/third_party/typeshed/third_party/2and3/boto/auth.pyi jedi/third_party/typeshed/third_party/2and3/boto/auth_handler.pyi jedi/third_party/typeshed/third_party/2and3/boto/compat.pyi jedi/third_party/typeshed/third_party/2and3/boto/connection.pyi jedi/third_party/typeshed/third_party/2and3/boto/exception.pyi jedi/third_party/typeshed/third_party/2and3/boto/plugin.pyi jedi/third_party/typeshed/third_party/2and3/boto/regioninfo.pyi jedi/third_party/typeshed/third_party/2and3/boto/utils.pyi jedi/third_party/typeshed/third_party/2and3/boto/ec2/__init__.pyi jedi/third_party/typeshed/third_party/2and3/boto/elb/__init__.pyi jedi/third_party/typeshed/third_party/2and3/boto/kms/__init__.pyi jedi/third_party/typeshed/third_party/2and3/boto/kms/exceptions.pyi jedi/third_party/typeshed/third_party/2and3/boto/kms/layer1.pyi jedi/third_party/typeshed/third_party/2and3/boto/s3/__init__.pyi jedi/third_party/typeshed/third_party/2and3/boto/s3/acl.pyi jedi/third_party/typeshed/third_party/2and3/boto/s3/bucket.pyi jedi/third_party/typeshed/third_party/2and3/boto/s3/bucketlistresultset.pyi jedi/third_party/typeshed/third_party/2and3/boto/s3/bucketlogging.pyi jedi/third_party/typeshed/third_party/2and3/boto/s3/connection.pyi jedi/third_party/typeshed/third_party/2and3/boto/s3/cors.pyi jedi/third_party/typeshed/third_party/2and3/boto/s3/deletemarker.pyi jedi/third_party/typeshed/third_party/2and3/boto/s3/key.pyi jedi/third_party/typeshed/third_party/2and3/boto/s3/keyfile.pyi jedi/third_party/typeshed/third_party/2and3/boto/s3/lifecycle.pyi jedi/third_party/typeshed/third_party/2and3/boto/s3/multidelete.pyi jedi/third_party/typeshed/third_party/2and3/boto/s3/multipart.pyi jedi/third_party/typeshed/third_party/2and3/boto/s3/prefix.pyi jedi/third_party/typeshed/third_party/2and3/boto/s3/tagging.pyi jedi/third_party/typeshed/third_party/2and3/boto/s3/user.pyi jedi/third_party/typeshed/third_party/2and3/boto/s3/website.pyi jedi/third_party/typeshed/third_party/2and3/cachetools/__init__.pyi jedi/third_party/typeshed/third_party/2and3/cachetools/abc.pyi jedi/third_party/typeshed/third_party/2and3/cachetools/cache.pyi jedi/third_party/typeshed/third_party/2and3/cachetools/decorators.pyi jedi/third_party/typeshed/third_party/2and3/cachetools/func.pyi jedi/third_party/typeshed/third_party/2and3/cachetools/lfu.pyi jedi/third_party/typeshed/third_party/2and3/cachetools/lru.pyi jedi/third_party/typeshed/third_party/2and3/cachetools/rr.pyi jedi/third_party/typeshed/third_party/2and3/cachetools/ttl.pyi jedi/third_party/typeshed/third_party/2and3/characteristic/__init__.pyi jedi/third_party/typeshed/third_party/2and3/chardet/__init__.pyi jedi/third_party/typeshed/third_party/2and3/chardet/enums.pyi jedi/third_party/typeshed/third_party/2and3/chardet/langbulgarianmodel.pyi jedi/third_party/typeshed/third_party/2and3/chardet/langcyrillicmodel.pyi jedi/third_party/typeshed/third_party/2and3/chardet/langgreekmodel.pyi jedi/third_party/typeshed/third_party/2and3/chardet/langhebrewmodel.pyi jedi/third_party/typeshed/third_party/2and3/chardet/langhungarianmodel.pyi jedi/third_party/typeshed/third_party/2and3/chardet/langthaimodel.pyi jedi/third_party/typeshed/third_party/2and3/chardet/langturkishmodel.pyi jedi/third_party/typeshed/third_party/2and3/chardet/universaldetector.pyi jedi/third_party/typeshed/third_party/2and3/chardet/version.pyi jedi/third_party/typeshed/third_party/2and3/click/__init__.pyi jedi/third_party/typeshed/third_party/2and3/click/_termui_impl.pyi jedi/third_party/typeshed/third_party/2and3/click/core.pyi jedi/third_party/typeshed/third_party/2and3/click/decorators.pyi jedi/third_party/typeshed/third_party/2and3/click/exceptions.pyi jedi/third_party/typeshed/third_party/2and3/click/formatting.pyi jedi/third_party/typeshed/third_party/2and3/click/globals.pyi jedi/third_party/typeshed/third_party/2and3/click/parser.pyi jedi/third_party/typeshed/third_party/2and3/click/termui.pyi jedi/third_party/typeshed/third_party/2and3/click/testing.pyi jedi/third_party/typeshed/third_party/2and3/click/types.pyi jedi/third_party/typeshed/third_party/2and3/click/utils.pyi jedi/third_party/typeshed/third_party/2and3/cryptography/__init__.pyi jedi/third_party/typeshed/third_party/2and3/cryptography/exceptions.pyi jedi/third_party/typeshed/third_party/2and3/cryptography/fernet.pyi jedi/third_party/typeshed/third_party/2and3/cryptography/hazmat/__init__.pyi jedi/third_party/typeshed/third_party/2and3/cryptography/hazmat/backends/__init__.pyi jedi/third_party/typeshed/third_party/2and3/cryptography/hazmat/backends/interfaces.pyi jedi/third_party/typeshed/third_party/2and3/cryptography/hazmat/bindings/__init__.pyi jedi/third_party/typeshed/third_party/2and3/cryptography/hazmat/bindings/openssl/__init__.pyi jedi/third_party/typeshed/third_party/2and3/cryptography/hazmat/bindings/openssl/binding.pyi jedi/third_party/typeshed/third_party/2and3/cryptography/hazmat/primitives/__init__.pyi jedi/third_party/typeshed/third_party/2and3/cryptography/hazmat/primitives/cmac.pyi jedi/third_party/typeshed/third_party/2and3/cryptography/hazmat/primitives/constant_time.pyi jedi/third_party/typeshed/third_party/2and3/cryptography/hazmat/primitives/hashes.pyi jedi/third_party/typeshed/third_party/2and3/cryptography/hazmat/primitives/hmac.pyi jedi/third_party/typeshed/third_party/2and3/cryptography/hazmat/primitives/keywrap.pyi jedi/third_party/typeshed/third_party/2and3/cryptography/hazmat/primitives/padding.pyi jedi/third_party/typeshed/third_party/2and3/cryptography/hazmat/primitives/poly1305.pyi jedi/third_party/typeshed/third_party/2and3/cryptography/hazmat/primitives/asymmetric/__init__.pyi jedi/third_party/typeshed/third_party/2and3/cryptography/hazmat/primitives/asymmetric/dh.pyi jedi/third_party/typeshed/third_party/2and3/cryptography/hazmat/primitives/asymmetric/dsa.pyi jedi/third_party/typeshed/third_party/2and3/cryptography/hazmat/primitives/asymmetric/ec.pyi jedi/third_party/typeshed/third_party/2and3/cryptography/hazmat/primitives/asymmetric/ed25519.pyi jedi/third_party/typeshed/third_party/2and3/cryptography/hazmat/primitives/asymmetric/ed448.pyi jedi/third_party/typeshed/third_party/2and3/cryptography/hazmat/primitives/asymmetric/padding.pyi jedi/third_party/typeshed/third_party/2and3/cryptography/hazmat/primitives/asymmetric/rsa.pyi jedi/third_party/typeshed/third_party/2and3/cryptography/hazmat/primitives/asymmetric/utils.pyi jedi/third_party/typeshed/third_party/2and3/cryptography/hazmat/primitives/asymmetric/x25519.pyi jedi/third_party/typeshed/third_party/2and3/cryptography/hazmat/primitives/asymmetric/x448.pyi jedi/third_party/typeshed/third_party/2and3/cryptography/hazmat/primitives/ciphers/__init__.pyi jedi/third_party/typeshed/third_party/2and3/cryptography/hazmat/primitives/ciphers/aead.pyi jedi/third_party/typeshed/third_party/2and3/cryptography/hazmat/primitives/ciphers/algorithms.pyi jedi/third_party/typeshed/third_party/2and3/cryptography/hazmat/primitives/ciphers/modes.pyi jedi/third_party/typeshed/third_party/2and3/cryptography/hazmat/primitives/kdf/__init__.pyi jedi/third_party/typeshed/third_party/2and3/cryptography/hazmat/primitives/kdf/concatkdf.pyi jedi/third_party/typeshed/third_party/2and3/cryptography/hazmat/primitives/kdf/hkdf.pyi jedi/third_party/typeshed/third_party/2and3/cryptography/hazmat/primitives/kdf/kbkdf.pyi jedi/third_party/typeshed/third_party/2and3/cryptography/hazmat/primitives/kdf/pbkdf2.pyi jedi/third_party/typeshed/third_party/2and3/cryptography/hazmat/primitives/kdf/scrypt.pyi jedi/third_party/typeshed/third_party/2and3/cryptography/hazmat/primitives/kdf/x963kdf.pyi jedi/third_party/typeshed/third_party/2and3/cryptography/hazmat/primitives/serialization/__init__.pyi jedi/third_party/typeshed/third_party/2and3/cryptography/hazmat/primitives/serialization/pkcs12.pyi jedi/third_party/typeshed/third_party/2and3/cryptography/hazmat/primitives/twofactor/__init__.pyi jedi/third_party/typeshed/third_party/2and3/cryptography/hazmat/primitives/twofactor/hotp.pyi jedi/third_party/typeshed/third_party/2and3/cryptography/hazmat/primitives/twofactor/totp.pyi jedi/third_party/typeshed/third_party/2and3/cryptography/x509/__init__.pyi jedi/third_party/typeshed/third_party/2and3/cryptography/x509/extensions.pyi jedi/third_party/typeshed/third_party/2and3/cryptography/x509/oid.pyi jedi/third_party/typeshed/third_party/2and3/datetimerange/__init__.pyi jedi/third_party/typeshed/third_party/2and3/dateutil/__init__.pyi jedi/third_party/typeshed/third_party/2and3/dateutil/_common.pyi jedi/third_party/typeshed/third_party/2and3/dateutil/easter.pyi jedi/third_party/typeshed/third_party/2and3/dateutil/parser.pyi jedi/third_party/typeshed/third_party/2and3/dateutil/relativedelta.pyi jedi/third_party/typeshed/third_party/2and3/dateutil/rrule.pyi jedi/third_party/typeshed/third_party/2and3/dateutil/utils.pyi jedi/third_party/typeshed/third_party/2and3/dateutil/tz/__init__.pyi jedi/third_party/typeshed/third_party/2and3/dateutil/tz/_common.pyi jedi/third_party/typeshed/third_party/2and3/dateutil/tz/tz.pyi jedi/third_party/typeshed/third_party/2and3/deprecated/__init__.pyi jedi/third_party/typeshed/third_party/2and3/deprecated/classic.pyi jedi/third_party/typeshed/third_party/2and3/deprecated/sphinx.pyi jedi/third_party/typeshed/third_party/2and3/emoji/__init__.pyi jedi/third_party/typeshed/third_party/2and3/emoji/core.pyi jedi/third_party/typeshed/third_party/2and3/emoji/unicode_codes.pyi jedi/third_party/typeshed/third_party/2and3/flask/__init__.pyi jedi/third_party/typeshed/third_party/2and3/flask/app.pyi jedi/third_party/typeshed/third_party/2and3/flask/blueprints.pyi jedi/third_party/typeshed/third_party/2and3/flask/cli.pyi jedi/third_party/typeshed/third_party/2and3/flask/config.pyi jedi/third_party/typeshed/third_party/2and3/flask/ctx.pyi jedi/third_party/typeshed/third_party/2and3/flask/debughelpers.pyi jedi/third_party/typeshed/third_party/2and3/flask/globals.pyi jedi/third_party/typeshed/third_party/2and3/flask/helpers.pyi jedi/third_party/typeshed/third_party/2and3/flask/logging.pyi jedi/third_party/typeshed/third_party/2and3/flask/sessions.pyi jedi/third_party/typeshed/third_party/2and3/flask/signals.pyi jedi/third_party/typeshed/third_party/2and3/flask/templating.pyi jedi/third_party/typeshed/third_party/2and3/flask/testing.pyi jedi/third_party/typeshed/third_party/2and3/flask/views.pyi jedi/third_party/typeshed/third_party/2and3/flask/wrappers.pyi jedi/third_party/typeshed/third_party/2and3/flask/json/__init__.pyi jedi/third_party/typeshed/third_party/2and3/flask/json/tag.pyi jedi/third_party/typeshed/third_party/2and3/geoip2/__init__.pyi jedi/third_party/typeshed/third_party/2and3/geoip2/database.pyi jedi/third_party/typeshed/third_party/2and3/geoip2/errors.pyi jedi/third_party/typeshed/third_party/2and3/geoip2/mixins.pyi jedi/third_party/typeshed/third_party/2and3/geoip2/models.pyi jedi/third_party/typeshed/third_party/2and3/geoip2/records.pyi jedi/third_party/typeshed/third_party/2and3/google/__init__.pyi jedi/third_party/typeshed/third_party/2and3/google/protobuf/__init__.pyi jedi/third_party/typeshed/third_party/2and3/google/protobuf/any_pb2.pyi jedi/third_party/typeshed/third_party/2and3/google/protobuf/api_pb2.pyi jedi/third_party/typeshed/third_party/2and3/google/protobuf/descriptor.pyi jedi/third_party/typeshed/third_party/2and3/google/protobuf/descriptor_pb2.pyi jedi/third_party/typeshed/third_party/2and3/google/protobuf/descriptor_pool.pyi jedi/third_party/typeshed/third_party/2and3/google/protobuf/duration_pb2.pyi jedi/third_party/typeshed/third_party/2and3/google/protobuf/empty_pb2.pyi jedi/third_party/typeshed/third_party/2and3/google/protobuf/field_mask_pb2.pyi jedi/third_party/typeshed/third_party/2and3/google/protobuf/json_format.pyi jedi/third_party/typeshed/third_party/2and3/google/protobuf/message.pyi jedi/third_party/typeshed/third_party/2and3/google/protobuf/message_factory.pyi jedi/third_party/typeshed/third_party/2and3/google/protobuf/reflection.pyi jedi/third_party/typeshed/third_party/2and3/google/protobuf/service.pyi jedi/third_party/typeshed/third_party/2and3/google/protobuf/source_context_pb2.pyi jedi/third_party/typeshed/third_party/2and3/google/protobuf/struct_pb2.pyi jedi/third_party/typeshed/third_party/2and3/google/protobuf/symbol_database.pyi jedi/third_party/typeshed/third_party/2and3/google/protobuf/timestamp_pb2.pyi jedi/third_party/typeshed/third_party/2and3/google/protobuf/type_pb2.pyi jedi/third_party/typeshed/third_party/2and3/google/protobuf/wrappers_pb2.pyi jedi/third_party/typeshed/third_party/2and3/google/protobuf/compiler/__init__.pyi jedi/third_party/typeshed/third_party/2and3/google/protobuf/compiler/plugin_pb2.pyi jedi/third_party/typeshed/third_party/2and3/google/protobuf/internal/__init__.pyi jedi/third_party/typeshed/third_party/2and3/google/protobuf/internal/containers.pyi jedi/third_party/typeshed/third_party/2and3/google/protobuf/internal/decoder.pyi jedi/third_party/typeshed/third_party/2and3/google/protobuf/internal/encoder.pyi jedi/third_party/typeshed/third_party/2and3/google/protobuf/internal/enum_type_wrapper.pyi jedi/third_party/typeshed/third_party/2and3/google/protobuf/internal/extension_dict.pyi jedi/third_party/typeshed/third_party/2and3/google/protobuf/internal/message_listener.pyi jedi/third_party/typeshed/third_party/2and3/google/protobuf/internal/python_message.pyi jedi/third_party/typeshed/third_party/2and3/google/protobuf/internal/well_known_types.pyi jedi/third_party/typeshed/third_party/2and3/google/protobuf/internal/wire_format.pyi jedi/third_party/typeshed/third_party/2and3/google/protobuf/util/__init__.pyi jedi/third_party/typeshed/third_party/2and3/jinja2/__init__.pyi jedi/third_party/typeshed/third_party/2and3/jinja2/_compat.pyi jedi/third_party/typeshed/third_party/2and3/jinja2/_stringdefs.pyi jedi/third_party/typeshed/third_party/2and3/jinja2/bccache.pyi jedi/third_party/typeshed/third_party/2and3/jinja2/compiler.pyi jedi/third_party/typeshed/third_party/2and3/jinja2/constants.pyi jedi/third_party/typeshed/third_party/2and3/jinja2/debug.pyi jedi/third_party/typeshed/third_party/2and3/jinja2/defaults.pyi jedi/third_party/typeshed/third_party/2and3/jinja2/environment.pyi jedi/third_party/typeshed/third_party/2and3/jinja2/exceptions.pyi jedi/third_party/typeshed/third_party/2and3/jinja2/ext.pyi jedi/third_party/typeshed/third_party/2and3/jinja2/filters.pyi jedi/third_party/typeshed/third_party/2and3/jinja2/lexer.pyi jedi/third_party/typeshed/third_party/2and3/jinja2/loaders.pyi jedi/third_party/typeshed/third_party/2and3/jinja2/meta.pyi jedi/third_party/typeshed/third_party/2and3/jinja2/nodes.pyi jedi/third_party/typeshed/third_party/2and3/jinja2/optimizer.pyi jedi/third_party/typeshed/third_party/2and3/jinja2/parser.pyi jedi/third_party/typeshed/third_party/2and3/jinja2/runtime.pyi jedi/third_party/typeshed/third_party/2and3/jinja2/sandbox.pyi jedi/third_party/typeshed/third_party/2and3/jinja2/tests.pyi jedi/third_party/typeshed/third_party/2and3/jinja2/utils.pyi jedi/third_party/typeshed/third_party/2and3/jinja2/visitor.pyi jedi/third_party/typeshed/third_party/2and3/markdown/__init__.pyi jedi/third_party/typeshed/third_party/2and3/markdown/__meta__.pyi jedi/third_party/typeshed/third_party/2and3/markdown/blockparser.pyi jedi/third_party/typeshed/third_party/2and3/markdown/blockprocessors.pyi jedi/third_party/typeshed/third_party/2and3/markdown/core.pyi jedi/third_party/typeshed/third_party/2and3/markdown/inlinepatterns.pyi jedi/third_party/typeshed/third_party/2and3/markdown/pep562.pyi jedi/third_party/typeshed/third_party/2and3/markdown/postprocessors.pyi jedi/third_party/typeshed/third_party/2and3/markdown/preprocessors.pyi jedi/third_party/typeshed/third_party/2and3/markdown/serializers.pyi jedi/third_party/typeshed/third_party/2and3/markdown/treeprocessors.pyi jedi/third_party/typeshed/third_party/2and3/markdown/util.pyi jedi/third_party/typeshed/third_party/2and3/markdown/extensions/__init__.pyi jedi/third_party/typeshed/third_party/2and3/markdown/extensions/abbr.pyi jedi/third_party/typeshed/third_party/2and3/markdown/extensions/admonition.pyi jedi/third_party/typeshed/third_party/2and3/markdown/extensions/attr_list.pyi jedi/third_party/typeshed/third_party/2and3/markdown/extensions/codehilite.pyi jedi/third_party/typeshed/third_party/2and3/markdown/extensions/def_list.pyi jedi/third_party/typeshed/third_party/2and3/markdown/extensions/extra.pyi jedi/third_party/typeshed/third_party/2and3/markdown/extensions/fenced_code.pyi jedi/third_party/typeshed/third_party/2and3/markdown/extensions/footnotes.pyi jedi/third_party/typeshed/third_party/2and3/markdown/extensions/legacy_attrs.pyi jedi/third_party/typeshed/third_party/2and3/markdown/extensions/legacy_em.pyi jedi/third_party/typeshed/third_party/2and3/markdown/extensions/md_in_html.pyi jedi/third_party/typeshed/third_party/2and3/markdown/extensions/meta.pyi jedi/third_party/typeshed/third_party/2and3/markdown/extensions/nl2br.pyi jedi/third_party/typeshed/third_party/2and3/markdown/extensions/sane_lists.pyi jedi/third_party/typeshed/third_party/2and3/markdown/extensions/smarty.pyi jedi/third_party/typeshed/third_party/2and3/markdown/extensions/tables.pyi jedi/third_party/typeshed/third_party/2and3/markdown/extensions/toc.pyi jedi/third_party/typeshed/third_party/2and3/markdown/extensions/wikilinks.pyi jedi/third_party/typeshed/third_party/2and3/markupsafe/__init__.pyi jedi/third_party/typeshed/third_party/2and3/markupsafe/_compat.pyi jedi/third_party/typeshed/third_party/2and3/markupsafe/_constants.pyi jedi/third_party/typeshed/third_party/2and3/markupsafe/_native.pyi jedi/third_party/typeshed/third_party/2and3/markupsafe/_speedups.pyi jedi/third_party/typeshed/third_party/2and3/maxminddb/__init__.pyi jedi/third_party/typeshed/third_party/2and3/maxminddb/compat.pyi jedi/third_party/typeshed/third_party/2and3/maxminddb/const.pyi jedi/third_party/typeshed/third_party/2and3/maxminddb/decoder.pyi jedi/third_party/typeshed/third_party/2and3/maxminddb/errors.pyi jedi/third_party/typeshed/third_party/2and3/maxminddb/extension.pyi jedi/third_party/typeshed/third_party/2and3/maxminddb/reader.pyi jedi/third_party/typeshed/third_party/2and3/nmap/__init__.pyi jedi/third_party/typeshed/third_party/2and3/nmap/nmap.pyi jedi/third_party/typeshed/third_party/2and3/paramiko/__init__.pyi jedi/third_party/typeshed/third_party/2and3/paramiko/_version.pyi jedi/third_party/typeshed/third_party/2and3/paramiko/_winapi.pyi jedi/third_party/typeshed/third_party/2and3/paramiko/agent.pyi jedi/third_party/typeshed/third_party/2and3/paramiko/auth_handler.pyi jedi/third_party/typeshed/third_party/2and3/paramiko/ber.pyi jedi/third_party/typeshed/third_party/2and3/paramiko/buffered_pipe.pyi jedi/third_party/typeshed/third_party/2and3/paramiko/channel.pyi jedi/third_party/typeshed/third_party/2and3/paramiko/client.pyi jedi/third_party/typeshed/third_party/2and3/paramiko/common.pyi jedi/third_party/typeshed/third_party/2and3/paramiko/compress.pyi jedi/third_party/typeshed/third_party/2and3/paramiko/config.pyi jedi/third_party/typeshed/third_party/2and3/paramiko/dsskey.pyi jedi/third_party/typeshed/third_party/2and3/paramiko/ecdsakey.pyi jedi/third_party/typeshed/third_party/2and3/paramiko/ed25519key.pyi jedi/third_party/typeshed/third_party/2and3/paramiko/file.pyi jedi/third_party/typeshed/third_party/2and3/paramiko/hostkeys.pyi jedi/third_party/typeshed/third_party/2and3/paramiko/kex_curve25519.pyi jedi/third_party/typeshed/third_party/2and3/paramiko/kex_ecdh_nist.pyi jedi/third_party/typeshed/third_party/2and3/paramiko/kex_gex.pyi jedi/third_party/typeshed/third_party/2and3/paramiko/kex_group1.pyi jedi/third_party/typeshed/third_party/2and3/paramiko/kex_group14.pyi jedi/third_party/typeshed/third_party/2and3/paramiko/kex_group16.pyi jedi/third_party/typeshed/third_party/2and3/paramiko/kex_gss.pyi jedi/third_party/typeshed/third_party/2and3/paramiko/message.pyi jedi/third_party/typeshed/third_party/2and3/paramiko/packet.pyi jedi/third_party/typeshed/third_party/2and3/paramiko/pipe.pyi jedi/third_party/typeshed/third_party/2and3/paramiko/pkey.pyi jedi/third_party/typeshed/third_party/2and3/paramiko/primes.pyi jedi/third_party/typeshed/third_party/2and3/paramiko/proxy.pyi jedi/third_party/typeshed/third_party/2and3/paramiko/py3compat.pyi jedi/third_party/typeshed/third_party/2and3/paramiko/rsakey.pyi jedi/third_party/typeshed/third_party/2and3/paramiko/server.pyi jedi/third_party/typeshed/third_party/2and3/paramiko/sftp.pyi jedi/third_party/typeshed/third_party/2and3/paramiko/sftp_attr.pyi jedi/third_party/typeshed/third_party/2and3/paramiko/sftp_client.pyi jedi/third_party/typeshed/third_party/2and3/paramiko/sftp_file.pyi jedi/third_party/typeshed/third_party/2and3/paramiko/sftp_handle.pyi jedi/third_party/typeshed/third_party/2and3/paramiko/sftp_server.pyi jedi/third_party/typeshed/third_party/2and3/paramiko/sftp_si.pyi jedi/third_party/typeshed/third_party/2and3/paramiko/ssh_exception.pyi jedi/third_party/typeshed/third_party/2and3/paramiko/ssh_gss.pyi jedi/third_party/typeshed/third_party/2and3/paramiko/transport.pyi jedi/third_party/typeshed/third_party/2and3/paramiko/util.pyi jedi/third_party/typeshed/third_party/2and3/paramiko/win_pageant.pyi jedi/third_party/typeshed/third_party/2and3/pyVmomi/__init__.pyi jedi/third_party/typeshed/third_party/2and3/pyVmomi/vim/__init__.pyi jedi/third_party/typeshed/third_party/2and3/pyVmomi/vim/event.pyi jedi/third_party/typeshed/third_party/2and3/pyVmomi/vim/fault.pyi jedi/third_party/typeshed/third_party/2and3/pyVmomi/vim/option.pyi jedi/third_party/typeshed/third_party/2and3/pyVmomi/vim/view.pyi jedi/third_party/typeshed/third_party/2and3/pyVmomi/vmodl/__init__.pyi jedi/third_party/typeshed/third_party/2and3/pyVmomi/vmodl/fault.pyi jedi/third_party/typeshed/third_party/2and3/pyVmomi/vmodl/query.pyi jedi/third_party/typeshed/third_party/2and3/pymysql/__init__.pyi jedi/third_party/typeshed/third_party/2and3/pymysql/charset.pyi jedi/third_party/typeshed/third_party/2and3/pymysql/connections.pyi jedi/third_party/typeshed/third_party/2and3/pymysql/converters.pyi jedi/third_party/typeshed/third_party/2and3/pymysql/cursors.pyi jedi/third_party/typeshed/third_party/2and3/pymysql/err.pyi jedi/third_party/typeshed/third_party/2and3/pymysql/times.pyi jedi/third_party/typeshed/third_party/2and3/pymysql/util.pyi jedi/third_party/typeshed/third_party/2and3/pymysql/constants/CLIENT.pyi jedi/third_party/typeshed/third_party/2and3/pymysql/constants/COMMAND.pyi jedi/third_party/typeshed/third_party/2and3/pymysql/constants/ER.pyi jedi/third_party/typeshed/third_party/2and3/pymysql/constants/FIELD_TYPE.pyi jedi/third_party/typeshed/third_party/2and3/pymysql/constants/FLAG.pyi jedi/third_party/typeshed/third_party/2and3/pymysql/constants/SERVER_STATUS.pyi jedi/third_party/typeshed/third_party/2and3/pymysql/constants/__init__.pyi jedi/third_party/typeshed/third_party/2and3/pynamodb/__init__.pyi jedi/third_party/typeshed/third_party/2and3/pynamodb/attributes.pyi jedi/third_party/typeshed/third_party/2and3/pynamodb/constants.pyi jedi/third_party/typeshed/third_party/2and3/pynamodb/exceptions.pyi jedi/third_party/typeshed/third_party/2and3/pynamodb/indexes.pyi jedi/third_party/typeshed/third_party/2and3/pynamodb/models.pyi jedi/third_party/typeshed/third_party/2and3/pynamodb/settings.pyi jedi/third_party/typeshed/third_party/2and3/pynamodb/throttle.pyi jedi/third_party/typeshed/third_party/2and3/pynamodb/types.pyi jedi/third_party/typeshed/third_party/2and3/pynamodb/connection/__init__.pyi jedi/third_party/typeshed/third_party/2and3/pynamodb/connection/base.pyi jedi/third_party/typeshed/third_party/2and3/pynamodb/connection/table.pyi jedi/third_party/typeshed/third_party/2and3/pynamodb/connection/util.pyi jedi/third_party/typeshed/third_party/2and3/pytz/__init__.pyi jedi/third_party/typeshed/third_party/2and3/redis/__init__.pyi jedi/third_party/typeshed/third_party/2and3/redis/client.pyi jedi/third_party/typeshed/third_party/2and3/redis/connection.pyi jedi/third_party/typeshed/third_party/2and3/redis/exceptions.pyi jedi/third_party/typeshed/third_party/2and3/redis/utils.pyi jedi/third_party/typeshed/third_party/2and3/requests/__init__.pyi jedi/third_party/typeshed/third_party/2and3/requests/adapters.pyi jedi/third_party/typeshed/third_party/2and3/requests/api.pyi jedi/third_party/typeshed/third_party/2and3/requests/auth.pyi jedi/third_party/typeshed/third_party/2and3/requests/compat.pyi jedi/third_party/typeshed/third_party/2and3/requests/cookies.pyi jedi/third_party/typeshed/third_party/2and3/requests/exceptions.pyi jedi/third_party/typeshed/third_party/2and3/requests/hooks.pyi jedi/third_party/typeshed/third_party/2and3/requests/models.pyi jedi/third_party/typeshed/third_party/2and3/requests/sessions.pyi jedi/third_party/typeshed/third_party/2and3/requests/status_codes.pyi jedi/third_party/typeshed/third_party/2and3/requests/structures.pyi jedi/third_party/typeshed/third_party/2and3/requests/utils.pyi jedi/third_party/typeshed/third_party/2and3/requests/packages/__init__.pyi jedi/third_party/typeshed/third_party/2and3/requests/packages/urllib3/__init__.pyi jedi/third_party/typeshed/third_party/2and3/requests/packages/urllib3/_collections.pyi jedi/third_party/typeshed/third_party/2and3/requests/packages/urllib3/connection.pyi jedi/third_party/typeshed/third_party/2and3/requests/packages/urllib3/connectionpool.pyi jedi/third_party/typeshed/third_party/2and3/requests/packages/urllib3/exceptions.pyi jedi/third_party/typeshed/third_party/2and3/requests/packages/urllib3/fields.pyi jedi/third_party/typeshed/third_party/2and3/requests/packages/urllib3/filepost.pyi jedi/third_party/typeshed/third_party/2and3/requests/packages/urllib3/poolmanager.pyi jedi/third_party/typeshed/third_party/2and3/requests/packages/urllib3/request.pyi jedi/third_party/typeshed/third_party/2and3/requests/packages/urllib3/response.pyi jedi/third_party/typeshed/third_party/2and3/requests/packages/urllib3/contrib/__init__.pyi jedi/third_party/typeshed/third_party/2and3/requests/packages/urllib3/packages/__init__.pyi jedi/third_party/typeshed/third_party/2and3/requests/packages/urllib3/packages/ssl_match_hostname/__init__.pyi jedi/third_party/typeshed/third_party/2and3/requests/packages/urllib3/packages/ssl_match_hostname/_implementation.pyi jedi/third_party/typeshed/third_party/2and3/requests/packages/urllib3/util/__init__.pyi jedi/third_party/typeshed/third_party/2and3/requests/packages/urllib3/util/connection.pyi jedi/third_party/typeshed/third_party/2and3/requests/packages/urllib3/util/request.pyi jedi/third_party/typeshed/third_party/2and3/requests/packages/urllib3/util/response.pyi jedi/third_party/typeshed/third_party/2and3/requests/packages/urllib3/util/retry.pyi jedi/third_party/typeshed/third_party/2and3/requests/packages/urllib3/util/ssl_.pyi jedi/third_party/typeshed/third_party/2and3/requests/packages/urllib3/util/timeout.pyi jedi/third_party/typeshed/third_party/2and3/requests/packages/urllib3/util/url.pyi jedi/third_party/typeshed/third_party/2and3/retry/__init__.pyi jedi/third_party/typeshed/third_party/2and3/retry/api.pyi jedi/third_party/typeshed/third_party/2and3/simplejson/__init__.pyi jedi/third_party/typeshed/third_party/2and3/simplejson/decoder.pyi jedi/third_party/typeshed/third_party/2and3/simplejson/encoder.pyi jedi/third_party/typeshed/third_party/2and3/simplejson/scanner.pyi jedi/third_party/typeshed/third_party/2and3/slugify/__init__.pyi jedi/third_party/typeshed/third_party/2and3/slugify/slugify.pyi jedi/third_party/typeshed/third_party/2and3/slugify/special.pyi jedi/third_party/typeshed/third_party/2and3/tzlocal/__init__.pyi jedi/third_party/typeshed/third_party/2and3/werkzeug/__init__.pyi jedi/third_party/typeshed/third_party/2and3/werkzeug/_compat.pyi jedi/third_party/typeshed/third_party/2and3/werkzeug/_internal.pyi jedi/third_party/typeshed/third_party/2and3/werkzeug/_reloader.pyi jedi/third_party/typeshed/third_party/2and3/werkzeug/datastructures.pyi jedi/third_party/typeshed/third_party/2and3/werkzeug/exceptions.pyi jedi/third_party/typeshed/third_party/2and3/werkzeug/filesystem.pyi jedi/third_party/typeshed/third_party/2and3/werkzeug/formparser.pyi jedi/third_party/typeshed/third_party/2and3/werkzeug/http.pyi jedi/third_party/typeshed/third_party/2and3/werkzeug/local.pyi jedi/third_party/typeshed/third_party/2and3/werkzeug/posixemulation.pyi jedi/third_party/typeshed/third_party/2and3/werkzeug/routing.pyi jedi/third_party/typeshed/third_party/2and3/werkzeug/script.pyi jedi/third_party/typeshed/third_party/2and3/werkzeug/security.pyi jedi/third_party/typeshed/third_party/2and3/werkzeug/serving.pyi jedi/third_party/typeshed/third_party/2and3/werkzeug/test.pyi jedi/third_party/typeshed/third_party/2and3/werkzeug/testapp.pyi jedi/third_party/typeshed/third_party/2and3/werkzeug/urls.pyi jedi/third_party/typeshed/third_party/2and3/werkzeug/useragents.pyi jedi/third_party/typeshed/third_party/2and3/werkzeug/utils.pyi jedi/third_party/typeshed/third_party/2and3/werkzeug/wrappers.pyi jedi/third_party/typeshed/third_party/2and3/werkzeug/wsgi.pyi jedi/third_party/typeshed/third_party/2and3/werkzeug/contrib/__init__.pyi jedi/third_party/typeshed/third_party/2and3/werkzeug/contrib/atom.pyi jedi/third_party/typeshed/third_party/2and3/werkzeug/contrib/cache.pyi jedi/third_party/typeshed/third_party/2and3/werkzeug/contrib/fixers.pyi jedi/third_party/typeshed/third_party/2and3/werkzeug/contrib/iterio.pyi jedi/third_party/typeshed/third_party/2and3/werkzeug/contrib/jsrouting.pyi jedi/third_party/typeshed/third_party/2and3/werkzeug/contrib/limiter.pyi jedi/third_party/typeshed/third_party/2and3/werkzeug/contrib/lint.pyi jedi/third_party/typeshed/third_party/2and3/werkzeug/contrib/profiler.pyi jedi/third_party/typeshed/third_party/2and3/werkzeug/contrib/securecookie.pyi jedi/third_party/typeshed/third_party/2and3/werkzeug/contrib/sessions.pyi jedi/third_party/typeshed/third_party/2and3/werkzeug/contrib/testtools.pyi jedi/third_party/typeshed/third_party/2and3/werkzeug/contrib/wrappers.pyi jedi/third_party/typeshed/third_party/2and3/werkzeug/debug/__init__.pyi jedi/third_party/typeshed/third_party/2and3/werkzeug/debug/console.pyi jedi/third_party/typeshed/third_party/2and3/werkzeug/debug/repr.pyi jedi/third_party/typeshed/third_party/2and3/werkzeug/debug/tbtools.pyi jedi/third_party/typeshed/third_party/2and3/werkzeug/middleware/__init__.pyi jedi/third_party/typeshed/third_party/2and3/werkzeug/middleware/dispatcher.pyi jedi/third_party/typeshed/third_party/2and3/werkzeug/middleware/http_proxy.pyi jedi/third_party/typeshed/third_party/2and3/werkzeug/middleware/lint.pyi jedi/third_party/typeshed/third_party/2and3/werkzeug/middleware/profiler.pyi jedi/third_party/typeshed/third_party/2and3/werkzeug/middleware/proxy_fix.pyi jedi/third_party/typeshed/third_party/2and3/werkzeug/middleware/shared_data.pyi jedi/third_party/typeshed/third_party/2and3/yaml/__init__.pyi jedi/third_party/typeshed/third_party/2and3/yaml/composer.pyi jedi/third_party/typeshed/third_party/2and3/yaml/constructor.pyi jedi/third_party/typeshed/third_party/2and3/yaml/cyaml.pyi jedi/third_party/typeshed/third_party/2and3/yaml/dumper.pyi jedi/third_party/typeshed/third_party/2and3/yaml/emitter.pyi jedi/third_party/typeshed/third_party/2and3/yaml/error.pyi jedi/third_party/typeshed/third_party/2and3/yaml/events.pyi jedi/third_party/typeshed/third_party/2and3/yaml/loader.pyi jedi/third_party/typeshed/third_party/2and3/yaml/nodes.pyi jedi/third_party/typeshed/third_party/2and3/yaml/parser.pyi jedi/third_party/typeshed/third_party/2and3/yaml/reader.pyi jedi/third_party/typeshed/third_party/2and3/yaml/representer.pyi jedi/third_party/typeshed/third_party/2and3/yaml/resolver.pyi jedi/third_party/typeshed/third_party/2and3/yaml/scanner.pyi jedi/third_party/typeshed/third_party/2and3/yaml/serializer.pyi jedi/third_party/typeshed/third_party/2and3/yaml/tokens.pyi jedi/third_party/typeshed/third_party/3/contextvars.pyi jedi/third_party/typeshed/third_party/3/dataclasses.pyi jedi/third_party/typeshed/third_party/3/frozendict.pyi jedi/third_party/typeshed/third_party/3/orjson.pyi jedi/third_party/typeshed/third_party/3/aiofiles/__init__.pyi jedi/third_party/typeshed/third_party/3/aiofiles/base.pyi jedi/third_party/typeshed/third_party/3/aiofiles/os.pyi jedi/third_party/typeshed/third_party/3/aiofiles/threadpool/__init__.pyi jedi/third_party/typeshed/third_party/3/aiofiles/threadpool/binary.pyi jedi/third_party/typeshed/third_party/3/aiofiles/threadpool/text.pyi jedi/third_party/typeshed/third_party/3/docutils/__init__.pyi jedi/third_party/typeshed/third_party/3/docutils/examples.pyi jedi/third_party/typeshed/third_party/3/docutils/nodes.pyi jedi/third_party/typeshed/third_party/3/docutils/parsers/__init__.pyi jedi/third_party/typeshed/third_party/3/docutils/parsers/rst/__init__.pyi jedi/third_party/typeshed/third_party/3/docutils/parsers/rst/nodes.pyi jedi/third_party/typeshed/third_party/3/docutils/parsers/rst/roles.pyi jedi/third_party/typeshed/third_party/3/docutils/parsers/rst/states.pyi jedi/third_party/typeshed/third_party/3/filelock/__init__.pyi jedi/third_party/typeshed/third_party/3/freezegun/__init__.pyi jedi/third_party/typeshed/third_party/3/freezegun/api.pyi jedi/third_party/typeshed/third_party/3/jwt/__init__.pyi jedi/third_party/typeshed/third_party/3/jwt/algorithms.pyi jedi/third_party/typeshed/third_party/3/jwt/contrib/__init__.pyi jedi/third_party/typeshed/third_party/3/jwt/contrib/algorithms/__init__.pyi jedi/third_party/typeshed/third_party/3/jwt/contrib/algorithms/py_ecdsa.pyi jedi/third_party/typeshed/third_party/3/jwt/contrib/algorithms/pycrypto.pyi jedi/third_party/typeshed/third_party/3/pkg_resources/__init__.pyi jedi/third_party/typeshed/third_party/3/pkg_resources/py31compat.pyi jedi/third_party/typeshed/third_party/3/pyrfc3339/__init__.pyi jedi/third_party/typeshed/third_party/3/pyrfc3339/generator.pyi jedi/third_party/typeshed/third_party/3/pyrfc3339/parser.pyi jedi/third_party/typeshed/third_party/3/pyrfc3339/utils.pyi jedi/third_party/typeshed/third_party/3/six/__init__.pyi jedi/third_party/typeshed/third_party/3/six/moves/BaseHTTPServer.pyi jedi/third_party/typeshed/third_party/3/six/moves/CGIHTTPServer.pyi jedi/third_party/typeshed/third_party/3/six/moves/SimpleHTTPServer.pyi jedi/third_party/typeshed/third_party/3/six/moves/__init__.pyi jedi/third_party/typeshed/third_party/3/six/moves/_dummy_thread.pyi jedi/third_party/typeshed/third_party/3/six/moves/_thread.pyi jedi/third_party/typeshed/third_party/3/six/moves/builtins.pyi jedi/third_party/typeshed/third_party/3/six/moves/cPickle.pyi jedi/third_party/typeshed/third_party/3/six/moves/collections_abc.pyi jedi/third_party/typeshed/third_party/3/six/moves/configparser.pyi jedi/third_party/typeshed/third_party/3/six/moves/email_mime_base.pyi jedi/third_party/typeshed/third_party/3/six/moves/email_mime_multipart.pyi jedi/third_party/typeshed/third_party/3/six/moves/email_mime_nonmultipart.pyi jedi/third_party/typeshed/third_party/3/six/moves/email_mime_text.pyi jedi/third_party/typeshed/third_party/3/six/moves/html_entities.pyi jedi/third_party/typeshed/third_party/3/six/moves/html_parser.pyi jedi/third_party/typeshed/third_party/3/six/moves/http_client.pyi jedi/third_party/typeshed/third_party/3/six/moves/http_cookiejar.pyi jedi/third_party/typeshed/third_party/3/six/moves/http_cookies.pyi jedi/third_party/typeshed/third_party/3/six/moves/queue.pyi jedi/third_party/typeshed/third_party/3/six/moves/reprlib.pyi jedi/third_party/typeshed/third_party/3/six/moves/socketserver.pyi jedi/third_party/typeshed/third_party/3/six/moves/tkinter.pyi jedi/third_party/typeshed/third_party/3/six/moves/tkinter_commondialog.pyi jedi/third_party/typeshed/third_party/3/six/moves/tkinter_constants.pyi jedi/third_party/typeshed/third_party/3/six/moves/tkinter_dialog.pyi jedi/third_party/typeshed/third_party/3/six/moves/tkinter_filedialog.pyi jedi/third_party/typeshed/third_party/3/six/moves/tkinter_tkfiledialog.pyi jedi/third_party/typeshed/third_party/3/six/moves/tkinter_ttk.pyi jedi/third_party/typeshed/third_party/3/six/moves/urllib_error.pyi jedi/third_party/typeshed/third_party/3/six/moves/urllib_parse.pyi jedi/third_party/typeshed/third_party/3/six/moves/urllib_request.pyi jedi/third_party/typeshed/third_party/3/six/moves/urllib_response.pyi jedi/third_party/typeshed/third_party/3/six/moves/urllib_robotparser.pyi jedi/third_party/typeshed/third_party/3/six/moves/urllib/__init__.pyi jedi/third_party/typeshed/third_party/3/six/moves/urllib/error.pyi jedi/third_party/typeshed/third_party/3/six/moves/urllib/parse.pyi jedi/third_party/typeshed/third_party/3/six/moves/urllib/request.pyi jedi/third_party/typeshed/third_party/3/six/moves/urllib/response.pyi jedi/third_party/typeshed/third_party/3/six/moves/urllib/robotparser.pyi jedi/third_party/typeshed/third_party/3/typed_ast/__init__.pyi jedi/third_party/typeshed/third_party/3/typed_ast/ast27.pyi jedi/third_party/typeshed/third_party/3/typed_ast/ast3.pyi jedi/third_party/typeshed/third_party/3/typed_ast/conversions.pyi jedi/third_party/typeshed/third_party/3/waitress/__init__.pyi jedi/third_party/typeshed/third_party/3/waitress/adjustments.pyi jedi/third_party/typeshed/third_party/3/waitress/buffers.pyi jedi/third_party/typeshed/third_party/3/waitress/channel.pyi jedi/third_party/typeshed/third_party/3/waitress/compat.pyi jedi/third_party/typeshed/third_party/3/waitress/parser.pyi jedi/third_party/typeshed/third_party/3/waitress/proxy_headers.pyi jedi/third_party/typeshed/third_party/3/waitress/receiver.pyi jedi/third_party/typeshed/third_party/3/waitress/rfc7230.pyi jedi/third_party/typeshed/third_party/3/waitress/runner.pyi jedi/third_party/typeshed/third_party/3/waitress/server.pyi jedi/third_party/typeshed/third_party/3/waitress/task.pyi jedi/third_party/typeshed/third_party/3/waitress/trigger.pyi jedi/third_party/typeshed/third_party/3/waitress/utilities.pyi jedi/third_party/typeshed/third_party/3/waitress/wasyncore.pyi test/__init__.py test/conftest.py test/helpers.py test/refactor.py test/run.py test/test_cache.py test/test_debug.py test/test_file_io.py test/test_integration.py test/test_settings.py test/test_utils.py test/completion/__init__.py test/completion/arrays.py test/completion/async_.py test/completion/basic.py test/completion/classes.py test/completion/completion.py test/completion/complex.py test/completion/comprehensions.py test/completion/conftest.py test/completion/context.py test/completion/decorators.py test/completion/descriptors.py test/completion/django.py test/completion/docstring.py test/completion/dynamic_arrays.py test/completion/dynamic_params.py test/completion/flow_analysis.py test/completion/fstring.py test/completion/functions.py test/completion/generators.py test/completion/goto.py test/completion/imports.py test/completion/inheritance.py test/completion/invalid.py test/completion/isinstance.py test/completion/keywords.py test/completion/lambdas.py test/completion/named_expression.py test/completion/named_param.py test/completion/ns_path.py test/completion/on_import.py test/completion/ordering.py test/completion/parser.py test/completion/pep0484_basic.py test/completion/pep0484_comments.py test/completion/pep0484_decorators.py test/completion/pep0484_generic_mismatches.py test/completion/pep0484_generic_parameters.py test/completion/pep0484_generic_passthroughs.py test/completion/pep0484_overload.py test/completion/pep0484_typing.py test/completion/pep0526_variables.py test/completion/pep0593_annotations.py test/completion/pep0604.py test/completion/positional_only_params.py test/completion/precedence.py test/completion/pytest.py test/completion/recursion.py test/completion/stdlib.py test/completion/stubs.py test/completion/sys_path.py test/completion/types.py test/completion/usages.py test/completion/import_tree/__init__.py test/completion/import_tree/classes.py test/completion/import_tree/flow_import.py test/completion/import_tree/globals.py test/completion/import_tree/invisible_pkg.py test/completion/import_tree/mod1.py test/completion/import_tree/mod2.py test/completion/import_tree/random.py test/completion/import_tree/recurse_class1.py test/completion/import_tree/recurse_class2.py test/completion/import_tree/references.py test/completion/import_tree/rename1.py test/completion/import_tree/rename2.py test/completion/import_tree/pkg/__init__.py test/completion/import_tree/pkg/base.py test/completion/import_tree/pkg/mod1.py test/completion/namespace1/pkg1/pkg2/mod1.py test/completion/namespace2/pkg1/pkg2/mod2.py test/completion/stub_folder/stub_only.pyi test/completion/stub_folder/with_stub.py test/completion/stub_folder/with_stub.pyi test/completion/stub_folder/stub_only_folder/__init__.pyi test/completion/stub_folder/stub_only_folder/nested_stub_only.pyi test/completion/stub_folder/stub_only_folder/nested_with_stub.py test/completion/stub_folder/stub_only_folder/nested_with_stub.pyi test/completion/stub_folder/stub_only_folder/python_only.py test/completion/stub_folder/with_stub_folder/__init__.py test/completion/stub_folder/with_stub_folder/__init__.pyi test/completion/stub_folder/with_stub_folder/nested_stub_only.pyi test/completion/stub_folder/with_stub_folder/nested_with_stub.py test/completion/stub_folder/with_stub_folder/nested_with_stub.pyi test/completion/stub_folder/with_stub_folder/python_only.py test/completion/thirdparty/PyQt4_.py test/completion/thirdparty/jedi_.py test/completion/thirdparty/psycopg2_.py test/completion/thirdparty/pylab_.py test/examples/README.rst test/examples/buildout_project/buildout.cfg test/examples/buildout_project/bin/app test/examples/buildout_project/bin/binary_file test/examples/buildout_project/bin/empty_file test/examples/buildout_project/src/proj_name/module_name.py test/examples/django/manage.py test/examples/django/app/__init__.py test/examples/django/app/models.py test/examples/flask-site-packages/flask_foo.py test/examples/flask-site-packages/flask/__init__.py test/examples/flask-site-packages/flask/ext/__init__.py test/examples/flask-site-packages/flask_baz/__init__.py test/examples/flask-site-packages/flaskext/__init__.py test/examples/flask-site-packages/flaskext/bar.py test/examples/flask-site-packages/flaskext/moo/__init__.py test/examples/implicit_namespace_package/ns1/pkg/ns1_file.py test/examples/implicit_namespace_package/ns2/pkg/ns2_file.py test/examples/implicit_nested_namespaces/namespace/pkg/module.py test/examples/import-recursion/cq_example.py test/examples/import-recursion/cadquery_simple/__init__.py test/examples/import-recursion/cadquery_simple/cq.py test/examples/inheritance/pkg/__init__.py test/examples/inheritance/pkg/module.py test/examples/init_extension_module/__init__.cpython-38-x86_64-linux-gnu.so test/examples/init_extension_module/module.c test/examples/init_extension_module/setup.py test/examples/issue1209/__init__.py test/examples/issue1209/api/__init__.py test/examples/issue1209/api/whatever/__init__.py test/examples/issue1209/api/whatever/api_test1.py test/examples/issue1209/whatever/__init__.py test/examples/issue1209/whatever/test.py test/examples/namespace_package/ns1/pkg/__init__.py test/examples/namespace_package/ns1/pkg/ns1_file.py test/examples/namespace_package/ns1/pkg/ns1_folder/__init__.py test/examples/namespace_package/ns2/pkg/ns2_file.py test/examples/namespace_package/ns2/pkg/ns2_folder/__init__.py test/examples/namespace_package/ns2/pkg/ns2_folder/nested/__init__.py test/examples/namespace_package_relative_import/rel1.py test/examples/namespace_package_relative_import/rel2.py test/examples/nested_namespaces/__init__.py test/examples/nested_namespaces/namespace/__init__.py test/examples/nested_namespaces/namespace/pkg/__init__.py test/examples/not_in_sys_path/__init__.py test/examples/not_in_sys_path/not_in_sys_path.py test/examples/not_in_sys_path/not_in_sys_path_package/__init__.py test/examples/not_in_sys_path/not_in_sys_path_package/module.py test/examples/not_in_sys_path/pkg/__init__.py test/examples/not_in_sys_path/pkg/module.py test/examples/pytest_plugin_package/pytest_plugin/fixtures.py test/examples/pytest_plugin_package/pytest_plugin/plugin.py test/examples/sample_venvs/pth_directory/egg_link.egg-link test/examples/sample_venvs/pth_directory/foo.pth test/examples/sample_venvs/pth_directory/import_smth.pth test/examples/sample_venvs/pth_directory/relative.egg-link test/examples/sample_venvs/pth_directory/smth.py test/examples/sample_venvs/pth_directory/dir-from-foo-pth/__init__.py test/examples/simple_import/__init__.py test/examples/simple_import/module.py test/examples/simple_import/module2.py test/examples/speed/precedence.py test/examples/stub_packages/no_python-stubs/__init__.pyi test/examples/stub_packages/with_python/__init__.py test/examples/stub_packages/with_python/module.py test/examples/stub_packages/with_python-stubs/__init__.pyi test/examples/stub_packages/with_python-stubs/module.pyi test/examples/typing_overload/file.py test/examples/typing_overload/file.pyi test/examples/zipped_imports/not_pkg.zip test/examples/zipped_imports/pkg.zip test/refactor/extract_function.py test/refactor/extract_variable.py test/refactor/inline.py test/refactor/rename.py test/refactor/import_tree/inline_mod.py test/refactor/import_tree/some_mod.py test/refactor/import_tree/pkgx/__init__.py test/refactor/import_tree/pkgx/__init__.pyi test/refactor/import_tree/pkgx/mod.pyi test/refactor/import_tree/pkgx/mod2.py test/static_analysis/attribute_error.py test/static_analysis/attribute_warnings.py test/static_analysis/branches.py test/static_analysis/builtins.py test/static_analysis/class_simple.py test/static_analysis/comprehensions.py test/static_analysis/descriptors.py test/static_analysis/generators.py test/static_analysis/imports.py test/static_analysis/iterable.py test/static_analysis/keywords.py test/static_analysis/normal_arguments.py test/static_analysis/operations.py test/static_analysis/star_arguments.py test/static_analysis/try_except.py test/static_analysis/import_tree/__init__.py test/static_analysis/import_tree/a.py test/static_analysis/import_tree/b.py test/test_api/__init__.py test/test_api/test_analysis.py test/test_api/test_api.py test/test_api/test_api_classes_follow_definition.py test/test_api/test_call_signatures.py test/test_api/test_classes.py test/test_api/test_completion.py test/test_api/test_context.py test/test_api/test_documentation.py test/test_api/test_environment.py test/test_api/test_full_name.py test/test_api/test_interpreter.py test/test_api/test_keyword.py test/test_api/test_names.py test/test_api/test_project.py test/test_api/test_refactoring.py test/test_api/test_search.py test/test_api/test_settings.py test/test_api/test_signatures.py test/test_api/test_syntax_errors.py test/test_api/test_unicode.py test/test_api/test_usages.py test/test_inference/__init__.py test/test_inference/test_annotations.py test/test_inference/test_buildout_detection.py test/test_inference/test_compiled.py test/test_inference/test_context.py test/test_inference/test_docstring.py test/test_inference/test_extension.py test/test_inference/test_fstring.py test/test_inference/test_implicit_namespace_package.py test/test_inference/test_imports.py test/test_inference/test_literals.py test/test_inference/test_mixed.py test/test_inference/test_namespace_package.py test/test_inference/test_precedence.py test/test_inference/test_pyc.py test/test_inference/test_representation.py test/test_inference/test_signature.py test/test_inference/test_stdlib.py test/test_inference/test_sys_path.py test/test_inference/test_gradual/__init__.py test/test_inference/test_gradual/test_conversion.py test/test_inference/test_gradual/test_stub_loading.py test/test_inference/test_gradual/test_stubs.py test/test_inference/test_gradual/test_typeshed.py test/test_parso_integration/__init__.py test/test_parso_integration/test_basic.py test/test_parso_integration/test_error_correction.py test/test_parso_integration/test_parser_utils.py././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238359.0 jedi-0.19.1/jedi.egg-info/dependency_links.txt0000664000175000017500000000000100000000000021053 0ustar00davedave00000000000000 ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238359.0 jedi-0.19.1/jedi.egg-info/requires.txt0000664000175000017500000000112400000000000017403 0ustar00davedave00000000000000parso<0.9.0,>=0.8.3 [docs] Jinja2==2.11.3 MarkupSafe==1.1.1 Pygments==2.8.1 alabaster==0.7.12 babel==2.9.1 chardet==4.0.0 commonmark==0.8.1 docutils==0.17.1 future==0.18.2 idna==2.10 imagesize==1.2.0 mock==1.0.1 packaging==20.9 pyparsing==2.4.7 pytz==2021.1 readthedocs-sphinx-ext==2.1.4 recommonmark==0.5.0 requests==2.25.1 six==1.15.0 snowballstemmer==2.1.0 sphinx-rtd-theme==0.4.3 sphinx==1.8.5 sphinxcontrib-serializinghtml==1.1.4 sphinxcontrib-websupport==1.2.4 urllib3==1.26.4 [qa] flake8==5.0.4 mypy==0.971 types-setuptools==67.2.0.1 [testing] Django attrs colorama docopt pytest<7.0.0 ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238359.0 jedi-0.19.1/jedi.egg-info/top_level.txt0000664000175000017500000000000500000000000017532 0ustar00davedave00000000000000jedi ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/pytest.ini0000664000175000017500000000063400000000000014434 0ustar00davedave00000000000000[pytest] addopts = --doctest-modules # Ignore broken files in blackbox test directories norecursedirs = .* jedi/third_party scripts docs test/completion test/refactor test/static_analysis test/examples # Activate `clean_jedi_cache` fixture for all tests. This should be # fine as long as we are using `clean_jedi_cache` as a session scoped # fixture. usefixtures = clean_jedi_cache testpaths = jedi test ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4743795 jedi-0.19.1/setup.cfg0000664000175000017500000000140100000000000014215 0ustar00davedave00000000000000[bdist_wheel] universal = 1 [flake8] max-line-length = 100 ignore = E722, E226, E721, W503, E741, per-file-ignores = jedi/__init__.py:F401 jedi/inference/compiled/__init__.py:F401 jedi/inference/value/__init__.py:F401 exclude = jedi/third_party/* .tox/* [pycodestyle] max-line-length = 100 [mypy] exclude = ^jedi/third_party show_error_codes = true enable_error_code = ignore-without-code disallow_any_generics = True disallow_subclassing_any = True warn_redundant_casts = True warn_unused_ignores = True warn_return_any = True warn_unused_configs = True warn_unreachable = True implicit_reexport = False strict_equality = True [mypy-jedi,jedi.inference.compiled,jedi.inference.value,parso] implicit_reexport = True [egg_info] tag_build = tag_date = 0 ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/setup.py0000775000175000017500000000767200000000000014131 0ustar00davedave00000000000000#!/usr/bin/env python from setuptools import setup, find_packages from setuptools.depends import get_module_constant import os __AUTHOR__ = 'David Halter' __AUTHOR_EMAIL__ = 'davidhalter88@gmail.com' # Get the version from within jedi. It's defined in exactly one place now. version = get_module_constant("jedi", "__version__") readme = open('README.rst').read() + '\n\n' + open('CHANGELOG.rst').read() assert os.path.isfile("jedi/third_party/typeshed/LICENSE"), \ "Please download the typeshed submodule first (Hint: git submodule update --init)" assert os.path.isfile("jedi/third_party/django-stubs/LICENSE.txt"), \ "Please download the django-stubs submodule first (Hint: git submodule update --init)" setup(name='jedi', version=version, description='An autocompletion tool for Python that can be used for text editors.', author=__AUTHOR__, author_email=__AUTHOR_EMAIL__, include_package_data=True, maintainer=__AUTHOR__, maintainer_email=__AUTHOR_EMAIL__, url='https://github.com/davidhalter/jedi', project_urls={ "Documentation": 'https://jedi.readthedocs.io/en/latest/', }, license='MIT', keywords='python completion refactoring vim', long_description=readme, packages=find_packages(exclude=['test', 'test.*']), python_requires='>=3.6', # Python 3.11 & 3.12 grammars are added to parso in 0.8.3 install_requires=['parso>=0.8.3,<0.9.0'], extras_require={ 'testing': [ 'pytest<7.0.0', # docopt for sith doctests 'docopt', # coloroma for colored debug output 'colorama', 'Django', 'attrs', ], 'qa': [ # latest version supporting Python 3.6 'flake8==5.0.4', # latest version supporting Python 3.6 'mypy==0.971', # Arbitrary pins, latest at the time of pinning 'types-setuptools==67.2.0.1', ], 'docs': [ # Just pin all of these. 'Jinja2==2.11.3', 'MarkupSafe==1.1.1', 'Pygments==2.8.1', 'alabaster==0.7.12', 'babel==2.9.1', 'chardet==4.0.0', 'commonmark==0.8.1', 'docutils==0.17.1', 'future==0.18.2', 'idna==2.10', 'imagesize==1.2.0', 'mock==1.0.1', 'packaging==20.9', 'pyparsing==2.4.7', 'pytz==2021.1', 'readthedocs-sphinx-ext==2.1.4', 'recommonmark==0.5.0', 'requests==2.25.1', 'six==1.15.0', 'snowballstemmer==2.1.0', 'sphinx==1.8.5', 'sphinx-rtd-theme==0.4.3', 'sphinxcontrib-serializinghtml==1.1.4', 'sphinxcontrib-websupport==1.2.4', 'urllib3==1.26.4', ], }, package_data={'jedi': ['*.pyi', 'third_party/typeshed/LICENSE', 'third_party/typeshed/README']}, platforms=['any'], classifiers=[ 'Development Status :: 4 - Beta', 'Environment :: Plugins', 'Intended Audience :: Developers', 'License :: OSI Approved :: MIT License', 'Operating System :: OS Independent', 'Programming Language :: Python :: 3', 'Programming Language :: Python :: 3.6', 'Programming Language :: Python :: 3.7', 'Programming Language :: Python :: 3.8', 'Programming Language :: Python :: 3.9', 'Programming Language :: Python :: 3.10', 'Programming Language :: Python :: 3.11', 'Programming Language :: Python :: 3.12', 'Topic :: Software Development :: Libraries :: Python Modules', 'Topic :: Text Editors :: Integrated Development Environments (IDE)', 'Topic :: Utilities', ], ) ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/sith.py0000775000175000017500000001625000000000000013730 0ustar00davedave00000000000000#!/usr/bin/env python """ Sith attacks (and helps debugging) Jedi. Randomly search Python files and run Jedi on it. Exception and used arguments are recorded to ``./record.json`` (specified by --record):: ./sith.py random /path/to/sourcecode Redo recorded exception:: ./sith.py redo Show recorded exception:: ./sith.py show Run a specific operation ./sith.py run Where operation is one of complete, goto, infer, get_references or get_signatures. Note: Line numbers start at 1; columns start at 0 (this is consistent with many text editors, including Emacs). Usage: sith.py [--pdb|--ipdb|--pudb] [-d] [-n=] [-f] [--record=] random [-s] [] sith.py [--pdb|--ipdb|--pudb] [-d] [-f] [--record=] redo sith.py [--pdb|--ipdb|--pudb] [-d] [-f] run sith.py show [--record=] sith.py -h | --help Options: -h --help Show this screen. --record= Exceptions are recorded in here [default: record.json]. -f, --fs-cache By default, file system cache is off for reproducibility. -n, --maxtries= Maximum of random tries [default: 100] -d, --debug Jedi print debugging when an error is raised. -s Shows the path/line numbers of every completion before it starts. --pdb Launch pdb when error is raised. --ipdb Launch ipdb when error is raised. --pudb Launch pudb when error is raised. """ from docopt import docopt # type: ignore[import] import json import os import random import sys import traceback import jedi class SourceFinder(object): _files = None @staticmethod def fetch(file_path): if not os.path.isdir(file_path): yield file_path return for root, dirnames, filenames in os.walk(file_path): for name in filenames: if name.endswith('.py'): yield os.path.join(root, name) @classmethod def files(cls, file_path): if cls._files is None: cls._files = list(cls.fetch(file_path)) return cls._files class TestCase(object): def __init__(self, operation, path, line, column, traceback=None): if operation not in self.operations: raise ValueError("%s is not a valid operation" % operation) # Set other attributes self.operation = operation self.path = path self.line = line self.column = column self.traceback = traceback @classmethod def from_cache(cls, record): with open(record) as f: args = json.load(f) return cls(*args) # Changing this? Also update the module docstring above. operations = ['complete', 'goto', 'infer', 'get_references', 'get_signatures'] @classmethod def generate(cls, file_path): operation = random.choice(cls.operations) path = random.choice(SourceFinder.files(file_path)) with open(path) as f: source = f.read() lines = source.splitlines() if not lines: lines = [''] line = random.randint(1, len(lines)) line_string = lines[line - 1] line_len = len(line_string) if line_string.endswith('\r\n'): line_len -= 1 if line_string.endswith('\n'): line_len -= 1 column = random.randint(0, line_len) return cls(operation, path, line, column) def run(self, debugger, record=None, print_result=False): try: with open(self.path) as f: self.script = jedi.Script(f.read(), path=self.path) kwargs = {} if self.operation == 'goto': kwargs['follow_imports'] = random.choice([False, True]) self.objects = getattr(self.script, self.operation)(self.line, self.column, **kwargs) if print_result: print("{path}: Line {line} column {column}".format(**self.__dict__)) self.show_location(self.line, self.column) self.show_operation() except Exception: self.traceback = traceback.format_exc() if record is not None: call_args = (self.operation, self.path, self.line, self.column, self.traceback) with open(record, 'w') as f: json.dump(call_args, f) self.show_errors() if debugger: einfo = sys.exc_info() pdb = __import__(debugger) if debugger == 'pudb': pdb.post_mortem(einfo[2], einfo[0], einfo[1]) else: pdb.post_mortem(einfo[2]) exit(1) def show_location(self, lineno, column, show=3): # Three lines ought to be enough lower = lineno - show if lineno - show > 0 else 0 prefix = ' |' for i, line in enumerate(self.script._code.split('\n')[lower:lineno]): print(prefix, lower + i + 1, line) print(prefix, ' ' * (column + len(str(lineno))), '^') def show_operation(self): print("%s:\n" % self.operation.capitalize()) if self.operation == 'complete': self.show_completions() else: self.show_definitions() def show_completions(self): for completion in self.objects: print(completion.name) def show_definitions(self): for completion in self.objects: print(completion.full_name) if completion.module_path is None: continue if os.path.abspath(completion.module_path) == os.path.abspath(self.path): self.show_location(completion.line, completion.column) def show_errors(self): sys.stderr.write(self.traceback) print(("Error with running Script(...).{operation}() with\n" "\tpath: {path}\n" "\tline: {line}\n" "\tcolumn: {column}").format(**self.__dict__)) def main(arguments): debugger = 'pdb' if arguments['--pdb'] else \ 'ipdb' if arguments['--ipdb'] else \ 'pudb' if arguments['--pudb'] else None record = arguments['--record'] jedi.settings.use_filesystem_cache = arguments['--fs-cache'] if arguments['--debug']: jedi.set_debug_function() if arguments['redo'] or arguments['show']: t = TestCase.from_cache(record) if arguments['show']: t.show_errors() else: t.run(debugger) elif arguments['run']: TestCase( arguments[''], arguments[''], int(arguments['']), int(arguments['']) ).run(debugger, print_result=True) else: for _ in range(int(arguments['--maxtries'])): t = TestCase.generate(arguments[''] or '.') if arguments['-s']: print('%s %s %s %s ' % (t.operation, t.path, t.line, t.column)) sys.stdout.flush() else: print('.', end='') t.run(debugger, record) sys.stdout.flush() print() if __name__ == '__main__': arguments = docopt(__doc__) main(arguments) ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4663794 jedi-0.19.1/test/0000775000175000017500000000000000000000000013357 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/__init__.py0000664000175000017500000000000000000000000015456 0ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4663794 jedi-0.19.1/test/completion/0000775000175000017500000000000000000000000015530 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/completion/__init__.py0000664000175000017500000000020100000000000017632 0ustar00davedave00000000000000""" needed for some modules to test against packages. """ some_variable = 1 from . import imports #? int() imports.relative() ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/completion/arrays.py0000664000175000017500000001424700000000000017413 0ustar00davedave00000000000000# ----------------- # basic array lookups # ----------------- #? int() [1,""][0] #? str() [1,""][1] #? int() str() [1,""][2] #? int() str() [1,""][20] #? int() str() [1,""][str(hello)] a = list() #? list() [a][0] #? list() [[a,a,a]][2][100] c = [[a,""]] #? str() c[0][1] b = [6,7] #? int() b[8-7] # Something unreasonable: #? int() b[''] # ----------------- # Slices # ----------------- #? list() b[8:] #? list() b[int():] #? list() b[:] #? int() b[:, :-1] #? 3 b[:] #? int() b[:, 1] #? int() b[:1, 1] #? int() b[1:1, 1] #? int() b[1:1:, ...] #? int() b[1:1:5, ...] class _StrangeSlice(): def __getitem__(self, sliced): return sliced # Should not result in an error, just because the slice itself is returned. #? slice() _StrangeSlice()[1:2] for x in b[:]: #? int() x for x in b[:, :-1]: #? x class Foo: def __getitem__(self, item): return item #? Foo()[:, :-1][0] # ----------------- # iterable multiplication # ----------------- a = ['']*2 #? list() a # ----------------- # tuple assignments # ----------------- a1, b1 = (1, "") #? int() a1 #? str() b1 (a2, b2) = (1, "") #? int() a2 #? str() b2 # list assignment [list1, list2] = (1, "") #? int() list1 #? str() list2 [list3, list4] = [1, ""] #? int() list3 #? str() list4 # ----------------- # subtuple assignment # ----------------- (a3, (b3, c3)) = (1, ("", list)) #? list c3 a4, (b4, c4) = (1, ("", list)) #? list c4 #? int() a4 #? str() b4 # ----------------- # multiple assignments # ----------------- a = b = 1 #? int() a #? int() b (a, b) = (c, (e, f)) = ('2', (3, 4)) #? str() a #? tuple() b #? str() c #? int() e #? int() f # ----------------- # unnessecary braces # ----------------- a = (1) #? int() a #? int() (1) #? int() ((1)) #? int() ((1)+1) u, v = 1, "" #? int() u ((u1, v1)) = 1, "" #? int() u1 #? int() (u1) (a), b = 1, '' #? int() a def a(): return '' #? str() (a)() #? str() (a)().title() #? int() (tuple).index() #? int() (tuple)().index() class C(): def __init__(self): self.a = (str()).upper() #? str() C().a # ----------------- # imbalanced sides # ----------------- (f, g) = (1,) #? int() f #? [] g. (f, g, h) = (1,'') #? int() f #? str() g #? [] h. (f1, g1) = 1 #? [] f1. #? [] g1. (f, g) = (1,'',1.0) #? int() f #? str() g # ----------------- # setitem # ----------------- class F: setitem_x = [1,2] setitem_x[0] = 3 #? ['setitem_x'] F().setitem_x #? list() F().setitem_x # ----------------- # dicts # ----------------- dic2 = {'asdf': 3, 'b': 'str'} #? int() dic2['asdf'] #? None int() str() dic2.get('asdf') # string literal #? int() dic2[r'asdf'] #? int() dic2[r'asdf'] #? int() dic2[r'as' 'd' u'f'] #? int() str() dic2['just_something'] # unpacking a, b = dic2 #? str() a a, b = {1: 'x', 2.0: 1j} #? int() float() a #? int() float() b def f(): """ github #83 """ r = {} r['status'] = (200, 'ok') return r #? dict() f() # completion within dicts #? 9 ['str'] {str: str} # iteration problem (detected with sith) d = dict({'a':''}) def y(a): return a #? y(**d) #? str() d['a'] # problem with more complicated casts dic = {str(key): ''} #? str() dic[''] for x in {1: 3.0, '': 1j}: #? int() str() x #? ['__iter__'] dict().values().__iter__ d = dict(a=3, b='') x, = d.values() #? int() str() x #? int() d['a'] #? int() str() None d.get('a') some_dct = dict({'a': 1, 'b': ''}, a=1.0) #? float() some_dct['a'] #? str() some_dct['b'] #? int() float() str() some_dct['c'] class Foo: pass objects = {object(): 1, Foo: '', Foo(): 3.0} #? int() float() str() objects[Foo] #? int() float() str() objects[Foo()] #? int() float() str() objects[''] # ----------------- # with variable as index # ----------------- a = (1, "") index = 1 #? str() a[index] # these should just ouput the whole array index = int #? int() str() a[index] index = int() #? int() str() a[index] # dicts index = 'asdf' dic2 = {'asdf': 3, 'b': 'str'} #? int() dic2[index] # ----------------- # __getitem__ # ----------------- class GetItem(): def __getitem__(self, index): return 1.0 #? float() GetItem()[0] class GetItem(): def __init__(self, el): self.el = el def __getitem__(self, index): return self.el #? str() GetItem("")[1] class GetItemWithList(): def __getitem__(self, index): return [1, 1.0, 's'][index] #? float() GetItemWithList()[1] for i in 0, 2: #? int() str() GetItemWithList()[i] # With super class SuperYeah(list): def __getitem__(self, index): return super()[index] #? SuperYeah([1])[0] #? SuperYeah()[0] # ----------------- # conversions # ----------------- a = [1, ""] #? int() str() list(a)[1] #? int() str() list(a)[0] #? set(a)[0] #? int() str() list(set(a))[1] #? int() str() next(iter(set(a))) #? int() str() list(list(set(a)))[1] # does not yet work, because the recursion catching is not good enough (catches # to much) #? int() str() list(set(list(set(a))))[1] #? int() str() list(set(set(a)))[1] # frozenset #? int() str() list(frozenset(a))[1] #? int() str() list(set(frozenset(a)))[1] # iter #? int() str() list(iter(a))[1] #? int() str() list(iter(list(set(a))))[1] # tuple #? int() str() tuple(a)[1] #? int() str() tuple(list(set(a)))[1] #? int() tuple((1,))[0] # implementation detail for lists, should not be visible #? [] list().__iterable # With a list comprehension. for i in set(a for a in [1]): #? int() i # ----------------- # Merged Arrays # ----------------- for x in [1] + ['']: #? int() str() x # ----------------- # Potential Recursion Issues # ----------------- class X(): def y(self): self.a = [1] def x(self): self.a = list(self.a) #? int() self.a[0] # ----------------- # For loops with attribute assignment. # ----------------- def test_func(): x = 'asdf' for x.something in [6,7,8]: pass #? str() x for x.something, b in [[6, 6.0]]: pass #? str() x #? int() tuple({1})[0] # ----------------- # PEP 3132 Extended Iterable Unpacking (star unpacking) # ----------------- a, *b, c = [1, 'b', list, dict] #? int() a #? b #? list c # Not valid syntax a, *b, *c = [1, 'd', list] #? int() a #? b #? c lc = [x for a, *x in [(1, '', 1.0)]] #? lc[0][0] #? lc[0][1] ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/completion/async_.py0000664000175000017500000000336000000000000017360 0ustar00davedave00000000000000""" Tests for all async use cases. Currently we're not supporting completion of them, but they should at least not raise errors or return extremely strange results. """ async def x(): return 1 #? [] x.cr_awai #? ['cr_await'] x().cr_awai a = await x() #? int() a async def y(): argh = await x() #? int() argh #? ['__next__'] x().__await__().__next return 2 class A(): @staticmethod async def b(c=1, d=2): return 1 #! 9 ['def b'] await A.b() #! 11 ['param d=2'] await A.b(d=3) class Awaitable: def __await__(self): yield None return '' async def awaitable_test(): foo = await Awaitable() #? str() foo async def asgen(): yield 1 await asyncio.sleep(0) yield 2 async def wrapper(): #? int() [x async for x in asgen()][0] async for y in asgen(): #? int() y #? ['__anext__'] asgen().__ane #? [] asgen().mro # Normal completion (#1092) normal_var1 = 42 async def foo(): normal_var2 = False #? ['normal_var1', 'normal_var2'] normal_var class C: @classmethod async def async_for_classmethod(cls) -> "C": return async def async_for_method(cls) -> int: return async def f(): c = await C.async_for_method() #? int() c d = await C().async_for_method() #? int() d e = await C.async_for_classmethod() #? C() e f = await C().async_for_classmethod() #? C() f class AsyncCtxMgr: def some_method(): pass async def __aenter__(self): return self async def __aexit__(self, *args): pass async def asyncctxmgr(): async with AsyncCtxMgr() as acm: #? AsyncCtxMgr() acm #? ['some_method'] acm.som ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/completion/basic.py0000664000175000017500000001320500000000000017164 0ustar00davedave00000000000000# ----------------- # cursor position # ----------------- #? 0 int int() #? 3 int int() #? 4 str int(str) # ----------------- # should not complete # ----------------- #? [] . #? [] str.. #? [] a(0):. #? 2 [] 0x0 #? [] 1j #? ['and', 'or', 'if', 'is', 'in', 'not'] 1j x = None() #? x # ----------------- # if/else/elif # ----------------- if (random.choice([0, 1])): 1 elif(random.choice([0, 1])): a = 3 else: a = '' #? int() str() a def func(): if random.choice([0, 1]): 1 elif(random.choice([0, 1])): a = 3 else: a = '' #? int() str() return a #? int() str() func() # ----------------- # keywords # ----------------- #? list() assert [] def focus_return(): #? list() return [] # ----------------- # for loops # ----------------- for a in [1,2]: #? int() a for a1 in 1,"": #? int() str() a1 for a3, b3 in (1,""), (1,""), (1,""): #? int() a3 #? str() b3 for (a3, b3) in (1,""), (1,""), (1,""): #? int() a3 #? str() b3 for a4, (b4, c4) in (1,("", list)), (1,("", list)): #? int() a4 #? str() b4 #? list c4 a = [] for i in [1,'']: #? int() str() i a += [i] #? int() str() a[0] for i in list([1,'']): #? int() str() i #? int() str() for x in [1,'']: x a = [] b = [1.0,''] for i in b: a += [i] #? float() str() a[0] for i in [1,2,3]: #? int() i else: i # ----------------- # range() # ----------------- for i in range(10): #? int() i # ----------------- # ternary operator # ----------------- a = 3 b = '' if a else set() #? str() set() b def ret(a): return ['' if a else set()] #? str() set() ret(1)[0] #? str() set() ret()[0] # ----------------- # global vars # ----------------- def global_define(): #? int() global global_var_in_func global_var_in_func = 3 #? int() global_var_in_func #? ['global_var_in_func'] global_var_in_f def funct1(): # From issue #610 global global_dict_var global_dict_var = dict() def funct2(): #! ['global_dict_var', 'global_dict_var'] global global_dict_var #? dict() global_dict_var global_var_predefined = None def init_global_var_predefined(): global global_var_predefined if global_var_predefined is None: global_var_predefined = 3 #? int() None global_var_predefined def global_as_import(): from import_tree import globals #? ['foo'] globals.foo #? int() globals.foo global r r = r[r] if r: r += r + 2 #? int() r # ----------------- # del # ----------------- deleted_var = 3 del deleted_var #? deleted_var #? [] deleted_var #! [] deleted_var # ----------------- # within docstrs # ----------------- def a(): """ #? [] global_define #? str """ pass #? # str literals in comment """ upper def completion_in_comment(): #? ['Exception'] # might fail because the comment is not a leaf: Exception pass some_word #? ['Exception'] # Very simple comment completion: Exception # Commment after it # ----------------- # magic methods # ----------------- class A(object): pass class B(): pass #? ['__init__'] A.__init__ #? ['__init__'] B.__init__ #? ['__init__'] int().__init__ # ----------------- # comments # ----------------- class A(): def __init__(self): self.hello = {} # comment shouldn't be a string #? dict() A().hello # ----------------- # unicode # ----------------- a = 'smörbröd' #? str() a xyz = 'smörbröd.py' if 1: #? str() xyz #? ¹. # ----------------- # exceptions # ----------------- try: import math except ImportError as i_a: #? ['i_a'] i_a #? ImportError() i_a class MyException(Exception): def __init__(self, my_attr): self.my_attr = my_attr try: raise MyException(1) except MyException as e: #? ['my_attr'] e.my_attr #? 22 ['my_attr'] for x in e.my_attr: pass # ----------------- # params # ----------------- my_param = 1 #? 9 str() def foo1(my_param): my_param = 3.0 foo1("") my_type = float() #? 20 float() def foo2(my_param: my_type): pass foo2("") #? 20 int() def foo3(my_param=my_param): pass foo3("") some_default = '' #? [] def foo(my_t #? [] def foo(my_t, my_ty #? ['some_default'] def foo(my_t=some_defa #? ['some_default'] def foo(my_t=some_defa, my_t2=some_defa #? ['my_type'] def foo(my_t: lala=some_defa, my_t2: my_typ #? ['my_type'] def foo(my_t: lala=some_defa, my_t2: my_typ #? [] def foo(my_t: lala=some_defa, my_t #? [] lambda my_t #? [] lambda my_, my_t #? ['some_default'] lambda x=some_defa #? ['some_default'] lambda y, x=some_defa # Just make sure we're not in some weird parsing recovery after opening brackets def # ----------------- # continuations # ----------------- foo = \ 1 #? int() foo # ----------------- # module attributes # ----------------- # Don't move this to imports.py, because there's a star import. #? str() __file__ #? ['__file__'] __file__ #? str() math.__file__ # Should not lead to errors #? math() # ----------------- # with statements # ----------------- with open('') as f: #? ['closed'] f.closed for line in f: #? str() bytes() line with open('') as f1, open('') as f2: #? ['closed'] f1.closed #? ['closed'] f2.closed class Foo(): def __enter__(self): return '' #? 14 str() with Foo() as f3: #? str() f3 #! 14 ['with Foo() as f3: f3'] with Foo() as f3: f3 #? 6 Foo with Foo() as f3: f3 with open("a"), open("b") as bfile: #? ['flush'] bfile.flush # ----------------- # Avoiding multiple definitions # ----------------- some_array = ['', ''] #! ['def upper'] some_array[some_not_defined_index].upper ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/completion/classes.py0000664000175000017500000002373700000000000017553 0ustar00davedave00000000000000def find_class(): """ This scope is special, because its in front of TestClass """ #? ['ret'] TestClass.ret if 1: #? ['ret'] TestClass.ret class FindClass(): #? [] TestClass.ret if a: #? [] TestClass.ret def find_class(self): #? ['ret'] TestClass.ret if 1: #? ['ret'] TestClass.ret #? [] FindClass().find_class.self #? [] FindClass().find_class.self.find_class # set variables, which should not be included, because they don't belong to the # class second = 1 second = "" class TestClass(object): var_class = TestClass(1) self.pseudo_var = 3 def __init__(self2, first_param, second_param, third=1.0): self2.var_inst = first_param self2.second = second_param self2.first = first_param self2.first.var_on_argument = 5 a = 3 def var_func(self): return 1 def get_first(self): # traversal self.second_new = self.second return self.var_inst def values(self): self.var_local = 3 #? ['var_class', 'var_func', 'var_inst', 'var_local'] self.var_ #? var_local def ret(self, a1): # should not know any class functions! #? [] values #? values #? ['return'] ret return a1 # should not work #? [] var_local #? [] var_inst #? [] var_func # instance inst = TestClass(1) #? ['var_class', 'var_func', 'var_inst', 'var_local'] inst.var #? ['var_class', 'var_func'] TestClass.var #? int() inst.var_local #? [] TestClass.var_local. #? TestClass.pseudo_var #? TestClass().pseudo_var #? int() TestClass().ret(1) # Should not return int(), because we want the type before `.ret(1)`. #? 11 TestClass() TestClass().ret(1) #? int() inst.ret(1) myclass = TestClass(1, '', 3.0) #? int() myclass.get_first() #? [] myclass.get_first.real # too many params #? int() TestClass(1,1,1).var_inst # too few params #? int() TestClass(1).first #? [] TestClass(1).second. # complicated variable settings in class #? str() myclass.second #? str() myclass.second_new # multiple classes / ordering ints = TestClass(1, 1.0) strs = TestClass("", '') #? float() ints.second #? str() strs.second #? ['var_class'] TestClass.var_class.var_class.var_class.var_class # operations (+, *, etc) shouldn't be InstanceElements - #246 class A(): def __init__(self): self.addition = 1 + 2 #? int() A().addition # should also work before `=` #? 8 int() A().addition = None #? 8 int() A(1).addition = None #? 1 A A(1).addition = None a = A() #? 8 int() a.addition = None # ----------------- # inheritance # ----------------- class Base(object): def method_base(self): return 1 class SuperClass(Base): class_super = 3 def __init__(self): self.var_super = '' def method_super(self): self.var2_super = list class Mixin(SuperClass): def method_mixin(self): return int #? 20 SuperClass class SubClass(SuperClass): class_sub = 3 def __init__(self): self.var_sub = '' def method_sub(self): self.var_sub = list return tuple instance = SubClass() #? ['method_base', 'method_sub', 'method_super'] instance.method_ #? ['var2_super', 'var_sub', 'var_super'] instance.var #? ['class_sub', 'class_super'] instance.class_ #? ['method_base', 'method_sub', 'method_super'] SubClass.method_ #? [] SubClass.var #? ['class_sub', 'class_super'] SubClass.class_ # ----------------- # inheritance of builtins # ----------------- class Base(str): pass #? ['upper'] Base.upper #? ['upper'] Base().upper # ----------------- # dynamic inheritance # ----------------- class Angry(object): def shout(self): return 'THIS IS MALARKEY!' def classgetter(): return Angry class Dude(classgetter()): def react(self): #? ['shout'] self.s # ----------------- # multiple inheritance # 1071 # ----------------- class FactorMixin(object): FACTOR_1 = 0.1 class Calc(object): def sum(self, a, b): self.xxx = 3 return a + b class BetterCalc(Calc, FactorMixin): def multiply_factor(self, a): return a * self.FACTOR_1 calc = BetterCalc() #? ['sum'] calc.sum #? ['multiply_factor'] calc.multip #? ['FACTOR_1'] calc.FACTOR_1 #? ['xxx'] calc.xxx # ----------------- # __call__ # ----------------- class CallClass(): def __call__(self): return 1 #? int() CallClass()() # ----------------- # variable assignments # ----------------- class V: def __init__(self, a): self.a = a def ret(self): return self.a d = b b = ret if 1: c = b #? int() V(1).b() #? int() V(1).c() #? V(1).d() # Only keywords should be possible to complete. #? ['is', 'in', 'not', 'and', 'or', 'if'] V(1).d() # ----------------- # ordering # ----------------- class A(): def b(self): #? int() a_func() #? str() self.a_func() return a_func() def a_func(self): return "" def a_func(): return 1 #? int() A().b() #? str() A().a_func() # ----------------- # nested classes # ----------------- class A(): class B(): pass def b(self): return 1.0 #? float() A().b() class A(): def b(self): class B(): def b(self): return [] return B().b() #? list() A().b() # ----------------- # ducktyping # ----------------- def meth(self): return self.a, self.b class WithoutMethod(): a = 1 def __init__(self): self.b = 1.0 def blub(self): return self.b m = meth class B(): b = '' a = WithoutMethod().m() #? int() a[0] #? float() a[1] #? float() WithoutMethod.blub(WithoutMethod()) #? str() WithoutMethod.blub(B()) # ----------------- # __getattr__ / getattr() / __getattribute__ # ----------------- #? str().upper getattr(str(), 'upper') #? str.upper getattr(str, 'upper') # some strange getattr calls #? getattr(str, 1) #? getattr() #? getattr(str) #? getattr(getattr, 1) #? getattr(str, []) class Base(): def ret(self, b): return b class Wrapper(): def __init__(self, obj): self.obj = obj def __getattr__(self, name): return getattr(self.obj, name) class Wrapper2(): def __getattribute__(self, name): return getattr(Base(), name) #? int() Wrapper(Base()).ret(3) #? ['ret'] Wrapper(Base()).ret #? int() Wrapper(Wrapper(Base())).ret(3) #? ['ret'] Wrapper(Wrapper(Base())).ret #? int() Wrapper2(Base()).ret(3) class GetattrArray(): def __getattr__(self, name): return [1] #? int() GetattrArray().something[0] #? [] GetattrArray().something class WeirdGetattr: class __getattr__(): pass #? [] WeirdGetattr().something # ----------------- # private vars # ----------------- class PrivateVar(): def __init__(self): self.__var = 1 #? int() self.__var #? ['__var'] self.__var def __private_func(self): return 1 #? int() __private_func() def wrap_private(self): return self.__private_func() #? [] PrivateVar().__var #? PrivateVar().__var #? [] PrivateVar().__private_func #? [] PrivateVar.__private_func #? int() PrivateVar().wrap_private() class PrivateSub(PrivateVar): def test(self): #? [] self.__var def wrap_private(self): #? [] self.__var #? [] PrivateSub().__var # ----------------- # super # ----------------- class Super(object): a = 3 def return_sup(self): return 1 SuperCopy = Super class TestSuper(Super): #? super() def test(self): #? SuperCopy() super() #? ['a'] super().a if 1: #? SuperCopy() super() def a(): #? super() def return_sup(self): #? int() return super().return_sup() #? int() TestSuper().return_sup() Super = 3 class Foo(): def foo(self): return 1 # Somehow overwriting the same name caused problems (#1044) class Foo(Foo): def foo(self): #? int() super().foo() # ----------------- # if flow at class level # ----------------- class TestX(object): def normal_method(self): return 1 if True: def conditional_method(self): var = self.normal_method() #? int() var return 2 def other_method(self): var = self.conditional_method() #? int() var # ----------------- # mro method # ----------------- class A(object): a = 3 #? ['mro'] A.mro #? [] A().mro # ----------------- # mro resolution # ----------------- class B(A()): b = 3 #? B.a #? B().a #? int() B.b #? int() B().b # ----------------- # With import # ----------------- from import_tree.classes import Config2, BaseClass class Config(BaseClass): """#884""" #? Config2() Config.mode #? int() Config.mode2 # ----------------- # Nested class/def/class # ----------------- class Foo(object): a = 3 def create_class(self): class X(): a = self.a self.b = 3.0 return X #? int() Foo().create_class().a #? float() Foo().b class Foo(object): def comprehension_definition(self): return [1 for self.b in [1]] #? int() Foo().b # ----------------- # default arguments # ----------------- default = '' class DefaultArg(): default = 3 def x(self, arg=default): #? str() default return arg def y(self): return default #? int() DefaultArg().x() #? str() DefaultArg().y() #? int() DefaultArg.x() #? str() DefaultArg.y() # ----------------- # Error Recovery # ----------------- from import_tree.pkg.base import MyBase class C1(MyBase): def f3(self): #! 13 ['def f1'] self.f1() . # hey''' #? 13 MyBase.f1 self.f1() . # hey''' # ----------------- # With a very weird __init__ # ----------------- class WithWeirdInit: class __init__: def __init__(self, a): self.a = a def y(self): return self.a #? WithWeirdInit(1).y() ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/completion/completion.py0000664000175000017500000000105400000000000020253 0ustar00davedave00000000000000""" Special cases of completions (typically special positions that caused issues with value parsing. """ def pass_decorator(func): return func def x(): return ( 1, #? ["tuple"] tuple ) # Comment just somewhere class MyClass: @pass_decorator def x(foo, #? 5 [] tuple, ): return 1 if x: pass #? ['else'] else try: pass #? ['except', 'Exception'] except try: pass #? 6 ['except', 'Exception'] except AttributeError: pass #? ['finally'] finally for x in y: pass #? ['else'] else ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/completion/complex.py0000664000175000017500000000104200000000000017546 0ustar00davedave00000000000000""" Mostly for stupid error reports of @dbrgn. :-) """ import time class Foo(object): global time asdf = time def asdfy(): return Foo xorz = getattr(asdfy()(), 'asdf') #? time xorz def args_returner(*args): return args #? tuple() args_returner(1)[:] #? int() args_returner(1)[:][0] def kwargs_returner(**kwargs): return kwargs # TODO This is not really correct, needs correction probably at some point, but # at least it doesn't raise an error. #? int() kwargs_returner(a=1)[:] #? kwargs_returner(b=1)[:][0] ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/completion/comprehensions.py0000664000175000017500000000730300000000000021141 0ustar00davedave00000000000000# ----------------- # list comprehensions # ----------------- # basics: a = ['' for a in [1]] #? str() a[0] #? ['insert'] a.insert a = [a for a in [1]] #? int() a[0] y = 1.0 # Should not leak. [y for y in [3]] #? float() y a = [a for a in (1, 2)] #? int() a[0] a = [a for a,b in [(1,'')]] #? int() a[0] a = [a for (a,b) in [(1,'')]] #? int() a[0] arr = [1,''] a = [a for a in arr] #? int() a[0] #? str() a[1] #? int() str() a[2] a = [a if 1.0 else '' for a in [1] if [1.0]] #? int() str() a[0] # name resolve should be correct left, right = 'a', 'b' left, right = [x for x in (left, right)] #? str() left # with a dict literal #? int() [a for a in {1:'x'}][0] # list comprehensions should also work in combination with functions def _listen(arg): for x in arg: #? str() x _listen(['' for x in [1]]) #? ([str for x in []])[0] # ----------------- # nested list comprehensions # ----------------- b = [a for arr in [[1, 1.0]] for a in arr] #? int() b[0] #? float() b[1] b = [arr for arr in [[1, 1.0]] for a in arr] #? int() b[0][0] #? float() b[1][1] b = [a for arr in [[1]] if '' for a in arr if ''] #? int() b[0] b = [b for arr in [[[1.0]]] for a in arr for b in a] #? float() b[0] #? str() [x for x in 'chr'][0] # From GitHub #26 #? list() a = [[int(v) for v in line.strip().split() if v] for line in ["123", str(), "123"] if line] #? list() a[0] #? int() a[0][0] # From GitHub #1524 #? [nothing for nothing, _ in [1]][0] # ----------------- # generator comprehensions # ----------------- left, right = (i for i in (1, '')) #? int() left #? str() right gen = (i for i in (1,)) #? int() next(gen) #? gen[0] gen = (a for arr in [[1.0]] for a in arr) #? float() next(gen) #? int() (i for i in (1,)).send() # issues with different formats left, right = (i for i in ('1', 2)) #? str() left #? int() right # ----------------- # name resolution in comprehensions. # ----------------- def x(): """Should not try to resolve to the if hio, which was a bug.""" #? 22 [a for a in h if hio] if hio: pass # ----------------- # slices # ----------------- #? list() foo = [x for x in [1, '']][:1] #? int() foo[0] #? str() foo[1] # ----------------- # In class # ----------------- class X(): def __init__(self, bar): self.bar = bar def foo(self): x = [a for a in self.bar][0] #? int() x return x #? int() X([1]).foo() # ----------------- # dict comprehensions # ----------------- #? int() list({a - 1: 3 for a in [1]})[0] d = {a - 1: b for a, b in {1: 'a', 3: 1.0}.items()} #? int() list(d)[0] #? str() float() d.values()[0] #? str() d[0] #? float() str() d[1] #? float() d[2] # ----------------- # set comprehensions # ----------------- #? set() {a - 1 for a in [1]} #? set() {a for a in range(10)} #? int() [x for x in {a for a in range(10)}][0] #? int() {a for a in range(10)}.pop() #? float() str() {b for a in [[3.0], ['']] for b in a}.pop() #? int() next(iter({a for a in range(10)})) #? int() [a for a in {1, 2, 3}][0] # ----------------- # syntax errors # ----------------- # Issue #1146 #? ['list'] [int(str(x.value) for x in list def reset_missing_bracket(): pass # ----------------- # function calls # ----------------- def foo(arg): return arg x = foo(x for x in [1]) #? int() next(x) #? x[0] # While it's illegal to have more than one argument, when a generator # expression is involved, it's still a valid parse tree and Jedi should still # work (and especially not raise Exceptions). It's debatable wheter inferring # values for invalid statements is a good idea, but not failing is a must. #? int() next(foo(x for x in [1], 1)) def bar(x, y): return y #? str() next(bar(x for x in [1], x for x in [''])) ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/completion/conftest.py0000664000175000017500000000073500000000000017734 0ustar00davedave00000000000000# Exists only for completion/pytest.py import pytest @pytest.fixture() def my_other_conftest_fixture(): return 1.0 @pytest.fixture() def my_conftest_fixture(my_other_conftest_fixture): return my_other_conftest_fixture def my_not_existing_fixture(): return 3 # Just a normal function @pytest.fixture() def inheritance_fixture(): return '' @pytest.fixture def capsysbinary(capsysbinary): #? ['close'] capsysbinary.clos return capsysbinary ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/completion/context.py0000664000175000017500000000135100000000000017566 0ustar00davedave00000000000000class Base(): myfoobar = 3 class X(Base): def func(self, foo): pass class Y(X): def actual_function(self): pass #? [] def actual_function #? ['func'] def f #? ['__doc__'] __doc__ #? [] def __doc__ # This might or might not be what we wanted, currently properties are also # used like this. IMO this is not wanted ~dave. #? ['__class__'] def __class__ #? [] __class__ #? ['__repr__'] def __repr__ #? [] def mro #? ['myfoobar'] myfoobar #? [] myfoobar # ----------------- # Inheritance # ----------------- class Super(): enabled = True if enabled: yo_dude = 4 class Sub(Super): #? ['yo_dude'] yo_dud ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/completion/decorators.py0000664000175000017500000001261500000000000020254 0ustar00davedave00000000000000# ----------------- # normal decorators # ----------------- def decorator(func): def wrapper(*args): return func(1, *args) return wrapper @decorator def decorated(a,b): return a,b exe = decorated(set, '') #? set exe[1] #? int() exe[0] # more complicated with args/kwargs def dec(func): def wrapper(*args, **kwargs): return func(*args, **kwargs) return wrapper @dec def fu(a, b, c, *args, **kwargs): return a, b, c, args, kwargs exe = fu(list, c=set, b=3, d='') #? list exe[0] #? int() exe[1] #? set exe[2] #? [] exe[3][0]. #? str() exe[4]['d'] exe = fu(list, set, 3, '', d='') #? str() exe[3][0] # ----------------- # multiple decorators # ----------------- def dec2(func2): def wrapper2(first_arg, *args2, **kwargs2): return func2(first_arg, *args2, **kwargs2) return wrapper2 @dec2 @dec def fu2(a, b, c, *args, **kwargs): return a, b, c, args, kwargs exe = fu2(list, c=set, b=3, d='str') #? list exe[0] #? int() exe[1] #? set exe[2] #? [] exe[3][0]. #? str() exe[4]['d'] # ----------------- # Decorator is a class # ----------------- def same_func(func): return func class Decorator(object): def __init__(self, func): self.func = func def __call__(self, *args, **kwargs): return self.func(1, *args, **kwargs) @Decorator def nothing(a,b,c): return a,b,c #? int() nothing("")[0] #? str() nothing("")[1] @same_func @Decorator def nothing(a,b,c): return a,b,c #? int() nothing("")[0] class MethodDecoratorAsClass(): class_var = 3 @Decorator def func_without_self(arg, arg2): return arg, arg2 @Decorator def func_with_self(self, arg): return self.class_var #? int() MethodDecoratorAsClass().func_without_self('')[0] #? str() MethodDecoratorAsClass().func_without_self('')[1] #? MethodDecoratorAsClass().func_with_self(1) class SelfVars(): """Init decorator problem as an instance, #247""" @Decorator def __init__(self): """ __init__ decorators should be ignored when looking up variables in the class. """ self.c = list @Decorator def shouldnt_expose_var(not_self): """ Even though in real Python this shouldn't expose the variable, in this case Jedi exposes the variable, because these kind of decorators are normally descriptors, which SHOULD be exposed (at least 90%). """ not_self.b = 1.0 def other_method(self): #? float() self.b #? list self.c # ----------------- # not found decorators (are just ignored) # ----------------- @not_found_decorator def just_a_func(): return 1 #? int() just_a_func() #? ['__closure__'] just_a_func.__closure__ class JustAClass: @not_found_decorator2 def a(self): return 1 #? ['__call__'] JustAClass().a.__call__ #? int() JustAClass().a() #? ['__call__'] JustAClass.a.__call__ #? int() JustAClass.a() # ----------------- # illegal decorators # ----------------- class DecoratorWithoutCall(): def __init__(self, func): self.func = func @DecoratorWithoutCall def f(): return 1 # cannot be resolved - should be ignored @DecoratorWithoutCall(None) def g(): return 1 #? f() #? int() g() class X(): @str def x(self): pass def y(self): #? str() self.x #? self.x() def decorator_var_args(function, *args): return function(*args) @decorator_var_args def function_var_args(param): return param #? int() function_var_args(1) # ----------------- # method decorators # ----------------- def dec(f): def wrapper(s): return f(s) return wrapper class MethodDecorators(): _class_var = 1 def __init__(self): self._method_var = '' @dec def constant(self): return 1.0 @dec def class_var(self): return self._class_var @dec def method_var(self): return self._method_var #? float() MethodDecorators().constant() #? int() MethodDecorators().class_var() #? str() MethodDecorators().method_var() class Base(): @not_existing def __init__(self): pass @not_existing def b(self): return '' @dec def c(self): return 1 class MethodDecoratorDoesntExist(Base): """#272 github: combination of method decorators and super()""" def a(self): #? super().__init__() #? str() super().b() #? int() super().c() #? float() self.d() @doesnt_exist def d(self): return 1.0 # ----------------- # others # ----------------- def memoize(function): def wrapper(*args): if random.choice([0, 1]): pass else: rv = function(*args) return rv return wrapper @memoize def follow_statement(stmt): return stmt # here we had problems with the else clause, because the parent was not right. #? int() follow_statement(1) # ----------------- # class decorators # ----------------- # class decorators should just be ignored @should_ignore class A(): x = 3 def ret(self): return 1 #? int() A().ret() #? int() A().x # ----------------- # On decorator completions # ----------------- import abc #? ['abc'] @abc #? ['abstractmethod'] @abc.abstractmethod # ----------------- # Goto # ----------------- x = 1 #! 5 [] @x.foo() def f(): pass #! 1 ['x = 1'] @x.foo() def f(): pass ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/completion/descriptors.py0000664000175000017500000000653500000000000020454 0ustar00davedave00000000000000class RevealAccess(object): """ A data descriptor that sets and returns values normally and prints a message logging their access. """ def __init__(self, initval=None, name='var'): self.val = initval self.name = name def __get__(self, obj, objtype): print('Retrieving', self.name) return self.val def __set__(self, obj, val): print('Updating', self.name) self.val = val def just_a_method(self): pass class C(object): x = RevealAccess(10, 'var "x"') #? RevealAccess() x #? ['just_a_method'] x.just_a_method y = 5.0 def __init__(self): #? int() self.x #? [] self.just_a_method #? [] C.just_a_method m = C() #? int() m.x #? float() m.y #? int() C.x #? [] m.just_a_method #? [] C.just_a_method # ----------------- # properties # ----------------- class B(): @property def r(self): return 1 @r.setter def r(self, value): return '' def t(self): return '' p = property(t) #? [] B().r(). #? int() B().r #? str() B().p #? [] B().p(). class PropClass(): def __init__(self, a): self.a = a @property def ret(self): return self.a @ret.setter def ret(self, value): return 1.0 def ret2(self): return self.a ret2 = property(ret2) @property def nested(self): """ causes recusions in properties, should work """ return self.ret @property def nested2(self): """ causes recusions in properties, should not work """ return self.nested2 @property def join1(self): """ mutual recusion """ return self.join2 @property def join2(self): """ mutual recusion """ return self.join1 #? str() PropClass("").ret #? [] PropClass().ret. #? str() PropClass("").ret2 #? PropClass().ret2 #? int() PropClass(1).nested #? [] PropClass().nested. #? PropClass(1).nested2 #? [] PropClass().nested2. #? PropClass(1).join1 # ----------------- # staticmethod/classmethod # ----------------- class E(object): a = '' def __init__(self, a): self.a = a def f(x): return x f = staticmethod(f) #? f.__func @staticmethod def g(x): return x def s(cls, x): return x s = classmethod(s) @classmethod def t(cls, x): return x @classmethod def u(cls, x): return cls.a e = E(1) #? int() e.f(1) #? int() E.f(1) #? int() e.g(1) #? int() E.g(1) #? int() e.s(1) #? int() E.s(1) #? int() e.t(1) #? int() E.t(1) #? str() e.u(1) #? str() E.u(1) # ----------------- # Conditions # ----------------- from functools import partial class Memoize(): def __init__(self, func): self.func = func def __get__(self, obj, objtype): if obj is None: return self.func return partial(self, obj) def __call__(self, *args, **kwargs): # We don't do caching here, but that's what would normally happen. return self.func(*args, **kwargs) class MemoizeTest(): def __init__(self, x): self.x = x @Memoize def some_func(self): return self.x #? int() MemoizeTest(10).some_func() # Now also call the same function over the class (see if clause above). #? float() MemoizeTest.some_func(MemoizeTest(10.0)) ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/completion/django.py0000664000175000017500000001455100000000000017352 0ustar00davedave00000000000000import datetime import decimal import uuid from django.db import models from django.contrib.auth.models import User from django.db.models.query_utils import DeferredAttribute from django.db.models.manager import BaseManager class TagManager(models.Manager): def specially_filtered_tags(self): return self.all() class Tag(models.Model): tag_name = models.CharField() objects = TagManager() custom_objects = TagManager() class Category(models.Model): category_name = models.CharField() class AttachedData(models.Model): extra_data = models.TextField() class BusinessModel(models.Model): attached_o2o = models.OneToOneField(AttachedData) category_fk = models.ForeignKey(Category) category_fk2 = models.ForeignKey('Category') category_fk3 = models.ForeignKey(1) category_fk4 = models.ForeignKey('models') category_fk5 = models.ForeignKey() integer_field = models.IntegerField() big_integer_field = models.BigIntegerField() positive_integer_field = models.PositiveIntegerField() small_integer_field = models.SmallIntegerField() char_field = models.CharField() text_field = models.TextField() email_field = models.EmailField() ip_address_field = models.GenericIPAddressField() url_field = models.URLField() float_field = models.FloatField() binary_field = models.BinaryField() boolean_field = models.BooleanField() decimal_field = models.DecimalField() time_field = models.TimeField() duration_field = models.DurationField() date_field = models.DateField() date_time_field = models.DateTimeField() uuid_field = models.UUIDField() tags_m2m = models.ManyToManyField(Tag) unidentifiable = NOT_FOUND #? models.IntegerField() integer_field def method(self): return 42 # ----------------- # Model attribute inference # ----------------- #? DeferredAttribute() BusinessModel.integer_field #? DeferredAttribute() BusinessModel.tags_m2m #? DeferredAttribute() BusinessModel.email_field model_instance = BusinessModel() #? int() model_instance.integer_field #? int() model_instance.big_integer_field #? int() model_instance.positive_integer_field #? int() model_instance.small_integer_field #? str() model_instance.char_field #? str() model_instance.text_field #? str() model_instance.email_field #? str() model_instance.ip_address_field #? str() model_instance.url_field #? float() model_instance.float_field #? bytes() model_instance.binary_field #? bool() model_instance.boolean_field #? decimal.Decimal() model_instance.decimal_field #? datetime.time() model_instance.time_field #? datetime.timedelta() model_instance.duration_field #? datetime.date() model_instance.date_field #? datetime.datetime() model_instance.date_time_field #? uuid.UUID() model_instance.uuid_field #! ['attached_o2o = models.OneToOneField(AttachedData)'] model_instance.attached_o2o #! ['extra_data = models.TextField()'] model_instance.attached_o2o.extra_data #? AttachedData() model_instance.attached_o2o #? str() model_instance.attached_o2o.extra_data #! ['category_fk = models.ForeignKey(Category)'] model_instance.category_fk #! ['category_name = models.CharField()'] model_instance.category_fk.category_name #? Category() model_instance.category_fk #? str() model_instance.category_fk.category_name #? Category() model_instance.category_fk2 #? str() model_instance.category_fk2.category_name #? model_instance.category_fk3 #? model_instance.category_fk4 #? model_instance.category_fk5 #? models.manager.RelatedManager() model_instance.tags_m2m #? Tag() model_instance.tags_m2m.get() #? ['add'] model_instance.tags_m2m.add #? model_instance.unidentifiable #! ['unidentifiable = NOT_FOUND'] model_instance.unidentifiable #? int() model_instance.method() #! ['def method'] model_instance.method # ----------------- # Queries # ----------------- #? ['objects'] model_instance.object #? model_instance.objects #? model_instance.objects.filter #? models.query.QuerySet.filter BusinessModel.objects.filter #? BusinessModel() None BusinessModel.objects.filter().first() #? str() BusinessModel.objects.get().char_field #? int() BusinessModel.objects.update(x='') #? BusinessModel() BusinessModel.objects.create() # ----------------- # Custom object manager # ----------------- #? TagManager() Tag.objects #? Tag() None Tag.objects.filter().first() #? TagManager() Tag.custom_objects #? Tag() None Tag.custom_objects.filter().first() # ----------------- # Inheritance # ----------------- class Inherited(BusinessModel): text_field = models.IntegerField() new_field = models.FloatField() inherited = Inherited() #? int() inherited.text_field #? str() inherited.char_field #? float() inherited.new_field #? Inherited.category_fk2.category_name #? str() inherited.category_fk2.category_name #? str() Inherited.objects.get().char_field #? int() Inherited.objects.get().text_field #? float() Inherited.objects.get().new_field # ----------------- # Model methods # ----------------- #? ['from_db'] Inherited.from_db #? ['validate_unique'] Inherited.validate_uniqu #? ['validate_unique'] Inherited().validate_unique # ----------------- # Django Auth # ----------------- #? str() User().email #? str() User.objects.get().email # ----------------- # values & values_list (dave is too lazy to implement it) # ----------------- #? BusinessModel.objects.values_list('char_field')[0] #? dict() BusinessModel.objects.values('char_field')[0] #? BusinessModel.objects.values('char_field')[0]['char_field'] # ----------------- # Completion # ----------------- #? 19 ['text_field='] Inherited(text_fiel) #? 18 ['new_field='] Inherited(new_fiel) #? 19 ['char_field='] Inherited(char_fiel) #? 19 ['email_field='] Inherited(email_fie) #? 19 [] Inherited(unidentif) #? 21 ['category_fk=', 'category_fk2=', 'category_fk3=', 'category_fk4=', 'category_fk5='] Inherited(category_fk) #? 21 ['attached_o2o='] Inherited(attached_o2) #? 18 ['tags_m2m='] Inherited(tags_m2m) #? 32 ['tags_m2m='] Inherited.objects.create(tags_m2) #? 32 ['tags_m2m='] Inherited.objects.filter(tags_m2) #? 35 ['char_field='] Inherited.objects.exclude(char_fiel) #? 34 ['char_field='] Inherited.objects.update(char_fiel) #? 32 ['email_field='] Inherited.objects.get(email_fiel) #? 44 ['category_fk2='] Inherited.objects.get_or_create(category_fk2) #? 44 ['uuid_field='] Inherited.objects.update_or_create(uuid_fiel) #? 48 ['char_field='] Inherited.objects.exclude(pk=3).filter(char_fiel) ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/completion/docstring.py0000664000175000017500000001127200000000000020101 0ustar00davedave00000000000000""" Test docstrings in functions and classes, which are used to infer types """ # ----------------- # sphinx style # ----------------- def sphinxy(a, b, c, d, x): """ asdfasdf :param a: blablabla :type a: str :type b: (str, int) :type c: random.Random :type d: :class:`random.Random` :param str x: blablabla :rtype: dict """ #? str() a #? str() b[0] #? int() b[1] #? ['seed'] c.seed #? ['seed'] d.seed #? ['lower'] x.lower #? dict() sphinxy() # wrong declarations def sphinxy2(a, b, x, y, z): """ :param a: Forgot type declaration :type a: :param b: Just something :type b: `` :param x: Just something without type :param y: A function :type y: def l(): pass :param z: A keyword :type z: return :rtype: """ #? a #? b #? x #? y #? z #? sphinxy2() def sphinxy_param_type_wrapped(a): """ :param str a: Some description wrapped onto the next line with no space after the colon. """ #? str() a # local classes -> github #370 class ProgramNode(): pass def local_classes(node, node2): """ :type node: ProgramNode ... and the class definition after this func definition: :type node2: ProgramNode2 """ #? ProgramNode() node #? ProgramNode2() node2 class ProgramNode2(): pass def list_with_non_imports(lst): """ Should be able to work with tuples and lists and still import stuff. :type lst: (random.Random, [collections.defaultdict, ...]) """ #? ['seed'] lst[0].seed import collections as col # use some weird index #? col.defaultdict() lst[1][10] def two_dots(a): """ :type a: json.decoder.JSONDecoder """ #? ['raw_decode'] a.raw_decode # sphinx returns def return_module_object(): """ :rtype: :class:`random.Random` """ #? ['seed'] return_module_object().seed # ----------------- # epydoc style # ----------------- def epydoc(a, b): """ asdfasdf @type a: str @param a: blablabla @type b: (str, int) @param b: blablah @rtype: list """ #? str() a #? str() b[0] #? int() b[1] #? list() epydoc() # Returns with param type only def rparam(a,b): """ @type a: str """ return a #? str() rparam() # Composite types def composite(): """ @rtype: (str, int, dict) """ x, y, z = composite() #? str() x #? int() y #? dict() z # Both docstring and calculated return type def both(): """ @rtype: str """ return 23 #? str() int() both() class Test(object): def __init__(self): self.teststr = "" """ # jedi issue #210 """ def test(self): #? ['teststr'] self.teststr # ----------------- # statement docstrings # ----------------- d = '' """ bsdf """ #? str() d.upper() # ----------------- # class docstrings # ----------------- class InInit(): def __init__(self, foo): """ :type foo: str """ #? str() foo class InClass(): """ :type foo: str """ def __init__(self, foo): #? str() foo class InBoth(): """ :type foo: str """ def __init__(self, foo): """ :type foo: int """ #? str() int() foo def __init__(foo): """ :type foo: str """ #? str() foo # ----------------- # Renamed imports (#507) # ----------------- import datetime from datetime import datetime as datetime_imported def import_issues(foo): """ @type foo: datetime_imported """ #? datetime.datetime() foo # ----------------- # Doctest completions # ----------------- def doctest_with_gt(): """ x >>> somewhere_in_docstring = 3 #? ['import_issues'] >>> import_issu #? ['somewhere_in_docstring'] >>> somewhere_ blabla >>> haha = 3 #? ['haha'] >>> hah #? ['doctest_with_space'] >>> doctest_with_sp """ def doctest_with_space(): """ x #? ['import_issues'] import_issu """ def doctest_issue_github_1748(): """From GitHub #1748 #? 10 [] This. Al """ pass def docstring_rst_identifiers(): """ #? 30 ['import_issues'] hello I'm here `import_iss` blabla #? ['import_issues'] hello I'm here `import_iss #? [] hello I'm here import_iss #? [] hello I'm here ` import_iss #? ['upper'] hello I'm here `str.upp """ def doctest_without_ending(): """ #? [] import_issu ha no_ending = False #? ['import_issues'] import_issu #? ['no_ending'] no_endin ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/completion/dynamic_arrays.py0000664000175000017500000001257200000000000021116 0ustar00davedave00000000000000""" Checking for ``list.append`` and all the other possible array modifications. """ # ----------------- # list.append # ----------------- arr = [] for a in [1,2]: arr.append(a); arr.append # should not cause an exception arr.append() # should not cause an exception #? int() arr[10] arr = [tuple()] for a in [1,2]: arr.append(a); #? int() tuple() arr[10] #? int() arr[10].index() arr = list([]) arr.append(1) #? int() arr[0] # ----------------- # list.insert # ----------------- arr = [""] arr.insert(0, 1.0) # on exception due to this, please! arr.insert(0) arr.insert() #? float() str() arr[10] for a in arr: #? float() str() a #? float() str() list(arr)[10] # ----------------- # list.extend / set.update # ----------------- arr = [1.0] arr.extend([1,2,3]) arr.extend([]) arr.extend("") arr.extend(list) # should ignore #? float() int() str() arr[100] a = set(arr) a.update(list(["", 1])) #? float() int() str() list(a)[0] # ----------------- # set/list initialized as functions # ----------------- st = set() st.add(1) #? int() for s in st: s lst = list() lst.append(1) #? int() for i in lst: i # ----------------- # renames / type changes # ----------------- arr = [] arr2 = arr arr2.append('') #? str() arr2[0] lst = [1] lst.append(1.0) s = set(lst) s.add("ahh") lst = list(s) lst.append({}) #? dict() int() float() str() lst[0] # should work with tuple conversion, too. #? dict() int() float() str() tuple(lst)[0] # but not with an iterator #? iter(lst)[0] # ----------------- # complex including += # ----------------- class C(): pass class D(): pass class E(): pass lst = [1] lst.append(1.0) lst += [C()] s = set(lst) s.add("") s += [D()] lst = list(s) lst.append({}) lst += [E()] #? dict() int() float() str() C() D() E() lst[0] # ----------------- # functions # ----------------- def arr_append(arr4, a): arr4.append(a) def add_to_arr(arr2, a): arr2.append(a) return arr2 def app(a): arr3.append(a) arr3 = [1.0] res = add_to_arr(arr3, 1) arr_append(arr3, 'str') app(set()) #? float() str() int() set() arr3[10] #? float() str() int() set() res[10] # ----------------- # returns, special because the module dicts are not correct here. # ----------------- def blub(): a = [] a.append(1.0) #? float() a[0] return a #? float() blub()[0] # list with default def blub(): a = list([1]) a.append(1.0) return a #? int() float() blub()[0] # empty list def blub(): a = list() a.append(1.0) return a #? float() blub()[0] # with if def blub(): if 1: a = [] a.append(1.0) return a #? float() blub()[0] # with else clause def blub(): if random.choice([0, 1]): 1 else: a = [] a.append(1) return a #? int() blub()[0] # ----------------- # returns, the same for classes # ----------------- class C(): def blub(self, b): if 1: a = [] a.append(b) return a def blub2(self): """ mapper function """ a = self.blub(1.0) #? float() a[0] return a def literal_arr(self, el): self.a = [] self.a.append(el) #? int() self.a[0] return self.a def list_arr(self, el): self.b = list([]) self.b.append(el) #? float() self.b[0] return self.b #? int() C().blub(1)[0] #? float() C().blub2(1)[0] #? int() C().a[0] #? int() C().literal_arr(1)[0] #? float() C().b[0] #? float() C().list_arr(1.0)[0] # ----------------- # array recursions # ----------------- a = set([1.0]) a.update(a) a.update([1]) #? float() int() list(a)[0] def first(a): b = [] b.append(a) b.extend(second(a)) return list(b) def second(a): b = [] b.extend(first(a)) return list(b) #? float() first(1.0)[0] def third(): b = [] b.extend extend() b.extend(first()) return list(b) #? third()[0] # ----------------- # set.add # ----------------- st = {1.0} for a in [1,2]: st.add(a) st.append('') # lists should not have an influence st.add # should not cause an exception st.add() st = {1.0} st.add(1) lst = list(st) lst.append('') #? float() int() str() lst[0] # ----------------- # list setitem # ----------------- some_lst = [int] some_lst[3] = str #? int some_lst[0] #? str some_lst[3] #? int str some_lst[2] some_lst[0] = tuple #? tuple some_lst[0] #? int str tuple some_lst[1] some_lst2 = list([1]) some_lst2[3] = '' #? int() str() some_lst2[0] #? str() some_lst2[3] #? int() str() some_lst2[2] some_lst3 = [] some_lst3[0] = 3 some_lst3[:] = '' # Is ignored for now. #? int() some_lst3[0] # ----------------- # set setitem/other modifications (should not work) # ----------------- some_set = {int} some_set[3] = str #? int some_set[0] #? int some_set[3] something = object() something[3] = str #? something[0] #? something[3] # ----------------- # dict setitem # ----------------- some_dct = {'a': float, 1: int} some_dct['x'] = list some_dct['y'] = tuple #? list some_dct['x'] #? int float list tuple some_dct['unknown'] #? float some_dct['a'] some_dct = dict({'a': 1, 1: ''}) #? int() str() some_dct['la'] #? int() some_dct['a'] some_dct['x'] = list some_dct['y'] = tuple #? list some_dct['x'] #? int() str() list tuple some_dct['unknown'] k = 'a' #? int() some_dct[k] some_other_dct = dict(some_dct, c=set) #? int() some_other_dct['a'] #? list some_other_dct['x'] #? set some_other_dct['c'] ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/completion/dynamic_params.py0000664000175000017500000000422700000000000021076 0ustar00davedave00000000000000""" This is used for dynamic object completion. Jedi tries to guess param types with a backtracking approach. """ def func(a, default_arg=2): #? int() default_arg #? int() str() return a #? int() func(1) func int(1) + (int(2))+ func('') # Again the same function, but with another call. def func(a): #? float() return a func(1.0) # Again the same function, but with no call. def func(a): #? return a def func(a): #? float() return a str(func(1.0)) # ----------------- # *args, **args # ----------------- def arg(*args): #? tuple() args #? int() args[0] arg(1,"") # ----------------- # decorators # ----------------- def def_func(f): def wrapper(*args, **kwargs): return f(*args, **kwargs) return wrapper @def_func def func(c): #? str() return c #? str() func("something") @def_func def func(c=1): #? float() return c func(1.0) def tricky_decorator(func): def wrapper(*args): return func(1, *args) return wrapper @tricky_decorator def func(a, b): #? int() a #? float() b func(1.0) # Needs to be here, because in this case func is an import -> shouldn't lead to # exceptions. import sys as func func.sys # ----------------- # classes # ----------------- class A(): def __init__(self, a): #? str() a A("s") class A(): def __init__(self, a): #? int() a self.a = a def test(self, a): #? float() a self.c = self.test2() def test2(self): #? int() return self.a def test3(self): #? int() self.test2() #? int() self.c A(3).test(2.0) A(3).test2() def from_class(x): #? x from UNDEFINED import from_class class Foo(from_class(1),): pass # ----------------- # comprehensions # ----------------- def from_comprehension(foo): #? int() float() return foo [from_comprehension(1.0) for n in (1,)] [from_comprehension(n) for n in (1,)] # ----------------- # lambdas # ----------------- #? int() x_lambda = lambda x: x x_lambda(1) class X(): #? str() x_method = lambda self, a: a X().x_method('') ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/completion/flow_analysis.py0000664000175000017500000001025200000000000020754 0ustar00davedave00000000000000# ----------------- # First a few name resolution things # ----------------- x = 3 if NOT_DEFINED: x = '' #? 6 int() elif x: pass else: #? int() x x = 1 try: x = '' #? 8 int() str() except x: #? 5 int() str() x x = 1.0 else: #? 5 int() str() x x = list finally: #? 5 int() str() float() list x x = tuple if False: with open("") as defined_in_false: #? ['flush'] defined_in_false.flu # ----------------- # Return checks # ----------------- def foo(x): if 1.0: return 1 else: return '' #? int() foo(1) # Exceptions are not analyzed. So check both if branches def try_except(x): try: if 0: return 1 else: return '' except AttributeError: return 1.0 #? float() str() try_except(1) # Exceptions are not analyzed. So check both if branches def try_except(x): try: if 0: return 1 else: return '' except AttributeError: return 1.0 #? float() str() try_except(1) def test_function(): a = int(input()) if a % 2 == 0: return True return "False" #? bool() str() test_function() # ----------------- # elif # ----------------- def elif_flows1(x): if False: return 1 elif True: return 1.0 else: return '' #? float() elif_flows1(1) def elif_flows2(x): try: if False: return 1 elif 0: return 1.0 else: return '' except ValueError: return set #? str() set elif_flows2(1) def elif_flows3(x): try: if True: return 1 elif 0: return 1.0 else: return '' except ValueError: return set #? int() set elif_flows3(1) # ----------------- # mid-difficulty if statements # ----------------- def check(a): if a is None: return 1 return '' return set #? int() check(None) #? str() check('asb') a = list if 2 == True: a = set elif 1 == True: a = 0 #? int() a if check != 1: a = '' #? int() str() a if check == check: a = list #? list a if check != check: a = set else: a = dict #? dict a if not (check is not check): a = 1 #? int() a # ----------------- # name resolution # ----------------- a = list def elif_name(x): try: if True: a = 1 elif 0: a = 1.0 else: return '' except ValueError: a = x return a #? int() set elif_name(set) if 0: a = '' else: a = int #? int a # ----------------- # isinstance # ----------------- class A(): pass def isinst(x): if isinstance(x, A): return dict elif isinstance(x, int) and x == 1 or x is True: return set elif isinstance(x, (float, reversed)): return list elif not isinstance(x, str): return tuple return 1 #? dict isinst(A()) #? set isinst(True) #? set isinst(1) #? tuple isinst(2) #? list isinst(1.0) #? tuple isinst(False) #? int() isinst('') # ----------------- # flows that are not reachable should be able to access parent scopes. # ----------------- foobar = '' if 0: within_flow = 1.0 #? float() within_flow #? str() foobar if 0: nested = 1 #? int() nested #? float() within_flow #? str() foobar #? nested if False: in_false = 1 #? ['in_false'] in_false # ----------------- # True objects like modules # ----------------- class X(): pass if X: a = 1 else: a = '' #? int() a # ----------------- # Recursion issues # ----------------- def possible_recursion_error(filename): if filename == 'a': return filename # It seems like without the brackets there wouldn't be a RecursionError. elif type(filename) == str: return filename if NOT_DEFINED: s = str() else: s = str() #? str() possible_recursion_error(s) # ----------------- # In combination with imports # ----------------- from import_tree import flow_import if 1 == flow_import.env: a = 1 elif 2 == flow_import.env: a = '' elif 3 == flow_import.env: a = 1.0 #? int() str() a ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/completion/fstring.py0000664000175000017500000000054700000000000017564 0ustar00davedave00000000000000class Foo: bar = 1 #? 10 int() f'{Foo.bar}' #? 10 ['bar'] f'{Foo.bar}' #? 10 int() Fr'{Foo.bar' #? 10 ['bar'] Fr'{Foo.bar' #? int() Fr'{Foo.bar #? ['bar'] Fr'{Foo.bar #? ['Exception'] F"{Excepti #? 8 Foo Fr'a{Foo.bar' #? str() Fr'sasdf' #? 7 str() Fr'''sasdf''' + '' #? ['upper'] f'xyz'.uppe #? 3 [] f'f' # Github #1248 #? int() {"foo": 1}[f"foo"] ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/completion/functions.py0000664000175000017500000001555600000000000020126 0ustar00davedave00000000000000def x(): return #? None x() def array(first_param): #? ['first_param'] first_param return list() #? [] array.first_param #? [] array.first_param. func = array #? [] func.first_param #? list() array() #? ['array'] arr def inputs(param): return param #? list inputs(list) def variable_middle(): var = 3 return var #? int() variable_middle() def variable_rename(param): var = param return var #? int() variable_rename(1) def multi_line_func(a, # comment blabla b): return b #? str() multi_line_func(1,'') def multi_line_call(b): return b multi_line_call( #? int() b=1) # nothing after comma def asdf(a): return a x = asdf(a=1, ) #? int() x # ----------------- # double execution # ----------------- def double_exe(param): return param #? str() variable_rename(double_exe)("") # -> shouldn't work (and throw no error) #? [] variable_rename(list())(). #? [] variable_rename(1)(). # ----------------- # recursions (should ignore) # ----------------- def recursion(a, b): if a: return b else: return recursion(a+".", b+1) # Does not also return int anymore, because we now support operators in simple cases. #? float() recursion("a", 1.0) def other(a): return recursion2(a) def recursion2(a): if random.choice([0, 1]): return other(a) else: if random.choice([0, 1]): return recursion2("") else: return a #? int() str() recursion2(1) # ----------------- # ordering # ----------------- def a(): #? int() b() return b() def b(): return 1 #? int() a() # ----------------- # keyword arguments # ----------------- def func(a=1, b=''): return a, b exe = func(b=list, a=tuple) #? tuple exe[0] #? list exe[1] # ----------------- # default arguments # ----------------- #? int() func()[0] #? str() func()[1] #? float() func(1.0)[0] #? str() func(1.0)[1] #? float() func(a=1.0)[0] #? str() func(a=1.0)[1] #? int() func(b=1.0)[0] #? float() func(b=1.0)[1] #? list func(a=list, b=set)[0] #? set func(a=list, b=set)[1] def func_default(a, b=1): return a, b def nested_default(**kwargs): return func_default(**kwargs) #? float() nested_default(a=1.0)[0] #? int() nested_default(a=1.0)[1] #? str() nested_default(a=1.0, b='')[1] # Defaults should only work if they are defined before - not after. def default_function(a=default): #? return a #? default_function() default = int() def default_function(a=default): #? int() return a #? int() default_function() def default(a=default): #? int() a # ----------------- # closures # ----------------- def a(): l = 3 def func_b(): l = '' #? str() l #? ['func_b'] func_b #? int() l # ----------------- # *args # ----------------- def args_func(*args): #? tuple() return args exe = args_func(1, "") #? int() exe[0] #? str() exe[1] # illegal args (TypeError) #? args_func(*1)[0] # iterator #? int() args_func(*iter([1]))[0] # different types e = args_func(*[1 if UNDEFINED else "", {}]) #? int() str() e[0] #? dict() e[1] _list = [1,""] exe2 = args_func(_list)[0] #? str() exe2[1] exe3 = args_func([1,""])[0] #? str() exe3[1] def args_func(arg1, *args): return arg1, args exe = args_func(1, "", list) #? int() exe[0] #? tuple() exe[1] #? list exe[1][1] # In a dynamic search, both inputs should be given. def simple(a): #? int() str() return a def xargs(*args): return simple(*args) xargs(1) xargs('') # *args without a self symbol def memoize(func): def wrapper(*args, **kwargs): return func(*args, **kwargs) return wrapper class Something(): @memoize def x(self, a, b=1): return a #? int() Something().x(1) # ----------------- # ** kwargs # ----------------- def kwargs_func(**kwargs): #? ['keys'] kwargs.keys #? dict() return kwargs exe = kwargs_func(a=3,b=4.0) #? dict() exe #? int() exe['a'] #? float() exe['b'] #? int() float() exe['c'] a = 'a' exe2 = kwargs_func(**{a:3, 'b':4.0}) #? int() exe2['a'] #? float() exe2['b'] #? int() float() exe2['c'] exe3 = kwargs_func(**{k: v for k, v in [(a, 3), ('b', 4.0)]}) # Should resolve to the same as 2 but jedi is not smart enough yet # Here to make sure it doesn't result in crash though #? exe3['a'] #? exe3['b'] #? exe3['c'] # ----------------- # *args / ** kwargs # ----------------- def func_without_call(*args, **kwargs): #? tuple() args #? dict() kwargs def fu(a=1, b="", *args, **kwargs): return a, b, args, kwargs exe = fu(list, 1, "", c=set, d="") #? list exe[0] #? int() exe[1] #? tuple() exe[2] #? str() exe[2][0] #? dict() exe[3] #? set exe[3]['c'] def kwargs_iteration(**kwargs): return kwargs for x in kwargs_iteration(d=3): #? float() {'d': 1.0, 'c': '1'}[x] # ----------------- # nested *args # ----------------- def function_args(a, b, c): return b def nested_args(*args): return function_args(*args) def nested_args2(*args, **kwargs): return nested_args(*args) #? int() nested_args('', 1, 1.0, list) #? [] nested_args(''). #? int() nested_args2('', 1, 1.0) #? [] nested_args2(''). # ----------------- # nested **kwargs # ----------------- def nested_kw(**kwargs1): return function_args(**kwargs1) def nested_kw2(**kwargs2): return nested_kw(**kwargs2) # invalid command, doesn't need to return anything #? nested_kw(b=1, c=1.0, list) #? int() nested_kw(b=1) # invalid command, doesn't need to return anything #? nested_kw(d=1.0, b=1, list) #? int() nested_kw(a=3.0, b=1) #? int() nested_kw(b=1, a=r"") #? [] nested_kw(1, ''). #? [] nested_kw(a=''). #? int() nested_kw2(b=1) #? int() nested_kw2(b=1, c=1.0) #? int() nested_kw2(c=1.0, b=1) #? [] nested_kw2(''). #? [] nested_kw2(a=''). #? [] nested_kw2('', b=1). # ----------------- # nested *args/**kwargs # ----------------- def nested_both(*args, **kwargs): return function_args(*args, **kwargs) def nested_both2(*args, **kwargs): return nested_both(*args, **kwargs) # invalid commands, may return whatever. #? list nested_both('', b=1, c=1.0, list) #? list nested_both('', c=1.0, b=1, list) #? [] nested_both(''). #? int() nested_both2('', b=1, c=1.0) #? int() nested_both2('', c=1.0, b=1) #? [] nested_both2(''). # ----------------- # nested *args/**kwargs with a default arg # ----------------- def function_def(a, b, c): return a, b def nested_def(a, *args, **kwargs): return function_def(a, *args, **kwargs) def nested_def2(*args, **kwargs): return nested_def(*args, **kwargs) #? str() nested_def2('', 1, 1.0)[0] #? str() nested_def2('', b=1, c=1.0)[0] #? str() nested_def2('', c=1.0, b=1)[0] #? int() nested_def2('', 1, 1.0)[1] #? int() nested_def2('', b=1, c=1.0)[1] #? int() nested_def2('', c=1.0, b=1)[1] #? [] nested_def2('')[1]. # ----------------- # magic methods # ----------------- def a(): pass #? ['__closure__'] a.__closure__ ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/completion/generators.py0000664000175000017500000000766300000000000020267 0ustar00davedave00000000000000# ----------------- # yield statement # ----------------- def gen(): if random.choice([0, 1]): yield 1 else: yield "" gen_exe = gen() #? int() str() next(gen_exe) #? int() str() list next(gen_exe, list) def gen_ret(value): yield value #? int() next(gen_ret(1)) #? [] next(gen_ret()). # generators infer to true if cast by bool. a = '' if gen_ret(): a = 3 #? int() a # ----------------- # generators should not be indexable # ----------------- def get(param): if random.choice([0, 1]): yield 1 else: yield "" #? [] get()[0]. # ----------------- # __iter__ # ----------------- for a in get(): #? int() str() a class Get(): def __iter__(self): if random.choice([0, 1]): yield 1 else: yield "" b = [] for a in Get(): #? int() str() a b += [a] #? list() b #? int() str() b[0] g = iter(Get()) #? int() str() next(g) g = iter([1.0]) #? float() next(g) x, y = Get() #? int() str() x #? int() str() x class Iter: def __iter__(self): yield "" i = 0 while True: v = 1 yield v i += 1 a, b, c = Iter() #? str() int() a #? str() int() b #? str() int() c # ----------------- # __next__ # ----------------- class Counter: def __init__(self, low, high): self.current = low self.high = high def __iter__(self): return self def next(self): """ need to have both __next__ and next, because of py2/3 testing """ return self.__next__() def __next__(self): if self.current > self.high: raise StopIteration else: self.current += 1 return self.current - 1 for c in Counter(3, 8): #? int() print c # ----------------- # tuple assignments # ----------------- def gen(): if random.choice([0,1]): yield 1, "" else: yield 2, 1.0 a, b = next(gen()) #? int() a #? str() float() b def simple(): if random.choice([0, 1]): yield 1 else: yield "" a, b = simple() #? int() str() a # For now this is ok. #? int() str() b def simple2(): yield 1 yield "" a, b = simple2() #? int() a #? str() b a, = (a for a in [1]) #? int() a # ----------------- # More complicated access # ----------------- # `close` is a method wrapper. #? ['__call__'] gen().close.__call__ #? gen().throw() #? ['co_consts'] gen().gi_code.co_consts #? [] gen.gi_code.co_consts # `send` is also a method wrapper. #? ['__call__'] gen().send.__call__ #? tuple() gen().send() #? gen()() # ----------------- # empty yield # ----------------- def x(): yield #? None next(x()) #? gen() x() def x(): for i in range(3): yield #? None next(x()) # ----------------- # yield in expression # ----------------- def x(): a= [(yield 1)] #? int() next(x()) # ----------------- # statements # ----------------- def x(): foo = yield #? foo # ----------------- # yield from # ----------------- def yield_from(): yield from iter([1]) #? int() next(yield_from()) def yield_from_multiple(): yield from iter([1]) yield str() return 2.0 x, y = yield_from_multiple() #? int() x #? str() y def test_nested(): x = yield from yield_from_multiple() #? float() x yield x x, y, z = test_nested() #? int() x #? str() y # For whatever reason this is currently empty #? float() z def test_in_brackets(): x = 1 + (yield from yield_from_multiple()) #? float() x generator = (1 for 1 in [1]) x = yield from generator #? None x x = yield from 1 #? x x = yield from [1] #? None x # ----------------- # Annotations # ----------------- from typing import Iterator def annotation1() -> float: yield 1 def annotation2() -> Iterator[float]: yield 1 #? next(annotation1()) #? float() next(annotation2()) # annotations should override generator inference #? float() annotation1() ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/completion/goto.py0000664000175000017500000000664200000000000017062 0ustar00davedave00000000000000# goto command tests are different in syntax definition = 3 #! 0 ['a = definition'] a = definition #! [] b #! ['a = definition'] a b = a c = b #! ['c = b'] c cd = 1 #! 1 ['cd = c'] cd = c #! 0 ['cd = e'] cd = e #! ['module math'] import math #! ['module math'] math #! ['module math'] b = math #! ['b = math'] b #! 18 ['foo = 10'] foo = 10;print(foo) # ----------------- # classes # ----------------- class C(object): x = 3 def b(self): #! ['b = math'] b #! ['def b'] self.b #! 14 ['def b'] self.b() #! 14 ['def b'] self.b. #! 11 ['param self'] self.b #! ['x = 3'] self.x #! 14 ['x = 3'] self.x. return 1 #! ['def b'] b #! ['b = math'] b #! ['def b'] C.b #! ['def b'] C().b #! 0 ['class C'] C().b #! 0 ['class C'] C().b D = C #! ['def b'] D.b #! ['def b'] D().b #! 0 ['D = C'] D().b #! 0 ['D = C'] D().b def c(): return '' #! ['def c'] c #! 0 ['def c'] c() class ClassVar(): x = 3 #! ['x = 3'] ClassVar.x #! ['x = 3'] ClassVar().x # before assignments #! 10 ['x = 3'] ClassVar.x = '' #! 12 ['x = 3'] ClassVar().x = '' # Recurring use of the same var name, github #315 def f(t=None): #! 9 ['param t=None'] t = t or 1 class X(): pass #! 3 [] X(foo=x) # Multiple inheritance class Foo: def foo(self): print("foo") class Bar: def bar(self): print("bar") class Baz(Foo, Bar): def baz(self): #! ['def foo'] super().foo #! ['def bar'] super().bar #! ['instance Foo'] super() # ----------------- # imports # ----------------- #! ['module import_tree'] import import_tree #! ["a = ''"] import_tree.a #! ['module mod1'] import import_tree.mod1 #! ['module mod1'] from import_tree.mod1 #! ['a = 1'] import_tree.mod1.a #! ['module pkg'] import import_tree.pkg #! ['a = list'] import_tree.pkg.a #! ['module mod1'] import import_tree.pkg.mod1 #! ['a = 1.0'] import_tree.pkg.mod1.a #! ["a = ''"] import_tree.a #! ['module mod1'] from import_tree.pkg import mod1 #! ['a = 1.0'] mod1.a #! ['module mod1'] from import_tree import mod1 #! ['a = 1'] mod1.a #! ['a = 1.0'] from import_tree.pkg.mod1 import a #! ['module os'] from .imports import os #! ['some_variable = 1'] from . import some_variable # ----------------- # anonymous classes # ----------------- def func(): class A(): def b(self): return 1 return A() #! 8 ['def b'] func().b() # ----------------- # on itself # ----------------- #! 7 ['class ClassDef'] class ClassDef(): """ abc """ pass # ----------------- # params # ----------------- param = ClassDef #! 8 ['param param'] def ab1(param): pass #! 9 ['param param'] def ab2(param): pass #! 11 ['param = ClassDef'] def ab3(a=param): pass ab1(ClassDef);ab2(ClassDef);ab3(ClassDef) # ----------------- # for loops # ----------------- for i in range(1): #! ['for i in range(1): i'] i for key, value in [(1,2)]: #! ['for key, value in [(1,2)]: key'] key #! 4 ['for y in [1]: y'] for y in [1]: #! ['for y in [1]: y'] y # ----------------- # decorator # ----------------- def dec(dec_param=3): pass #! 8 ['param dec_param=3'] @dec(dec_param=5) def y(): pass class ClassDec(): def class_func(func): return func #! 14 ['def class_func'] @ClassDec.class_func def x(): pass #! 2 ['class ClassDec'] @ClassDec.class_func def z(): pass ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4663794 jedi-0.19.1/test/completion/import_tree/0000775000175000017500000000000000000000000020061 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/completion/import_tree/__init__.py0000664000175000017500000000012000000000000022163 0ustar00davedave00000000000000a = '' from . import invisible_pkg the_pkg = invisible_pkg invisible_pkg = 1 ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/completion/import_tree/classes.py0000664000175000017500000000020300000000000022063 0ustar00davedave00000000000000blub = 1 class Config2(): pass class BaseClass(): mode = Config2() if isinstance(whaat, int): mode2 = whaat ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/completion/import_tree/flow_import.py0000664000175000017500000000004700000000000022775 0ustar00davedave00000000000000if name: env = 1 else: env = 2 ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/completion/import_tree/globals.py0000664000175000017500000000005600000000000022057 0ustar00davedave00000000000000 def something(): global foo foo = 3 ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/completion/import_tree/invisible_pkg.py0000664000175000017500000000030100000000000023252 0ustar00davedave00000000000000""" It should not be possible to import this pkg except for the import_tree itself, because it is overwritten there. (It would be possible with a sys.path modification, though). """ foo = 1.0 ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/completion/import_tree/mod1.py0000664000175000017500000000007500000000000021275 0ustar00davedave00000000000000a = 1 from import_tree.random import a as c foobarbaz = 3.0 ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/completion/import_tree/mod2.py0000664000175000017500000000003300000000000021270 0ustar00davedave00000000000000from . import mod1 as fake ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4663794 jedi-0.19.1/test/completion/import_tree/pkg/0000775000175000017500000000000000000000000020642 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/completion/import_tree/pkg/__init__.py0000664000175000017500000000003500000000000022751 0ustar00davedave00000000000000a = list from math import * ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/completion/import_tree/pkg/base.py0000664000175000017500000000005500000000000022126 0ustar00davedave00000000000000class MyBase: def f1(self): pass ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/completion/import_tree/pkg/mod1.py0000664000175000017500000000004500000000000022053 0ustar00davedave00000000000000a = 1.0 from ..random import foobar ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/completion/import_tree/random.py0000664000175000017500000000011200000000000021705 0ustar00davedave00000000000000""" Here because random is also a builtin module. """ a = set foobar = 0 ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/completion/import_tree/recurse_class1.py0000664000175000017500000000012700000000000023351 0ustar00davedave00000000000000from . import recurse_class2 class C(recurse_class2.C): def a(self): pass ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/completion/import_tree/recurse_class2.py0000664000175000017500000000010200000000000023343 0ustar00davedave00000000000000from . import recurse_class1 class C(recurse_class1.C): pass ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/completion/import_tree/references.py0000664000175000017500000000011000000000000022544 0ustar00davedave00000000000000from ..usages import usage_definition def x(): usage_definition() ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/completion/import_tree/rename1.py0000664000175000017500000000005100000000000021757 0ustar00davedave00000000000000""" used for renaming tests """ abc = 3 ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/completion/import_tree/rename2.py0000664000175000017500000000011300000000000021757 0ustar00davedave00000000000000""" used for renaming tests """ from import_tree.rename1 import abc abc ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/completion/imports.py0000664000175000017500000001271400000000000017604 0ustar00davedave00000000000000# ----------------- # own structure # ----------------- # do separate scopes def scope_basic(): from import_tree import mod1 #? int() mod1.a #? [] import_tree.a #? [] import_tree.mod1 import import_tree #? str() import_tree.a def scope_pkg(): import import_tree.mod1 #? str() import_tree.a #? ['mod1'] import_tree.mod1 #? int() import_tree.mod1.a def scope_nested(): import import_tree.pkg.mod1 #? str() import_tree.a #? list import_tree.pkg.a #? ['sqrt'] import_tree.pkg.sqrt #? ['pkg'] import_tree.p #? float() import_tree.pkg.mod1.a #? ['a', 'foobar', '__name__', '__package__', '__file__', '__doc__'] a = import_tree.pkg.mod1. import import_tree.random #? set import_tree.random.a def scope_nested2(): """Multiple modules should be indexable, if imported""" import import_tree.mod1 import import_tree.pkg #? ['mod1'] import_tree.mod1 #? ['pkg'] import_tree.pkg # With the latest changes this completion also works, because submodules # are always included (some nested import structures lead to this, # typically). #? ['rename1'] import_tree.rename1 def scope_from_import_variable(): """ All of them shouldn't work, because "fake" imports don't work in python without the use of ``sys.modules`` modifications (e.g. ``os.path`` see also github issue #213 for clarification. """ a = 3 #? from import_tree.mod2.fake import a #? from import_tree.mod2.fake import c #? a #? c def scope_from_import_variable_with_parenthesis(): from import_tree.mod2.fake import ( a, foobarbaz ) #? a #? foobarbaz # shouldn't complete, should still list the name though. #? ['foobarbaz'] foobarbaz def as_imports(): from import_tree.mod1 import a as xyz #? int() xyz import not_existant, import_tree.mod1 as foo #? int() foo.a import import_tree.mod1 as bar #? int() bar.a def broken_import(): import import_tree.mod1 #? import_tree.mod1 from import_tree.mod1 #? 25 import_tree.mod1 import import_tree.mod1. #? 25 import_tree.mod1 impo5t import_tree.mod1.foo #? 25 import_tree.mod1 import import_tree.mod1.foo. #? 31 import_tree.mod1 import json, import_tree.mod1.foo. # Cases with ; mod1 = 3 #? 25 int() import import_tree; mod1. #? 38 import_tree.mod1 import_tree; import import_tree.mod1. #! ['module json'] from json def test_import_priorities(): """ It's possible to overwrite import paths in an ``__init__.py`` file, by just assigining something there. See also #536. """ from import_tree import the_pkg, invisible_pkg #? int() invisible_pkg # In real Python, this would be the module, but it's not, because Jedi # doesn't care about most stateful issues such as __dict__, which it would # need to, to do this in a correct way. #? int() the_pkg # Importing foo is still possible, even though inivisible_pkg got changed. #? float() from import_tree.invisible_pkg import foo # ----------------- # std lib modules # ----------------- import tokenize #? ['tok_name'] tokenize.tok_name from pyclbr import * #? ['readmodule_ex'] readmodule_ex import os #? ['dirname'] os.path.dirname from os.path import ( expanduser ) #? os.path.expanduser expanduser from itertools import (tee, islice) #? ['islice'] islice from functools import (partial, wraps) #? ['wraps'] wraps from keyword import kwlist, \ iskeyword #? ['kwlist'] kwlist #? [] from keyword import not_existing1, not_existing2 from tokenize import io tokenize.generate_tokens import socket #? 14 ['SocketIO'] socket.SocketIO # ----------------- # builtins # ----------------- import sys #? ['prefix'] sys.prefix #? ['append'] sys.path.append from math import * #? ['cos', 'cosh'] cos def func_with_import(): import time return time #? ['sleep'] func_with_import().sleep # ----------------- # relative imports # ----------------- from .import_tree import mod1 #? int() mod1.a from ..import_tree import mod1 #? mod1.a from .......import_tree import mod1 #? mod1.a from .. import helpers #? int() helpers.sample_int from ..helpers import sample_int as f #? int() f from . import run #? [] run. from . import import_tree as imp_tree #? str() imp_tree.a from . import datetime as mod1 #? [] mod1. # self import # this can cause recursions from imports import * # ----------------- # packages # ----------------- from import_tree.mod1 import c #? set c from import_tree import recurse_class1 #? ['a'] recurse_class1.C.a # github #239 RecursionError #? ['a'] recurse_class1.C().a # ----------------- # Jedi debugging # ----------------- # memoizing issues (check git history for the fix) import not_existing_import if not_existing_import: a = not_existing_import else: a = not_existing_import #? a # ----------------- # module underscore descriptors # ----------------- def underscore(): import keyword #? ['__file__'] keyword.__file__ #? str() keyword.__file__ # Does that also work for our own module? #? ['__file__'] __file__ # ----------------- # complex relative imports #784 # ----------------- def relative(): #? ['foobar'] from import_tree.pkg.mod1 import foobar #? int() foobar return 1 ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/completion/inheritance.py0000664000175000017500000000251500000000000020376 0ustar00davedave00000000000000 class Super(object): attribute = 3 def func(self): return 1 class Inner(): pass class Sub(Super): #? 13 Sub.attribute def attribute(self): pass #! 8 ['attribute = 3'] def attribute(self): pass #! 4 ['def func'] func = 3 #! 12 ['def func'] class func(): pass #! 8 ['class Inner'] def Inner(self): pass # ----------------- # Finding self # ----------------- class Test1: class Test2: def __init__(self): self.foo_nested = 0 #? ['foo_nested'] self.foo_ #? self.foo_here def __init__(self, self2): self.foo_here = 3 #? ['foo_here', 'foo_in_func'] self.foo_ #? int() self.foo_here #? self.foo_nested #? self.foo_not_on_self #? float() self.foo_in_func self2.foo_on_second = '' def closure(): self.foo_in_func = 4. def bar(self): self = 3 self.foo_not_on_self = 3 class SubTest(Test1): def __init__(self): self.foo_sub_class = list def bar(self): #? ['foo_here', 'foo_in_func', 'foo_sub_class'] self.foo_ #? int() self.foo_here #? self.foo_nested #? self.foo_not_on_self ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/completion/invalid.py0000664000175000017500000000523600000000000017536 0ustar00davedave00000000000000""" This file is less about the results and much more about the fact, that no exception should be thrown. Basically this file could change depending on the current implementation. But there should never be any errors. """ # wait until keywords are out of definitions (pydoc function). #? 5 's'() #? [] str()).upper # ----------------- # funcs # ----------------- def asdf(a or b): # multiple param names return a #? asdf(2) asdf = '' from a import (b def blub(): return 0 def wrong_indents(): asdf = 3 asdf asdf( # TODO this seems to be wrong now? #? int() asdf def openbrace(): asdf = 3 asdf( #? int() asdf return 1 #? int() openbrace() blub([ #? int() openbrace() def indentfault(): asd( indentback #? [] indentfault(). def openbrace2(): asd( def normalfunc(): return 1 #? int() normalfunc() # dots in param def f(seq1...=None): return seq1 #? f(1) @ def test_empty_decorator(): return 1 #? int() test_empty_decorator() def invalid_param(param=): #? param # ----------------- # flows # ----------------- # first part not complete (raised errors) if a a else: #? ['AttributeError'] AttributeError try #? ['AttributeError'] except AttributeError pass finally: pass #? ['isinstance'] if isi try: except TypeError: #? str() str() def break(): pass # wrong ternary expression a = '' a = 1 if #? str() a # No completions for for loops without the right syntax for for_local in : for_local #? [] for_local #? for_local # ----------------- # list comprehensions # ----------------- a2 = [for a2 in [0]] #? a2[0] a3 = [for xyz in] #? a3[0] a3 = [a4 for in 'b'] #? a3[0] a3 = [a4 for a in for x in y] #? a3[0] a = [for a in def break(): pass #? str() a[0] a = [a for a in [1,2] def break(): pass #? str() a[0] #? [] int()).real # ----------------- # keywords # ----------------- #! [] as def empty_assert(): x = 3 assert #? int() x import datetime as # ----------------- # statements # ----------------- call = '' invalid = .call #? invalid invalid = call?.call #? str() invalid # comma invalid = ,call #? str() invalid # ----------------- # classes # ----------------- class BrokenPartsOfClass(): def foo(self): # This construct contains two places where Jedi with Python 3 can fail. # It should just ignore those constructs and still execute `bar`. pass if 2: try: pass except ValueError, e: raise TypeError, e else: pass def bar(self): self.x = 3 return '' #? str() BrokenPartsOfClass().bar() ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/completion/isinstance.py0000664000175000017500000000360000000000000020241 0ustar00davedave00000000000000if isinstance(i, str): #? str() i if isinstance(j, (str, int)): #? str() int() j while isinstance(k, (str, int)): #? str() int() k if not isinstance(k, (str, int)): #? k while not isinstance(k, (str, int)): #? k assert isinstance(ass, int) #? int() ass assert isinstance(ass, str) assert not isinstance(ass, int) if 2: #? str() ass # ----------------- # invalid arguments # ----------------- if isinstance(wrong, str()): #? wrong # ----------------- # in functions # ----------------- import datetime def fooooo(obj): if isinstance(obj, datetime.datetime): #? datetime.datetime() obj def fooooo2(obj): if isinstance(obj, datetime.date): return obj else: return 1 a # In earlier versions of Jedi, this returned both datetime and int, but now # Jedi does flow checks and realizes that the top return isn't executed. #? int() fooooo2('') def isinstance_func(arr): for value in arr: if isinstance(value, dict): # Shouldn't fail, even with the dot. #? 17 dict() value. elif isinstance(value, int): x = value #? int() x # ----------------- # Names with multiple indices. # ----------------- class Test(): def __init__(self, testing): if isinstance(testing, str): self.testing = testing else: self.testing = 10 def boo(self): if isinstance(self.testing, str): # TODO this is wrong, it should only be str. #? str() int() self.testing #? Test() self # ----------------- # Syntax # ----------------- #? isinstance(1, int()) # ----------------- # more complicated arguments # ----------------- def ayyyyyye(obj): if isinstance(obj.obj, str): #? obj.obj #? obj ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/completion/keywords.py0000664000175000017500000000107600000000000017755 0ustar00davedave00000000000000 #? ['raise'] raise #? ['Exception'] except #? [] b + continu #? [] b + continue #? ['continue'] b; continue #? ['continue'] b; continu #? [] c + pass #? [] a + pass #? ['pass'] b; pass # ----------------- # Keywords should not appear everywhere. # ----------------- #? [] with open() as f #? [] def i #? [] class i #? [] continue i # More syntax details, e.g. while only after newline, but not after semicolon, # continue also after semicolon #? ['while'] while #? [] x while #? [] x; while #? ['continue'] x; continue #? [] and #? ['and'] x and #? [] x * and ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/completion/lambdas.py0000664000175000017500000000345300000000000017512 0ustar00davedave00000000000000# ----------------- # lambdas # ----------------- a = lambda: 3 #? int() a() x = [] a = lambda x: x #? int() a(0) #? float() (lambda x: x)(3.0) arg_l = lambda x, y: y, x #? float() arg_l[0]('', 1.0) #? list() arg_l[1] arg_l = lambda x, y: (y, x) args = 1,"" result = arg_l(*args) #? tuple() result #? str() result[0] #? int() result[1] def with_lambda(callable_lambda, *args, **kwargs): return callable_lambda(1, *args, **kwargs) #? int() with_lambda(arg_l, 1.0)[1] #? float() with_lambda(arg_l, 1.0)[0] #? float() with_lambda(arg_l, y=1.0)[0] #? int() with_lambda(lambda x: x) #? float() with_lambda(lambda x, y: y, y=1.0) arg_func = lambda *args, **kwargs: (args[0], kwargs['a']) #? int() arg_func(1, 2, a='', b=10)[0] #? list() arg_func(1, 2, a=[], b=10)[1] # magic method a = lambda: 3 #? ['__closure__'] a.__closure__ class C(): def __init__(self, foo=1.0): self.a = lambda: 1 self.foo = foo def ret(self): return lambda: self.foo def with_param(self): return lambda x: x + self.a() lambd = lambda self: self.foo #? int() C().a() #? str() C('foo').ret()() index = C().with_param()(1) #? float() ['', 1, 1.0][index] #? float() C().lambd() #? int() C(1).lambd() def xy(param): def ret(a, b): return a + b return lambda b: ret(param, b) #? int() xy(1)(2) # ----------------- # lambda param (#379) # ----------------- class Test(object): def __init__(self, pred=lambda a, b: a): self.a = 1 #? int() self.a #? float() pred(1.0, 2) # ----------------- # test_nocond in grammar (happens in list comprehensions with `if`) # ----------------- # Doesn't need to do anything yet. It should just not raise an error. These # nocond lambdas make no sense at all. #? int() [a for a in [1,2] if (lambda: 3)][0] ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/completion/named_expression.py0000664000175000017500000000126100000000000021445 0ustar00davedave00000000000000# For assignment expressions / named expressions / walrus operators / whatever # they are called. # python >= 3.8 b = (a:=1, a) #? int() b[0] #? b[1] # Should not fail b = ('':=1,) #? int() b[0] def test_assignments(): match = '' #? str() match #? 8 int() if match := 1: #? int() match #? int() match def test_assignments2(): class Foo: match = '' #? str() Foo.match #? 13 int() if Foo.match := 1: #? str() Foo.match #? str() Foo.match #? y #? 16 str() if y := Foo.match: #? str() y #? str() y #? 8 str() if z := Foo.match: pass ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/completion/named_param.py0000664000175000017500000000375700000000000020362 0ustar00davedave00000000000000""" Named Params: >>> def a(abc): pass ... >>> a(abc=3) # <- this stuff (abc) """ def a(abc): pass #? 5 ['abc='] a(abc) def a(*some_args, **some_kwargs): pass #? 11 [] a(some_args) #? 13 [] a(some_kwargs) def multiple(foo, bar): pass #? 17 ['bar='] multiple(foo, bar) #? ['bar='] multiple(foo, bar my_lambda = lambda lambda_param: lambda_param + 1 #? 22 ['lambda_param='] my_lambda(lambda_param) # __call__ / __init__ class Test(object): def __init__(self, hello_other): pass def __call__(self, hello): pass def test(self, blub): pass #? 10 ['hello_other='] Test(hello=) #? 12 ['hello='] Test()(hello=) #? 11 [] Test()(self=) #? 16 [] Test().test(self=) #? 16 ['blub='] Test().test(blub=) # builtins #? 12 [] any(iterable=) def foo(xyz): pass #? 7 ['xyz='] @foo(xy) def x(): pass #? 7 ['xyz='] foo(xyz) # No completion should be possible if it's not a simple name #? 17 [] x = " "; foo(x.xyz) #? 17 [] x = " "; foo([xyz) #? 20 [] x = " "; foo(z[f,xyz) #? 18 [] x = " "; foo(z[xyz) #? 20 [] x = " "; foo(xyz[xyz) #? 20 [] x = " "; foo(xyz[(xyz) #? 8 ['xyz='] @foo(xyz) def x(): pass @str #? 8 ['xyz='] @foo(xyz) def x(): pass # ----------------- # Only keyword arguments are valid # ----------------- def x(bam, *, bar, baz): pass def y(bam, *bal, bar, baz, **bag): pass def z(bam, bar=2, *, bas=1): pass #? 7 ['bar=', 'baz='] x(1, ba) #? 14 ['baz='] x(1, bar=2, ba) #? 7 ['bar=', 'baz='] x(1, ba, baz=3) #? 14 ['baz='] x(1, bar=2, baz=3) #? 7 ['BaseException'] x(basee) #? 22 ['bar=', 'baz='] x(1, 2, 3, 4, 5, 6, bar=2) #? 14 ['baz='] y(1, bar=2, ba) #? 7 ['bar=', 'BaseException', 'baz='] y(1, ba, baz=3) #? 14 ['baz='] y(1, bar=2, baz=3) #? 7 ['BaseException'] y(basee) #? 22 ['bar=', 'BaseException', 'baz='] y(1, 2, 3, 4, 5, 6, bar=2) #? 11 ['bar=', 'bas='] z(bam=1, bar=2, bas=3) #? 8 ['BaseException', 'bas='] z(1, bas=2) #? 12 ['BaseException'] z(1, bas=bas) #? 19 ['dict'] z(1, bas=bas, **dic) #? 18 ['dict'] z(1, bas=bas, *dic) ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.3863792 jedi-0.19.1/test/completion/namespace1/0000775000175000017500000000000000000000000017545 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.3863792 jedi-0.19.1/test/completion/namespace1/pkg1/0000775000175000017500000000000000000000000020407 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4703794 jedi-0.19.1/test/completion/namespace1/pkg1/pkg2/0000775000175000017500000000000000000000000021252 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/completion/namespace1/pkg1/pkg2/mod1.py0000664000175000017500000000002300000000000022457 0ustar00davedave00000000000000mod1_name = 'mod1' ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.3863792 jedi-0.19.1/test/completion/namespace2/0000775000175000017500000000000000000000000017546 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.3863792 jedi-0.19.1/test/completion/namespace2/pkg1/0000775000175000017500000000000000000000000020410 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4703794 jedi-0.19.1/test/completion/namespace2/pkg1/pkg2/0000775000175000017500000000000000000000000021253 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/completion/namespace2/pkg1/pkg2/mod2.py0000664000175000017500000000002300000000000022461 0ustar00davedave00000000000000mod2_name = 'mod2' ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/completion/ns_path.py0000664000175000017500000000052200000000000017535 0ustar00davedave00000000000000import sys import os from os.path import dirname sys.path.insert(0, os.path.join(dirname(__file__), 'namespace2')) sys.path.insert(0, os.path.join(dirname(__file__), 'namespace1')) #? ['mod1'] import pkg1.pkg2.mod1 #? ['mod2'] import pkg1.pkg2.mod2 #? ['mod1_name'] pkg1.pkg2.mod1.mod1_name #? ['mod2_name'] pkg1.pkg2.mod2.mod2_name ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/completion/on_import.py0000664000175000017500000000424700000000000020117 0ustar00davedave00000000000000def from_names(): #? ['mod1', 'base'] from import_tree.pkg. #? ['path'] from os. def from_names_goto(): from import_tree import pkg #? pkg from import_tree.pkg def builtin_test(): #? ['math'] import math #? ['mmap'] import mmap # ----------------- # completions within imports # ----------------- #? ['sqlite3'] import sqlite3 # classes is a local module that has an __init__.py and can therefore not be # found. #? [] import classes #? ['timedelta'] from datetime import timedel #? 21 [] from datetime.timedel import timedel # should not be possible, because names can only be looked up 1 level deep. #? [] from datetime.timedelta import resolution #? [] from datetime.timedelta import #? ['Cursor'] from sqlite3 import Cursor #? ['some_variable'] from . import some_variable #? ['arrays'] from . import arrays #? [] from . import import_tree as ren #? [] import json as import os #? os.path.join from os.path import join # ----------------- # special positions -> edge cases # ----------------- import datetime #? 6 datetime from datetime.time import time #? [] import datetime. #? [] import datetime.date #? 21 ['import'] from import_tree.pkg import pkg #? 49 ['a', 'foobar', '__name__', '__doc__', '__file__', '__package__'] from import_tree.pkg.mod1 import not_existant, # whitespace before #? ['a', 'foobar', '__name__', '__doc__', '__file__', '__package__'] from import_tree.pkg.mod1 import not_existant, #? 22 ['mod1', 'base'] from import_tree.pkg. import mod1 #? 17 ['mod1', 'mod2', 'random', 'pkg', 'references', 'rename1', 'rename2', 'classes', 'globals', 'recurse_class1', 'recurse_class2', 'invisible_pkg', 'flow_import'] from import_tree. import new_pkg #? 18 ['pkg'] from import_tree.p import pkg #? 17 ['import_tree'] from .import_tree import #? 10 ['run'] from ..run import #? ['run'] from ..run #? 10 ['run'] from ..run. #? [] from ..run. #? ['run'] from .. import run #? [] from not_a_module import #137 import json #? 23 json.dump from json import load, dump #? 17 json.load from json import load, dump # without the from clause: import json, datetime #? 7 json import json, datetime #? 13 datetime import json, datetime ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/completion/ordering.py0000664000175000017500000000404000000000000017711 0ustar00davedave00000000000000# ----------------- # normal # ----------------- a = "" a = 1 #? int() a #? [] a.append a = list b = 1; b = "" #? str() b # temp should not be accessible before definition #? [] temp a = 1 temp = b; b = a a = temp #? int() b #? int() b #? str() a a = tuple if 1: a = list #? ['append'] a.append #? ['index'] a.index # ----------------- # tuples exchanges # ----------------- a, b = 1, "" #? int() a #? str() b b, a = a, b #? int() b #? str() a b, a = a, b #? int() a #? str() b # ----------------- # function # ----------------- def a(a=3): #? int() a #? [] a.func return a #? int() a(2) #? [] a(2).func a_param = 3 def func(a_param): # should not be int #? [] a_param. from os import path # should not return a function, because `a` is a function above def f(b, a): return a #? [] f(b=3). # ----------------- # closure # ----------------- def x(): a = 0 def x(): return a a = 3.0 return x() #? float() x() # ----------------- # class # ----------------- class A(object): a = "" a = 3 #? int() a a = list() def __init__(self): self.b = "" def before(self): self.b = 3 # TODO should this be so? include entries after cursor? #? int() str() list self.b self.b = list self.a = 1 #? str() int() self.a #? ['after'] self.after self.c = 3 #? int() self.c def after(self): self.a = '' c = set() #? list() A.a a = A() #? ['after'] a.after #? [] a.upper #? [] a.append #? [] a.real #? str() int() a.a a = 3 class a(): def __init__(self, a): self.a = a #? float() a(1.0).a #? a().a # ----------------- # imports # ----------------- math = 3 import math #? ['cosh'] math.cosh #? [] math.real math = 3 #? int() math #? [] math.cos # do the same for star imports cosh = 3 from math import * # cosh doesn't work, but that's not a problem, star imports should be at the # start of EVERY script! cosh.real cosh = 3 #? int() cosh ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/completion/parser.py0000664000175000017500000000135000000000000017375 0ustar00davedave00000000000000""" Issues with the parser and not the type inference should be part of this file. """ class IndentIssues(): """ issue jedi-vim#288 Which is really a fast parser issue. It used to start a new block at the parentheses, because it had problems with the indentation. """ def one_param( self, ): return 1 def with_param( self, y): return y #? int() IndentIssues().one_param() #? str() IndentIssues().with_param('') """ Just because there's a def keyword, doesn't mean it should not be able to complete to definition. """ definition = 0 #? ['definition'] str(def # It might be hard to determine the value class Foo(object): @property #? ['str'] def bar(x=str ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/completion/pep0484_basic.py0000664000175000017500000000646200000000000020357 0ustar00davedave00000000000000""" Pep-0484 type hinting """ class A(): pass def function_parameters(a: A, b, c: str, d: int, e: str, f: str, g: int=4): """ :param e: if docstring and annotation agree, only one should be returned :type e: str :param f: if docstring and annotation disagree, both should be returned :type f: int """ #? A() a #? b #? str() c #? int() d #? str() e #? str() f # int() g def return_unspecified(): pass #? return_unspecified() def return_none() -> None: """ Return type None means the same as no return type as far as jedi is concerned """ pass #? None return_none() def return_str() -> str: pass #? str() return_str() def return_custom_class() -> A: pass #? A() return_custom_class() def return_annotation_and_docstring() -> str: """ :rtype: int """ pass #? str() return_annotation_and_docstring() def return_annotation_and_docstring_different() -> str: """ :rtype: str """ pass #? str() return_annotation_and_docstring_different() def annotation_forward_reference(b: "B") -> "B": #? B() b #? ["test_element"] annotation_forward_reference(1).t class B: test_element = 1 pass #? B() annotation_forward_reference(1) class SelfReference: test_element = 1 def test_method(self, x: "SelfReference") -> "SelfReference": #? SelfReference() x #? ["test_element", "test_method"] self.t #? ["test_element", "test_method"] x.t #? ["test_element", "test_method"] self.test_method(1).t #? SelfReference() SelfReference().test_method() def function_with_non_pep_0484_annotation( x: "I can put anything here", xx: "", yy: "\r\n\0;+*&^564835(---^&*34", y: 3 + 3, zz: float) -> int("42"): # infers int from function call #? int() x # infers int from function call #? int() xx # infers int from function call #? int() yy # infers str from function call #? str() y #? float() zz #? function_with_non_pep_0484_annotation(1, 2, 3, "force string") def function_forward_reference_dynamic( x: return_str_type(), y: "return_str_type()") -> None: #? str() x #? str() y def return_str_type(): return str X = str def function_with_assined_class_in_reference(x: X, y: "Y"): #? str() x #? int() y Y = int def just_because_we_can(x: "flo" + "at"): #? float() x def keyword_only(a: str, *, b: str): #? ['startswith'] a.startswi #? ['startswith'] b.startswi def argskwargs(*args: int, **kwargs: float): """ This might be a bit confusing, but is part of the standard. args is changed to Tuple[int] in this case and kwargs to Dict[str, float], which makes sense if you think about it a bit. """ #? tuple() args #? int() args[0] #? str() next(iter(kwargs.keys())) #? float() kwargs[''] class NotCalledClass: def __init__(self, x): self.x: int = x self.y: int = '' #? int() self.x #? int() self.y #? int() self.y self.z: int self.z = '' #? str() int() self.z self.w: float #? float() self.w ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/completion/pep0484_comments.py0000664000175000017500000000635000000000000021117 0ustar00davedave00000000000000a = 3 # type: str #? str() a b = 3 # type: str but I write more #? int() b c = 3 # type: str # I comment more #? str() c d = "It should not read comments from the next line" # type: int #? str() d # type: int e = "It should not read comments from the previous line" #? str() e class BB: pass def test(a, b): a = a # type: BB c = a # type: str d = a # type: str e = a # type: str # Should ignore long whitespace #? BB() a #? str() c #? BB() d #? str() e class AA: class BB: pass def test(a): # type: (AA.BB) -> None #? AA.BB() a def test(a): # type: (AA.BB,) -> None #? AA.BB() a a,b = 1, 2 # type: str, float #? str() a #? float() b class Employee: pass from typing import List, Tuple x = [] # type: List[Employee] #? Employee() x[1] x, y, z = [], [], [] # type: List[int], List[int], List[str] #? int() y[2] x, y, z = [], [], [] # type: (List[float], List[float], List[BB]) for zi in z: #? BB() zi x = [ 1, 2, ] # type: List[str] #? str() x[1] for bar in foo(): # type: str #? str() bar for bar, baz in foo(): # type: int, float #? int() bar #? float() baz for bar, baz in foo(): # type: str, str """ type hinting on next line should not work """ #? bar #? baz with foo(): # type: int ... with foo() as f: # type: str #? str() f with foo() as f: # type: str """ type hinting on next line should not work """ #? f aaa = some_extremely_long_function_name_that_doesnt_leave_room_for_hints() \ # type: float # We should be able to put hints on the next line with a \ #? float() aaa # Test instance methods class Dog: def __init__(self, age, friends, name): # type: (int, List[Tuple[str, Dog]], str) -> None #? int() self.age = age self.friends = friends #? Dog() friends[0][1] #? str() self.name = name def friend_for_name(self, name): # type: (str) -> Dog for (friend_name, friend) in self.friends: if friend_name == name: return friend raise ValueError() def bark(self): pass buddy = Dog(UNKNOWN_NAME1, UNKNOWN_NAME2, UNKNOWN_NAME3) friend = buddy.friend_for_name('buster') # type of friend is determined by function return type #! 9 ['def bark'] friend.bark() friend = buddy.friends[0][1] # type of friend is determined by function parameter type #! 9 ['def bark'] friend.bark() # type is determined by function parameter type following nested generics #? str() friend.name # Mypy comment describing function return type. def annot(): # type: () -> str pass #? str() annot() # Mypy variable type annotation. x = UNKNOWN_NAME2 # type: str #? str() x class Cat(object): def __init__(self, age, friends, name): # type: (int, List[Dog], str) -> None self.age = age self.friends = friends self.name = name cat = Cat(UNKNOWN_NAME4, UNKNOWN_NAME5, UNKNOWN_NAME6) #? str() cat.name # Check potential errors def x(a, b): # type: ([) -> a #? a def x(a, b): # type: (1) -> a #? a def x(a, b, c): # type: (str) -> a #? b #? c ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/completion/pep0484_decorators.py0000664000175000017500000000121300000000000021430 0ustar00davedave00000000000000""" Pep-0484 type hinted decorators """ from typing import Callable def decorator(func): def wrapper(*a, **k): return str(func(*a, **k)) return wrapper def typed_decorator(func: Callable[..., int]) -> Callable[..., str]: ... # Functions @decorator def plain_func() -> int: return 4 #? str() plain_func() @typed_decorator def typed_func() -> int: return 4 #? str() typed_func() # Methods class X: @decorator def plain_method(self) -> int: return 4 @typed_decorator def typed_method(self) -> int: return 4 inst = X() #? str() inst.plain_method() #? str() inst.typed_method() ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/completion/pep0484_generic_mismatches.py0000664000175000017500000001073000000000000023120 0ustar00davedave00000000000000import typing from typing import ( Callable, Dict, Generic, List, Sequence, Tuple, Type, TypeVar, ) T = TypeVar('T') def foo(x: T) -> T: return x class CustomGeneric(Generic[T]): def __init__(self, val: T) -> None: self.val = val class PlainClass(object): pass tpl = ("1", 2) tpl_typed: Tuple[str, int] = ("2", 3) collection = {"a": 1} collection_typed: Dict[str, int] = {"a": 1} list_of_ints: List[int] = [42] list_of_funcs: List[Callable[[T], T]] = [foo] custom_generic = CustomGeneric(123.45) plain_instance = PlainClass() # Test that simple parameters are handled def list_t_to_list_t(the_list: List[T]) -> List[T]: return the_list x0 = list_t_to_list_t("abc")[0] #? x0 x1 = list_t_to_list_t(foo)[0] #? x1 x1 = list_t_to_list_t(typing)[0] #? x1 x2 = list_t_to_list_t(tpl)[0] #? x2 x3 = list_t_to_list_t(tpl_typed)[0] #? x3 x4 = list_t_to_list_t(collection)[0] #? x4 x5 = list_t_to_list_t(collection_typed)[0] #? x5 x6 = list_t_to_list_t(custom_generic)[0] #? x6 x7 = list_t_to_list_t(plain_instance)[0] #? x7 for a in list_t_to_list_t(12): #? a # Test that simple parameters are handled def list_type_t_to_list_t(the_list: List[Type[T]]) -> List[T]: return [x() for x in the_list] x0 = list_type_t_to_list_t("abc")[0] #? x0 x1 = list_type_t_to_list_t(foo)[0] #? x1 x2 = list_type_t_to_list_t(tpl)[0] #? x2 x3 = list_type_t_to_list_t(tpl_typed)[0] #? x3 x4 = list_type_t_to_list_t(collection)[0] #? x4 x5 = list_type_t_to_list_t(collection_typed)[0] #? x5 x6 = list_type_t_to_list_t(custom_generic)[0] #? x6 x7 = list_type_t_to_list_t(plain_instance)[0] #? x7 for a in list_type_t_to_list_t(12): #? a x0 = list_type_t_to_list_t(["abc"])[0] #? x0 x1 = list_type_t_to_list_t([foo])[0] #? x1 x2 = list_type_t_to_list_t([tpl])[0] #? x2 x3 = list_type_t_to_list_t([tpl_typed])[0] #? x3 x4 = list_type_t_to_list_t([collection])[0] #? x4 x5 = list_type_t_to_list_t([collection_typed])[0] #? x5 x6 = list_type_t_to_list_t([custom_generic])[0] #? x6 x7 = list_type_t_to_list_t([plain_instance])[0] #? x7 for a in list_type_t_to_list_t([12]): #? a def list_func_t_to_list_t(the_list: List[Callable[[T], T]]) -> List[T]: # Not actually a viable signature, but should be enough to test our handling # of the generic parameters. pass x0 = list_func_t_to_list_t("abc")[0] #? x0 x1 = list_func_t_to_list_t(foo)[0] #? x1 x2 = list_func_t_to_list_t(tpl)[0] #? x2 x3 = list_func_t_to_list_t(tpl_typed)[0] #? x3 x4 = list_func_t_to_list_t(collection)[0] #? x4 x5 = list_func_t_to_list_t(collection_typed)[0] #? x5 x6 = list_func_t_to_list_t(custom_generic)[0] #? x6 x7 = list_func_t_to_list_t(plain_instance)[0] #? x7 for a in list_func_t_to_list_t(12): #? a x0 = list_func_t_to_list_t(["abc"])[0] #? x0 x2 = list_func_t_to_list_t([tpl])[0] #? x2 x3 = list_func_t_to_list_t([tpl_typed])[0] #? x3 x4 = list_func_t_to_list_t([collection])[0] #? x4 x5 = list_func_t_to_list_t([collection_typed])[0] #? x5 x6 = list_func_t_to_list_t([custom_generic])[0] #? x6 x7 = list_func_t_to_list_t([plain_instance])[0] #? x7 for a in list_func_t_to_list_t([12]): #? a def tuple_t(tuple_in: Tuple[T]]) -> Sequence[T]: return tuple_in x0 = list_t_to_list_t("abc")[0] #? x0 x1 = list_t_to_list_t(foo)[0] #? x1 x2 = list_t_to_list_t(tpl)[0] #? x2 x3 = list_t_to_list_t(tpl_typed)[0] #? x3 x4 = list_t_to_list_t(collection)[0] #? x4 x5 = list_t_to_list_t(collection_typed)[0] #? x5 x6 = list_t_to_list_t(custom_generic)[0] #? x6 x7 = list_t_to_list_t(plain_instance)[0] #? x7 for a in list_t_to_list_t(12): #? a def tuple_t_elipsis(tuple_in: Tuple[T, ...]]) -> Sequence[T]: return tuple_in x0 = list_t_to_list_t("abc")[0] #? x0 x1 = list_t_to_list_t(foo)[0] #? x1 x2 = list_t_to_list_t(tpl)[0] #? x2 x3 = list_t_to_list_t(tpl_typed)[0] #? x3 x4 = list_t_to_list_t(collection)[0] #? x4 x5 = list_t_to_list_t(collection_typed)[0] #? x5 x6 = list_t_to_list_t(custom_generic)[0] #? x6 x7 = list_t_to_list_t(plain_instance)[0] #? x7 for a in list_t_to_list_t(12): #? a def list_tuple_t_to_tuple_list_t(the_list: List[Tuple[T]]) -> Tuple[List[T], ...]: return tuple(list(x) for x in the_list) for b in list_tuple_t_to_tuple_list_t(list_of_ints): #? b[0] def list_tuple_t_elipsis_to_tuple_list_t(the_list: List[Tuple[T, ...]]) -> Tuple[List[T], ...]: return tuple(list(x) for x in the_list) for b in list_tuple_t_to_tuple_list_t(list_of_ints): #? b[0] ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/completion/pep0484_generic_parameters.py0000664000175000017500000002025300000000000023127 0ustar00davedave00000000000000from typing import ( Callable, Dict, Generic, Iterable, List, Mapping, Optional, Tuple, Type, TypeVar, Union, Sequence, ) K = TypeVar('K') T = TypeVar('T') T_co = TypeVar('T_co', covariant=True) V = TypeVar('V') just_float: float = 42. optional_float: Optional[float] = 42. list_of_ints: List[int] = [42] list_of_floats: List[float] = [42.] list_of_optional_floats: List[Optional[float]] = [x or None for x in list_of_floats] list_of_ints_and_strs: List[Union[int, str]] = [42, 'abc'] # Test that simple parameters are handled def list_t_to_list_t(the_list: List[T]) -> List[T]: return the_list x0 = list_t_to_list_t(list_of_ints)[0] #? int() x0 for a in list_t_to_list_t(list_of_ints): #? int() a # Test that unions are handled x2 = list_t_to_list_t(list_of_ints_and_strs)[0] #? int() str() x2 for z in list_t_to_list_t(list_of_ints_and_strs): #? int() str() z list_of_int_type: List[Type[int]] = [int] # Test that nested parameters are handled def list_optional_t_to_list_t(the_list: List[Optional[T]]) -> List[T]: return [x for x in the_list if x is not None] for xa in list_optional_t_to_list_t(list_of_optional_floats): #? float() xa # Under covariance rules this is strictly incorrect (because List is mutable, # the function would be allowed to put `None`s into our List[float], which would # be bad), however we don't expect jedi to enforce that. for xa1 in list_optional_t_to_list_t(list_of_floats): #? float() xa1 def optional_t_to_list_t(x: Optional[T]) -> List[T]: return [x] if x is not None else [] for xb in optional_t_to_list_t(optional_float): #? float() xb for xb2 in optional_t_to_list_t(just_float): #? float() xb2 def optional_list_t_to_list_t(x: Optional[List[T]]) -> List[T]: return x if x is not None else [] optional_list_float: Optional[List[float]] = None for xc in optional_list_t_to_list_t(optional_list_float): #? float() xc for xc2 in optional_list_t_to_list_t(list_of_floats): #? float() xc2 def list_type_t_to_list_t(the_list: List[Type[T]]) -> List[T]: return [x() for x in the_list] x1 = list_type_t_to_list_t(list_of_int_type)[0] #? int() x1 for b in list_type_t_to_list_t(list_of_int_type): #? int() b # Test construction of nested generic tuple return parameters def list_t_to_list_tuple_t(the_list: List[T]) -> List[Tuple[T]]: return [(x,) for x in the_list] x1t = list_t_to_list_tuple_t(list_of_ints)[0][0] #? int() x1t for c1 in list_t_to_list_tuple_t(list_of_ints): #? int() c1[0] for c2, in list_t_to_list_tuple_t(list_of_ints): #? int() c2 # Test handling of nested tuple input parameters def list_tuple_t_to_tuple_list_t(the_list: List[Tuple[T]]) -> Tuple[List[T], ...]: return tuple(list(x) for x in the_list) list_of_int_tuples: List[Tuple[int]] = [(x,) for x in list_of_ints] for b in list_tuple_t_to_tuple_list_t(list_of_int_tuples): #? int() b[0] def list_tuple_t_elipsis_to_tuple_list_t(the_list: List[Tuple[T, ...]]) -> Tuple[List[T], ...]: return tuple(list(x) for x in the_list) list_of_int_tuple_elipsis: List[Tuple[int, ...]] = [tuple(list_of_ints)] for b in list_tuple_t_elipsis_to_tuple_list_t(list_of_int_tuple_elipsis): #? int() b[0] # Test handling of nested callables def foo(x: int) -> int: return x list_of_funcs: List[Callable[[int], int]] = [foo] def list_func_t_to_list_func_type_t(the_list: List[Callable[[T], T]]) -> List[Callable[[Type[T]], T]]: def adapt(func: Callable[[T], T]) -> Callable[[Type[T]], T]: def wrapper(typ: Type[T]) -> T: return func(typ()) return wrapper return [adapt(x) for x in the_list] for b in list_func_t_to_list_func_type_t(list_of_funcs): #? int() b(int) def bar(*a, **k) -> int: return len(a) + len(k) list_of_funcs_2: List[Callable[..., int]] = [bar] def list_func_t_passthrough(the_list: List[Callable[..., T]]) -> List[Callable[..., T]]: return the_list for b in list_func_t_passthrough(list_of_funcs_2): #? int() b(None, x="x") mapping_int_str: Dict[int, str] = {42: 'a'} # Test that mappings (that have more than one parameter) are handled def invert_mapping(mapping: Mapping[K, V]) -> Mapping[V, K]: return {v: k for k, v in mapping.items()} #? int() invert_mapping(mapping_int_str)['a'] # Test that the right type is chosen when a mapping is passed to something with # only a single parameter. This checks that our inheritance checking picks the # right thing. def first(iterable: Iterable[T]) -> T: return next(iter(iterable)) #? int() first(mapping_int_str) # Test inference of str as an iterable of str. #? str() first("abc") some_str: str = NotImplemented #? str() first(some_str) annotated: List[ Callable[[Sequence[float]], int] ] = [len] #? int() first(annotated)() # Test that the right type is chosen when a partially realised mapping is expected def values(mapping: Mapping[int, T]) -> List[T]: return list(mapping.values()) #? str() values(mapping_int_str)[0] x2 = values(mapping_int_str)[0] #? str() x2 for b in values(mapping_int_str): #? str() b # # Tests that user-defined generic types are handled # list_ints: List[int] = [42] class CustomGeneric(Generic[T_co]): def __init__(self, val: T_co) -> None: self.val = val # Test extraction of type from a custom generic type def custom(x: CustomGeneric[T]) -> T: return x.val custom_instance: CustomGeneric[int] = CustomGeneric(42) #? int() custom(custom_instance) x3 = custom(custom_instance) #? int() x3 # Test construction of a custom generic type def wrap_custom(iterable: Iterable[T]) -> List[CustomGeneric[T]]: return [CustomGeneric(x) for x in iterable] #? int() wrap_custom(list_ints)[0].val x4 = wrap_custom(list_ints)[0] #? int() x4.val for x5 in wrap_custom(list_ints): #? int() x5.val # Test extraction of type from a nested custom generic type list_custom_instances: List[CustomGeneric[int]] = [CustomGeneric(42)] def unwrap_custom(iterable: Iterable[CustomGeneric[T]]) -> List[T]: return [x.val for x in iterable] #? int() unwrap_custom(list_custom_instances)[0] x6 = unwrap_custom(list_custom_instances)[0] #? int() x6 for x7 in unwrap_custom(list_custom_instances): #? int() x7 for xc in unwrap_custom([CustomGeneric(s) for s in 'abc']): #? str() xc for xg in unwrap_custom(CustomGeneric(s) for s in 'abc'): #? str() xg # Test extraction of type from type parameer nested within a custom generic type custom_instance_list_int: CustomGeneric[List[int]] = CustomGeneric([42]) def unwrap_custom2(instance: CustomGeneric[Iterable[T]]) -> List[T]: return list(instance.val) #? int() unwrap_custom2(custom_instance_list_int)[0] x8 = unwrap_custom2(custom_instance_list_int)[0] #? int() x8 for x9 in unwrap_custom2(custom_instance_list_int): #? int() x9 # Test that classes which have generic parents but are not generic themselves # are still inferred correctly. class Specialised(Mapping[int, str]): pass specialised_instance: Specialised = NotImplemented #? int() first(specialised_instance) #? str() values(specialised_instance)[0] # Test that classes which have generic ancestry but neither they nor their # parents are not generic are still inferred correctly. class ChildOfSpecialised(Specialised): pass child_of_specialised_instance: ChildOfSpecialised = NotImplemented #? int() first(child_of_specialised_instance) #? str() values(child_of_specialised_instance)[0] # Test that unbound generics are inferred as much as possible class CustomPartialGeneric1(Mapping[str, T]): pass custom_partial1_instance: CustomPartialGeneric1[int] = NotImplemented #? str() first(custom_partial1_instance) custom_partial1_unbound_instance: CustomPartialGeneric1 = NotImplemented #? str() first(custom_partial1_unbound_instance) class CustomPartialGeneric2(Mapping[T, str]): pass custom_partial2_instance: CustomPartialGeneric2[int] = NotImplemented #? int() first(custom_partial2_instance) #? str() values(custom_partial2_instance)[0] custom_partial2_unbound_instance: CustomPartialGeneric2 = NotImplemented #? [] first(custom_partial2_unbound_instance) #? str() values(custom_partial2_unbound_instance)[0] ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/completion/pep0484_generic_passthroughs.py0000664000175000017500000001571400000000000023524 0ustar00davedave00000000000000from typing import ( Any, Callable, Iterable, List, Sequence, Tuple, Type, TypeVar, Union, Generic, ) T = TypeVar('T') U = TypeVar('U') TList = TypeVar('TList', bound=List[Any]) TType = TypeVar('TType', bound=Type) TTypeAny = TypeVar('TTypeAny', bound=Type[Any]) TCallable = TypeVar('TCallable', bound=Callable[..., Any]) untyped_list_str = ['abc', 'def'] typed_list_str: List[str] = ['abc', 'def'] untyped_tuple_str = ('abc',) typed_tuple_str: Tuple[str] = ('abc',) untyped_tuple_str_int = ('abc', 4) typed_tuple_str_int: Tuple[str, int] = ('abc', 4) variadic_tuple_str: Tuple[str, ...] = ('abc',) variadic_tuple_str_int: Tuple[Union[str, int], ...] = ('abc', 4) def untyped_passthrough(x): return x def typed_list_generic_passthrough(x: List[T]) -> List[T]: return x def typed_tuple_generic_passthrough(x: Tuple[T]) -> Tuple[T]: return x def typed_multi_typed_tuple_generic_passthrough(x: Tuple[T, U]) -> Tuple[U, T]: return x[1], x[0] def typed_variadic_tuple_generic_passthrough(x: Tuple[T, ...]) -> Sequence[T]: return x def typed_iterable_generic_passthrough(x: Iterable[T]) -> Iterable[T]: return x def typed_fully_generic_passthrough(x: T) -> T: return x def typed_bound_generic_passthrough(x: TList) -> TList: #? list() x return x # Forward references are more likely with custom types, however this aims to # test just the handling of the quoted type rather than any other part of the # machinery. def typed_quoted_return_generic_passthrough(x: T) -> 'List[T]': return [x] def typed_quoted_input_generic_passthrough(x: 'Tuple[T]') -> T: x return x[0] for a in untyped_passthrough(untyped_list_str): #? str() a for b in untyped_passthrough(typed_list_str): #? str() b for c in typed_list_generic_passthrough(untyped_list_str): #? str() c for d in typed_list_generic_passthrough(typed_list_str): #? str() d for e in typed_iterable_generic_passthrough(untyped_list_str): #? str() e for f in typed_iterable_generic_passthrough(typed_list_str): #? str() f for g in typed_tuple_generic_passthrough(untyped_tuple_str): #? str() g for h in typed_tuple_generic_passthrough(typed_tuple_str): #? str() h out_untyped = typed_multi_typed_tuple_generic_passthrough(untyped_tuple_str_int) #? int() out_untyped[0] #? str() out_untyped[1] out_typed = typed_multi_typed_tuple_generic_passthrough(typed_tuple_str_int) #? int() out_typed[0] #? str() out_typed[1] for j in typed_variadic_tuple_generic_passthrough(untyped_tuple_str_int): #? str() int() j for k in typed_variadic_tuple_generic_passthrough(typed_tuple_str_int): #? str() int() k for l in typed_variadic_tuple_generic_passthrough(variadic_tuple_str): #? str() l for m in typed_variadic_tuple_generic_passthrough(variadic_tuple_str_int): #? str() int() m #? float typed_fully_generic_passthrough(float) for n in typed_fully_generic_passthrough(untyped_list_str): #? str() n for o in typed_fully_generic_passthrough(typed_list_str): #? str() o for p in typed_bound_generic_passthrough(untyped_list_str): #? str() p for q in typed_bound_generic_passthrough(typed_list_str): #? str() q for r in typed_quoted_return_generic_passthrough("something"): #? str() r for s in typed_quoted_return_generic_passthrough(42): #? int() s #? str() typed_quoted_input_generic_passthrough(("something",)) #? int() typed_quoted_input_generic_passthrough((42,)) class CustomList(List): def get_first(self): return self[0] #? str() CustomList[str]()[0] #? str() CustomList[str]().get_first() #? str() typed_fully_generic_passthrough(CustomList[str]())[0] #? typed_list_generic_passthrough(CustomList[str])[0] def typed_bound_type_implicit_any_generic_passthrough(x: TType) -> TType: #? Type() x return x def typed_bound_type_any_generic_passthrough(x: TTypeAny) -> TTypeAny: # Should be Type(), though we don't get the handling of the nested argument # to `Type[...]` quite right here. x return x class MyClass: pass def my_func(a: str, b: int) -> float: pass #? MyClass typed_fully_generic_passthrough(MyClass) #? MyClass() typed_fully_generic_passthrough(MyClass()) #? my_func typed_fully_generic_passthrough(my_func) #? CustomList() typed_bound_generic_passthrough(CustomList[str]()) # should be list(), but we don't validate generic typevar upper bounds #? int() typed_bound_generic_passthrough(42) #? MyClass typed_bound_type_implicit_any_generic_passthrough(MyClass) #? MyClass typed_bound_type_any_generic_passthrough(MyClass) # should be Type(), but we don't validate generic typevar upper bounds #? int() typed_bound_type_implicit_any_generic_passthrough(42) # should be Type(), but we don't validate generic typevar upper bounds #? int() typed_bound_type_any_generic_passthrough(42) def decorator(fn: TCallable) -> TCallable: pass def will_be_decorated(the_param: complex) -> float: pass is_decorated = decorator(will_be_decorated) #? will_be_decorated is_decorated #? ['the_param='] is_decorated(the_para ) class class_decorator_factory_plain: def __call__(self, func: T) -> T: ... #? class_decorator_factory_plain() class_decorator_factory_plain() #? class_decorator_factory_plain()() is_decorated_by_class_decorator_factory = class_decorator_factory_plain()(will_be_decorated) #? will_be_decorated is_decorated_by_class_decorator_factory #? ['the_param='] is_decorated_by_class_decorator_factory(the_par ) def decorator_factory_plain() -> Callable[[T], T]: pass #? Callable() decorator_factory_plain() #? decorator_factory_plain()() #? int() decorator_factory_plain()(42) is_decorated_by_plain_factory = decorator_factory_plain()(will_be_decorated) #? will_be_decorated is_decorated_by_plain_factory #? ['the_param='] is_decorated_by_plain_factory(the_par ) class class_decorator_factory_bound_callable: def __call__(self, func: TCallable) -> TCallable: ... #? class_decorator_factory_bound_callable() class_decorator_factory_bound_callable() #? Callable() class_decorator_factory_bound_callable()() is_decorated_by_class_bound_factory = class_decorator_factory_bound_callable()(will_be_decorated) #? will_be_decorated is_decorated_by_class_bound_factory #? ['the_param='] is_decorated_by_class_bound_factory(the_par ) def decorator_factory_bound_callable() -> Callable[[TCallable], TCallable]: pass #? Callable() decorator_factory_bound_callable() #? Callable() decorator_factory_bound_callable()() is_decorated_by_bound_factory = decorator_factory_bound_callable()(will_be_decorated) #? will_be_decorated is_decorated_by_bound_factory #? ['the_param='] is_decorated_by_bound_factory(the_par ) class That(Generic[T]): def __init__(self, items: List[Tuple[str, T]]) -> None: pass def get(self) -> T: pass inst = That([("abc", 2)]) # No completions here, but should have completions for `int` #? int() inst.get() ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/completion/pep0484_overload.py0000664000175000017500000000264200000000000021105 0ustar00davedave00000000000000from typing import List, Dict, overload, Tuple, TypeVar lst: list list_alias: List list_str: List[str] list_int: List[int] # ------------------------- # With base classes # ------------------------- @overload def overload_f2(value: List) -> str: ... @overload def overload_f2(value: Dict) -> int: ... #? str() overload_f2(['']) #? int() overload_f2({1.0: 1.0}) #? str() overload_f2(lst) #? str() overload_f2(list_alias) #? str() overload_f2(list_str) @overload def overload_f3(value: list) -> str: ... @overload def overload_f3(value: dict) -> float: ... #? str() overload_f3(['']) #? float() overload_f3({1.0: 1.0}) #? str() overload_f3(lst) #? str() overload_f3(list_alias) #? str() overload_f3(list_str) # ------------------------- # Generics Matching # ------------------------- @overload def overload_f1(value: List[str]) -> str: ... @overload def overload_f1(value: Dict[str, str]) -> Dict[str, str]: ... def overload_f1(): pass #? str() overload_f1(['']) #? str() dict() overload_f1(1) #? dict() overload_f1({'': ''}) #? str() dict() overload_f1(lst) #? str() dict() overload_f1(list_alias) #? str() overload_f1(list_str) #? str() dict() overload_f1(list_int) # ------------------------- # Broken Matching # ------------------------- T = TypeVar('T') @overload def broken_f1(value: 1) -> str: ... @overload def broken_f1(value: Tuple[T]) -> Tuple[T]: ... tup: Tuple[float] #? float() broken_f1(broken_f1(tup))[0] ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/completion/pep0484_typing.py0000664000175000017500000002301400000000000020600 0ustar00davedave00000000000000""" Test the typing library, with docstrings and annotations """ import typing from typing import Sequence, MutableSequence, List, Iterable, Iterator, \ AbstractSet, Tuple, Mapping, Dict, Union, Optional class B: pass def we_can_has_sequence(p: Sequence[int], q: Sequence[B], r: Sequence[int], s: Sequence["int"], t: MutableSequence[dict], u: List[float]): #? ["count"] p.c #? int() p[1] #? ["count"] q.c #? B() q[1] #? ["count"] r.c #? int() r[1] #? ["count"] s.c #? int() s[1] #? [] s.a #? ["append"] t.a #? dict() t[1] #? ["append"] u.a #? float() list() u[1.0] #? float() u[1] def iterators(ps: Iterable[int], qs: Iterator[str], rs: Sequence["ForwardReference"], ts: AbstractSet["float"]): for p in ps: #? int() p #? next(ps) a, b = ps #? int() a ##? int() --- TODO fix support for tuple assignment # https://github.com/davidhalter/jedi/pull/663#issuecomment-172317854 # test below is just to make sure that in case it gets fixed by accident # these tests will be fixed as well the way they should be #? b for q in qs: #? str() q #? str() next(qs) for r in rs: #? ForwardReference() r #? next(rs) for t in ts: #? float() t def sets(p: AbstractSet[int], q: typing.MutableSet[float]): #? [] p.a #? ["add"] q.a def tuple(p: Tuple[int], q: Tuple[int, str, float], r: Tuple[B, ...]): #? int() p[0] #? ['index'] p.index #? int() q[0] #? str() q[1] #? float() q[2] #? B() r[0] #? B() r[1] #? B() r[2] #? B() r[10000] i, s, f = q #? int() i #? str() s #? float() f class Key: pass class Value: pass def mapping( p: Mapping[Key, Value], q: typing.MutableMapping[Key, Value], d: Dict[Key, Value], dd: typing.DefaultDict[Key, Value], r: typing.KeysView[Key], s: typing.ValuesView[Value], t: typing.ItemsView[Key, Value]): #? [] p.setd #? ["setdefault"] q.setd #? ["setdefault"] d.setd #? ["setdefault"] dd.setd #? Value() p[1] for key in p: #? Key() key for key in p.keys(): #? Key() key for value in p.values(): #? Value() value for item in p.items(): #? Key() item[0] #? Value() item[1] (key, value) = item #? Key() key #? Value() value for key, value in p.items(): #? Key() key #? Value() value for key, value in q.items(): #? Key() key #? Value() value for key, value in d.items(): #? Key() key #? Value() value for key, value in dd.items(): #? Key() key #? Value() value for key in r: #? Key() key for value in s: #? Value() value for key, value in t: #? Key() key #? Value() value def union( p: Union[int], q: Union[int, int], r: Union[int, str, "int"], s: Union[int, typing.Union[str, "typing.Union['float', 'dict']"]], t: Union[int, None]): #? int() p #? int() q #? int() str() r #? int() str() float() dict() s #? int() None t def optional(p: Optional[int]): """ Optional does not do anything special. However it should be recognised as being of that type. Jedi doesn't do anything with the extra into that it can be None as well """ #? int() None p class ForwardReference: pass class TestDict(typing.Dict[str, int]): def setdud(self): pass def testdict(x: TestDict): #? ["setdud", "setdefault"] x.setd for key in x.keys(): #? str() key for value in x.values(): #? int() value x = TestDict() #? ["setdud", "setdefault"] x.setd for key in x.keys(): #? str() key for value in x.values(): #? int() value WrappingType = typing.NewType('WrappingType', str) # Chosen arbitrarily y = WrappingType(0) # Per https://github.com/davidhalter/jedi/issues/1015#issuecomment-355795929 #? str() y def testnewtype(y: WrappingType): #? str() y #? ["upper"] y.u WrappingType2 = typing.NewType() def testnewtype2(y: WrappingType2): #? y #? [] y. # The type of a NewType is equivalent to the type of its underlying type. MyInt = typing.NewType('MyInt', int) x = type(MyInt) #? type.mro x.mro PlainInt = int y = type(PlainInt) #? type.mro y.mro class TestDefaultDict(typing.DefaultDict[str, int]): def setdud(self): pass def testdict(x: TestDefaultDict): #? ["setdud", "setdefault"] x.setd for key in x.keys(): #? str() key for value in x.values(): #? int() value x = TestDefaultDict() #? ["setdud", "setdefault"] x.setd for key in x.keys(): #? str() key for value in x.values(): #? int() value """ docstrings have some auto-import, annotations can use all of Python's import logic """ import typing as t def union2(x: t.Union[int, str]): #? int() str() x from typing import Union def union3(x: Union[int, str]): #? int() str() x from typing import Union as U def union4(x: U[int, str]): #? int() str() x #? typing.Optional typing.Optional[0] # ------------------------- # Type Vars # ------------------------- TYPE_VARX = typing.TypeVar('TYPE_VARX') TYPE_VAR_CONSTRAINTSX = typing.TypeVar('TYPE_VAR_CONSTRAINTSX', str, int) #? ['__class__'] TYPE_VARX.__clas #! ["TYPE_VARX = typing.TypeVar('TYPE_VARX')"] TYPE_VARX class WithTypeVar(typing.Generic[TYPE_VARX]): def lala(self) -> TYPE_VARX: ... def maaan(p: WithTypeVar[int]): #? int() p.lala() def in_out1(x: TYPE_VARX) -> TYPE_VARX: ... #? int() in_out1(1) #? str() in_out1("") #? str() in_out1(str()) #? in_out1() def type_in_out1(x: typing.Type[TYPE_VARX]) -> TYPE_VARX: ... #? int() type_in_out1(int) #? str() type_in_out1(str) #? float() type_in_out1(float) #? type_in_out1() def in_out2(x: TYPE_VAR_CONSTRAINTSX) -> TYPE_VAR_CONSTRAINTSX: ... #? int() in_out2(1) #? str() in_out2("") #? str() in_out2(str()) #? str() int() in_out2() # TODO this should actually be str() int(), because of the constraints. #? float() in_out2(1.0) def type_in_out2(x: typing.Type[TYPE_VAR_CONSTRAINTSX]) -> TYPE_VAR_CONSTRAINTSX: ... #? int() type_in_out2(int) #? str() type_in_out2(str) #? str() int() type_in_out2() # TODO this should actually be str() int(), because of the constraints. #? float() type_in_out2(float) def ma(a: typing.Callable[[str], TYPE_VARX]) -> typing.Callable[[str], TYPE_VARX]: #? typing.Callable() return a def mf(s: str) -> int: return int(s) #? int() ma(mf)('2') def xxx(x: typing.Iterable[TYPE_VARX]) -> typing.Tuple[str, TYPE_VARX]: ... #? str() xxx([0])[0] #? int() xxx([0])[1] #? xxx([0])[2] def call_pls() -> typing.Callable[[TYPE_VARX], TYPE_VARX]: ... #? int() call_pls()(1) def call2_pls() -> typing.Callable[[str, typing.Callable[[int], TYPE_VARX]], TYPE_VARX]: ... #? float() call2_pls('')(1, lambda x: 3.0) def call3_pls() -> typing.Callable[[typing.Callable[[int], TYPE_VARX]], typing.List[TYPE_VARX]]: ... def the_callable() -> float: ... #? float() call3_pls()(the_callable)[0] def call4_pls(fn: typing.Callable[..., TYPE_VARX]) -> typing.Callable[..., TYPE_VARX]: return "" #? int() call4_pls(lambda x: 1)() # ------------------------- # TYPE_CHECKING # ------------------------- if typing.TYPE_CHECKING: with_type_checking = 1 else: without_type_checking = 1.0 #? int() with_type_checking #? without_type_checking def foo(a: typing.List, b: typing.Dict, c: typing.MutableMapping) -> typing.Type[int]: #? ['append'] a.appen #? list() a #? a[0] #? ['setdefault'] b.setd #? ['setdefault'] c.setd #? typing.MutableMapping() c #? c['asdf'] #? int foo() # ------------------------- # cast # ------------------------- def cast_tests(): x = 3.0 y = typing.cast(int, x) #? int() y return typing.cast(str, x) #? str() cast_tests() # ------------------------- # dynamic # ------------------------- def dynamic_annotation(x: int): #? int() return x #? int() dynamic_annotation('') # ------------------------- # TypeDict # ------------------------- # python >= 3.8 class Foo(typing.TypedDict): foo: str bar: typing.List[float] an_int: int #! ['foo: str'] foo #? str() foo #? int() an_int def typed_dict_test_foo(arg: Foo): a_string = arg['foo'] a_list_of_floats = arg['bar'] an_int = arg['an_int'] #? str() a_string #? list() a_list_of_floats #? float() a_list_of_floats[0] #? int() an_int #? ['isupper'] a_string.isuppe #? ['pop'] a_list_of_floats.po #? ['as_integer_ratio'] an_int.as_integer_rati #! ['class Foo'] d: Foo #? str() d['foo'] #? float() d['bar'][0] #? d['baz'] #? d.foo #? d.bar #! [] d.foo #? [] Foo.set #? ['setdefault'] d.setdefaul #? [] Foo.setdefaul #? 5 ["'foo"] d['fo'] #? 5 ['"bar"'] d["bar"] class Bar(Foo): another_variable: int #? int() another_variable #? an_int def typed_dict_test_foo(arg: Bar): #? str() arg['foo'] #? list() arg['bar'] #? float() arg['bar'][0] #? int() arg['an_int'] #? int() arg['another_variable'] ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/completion/pep0526_variables.py0000664000175000017500000000360100000000000021233 0ustar00davedave00000000000000""" PEP 526 introduced a way of using type annotations on variables. """ import typing asdf = '' asdf: int # This is not necessarily correct, but for now this is ok (at least no error). #? int() asdf direct: int = NOT_DEFINED #? int() direct with_typing_module: typing.List[float] = NOT_DEFINED #? float() with_typing_module[0] somelist = [1, 2, 3, "A", "A"] element : int for element in somelist: #? int() element test_string: str = NOT_DEFINED #? str() test_string char: str for char in NOT_DEFINED: #? str() char # ------------------------- # instance/class vars # ------------------------- class Foo(): bar: int baz: typing.ClassVar[str] #? int() Foo.bar #? int() Foo().bar #? str() Foo.baz #? str() Foo().baz class VarClass: var_instance1: int = '' var_instance2: float var_class1: typing.ClassVar[str] = 1 var_class2: typing.ClassVar[bytes] var_class3 = None def __init__(self): #? int() d.var_instance1 #? float() d.var_instance2 #? str() d.var_class1 #? bytes() d.var_class2 #? [] d.int #? ['var_class1', 'var_class2', 'var_instance1', 'var_instance2', 'var_class3'] self.var_ class VarClass2(VarClass): var_class3: typing.ClassVar[int] def __init__(self): #? int() self.var_class3 #? ['var_class1', 'var_class2', 'var_instance1', 'var_class3', 'var_instance2'] VarClass.var_ #? int() VarClass.var_instance1 #? float() VarClass.var_instance2 #? str() VarClass.var_class1 #? bytes() VarClass.var_class2 #? [] VarClass.int d = VarClass() #? ['var_class1', 'var_class2', 'var_class3', 'var_instance1', 'var_instance2'] d.var_ #? int() d.var_instance1 #? float() d.var_instance2 #? str() d.var_class1 #? bytes() d.var_class2 #? [] d.int import dataclasses @dataclasses.dataclass class DC: name: int = 1 #? int() DC().name ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/completion/pep0593_annotations.py0000664000175000017500000000056400000000000021631 0ustar00davedave00000000000000# python >= 3.9 from typing import Annotated # This is just a dummy and very meaningless thing to use with to the Annotated # type hint class Foo: pass class A: pass def annotated_function_params( basic: Annotated[str, Foo()], obj: A, annotated_obj: Annotated[A, Foo()], ): #? str() basic #? A() obj #? A() annotated_obj ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/completion/pep0604.py0000664000175000017500000000147500000000000017207 0ustar00davedave00000000000000from pep0484_generic_parameters import list_t_to_list_t list_of_ints_and_strs: list[int | str] # Test that unions are handled x2 = list_t_to_list_t(list_of_ints_and_strs)[0] #? int() str() x2 for z in list_t_to_list_t(list_of_ints_and_strs): #? int() str() z from pep0484_generic_passthroughs import ( typed_variadic_tuple_generic_passthrough, ) variadic_tuple_str_int: tuple[int | str, ...] for m in typed_variadic_tuple_generic_passthrough(variadic_tuple_str_int): #? str() int() m def func_returns_byteslike() -> bytes | bytearray: pass #? bytes() bytearray() func_returns_byteslike() pep604_optional_1: int | str | None pep604_optional_2: None | bytes #? int() str() None pep604_optional_1 #? None bytes() pep604_optional_2 pep604_in_str: "int | bytes" #? int() bytes() pep604_in_str ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/completion/positional_only_params.py0000664000175000017500000000112600000000000022667 0ustar00davedave00000000000000# python >= 3.8 def positional_only_call(a, /, b): #? str() a #? int() b if UNDEFINED: return a else: return b #? int() str() positional_only_call('', 1) def positional_only_call2(a, /, b=3): if UNDEFINED: return a else: return b #? int() positional_only_call2(1) #? int() positional_only_call2(SOMETHING_UNDEFINED) #? str() positional_only_call2(SOMETHING_UNDEFINED, '') # Maybe change this? Because it's actually not correct #? int() str() positional_only_call2(a=1, b='') #? tuple str() positional_only_call2(b='', a=tuple) ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/completion/precedence.py0000664000175000017500000000523400000000000020203 0ustar00davedave00000000000000""" Test Jedi's operation understanding. Jedi should understand simple additions, multiplications, etc. """ # ----------------- # numbers # ----------------- x = [1, 'a', 1.0] #? int() str() float() x[12] #? float() x[1 + 1] index = 0 + 1 #? str() x[index] #? int() x[1 + (-1)] def calculate(number): return number + constant constant = 1 #? float() x[calculate(1)] def calculate(number): return number + constant # ----------------- # strings # ----------------- x = 'upp' + 'e' #? str.upper getattr(str, x + 'r') a = "a"*3 #? str() a a = 3 * "a" #? str() a a = 3 * "a" #? str() a #? int() (3 ** 3) #? int() (3 ** 'a') #? int() (3 + 'a') #? bool() (3 == 'a') #? bool() (3 >= 'a') class X(): foo = 2 #? int() (X.foo ** 3) # ----------------- # assignments # ----------------- x = [1, 'a', 1.0] i = 0 i += 1 i += 1 #? float() x[i] i = 1 i += 1 i -= 3 i += 1 #? int() x[i] # ----------------- # in # ----------------- if 'X' in 'Y': a = 3 else: a = '' # For now don't really check for truth values. So in should return both # results. #? str() int() a if 'X' not in 'Y': b = 3 else: b = '' # For now don't really check for truth values. So in should return both # results. #? str() int() b # ----------------- # for flow assignments # ----------------- class FooBar(object): fuu = 0.1 raboof = 'fourtytwo' # targets should be working target = '' for char in ['f', 'u', 'u']: target += char #? float() getattr(FooBar, target) # github #24 target = u'' for char in reversed(['f', 'o', 'o', 'b', 'a', 'r']): target += char #? str() getattr(FooBar, target) # ----------------- # repetition problems -> could be very slow and memory expensive - shouldn't # be. # ----------------- b = [str(1)] l = list for x in [l(0), l(1), l(2), l(3), l(4), l(5), l(6), l(7), l(8), l(9), l(10), l(11), l(12), l(13), l(14), l(15), l(16), l(17), l(18), l(19), l(20), l(21), l(22), l(23), l(24), l(25), l(26), l(27), l(28), l(29)]: b += x #? str() b[1] # ----------------- # undefined names # ----------------- a = foobarbaz + 'hello' #? int() float() {'hello': 1, 'bar': 1.0}[a] # ----------------- # stubs # ----------------- from datetime import datetime, timedelta #? (datetime - timedelta) #? datetime() (datetime() - timedelta()) #? timedelta() (datetime() - datetime()) #? timedelta() (timedelta() - datetime()) #? timedelta() (timedelta() - timedelta()) # ----------------- # magic methods # ----------------- class C: def __sub__(self, other) -> int: ... def __radd__(self, other) -> float: ... #? int() (C() - object()) #? C() object() (object() - C()) #? C() object() (C() + object()) #? float() (object() + C()) ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/completion/pytest.py0000664000175000017500000000642000000000000017434 0ustar00davedave00000000000000from typing import Generator import pytest from pytest import fixture @pytest.fixture(scope='module') def my_fixture() -> str: pass @fixture def my_simple_fixture(): return 1 @fixture def my_yield_fixture(): yield 1 @fixture class MyClassFixture(): pass # ----------------- # goto/infer # ----------------- #! 18 ['def my_conftest_fixture'] def test_x(my_conftest_fixture, my_fixture, my_not_existing_fixture, my_yield_fixture): #? str() my_fixture #? int() my_yield_fixture #? my_not_existing_fixture #? float() return my_conftest_fixture #? 18 float() def test_x(my_conftest_fixture, my_fixture): pass #! 18 ['param MyClassFixture'] def test_x(MyClassFixture): #? MyClassFixture #? 15 def lala(my_fixture): pass @pytest.fixture #? 15 str() def lala(my_fixture): pass #! 15 ['param my_fixture'] def lala(my_fixture): pass @pytest.fixture #! 15 ['def my_fixture'] def lala(my_fixture): pass # overriding types of a fixture should be possible def test_x(my_yield_fixture: str): #? str() my_yield_fixture # ----------------- # completion # ----------------- #? 34 ['my_fixture'] def test_x(my_simple_fixture, my_fixture): return #? 34 ['my_fixture'] def test_x(my_simple_fixture, my_fixture): return #? ['my_fixture'] def test_x(my_simple_fixture, my_f return #? 18 ['my_simple_fixture'] def test_x(my_simple_fixture): return #? ['my_simple_fixture'] def test_x(my_simp return #? ['my_conftest_fixture'] def test_x(my_con return #? 18 ['my_conftest_fixture'] def test_x(my_conftest_fixture): return #? [] def lala(my_con return @pytest.fixture #? ['my_conftest_fixture'] def lala(my_con return @pytest.fixture #? 15 ['my_conftest_fixture'] def lala(my_con): return @pytest.fixture @some_decorator #? ['my_conftest_fixture'] def lala(my_con return @pytest.fixture @some_decorator #? 15 ['my_conftest_fixture'] def lala(my_con): return # ----------------- # pytest owned fixtures # ----------------- #? ['monkeypatch'] def test_p(monkeyp #! 15 ['def monkeypatch'] def test_p(monkeypatch): #? ['setattr'] monkeypatch.setatt #? ['capsysbinary'] def test_p(capsysbin def close_parens(): pass # ----------------- # inheritance # ----------------- @fixture #? 40 ['inheritance_fixture'] def inheritance_fixture(inheritance_fixture): #? str() inheritance_fixture #? ['upper'] inheritance_fixture.upper return 1 #! 48 ['def inheritance_fixture'] def test_inheritance_fixture(inheritance_fixture, caplog): #? int() inheritance_fixture #? ['set_level'] caplog.set_le @pytest.fixture def caplog(caplog): yield caplog # ----------------- # Generator with annotation # ----------------- @pytest.fixture def with_annot() -> Generator[float, None, None]: pass def test_with_annot(inheritance_fixture, with_annot): #? float() with_annot # ----------------- # pytest external plugins # ----------------- #? ['admin_user', 'admin_client'] def test_z(admin #! 15 ['def admin_client'] def test_p(admin_client): #? ['login', 'logout'] admin_client.log @pytest.fixture @some_decorator #? ['admin_user'] def bla(admin_u return @pytest.fixture @some_decorator #! 12 ['def admin_user'] def bla(admin_user): pass ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/completion/recursion.py0000664000175000017500000000333500000000000020117 0ustar00davedave00000000000000""" Code that might cause recursion issues (or has caused in the past). """ def Recursion(): def recurse(self): self.a = self.a self.b = self.b.recurse() #? Recursion().a #? Recursion().b class X(): def __init__(self): self.recursive = [1, 3] def annoying(self): self.recursive = [self.recursive[0]] def recurse(self): self.recursive = [self.recursive[1]] #? int() X().recursive[0] def to_list(iterable): return list(set(iterable)) def recursion1(foo): return to_list(to_list(foo)) + recursion1(foo) #? int() recursion1([1,2])[0] class FooListComp(): def __init__(self): self.recursive = [1] def annoying(self): self.recursive = [x for x in self.recursive] #? int() FooListComp().recursive[0] class InstanceAttributeIfs: def b(self): self.a1 = 1 self.a2 = 1 def c(self): self.a2 = '' def x(self): self.b() if self.a1 == 1: self.a1 = self.a1 + 1 if self.a2 == UNDEFINED: self.a2 = self.a2 + 1 #? int() self.a1 #? int() str() self.a2 #? int() InstanceAttributeIfs().a1 #? int() str() InstanceAttributeIfs().a2 class A: def a(self, b): for x in [self.a(i) for i in b]: #? x class B: def a(self, b): for i in b: for i in self.a(i): #? yield i foo = int foo = foo # type: foo #? int foo while True: bar = int bar = bar # type: bar #? int() bar class Comprehension: def __init__(self, foo): self.foo = foo def update(self): self.foo = (self.foo,) #? int() tuple() Comprehension(1).foo[0] ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/completion/stdlib.py0000664000175000017500000001530600000000000017370 0ustar00davedave00000000000000""" std library stuff """ # ----------------- # builtins # ----------------- arr = [''] #? str() sorted(arr)[0] #? str() next(reversed(arr)) next(reversed(arr)) # should not fail if there's no return value. def yielder(): yield None #? None next(reversed(yielder())) # empty reversed should not raise an error #? next(reversed()) #? str() bytes() next(open('')) #? int() {'a':2}.setdefault('a', 3) # Compiled classes should have the meta class attributes. #? ['__itemsize__'] tuple.__itemsize__ #? [] tuple().__itemsize__ # ----------------- # type() calls with one parameter # ----------------- #? int type(1) #? int type(int()) #? type type(int) #? type type(type) #? list type([]) def x(): yield 1 generator = type(x()) #? generator type(x for x in []) #? type(x) type(lambda: x) import math import os #? type(os) type(math) class X(): pass #? type type(X) # ----------------- # type() calls with multiple parameters # ----------------- X = type('X', (object,), dict(a=1)) # Doesn't work yet. #? X.a #? X if os.path.isfile(): #? ['abspath'] fails = os.path.abspath # The type vars and other underscored things from typeshed should not be # findable. #? os._T with open('foo') as f: for line in f.readlines(): #? str() bytes() line # ----------------- # enumerate # ----------------- for i, j in enumerate(["as", "ad"]): #? int() i #? str() j # ----------------- # re # ----------------- import re c = re.compile(r'a') # re.compile should not return str -> issue #68 #? [] c.startswith #? int() c.match().start() #? int() re.match(r'a', 'a').start() for a in re.finditer('a', 'a'): #? int() a.start() # ----------------- # ref # ----------------- import weakref #? int() weakref.proxy(1) #? weakref.ref() weakref.ref(1) #? int() None weakref.ref(1)() # ----------------- # sqlite3 (#84) # ----------------- import sqlite3 #? sqlite3.Connection() con = sqlite3.connect() #? sqlite3.Cursor() c = con.cursor() def huhu(db): """ :type db: sqlite3.Connection :param db: the db connection """ #? sqlite3.Connection() db with sqlite3.connect() as c: #? sqlite3.Connection() c # ----------------- # hashlib # ----------------- import hashlib #? ['md5'] hashlib.md5 # ----------------- # copy # ----------------- import copy #? int() copy.deepcopy(1) #? copy.copy() # ----------------- # json # ----------------- # We don't want any results for json, because it depends on IO. import json #? json.load('asdf') #? json.loads('[1]') # ----------------- # random # ----------------- import random class A(object): def say(self): pass class B(object): def shout(self): pass cls = random.choice([A, B]) #? ['say', 'shout'] cls().s # ----------------- # random # ----------------- import zipfile z = zipfile.ZipFile("foo") #? ['upper'] z.read('name').upper # ----------------- # contextlib # ----------------- from typing import Iterator import contextlib with contextlib.closing('asd') as string: #? str() string @contextlib.contextmanager def cm1() -> Iterator[float]: yield 1 with cm1() as x: #? float() x @contextlib.contextmanager def cm2() -> float: yield 1 with cm2() as x: #? x @contextlib.contextmanager def cm3(): yield 3 with cm3() as x: #? int() x # ----------------- # operator # ----------------- import operator f = operator.itemgetter(1) #? float() f([1.0]) #? str() f([1, '']) g = operator.itemgetter(1, 2) x1, x2 = g([1, 1.0, '']) #? float() x1 #? str() x2 x1, x2 = g([1, '']) #? str() x1 #? int() str() x2 # ----------------- # shlex # ----------------- # Github issue #929 import shlex qsplit = shlex.split("foo, ferwerwerw werw werw e") for part in qsplit: #? str() part # ----------------- # staticmethod, classmethod params # ----------------- class F(): def __init__(self): self.my_variable = 3 @staticmethod def my_func(param): #? [] param.my_ #? ['upper'] param.uppe #? str() return param @staticmethod def my_func_without_call(param): #? [] param.my_ #? [] param.uppe #? return param @classmethod def my_method_without_call(cls, param): #? cls.my_variable #? ['my_method', 'my_method_without_call'] cls.my_meth #? return param @classmethod def my_method(cls, param): #? cls.my_variable #? ['my_method', 'my_method_without_call'] cls.my_meth #? return param #? str() F.my_func('') #? str() F.my_method('') # ----------------- # Unknown metaclass # ----------------- # Github issue 1321 class Meta(object): pass class Test(metaclass=Meta): def test_function(self): result = super(Test, self).test_function() #? [] result. # ----------------- # Enum # ----------------- import enum class X(enum.Enum): attr_x = 3 attr_y = 2.0 #? ['mro'] X.mro #? ['attr_x', 'attr_y'] X.attr_ #? str() X.attr_x.name #? int() X.attr_x.value #? str() X.attr_y.name #? float() X.attr_y.value #? str() X().name #? float() X().attr_x.attr_y.value # ----------------- # functools # ----------------- import functools basetwo = functools.partial(int, base=2) #? int() basetwo() def function(a, b): return a, b a = functools.partial(function, 0) #? int() a('')[0] #? str() a('')[1] kw = functools.partial(function, b=1.0) tup = kw(1) #? int() tup[0] #? float() tup[1] def my_decorator(f): @functools.wraps(f) def wrapper(*args, **kwds): return f(*args, **kwds) return wrapper @my_decorator def example(a): return a #? str() example('') # From GH #1574 #? float() functools.wraps(functools.partial(str, 1))(lambda: 1.0)() class X: def function(self, a, b): return a, b a = functools.partialmethod(function, 0) kw = functools.partialmethod(function, b=1.0) just_partial = functools.partial(function, 1, 2.0) #? int() X().a('')[0] #? str() X().a('')[1] # The access of partialmethods on classes are not 100% correct. This doesn't # really matter, because nobody uses it like that anyway and would take quite a # bit of work to fix all of these cases. #? str() X.a('')[0] #? X.a('')[1] #? X() X.a(X(), '')[0] #? str() X.a(X(), '')[1] tup = X().kw(1) #? int() tup[0] #? float() tup[1] tup = X.kw(1) #? tup[0] #? float() tup[1] tup = X.kw(X(), 1) #? int() tup[0] #? float() tup[1] #? float() X.just_partial('')[0] #? str() X.just_partial('')[1] #? float() X().just_partial('')[0] #? str() X().just_partial('')[1] # python >= 3.8 @functools.lru_cache def x() -> int: ... @functools.lru_cache() def y() -> float: ... @functools.lru_cache(8) def z() -> str: ... #? int() x() #? float() y() #? str() z() ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4703794 jedi-0.19.1/test/completion/stub_folder/0000775000175000017500000000000000000000000020040 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/completion/stub_folder/stub_only.pyi0000664000175000017500000000010300000000000022573 0ustar00davedave00000000000000in_stub_only: int class Foo(Bar): pass class Bar: pass ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4703794 jedi-0.19.1/test/completion/stub_folder/stub_only_folder/0000775000175000017500000000000000000000000023411 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/completion/stub_folder/stub_only_folder/__init__.pyi0000664000175000017500000000003100000000000025665 0ustar00davedave00000000000000in_stub_only_folder: int ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/completion/stub_folder/stub_only_folder/nested_stub_only.pyi0000664000175000017500000000002200000000000027506 0ustar00davedave00000000000000in_stub_only: int ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/completion/stub_folder/stub_only_folder/nested_with_stub.py0000664000175000017500000000003400000000000027332 0ustar00davedave00000000000000in_python = '' in_both = '' ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/completion/stub_folder/stub_only_folder/nested_with_stub.pyi0000664000175000017500000000003400000000000027503 0ustar00davedave00000000000000in_stub: int in_both: float ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/completion/stub_folder/stub_only_folder/python_only.py0000664000175000017500000000001700000000000026343 0ustar00davedave00000000000000in_python = '' ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/completion/stub_folder/with_stub.py0000664000175000017500000000020200000000000022414 0ustar00davedave00000000000000in_with_stub_both = 5 in_with_stub_python = 8 def stub_function(x: float, y): """ Python docstring """ return 1 ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/completion/stub_folder/with_stub.pyi0000664000175000017500000000014700000000000022575 0ustar00davedave00000000000000in_with_stub_both: str in_with_stub_stub: float def stub_function(x: int, y: float) -> str: pass ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4703794 jedi-0.19.1/test/completion/stub_folder/with_stub_folder/0000775000175000017500000000000000000000000023403 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/completion/stub_folder/with_stub_folder/__init__.py0000664000175000017500000000007400000000000025515 0ustar00davedave00000000000000in_with_stub_both_folder = 5 in_with_stub_python_folder = 8 ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/completion/stub_folder/with_stub_folder/__init__.pyi0000664000175000017500000000007600000000000025670 0ustar00davedave00000000000000in_with_stub_both_folder: str in_with_stub_stub_folder: float ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/completion/stub_folder/with_stub_folder/nested_stub_only.pyi0000664000175000017500000000007000000000000027503 0ustar00davedave00000000000000if 1: in_stub_only: int else: in_stub_only: int ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/completion/stub_folder/with_stub_folder/nested_with_stub.py0000664000175000017500000000003400000000000027324 0ustar00davedave00000000000000in_python = '' in_both = '' ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/completion/stub_folder/with_stub_folder/nested_with_stub.pyi0000664000175000017500000000003400000000000027475 0ustar00davedave00000000000000in_stub: int in_both: float ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/completion/stub_folder/with_stub_folder/python_only.py0000664000175000017500000000001700000000000026335 0ustar00davedave00000000000000in_python = '' ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/completion/stubs.py0000664000175000017500000000450600000000000017247 0ustar00davedave00000000000000from stub_folder import with_stub, stub_only, with_stub_folder, stub_only_folder # ------------------------- # Just files # ------------------------- #? int() stub_only.in_stub_only #? str() with_stub.in_with_stub_both #? int() with_stub.in_with_stub_python #? float() with_stub.in_with_stub_stub #! ['in_stub_only: int'] stub_only.in_stub_only #! ['in_with_stub_both = 5'] with_stub.in_with_stub_both #! ['in_with_stub_python = 8'] with_stub.in_with_stub_python #! ['in_with_stub_stub: float'] with_stub.in_with_stub_stub #? ['in_stub_only'] stub_only.in_ #? ['in_stub_only'] from stub_folder.stub_only import in_ #? ['in_with_stub_both', 'in_with_stub_python', 'in_with_stub_stub'] with_stub.in_ #? ['in_with_stub_both', 'in_with_stub_python', 'in_with_stub_stub'] from stub_folder.with_stub import in_ #? ['with_stub', 'stub_only', 'with_stub_folder', 'stub_only_folder'] from stub_folder. # ------------------------- # Folders # ------------------------- #? int() stub_only_folder.in_stub_only_folder #? str() with_stub_folder.in_with_stub_both_folder #? int() with_stub_folder.in_with_stub_python_folder #? float() with_stub_folder.in_with_stub_stub_folder #? ['in_stub_only_folder'] stub_only_folder.in_ #? ['in_with_stub_both_folder', 'in_with_stub_python_folder', 'in_with_stub_stub_folder'] with_stub_folder.in_ # ------------------------- # Folders nested with stubs # ------------------------- from stub_folder.with_stub_folder import nested_stub_only, nested_with_stub, \ python_only #? int() nested_stub_only.in_stub_only #? float() nested_with_stub.in_both #? str() nested_with_stub.in_python #? int() nested_with_stub.in_stub #? str() python_only.in_python #? ['in_stub_only_folder'] stub_only_folder.in_ #? ['in_with_stub_both_folder', 'in_with_stub_python_folder', 'in_with_stub_stub_folder'] with_stub_folder.in_ #? ['in_python'] python_only.in_ # ------------------------- # Folders nested with stubs # ------------------------- from stub_folder.stub_only_folder import nested_stub_only, nested_with_stub, \ python_only #? int() nested_stub_only.in_stub_only #? float() nested_with_stub.in_both #? str() nested_with_stub.in_python #? int() nested_with_stub.in_stub #? str() python_only.in_python #? ['in_stub_only'] nested_stub_only.in_ #? ['in_both', 'in_python', 'in_stub'] nested_with_stub.in_ #? ['in_python'] python_only.in_ ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/completion/sys_path.py0000664000175000017500000000071400000000000017736 0ustar00davedave00000000000000 import sys import os from os.path import dirname sys.path.insert(0, '../../jedi') sys.path.append(os.path.join(dirname(__file__), 'thirdparty')) # modifications, that should fail: # syntax err sys.path.append('a' +* '/thirdparty') #? ['inference'] import inference #? ['inference_state_function_cache'] inference.inference_state_fu # Those don't work because dirname and abspath are not properly understood. #? ['jedi_'] import jedi_ #? ['el'] jedi_.el ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4703794 jedi-0.19.1/test/completion/thirdparty/0000775000175000017500000000000000000000000017722 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/completion/thirdparty/PyQt4_.py0000664000175000017500000000050000000000000021407 0ustar00davedave00000000000000from PyQt4.QtCore import * from PyQt4.QtGui import * #? ['QActionGroup'] QActionGroup #? ['currentText'] QStyleOptionComboBox().currentText #? [] QStyleOptionComboBox().currentText. from PyQt4 import QtGui #? ['currentText'] QtGui.QStyleOptionComboBox().currentText #? [] QtGui.QStyleOptionComboBox().currentText. ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/completion/thirdparty/jedi_.py0000664000175000017500000000271600000000000021354 0ustar00davedave00000000000000 from jedi import functions, inference, parsing el = functions.complete()[0] #? ['description'] el.description #? str() el.description scopes, path, dot, like = \ api._prepare_goto(source, row, column, path, True) # has problems with that (sometimes) very deep nesting. #? set() el = scopes # get_names_for_scope is also recursion stuff #? tuple() el = list(inference.get_names_for_scope())[0] #? int() parsing.Module() el = list(inference.get_names_for_scope(1))[0][0] #? parsing.Module() el = list(inference.get_names_for_scope())[0][0] #? list() el = list(inference.get_names_for_scope(1))[0][1] #? list() el = list(inference.get_names_for_scope())[0][1] #? list() parsing.Scope((0,0)).get_set_vars() #? parsing.Import() parsing.Name() parsing.Scope((0,0)).get_set_vars()[0] # TODO access parent is not possible, because that is not set in the class ## parsing.Class() parsing.Scope((0,0)).get_set_vars()[0].parent #? parsing.Import() parsing.Name() el = list(inference.get_names_for_scope())[0][1][0] #? inference.Array() inference.Class() inference.Function() inference.Instance() list(inference.follow_call())[0] # With the right recursion settings, this should be possible (and maybe more): # Array Class Function Generator Instance Module # However, this was produced with the recursion settings 10/350/10000, and # lasted 18.5 seconds. So we just have to be content with the results. #? inference.Class() inference.Function() inference.get_scopes_for_name()[0] ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/completion/thirdparty/psycopg2_.py0000664000175000017500000000020600000000000022177 0ustar00davedave00000000000000import psycopg2 conn = psycopg2.connect('dbname=test') #? ['cursor'] conn.cursor cur = conn.cursor() #? ['fetchall'] cur.fetchall ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/completion/thirdparty/pylab_.py0000664000175000017500000000104000000000000021535 0ustar00davedave00000000000000import pylab # two gotos #! ['module numpy'] import numpy #! ['module random'] import numpy.random #? ['array2string'] numpy.array2string #? ['shape'] numpy.matrix().shape #? ['random_integers'] pylab.random_integers #? [] numpy.random_integers #? ['random_integers'] numpy.random.random_integers #? ['sample'] numpy.random.sample import numpy na = numpy.array([1,2]) #? ['shape'] na.shape # shouldn't raise an error #29, jedi-vim # doesn't return something, because matplotlib uses __import__ fig = pylab.figure() #? fig.add_subplot ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/completion/types.py0000664000175000017500000000427400000000000017255 0ustar00davedave00000000000000# ----------------- # non array # ----------------- #? ['imag'] int.imag #? [] int.is_integer #? ['is_integer'] float.is_int #? ['is_integer'] 1.0.is_integer #? ['upper'] "".upper #? ['upper'] r"".upper # strangely this didn't work, because the = is used for assignments #? ['upper'] "=".upper a = "=" #? ['upper'] a.upper # ----------------- # lists # ----------------- arr = [] #? ['append'] arr.app #? ['append'] list().app #? ['append'] [].append arr2 = [1,2,3] #? ['append'] arr2.app #? int() arr.count(1) x = [] #? x.pop() x = [3] #? int() x.pop() x = [] x.append(1.0) #? float() x.pop() # ----------------- # dicts # ----------------- dic = {} #? ['copy', 'clear'] dic.c dic2 = dict(a=1, b=2) #? ['pop', 'popitem'] dic2.p #? ['popitem'] {}.popitem dic2 = {'asdf': 3} #? ['popitem'] dic2.popitem #? int() dic2['asdf'] d = {'a': 3, 1.0: list} #? int() list d.values()[0] ##? int() list dict(d).values()[0] #? str() d.items()[0][0] #? int() d.items()[0][1] (a, b), = {a:1 for a in [1.0]}.items() #? float() a #? int() b # ----------------- # tuples # ----------------- tup = ('',2) #? ['count'] tup.c tup2 = tuple() #? ['index'] tup2.i #? ['index'] ().i tup3 = 1,"" #? ['index'] tup3.index tup4 = 1,"" #? ['index'] tup4.index # ----------------- # set # ----------------- set_t = {1,2} #? ['clear', 'copy'] set_t.c set_t2 = set() #? ['clear', 'copy'] set_t2.c # ----------------- # pep 448 unpacking generalizations # ----------------- d = {'a': 3} dc = {v: 3 for v in ['a']} #? dict() {**d} #? dict() {**dc} #? str() {**d, "b": "b"}["b"] #? str() {**dc, "b": "b"}["b"] # Should resolve to int() but jedi is not smart enough yet # Here to make sure it doesn't result in crash though #? {**d}["a"] # Should resolve to int() but jedi is not smart enough yet # Here to make sure it doesn't result in crash though #? {**dc}["a"] s = {1, 2, 3} #? set() {*s} #? set() {*s, 4, *s} s = {1, 2, 3} # Should resolve to int() but jedi is not smart enough yet # Here to make sure it doesn't result in crash though #? {*s}.pop() #? int() {*s, 4}.pop() # Should resolve to int() but jedi is not smart enough yet # Here to make sure it doesn't result in crash though #? [*s][0] #? int() [*s, 4][0] ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/completion/usages.py0000664000175000017500000002047400000000000017400 0ustar00davedave00000000000000""" Renaming tests. This means search for references. I always leave a little bit of space to add room for additions, because the results always contain position informations. """ #< 4 (0,4), (3,0), (5,0), (12,4), (14,5), (15,0), (17,0), (19,0) def abcd(): pass #< 0 (-3,4), (0,0), (2,0), (9,4), (11,5), (12,0), (14,0), (16,0) abcd.d.a.bsaasd.abcd.d abcd # unicode chars shouldn't be a problem. x['smörbröd'].abcd # With the new parser these statements are not recognized as stateents, because # they are not valid Python. if 1: abcd = else: (abcd) = abcd = #< (-17,4), (-14,0), (-12,0), (0,0), (2,0), (-2,0), (-3,5), (-5,4) abcd abcd = 5 Abc = 3 #< 6 (-3,0), (0,6), (2,4), (5,8), (17,0) class Abc(): #< (-5,0), (-2,6), (0,4), (2,8), (3,8), (15,0) Abc def Abc(self): Abc; self.c = 3 #< 17 (0,16), (2,8) def a(self, Abc): #< 10 (-2,16), (0,8) Abc #< 19 (0,18), (2,8) def self_test(self): #< 12 (-2,18), (0,8) self.b Abc.d.Abc #< 4 (0,4), (5,1) def blubi(): pass #< (-5,4), (0,1) @blubi def a(): pass #< 0 (0,0), (1,0) set_object_var = object() set_object_var.var = 1 def func(a, b): a = 12 #< 4 (0,4), (3,8) c = a if True: #< 8 (-3,4), (0,8) c = b response = 5 #< 0 (-2,0), (0,0), (1,0), (2,0), (4,0) response = HttpResponse(mimetype='application/pdf') response['Content-Disposition'] = 'attachment; filename=%s.pdf' % id response.write(pdf) #< (-6,0), (-4,0), (-3,0), (-2,0), (0,0) response # ----------------- # imports # ----------------- #< (0,7), (3,0) import module_not_exists #< (-3,7), (0,0) module_not_exists #< ('import_tree.rename1', 1,0), (0,24), (3,0), (6,17), ('import_tree.rename2', 4,17), (11,17), (14,17), ('imports', 72, 16) from import_tree import rename1 #< (0,8), ('import_tree.rename1',3,0), ('import_tree.rename2',4,32), ('import_tree.rename2',6,0), (3,32), (8,32), (5,0) rename1.abc #< (-3,8), ('import_tree.rename1', 3,0), ('import_tree.rename2', 4,32), ('import_tree.rename2', 6,0), (0,32), (5,32), (2,0) from import_tree.rename1 import abc #< (-5,8), (-2,32), ('import_tree.rename1', 3,0), ('import_tree.rename2', 4,32), ('import_tree.rename2', 6,0), (0,0), (3,32) abc #< 20 ('import_tree.rename1', 1,0), ('import_tree.rename2', 4,17), (-11,24), (-8,0), (-5,17), (0,17), (3,17), ('imports', 72, 16) from import_tree.rename1 import abc #< (0, 32), from import_tree.rename1 import not_existing # Shouldn't raise an error or do anything weird. from not_existing import * # ----------------- # classes # ----------------- class TestMethods(object): #< 8 (0,8), (2,13) def a_method(self): #< 13 (-2,8), (0,13) self.a_method() #< 13 (2,8), (0,13), (3,13) self.b_method() def b_method(self): self.b_method class TestClassVar(object): #< 4 (0,4), (5,13), (7,21) class_v = 1 def a(self): class_v = 1 #< (-5,4), (0,13), (2,21) self.class_v #< (-7,4), (-2,13), (0,21) TestClassVar.class_v #< (0,8), (-7, 8) class_v class TestInstanceVar(): def a(self): #< 13 (4,13), (0,13) self._instance_var = 3 def b(self): #< (-4,13), (0,13) self._instance_var # A call to self used to trigger an error, because it's also a trailer # with two children. self() class NestedClass(): def __getattr__(self, name): return self # Shouldn't find a definition, because there's other `instance`. #< (0, 14), NestedClass().instance # ----------------- # inheritance # ----------------- class Super(object): #< 4 (0,4), (23,18), (25,13) base_class = 1 #< 4 (0,4), class_var = 1 #< 8 (0,8), def base_method(self): #< 13 (0,13), (20,13) self.base_var = 1 #< 13 (0,13), self.instance_var = 1 #< 8 (0,8), def just_a_method(self): pass #< 20 (0,16), (-18,6) class TestClass(Super): #< 4 (0,4), class_var = 1 def x_method(self): #< (0,18), (2,13), (-23,4) TestClass.base_class #< (-2,18), (0,13), (-25,4) self.base_class #< (-20,13), (0,13) self.base_var #< (0, 18), TestClass.base_var #< 13 (5,13), (0,13) self.instance_var = 3 #< 9 (0,8), def just_a_method(self): #< (-5,13), (0,13) self.instance_var # ----------------- # properties # ----------------- class TestProperty: @property #< 10 (0,8), (5,13) def prop(self): return 1 def a(self): #< 13 (-5,8), (0,13) self.prop @property #< 13 (0,8), (4,5), (6,8), (11,13) def rw_prop(self): return self._rw_prop #< 8 (-4,8), (0,5), (2,8), (7,13) @rw_prop.setter #< 8 (-6,8), (-2,5), (0,8), (5,13) def rw_prop(self, value): self._rw_prop = value def b(self): #< 13 (-11,8), (-7,5), (-5,8), (0,13) self.rw_prop # ----------------- # *args, **kwargs # ----------------- #< 11 (1,11), (0,8) def f(**kwargs): return kwargs # ----------------- # No result # ----------------- if isinstance(j, int): #< (0, 4), j # ----------------- # Dynamic Param Search # ----------------- class DynamicParam(): def foo(self): return def check(instance): #< 13 (-5,8), (0,13) instance.foo() check(DynamicParam()) # ----------------- # Compiled Objects # ----------------- import _sre # TODO reenable this, it's currently not working, because of 2/3 # inconsistencies in typeshed (_sre exists in typeshed/2, but not in # typeshed/3). ##< 0 (-3,7), (0,0), ('_sre', None, None) _sre # ----------------- # on syntax # ----------------- #< 0 import undefined # ----------------- # comprehensions # ----------------- #< 0 (0,0), (2,12) x = 32 #< 12 (-2,0), (0,12) [x for x in x] #< 0 (0,0), (2,1), (2,12) y = 32 #< 12 (-2,0), (0,1), (0,12) [y for b in y] #< 1 (0,1), (0,7) [x for x in something] #< 7 (0,1), (0,7) [x for x in something] z = 3 #< 1 (0,1), (0,10) {z:1 for z in something} #< 10 (0,1), (0,10) {z:1 for z in something} #< 8 (0,6), (0, 40) [[x + nested_loopv2 for x in bar()] for nested_loopv2 in baz()] #< 25 (0,20), (0, 65) (("*" if abs(foo(x, nested_loopv1)) else " " for x in bar()) for nested_loopv1 in baz()) def whatever_func(): zzz = 3 if UNDEFINED: zzz = 5 if UNDEFINED2: #< (3, 8), (4, 4), (0, 12), (-3, 8), (-5, 4) zzz else: #< (0, 8), (1, 4), (-3, 12), (-6, 8), (-8, 4) zzz zzz # ----------------- # global # ----------------- def global_usage1(): #< (0, 4), (4, 11), (6, 4), (9, 8), (12, 4) my_global def global_definition(): #< (-4, 4), (0, 11), (2, 4), (5, 8), (8, 4) global my_global #< 4 (-6, 4), (-2, 11), (0, 4), (3, 8), (6, 4) my_global = 3 if WHATEVER: #< 8 (-9, 4), (-5, 11), (-3, 4), (0, 8), (3, 4) my_global = 4 def global_usage2() my_global def not_global(my_global): my_global class DefinitelyNotGlobal: def my_global(self): def my_global(self): pass # ----------------- # stubs # ----------------- from stub_folder import with_stub #< ('stub:stub_folder.with_stub', 5, 4), ('stub_folder.with_stub', 5, 4), (0, 10) with_stub.stub_function from stub_folder.with_stub_folder.nested_stub_only import in_stub_only #< ('stub:stub_folder.with_stub_folder.nested_stub_only', 2, 4), ('stub:stub_folder.with_stub_folder.nested_stub_only', 4, 4), ('stubs', 64, 17), (-2, 58), (0, 0) in_stub_only from stub_folder.with_stub_folder.nested_with_stub import in_python #< ('stub_folder.with_stub_folder.nested_with_stub', 1, 0), ('stubs', 68, 17), (-2, 58), (0, 0) in_python from stub_folder.with_stub_folder.nested_with_stub import in_both #< ('stub_folder.with_stub_folder.nested_with_stub', 2, 0), ('stub:stub_folder.with_stub_folder.nested_with_stub', 2, 0), ('stubs', 66, 17), (-2, 58), (0, 0) in_both # ----------------- # across directories # ----------------- #< 8 (0, 0), (3, 4), ('import_tree.references', 1, 21), ('import_tree.references', 5, 4) usage_definition = 1 if False: #< 8 (-3, 0), (0, 4), ('import_tree.references', 1, 21), ('import_tree.references', 5, 4) usage_definition() # ----------------- # stdlib stuff # ----------------- import socket #< (1, 21), (0, 7), ('socket', ..., 6), ('stub:socket', ..., 4), ('imports', ..., 7) socket.SocketIO some_socket = socket.SocketIO() ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/conftest.py0000664000175000017500000001341200000000000015557 0ustar00davedave00000000000000import os import sys import subprocess import pytest from . import helpers from . import run from . import refactor from jedi import InterpreterEnvironment, get_system_environment from jedi.inference.compiled.value import create_from_access_path from jedi.api.interpreter import MixedModuleContext # For interpreter tests sometimes the path of this directory is in the sys # path, which we definitely don't want. So just remove it globally. try: sys.path.remove(helpers.test_dir) except ValueError: pass def pytest_addoption(parser): parser.addoption( "--integration-case-dir", default=os.path.join(helpers.test_dir, 'completion'), help="Directory in which integration test case files locate.") parser.addoption( "--refactor-case-dir", default=os.path.join(helpers.test_dir, 'refactor'), help="Directory in which refactoring test case files locate.") parser.addoption( "--test-files", "-T", default=[], action='append', help=( "Specify test files using FILE_NAME[:LINE[,LINE[,...]]]. " "For example: -T generators.py:10,13,19. " "Note that you can use -m to specify the test case by id.")) parser.addoption( "--thirdparty", action='store_true', help="Include integration tests that requires third party modules.") def parse_test_files_option(opt): """ Parse option passed to --test-files into a key-value pair. >>> parse_test_files_option('generators.py:10,13,19') ('generators.py', [10, 13, 19]) """ opt = str(opt) if ':' in opt: (f_name, rest) = opt.split(':', 1) return f_name, list(map(int, rest.split(','))) else: return opt, [] def pytest_generate_tests(metafunc): """ :type metafunc: _pytest.python.Metafunc """ test_files = dict(map(parse_test_files_option, metafunc.config.option.test_files)) if 'case' in metafunc.fixturenames: base_dir = metafunc.config.option.integration_case_dir thirdparty = metafunc.config.option.thirdparty cases = list(run.collect_dir_tests(base_dir, test_files)) if thirdparty: cases.extend(run.collect_dir_tests( os.path.join(base_dir, 'thirdparty'), test_files, True)) ids = ["%s:%s" % (c.module_name, c.line_nr_test) for c in cases] metafunc.parametrize('case', cases, ids=ids) if 'refactor_case' in metafunc.fixturenames: base_dir = metafunc.config.option.refactor_case_dir cases = list(refactor.collect_dir_tests(base_dir, test_files)) metafunc.parametrize( 'refactor_case', cases, ids=[c.refactor_type + '-' + c.name for c in cases] ) if 'static_analysis_case' in metafunc.fixturenames: base_dir = os.path.join(os.path.dirname(__file__), 'static_analysis') cases = list(collect_static_analysis_tests(base_dir, test_files)) metafunc.parametrize( 'static_analysis_case', cases, ids=[c.name for c in cases] ) def collect_static_analysis_tests(base_dir, test_files): for f_name in os.listdir(base_dir): files_to_execute = [a for a in test_files.items() if a[0] in f_name] if f_name.endswith(".py") and (not test_files or files_to_execute): path = os.path.join(base_dir, f_name) yield run.StaticAnalysisCase(path) @pytest.fixture(scope='session') def venv_path(tmpdir_factory, environment): if isinstance(environment, InterpreterEnvironment): # The environment can be a tox virtualenv environment which we don't # want, so use the system environment. environment = get_system_environment( '.'.join(str(x) for x in environment.version_info[:2]) ) tmpdir = tmpdir_factory.mktemp('venv_path') dirname = os.path.join(tmpdir.strpath, 'venv') # We cannot use the Python from tox because tox creates virtualenvs and # they have different site.py files that work differently than the default # ones. Instead, we find the real Python executable by printing the value # of sys.base_prefix or sys.real_prefix if we are in a virtualenv. output = subprocess.check_output([ environment.executable, "-c", "import sys; " "print(sys.real_prefix if hasattr(sys, 'real_prefix') else sys.base_prefix)" ]) prefix = output.rstrip().decode('utf8') if os.name == 'nt': executable_path = os.path.join(prefix, 'python') else: executable_name = os.path.basename(environment.executable) executable_path = os.path.join(prefix, 'bin', executable_name) return_code = subprocess.call([executable_path, '-m', 'venv', dirname]) assert return_code == 0, return_code return dirname @pytest.fixture() def cwd_tmpdir(monkeypatch, tmpdir): with helpers.set_cwd(tmpdir.strpath): yield tmpdir @pytest.fixture def inference_state(Script): return Script('')._inference_state @pytest.fixture def same_process_inference_state(Script): return Script('', environment=InterpreterEnvironment())._inference_state @pytest.fixture def disable_typeshed(monkeypatch): from jedi.inference.gradual import typeshed monkeypatch.setattr(typeshed, '_load_from_typeshed', lambda *args, **kwargs: None) @pytest.fixture def create_compiled_object(inference_state): return lambda obj: create_from_access_path( inference_state, inference_state.compiled_subprocess.create_simple_object(obj) ) @pytest.fixture(params=[False, True]) def class_findable(monkeypatch, request): if not request.param: monkeypatch.setattr( MixedModuleContext, '_get_mixed_object', lambda self, compiled_object: compiled_object.as_context() ) return request.param ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4703794 jedi-0.19.1/test/examples/0000775000175000017500000000000000000000000015175 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/examples/README.rst0000664000175000017500000000023300000000000016662 0ustar00davedave00000000000000Examples ======== Here you can find project structures that match other Python projects. This is then used to check if jedi understands these structures. ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4703794 jedi-0.19.1/test/examples/buildout_project/0000775000175000017500000000000000000000000020552 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4703794 jedi-0.19.1/test/examples/buildout_project/bin/0000775000175000017500000000000000000000000021322 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/examples/buildout_project/bin/app0000664000175000017500000000034700000000000022031 0ustar00davedave00000000000000#!/usr/bin/python import sys sys.path[0:0] = [ '/usr/lib/python3.8/site-packages', '/tmp/.buildout/eggs/important_package.egg' ] import important_package if __name__ == '__main__': sys.exit(important_package.main()) ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/examples/buildout_project/bin/binary_file0000664000175000017500000000000500000000000023523 0ustar00davedave00000000000000PNG ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/examples/buildout_project/bin/empty_file0000664000175000017500000000000000000000000023370 0ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/examples/buildout_project/buildout.cfg0000664000175000017500000000000000000000000023050 0ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.3863792 jedi-0.19.1/test/examples/buildout_project/src/0000775000175000017500000000000000000000000021341 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4703794 jedi-0.19.1/test/examples/buildout_project/src/proj_name/0000775000175000017500000000000000000000000023313 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/examples/buildout_project/src/proj_name/module_name.py0000664000175000017500000000000000000000000026140 0ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4703794 jedi-0.19.1/test/examples/django/0000775000175000017500000000000000000000000016437 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4703794 jedi-0.19.1/test/examples/django/app/0000775000175000017500000000000000000000000017217 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/examples/django/app/__init__.py0000664000175000017500000000000000000000000021316 0ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/examples/django/app/models.py0000664000175000017500000000002200000000000021046 0ustar00davedave00000000000000SomeModel = "bar" ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/examples/django/manage.py0000664000175000017500000000037100000000000020242 0ustar00davedave00000000000000#!/usr/bin/env python import os import sys if __name__ == "__main__": os.environ.setdefault("DJANGO_SETTINGS_MODULE", "foobar.settings") from django.core.management import execute_from_command_line execute_from_command_line(sys.argv) ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4703794 jedi-0.19.1/test/examples/flask-site-packages/0000775000175000017500000000000000000000000021013 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4703794 jedi-0.19.1/test/examples/flask-site-packages/flask/0000775000175000017500000000000000000000000022113 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/examples/flask-site-packages/flask/__init__.py0000664000175000017500000000002500000000000024221 0ustar00davedave00000000000000 ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4703794 jedi-0.19.1/test/examples/flask-site-packages/flask/ext/0000775000175000017500000000000000000000000022713 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/examples/flask-site-packages/flask/ext/__init__.py0000664000175000017500000000000100000000000025013 0ustar00davedave00000000000000 ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4703794 jedi-0.19.1/test/examples/flask-site-packages/flask_baz/0000775000175000017500000000000000000000000022747 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/examples/flask-site-packages/flask_baz/__init__.py0000664000175000017500000000001000000000000025047 0ustar00davedave00000000000000Baz = 1 ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/examples/flask-site-packages/flask_foo.py0000664000175000017500000000003400000000000023325 0ustar00davedave00000000000000class Foo(object): pass ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4703794 jedi-0.19.1/test/examples/flask-site-packages/flaskext/0000775000175000017500000000000000000000000022634 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/examples/flask-site-packages/flaskext/__init__.py0000664000175000017500000000000000000000000024733 0ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/examples/flask-site-packages/flaskext/bar.py0000664000175000017500000000003400000000000023747 0ustar00davedave00000000000000class Bar(object): pass ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4703794 jedi-0.19.1/test/examples/flask-site-packages/flaskext/moo/0000775000175000017500000000000000000000000023426 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/examples/flask-site-packages/flaskext/moo/__init__.py0000664000175000017500000000001000000000000025526 0ustar00davedave00000000000000Moo = 1 ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.3863792 jedi-0.19.1/test/examples/implicit_namespace_package/0000775000175000017500000000000000000000000022476 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.3863792 jedi-0.19.1/test/examples/implicit_namespace_package/ns1/0000775000175000017500000000000000000000000023177 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4703794 jedi-0.19.1/test/examples/implicit_namespace_package/ns1/pkg/0000775000175000017500000000000000000000000023760 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/examples/implicit_namespace_package/ns1/pkg/ns1_file.py0000664000175000017500000000002200000000000026024 0ustar00davedave00000000000000foo = 'ns1_file!' ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.3863792 jedi-0.19.1/test/examples/implicit_namespace_package/ns2/0000775000175000017500000000000000000000000023200 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4703794 jedi-0.19.1/test/examples/implicit_namespace_package/ns2/pkg/0000775000175000017500000000000000000000000023761 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/examples/implicit_namespace_package/ns2/pkg/ns2_file.py0000664000175000017500000000002200000000000026026 0ustar00davedave00000000000000foo = 'ns2_file!' ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.3863792 jedi-0.19.1/test/examples/implicit_nested_namespaces/0000775000175000017500000000000000000000000022550 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.3863792 jedi-0.19.1/test/examples/implicit_nested_namespaces/namespace/0000775000175000017500000000000000000000000024504 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4703794 jedi-0.19.1/test/examples/implicit_nested_namespaces/namespace/pkg/0000775000175000017500000000000000000000000025265 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/examples/implicit_nested_namespaces/namespace/pkg/module.py0000664000175000017500000000001200000000000027115 0ustar00davedave00000000000000CONST = 1 ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4703794 jedi-0.19.1/test/examples/import-recursion/0000775000175000017500000000000000000000000020516 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4703794 jedi-0.19.1/test/examples/import-recursion/cadquery_simple/0000775000175000017500000000000000000000000023704 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/examples/import-recursion/cadquery_simple/__init__.py0000664000175000017500000000003200000000000026010 0ustar00davedave00000000000000from .cq import selectors ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/examples/import-recursion/cadquery_simple/cq.py0000664000175000017500000000003000000000000024652 0ustar00davedave00000000000000from . import selectors ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/examples/import-recursion/cq_example.py0000664000175000017500000000004200000000000023202 0ustar00davedave00000000000000import cadquery_simple as cq cq. ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.3863792 jedi-0.19.1/test/examples/inheritance/0000775000175000017500000000000000000000000017466 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4703794 jedi-0.19.1/test/examples/inheritance/pkg/0000775000175000017500000000000000000000000020247 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/examples/inheritance/pkg/__init__.py0000664000175000017500000000011200000000000022352 0ustar00davedave00000000000000from .module import Bar class Foo(Bar): def foo(self): pass ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/examples/inheritance/pkg/module.py0000664000175000017500000000005400000000000022105 0ustar00davedave00000000000000 class Bar: def bar(self): pass ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4703794 jedi-0.19.1/test/examples/init_extension_module/0000775000175000017500000000000000000000000021601 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/examples/init_extension_module/__init__.cpython-38-x86_64-linux-gnu.so0000775000175000017500000004166000000000000030510 0ustar00davedave00000000000000ELF>@:@8@# TT     $$PtdQtdRtd GNUKgoMkN=#4 `@ )֡BE|qX   a 8 R"u 0     __gmon_start___init_fini_ITM_deregisterTMCloneTable_ITM_registerTMCloneTable__cxa_finalize_Jv_RegisterClassesPyInit_init_extension_modulePyModule_Create2_Py_NoneStructPyModule_AddObjectlibpthread.so.0libc.so.6_edata__bss_start_endGLIBC_2.2.5ui  P @ @            HH Ht;H5 % @% h% h%b f%z fH=A HA UH)HHvH. Ht ]fD]@f.H= H5 UH)HHHH?HHtH Ht ]f]@f.= u'H= UHt H= EH] @f.H= H?u ^fDHy HtUH]@SH= HG H5HHH[HHfooinit_extension_module;l4\zRx $00FJ w?;*3$"DH0AnP    o8   0 oooo Vf@ GCC: (Ubuntu 5.4.0-6ubuntu1~16.04.12) 5.4.0 20160609,0  0D8"[` '] intZHi^ iAidA0=/ bA   (0*8 @ #H P lX rg` 9mh - bp  bt px @F ( T s  !{ U) \* c+ j, q.- /b 1 %gX gmNb6  /   CfU4ir87%9b5 :bMp0 mmtxb|bxb { h jQ k  As    (a 0 8 &@% VHP P Xf Š `y Ð h Ė p0 Ȗx ɗ{ ʋf K ̀ Ϝ  8T ԙ  K ߶L      9  lz     1 (e A 0@  8 @^ H lP lX l` lh lp x M   Y  ^ lm qA r s{ t  W]lll }lll llll" bl l4 l&l 17bPll> [abzlll bll bl? bl  " &l 17lKlY } agbll [ W lh lllb W W x [? [ " ( lA ll L R lf  P ( buf )obj *llen + , .b   /b$ 0( 1 0 2 87 3 @ 4H 5f  7  b2 l2 b  8C I Y l2 u :d j l l -l l  _Q  dr erZ fr gr$ hr  i( jL0 kL8g lL@ mH nLP orXn pr`t qrh rrp srxZ tL) u vL0 xr yr zr {r |c }rH ~r rL r r r. rs ri r\ L  r r P G  r   L &( 0 z8 r@ H \     r P  M  L L L  y    8 F X M Q   y 5 3  4 5d 6b 8  t ( 9 get set doc l   bXlXb? }5 : o7 ( , - .A / 0l l7 1 = >b ?Ih Kq L M( N0 O8 Pz@ QqH RP SXY T`}ll w bll  l0<m l~U ` T  UsT !7  ` "Sm"s m" 0# 0$[[$BB% : ; I$ > $ >   I : ;  : ; I8 : ;I8 : ; I !I/ &I7I I: ; (  : ;  : ; I8 : ;I8 : ; 'II' : ; I8  : ; <'I.?: ; 'I@B4: ; I1B 1!4: ; I"4: ; I?<#4: ;I?<$.?<n: ; z /usr/lib/gcc/x86_64-linux-gnu/5/include/usr/include/x86_64-linux-gnu/bits/usr/include/usr/include/python3.8/usr/include/x86_64-linux-gnu/sys/usr/include/python3.8/cpythonmodule.cstddef.htypes.hstdio.hlibio.hpyport.htime.hpymem.hobject.hobject.hmethodobject.hdescrobject.hmoduleobject.hmodsupport.h  !=sizetypeobjobjprocnb_inplace_remaindernb_reservedPyMethodDef__ssize_ttp_richcomparenb_inttp_dealloc_IO_save_endtp_as_sequencetp_reprssizeobjargprocstridesTRACEMALLOC_INITIALIZED_IO_write_base_lockgetbufferprocnb_addnb_subtractreleasebufferprocnb_xortp_basestp_methods_IO_save_basetp_init_chain_cur_columntp_weaklistoffsettp_is_gcnb_absolutetp_name_objectgettertp_mronb_floor_divideternaryfuncmp_ass_subscriptob_refcntPy_hash_tnb_inplace_multiplyinitialized_IO_markertp_iternb_inplace_orm_copyallocfuncnb_divmodnb_true_divide_IO_FILEPyBufferProcstp_docunsigned charnb_inplace_true_dividenb_floattp_freesq_repeatmp_lengthPy_bufferPyMappingMethodstp_basevaluenb_inplace_powertp_vectorcall_offsetnb_remainderPyMemberDefnb_matrix_multiplyndim_IO_lock_ttp_hashtimezone_IO_read_ptr_posstdingetattrofunctp_getattro_markersPyVarObjectreprfunctp_descr_setlenfunctp_dictnb_negativem_sizenb_lshiftunaryfunctp_traversenb_inplace_matrix_multiplynewfunctp_as_mappingnb_inplace_subtracttp_setattrnb_inplace_addtraverseprocnb_inplace_xorPyModule_Create2closurenb_andtp_strmax_nframeformat_flags2getiterfunc_IO_read_basesq_concat_unused2PyNumberMethodssq_inplace_repeat_typeobjecttracingtp_flags_old_offsetreadonlym_cleartz_minuteswestssizeargfuncm_indexPyModuleDeflong long intnb_inplace_lshiftvectorcallfuncm_docdoubleinternalml_meth_IO_write_endPyModuleDef_SlotTRACEMALLOC_FINALIZEDob_sizePyObjecttp_iternexttp_cleartp_callbf_releasebufferPyCFunctioninquiry_IO_buf_basesuboffsetsPyModule_AddObject__pad1__pad2__pad3__pad4__pad5descrsetfunc_sbufnb_positivetp_memberssetattrfuncam_aiterhashfunc_modePyAsyncMethodswas_sq_ass_slicesq_itemtp_setattroGNU C11 5.4.0 20160609 -mtune=generic -march=x86-64 -g -g -g -O2 -fwrapv -fstack-protector-strong -fstack-protector-strong -fPIC -fstack-protector-strongsq_inplace_concatnb_invertm_slotsiternextfuncbf_getbufferm_traversedescrgetfuncvisitprocTRACEMALLOC_NOT_INITIALIZEDmp_subscriptlong long unsigned intPy_ssize_tinitproc__off_ttp_as_asyncnb_indextp_allocnb_rshiftuse_domainnb_inplace_andam_anextfreefuncsq_containsnb_booltp_getsettp_weaklist_IO_backup_base_shortbuftp_as_buffertp_vectorcall/home/dave/source/jedi/test/examples/init_extension_moduleobjobjargprocsq_ass_item_next__off64_trichcmpfuncPyGetSetDef_Py_tracemalloc_configm_inittp_printtp_version_tagtp_getattr_IO_buf_endtp_cachetp_basicsizem_namebinaryfuncshort intsettertp_itemsize_PyTraceMalloc_Config_vtable_offsetPyModuleDef_Basenb_inplace_rshiftnb_multiplytp_as_numbernb_inplace_floor_dividesetattrofuncgetattrfuncbufferinfonb_ortp_finalizePySequenceMethodsshapeml_docPyInit_init_extension_module_IO_read_endml_flagstp_delob_basedestructor_filenotz_dsttimetp_newsq_lengthob_typem_freeshort unsigned intstdouttp_descr_getslotm_base_IO_write_ptrnb_powermodule.c_Py_NoneStructwas_sq_slicem_methodsam_awaittp_subclassesml_nametp_dictoffset#*P*/S/0P8  @ p        @      . D S z P ` hP @     / 6 < K\k p |  0 " crtstuff.c__JCR_LIST__deregister_tm_clones__do_global_dtors_auxcompleted.7594__do_global_dtors_aux_fini_array_entryframe_dummy__frame_dummy_init_array_entrymodule.c__FRAME_END____JCR_END____dso_handle_DYNAMIC__GNU_EH_FRAME_HDR__TMC_END___GLOBAL_OFFSET_TABLE__ITM_deregisterTMCloneTable_edata_fini__gmon_start__PyModule_Create2_Py_NoneStruct_end__bss_startPyModule_AddObject_Jv_RegisterClassesPyInit_init_extension_module_ITM_registerTMCloneTable__cxa_finalize@@GLIBC_2.2.5_init.symtab.strtab.shstrtab.note.gnu.build-id.gnu.hash.dynsym.dynstr.gnu.version.gnu.version_r.rela.dyn.rela.plt.init.plt.got.text.fini.rodata.eh_frame_hdr.eh_frame.init_array.fini_array.jcr.dynamic.got.plt.data.bss.comment.debug_aranges.debug_info.debug_abbrev.debug_line.debug_str.debug_loc$.oH8 88@Ho Uo dnB0x  s@@0~pp0 2d     0 (@ @  050-!#+0*% 601I9A10"4 7././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/examples/init_extension_module/module.c0000664000175000017500000000044600000000000023236 0ustar00davedave00000000000000#include "Python.h" static struct PyModuleDef module = { PyModuleDef_HEAD_INIT, "init_extension_module", NULL, -1, NULL }; PyMODINIT_FUNC PyInit_init_extension_module(void){ PyObject *m = PyModule_Create(&module); PyModule_AddObject(m, "foo", Py_None); return m; } ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/examples/init_extension_module/setup.py0000664000175000017500000000037200000000000023315 0ustar00davedave00000000000000from distutils.core import setup, Extension setup(name='init_extension_module', version='0.0', description='', ext_modules=[ Extension('init_extension_module.__init__', sources=['module.c']) ] ) ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4703794 jedi-0.19.1/test/examples/issue1209/0000775000175000017500000000000000000000000016641 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/examples/issue1209/__init__.py0000664000175000017500000000000000000000000020740 0ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4703794 jedi-0.19.1/test/examples/issue1209/api/0000775000175000017500000000000000000000000017412 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/examples/issue1209/api/__init__.py0000664000175000017500000000000000000000000021511 0ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4703794 jedi-0.19.1/test/examples/issue1209/api/whatever/0000775000175000017500000000000000000000000021237 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/examples/issue1209/api/whatever/__init__.py0000664000175000017500000000000000000000000023336 0ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/examples/issue1209/api/whatever/api_test1.py0000664000175000017500000000000000000000000023470 0ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4703794 jedi-0.19.1/test/examples/issue1209/whatever/0000775000175000017500000000000000000000000020466 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/examples/issue1209/whatever/__init__.py0000664000175000017500000000000000000000000022565 0ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/examples/issue1209/whatever/test.py0000664000175000017500000000000000000000000022005 0ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.3863792 jedi-0.19.1/test/examples/namespace_package/0000775000175000017500000000000000000000000020604 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.3863792 jedi-0.19.1/test/examples/namespace_package/ns1/0000775000175000017500000000000000000000000021305 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4703794 jedi-0.19.1/test/examples/namespace_package/ns1/pkg/0000775000175000017500000000000000000000000022066 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/examples/namespace_package/ns1/pkg/__init__.py0000664000175000017500000000032600000000000024200 0ustar00davedave00000000000000foo = 'ns1!' # this is a namespace package try: import pkg_resources pkg_resources.declare_namespace(__name__) except ImportError: import pkgutil __path__ = pkgutil.extend_path(__path__, __name__) ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/examples/namespace_package/ns1/pkg/ns1_file.py0000664000175000017500000000002200000000000024132 0ustar00davedave00000000000000foo = 'ns1_file!' ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4703794 jedi-0.19.1/test/examples/namespace_package/ns1/pkg/ns1_folder/0000775000175000017500000000000000000000000024122 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/examples/namespace_package/ns1/pkg/ns1_folder/__init__.py0000664000175000017500000000002400000000000026227 0ustar00davedave00000000000000foo = 'ns1_folder!' ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.3863792 jedi-0.19.1/test/examples/namespace_package/ns2/0000775000175000017500000000000000000000000021306 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4703794 jedi-0.19.1/test/examples/namespace_package/ns2/pkg/0000775000175000017500000000000000000000000022067 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/examples/namespace_package/ns2/pkg/ns2_file.py0000664000175000017500000000002200000000000024134 0ustar00davedave00000000000000foo = 'ns2_file!' ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4703794 jedi-0.19.1/test/examples/namespace_package/ns2/pkg/ns2_folder/0000775000175000017500000000000000000000000024124 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/examples/namespace_package/ns2/pkg/ns2_folder/__init__.py0000664000175000017500000000002400000000000026231 0ustar00davedave00000000000000foo = 'ns2_folder!' ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4703794 jedi-0.19.1/test/examples/namespace_package/ns2/pkg/ns2_folder/nested/0000775000175000017500000000000000000000000025406 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/examples/namespace_package/ns2/pkg/ns2_folder/nested/__init__.py0000664000175000017500000000002000000000000027507 0ustar00davedave00000000000000foo = 'nested!' ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4703794 jedi-0.19.1/test/examples/namespace_package_relative_import/0000775000175000017500000000000000000000000024071 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/examples/namespace_package_relative_import/rel1.py0000664000175000017500000000002700000000000025305 0ustar00davedave00000000000000from .rel2 import name ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/examples/namespace_package_relative_import/rel2.py0000664000175000017500000000001100000000000025277 0ustar00davedave00000000000000name = 1 ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4703794 jedi-0.19.1/test/examples/nested_namespaces/0000775000175000017500000000000000000000000020656 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/examples/nested_namespaces/__init__.py0000664000175000017500000000000000000000000022755 0ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4703794 jedi-0.19.1/test/examples/nested_namespaces/namespace/0000775000175000017500000000000000000000000022612 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/examples/nested_namespaces/namespace/__init__.py0000664000175000017500000000013600000000000024723 0ustar00davedave00000000000000try: __import__('pkg_resources').declare_namespace(__name__) except ImportError: pass ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4703794 jedi-0.19.1/test/examples/nested_namespaces/namespace/pkg/0000775000175000017500000000000000000000000023373 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/examples/nested_namespaces/namespace/pkg/__init__.py0000664000175000017500000000001200000000000025475 0ustar00davedave00000000000000CONST = 1 ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4703794 jedi-0.19.1/test/examples/not_in_sys_path/0000775000175000017500000000000000000000000020375 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/examples/not_in_sys_path/__init__.py0000664000175000017500000000000000000000000022474 0ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/examples/not_in_sys_path/not_in_sys_path.py0000664000175000017500000000001200000000000024140 0ustar00davedave00000000000000value = 3 ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4703794 jedi-0.19.1/test/examples/not_in_sys_path/not_in_sys_path_package/0000775000175000017500000000000000000000000025250 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/examples/not_in_sys_path/not_in_sys_path_package/__init__.py0000664000175000017500000000002200000000000027353 0ustar00davedave00000000000000value = 'package' ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/examples/not_in_sys_path/not_in_sys_path_package/module.py0000664000175000017500000000003100000000000027101 0ustar00davedave00000000000000value = 'package.module' ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4703794 jedi-0.19.1/test/examples/not_in_sys_path/pkg/0000775000175000017500000000000000000000000021156 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/examples/not_in_sys_path/pkg/__init__.py0000664000175000017500000000000000000000000023255 0ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/examples/not_in_sys_path/pkg/module.py0000664000175000017500000000033500000000000023016 0ustar00davedave00000000000000from not_in_sys_path import not_in_sys_path from not_in_sys_path import not_in_sys_path_package from not_in_sys_path.not_in_sys_path_package import module not_in_sys_path.value not_in_sys_path_package.value module.value ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.3863792 jedi-0.19.1/test/examples/pytest_plugin_package/0000775000175000017500000000000000000000000021556 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4703794 jedi-0.19.1/test/examples/pytest_plugin_package/pytest_plugin/0000775000175000017500000000000000000000000024464 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/examples/pytest_plugin_package/pytest_plugin/fixtures.py0000664000175000017500000000010300000000000026701 0ustar00davedave00000000000000from pytest import fixture @fixture() def admin_user(): pass ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/examples/pytest_plugin_package/pytest_plugin/plugin.py0000664000175000017500000000032700000000000026336 0ustar00davedave00000000000000import pytest from .fixtures import admin_user # noqa @pytest.fixture() def admin_client(): return Client() class Client: def login(self, **credentials): ... def logout(self): ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.3863792 jedi-0.19.1/test/examples/sample_venvs/0000775000175000017500000000000000000000000017677 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4703794 jedi-0.19.1/test/examples/sample_venvs/pth_directory/0000775000175000017500000000000000000000000022556 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4703794 jedi-0.19.1/test/examples/sample_venvs/pth_directory/dir-from-foo-pth/0000775000175000017500000000000000000000000025647 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/examples/sample_venvs/pth_directory/dir-from-foo-pth/__init__.py0000664000175000017500000000015200000000000027756 0ustar00davedave00000000000000# This file is here to force git to create the directory, as *.pth files only # add existing directories. ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/examples/sample_venvs/pth_directory/egg_link.egg-link0000664000175000017500000000002400000000000025750 0ustar00davedave00000000000000/path/from/egg-link ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/examples/sample_venvs/pth_directory/foo.pth0000664000175000017500000000002300000000000024051 0ustar00davedave00000000000000./dir-from-foo-pth ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/examples/sample_venvs/pth_directory/import_smth.pth0000664000175000017500000000004400000000000025636 0ustar00davedave00000000000000import smth; smth.extend_path_foo() ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/examples/sample_venvs/pth_directory/relative.egg-link0000664000175000017500000000003100000000000026002 0ustar00davedave00000000000000./relative/egg-link/path ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/examples/sample_venvs/pth_directory/smth.py0000664000175000017500000000017100000000000024102 0ustar00davedave00000000000000import sys sys.path.append('/foo/smth.py:module') def extend_path_foo(): sys.path.append('/foo/smth.py:from_func') ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4703794 jedi-0.19.1/test/examples/simple_import/0000775000175000017500000000000000000000000020060 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/examples/simple_import/__init__.py0000664000175000017500000000013400000000000022167 0ustar00davedave00000000000000from simple_import import module def in_function(): from simple_import import module2 ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/examples/simple_import/module.py0000664000175000017500000000000000000000000021705 0ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/examples/simple_import/module2.py0000664000175000017500000000000000000000000021767 0ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4703794 jedi-0.19.1/test/examples/speed/0000775000175000017500000000000000000000000016275 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/examples/speed/precedence.py0000664000175000017500000000120700000000000020744 0ustar00davedave00000000000000def marks(code): if '.' in code: another(code[:code.index(',') - 1] + '!') else: another(code + '.') def another(code2): call(numbers(code2 + 'haha')) marks('start1 ') marks('start2 ') def alphabet(code4): if 1: if 2: return code4 + 'a' else: return code4 + 'b' else: if 2: return code4 + 'c' else: return code4 + 'd' def numbers(code5): if 2: return alphabet(code5 + '1') else: return alphabet(code5 + '2') def call(code3): code3 = numbers(numbers('end')) + numbers(code3) code3.partition ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.3863792 jedi-0.19.1/test/examples/stub_packages/0000775000175000017500000000000000000000000020010 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4703794 jedi-0.19.1/test/examples/stub_packages/no_python-stubs/0000775000175000017500000000000000000000000023163 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/examples/stub_packages/no_python-stubs/__init__.pyi0000664000175000017500000000001100000000000025435 0ustar00davedave00000000000000foo: int ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4703794 jedi-0.19.1/test/examples/stub_packages/with_python/0000775000175000017500000000000000000000000022364 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/examples/stub_packages/with_python/__init__.py0000664000175000017500000000016500000000000024477 0ustar00davedave00000000000000from with_python import module as _module func_without_stub = _module.func_without_stub python_only = 1 both = '' ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/examples/stub_packages/with_python/module.py0000664000175000017500000000015200000000000024221 0ustar00davedave00000000000000def func_without_stub(a): 'nostubdoc' def func_with_stub(c): 'withstubdoc' in_sub_module = '' ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4703794 jedi-0.19.1/test/examples/stub_packages/with_python-stubs/0000775000175000017500000000000000000000000023522 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/examples/stub_packages/with_python-stubs/__init__.pyi0000664000175000017500000000012700000000000026004 0ustar00davedave00000000000000from . import module func_with_stub = module.func_with_stub both: int stub_only: str ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/examples/stub_packages/with_python-stubs/module.pyi0000664000175000017500000000010300000000000025524 0ustar00davedave00000000000000in_sub_module: int def func_with_stub(b: int) -> float: pass ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4703794 jedi-0.19.1/test/examples/typing_overload/0000775000175000017500000000000000000000000020402 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/examples/typing_overload/file.py0000664000175000017500000000005700000000000021675 0ustar00davedave00000000000000def with_overload(x, y: int) -> list: pass ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/examples/typing_overload/file.pyi0000664000175000017500000000022400000000000022042 0ustar00davedave00000000000000from typing import overload @overload def with_overload(x: int, y: int) -> float: ... @overload def with_overload(x: str, y: list) -> float: ... ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4703794 jedi-0.19.1/test/examples/zipped_imports/0000775000175000017500000000000000000000000020245 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/examples/zipped_imports/not_pkg.zip0000664000175000017500000000031400000000000022430 0ustar00davedave00000000000000PKH not_pkg.pyUX "W"W+K)MUUP/KIOIUJI($*$&g'EPK<6*,PKH<6*, @not_pkg.pyUX"W"WPKDr././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/examples/zipped_imports/pkg.zip0000664000175000017500000000204100000000000021547 0ustar00davedave00000000000000PK Hpkg/UX wWwWPKtN2?pkg/__init__.pyK+US-/*QO)IB80ĜT.̼[c#C.PKH pkg/module.pyUX vW`W+K)MUUP/NO)I+sPK0PPKiLzNpkg/namespace/PK cLzN!pkg/namespace/namespace_module.pyPKKzN pkg/nested/PK KzNpkg/nested/__init__.pyPK KzNpkg/nested/nested_module.pyPK H @Apkg/UXwWwWPK?tN2? 2pkg/__init__.pyPKH0P @pkg/module.pyUXvW`WPK?iLzNApkg/namespace/PK? cLzN! #pkg/namespace/namespace_module.pyPK?KzN Abpkg/nested/PK? KzN pkg/nested/__init__.pyPK? KzN pkg/nested/nested_module.pyPK././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/helpers.py0000664000175000017500000000260000000000000015371 0ustar00davedave00000000000000""" A helper module for testing, improves compatibility for testing (as ``jedi._compatibility``) as well as introducing helper functions. """ from contextlib import contextmanager import os import pytest from functools import partial, wraps from jedi import Project from pathlib import Path test_dir = Path(__file__).absolute().parent test_dir_project = Project(test_dir) root_dir = test_dir.parent example_dir = test_dir.joinpath('examples') sample_int = 1 # This is used in completion/imports.py skip_if_windows = partial(pytest.param, marks=pytest.mark.skipif("sys.platform=='win32'")) skip_if_not_windows = partial(pytest.param, marks=pytest.mark.skipif("sys.platform!='win32'")) def get_example_dir(*names): return example_dir.joinpath(*names) def cwd_at(path): """ Decorator to run function at `path`. :type path: str :arg path: relative path from repository root (e.g., ``'jedi'``). """ def decorator(func): @wraps(func) def wrapper(Script, **kwargs): with set_cwd(path): return func(Script, **kwargs) return wrapper return decorator @contextmanager def set_cwd(path, absolute_path=False): repo_root = test_dir.parent oldcwd = Path.cwd() os.chdir(repo_root.joinpath(path)) try: yield finally: os.chdir(oldcwd) ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4743795 jedi-0.19.1/test/refactor/0000775000175000017500000000000000000000000015164 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/refactor/extract_function.py0000664000175000017500000002500500000000000021117 0ustar00davedave00000000000000# -------------------------------------------------- in-module-0 global_var = 3 def x(): foo = 3.1 #? 11 text {'new_name': 'bar'} x = int(foo + 1 + global_var) # ++++++++++++++++++++++++++++++++++++++++++++++++++ global_var = 3 def bar(foo): return int(foo + 1 + global_var) def x(): foo = 3.1 #? 11 text {'new_name': 'bar'} x = bar(foo) # -------------------------------------------------- in-module-1 glob = 3 #? 11 text {'new_name': 'a'} test(100, (glob.a + b, c) + 1) # ++++++++++++++++++++++++++++++++++++++++++++++++++ glob = 3 #? 11 text {'new_name': 'a'} def a(b): return glob.a + b test(100, (a(b), c) + 1) # -------------------------------------------------- in-module-2 #? 0 text {'new_name': 'ab'} 100 + 1 * 2 # ++++++++++++++++++++++++++++++++++++++++++++++++++ #? 0 text {'new_name': 'ab'} def ab(): return 100 + 1 * 2 ab() # -------------------------------------------------- in-function-1 def f(x): #? 11 text {'new_name': 'ab'} return x + 1 * 2 # ++++++++++++++++++++++++++++++++++++++++++++++++++ def ab(x): return x + 1 * 2 def f(x): #? 11 text {'new_name': 'ab'} return ab(x) # -------------------------------------------------- in-function-with-dec @classmethod def f(x): #? 11 text {'new_name': 'ab'} return x + 1 * 2 # ++++++++++++++++++++++++++++++++++++++++++++++++++ def ab(x): return x + 1 * 2 @classmethod def f(x): #? 11 text {'new_name': 'ab'} return ab(x) # -------------------------------------------------- in-method-1 class X: def z(self): pass def f(x, b): #? 11 text {'new_name': 'ab'} return x + b * 2 # ++++++++++++++++++++++++++++++++++++++++++++++++++ class X: def z(self): pass def ab(x, b): return x + b * 2 def f(x, b): #? 11 text {'new_name': 'ab'} return x.ab(b) # -------------------------------------------------- in-method-2 glob1 = 1 class X: def g(self): pass def f(self, b, c): #? 11 text {'new_name': 'ab'} return self.g() or self.f(b) ^ glob1 & b # ++++++++++++++++++++++++++++++++++++++++++++++++++ glob1 = 1 class X: def g(self): pass def ab(self, b): return self.g() or self.f(b) ^ glob1 & b def f(self, b, c): #? 11 text {'new_name': 'ab'} return self.ab(b) # -------------------------------------------------- in-method-order class X: def f(self, b, c): #? 18 text {'new_name': 'b'} return b | self.a # ++++++++++++++++++++++++++++++++++++++++++++++++++ class X: def b(self, b): return b | self.a def f(self, b, c): #? 18 text {'new_name': 'b'} return self.b(b) # -------------------------------------------------- in-classmethod-1 class X: @classmethod def f(x): #? 16 text {'new_name': 'ab'} return 25 # ++++++++++++++++++++++++++++++++++++++++++++++++++ class X: @classmethod def ab(x): return 25 @classmethod def f(x): #? 16 text {'new_name': 'ab'} return x.ab() # -------------------------------------------------- in-staticmethod-1 class X(int): @staticmethod def f(x): #? 16 text {'new_name': 'ab'} return 25 | 3 # ++++++++++++++++++++++++++++++++++++++++++++++++++ def ab(): return 25 | 3 class X(int): @staticmethod def f(x): #? 16 text {'new_name': 'ab'} return ab() # -------------------------------------------------- in-class-1 class Ya(): a = 3 #? 11 text {'new_name': 'f'} c = a + 2 # ++++++++++++++++++++++++++++++++++++++++++++++++++ def f(a): return a + 2 class Ya(): a = 3 #? 11 text {'new_name': 'f'} c = f(a) # -------------------------------------------------- in-closure def x(z): def y(x): #? 15 text {'new_name': 'f'} return -x * z # ++++++++++++++++++++++++++++++++++++++++++++++++++ def f(x, z): return -x * z def x(z): def y(x): #? 15 text {'new_name': 'f'} return f(x, z) # -------------------------------------------------- with-range-1 #? 0 text {'new_name': 'a', 'until_line': 4} v1 = 3 v2 = 2 x = test(v1 + v2 * v3) # ++++++++++++++++++++++++++++++++++++++++++++++++++ #? 0 text {'new_name': 'a', 'until_line': 4} def a(test, v3): v1 = 3 v2 = 2 x = test(v1 + v2 * v3) return x x = a(test, v3) # -------------------------------------------------- with-range-2 #? 2 text {'new_name': 'a', 'until_line': 6, 'until_column': 4} #foo v1 = 3 v2 = 2 x, y = test(v1 + v2 * v3) #raaaa y # ++++++++++++++++++++++++++++++++++++++++++++++++++ #? 2 text {'new_name': 'a', 'until_line': 6, 'until_column': 4} def a(test, v3): #foo v1 = 3 v2 = 2 x, y = test(v1 + v2 * v3) #raaaa return y y = a(test, v3) y # -------------------------------------------------- with-range-3 #foo #? 2 text {'new_name': 'a', 'until_line': 5, 'until_column': 4} v1 = 3 v2 = 2 x, y = test(v1 + v2 * v3) #raaaa y # ++++++++++++++++++++++++++++++++++++++++++++++++++ #foo #? 2 text {'new_name': 'a', 'until_line': 5, 'until_column': 4} def a(test, v3): v1 = 3 v2 = 2 x, y = test(v1 + v2 * v3) return y y = a(test, v3) #raaaa y # -------------------------------------------------- with-range-func-1 import os # comment1 @dec # comment2 def x(v1): #foo #? 2 text {'new_name': 'a', 'until_line': 9, 'until_column': 5} v2 = 2 if 1: x, y = os.listdir(v1 + v2 * v3) #bar return x, y # ++++++++++++++++++++++++++++++++++++++++++++++++++ import os # comment1 def a(v1, v3): v2 = 2 if 1: x, y = os.listdir(v1 + v2 * v3) return x, y @dec # comment2 def x(v1): #foo #? 2 text {'new_name': 'a', 'until_line': 9, 'until_column': 5} x, y = a(v1, v3) #bar return x, y # -------------------------------------------------- with-range-func-2 import os # comment1 # comment2 def x(v1): #? 2 text {'new_name': 'a', 'until_line': 10, 'until_column': 0} #foo v2 = 2 if 1: x, y = os.listdir(v1 + v2 * v3) #bar return y x # ++++++++++++++++++++++++++++++++++++++++++++++++++ import os # comment1 # comment2 def a(v1, v3): #foo v2 = 2 if 1: x, y = os.listdir(v1 + v2 * v3) #bar return y def x(v1): #? 2 text {'new_name': 'a', 'until_line': 10, 'until_column': 0} y = a(v1, v3) return y x # -------------------------------------------------- with-range-func-3 def x(v1): #? 2 text {'new_name': 'func', 'until_line': 6, 'until_column': 4} #foo v2 = 2 x = v1 * 2 y = 3 #bar return x x # ++++++++++++++++++++++++++++++++++++++++++++++++++ def func(v1): #foo v2 = 2 x = v1 * 2 return x def x(v1): #? 2 text {'new_name': 'func', 'until_line': 6, 'until_column': 4} x = func(v1) y = 3 #bar return x x # -------------------------------------------------- in-class-range-1 class X1: #? 9 text {'new_name': 'f', 'until_line': 4} a = 3 c = a + 2 # ++++++++++++++++++++++++++++++++++++++++++++++++++ def f(): a = 3 c = a + 2 return c class X1: #? 9 text {'new_name': 'f', 'until_line': 4} c = f() # -------------------------------------------------- in-method-range-1 glob1 = 1 class X: # ha def g(self): pass # haha def f(self, b, c): #? 11 text {'new_name': 'ab', 'until_line': 12, 'until_column': 28} #foo local1 = 3 local2 = 4 x= self.g() or self.f(b) ^ glob1 & b is local1 # bar # ++++++++++++++++++++++++++++++++++++++++++++++++++ glob1 = 1 class X: # ha def g(self): pass # haha def ab(self, b): #foo local1 = 3 local2 = 4 x= self.g() or self.f(b) ^ glob1 & b is local1 return x def f(self, b, c): #? 11 text {'new_name': 'ab', 'until_line': 12, 'until_column': 28} x = self.ab(b) # bar # -------------------------------------------------- in-method-range-2 glob1 = 1 class X: # comment def f(self, b, c): #? 11 text {'new_name': 'ab', 'until_line': 11, 'until_column': 10} #foo local1 = 3 local2 = 4 return local1 * glob1 * b # bar # ++++++++++++++++++++++++++++++++++++++++++++++++++ glob1 = 1 class X: # comment def ab(self, b): #foo local1 = 3 local2 = 4 return local1 * glob1 * b # bar def f(self, b, c): #? 11 text {'new_name': 'ab', 'until_line': 11, 'until_column': 10} return self.ab(b) # -------------------------------------------------- in-method-range-3 glob1 = 1 class X: def f(self, b, c): local1, local2 = 3, 4 #foo #? 11 text {'new_name': 'ab', 'until_line': 7, 'until_column': 29} return local1 & glob1 & b # bar local2 # ++++++++++++++++++++++++++++++++++++++++++++++++++ glob1 = 1 class X: def ab(self, local1, b): return local1 & glob1 & b def f(self, b, c): local1, local2 = 3, 4 #foo #? 11 text {'new_name': 'ab', 'until_line': 7, 'until_column': 29} return self.ab(local1, b) # bar local2 # -------------------------------------------------- in-method-no-param glob1 = 1 class X: def f(): #? 11 text {'new_name': 'ab', 'until_line': 5, 'until_column': 22} return glob1 + 2 # ++++++++++++++++++++++++++++++++++++++++++++++++++ glob1 = 1 class X: def ab(): return glob1 + 2 def f(): #? 11 text {'new_name': 'ab', 'until_line': 5, 'until_column': 22} return ab() # -------------------------------------------------- random-return-1 def x(): #? 0 error {'new_name': 'ab', 'until_line': 5, 'until_column': 10} if x: return 1 return 1 # ++++++++++++++++++++++++++++++++++++++++++++++++++ Can only extract return statements if they are at the end. # -------------------------------------------------- random-return-2 def x(): #? 0 error {'new_name': 'ab', 'until_line': 5, 'until_column': 10} # return pass # ++++++++++++++++++++++++++++++++++++++++++++++++++ Can only extract return statements if they are at the end. # -------------------------------------------------- random-yield-1 def x(): #? 0 error {'new_name': 'ab', 'until_line': 5, 'until_column': 10} # if (yield 1): return pass # ++++++++++++++++++++++++++++++++++++++++++++++++++ Cannot extract yield statements. # -------------------------------------------------- random-yield-2 def x(): #? 0 error {'new_name': 'ab', 'until_line': 4, 'until_column': 10} # try: yield finally: pass # ++++++++++++++++++++++++++++++++++++++++++++++++++ Cannot extract yield statements. ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/refactor/extract_variable.py0000664000175000017500000002070100000000000021055 0ustar00davedave00000000000000# -------------------------------------------------- simple-1 def test(): #? 35 text {'new_name': 'a'} return test(100, (30 + b, c) + 1) # ++++++++++++++++++++++++++++++++++++++++++++++++++ def test(): #? 35 text {'new_name': 'a'} a = (30 + b, c) + 1 return test(100, a) # -------------------------------------------------- simple-2 def test(): #? 25 text {'new_name': 'a'} return test(100, (30 + b, c) + 1) # ++++++++++++++++++++++++++++++++++++++++++++++++++ def test(): #? 25 text {'new_name': 'a'} a = 30 + b return test(100, (a, c) + 1) # -------------------------------------------------- simple-3 foo = 3.1 #? 8 text {'new_name': 'bar'} x = int(foo + 1) # ++++++++++++++++++++++++++++++++++++++++++++++++++ foo = 3.1 #? 8 text {'new_name': 'bar'} bar = foo + 1 x = int(bar) # -------------------------------------------------- simple-4 #? 13 text {'new_name': 'zzx.x'} test(100, {1 |1: 2 + 3}) # ++++++++++++++++++++++++++++++++++++++++++++++++++ #? 13 text {'new_name': 'zzx.x'} zzx.x = 1 |1 test(100, {zzx.x: 2 + 3}) # -------------------------------------------------- multiline-1 def test(): #? 30 text {'new_name': 'x'} return test(1, (30 + b, c) + 1) # ++++++++++++++++++++++++++++++++++++++++++++++++++ def test(): #? 30 text {'new_name': 'x'} x = (30 + b, c) + 1 return test(1, x) # -------------------------------------------------- multiline-2 def test(): #? 25 text {'new_name': 'x'} return test(1, (30 + b, c) + 1) # ++++++++++++++++++++++++++++++++++++++++++++++++++ def test(): #? 25 text {'new_name': 'x'} x = 30 + b return test(1, (x, c) + 1) # -------------------------------------------------- for-param-error-1 #? 10 error {'new_name': 'x'} def test(p1): return # ++++++++++++++++++++++++++++++++++++++++++++++++++ Cannot extract a name that defines something # -------------------------------------------------- for-param-error-2 #? 12 error {'new_name': 'x'} def test(p1= 3): return # ++++++++++++++++++++++++++++++++++++++++++++++++++ Cannot extract a "param" # -------------------------------------------------- for-param-1 #? 12 text {'new_name': 'x'} def test(p1=20): return # ++++++++++++++++++++++++++++++++++++++++++++++++++ #? 12 text {'new_name': 'x'} x = 20 def test(p1=x): return # -------------------------------------------------- for-something #? 12 text {'new_name': 'x'} def test(p1=20): return # ++++++++++++++++++++++++++++++++++++++++++++++++++ #? 12 text {'new_name': 'x'} x = 20 def test(p1=x): return # -------------------------------------------------- class-inheritance-1 #? 12 text {'new_name': 'x'} class Foo(foo.Bar): pass # ++++++++++++++++++++++++++++++++++++++++++++++++++ #? 12 text {'new_name': 'x'} x = foo.Bar class Foo(x): pass # -------------------------------------------------- class-inheritance-2 #? 16 text {'new_name': 'x'} class Foo(foo.Bar): pass # ++++++++++++++++++++++++++++++++++++++++++++++++++ #? 16 text {'new_name': 'x'} x = foo.Bar class Foo(x): pass # -------------------------------------------------- keyword-pass #? 12 error {'new_name': 'x'} def x(): pass # ++++++++++++++++++++++++++++++++++++++++++++++++++ Cannot extract a "simple_stmt" # -------------------------------------------------- keyword-continue #? 5 error {'new_name': 'x'} continue # ++++++++++++++++++++++++++++++++++++++++++++++++++ Cannot extract a "simple_stmt" # -------------------------------------------------- keyword-None if 1: #? 4 text {'new_name': 'x'} None # ++++++++++++++++++++++++++++++++++++++++++++++++++ if 1: #? 4 text {'new_name': 'x'} x = None x # -------------------------------------------------- with-tuple #? 4 text {'new_name': 'x'} x + 1, 3 # ++++++++++++++++++++++++++++++++++++++++++++++++++ #? 4 text {'new_name': 'x'} x = x + 1 x, 3 # -------------------------------------------------- range-1 #? 4 text {'new_name': 'x', 'until_column': 9} y + 1, 3 # ++++++++++++++++++++++++++++++++++++++++++++++++++ #? 4 text {'new_name': 'x', 'until_column': 9} x = y + 1, 3 x # -------------------------------------------------- range-2 #? 1 text {'new_name': 'x', 'until_column': 3} y + 1, 3 # ++++++++++++++++++++++++++++++++++++++++++++++++++ #? 1 text {'new_name': 'x', 'until_column': 3} x = y + 1 x, 3 # -------------------------------------------------- range-3 #? 1 text {'new_name': 'x', 'until_column': 6} y + 1, 3 # ++++++++++++++++++++++++++++++++++++++++++++++++++ #? 1 text {'new_name': 'x', 'until_column': 6} x = y + 1 x, 3 # -------------------------------------------------- range-4 #? 1 text {'new_name': 'x', 'until_column': 1} y + 1, 3 # ++++++++++++++++++++++++++++++++++++++++++++++++++ #? 1 text {'new_name': 'x', 'until_column': 1} x = y x + 1, 3 # -------------------------------------------------- addition-1 #? 4 text {'new_name': 'x', 'until_column': 9} z = y + 1 + 2+ 3, 3 # ++++++++++++++++++++++++++++++++++++++++++++++++++ #? 4 text {'new_name': 'x', 'until_column': 9} x = y + 1 z = x + 2+ 3, 3 # -------------------------------------------------- addition-2 #? 8 text {'new_name': 'x', 'until_column': 12} z = y +1 + 2+ 3, 3 # ++++++++++++++++++++++++++++++++++++++++++++++++++ #? 8 text {'new_name': 'x', 'until_column': 12} x = 1 + 2 z = y +x+ 3, 3 # -------------------------------------------------- addition-3 #? 10 text {'new_name': 'x', 'until_column': 14} z = y + 1 + 2+ 3, 3 # ++++++++++++++++++++++++++++++++++++++++++++++++++ #? 10 text {'new_name': 'x', 'until_column': 14} x = 1 + 2+ 3 z = y + x, 3 # -------------------------------------------------- addition-4 #? 13 text {'new_name': 'x', 'until_column': 17} z = y + (1 + 2)+ 3, 3 # ++++++++++++++++++++++++++++++++++++++++++++++++++ #? 13 text {'new_name': 'x', 'until_column': 17} x = (1 + 2)+ 3 z = y + x, 3 # -------------------------------------------------- mult-add-1 #? 8 text {'new_name': 'x', 'until_column': 11} z = foo(y+1*2+3, 3) # ++++++++++++++++++++++++++++++++++++++++++++++++++ #? 8 text {'new_name': 'x', 'until_column': 11} x = y+1 z = foo(x*2+3, 3) # -------------------------------------------------- mult-add-2 #? 12 text {'new_name': 'x', 'until_column': 15} z = foo(y+1*2+3) # ++++++++++++++++++++++++++++++++++++++++++++++++++ #? 12 text {'new_name': 'x', 'until_column': 15} x = 2+3 z = foo(y+1*x) # -------------------------------------------------- mult-add-3 #? 9 text {'new_name': 'x', 'until_column': 13} z = (y+1*2+3) # ++++++++++++++++++++++++++++++++++++++++++++++++++ #? 9 text {'new_name': 'x', 'until_column': 13} x = (y+1*2+3) z = x # -------------------------------------------------- extract-weird-1 #? 0 error {'new_name': 'x', 'until_column': 7} foo = 3 # ++++++++++++++++++++++++++++++++++++++++++++++++++ Cannot extract a "expr_stmt" # -------------------------------------------------- extract-weird-2 #? 0 error {'new_name': 'x', 'until_column': 5} def x(): foo = 3 # ++++++++++++++++++++++++++++++++++++++++++++++++++ Cannot extract a "funcdef" # -------------------------------------------------- extract-weird-3 def x(): #? 4 error {'new_name': 'x', 'until_column': 8} if 1: pass # ++++++++++++++++++++++++++++++++++++++++++++++++++ Cannot extract a "if_stmt" # -------------------------------------------------- extract-weird-4 #? 4 error {'new_name': 'x', 'until_column': 7} x = foo = 4 # ++++++++++++++++++++++++++++++++++++++++++++++++++ Cannot extract a name that defines something # -------------------------------------------------- keyword-None #? 4 text {'new_name': 'x', 'until_column': 7} yy = not foo or bar # ++++++++++++++++++++++++++++++++++++++++++++++++++ #? 4 text {'new_name': 'x', 'until_column': 7} x = not foo yy = x or bar # -------------------------------------------------- augassign yy = () #? 6 text {'new_name': 'x', 'until_column': 10} yy += 3, 4 # ++++++++++++++++++++++++++++++++++++++++++++++++++ yy = () #? 6 text {'new_name': 'x', 'until_column': 10} x = 3, 4 yy += x # -------------------------------------------------- if-else #? 9 text {'new_name': 'x', 'until_column': 22} yy = foo(a if y else b) # ++++++++++++++++++++++++++++++++++++++++++++++++++ #? 9 text {'new_name': 'x', 'until_column': 22} x = a if y else b yy = foo(x) # -------------------------------------------------- lambda #? 8 text {'new_name': 'x', 'until_column': 17} y = foo(lambda x: 3, 5) # ++++++++++++++++++++++++++++++++++++++++++++++++++ #? 8 text {'new_name': 'x', 'until_column': 17} x = lambda x: 3 y = foo(x, 5) ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4743795 jedi-0.19.1/test/refactor/import_tree/0000775000175000017500000000000000000000000017515 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/refactor/import_tree/inline_mod.py0000664000175000017500000000002300000000000022177 0ustar00davedave00000000000000inline_var = 5 + 3 ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4743795 jedi-0.19.1/test/refactor/import_tree/pkgx/0000775000175000017500000000000000000000000020466 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/refactor/import_tree/pkgx/__init__.py0000664000175000017500000000002500000000000022574 0ustar00davedave00000000000000def pkgx(): pass ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/refactor/import_tree/pkgx/__init__.pyi0000664000175000017500000000002700000000000022747 0ustar00davedave00000000000000def pkgx() -> int: ... ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/refactor/import_tree/pkgx/mod.pyi0000664000175000017500000000002300000000000021763 0ustar00davedave00000000000000from . import pkgx ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/refactor/import_tree/pkgx/mod2.py0000664000175000017500000000002400000000000021675 0ustar00davedave00000000000000from .. import pkgx ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/refactor/import_tree/some_mod.py0000664000175000017500000000001300000000000021663 0ustar00davedave00000000000000foobar = 3 ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/refactor/inline.py0000664000175000017500000001363100000000000017020 0ustar00davedave00000000000000# -------------------------------------------------- no-name-error #? 0 error 1 # ++++++++++++++++++++++++++++++++++++++++++++++++++ There is no name under the cursor # -------------------------------------------------- no-reference-error #? 0 error a = 1 # ++++++++++++++++++++++++++++++++++++++++++++++++++ There are no references to this name # -------------------------------------------------- multi-equal-error def test(): #? 4 error a = b = 3 return test(100, a) # ++++++++++++++++++++++++++++++++++++++++++++++++++ Cannot inline a statement with multiple definitions # -------------------------------------------------- no-definition-error #? 5 error test(a) # ++++++++++++++++++++++++++++++++++++++++++++++++++ No definition found to inline # -------------------------------------------------- multi-names-error #? 0 error a, b[1] = 3 test(a) # ++++++++++++++++++++++++++++++++++++++++++++++++++ Cannot inline a statement with multiple definitions # -------------------------------------------------- addition-error #? 0 error a = 2 a += 3 test(a) # ++++++++++++++++++++++++++++++++++++++++++++++++++ Cannot inline a name with multiple definitions # -------------------------------------------------- only-addition-error #? 0 error a += 3 test(a) # ++++++++++++++++++++++++++++++++++++++++++++++++++ Cannot inline a statement with "+=" # -------------------------------------------------- with-annotation foobarb: int = 1 #? 5 test(foobarb) # ++++++++++++++++++++++++++++++++++++++++++++++++++ --- inline.py +++ inline.py @@ -1,4 +1,3 @@ -foobarb: int = 1 #? 5 -test(foobarb) +test(1) # -------------------------------------------------- only-annotation-error a: int #? 5 error test(a) # ++++++++++++++++++++++++++++++++++++++++++++++++++ Cannot inline a statement that is defined by an annotation # -------------------------------------------------- builtin import math #? 7 error math.cos # ++++++++++++++++++++++++++++++++++++++++++++++++++ Cannot inline builtins/extensions # -------------------------------------------------- module-error from import_tree import inline_mod #? 11 error test(inline_mod) # ++++++++++++++++++++++++++++++++++++++++++++++++++ Cannot inline imports, modules or namespaces # -------------------------------------------------- module-works from import_tree import inline_mod #? 22 test(x, inline_mod. inline_var.conjugate) # ++++++++++++++++++++++++++++++++++++++++++++++++++ --- import_tree/inline_mod.py +++ import_tree/inline_mod.py @@ -1,2 +1 @@ -inline_var = 5 + 3 --- inline.py +++ inline.py @@ -1,4 +1,4 @@ from import_tree import inline_mod #? 22 -test(x, inline_mod. inline_var.conjugate) +test(x, (5 + 3).conjugate) # -------------------------------------------------- class class A: pass #? 5 error test(A) # ++++++++++++++++++++++++++++++++++++++++++++++++++ Cannot inline a class # -------------------------------------------------- function def foo(a): return a + 1 #? 5 error test(foo(1)) # ++++++++++++++++++++++++++++++++++++++++++++++++++ Cannot inline a function # -------------------------------------------------- for-stmt for x in []: #? 9 error test(x) # ++++++++++++++++++++++++++++++++++++++++++++++++++ Cannot inline a for_stmt # -------------------------------------------------- simple def test(): #? 4 a = (30 + b, c) + 1 return test(100, a) # ++++++++++++++++++++++++++++++++++++++++++++++++++ --- inline.py +++ inline.py @@ -1,5 +1,4 @@ def test(): #? 4 - a = (30 + b, c) + 1 - return test(100, a) + return test(100, (30 + b, c) + 1) # -------------------------------------------------- tuple if 1: #? 4 a = 1, 2 return test(100, a) # ++++++++++++++++++++++++++++++++++++++++++++++++++ --- inline.py +++ inline.py @@ -1,5 +1,4 @@ if 1: #? 4 - a = 1, 2 - return test(100, a) + return test(100, (1, 2)) # -------------------------------------------------- multiplication-add-parens1 a = 1+2 #? 11 test(100 * a) # ++++++++++++++++++++++++++++++++++++++++++++++++++ --- inline.py +++ inline.py @@ -1,4 +1,3 @@ -a = 1+2 #? 11 -test(100 * a) +test(100 * (1+2)) # -------------------------------------------------- multiplication-add-parens2 a = 1+2 #? 11 (x, 100 * a) # ++++++++++++++++++++++++++++++++++++++++++++++++++ --- inline.py +++ inline.py @@ -1,4 +1,3 @@ -a = 1+2 #? 11 -(x, 100 * a) +(x, 100 * (1+2)) # -------------------------------------------------- multiplication-add-parens3 x a = 1+2 #? 9 (100 ** a) # ++++++++++++++++++++++++++++++++++++++++++++++++++ --- inline.py +++ inline.py @@ -1,5 +1,4 @@ x -a = 1+2 #? 9 -(100 ** a) +(100 ** (1+2)) # -------------------------------------------------- no-add-parens1 x a = 1+2 #? 5 test(a) # ++++++++++++++++++++++++++++++++++++++++++++++++++ --- inline.py +++ inline.py @@ -1,5 +1,4 @@ x -a = 1+2 #? 5 -test(a) +test(1+2) # -------------------------------------------------- no-add-parens2 a = 1+2 #? 9 test(3, a) # ++++++++++++++++++++++++++++++++++++++++++++++++++ --- inline.py +++ inline.py @@ -1,4 +1,3 @@ -a = 1+2 #? 9 -test(3, a) +test(3, 1+2) # -------------------------------------------------- no-add-parens3 a = 1|2 #? 5 (3, a) # ++++++++++++++++++++++++++++++++++++++++++++++++++ --- inline.py +++ inline.py @@ -1,4 +1,3 @@ -a = 1|2 #? 5 -(3, a) +(3, 1|2) # -------------------------------------------------- comment a = 1 and 2 # foo #? 9 (3, 3 * a) # ++++++++++++++++++++++++++++++++++++++++++++++++++ --- inline.py +++ inline.py @@ -1,4 +1,4 @@ -a = 1 and 2 # foo + # foo #? 9 -(3, 3 * a) +(3, 3 * (1 and 2)) # -------------------------------------------------- semicolon a = 1, 2 ; b = 3 #? 9 (3, 3 == a) # ++++++++++++++++++++++++++++++++++++++++++++++++++ --- inline.py +++ inline.py @@ -1,4 +1,4 @@ -a = 1, 2 ; b = 3 + b = 3 #? 9 -(3, 3 == a) +(3, 3 == (1, 2)) # -------------------------------------------------- no-tree-name a = 1 + 2 #? 0 a.conjugate # ++++++++++++++++++++++++++++++++++++++++++++++++++ --- inline.py +++ inline.py @@ -1,4 +1,3 @@ -a = 1 + 2 #? 0 -a.conjugate +(1 + 2).conjugate ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/refactor/rename.py0000664000175000017500000001365300000000000017015 0ustar00davedave00000000000000""" Test coverage for renaming is mostly being done by testing `Script.get_references`. """ # -------------------------------------------------- no-name #? 0 error {'new_name': 'blabla'} 1 # ++++++++++++++++++++++++++++++++++++++++++++++++++ There is no name under the cursor # -------------------------------------------------- simple def test1(): #? 7 {'new_name': 'blabla'} test1() AssertionError return test1, test1.not_existing # ++++++++++++++++++++++++++++++++++++++++++++++++++ --- rename.py +++ rename.py @@ -1,6 +1,6 @@ -def test1(): +def blabla(): #? 7 {'new_name': 'blabla'} - test1() + blabla() AssertionError - return test1, test1.not_existing + return blabla, blabla.not_existing # -------------------------------------------------- var-not-found undefined_var #? 0 {'new_name': 'lala'} undefined_var # ++++++++++++++++++++++++++++++++++++++++++++++++++ --- rename.py +++ rename.py @@ -1,4 +1,4 @@ undefined_var #? 0 {'new_name': 'lala'} -undefined_var +lala # -------------------------------------------------- different-scopes def x(): #? 7 {'new_name': 'v'} some_var = 3 some_var def y(): some_var = 3 some_var # ++++++++++++++++++++++++++++++++++++++++++++++++++ --- rename.py +++ rename.py @@ -1,7 +1,7 @@ def x(): #? 7 {'new_name': 'v'} - some_var = 3 - some_var + v = 3 + v def y(): some_var = 3 some_var # -------------------------------------------------- keyword-param1 #? 22 {'new_name': 'lala'} def mykeywordparam1(param1): str(param1) mykeywordparam1(1) mykeywordparam1(param1=3) mykeywordparam1(x, param1=2) # ++++++++++++++++++++++++++++++++++++++++++++++++++ --- rename.py +++ rename.py @@ -1,7 +1,7 @@ #? 22 {'new_name': 'lala'} -def mykeywordparam1(param1): - str(param1) +def mykeywordparam1(lala): + str(lala) mykeywordparam1(1) -mykeywordparam1(param1=3) -mykeywordparam1(x, param1=2) +mykeywordparam1(lala=3) +mykeywordparam1(x, lala=2) # -------------------------------------------------- keyword-param2 def mykeywordparam2(param1): str(param1) mykeywordparam2(1) mykeywordparam2(param1=3) #? 22 {'new_name': 'lala'} mykeywordparam2(x, param1=2) # ++++++++++++++++++++++++++++++++++++++++++++++++++ --- rename.py +++ rename.py @@ -1,7 +1,7 @@ -def mykeywordparam2(param1): - str(param1) +def mykeywordparam2(lala): + str(lala) mykeywordparam2(1) -mykeywordparam2(param1=3) +mykeywordparam2(lala=3) #? 22 {'new_name': 'lala'} -mykeywordparam2(x, param1=2) +mykeywordparam2(x, lala=2) # -------------------------------------------------- import from import_tree.some_mod import foobar #? 0 {'new_name': 'renamed'} foobar # ++++++++++++++++++++++++++++++++++++++++++++++++++ --- import_tree/some_mod.py +++ import_tree/some_mod.py @@ -1,2 +1,2 @@ -foobar = 3 +renamed = 3 --- rename.py +++ rename.py @@ -1,4 +1,4 @@ -from import_tree.some_mod import foobar +from import_tree.some_mod import renamed #? 0 {'new_name': 'renamed'} -foobar +renamed # -------------------------------------------------- module from import_tree import some_mod #? 0 {'new_name': 'renamedm'} some_mod # ++++++++++++++++++++++++++++++++++++++++++++++++++ rename from import_tree/some_mod.py rename to import_tree/renamedm.py --- rename.py +++ rename.py @@ -1,4 +1,4 @@ -from import_tree import some_mod +from import_tree import renamedm #? 0 {'new_name': 'renamedm'} -some_mod +renamedm # -------------------------------------------------- import-not-found #? 20 {'new_name': 'lala'} import undefined_import haha( undefined_import) # ++++++++++++++++++++++++++++++++++++++++++++++++++ --- rename.py +++ rename.py @@ -1,4 +1,4 @@ #? 20 {'new_name': 'lala'} -import undefined_import -haha( undefined_import) +import lala +haha( lala) # -------------------------------------------------- in-package-with-stub #? 31 {'new_name': 'renamedm'} from import_tree.pkgx import pkgx # ++++++++++++++++++++++++++++++++++++++++++++++++++ --- import_tree/pkgx/__init__.py +++ import_tree/pkgx/__init__.py @@ -1,3 +1,3 @@ -def pkgx(): +def renamedm(): pass --- import_tree/pkgx/__init__.pyi +++ import_tree/pkgx/__init__.pyi @@ -1,2 +1,2 @@ -def pkgx() -> int: ... +def renamedm() -> int: ... --- import_tree/pkgx/mod.pyi +++ import_tree/pkgx/mod.pyi @@ -1,2 +1,2 @@ -from . import pkgx +from . import renamedm --- rename.py +++ rename.py @@ -1,3 +1,3 @@ #? 31 {'new_name': 'renamedm'} -from import_tree.pkgx import pkgx +from import_tree.pkgx import renamedm # -------------------------------------------------- package-with-stub #? 18 {'new_name': 'renamedp'} from import_tree.pkgx # ++++++++++++++++++++++++++++++++++++++++++++++++++ rename from import_tree/pkgx rename to import_tree/renamedp --- import_tree/pkgx/mod2.py +++ import_tree/renamedp/mod2.py @@ -1,2 +1,2 @@ -from .. import pkgx +from .. import renamedp --- rename.py +++ rename.py @@ -1,3 +1,3 @@ #? 18 {'new_name': 'renamedp'} -from import_tree.pkgx +from import_tree.renamedp # -------------------------------------------------- weird-package-mix if random_undefined_variable: from import_tree.pkgx import pkgx else: from import_tree import pkgx #? 4 {'new_name': 'rename'} pkgx # ++++++++++++++++++++++++++++++++++++++++++++++++++ rename from import_tree/pkgx rename to import_tree/rename --- import_tree/pkgx/__init__.py +++ import_tree/rename/__init__.py @@ -1,3 +1,3 @@ -def pkgx(): +def rename(): pass --- import_tree/pkgx/__init__.pyi +++ import_tree/rename/__init__.pyi @@ -1,2 +1,2 @@ -def pkgx() -> int: ... +def rename() -> int: ... --- import_tree/pkgx/mod.pyi +++ import_tree/rename/mod.pyi @@ -1,2 +1,2 @@ -from . import pkgx +from . import rename --- import_tree/pkgx/mod2.py +++ import_tree/rename/mod2.py @@ -1,2 +1,2 @@ -from .. import pkgx +from .. import rename --- rename.py +++ rename.py @@ -1,7 +1,7 @@ if random_undefined_variable: - from import_tree.pkgx import pkgx + from import_tree.rename import rename else: - from import_tree import pkgx + from import_tree import rename #? 4 {'new_name': 'rename'} -pkgx +rename ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/refactor.py0000664000175000017500000000703000000000000015536 0ustar00davedave00000000000000#!/usr/bin/env python """ Refactoring tests work a little bit similar to integration tests. But the idea is here to compare two versions of code. If you want to add a new test case, just look at the existing ones in the ``test/refactor`` folder and copy them. """ import os import platform import re from parso import split_lines from functools import reduce import jedi from .helpers import test_dir class RefactoringCase(object): def __init__(self, name, code, line_nr, index, path, kwargs, type_, desired_result): self.name = name self._code = code self._line_nr = line_nr self._index = index self._path = path self._kwargs = kwargs self.type = type_ self._desired_result = desired_result def get_desired_result(self): if platform.system().lower() == 'windows' and self.type == 'diff': # Windows uses backslashes to separate paths. lines = split_lines(self._desired_result, keepends=True) for i, line in enumerate(lines): if re.search(' import_tree/', line): lines[i] = line.replace('/', '\\') return ''.join(lines) return self._desired_result @property def refactor_type(self): f_name = os.path.basename(self._path) return f_name.replace('.py', '') def refactor(self, environment): project = jedi.Project(os.path.join(test_dir, 'refactor')) script = jedi.Script(self._code, path=self._path, project=project, environment=environment) refactor_func = getattr(script, self.refactor_type) return refactor_func(self._line_nr, self._index, **self._kwargs) def __repr__(self): return '<%s: %s:%s>' % (self.__class__.__name__, self.name, self._line_nr - 1) def _collect_file_tests(code, path, lines_to_execute): r = r'^# -{5,} ?([^\n]*)\n((?:(?!\n# \+{5,}).)*\n)' \ r'# \+{5,}\n((?:(?!\n# -{5,}).)*\n)' match = None for match in re.finditer(r, code, re.DOTALL | re.MULTILINE): name = match.group(1).strip() first = match.group(2) second = match.group(3) # get the line with the position of the operation p = re.match(r'((?:(?!#\?).)*)#\? (\d*)( error| text|) ?([^\n]*)', first, re.DOTALL) if p is None: raise Exception("Please add a test start.") continue until = p.group(1) index = int(p.group(2)) type_ = p.group(3).strip() or 'diff' if p.group(4): kwargs = eval(p.group(4)) else: kwargs = {} line_nr = until.count('\n') + 2 if lines_to_execute and line_nr - 1 not in lines_to_execute: continue yield RefactoringCase(name, first, line_nr, index, path, kwargs, type_, second) if match is None: raise Exception(f"Didn't match any test for {path}, {code!r}") if match.end() != len(code): raise Exception(f"Didn't match until the end of the file in {path}") def collect_dir_tests(base_dir, test_files): for f_name in os.listdir(base_dir): files_to_execute = [a for a in test_files.items() if a[0] in f_name] lines_to_execute = reduce(lambda x, y: x + y[1], files_to_execute, []) if f_name.endswith(".py") and (not test_files or files_to_execute): path = os.path.join(base_dir, f_name) with open(path, newline='') as f: code = f.read() for case in _collect_file_tests(code, path, lines_to_execute): yield case ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/run.py0000775000175000017500000004322300000000000014544 0ustar00davedave00000000000000#!/usr/bin/env python3 """ |jedi| is mostly being tested by what I would call "integration tests". These tests are testing type inference with the public API. This makes a lot of sense for |jedi|. Also, it is hard to write doctests/unittests for the internal data structures. There are different kinds of tests: - completions / inference ``#?`` - goto: ``#!`` - references: ``#<`` How to run tests? +++++++++++++++++ Jedi uses pytest_ to run unit and integration tests. To run tests, simply run ``pytest``. .. _pytest: http://pytest.org Most integration test cases are located in the ``test/completion`` directory and each test case starts with one of these comments: - ``#?`` (completions / inference) - ``#!`` (goto) - ``#<`` (references) There is also support for third party libraries. In a normal test run they are not being executed, you have to provide a ``--thirdparty`` option. In addition to pytest's ``-k`` and ``-m`` options, you can use the ``-T`` (``--test-files`) option to specify which test cases should run. It takes the format of ``FILE_NAME[:LINE[,LINE[,...]]]`` where ``FILE_NAME`` is a file in ``test/completion`` and ``LINE`` is a line number of the test comment. Here are some examples: Run tests only in ``completion/basic.py`` and ``completion/imports.py``:: pytest test/test_integration.py -T basic.py -T imports.py Run test at line 4, 6, and 8 in ``completion/basic.py``:: pytest test/test_integration.py -T basic.py:4,6,8 See ``pytest --help`` for more information. If you want to debug a test, just use the ``--pdb`` option. Alternate Test Runner +++++++++++++++++++++ If you don't like the output of ``pytest``, there's an alternate test runner that you can start by running ``./run.py``. The above example could be run by:: ./run.py basic 4 6 8 50-80 The advantage of this runner is simplicity and more customized error reports. Auto-Completion Tests +++++++++++++++++++++ Uses a comment to specify a test on the next line. The comment defines the expected completions. The comment always begins with `#?`. The last row symbolizes the cursor. For example:: #? ['upper'] a = 'foo'; a.upp Inference Tests +++++++++++++++ Inference tests look very simliar. The difference is that inference tests don't use brackets:: #? int() ab = 3; ab Goto Tests ++++++++++ Goto Tests look like this:: abc = 1 #! ['abc=1'] abc Additionally it is possible to specify the column by adding a number, which describes the position of the test (otherwise it's just the end of line):: #! 2 ['abc=1'] abc Reference Tests +++++++++++++++ Tests look like this:: abc = 1 #< (1,0), (3,0) abc """ import os import re import sys import operator if sys.version_info < (3, 8): literal_eval = eval else: from ast import literal_eval from io import StringIO from functools import reduce from unittest.mock import ANY from pathlib import Path import parso from _pytest.outcomes import Skipped import pytest import jedi from jedi import debug from jedi.api.classes import Name from jedi.api.completion import get_user_context from jedi import parser_utils from jedi.api.environment import get_default_environment, get_system_environment from jedi.inference.gradual.conversion import convert_values from jedi.inference.analysis import Warning test_dir = Path(__file__).absolute().parent TEST_COMPLETIONS = 0 TEST_INFERENCE = 1 TEST_GOTO = 2 TEST_REFERENCES = 3 grammar36 = parso.load_grammar(version='3.6') class BaseTestCase(object): def __init__(self, skip_version_info=None): self._skip_version_info = skip_version_info self._skip = None def set_skip(self, reason): self._skip = reason def get_skip_reason(self, environment): if self._skip is not None: return self._skip if self._skip_version_info is None: return comp_map = { '==': 'eq', '<=': 'le', '>=': 'ge', '<': 'lt', '>': 'gt', } min_version, operator_ = self._skip_version_info operation = getattr(operator, comp_map[operator_]) if not operation(environment.version_info[:2], min_version): return "Python version %s %s.%s" % ( operator_, min_version[0], min_version[1] ) class IntegrationTestCase(BaseTestCase): def __init__(self, test_type, correct, line_nr, column, start, line, path=None, skip_version_info=None): super().__init__(skip_version_info) self.test_type = test_type self.correct = correct self.line_nr = line_nr self.column = column self.start = start self.line = line self.path = path self._project = jedi.Project(test_dir) @property def module_name(self): return os.path.splitext(os.path.basename(self.path))[0] @property def line_nr_test(self): """The test is always defined on the line before.""" return self.line_nr - 1 def __repr__(self): return '<%s: %s:%s %r>' % (self.__class__.__name__, self.path, self.line_nr_test, self.line.rstrip()) def script(self, environment): return jedi.Script( self.source, path=self.path, environment=environment, project=self._project ) def run(self, compare_cb, environment=None): testers = { TEST_COMPLETIONS: self.run_completion, TEST_INFERENCE: self.run_inference, TEST_GOTO: self.run_goto, TEST_REFERENCES: self.run_get_references, } if (self.path.endswith('pytest.py') or self.path.endswith('conftest.py')) \ and os.path.realpath(environment.executable) != os.path.realpath(sys.executable): # It's not guarantueed that pytest is installed in test # environments, if we're not running in the same environment that # we're already in, so just skip that case. pytest.skip() return testers[self.test_type](compare_cb, environment) def run_completion(self, compare_cb, environment): completions = self.script(environment).complete(self.line_nr, self.column) # import cProfile; cProfile.run('...') comp_str = {c.name for c in completions} for r in completions: # Test if this access raises an error assert isinstance(r.type, str) return compare_cb(self, comp_str, set(literal_eval(self.correct))) def run_inference(self, compare_cb, environment): script = self.script(environment) inference_state = script._inference_state def comparison(definition): suffix = '()' if definition.type == 'instance' else '' return definition.full_name + suffix def definition(correct, correct_start, path): should_be = set() for match in re.finditer('(?:[^ ]+)', correct): string = match.group(0) parser = grammar36.parse(string, start_symbol='eval_input', error_recovery=False) parser_utils.move(parser.get_root_node(), self.line_nr) node = parser.get_root_node() module_context = script._get_module_context() user_context = get_user_context(module_context, (self.line_nr, 0)) node.parent = user_context.tree_node results = convert_values(user_context.infer_node(node)) if not results: raise Exception('Could not resolve %s on line %s' % (match.string, self.line_nr - 1)) should_be |= set(Name(inference_state, r.name) for r in results) debug.dbg('Finished getting types', color='YELLOW') # Because the objects have different ids, `repr`, then compare. should = set(comparison(r) for r in should_be) return should should = definition(self.correct, self.start, script.path) result = script.infer(self.line_nr, self.column) is_str = set(comparison(r) for r in result) for r in result: # Test if this access raises an error assert isinstance(r.type, str) return compare_cb(self, is_str, should) def run_goto(self, compare_cb, environment): result = self.script(environment).goto(self.line_nr, self.column) comp_str = str(sorted(str(r.description) for r in result)) return compare_cb(self, comp_str, self.correct) def run_get_references(self, compare_cb, environment): result = self.script(environment).get_references(self.line_nr, self.column) self.correct = self.correct.strip() compare = sorted( (('stub:' if r.is_stub() else '') + re.sub(r'^completion\.', '', r.module_name), r.line, r.column) for r in result ) wanted = [] if not self.correct: positions = [] else: positions = literal_eval(self.correct) for pos_tup in positions: if type(pos_tup[0]) == str: # this means that there is a module specified if pos_tup[1] == ...: pos_tup = pos_tup[0], ANY, pos_tup[2] wanted.append(pos_tup) else: line = pos_tup[0] if pos_tup[0] is not None: line += self.line_nr wanted.append((self.module_name, line, pos_tup[1])) return compare_cb(self, compare, sorted(wanted)) class StaticAnalysisCase(BaseTestCase): """ Static Analysis cases lie in the static_analysis folder. The tests also start with `#!`, like the inference tests. """ def __init__(self, path): self._path = path self.name = os.path.basename(path) with open(path) as f: self._source = f.read() skip_version_info = None for line in self._source.splitlines(): skip_version_info = skip_python_version(line) or skip_version_info super().__init__(skip_version_info) def collect_comparison(self): cases = [] for line_nr, line in enumerate(self._source.splitlines(), 1): match = re.match(r'(\s*)#! (\d+ )?(.*)$', line) if match is not None: column = int(match.group(2) or 0) + len(match.group(1)) cases.append((line_nr + 1, column, match.group(3))) return cases def run(self, compare_cb, environment): def typ_str(inst): return 'warning ' if isinstance(inst, Warning) else '' analysis = jedi.Script( self._source, path=self._path, environment=environment, )._analysis() analysis = [(r.line, r.column, typ_str(r) + r.name) for r in analysis] compare_cb(self, analysis, self.collect_comparison()) def __repr__(self): return "<%s: %s>" % (self.__class__.__name__, os.path.basename(self._path)) def skip_python_version(line): # check for python minimal version number match = re.match(r" *# *python *([<>]=?|==) *(\d+(?:\.\d+)?)$", line) if match: minimal_python_version = tuple(map(int, match.group(2).split("."))) return minimal_python_version, match.group(1) return None def collect_file_tests(path, lines, lines_to_execute): def makecase(t): return IntegrationTestCase(t, correct, line_nr, column, start, line, path=path, skip_version_info=skip_version_info) start = None correct = None test_type = None skip_version_info = None for line_nr, line in enumerate(lines, 1): if correct is not None: r = re.match(r'^(\d+)\s*(.*)$', correct) if r: column = int(r.group(1)) correct = r.group(2) start += r.regs[2][0] # second group, start index else: column = len(line) - 1 # -1 for the \n if test_type == '!': yield makecase(TEST_GOTO) elif test_type == '<': yield makecase(TEST_REFERENCES) elif correct.startswith('['): yield makecase(TEST_COMPLETIONS) else: yield makecase(TEST_INFERENCE) correct = None else: skip_version_info = skip_python_version(line) or skip_version_info try: r = re.search(r'(?:^|(?<=\s))#([?!<])\s*([^\n]*)', line) # test_type is ? for completion and ! for goto test_type = r.group(1) correct = r.group(2) # Quick hack to make everything work (not quite a bloody unicorn hack though). if correct == '': correct = ' ' start = r.start() except AttributeError: correct = None else: # Skip the test, if this is not specified test. for l in lines_to_execute: if isinstance(l, tuple) and l[0] <= line_nr <= l[1] \ or line_nr == l: break else: if lines_to_execute: correct = None def collect_dir_tests(base_dir, test_files, check_thirdparty=False): for f_name in os.listdir(base_dir): files_to_execute = [a for a in test_files.items() if f_name.startswith(a[0])] lines_to_execute = reduce(lambda x, y: x + y[1], files_to_execute, []) if f_name.endswith(".py") and (not test_files or files_to_execute): skip = None if check_thirdparty: lib = f_name.replace('_.py', '') try: # there is always an underline at the end. # It looks like: completion/thirdparty/pylab_.py __import__(lib) except ImportError: skip = 'Thirdparty-Library %s not found.' % lib path = os.path.join(base_dir, f_name) with open(path, newline='') as f: source = f.read() for case in collect_file_tests(path, StringIO(source), lines_to_execute): case.source = source if skip: case.set_skip(skip) yield case docoptstr = """ Using run.py to make debugging easier with integration tests. An alternative testing format, which is much more hacky, but very nice to work with. Usage: run.py [--pdb] [--debug] [--thirdparty] [--env ] [...] run.py --help Options: -h --help Show this screen. --pdb Enable pdb debugging on fail. -d, --debug Enable text output debugging (please install ``colorama``). --thirdparty Also run thirdparty tests (in ``completion/thirdparty``). --env A Python version, like 3.9, 3.8, etc. """ if __name__ == '__main__': import docopt arguments = docopt.docopt(docoptstr) import time t_start = time.time() if arguments['--debug']: jedi.set_debug_function() # get test list, that should be executed test_files = {} last = None for arg in arguments['']: match = re.match(r'(\d+)-(\d+)', arg) if match: start, end = match.groups() test_files[last].append((int(start), int(end))) elif arg.isdigit(): if last is None: continue test_files[last].append(int(arg)) else: test_files[arg] = [] last = arg # completion tests: dir_ = os.path.dirname(os.path.realpath(__file__)) completion_test_dir = os.path.join(dir_, '../test/completion') completion_test_dir = os.path.abspath(completion_test_dir) tests_fail = 0 # execute tests cases = list(collect_dir_tests(completion_test_dir, test_files)) if test_files or arguments['--thirdparty']: completion_test_dir += '/thirdparty' cases += collect_dir_tests(completion_test_dir, test_files, True) def file_change(current, tests, fails): if current is None: current = '' else: current = os.path.basename(current) print('{:25} {} tests and {} fails.'.format(current, tests, fails)) def report(case, actual, desired): if actual == desired: return 0 else: print("\ttest fail @%d, actual = %s, desired = %s" % (case.line_nr - 1, actual, desired)) return 1 if arguments['--env']: environment = get_system_environment(arguments['--env']) else: # Will be 3.6. environment = get_default_environment() import traceback current = cases[0].path if cases else None count = fails = 0 for c in cases: if c.get_skip_reason(environment): continue if current != c.path: file_change(current, count, fails) current = c.path count = fails = 0 try: if c.run(report, environment): tests_fail += 1 fails += 1 except Exception: traceback.print_exc() print("\ttest fail @%d" % (c.line_nr - 1)) tests_fail += 1 fails += 1 if arguments['--pdb']: import pdb pdb.post_mortem() except Skipped: pass count += 1 file_change(current, count, fails) print('\nSummary: (%s fails of %s tests) in %.3fs' % (tests_fail, len(cases), time.time() - t_start)) exit_code = 1 if tests_fail else 0 sys.exit(exit_code) ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4743795 jedi-0.19.1/test/static_analysis/0000775000175000017500000000000000000000000016551 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/static_analysis/attribute_error.py0000664000175000017500000000404700000000000022344 0ustar00davedave00000000000000class Cls(): class_attr = '' def __init__(self, input): self.instance_attr = 3 self.input = input def f(self): #! 12 attribute-error return self.not_existing def undefined_object(self, obj): """ Uses an arbitrary object and performs an operation on it, shouldn't be a problem. """ obj.arbitrary_lookup def defined_lookup(self, obj): """ `obj` is defined by a call into this function. """ obj.upper #! 4 attribute-error obj.arbitrary_lookup #! 13 name-error class_attr = a Cls(1).defined_lookup('') c = Cls(1) c.class_attr Cls.class_attr #! 4 attribute-error Cls.class_attr_error c.instance_attr #! 2 attribute-error c.instance_attr_error c.something = None #! 12 name-error something = a something # ----------------- # Unused array variables should still raise attribute errors. # ----------------- # should not raise anything. for loop_variable in [1, 2]: #! 4 name-error x = undefined loop_variable #! 28 name-error for loop_variable in [1, 2, undefined]: pass #! 7 attribute-error [1, ''.undefined_attr] def return_one(something): return 1 #! 14 attribute-error return_one(''.undefined_attribute) #! 12 name-error [r for r in undefined] #! 1 name-error [undefined for r in [1, 2]] [r for r in [1, 2]] # some random error that showed up class NotCalled(): def match_something(self, param): seems_to_need_an_assignment = param return [value.match_something() for value in []] # ----------------- # decorators # ----------------- #! 1 name-error @undefined_decorator def func(): return 1 # ----------------- # operators # ----------------- string = '%s %s' % (1, 2) # Shouldn't raise an error, because `string` is really just a string, not an # array or something. string.upper # ----------------- # imports # ----------------- # Star imports and the like in modules should not cause attribute errors in # this module. import import_tree import_tree.a import_tree.b ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/static_analysis/attribute_warnings.py0000664000175000017500000000135200000000000023037 0ustar00davedave00000000000000""" Jedi issues warnings for possible errors if ``__getattr__``, ``__getattribute__`` or ``setattr`` are used. """ # ----------------- # __getattr*__ # ----------------- class Cls(): def __getattr__(self, name): return getattr(str, name) Cls().upper #! 6 warning attribute-error Cls().undefined class Inherited(Cls): pass Inherited().upper #! 12 warning attribute-error Inherited().undefined # ----------------- # setattr # ----------------- class SetattrCls(): def __init__(self, dct): # Jedi doesn't even try to understand such code for k, v in dct.items(): setattr(self, k, v) self.defined = 3 c = SetattrCls({'a': 'b'}) c.defined #! 2 warning attribute-error c.undefined ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/static_analysis/branches.py0000664000175000017500000000160700000000000020714 0ustar00davedave00000000000000# ----------------- # Simple tests # ----------------- import random if random.choice([0, 1]): x = '' else: x = 1 if random.choice([0, 1]): y = '' else: y = 1 # A simple test if x != 1: x.upper() else: #! 2 attribute-error x.upper() pass # This operation is wrong, because the types could be different. #! 6 type-error-operation z = x + y # However, here we have correct types. if x == y: z = x + y else: #! 6 type-error-operation z = x + y # TODO enable this one. #x = 3 #if x != 1: # x.upper() # ----------------- # With a function # ----------------- def addition(a, b): if type(a) == type(b): # Might still be a type error, we might want to change this in the # future. #! 9 type-error-operation return a + b else: #! 9 type-error-operation return a + b addition(1, 1) addition(1.0, '') ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/static_analysis/builtins.py0000664000175000017500000000027100000000000020754 0ustar00davedave00000000000000# ---------- # isinstance # ---------- isinstance(1, int) isinstance(1, (int, str)) #! 14 type-error-isinstance isinstance(1, 1) #! 14 type-error-isinstance isinstance(1, [int, str]) ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/static_analysis/class_simple.py0000664000175000017500000000023000000000000021574 0ustar00davedave00000000000000class Base(object): class Nested(): def foo(): pass class X(Base.Nested): pass X().foo() #! 4 attribute-error X().bar() ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/static_analysis/comprehensions.py0000664000175000017500000000140500000000000022157 0ustar00davedave00000000000000[a + 1 for a in [1, 2]] #! 3 type-error-operation [a + '' for a in [1, 2]] #! 3 type-error-operation (a + '' for a in [1, 2]) #! 12 type-error-not-iterable [a for a in 1] tuple(str(a) for a in [1]) #! 8 type-error-operation tuple(a + 3 for a in ['']) # ---------- # Some variables within are not defined # ---------- abcdef = [] #! 12 name-error [1 for a in NOT_DEFINFED for b in abcdef if 1] #! 25 name-error [1 for a in [1] for b in NOT_DEFINED if 1] #! 12 name-error [1 for a in NOT_DEFINFED for b in [1] if 1] #! 19 name-error (1 for a in [1] if NOT_DEFINED) # ---------- # unbalanced sides. # ---------- # ok (1 for a, b in [(1, 2)]) #! 13 value-error-too-few-values (1 for a, b, c in [(1, 2)]) #! 10 value-error-too-many-values (1 for a, b in [(1, 2, 3)]) ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/static_analysis/descriptors.py0000664000175000017500000000036500000000000021470 0ustar00davedave00000000000000# classmethod class TarFile(): @classmethod def open(cls, name, **kwargs): return cls.taropen(name, **kwargs) @classmethod def taropen(cls, name, **kwargs): return name # should just work TarFile.open('hallo') ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/static_analysis/generators.py0000664000175000017500000000014600000000000021275 0ustar00davedave00000000000000def generator(): yield 1 #! 11 type-error-not-subscriptable generator()[0] list(generator())[0] ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4743795 jedi-0.19.1/test/static_analysis/import_tree/0000775000175000017500000000000000000000000021102 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/static_analysis/import_tree/__init__.py0000664000175000017500000000014200000000000023210 0ustar00davedave00000000000000""" Another import tree, this time not for completion, but static analysis. """ from .a import * ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/static_analysis/import_tree/a.py0000664000175000017500000000002000000000000021664 0ustar00davedave00000000000000from . import b ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/static_analysis/import_tree/b.py0000664000175000017500000000000000000000000021663 0ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/static_analysis/imports.py0000664000175000017500000000057600000000000020630 0ustar00davedave00000000000000 #! 7 import-error import not_existing import os from os.path import abspath #! 20 import-error from os.path import not_existing from datetime import date date.today #! 5 attribute-error date.not_existing_attribute #! 14 import-error from datetime.date import today #! 16 import-error import datetime.datetime #! 7 import-error import not_existing_nested.date import os.path ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/static_analysis/iterable.py0000664000175000017500000000055600000000000020720 0ustar00davedave00000000000000 a, b = {'asdf': 3, 'b': 'str'} a x = [1] x[0], b = {'a': 1, 'b': '2'} dct = {3: ''} for x in dct: pass #! 4 type-error-not-iterable for x, y in dct: pass # Shouldn't cause issues, because if there are no types (or we don't know what # the types are, we should just ignore it. #! 0 value-error-too-few-values a, b = [] #! 7 name-error a, b = NOT_DEFINED ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/static_analysis/keywords.py0000664000175000017500000000015400000000000020772 0ustar00davedave00000000000000def raises(): raise KeyError() def wrong_name(): #! 6 name-error raise NotExistingException() ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/static_analysis/normal_arguments.py0000664000175000017500000000217600000000000022506 0ustar00davedave00000000000000# ----------------- # normal arguments (no keywords) # ----------------- def simple(a): return a simple(1) #! 6 type-error-too-few-arguments simple() #! 10 type-error-too-many-arguments simple(1, 2) #! 10 type-error-too-many-arguments simple(1, 2, 3) # ----------------- # keyword arguments # ----------------- simple(a=1) #! 7 type-error-keyword-argument simple(b=1) #! 10 type-error-too-many-arguments simple(1, a=1) def two_params(x, y): return y two_params(y=2, x=1) two_params(1, y=2) #! 11 type-error-multiple-values two_params(1, x=2) #! 17 type-error-too-many-arguments two_params(1, 2, y=3) # ----------------- # default arguments # ----------------- def default(x, y=1, z=2): return x #! 7 type-error-too-few-arguments default() default(1) default(1, 2) default(1, 2, 3) #! 17 type-error-too-many-arguments default(1, 2, 3, 4) default(x=1) # ----------------- # class arguments # ----------------- class Instance(): def __init__(self, foo): self.foo = foo Instance(1).foo Instance(foo=1).foo #! 12 type-error-too-many-arguments Instance(1, 2).foo #! 8 type-error-too-few-arguments Instance().foo ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/static_analysis/operations.py0000664000175000017500000000030700000000000021306 0ustar00davedave00000000000000-1 + 1 1 + 1.0 #! 2 type-error-operation 1 + '1' #! 2 type-error-operation 1 - '1' -1 - - 1 # TODO uncomment #-1 - int() #int() - float() float() - 3.0 a = 3 b = '' #! 2 type-error-operation a + b ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/static_analysis/star_arguments.py0000664000175000017500000000427500000000000022171 0ustar00davedave00000000000000# ----------------- # *args # ----------------- def simple(a): return a def nested(*args): return simple(*args) nested(1) #! 6 type-error-too-few-arguments nested() def nested_no_call_to_function(*args): return simple(1, *args) def simple2(a, b, c): return b def nested(*args): return simple2(1, *args) def nested_twice(*args1): return nested(*args1) nested_twice(2, 3) #! 13 type-error-too-few-arguments nested_twice(2) #! 19 type-error-too-many-arguments nested_twice(2, 3, 4) # A named argument can be located before *args. def star_args_with_named(*args): return simple2(c='', *args) star_args_with_named(1, 2) # ----------------- # **kwargs # ----------------- def kwargs_test(**kwargs): return simple2(1, **kwargs) kwargs_test(c=3, b=2) #! 12 type-error-too-few-arguments kwargs_test(c=3) #! 12 type-error-too-few-arguments kwargs_test(b=2) #! 22 type-error-keyword-argument kwargs_test(b=2, c=3, d=4) #! 12 type-error-multiple-values kwargs_test(b=2, c=3, a=4) def kwargs_nested(**kwargs): return kwargs_test(b=2, **kwargs) kwargs_nested(c=3) #! 13 type-error-too-few-arguments kwargs_nested() #! 19 type-error-keyword-argument kwargs_nested(c=2, d=4) #! 14 type-error-multiple-values kwargs_nested(c=2, a=4) # TODO reenable ##! 14 type-error-multiple-values #kwargs_nested(b=3, c=2) # ----------------- # mixed *args/**kwargs # ----------------- def simple_mixed(a, b, c): return b def mixed(*args, **kwargs): return simple_mixed(1, *args, **kwargs) mixed(1, 2) mixed(1, c=2) mixed(b=2, c=3) mixed(c=4, b='') # need separate functions, otherwise these might swallow the errors def mixed2(*args, **kwargs): return simple_mixed(1, *args, **kwargs) #! 7 type-error-too-few-arguments mixed2(c=2) #! 7 type-error-too-few-arguments mixed2(3) #! 13 type-error-too-many-arguments mixed2(3, 4, 5) # TODO reenable ##! 13 type-error-too-many-arguments #mixed2(3, 4, c=5) #! 7 type-error-multiple-values mixed2(3, b=5) # ----------------- # plain wrong arguments # ----------------- #! 12 type-error-star-star simple(1, **[]) #! 12 type-error-star-star simple(1, **1) class A(): pass #! 12 type-error-star-star simple(1, **A()) #! 11 type-error-star simple(1, *1) ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/static_analysis/try_except.py0000664000175000017500000000331500000000000021313 0ustar00davedave00000000000000try: #! 4 attribute-error str.not_existing except TypeError: pass try: str.not_existing except AttributeError: #! 4 attribute-error str.not_existing pass try: import not_existing_import except ImportError: pass try: #! 7 import-error import not_existing_import2 except AttributeError: pass # ----------------- # multi except # ----------------- try: str.not_existing except (TypeError, AttributeError): pass try: str.not_existing except ImportError: pass except (NotImplementedError, AttributeError): pass try: #! 4 attribute-error str.not_existing except (TypeError, NotImplementedError): pass # ----------------- # detailed except # ----------------- try: str.not_existing except ((AttributeError)): pass try: #! 4 attribute-error str.not_existing except [AttributeError]: pass # Should be able to detect errors in except statement as well. try: pass #! 7 name-error except Undefined: pass # ----------------- # inheritance # ----------------- try: undefined except Exception: pass # should catch everything try: undefined except: pass # ----------------- # kind of similar: hasattr # ----------------- if hasattr(str, 'undefined'): str.undefined str.upper #! 4 attribute-error str.undefined2 #! 4 attribute-error int.undefined else: str.upper #! 4 attribute-error str.undefined # ----------------- # arguments # ----------------- def i_see(r): return r def lala(): # This weird structure checks if the error is actually resolved in the # right place. a = TypeError try: i_see() except a: pass #! 5 type-error-too-few-arguments i_see() ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4743795 jedi-0.19.1/test/test_api/0000775000175000017500000000000000000000000015167 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/test_api/__init__.py0000664000175000017500000000000000000000000017266 0ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/test_api/test_analysis.py0000664000175000017500000000042700000000000020426 0ustar00davedave00000000000000def test_issue436(Script): code = "bar = 0\nbar += 'foo' + 4" errors = set(repr(e) for e in Script(code)._analysis()) assert len(errors) == 2 assert '' in errors assert '' in errors ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/test_api/test_api.py0000664000175000017500000002721000000000000017353 0ustar00davedave00000000000000""" Test all things related to the ``jedi.api`` module. """ import os from textwrap import dedent import pytest from pytest import raises from parso import cache from jedi import preload_module from jedi.inference.gradual import typeshed from test.helpers import test_dir, get_example_dir def test_preload_modules(): def check_loaded(*module_names): for grammar_cache in cache.parser_cache.values(): if None in grammar_cache: break # Filter the typeshed parser cache. typeshed_cache_count = sum( 1 for path in grammar_cache if path is not None and str(path).startswith(str(typeshed.TYPESHED_PATH)) ) # +1 for None module (currently used) assert len(grammar_cache) - typeshed_cache_count == len(module_names) + 1 for i in module_names: assert [i in str(k) for k in grammar_cache.keys() if k is not None] old_cache = cache.parser_cache.copy() cache.parser_cache.clear() try: preload_module('sys') check_loaded() # compiled (c_builtin) modules shouldn't be in the cache. preload_module('types', 'token') check_loaded('types', 'token') finally: cache.parser_cache.update(old_cache) def test_empty_script(Script): assert Script('') def test_line_number_errors(Script): """ Script should raise a ValueError if line/column numbers are not in a valid range. """ s = 'hello' # lines with raises(ValueError): Script(s).complete(2, 0) with raises(ValueError): Script(s).complete(0, 0) # columns with raises(ValueError): Script(s).infer(1, len(s) + 1) with raises(ValueError): Script(s).goto(1, -1) # ok Script(s).get_signatures(1, 0) Script(s).get_references(1, len(s)) def _check_number(Script, source, result='float'): completions = Script(source).complete() assert completions[0].parent().name == result def test_completion_on_number_literals(Script): # No completions on an int literal (is a float). assert [c.name for c in Script('1. ').complete()] \ == ['and', 'if', 'in', 'is', 'not', 'or'] # Multiple points after an int literal basically mean that there's a float # and a call after that. _check_number(Script, '1..') _check_number(Script, '1.0.') # power notation _check_number(Script, '1.e14.') _check_number(Script, '1.e-3.') _check_number(Script, '9e3.') assert Script('1.e3..').complete() == [] assert Script('1.e-13..').complete() == [] def test_completion_on_hex_literals(Script): assert Script('0x1..').complete() == [] _check_number(Script, '0x1.', 'int') # hexdecimal # Completing binary literals doesn't work if they are not actually binary # (invalid statements). assert Script('0b2.b').complete() == [] _check_number(Script, '0b1.', 'int') # binary _check_number(Script, '0x2e.', 'int') _check_number(Script, '0xE7.', 'int') _check_number(Script, '0xEa.', 'int') # theoretically, but people can just check for syntax errors: assert Script('0x.').complete() == [] def test_completion_on_complex_literals(Script): assert Script('1j..').complete() == [] _check_number(Script, '1j.', 'complex') _check_number(Script, '44.j.', 'complex') _check_number(Script, '4.0j.', 'complex') # No dot no completion - I thought, but 4j is actually a literal after # which a keyword like or is allowed. Good times, haha! # However this has been disabled again, because it apparently annoyed # users. So no completion after j without a space :) assert not Script('4j').complete() assert ({c.name for c in Script('4j ').complete()} == {'if', 'and', 'in', 'is', 'not', 'or'}) def test_goto_non_name(Script, environment): assert Script('for').goto() == [] assert Script('assert').goto() == [] assert Script('True').goto() == [] def test_infer_on_non_name(Script): assert Script('import x').infer(column=0) == [] def test_infer_on_generator(Script, environment): script = Script('def x(): yield 1\ny=x()\ny') def_, = script.infer() assert def_.name == 'Generator' def_, = script.infer(only_stubs=True) assert def_.name == 'Generator' def test_goto_definition_not_multiple(Script): """ There should be only one result if it leads back to the same origin (e.g. instance method) """ s = dedent('''\ import random class A(): def __init__(self, a): self.a = 3 def foo(self): pass if random.randint(0, 1): a = A(2) else: a = A(1) a''') assert len(Script(s).infer()) == 1 def test_reference_description(Script): descs = [u.description for u in Script("foo = ''; foo").get_references()] assert set(descs) == {"foo = ''", 'foo'} def test_get_line_code(Script): def get_line_code(source, line=None, **kwargs): # On Windows replace \r return Script(source).complete(line=line)[0].get_line_code(**kwargs).replace('\r', '') # On builtin assert get_line_code('abs') == 'def abs(__x: SupportsAbs[_T]) -> _T: ...\n' # On custom code first_line = 'def foo():\n' line = ' foo' code = first_line + line assert get_line_code(code) == first_line # With before/after code = code + '\nother_line' assert get_line_code(code, line=2) == first_line assert get_line_code(code, line=2, after=1) == first_line + line + '\n' assert get_line_code(code, line=2, after=2, before=1) == code # Should just be the whole thing, since there are no more lines on both # sides. assert get_line_code(code, line=2, after=3, before=3) == code def test_get_line_code_on_builtin(Script, disable_typeshed): abs_ = Script('abs').complete()[0] assert abs_.name == 'abs' assert abs_.get_line_code() == '' assert abs_.line is None def test_goto_follow_imports(Script): code = dedent(""" import inspect inspect.isfunction""") definition, = Script(code).goto(column=0, follow_imports=True) assert definition.module_path.name == 'inspect.py' assert (definition.line, definition.column) == (1, 0) definition, = Script(code).goto(follow_imports=True) assert definition.module_path.name == 'inspect.py' assert (definition.line, definition.column) > (1, 0) code = '''def param(p): pass\nparam(1)''' start_pos = 1, len('def param(') script = Script(code) definition, = script.goto(*start_pos, follow_imports=True) assert (definition.line, definition.column) == start_pos assert definition.name == 'p' result, = definition.goto() assert result.name == 'p' result, = definition.infer() assert result.name == 'int' result, = result.infer() assert result.name == 'int' definition, = script.goto(*start_pos) assert (definition.line, definition.column) == start_pos d, = Script('a = 1\na').goto(follow_imports=True) assert d.name == 'a' def test_goto_module(Script): def check(line, expected, follow_imports=False): script = Script(path=path) module, = script.goto(line=line, follow_imports=follow_imports) assert module.module_path == expected base_path = get_example_dir('simple_import') path = base_path.joinpath('__init__.py') check(1, base_path.joinpath('module.py')) check(1, base_path.joinpath('module.py'), follow_imports=True) check(5, base_path.joinpath('module2.py')) def test_goto_definition_cursor(Script): s = ("class A():\n" " def _something(self):\n" " return\n" " def different_line(self,\n" " b):\n" " return\n" "A._something\n" "A.different_line" ) in_name = 2, 9 under_score = 2, 8 cls = 2, 7 should1 = 7, 10 diff_line = 4, 10 should2 = 8, 10 def get_def(pos): return [d.description for d in Script(s).infer(*pos)] in_name = get_def(in_name) under_score = get_def(under_score) should1 = get_def(should1) should2 = get_def(should2) diff_line = get_def(diff_line) assert should1 == in_name assert should1 == under_score assert should2 == diff_line assert get_def(cls) == [] def test_no_statement_parent(Script): source = dedent(""" def f(): pass class C: pass variable = f if random.choice([0, 1]) else C""") defs = Script(source).infer(column=3) defs = sorted(defs, key=lambda d: d.line) assert [d.description for d in defs] == ['def f', 'class C'] def test_backslash_continuation_and_bracket(Script): code = dedent(r""" x = 0 a = \ [1, 2, 3, (x)]""") lines = code.splitlines() column = lines[-1].index('(') def_, = Script(code).infer(line=len(lines), column=column) assert def_.name == 'int' def test_goto_follow_builtin_imports(Script): s = Script('import sys; sys') d, = s.goto(follow_imports=True) assert d.in_builtin_module() is True d, = s.goto(follow_imports=True, follow_builtin_imports=True) assert d.in_builtin_module() is True def test_docstrings_for_completions(Script): for c in Script('').complete(): assert isinstance(c.docstring(), str) def test_fuzzy_completion(Script): script = Script('string = "hello"\nstring.upper') assert ['isupper', 'upper'] == [comp.name for comp in script.complete(fuzzy=True)] def test_math_fuzzy_completion(Script, environment): script = Script('import math\nmath.og') expected = ['copysign', 'log', 'log10', 'log1p', 'log2'] completions = script.complete(fuzzy=True) assert expected == [comp.name for comp in completions] for c in completions: assert c.complete is None def test_file_fuzzy_completion(Script): path = os.path.join(test_dir, 'completion') script = Script('"{}/ep08_i'.format(path)) expected = [ 'pep0484_basic.py"', 'pep0484_generic_mismatches.py"', 'pep0484_generic_parameters.py"', 'pep0484_generic_passthroughs.py"', 'pep0484_typing.py"', ] assert expected == [comp.name for comp in script.complete(fuzzy=True)] @pytest.mark.parametrize( 'code, column', [ ('"foo"', 0), ('"foo"', 3), ('"foo"', None), ('"""foo"""', 5), ('"""foo"""', 1), ('"""foo"""', 2), ] ) def test_goto_on_string(Script, code, column): script = Script(code) assert not script.infer(column=column) assert not script.goto(column=column) def test_multi_goto(Script): script = Script('x = 1\ny = 1.0\nx\ny') x, = script.goto(line=3) y, = script.goto(line=4) assert x.line == 1 assert y.line == 2 @pytest.mark.parametrize( 'code, column, expected', [ ('str() ', 3, 'str'), ('str() ', 4, 'str'), ('str() ', 5, 'str'), ('str() ', 6, None), ('str( ) ', 6, None), (' 1', 1, None), ('str(1) ', 3, 'str'), ('str(1) ', 4, 'int'), ('str(1) ', 5, 'int'), ('str(1) ', 6, 'str'), ('str(1) ', 7, None), ('str( 1) ', 4, 'str'), ('str( 1) ', 5, 'int'), ('str(+1) ', 4, 'str'), ('str(+1) ', 5, 'int'), ('str(1, 1.) ', 3, 'str'), ('str(1, 1.) ', 4, 'int'), ('str(1, 1.) ', 5, 'int'), ('str(1, 1.) ', 6, None), ('str(1, 1.) ', 7, 'float'), ] ) def test_infer_after_parentheses(Script, code, column, expected): completions = Script(code).infer(column=column) if expected is None: assert completions == [] else: assert [c.name for c in completions] == [expected] ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/test_api/test_api_classes_follow_definition.py0000664000175000017500000000423200000000000024661 0ustar00davedave00000000000000from os.path import join from itertools import chain from functools import partial import jedi from ..helpers import test_dir def test_import_empty(Script): """ github #340, return the full word. """ completion = Script("import ").complete()[0] definition = completion.infer()[0] assert definition def check_follow_definition_types(Script, source): # nested import completions = Script(source, path='some_path.py').complete() defs = chain.from_iterable(c.infer() for c in completions) return [d.type for d in defs] def test_follow_import_incomplete(Script, environment): """ Completion on incomplete imports should always take the full completion to do any type inference. """ datetime = check_follow_definition_types(Script, "import itertool") assert datetime == ['module'] # empty `from * import` parts itert = jedi.Script("from itertools import ").complete() definitions = [d for d in itert if d.name == 'chain'] assert len(definitions) == 1 assert [d.type for d in definitions[0].infer()] == ['class'] # incomplete `from * import` part datetime = check_follow_definition_types(Script, "from datetime import datetim") assert set(datetime) == {'class', 'instance'} # py3: builtin and pure py version # os.path check ospath = check_follow_definition_types(Script, "from os.path import abspat") assert set(ospath) == {'function'} # alias alias = check_follow_definition_types(Script, "import io as abcd; abcd") assert alias == ['module'] def test_follow_definition_nested_import(Script): Script = partial(Script, project=jedi.Project(join(test_dir, 'completion', 'import_tree'))) types = check_follow_definition_types(Script, "import pkg.mod1; pkg") assert types == ['module'] types = check_follow_definition_types(Script, "import pkg.mod1; pkg.mod1") assert types == ['module'] types = check_follow_definition_types(Script, "import pkg.mod1; pkg.mod1.a") assert types == ['instance'] def test_follow_definition_land_on_import(Script): types = check_follow_definition_types(Script, "import datetime; datetim") assert types == ['module'] ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/test_api/test_call_signatures.py0000664000175000017500000004443700000000000021773 0ustar00davedave00000000000000from textwrap import dedent import inspect from unittest import TestCase import pytest from jedi import cache from jedi.parser_utils import get_signature from jedi import Interpreter def assert_signature(Script, source, expected_name, expected_index=0, line=None, column=None): signatures = Script(source).get_signatures(line, column) assert len(signatures) <= 1 if not signatures: assert expected_name is None, \ 'There are no signatures, but `%s` expected.' % expected_name else: assert signatures[0].name == expected_name assert signatures[0].index == expected_index return signatures[0] def test_valid_call(Script): assert_signature(Script, 'bool()', 'bool', column=5) class TestSignatures(TestCase): @pytest.fixture(autouse=True) def init(self, Script): self.Script = Script def _run_simple(self, source, name, index=0, column=None, line=1): assert_signature(self.Script, source, name, index, line, column) def test_simple(self): run = self._run_simple # simple s1 = "tuple(a, bool(" run(s1, 'tuple', 0, 6) run(s1, 'tuple', None, 8) run(s1, 'tuple', None, 9) run(s1, 'bool', 0, 14) s2 = "abs(), " run(s2, 'abs', 0, 4) run(s2, None, column=5) run(s2, None) s3 = "abs()." run(s3, None, column=5) run(s3, None) def test_more_complicated(self): run = self._run_simple s4 = 'abs(bool(), , set,' run(s4, None, column=3) run(s4, 'abs', 0, 4) run(s4, 'bool', 0, 9) run(s4, 'abs', 0, 10) run(s4, 'abs', None, 11) s5 = "tuple(1,\nif 2:\n def a():" run(s5, 'tuple', 0, 6) run(s5, 'tuple', None, 8) s6 = "bool().__eq__(" run(s6, '__eq__', 0) run(s6, 'bool', 0, 5) s7 = "str().upper().center(" s8 = "bool(int[abs(" run(s7, 'center', 0) run(s8, 'abs', 0) run(s8, 'bool', 0, 10) run("import time; abc = time; abc.sleep(", 'sleep', 0) def test_issue_57(self): # jedi #57 s = "def func(alpha, beta): pass\n" \ "func(alpha='101'," self._run_simple(s, 'func', 0, column=13, line=2) def test_for(self): # jedi-vim #11 self._run_simple("for tuple(", 'tuple', 0) self._run_simple("for s in tuple(", 'tuple', 0) def test_with(Script): # jedi-vim #9 sigs = Script("with open(").get_signatures() assert sigs assert all(sig.name == 'open' for sig in sigs) def test_get_signatures_empty_parentheses_pre_space(Script): s = dedent("""\ def f(a, b): pass f( )""") assert_signature(Script, s, 'f', 0, line=3, column=3) def test_multiple_signatures(Script): s = dedent("""\ if x: def f(a, b): pass else: def f(a, b): pass f(""") assert len(Script(s).get_signatures()) == 2 def test_get_signatures_whitespace(Script): # note: trailing space after 'abs' s = 'abs( \ndef x():\n pass\n' assert_signature(Script, s, 'abs', 0, line=1, column=5) def test_decorator_in_class(Script): """ There's still an implicit param, with a decorator. Github issue #319. """ s = dedent("""\ def static(func): def wrapped(obj, *args): return f(type(obj), *args) return wrapped class C(object): @static def test(cls): return 10 C().test(""") signatures = Script(s).get_signatures() assert len(signatures) == 1 x = [p.description for p in signatures[0].params] assert x == ['param *args'] def test_additional_brackets(Script): assert_signature(Script, 'abs((', 'abs', 0) def test_unterminated_strings(Script): assert_signature(Script, 'abs(";', 'abs', 0) def test_whitespace_before_bracket(Script): assert_signature(Script, 'abs (', 'abs', 0) assert_signature(Script, 'abs (";', 'abs', 0) assert_signature(Script, 'abs\n(', None) def test_brackets_in_string_literals(Script): assert_signature(Script, 'abs (" (', 'abs', 0) assert_signature(Script, 'abs (" )', 'abs', 0) def test_function_definitions_should_break(Script): """ Function definitions (and other tokens that cannot exist within call signatures) should break and not be able to return a signature. """ assert_signature(Script, 'abs(\ndef x', 'abs', 0) assert not Script('abs(\ndef x(): pass').get_signatures() def test_flow_call(Script): assert not Script('if (1').get_signatures() def test_chained_calls(Script): source = dedent(''' class B(): def test2(self, arg): pass class A(): def test1(self): return B() A().test1().test2(''') assert_signature(Script, source, 'test2', 0) def test_return(Script): source = dedent(''' def foo(): return '.'.join()''') assert_signature(Script, source, 'join', 0, column=len(" return '.'.join(")) def test_find_signature_on_module(Script): """github issue #240""" s = 'import datetime; datetime(' # just don't throw an exception (if numpy doesn't exist, just ignore it) assert Script(s).get_signatures() == [] def test_complex(Script, environment): s = """ def abc(a,b): pass def a(self): abc( if 1: pass """ assert_signature(Script, s, 'abc', 0, line=6, column=20) s = """ import re def huhu(it): re.compile( return it * 2 """ sig1, sig2 = sorted(Script(s).get_signatures(line=4, column=27), key=lambda s: s.line) assert sig1.name == sig2.name == 'compile' assert sig1.index == sig2.index == 0 func1, = sig1._name.infer() func2, = sig2._name.infer() # Do these checks just for Python 3, I'm too lazy to deal with this # legacy stuff. ~ dave. assert get_signature(func1.tree_node) \ == 'compile(pattern: AnyStr, flags: _FlagsType = ...) -> Pattern[AnyStr]' assert get_signature(func2.tree_node) \ == 'compile(pattern: Pattern[AnyStr], flags: _FlagsType = ...) ->\nPattern[AnyStr]' # jedi-vim #70 s = """def foo(""" assert Script(s).get_signatures() == [] # jedi-vim #116 s = """import itertools; test = getattr(itertools, 'chain'); test(""" assert_signature(Script, s, 'chain', 0) def _params(Script, source, line=None, column=None): signatures = Script(source).get_signatures(line, column) assert len(signatures) == 1 return signatures[0].params def test_int_params(Script): sig1, sig2 = Script('int(').get_signatures() # int is defined as: `int(x[, base])` assert len(sig1.params) == 1 assert sig1.params[0].name == 'x' assert len(sig2.params) == 2 assert sig2.params[0].name == 'x' assert sig2.params[1].name == 'base' def test_pow_params(Script): # See Github #1357. for sig in Script('pow(').get_signatures(): param_names = [p.name for p in sig.params] assert param_names in (['base', 'exp'], ['base', 'exp', 'mod']) def test_param_name(Script): sigs = Script('open(something,').get_signatures() for sig in sigs: # All of the signatures (in Python the function is overloaded), # contain the same param names. assert sig.params[0].name in ['file', 'name'] assert sig.params[1].name == 'mode' assert sig.params[2].name == 'buffering' def test_builtins(Script): """ The self keyword should be visible even for builtins, if not instantiated. """ p = _params(Script, 'str.endswith(') assert p[0].name == 'self' assert p[1].name == 'suffix' p = _params(Script, 'str().endswith(') assert p[0].name == 'suffix' def test_signature_is_definition(Script): """ Through inheritance, a signature is a sub class of Name. Check if the attributes match. """ s = """class Spam(): pass\nSpam""" signature = Script(s + '(').get_signatures()[0] definition = Script(s + '(').infer(column=0)[0] signature.line == 1 signature.column == 6 # Now compare all the attributes that a Signature must also have. for attr_name in dir(definition): dont_scan = ['defined_names', 'parent', 'goto_assignments', 'infer', 'params', 'get_signatures', 'execute', 'goto', 'desc_with_module'] if attr_name.startswith('_') or attr_name in dont_scan: continue attribute = getattr(definition, attr_name) signature_attribute = getattr(signature, attr_name) if inspect.ismethod(attribute): assert attribute() == signature_attribute() else: assert attribute == signature_attribute def test_no_signature(Script): # str doesn't have a __call__ method assert Script('str()(').get_signatures() == [] s = dedent("""\ class X(): pass X()(""") assert Script(s).get_signatures() == [] assert len(Script(s).get_signatures(column=2)) == 1 assert Script('').get_signatures() == [] def test_dict_literal_in_incomplete_call(Script): source = """\ import json def foo(): json.loads( json.load.return_value = {'foo': [], 'bar': True} c = Foo() """ script = Script(dedent(source)) assert script.get_signatures(line=4, column=15) def test_completion_interference(Script): """Seems to cause problems, see also #396.""" cache.parser_cache.pop(None, None) assert Script('open(').get_signatures() # complete something usual, before doing the same get_signatures again. assert Script('from datetime import ').complete() assert Script('open(').get_signatures() def test_keyword_argument_index(Script, environment): def get(source, column=None): return Script(source).get_signatures(column=column)[0] assert get('sorted([], key=a').index == 1 assert get('sorted([], key=').index == 1 assert get('sorted([], no_key=a').index is None kw_func = 'def foo(a, b): pass\nfoo(b=3, a=4)' assert get(kw_func, column=len('foo(b')).index == 0 assert get(kw_func, column=len('foo(b=')).index == 1 assert get(kw_func, column=len('foo(b=3, a=')).index == 0 kw_func_simple = 'def foo(a, b): pass\nfoo(b=4)' assert get(kw_func_simple, column=len('foo(b')).index == 0 assert get(kw_func_simple, column=len('foo(b=')).index == 1 args_func = 'def foo(*kwargs): pass\n' assert get(args_func + 'foo(a').index == 0 assert get(args_func + 'foo(a, b').index == 0 kwargs_func = 'def foo(**kwargs): pass\n' assert get(kwargs_func + 'foo(a=2').index == 0 assert get(kwargs_func + 'foo(a=2, b=2').index == 0 both = 'def foo(*args, **kwargs): pass\n' assert get(both + 'foo(a=2').index == 1 assert get(both + 'foo(a=2, b=2').index == 1 assert get(both + 'foo(a=2, b=2)', column=len('foo(b=2, a=2')).index == 1 assert get(both + 'foo(a, b, c').index == 0 code1 = 'def f(u, /, v=3, *, abc, abd, xyz): pass' code2 = 'def g(u, /, v=3, *, abc, abd, xyz, **kwargs): pass' code3 = 'def h(u, /, v, *args, x=1, y): pass' code4 = 'def i(u, /, v, *args, x=1, y, **kwargs): pass' _calls = [ # No *args, **kwargs (code1, 'f(', 0), (code1, 'f(a', 0), (code1, 'f(a,', 1), (code1, 'f(a,b', 1), (code1, 'f(a,b,', 2), (code1, 'f(a,b,c', None), (code1, 'f(a,b,a', 2), (code1, 'f(a,b,a=', None), (code1, 'f(a,b,abc', 2), (code1, 'f(a,b,abc=(', 2), (code1, 'f(a,b,abc=(f,1,2,3', 2), (code1, 'f(a,b,abd', 3), (code1, 'f(a,b,x', 4), (code1, 'f(a,b,xy', 4), (code1, 'f(a,b,xyz=', 4), (code1, 'f(a,b,xy=', None), (code1, 'f(u=', (0, None)), (code1, 'f(v=', 1), # **kwargs (code2, 'g(a,b,a', 2), (code2, 'g(a,b,abc', 2), (code2, 'g(a,b,abd', 3), (code2, 'g(a,b,arr', 5), (code2, 'g(a,b,xy', 4), (code2, 'g(a,b,xyz=', 4), (code2, 'g(a,b,xy=', 5), (code2, 'g(a,b,abc=1,abd=4,', 4), (code2, 'g(a,b,abc=1,xyz=3,abd=4,', 5), (code2, 'g(a,b,abc=1,abd=4,lala', 5), (code2, 'g(a,b,abc=1,abd=4,lala=', 5), (code2, 'g(a,b,abc=1,abd=4,abd=', 5), (code2, 'g(a,b,kw', 5), (code2, 'g(a,b,kwargs=', 5), (code2, 'g(u=', (0, 5)), (code2, 'g(v=', 1), # *args (code3, 'h(a,b,c', 2), (code3, 'h(a,b,c,', 2), (code3, 'h(a,b,c,d', 2), (code3, 'h(a,b,c,d[', 2), (code3, 'h(a,b,c,(3,', 2), (code3, 'h(a,b,c,(3,)', 2), (code3, 'h(a,b,args=', None), (code3, 'h(u,v=', 1), (code3, 'h(u=', (0, None)), (code3, 'h(u,*xxx', 1), (code3, 'h(u,*xxx,*yyy', 1), (code3, 'h(u,*[]', 1), (code3, 'h(u,*', 1), (code3, 'h(u,*, *', 1), (code3, 'h(u,1,**', 3), (code3, 'h(u,**y', 1), (code3, 'h(u,x=2,**', 1), (code3, 'h(u,x=2,**y', 1), (code3, 'h(u,v=2,**y', 3), (code3, 'h(u,x=2,**vv', 1), # *args, **kwargs (code4, 'i(a,b,c,d', 2), (code4, 'i(a,b,c,d,e', 2), (code4, 'i(a,b,c,d,e=', 5), (code4, 'i(a,b,c,d,e=3', 5), (code4, 'i(a,b,c,d=,x=', 3), (code4, 'i(a,b,c,d=5,x=4', 3), (code4, 'i(a,b,c,d=5,x=4,y', 4), (code4, 'i(a,b,c,d=5,x=4,y=3,', 5), (code4, 'i(a,b,c,d=5,y=4,x=3,', 5), (code4, 'i(a,b,c,d=4,', 3), (code4, 'i(a,b,c,x=1,d=,', 4), # Error nodes (code4, 'i(1, [a,b', 1), (code4, 'i(1, [a,b=,', 2), (code4, 'i(1, [a?b,', 2), (code4, 'i(1, [a?b,*', 2), (code4, 'i(?b,*r,c', 1), (code4, 'i(?*', 0), (code4, 'i(?**', (0, 1)), # Random (code4, 'i(()', 0), (code4, 'i((),', 1), (code4, 'i([(),', 0), (code4, 'i([(,', 1), (code4, 'i(x,()', 1), ] @pytest.mark.parametrize('ending', ['', ')']) @pytest.mark.parametrize('code, call, expected_index', _calls) def test_signature_index(Script, environment, code, call, expected_index, ending): if isinstance(expected_index, tuple): expected_index = expected_index[environment.version_info > (3, 8)] if environment.version_info < (3, 8): code = code.replace('/,', '') sig, = Script(code + '\n' + call + ending).get_signatures(column=len(call)) index = sig.index assert expected_index == index @pytest.mark.parametrize('code', ['foo', 'instance.foo']) def test_arg_defaults(Script, environment, code): def foo(arg="bla", arg1=1): pass class Klass: def foo(self, arg="bla", arg1=1): pass instance = Klass() src = dedent(""" def foo2(arg="bla", arg1=1): pass class Klass2: def foo2(self, arg="bla", arg1=1): pass instance = Klass2() """) executed_locals = dict() exec(src, None, executed_locals) locals_ = locals() def iter_scripts(): yield Interpreter(code + '(', namespaces=[locals_]) yield Script(src + code + "2(") yield Interpreter(code + '2(', namespaces=[executed_locals]) for script in iter_scripts(): signatures = script.get_signatures() assert signatures[0].params[0].description in ('param arg="bla"', "param arg='bla'") assert signatures[0].params[1].description == 'param arg1=1' def test_bracket_start(Script): def bracket_start(src): signatures = Script(src).get_signatures() assert len(signatures) == 1 return signatures[0].bracket_start assert bracket_start('abs(') == (1, 3) def test_different_caller(Script): """ It's possible to not use names, but another function result or an array index and then get the signature of it. """ assert_signature(Script, '[abs][0](', 'abs', 0) assert_signature(Script, '[abs][0]()', 'abs', 0, column=len('[abs][0](')) assert_signature(Script, '(abs)(', 'abs', 0) assert_signature(Script, '(abs)()', 'abs', 0, column=len('(abs)(')) def test_in_function(Script): code = dedent('''\ class X(): @property def func(''') assert not Script(code).get_signatures() def test_lambda_params(Script): code = dedent('''\ my_lambda = lambda x: x+1 my_lambda(1)''') sig, = Script(code).get_signatures(column=11) assert sig.index == 0 assert sig.name == '' assert [p.name for p in sig.params] == ['x'] CLASS_CODE = dedent('''\ class X(): def __init__(self, foo, bar): self.foo = foo ''') def test_class_creation(Script): sig, = Script(CLASS_CODE + 'X(').get_signatures() assert sig.index == 0 assert sig.name == 'X' assert [p.name for p in sig.params] == ['foo', 'bar'] def test_call_init_on_class(Script): sig, = Script(CLASS_CODE + 'X.__init__(').get_signatures() assert [p.name for p in sig.params] == ['self', 'foo', 'bar'] def test_call_init_on_instance(Script): sig, = Script(CLASS_CODE + 'X().__init__(').get_signatures() assert [p.name for p in sig.params] == ['foo', 'bar'] def test_call_magic_method(Script): code = dedent('''\ class X(): def __call__(self, baz): pass ''') sig, = Script(code + 'X()(').get_signatures() assert sig.index == 0 assert sig.name == 'X' assert [p.name for p in sig.params] == ['baz'] sig, = Script(code + 'X.__call__(').get_signatures() assert [p.name for p in sig.params] == ['self', 'baz'] sig, = Script(code + 'X().__call__(').get_signatures() assert [p.name for p in sig.params] == ['baz'] @pytest.mark.parametrize('column', [6, 9]) def test_cursor_after_signature(Script, column): source = dedent(""" def foo(*args): pass foo() # _ """) script = Script(source) assert not script.get_signatures(4, column) @pytest.mark.parametrize( 'code, line, column, name, index', [ ('abs(()\ndef foo(): pass', 1, None, 'abs', 0), ('abs(chr() \ndef foo(): pass', 1, 10, 'abs', 0), ('abs(chr()\ndef foo(): pass', 1, None, 'abs', 0), ('abs(chr()\ndef foo(): pass', 1, 8, 'chr', 0), ('abs(chr()\ndef foo(): pass', 1, 7, 'abs', 0), ('abs(chr ( \nclass y: pass', 1, None, 'chr', 0), ('abs(chr ( \nclass y: pass', 1, 8, 'abs', 0), ('abs(chr ( \nclass y: pass', 1, 9, 'abs', 0), ('abs(chr ( \nclass y: pass', 1, 10, 'chr', 0), ('abs(foo.bar=3)', 1, 13, 'abs', 0), ] ) def test_base_signatures(Script, code, line, column, name, index): sig, = Script(code).get_signatures(line=line, column=column) assert sig.name == name assert sig.index == index ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/test_api/test_classes.py0000664000175000017500000004730200000000000020243 0ustar00davedave00000000000000""" Test all things related to the ``jedi.api_classes`` module. """ from textwrap import dedent from inspect import cleandoc import pytest import jedi from jedi import __doc__ as jedi_doc from jedi.inference.compiled import CompiledValueName from ..helpers import get_example_dir def test_is_keyword(Script): results = Script('str', path=None).infer(1, 1) assert len(results) == 1 and results[0].is_keyword is False def test_basedefinition_type(Script, get_names): def make_definitions(): """ Return a list of definitions for parametrized tests. :rtype: [jedi.api_classes.BaseName] """ source = dedent(""" import sys class C: pass x = C() def f(): pass def g(): yield h = lambda: None """) definitions = [] definitions += get_names(source) source += dedent(""" variable = sys or C or x or f or g or g() or h""") lines = source.splitlines() script = Script(source, path=None) definitions += script.infer(len(lines), len('variable')) script2 = Script(source, path=None) definitions += script2.get_references(4, len('class C')) source_param = "def f(a): return a" script_param = Script(source_param, path=None) definitions += script_param.goto(1, len(source_param)) return definitions for definition in make_definitions(): assert definition.type in ('module', 'class', 'instance', 'function', 'generator', 'statement', 'import', 'param') @pytest.mark.parametrize( ('src', 'expected_result', 'column'), [ # import one level ('import t', 'module', None), ('import ', 'module', None), ('import datetime; datetime', 'module', None), # from ('from datetime import timedelta', 'class', None), ('from datetime import timedelta; timedelta', 'class', None), ('from json import tool', 'module', None), ('from json import tool; tool', 'module', None), # import two levels ('import json.tool; json', 'module', None), ('import json.tool; json.tool', 'module', None), ('import json.tool; json.tool.main', 'function', None), ('import json.tool', 'module', None), ('import json.tool', 'module', 9), ] ) def test_basedefinition_type_import(Script, src, expected_result, column): types = {t.type for t in Script(src).complete(column=column)} assert types == {expected_result} def test_function_signature_in_doc(Script): defs = Script(""" def f(x, y=1, z='a'): pass f""").infer() doc = defs[0].docstring() assert "f(x, y=1, z='a')" in str(doc) def test_param_docstring(get_names): param = get_names("def test(parameter): pass", all_scopes=True)[1] assert param.name == 'parameter' assert param.docstring() == '' def test_class_signature(Script): defs = Script(""" class Foo: def __init__(self, x, y=1, z='a'): pass Foo""").infer() doc = defs[0].docstring() assert doc == "Foo(x, y=1, z='a')" def test_position_none_if_builtin(Script): gotos = Script('import sys; sys.path').goto() assert gotos[0].in_builtin_module() assert gotos[0].line is not None assert gotos[0].column is not None def test_completion_docstring(Script, jedi_path): """ Jedi should follow imports in certain conditions """ def docstr(src, result): c = Script(src, project=project).complete()[0] assert c.docstring(raw=True, fast=False) == cleandoc(result) project = jedi.Project('.', sys_path=[jedi_path]) c = Script('import jedi\njed', project=project).complete()[0] assert c.docstring(fast=False) == cleandoc(jedi_doc) docstr('import jedi\njedi.Scr', cleandoc(jedi.Script.__doc__)) docstr('abcd=3;abcd', '') docstr('"hello"\nabcd=3\nabcd', '') docstr( dedent(''' def x(): "hello" 0 x'''), 'hello' ) docstr( dedent(''' def x(): "hello";0 x'''), 'hello' ) # Shouldn't work with a tuple. docstr( dedent(''' def x(): "hello",0 x'''), '' ) # Should also not work if we rename something. docstr( dedent(''' def x(): "hello" y = x y'''), '' ) def test_completion_params(Script): c = Script('import string; string.capwords').complete()[0] assert [p.name for p in c.get_signatures()[0].params] == ['s', 'sep'] def test_functions_should_have_params(Script): for c in Script('bool.').complete(): if c.type == 'function': if c.name in ('denominator', 'numerator', 'imag', 'real', '__class__'): # Properties assert not c.get_signatures() else: assert c.get_signatures() def test_hashlib_params(Script): script = Script('from hashlib import sha256') c, = script.complete() sig, = c.get_signatures() assert [p.name for p in sig.params] == ['string'] def test_signature_params(Script): def check(defs): signature, = defs[0].get_signatures() assert len(signature.params) == 1 assert signature.params[0].name == 'bar' s = dedent(''' def foo(bar): pass foo''') check(Script(s).infer()) check(Script(s).goto()) check(Script(s + '\nbar=foo\nbar').goto()) def test_param_endings(Script): """ Params should be represented without the comma and whitespace they have around them. """ sig, = Script('def x(a, b=5, c=""): pass\n x(').get_signatures() assert [p.description for p in sig.params] == ['param a', 'param b=5', 'param c=""'] @pytest.mark.parametrize( 'code, index, name, is_definition', [ ('name', 0, 'name', False), ('a = f(x)', 0, 'a', True), ('a = f(x)', 1, 'f', False), ('a = f(x)', 2, 'x', False), ] ) def test_is_definition(get_names, code, index, name, is_definition): d = get_names( dedent(code), references=True, all_scopes=True, )[index] assert d.name == name assert d.is_definition() == is_definition @pytest.mark.parametrize( 'code, expected', ( ('import x as a', [False, True]), ('from x import y', [False, True]), ('from x.z import y', [False, False, True]), ) ) def test_is_definition_import(get_names, code, expected): ns = get_names(dedent(code), references=True, all_scopes=True) # Assure that names are definitely sorted. ns = sorted(ns, key=lambda name: (name.line, name.column)) assert [name.is_definition() for name in ns] == expected def test_parent(Script): def _parent(source, line=None, column=None): def_, = Script(dedent(source)).goto(line, column) return def_.parent() parent = _parent('foo=1\nfoo') assert parent.type == 'module' parent = _parent(''' def spam(): if 1: y=1 y''') assert parent.name == 'spam' assert parent.parent().type == 'module' def test_parent_on_function(Script): code = 'def spam():\n pass' def_, = Script(code).goto(line=1, column=len('def spam')) parent = def_.parent() assert parent.name == '__main__' assert parent.type == 'module' def test_parent_on_completion_and_else(Script): script = Script(dedent('''\ class Foo(): def bar(name): name Foo().bar''')) bar, = script.complete() parent = bar.parent() assert parent.name == 'Foo' assert parent.type == 'class' param, name, = [d for d in script.get_names(all_scopes=True, references=True) if d.name == 'name'] parent = name.parent() assert parent.name == 'bar' assert parent.type == 'function' parent = name.parent().parent() assert parent.name == 'Foo' assert parent.type == 'class' parent = param.parent() assert parent.name == 'bar' assert parent.type == 'function' parent = param.parent().parent() assert parent.name == 'Foo' assert parent.type == 'class' parent = Script('str.join').complete()[0].parent() assert parent.name == 'str' assert parent.type == 'class' def test_parent_on_closure(Script): script = Script(dedent('''\ class Foo(): def bar(name): def inner(): foo return inner''')) names = script.get_names(all_scopes=True, references=True) inner_func, inner_reference = filter(lambda d: d.name == 'inner', names) foo, = filter(lambda d: d.name == 'foo', names) assert foo.parent().name == 'inner' assert foo.parent().parent().name == 'bar' assert foo.parent().parent().parent().name == 'Foo' assert foo.parent().parent().parent().parent().name == '__main__' assert inner_func.parent().name == 'bar' assert inner_func.parent().parent().name == 'Foo' assert inner_reference.parent().name == 'bar' assert inner_reference.parent().parent().name == 'Foo' def test_parent_on_comprehension(Script): ns = Script('''\ def spam(): return [i for i in range(5)] ''').get_names(all_scopes=True) assert [name.name for name in ns] == ['spam', 'i'] assert ns[0].parent().name == '__main__' assert ns[0].parent().type == 'module' assert ns[1].parent().name == 'spam' assert ns[1].parent().type == 'function' def test_type(Script): for c in Script('a = [str()]; a[0].').complete(): if c.name == '__class__' and False: # TODO fix. assert c.type == 'class' else: assert c.type in ('function', 'statement') for c in Script('list.').complete(): assert c.type # Github issue #397, type should never raise an error. for c in Script('import os; os.path.').complete(): assert c.type def test_type_II(Script): """ GitHub Issue #833, `keyword`s are seen as `module`s """ for c in Script('f').complete(): if c.name == 'for': assert c.type == 'keyword' @pytest.mark.parametrize( 'added_code, expected_type, expected_infer_type', [ ('Foo().x', 'property', 'instance'), ('Foo.x', 'property', 'property'), ('Foo().y', 'function', 'function'), ('Foo.y', 'function', 'function'), ('Foo().z', 'function', 'function'), ('Foo.z', 'function', 'function'), ] ) def test_class_types(goto_or_help_or_infer, added_code, expected_type, expected_infer_type): code = dedent('''\ class Foo: @property def x(self): return 1 @staticmethod def y(self): ... @classmethod def z(self): ... ''') d, = goto_or_help_or_infer(code + added_code) if goto_or_help_or_infer.type == 'infer': assert d.type == expected_infer_type else: assert d.type == expected_type """ This tests the BaseName.goto function, not the jedi function. They are not really different in functionality, but really different as an implementation. """ def test_goto_repetition(get_names): defs = get_names('a = 1; a', references=True, definitions=False) # Repeat on the same variable. Shouldn't change once we're on a # definition. for _ in range(3): assert len(defs) == 1 ass = defs[0].goto() assert ass[0].description == 'a = 1' def test_goto_named_params(get_names): src = """\ def foo(a=1, bar=2): pass foo(bar=1) """ bar = get_names(dedent(src), references=True)[-1] param = bar.goto()[0] assert (param.line, param.column) == (1, 13) assert param.type == 'param' def test_class_call(get_names): src = 'from threading import Thread; Thread(group=1)' n = get_names(src, references=True)[-1] assert n.name == 'group' param_def = n.goto()[0] assert param_def.name == 'group' assert param_def.type == 'param' def test_parentheses(get_names): n = get_names('("").upper', references=True)[-1] assert n.goto()[0].name == 'upper' def test_import(get_names): nms = get_names('from json import load', references=True) assert nms[0].name == 'json' assert nms[0].type == 'module' n = nms[0].goto()[0] assert n.name == 'json' assert n.type == 'module' assert nms[1].name == 'load' assert nms[1].type == 'function' n = nms[1].goto()[0] assert n.name == 'load' assert n.type == 'function' nms = get_names('import os; os.path', references=True) assert nms[0].name == 'os' assert nms[0].type == 'module' n = nms[0].goto()[0] assert n.name == 'os' assert n.type == 'module' nms = nms[2].goto() assert nms assert all(n.type == 'module' for n in nms) assert 'posixpath' in {n.name for n in nms} nms = get_names('import os.path', references=True) n = nms[0].goto()[0] assert n.name == 'os' assert n.type == 'module' n = nms[1].goto()[0] # This is very special, normally the name doesn't change, but since # os.path is a sys.modules hack, it does. assert n.name in ('macpath', 'ntpath', 'posixpath', 'os2emxpath') assert n.type == 'module' def test_import_alias(get_names): nms = get_names('import json as foo', references=True) assert nms[0].name == 'json' assert nms[0].type == 'module' assert nms[0]._name.tree_name.parent.type == 'dotted_as_name' n = nms[0].goto()[0] assert n.name == 'json' assert n.type == 'module' assert n._name._value.tree_node.type == 'file_input' assert nms[1].name == 'foo' assert nms[1].type == 'module' assert nms[1]._name.tree_name.parent.type == 'dotted_as_name' ass = nms[1].goto() assert len(ass) == 1 assert ass[0].name == 'json' assert ass[0].type == 'module' assert ass[0]._name._value.tree_node.type == 'file_input' def test_added_equals_to_params(Script): def run(rest_source): source = dedent(""" def foo(bar, baz): pass """) results = Script(source + rest_source).complete() assert len(results) == 1 return results[0] assert run('foo(bar').name_with_symbols == 'bar=' assert run('foo(bar').complete == '=' assert run('foo(bar').get_completion_prefix_length() == 3 assert run('foo(bar, baz').complete == '=' assert run('foo(bar, baz').get_completion_prefix_length() == 3 assert run(' bar').name_with_symbols == 'bar' assert run(' bar').complete == '' assert run(' bar').get_completion_prefix_length() == 3 x = run('foo(bar=isins').name_with_symbols assert run('foo(bar=isins').get_completion_prefix_length() == 5 assert x == 'isinstance' def test_builtin_module_with_path(Script): """ This test simply tests if a module from /usr/lib/python3.8/lib-dynload/ has a path or not. It shouldn't have a module_path, because that is just confusing. """ semlock, = Script('from _multiprocessing import SemLock').infer() assert isinstance(semlock._name, CompiledValueName) assert semlock.module_path is None assert semlock.in_builtin_module() is True assert semlock.name == 'SemLock' assert semlock.line is None assert semlock.column is None @pytest.mark.parametrize( 'code, description', [ ('int', 'instance int'), ('str.index', 'instance int'), ('1', None), ] ) def test_execute(Script, code, description): definition, = Script(code).goto() definitions = definition.execute() if description is None: assert not definitions else: d, = definitions assert d.description == description @pytest.mark.parametrize('goto', [False, True, None]) @pytest.mark.parametrize( 'code, name, file_name', [ ('from pkg import Foo; Foo.foo', 'foo', '__init__.py'), ('from pkg import Foo; Foo().foo', 'foo', '__init__.py'), ('from pkg import Foo; Foo.bar', 'bar', 'module.py'), ('from pkg import Foo; Foo().bar', 'bar', 'module.py'), ]) def test_inheritance_module_path(Script, goto, code, name, file_name): base_path = get_example_dir('inheritance', 'pkg') whatever_path = base_path.joinpath('NOT_EXISTING.py') script = Script(code, path=whatever_path) if goto is None: func, = script.infer() else: func, = script.goto(follow_imports=goto) assert func.type == 'function' assert func.name == name assert func.module_path == base_path.joinpath(file_name) def test_definition_goto_follow_imports(Script): dumps = Script('from json import dumps\ndumps').get_names(references=True)[-1] assert dumps.description == 'dumps' no_follow, = dumps.goto() assert no_follow.description == 'def dumps' assert no_follow.line == 1 assert no_follow.column == 17 assert no_follow.module_name == '__main__' follow, = dumps.goto(follow_imports=True) assert follow.description == 'def dumps' assert follow.line != 1 assert follow.module_name == 'json' @pytest.mark.parametrize( 'code, expected', [ ('1', 'int'), ('x = None; x', 'None'), ('n: Optional[str]; n', 'Optional[str]'), ('n = None if xxxxx else ""; n', 'Optional[str]'), ('n = None if xxxxx else str(); n', 'Optional[str]'), ('n = None if xxxxx else str; n', 'Optional[Type[str]]'), ('class Foo: pass\nFoo', 'Type[Foo]'), ('class Foo: pass\nFoo()', 'Foo'), ('n: Type[List[int]]; n', 'Type[List[int]]'), ('n: Type[List]; n', 'Type[list]'), ('n: List; n', 'list'), ('n: List[int]; n', 'List[int]'), ('n: Iterable[int]; n', 'Iterable[int]'), ('n = [1]; n', 'List[int]'), ('n = [1, ""]; n', 'List[Union[int, str]]'), ('n = [1, str(), None]; n', 'List[Optional[Union[int, str]]]'), ('n = {1, str()}; n', 'Set[Union[int, str]]'), ('n = (1,); n', 'Tuple[int]'), ('n = {1: ""}; n', 'Dict[int, str]'), ('n = {1: "", 1.0: b""}; n', 'Dict[Union[float, int], Union[bytes, str]]'), ('n = next; n', 'Union[next(__i: Iterator[_T]) -> _T, ' 'next(__i: Iterator[_T], default: _VT) -> Union[_T, _VT]]'), ('abs', 'abs(__x: SupportsAbs[_T]) -> _T'), ('def foo(x, y): return x if xxxx else y\nfoo(str(), 1)\nfoo', 'foo(x: str, y: int) -> Union[int, str]'), ('def foo(x, y = None): return x if xxxx else y\nfoo(str(), 1)\nfoo', 'foo(x: str, y: int=None) -> Union[int, str]'), ] ) def test_get_type_hint(Script, code, expected): code = 'from typing import *\n' + code d, = Script(code).goto() assert d.get_type_hint() == expected def test_pseudotreenameclass_type(Script): assert Script('from typing import Any\n').get_names()[0].type == 'class' cls_code = '''\ class AClass: """my class""" @staticmethod def hello(): func_var = 1 return func_var ''' @pytest.mark.parametrize( 'code, pos, start, end', [ ('def a_func():\n return "bar"\n', (1, 4), (1, 0), (2, 16)), ('var1 = 12', (1, 0), (1, 0), (1, 9)), ('var1 + 1', (1, 0), (1, 0), (1, 4)), ('class AClass: pass', (1, 6), (1, 0), (1, 18)), ('class AClass: pass\n', (1, 6), (1, 0), (1, 18)), (cls_code, (1, 6), (1, 0), (6, 23)), (cls_code, (4, 8), (4, 4), (6, 23)), (cls_code, (5, 8), (5, 8), (5, 20)), ] ) def test_definition_start_end_position(Script, code, pos, start, end): '''Tests for definition_start_position and definition_end_position''' name = next( n for n in Script(code=code).get_names(all_scopes=True, references=True) if n._name.tree_name.start_pos <= pos <= n._name.tree_name.end_pos ) assert name.get_definition_start_position() == start assert name.get_definition_end_position() == end ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/test_api/test_completion.py0000664000175000017500000003655400000000000020766 0ustar00davedave00000000000000from os.path import join, sep as s, dirname, expanduser import os from textwrap import dedent from itertools import count from pathlib import Path import pytest from ..helpers import root_dir from jedi.api.helpers import _start_match, _fuzzy_match from jedi.inference.imports import _load_python_module from jedi.file_io import KnownContentFileIO from jedi.inference.base_value import ValueSet def test_in_whitespace(Script): code = dedent(''' def x(): pass''') assert len(Script(code).complete(column=2)) > 20 def test_empty_init(Script): """This was actually an issue.""" code = dedent('''\ class X(object): pass X(''') assert not Script(code).complete() def test_in_empty_space(Script): code = dedent('''\ class X(object): def __init__(self): hello ''') comps = Script(code).complete(3, 7) self, = [c for c in comps if c.name == 'self'] assert self.name == 'self' def_, = self.infer() assert def_.name == 'X' def test_indent_value(Script): """ If an INDENT is the next supposed token, we should still be able to complete. """ code = 'if 1:\nisinstanc' comp, = Script(code).complete() assert comp.name == 'isinstance' def test_keyword_value(Script): def get_names(*args, **kwargs): return [d.name for d in Script(*args, **kwargs).complete()] names = get_names('if 1:\n pass\n') assert 'if' in names assert 'elif' in names def test_os_nowait(Script): """ github issue #45 """ s = Script("import os; os.P_").complete() assert 'P_NOWAIT' in [i.name for i in s] def test_points_in_completion(Script): """At some point, points were inserted into the completions, this caused problems, sometimes. """ c = Script("if IndentationErr").complete() assert c[0].name == 'IndentationError' assert c[0].complete == 'or' def test_loading_unicode_files_with_bad_global_charset(Script, monkeypatch, tmpdir): dirname = str(tmpdir.mkdir('jedi-test')) filename1 = join(dirname, 'test1.py') filename2 = join(dirname, 'test2.py') data = "# coding: latin-1\nfoo = 'm\xf6p'\n".encode("latin-1") with open(filename1, "wb") as f: f.write(data) s = Script("from test1 import foo\nfoo.", path=filename2) s.complete(line=2, column=4) def test_complete_expanduser(Script): possibilities = os.scandir(expanduser('~')) non_dots = [p for p in possibilities if not p.name.startswith('.') and len(p.name) > 1] item = non_dots[0] line = "'~%s%s'" % (os.sep, item.name) s = Script(line) expected_name = item.name if item.is_dir(): expected_name += os.path.sep assert expected_name in [c.name for c in s.complete(column=len(line)-1)] def test_fake_subnodes(Script): """ Test the number of subnodes of a fake object. There was a bug where the number of child nodes would grow on every call to :func:``jedi.inference.compiled.fake.get_faked``. See Github PR#649 and isseu #591. """ def get_str_completion(values): for c in values: if c.name == 'str': return c limit = None for i in range(2): completions = Script('').complete() c = get_str_completion(completions) str_value, = c._name.infer() n = len(str_value.tree_node.children[-1].children) if i == 0: limit = n else: assert n == limit def test_generator(Script): # Did have some problems with the usage of generator completions this # way. s = "def abc():\n" \ " yield 1\n" \ "abc()." assert Script(s).complete() def test_in_comment(Script): assert Script(" # Comment").complete() # TODO this is a bit ugly, that the behaviors in comments are different. assert not Script("max_attr_value = int(2) # Cast to int for spe").complete() def test_in_comment_before_string(Script): assert not Script(" # Foo\n'asdf'").complete(line=1) def test_async(Script, environment): code = dedent(''' foo = 3 async def x(): hey = 3 ho''') comps = Script(code).complete(column=4) names = [c.name for c in comps] assert 'foo' in names assert 'hey' in names def test_with_stmt_error_recovery(Script): assert Script('with open('') as foo: foo.\na').complete(line=1) def test_function_param_usage(Script): c, = Script('def func(foo_value):\n str(foo_valu').complete() assert c.complete == 'e' assert c.name == 'foo_value' c1, c2 = Script('def func(foo_value):\n func(foo_valu').complete() assert c1.complete == 'e' assert c1.name == 'foo_value' assert c2.complete == 'e=' assert c2.name == 'foo_value=' @pytest.mark.parametrize( 'code, has_keywords', ( ('', True), ('x;', True), ('1', False), ('1 ', True), ('1\t', True), ('1\n', True), ('1\\\n', True), ) ) def test_keyword_completion(Script, code, has_keywords): assert has_keywords == any(x.is_keyword for x in Script(code).complete()) f1 = join(root_dir, 'example.py') f2 = join(root_dir, 'test', 'example.py') os_path = 'from os.path import *\n' # os.path.sep escaped se = s * 2 if s == '\\' else s current_dirname = os.path.basename(dirname(dirname(dirname(__file__)))) @pytest.mark.parametrize( 'file, code, column, expected', [ # General tests / relative paths (None, '"comp', None, []), # No files like comp (None, '"test', None, [s]), (None, '"test', 4, ['t' + s]), ('example.py', '"test%scomp' % s, None, ['letion' + s]), ('example.py', 'r"comp"', None, []), ('example.py', 'r"tes"', None, []), ('example.py', '1 + r"tes"', None, []), ('example.py', 'r"tes"', 5, ['t' + s]), ('example.py', 'r" tes"', 6, []), ('test%sexample.py' % se, 'r"tes"', 5, ['t' + s]), ('test%sexample.py' % se, 'r"test%scomp"' % s, 5, ['t' + s]), ('test%sexample.py' % se, 'r"test%scomp"' % s, 11, ['letion' + s]), ('test%sexample.py' % se, '"%s"' % join('test', 'completion', 'basi'), 21, ['c.py']), ('example.py', 'rb"' + join('..', current_dirname, 'tes'), None, ['t' + s]), # Absolute paths (None, f'"{root_dir.joinpath("test", "test_ca")}', None, ['che.py"']), (None, f'"{root_dir.joinpath("test", "test_ca")}"', len(str(root_dir)) + 14, ['che.py']), # Longer quotes ('example.py', 'r"""test', None, [s]), ('example.py', 'r"""\ntest', None, []), ('example.py', 'u"""tes\n', (1, 7), ['t' + s]), ('example.py', '"""test%stest_cache.p"""' % s, 20, ['y']), ('example.py', '"""test%stest_cache.p"""' % s, 19, ['py"""']), # Adding ('example.py', '"test" + "%stest_cac' % se, None, ['he.py"']), ('example.py', '"test" + "%s" + "test_cac' % se, None, ['he.py"']), ('example.py', 'x = 1 + "test', None, []), ('example.py', 'x = f("te" + "st)', 16, [s]), ('example.py', 'x = f("te" + "st', 16, [s]), ('example.py', 'x = f("te" + "st"', 16, [s]), ('example.py', 'x = f("te" + "st")', 16, [s]), ('example.py', 'x = f("t" + "est")', 16, [s]), ('example.py', 'x = f(b"t" + "est")', 17, []), ('example.py', '"test" + "', None, [s]), # __file__ (f1, os_path + 'dirname(__file__) + "%stest' % s, None, [s]), (f2, os_path + 'dirname(__file__) + "%stest_ca' % se, None, ['che.py"']), (f2, os_path + 'dirname(abspath(__file__)) + sep + "test_ca', None, ['che.py"']), (f2, os_path + 'join(dirname(__file__), "completion") + sep + "basi', None, ['c.py"']), (f2, os_path + 'join("test", "completion") + sep + "basi', None, ['c.py"']), # inside join (f2, os_path + 'join(dirname(__file__), "completion", "basi', None, ['c.py"']), (f2, os_path + 'join(dirname(__file__), "completion", "basi)', 43, ['c.py"']), (f2, os_path + 'join(dirname(__file__), "completion", "basi")', 43, ['c.py']), (f2, os_path + 'join(dirname(__file__), "completion", "basi)', 35, ['']), (f2, os_path + 'join(dirname(__file__), "completion", "basi)', 33, ['on"']), (f2, os_path + 'join(dirname(__file__), "completion", "basi")', 33, ['on"']), # join with one argument. join will not get inferred and the result is # that directories and in a slash. This is unfortunate, but doesn't # really matter. (f2, os_path + 'join("tes', 9, ['t"']), (f2, os_path + 'join(\'tes)', 9, ["t'"]), (f2, os_path + 'join(r"tes"', 10, ['t']), (f2, os_path + 'join("""tes""")', 11, ['t']), # Almost like join but not really (f2, os_path + 'join["tes', 9, ['t' + s]), (f2, os_path + 'join["tes"', 9, ['t' + s]), (f2, os_path + 'join["tes"]', 9, ['t' + s]), (f2, os_path + 'join[dirname(__file__), "completi', 33, []), (f2, os_path + 'join[dirname(__file__), "completi"', 33, []), (f2, os_path + 'join[dirname(__file__), "completi"]', 33, []), # With full paths (f2, 'import os\nos.path.join(os.path.dirname(__file__), "completi', 49, ['on"']), (f2, 'import os\nos.path.join(os.path.dirname(__file__), "completi"', 49, ['on']), (f2, 'import os\nos.path.join(os.path.dirname(__file__), "completi")', 49, ['on']), # With alias (f2, 'import os.path as p as p\np.join(p.dirname(__file__), "completi', None, ['on"']), (f2, 'from os.path import dirname, join as j\nj(dirname(__file__), "completi', None, ['on"']), # Trying to break it (f2, os_path + 'join(["tes', 10, ['t' + s]), (f2, os_path + 'join(["tes"]', 10, ['t' + s]), (f2, os_path + 'join(["tes"])', 10, ['t' + s]), (f2, os_path + 'join("test", "test_cac" + x,', 22, ['he.py']), # GH #1528 (f2, "'a' 'b'", 4, Ellipsis), ] ) def test_file_path_completions(Script, file, code, column, expected): line = None if isinstance(column, tuple): line, column = column comps = Script(code, path=file).complete(line=line, column=column) if expected is Ellipsis: assert len(comps) > 100 # This is basically global completions. else: assert [c.complete for c in comps] == expected def test_file_path_should_have_completions(Script): assert Script('r"').complete() # See GH #1503 _dict_keys_completion_tests = [ ('ints[', 5, ['1', '50', Ellipsis]), ('ints[]', 5, ['1', '50', Ellipsis]), ('ints[1]', 5, ['1', '50', Ellipsis]), ('ints[1]', 6, ['']), ('ints[1', 5, ['1', '50', Ellipsis]), ('ints[1', 6, ['']), ('ints[5]', 5, ['1', '50', Ellipsis]), ('ints[5]', 6, ['0']), ('ints[50', 5, ['1', '50', Ellipsis]), ('ints[5', 6, ['0']), ('ints[ 5', None, ['0']), ('ints [ 5', None, ['0']), ('ints[50', 6, ['0']), ('ints[50', 7, ['']), ('strs[', 5, ["'asdf'", "'fbar'", "'foo'", Ellipsis]), ('strs[]', 5, ["'asdf'", "'fbar'", "'foo'", Ellipsis]), ("strs['", 6, ["asdf'", "fbar'", "foo'"]), ("strs[']", 6, ["asdf'", "fbar'", "foo'"]), ('strs["]', 6, ['asdf"', 'fbar"', 'foo"']), ('strs["""]', 6, ['asdf', 'fbar', 'foo']), ('strs["""]', 8, ['asdf"""', 'fbar"""', 'foo"""']), ('strs[b"]', 8, []), ('strs[r"asd', 10, ['f"']), ('strs[r"asd"', 10, ['f']), ('strs[R"asd', 10, ['f"']), ('strs[ R"asd', None, ['f"']), ('strs[\tR"asd', None, ['f"']), ('strs[\nR"asd', None, ['f"']), ('strs[f"asd', 10, []), ('strs[br"""asd', 13, ['f"""']), ('strs[br"""asd"""', 13, ['f']), ('strs[ \t"""asd"""', 13, ['f']), ('strs["f', 7, ['bar"', 'oo"']), ('strs["f"', 7, ['bar', 'oo']), ('strs["f]', 7, ['bar"', 'oo"']), ('strs["f"]', 7, ['bar', 'oo']), ('mixed[', 6, [r"'a\\sdf'", '1', '1.1', "b'foo'", Ellipsis]), ('mixed[1', 7, ['', '.1']), ('mixed[Non', 9, ['e']), ('casted["f', 9, ['3"', 'bar"', 'oo"']), ('casted["f"', 9, ['3', 'bar', 'oo']), ('casted["f3', 10, ['"']), ('casted["f3"', 10, ['']), ('casted_mod["f', 13, ['3"', 'bar"', 'oo"', 'ull"', 'uuu"']), ('keywords["', None, ['a"']), ('keywords[Non', None, ['e']), ('keywords[Fa', None, ['lse']), ('keywords[Tr', None, ['ue']), ('keywords[str', None, ['', 's']), ] @pytest.mark.parametrize( 'added_code, column, expected', _dict_keys_completion_tests ) def test_dict_keys_completions(Script, added_code, column, expected): code = dedent(r''' ints = {1: ''} ints[50] = 3.0 strs = {'asdf': 1, u"""foo""": 2, r'fbar': 3} mixed = {1: 2, 1.10: 4, None: 6, r'a\sdf': 8, b'foo': 9} casted = dict(strs, f3=4, r'\\xyz') casted_mod = dict(casted) casted_mod["fuuu"] = 8 casted_mod["full"] = 8 keywords = {None: 1, False: 2, "a": 3} ''') comps = Script(code + added_code).complete(column=column) if Ellipsis in expected: # This means that global completions are part of this, so filter all of # that out. comps = [c for c in comps if not c._name.is_value_name and not c.is_keyword] expected = [e for e in expected if e is not Ellipsis] assert [c.complete for c in comps] == expected def test_dict_keys_in_weird_case(Script): assert Script('a[\n# foo\nx]').complete(line=2, column=0) def test_start_match(): assert _start_match('Condition', 'C') def test_fuzzy_match(): assert _fuzzy_match('Condition', 'i') assert not _fuzzy_match('Condition', 'p') assert _fuzzy_match('Condition', 'ii') assert not _fuzzy_match('Condition', 'Ciito') assert _fuzzy_match('Condition', 'Cdiio') def test_ellipsis_completion(Script): assert Script('...').complete() == [] @pytest.fixture def module_injector(): counter = count() def module_injector(inference_state, names, code): assert isinstance(names, tuple) file_io = KnownContentFileIO( Path('foo/bar/module-injector-%s.py' % next(counter)).absolute(), code ) v = _load_python_module(inference_state, file_io, names) inference_state.module_cache.add(names, ValueSet([v])) return module_injector def test_completion_cache(Script, module_injector): """ For some modules like numpy, tensorflow or pandas we cache docstrings and type to avoid them slowing us down, because they are huge. """ script = Script('import numpy; numpy.foo') module_injector(script._inference_state, ('numpy',), 'def foo(a): "doc"') c, = script.complete() assert c.name == 'foo' assert c.type == 'function' assert c.docstring() == 'foo(a)\n\ndoc' code = dedent('''\ class foo: 'doc2' def __init__(self): pass ''') script = Script('import numpy; numpy.foo') module_injector(script._inference_state, ('numpy',), code) # The outpus should still be the same c, = script.complete() assert c.name == 'foo' assert c.type == 'function' assert c.docstring() == 'foo(a)\n\ndoc' cls, = c.infer() assert cls.type == 'class' assert cls.docstring() == 'foo()\n\ndoc2' @pytest.mark.parametrize('module', ['typing', 'os']) def test_module_completions(Script, module): for c in Script('import {module}; {module}.'.format(module=module)).complete(): # Just make sure that there are no errors c.type c.docstring() def test_whitespace_at_end_after_dot(Script): assert 'strip' in [c.name for c in Script('str. ').complete()] ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/test_api/test_context.py0000664000175000017500000000635300000000000020273 0ustar00davedave00000000000000import pytest def _iter_hierarchy(context): def iter(context): while context is not None: yield context context = context.parent() return reversed(list(iter(context))) func_code = '''\ def func1(x, y): pass def func2(): what ? i = 3 def func3(): 1''' cls_code = '''\ class Foo: def x(): def y(): pass ''' cls_nested = '''\ class C: class D: def f(): pass ''' lambda_ = '''\ def x(): (lambda x: lambda: y ) ''' comprehension = ''' def f(x): [x for x in x ]''' with_brackets = '''\ def x(): [ ] ''' @pytest.mark.parametrize( 'code, line, column, full_name, expected_parents', [ ('', None, None, 'myfile', []), (' ', None, 0, 'myfile', []), (func_code, 1, 0, 'myfile', []), (func_code, 1, None, 'myfile.func1', ['func1']), (func_code, 1, 1, 'myfile.func1', ['func1']), (func_code, 1, 4, 'myfile.func1', ['func1']), (func_code, 1, 10, 'myfile.func1', ['func1']), (func_code, 3, 0, 'myfile', []), (func_code, 5, None, 'myfile.func2', ['func2']), (func_code, 6, None, 'myfile', []), (func_code, 7, None, 'myfile', []), (func_code, 9, None, 'myfile.func3', ['func3']), (cls_code, None, None, 'myfile', []), (cls_code + ' ', None, None, 'myfile.Foo', ['Foo']), (cls_code + ' ' * 3, None, None, 'myfile.Foo', ['Foo']), (cls_code + ' ' * 4, None, None, 'myfile.Foo', ['Foo']), (cls_code + ' ' * 5, None, None, 'myfile.Foo.x', ['Foo', 'x']), (cls_code + ' ' * 8, None, None, 'myfile.Foo.x', ['Foo', 'x']), (cls_code + ' ' * 12, None, None, None, ['Foo', 'x', 'y']), (cls_code, 4, 0, 'myfile', []), (cls_code, 4, 3, 'myfile.Foo', ['Foo']), (cls_code, 4, 4, 'myfile.Foo', ['Foo']), (cls_code, 4, 5, 'myfile.Foo.x', ['Foo', 'x']), (cls_code, 4, 8, 'myfile.Foo.x', ['Foo', 'x']), (cls_code, 4, 12, None, ['Foo', 'x', 'y']), (cls_code, 1, 1, 'myfile.Foo', ['Foo']), (cls_nested, 4, None, 'myfile.C.D.f', ['C', 'D', 'f']), (cls_nested, 4, 3, 'myfile.C', ['C']), (lambda_, 2, 9, 'myfile.x', ['x']), # the lambda keyword (lambda_, 2, 13, 'myfile.x', ['x']), # the lambda param (lambda_, 3, 0, 'myfile', []), # Within brackets, but they are ignored. (lambda_, 3, 8, 'myfile.x', ['x']), (lambda_, 3, None, 'myfile.x', ['x']), (comprehension, 2, None, 'myfile.f', ['f']), (comprehension, 3, None, 'myfile.f', ['f']), (comprehension, 4, None, 'myfile.f', ['f']), (comprehension, 5, None, 'myfile.f', ['f']), (comprehension, 6, None, 'myfile.f', ['f']), # Brackets are just ignored. (with_brackets, 3, None, 'myfile', []), (with_brackets, 4, 4, 'myfile.x', ['x']), (with_brackets, 4, 5, 'myfile.x', ['x']), ] ) def test_context(Script, code, line, column, full_name, expected_parents): context = Script(code, path='/foo/myfile.py').get_context(line, column) assert context.full_name == full_name parent_names = [d.name for d in _iter_hierarchy(context)] assert parent_names == ['myfile'] + expected_parents ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/test_api/test_documentation.py0000664000175000017500000000677500000000000021470 0ustar00davedave00000000000000from textwrap import dedent import pytest def test_error_leaf_keyword_doc(Script): d, = Script("or").help(1, 1) assert len(d.docstring()) > 100 assert d.name == 'or' def test_error_leaf_operator_doc(Script): d, = Script("==").help() assert len(d.docstring()) > 100 assert d.name == '==' def test_keyword_completion(Script): k = Script("fro").complete()[0] imp_start = 'The "import' assert k.docstring(raw=True).startswith(imp_start) assert k.docstring().startswith(imp_start) def test_import_keyword(Script): d, = Script("import x").help(column=0) assert d.docstring().startswith('The "import" statement') # unrelated to #44 def test_import_keyword_after_newline(Script): d, = Script("import x\nimport y").help(line=2, column=0) assert d.docstring().startswith('The "import" statement') def test_import_keyword_with_gotos(goto_or_infer): assert not goto_or_infer("import x", column=0) def test_operator_doc(Script): d, = Script("a == b").help(1, 3) assert len(d.docstring()) > 100 @pytest.mark.parametrize( 'code, help_part', [ ('str', 'Create a new string object'), ('str.strip', 'Return a copy of the string'), ] ) def test_stdlib_doc(Script, code, help_part): h, = Script(code).help() assert help_part in h.docstring(raw=True) def test_lambda(Script): d, = Script('lambda x: x').help(column=0) assert d.type == 'keyword' assert d.docstring().startswith('Lambdas\n*******') @pytest.mark.parametrize( 'code, kwargs', [ ('?', {}), ('""', {}), ('"', {}), ] ) def test_help_no_returns(Script, code, kwargs): assert not Script(code).help(**kwargs) @pytest.mark.parametrize( 'to_execute, expected_doc', [ ('X.x', 'Yeah '), ('X().x', 'Yeah '), ('X.y', 'f g '), ('X.z', ''), ] ) def test_attribute_docstrings(goto_or_help, expected_doc, to_execute): code = dedent('''\ class X: "ha" x = 3 """ Yeah """ y = 5 "f g " z = lambda x: 1 ''') d, = goto_or_help(code + to_execute) assert d.docstring() == expected_doc def test_version_info(Script): """ Version info is a bit special, because it needs to be fast for some ifs, so it's a special object that we have to check. """ s = Script(dedent("""\ import sys sys.version_info""")) c, = s.complete() assert c.docstring() == 'sys.version_info\n\nVersion information as a named tuple.' def test_builtin_docstring(goto_or_help_or_infer): d, = goto_or_help_or_infer('open') doc = d.docstring() assert doc.startswith('open(file: ') assert 'Open file' in doc def test_docstring_decorator(goto_or_help_or_infer): code = dedent(''' import types def dec(func): return types.FunctionType() @dec def func(a, b): "hello" return func''') d, = goto_or_help_or_infer(code) doc = d.docstring() assert doc == 'FunctionType(*args: Any, **kwargs: Any) -> Any\n\nhello' @pytest.mark.parametrize('code', ['', '\n', ' ']) def test_empty(Script, code): assert not Script(code).help(1, 0) @pytest.mark.parametrize('code', ['f()', '(bar or baz)', 'f[3]']) def test_no_help_for_operator(Script, code): assert not Script(code).help() @pytest.mark.parametrize('code', ['()', '(1,)', '[]', '[1]', 'f[]']) def test_help_for_operator(Script, code): assert Script(code).help() ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/test_api/test_environment.py0000664000175000017500000001214300000000000021145 0ustar00davedave00000000000000import os import sys import pytest import jedi from jedi.api.environment import get_default_environment, find_virtualenvs, \ InvalidPythonEnvironment, find_system_environments, \ get_system_environment, create_environment, InterpreterEnvironment, \ get_cached_default_environment def test_sys_path(): assert get_default_environment().get_sys_path() def test_find_system_environments(): envs = list(find_system_environments()) assert len(envs) for env in envs: assert env.version_info assert env.get_sys_path() parser_version = env.get_grammar().version_info assert parser_version[:2] == env.version_info[:2] @pytest.mark.parametrize( 'version', ['3.6', '3.7', '3.8', '3.9'] ) def test_versions(version): try: env = get_system_environment(version) except InvalidPythonEnvironment: if int(version.replace('.', '')) == str(sys.version_info[0]) + str(sys.version_info[1]): # At least the current version has to work raise pytest.skip() assert version == str(env.version_info[0]) + '.' + str(env.version_info[1]) assert env.get_sys_path() def test_load_module(inference_state): access_path = inference_state.compiled_subprocess.load_module( dotted_name='math', sys_path=inference_state.get_sys_path() ) name, access_handle = access_path.accesses[0] assert access_handle.py__bool__() is True assert access_handle.get_api_type() == 'module' with pytest.raises(AttributeError): access_handle.py__mro__() def test_error_in_environment(inference_state, Script, environment): if isinstance(environment, InterpreterEnvironment): pytest.skip("We don't catch these errors at the moment.") # Provoke an error to show how Jedi can recover from it. with pytest.raises(jedi.InternalError): inference_state.compiled_subprocess._test_raise_error(KeyboardInterrupt) # The second time it should raise an InternalError again. with pytest.raises(jedi.InternalError): inference_state.compiled_subprocess._test_raise_error(KeyboardInterrupt) # Jedi should still work. def_, = Script('str').infer() assert def_.name == 'str' def test_stdout_in_subprocess(inference_state, Script): inference_state.compiled_subprocess._test_print(stdout='.') Script('1').infer() def test_killed_subprocess(inference_state, Script, environment): if isinstance(environment, InterpreterEnvironment): pytest.skip("We cannot kill our own process") # Just kill the subprocess. inference_state.compiled_subprocess._compiled_subprocess._get_process().kill() # Since the process was terminated (and nobody knows about it) the first # Jedi call fails. with pytest.raises(jedi.InternalError): Script('str').infer() def_, = Script('str').infer() # Jedi should now work again. assert def_.name == 'str' def test_not_existing_virtualenv(monkeypatch): """Should not match the path that was given""" path = '/foo/bar/jedi_baz' monkeypatch.setenv('VIRTUAL_ENV', path) assert get_default_environment().executable != path def test_working_venv(venv_path, monkeypatch): monkeypatch.setenv('VIRTUAL_ENV', venv_path) assert get_default_environment().path == venv_path def test_scanning_venvs(venv_path): parent_dir = os.path.dirname(venv_path) assert any(venv.path == venv_path for venv in find_virtualenvs([parent_dir])) def test_create_environment_venv_path(venv_path): environment = create_environment(venv_path) assert environment.path == venv_path def test_create_environment_executable(): environment = create_environment(sys.executable) assert environment.executable == sys.executable def test_get_default_environment_from_env_does_not_use_safe(tmpdir, monkeypatch): fake_python = os.path.join(str(tmpdir), 'fake_python') with open(fake_python, 'w', newline='') as f: f.write('') def _get_subprocess(self): if self._start_executable != fake_python: raise RuntimeError('Should not get called!') self.executable = fake_python self.path = 'fake' monkeypatch.setattr('jedi.api.environment.Environment._get_subprocess', _get_subprocess) monkeypatch.setenv('VIRTUAL_ENV', fake_python) env = get_default_environment() assert env.path == 'fake' @pytest.mark.parametrize('virtualenv', ['', 'fufuuuuu', sys.prefix]) def test_get_default_environment_when_embedded(monkeypatch, virtualenv): # When using Python embedded, sometimes the executable is not a Python # executable. executable_name = 'RANDOM_EXE' monkeypatch.setattr(sys, 'executable', executable_name) monkeypatch.setenv('VIRTUAL_ENV', virtualenv) env = get_default_environment() assert env.executable != executable_name def test_changing_venv(venv_path, monkeypatch): monkeypatch.setitem(os.environ, 'VIRTUAL_ENV', venv_path) get_cached_default_environment() monkeypatch.setitem(os.environ, 'VIRTUAL_ENV', sys.executable) assert get_cached_default_environment().executable == sys.executable ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/test_api/test_full_name.py0000664000175000017500000000675200000000000020554 0ustar00davedave00000000000000""" Tests for :attr:`.BaseName.full_name`. There are three kinds of test: #. Test classes derived from :class:`MixinTestFullName`. Child class defines :attr:`.operation` to alter how the api definition instance is created. #. :class:`TestFullDefinedName` is to test combination of ``obj.full_name`` and ``jedi.defined_names``. #. Misc single-function tests. """ import textwrap from unittest import TestCase import pytest import jedi class MixinTestFullName(object): operation = None @pytest.fixture(autouse=True) def init(self, Script, environment): self.Script = Script self.environment = environment def check(self, source, desired): script = self.Script(textwrap.dedent(source)) definitions = getattr(script, self.operation)() for d in definitions: self.assertEqual(d.full_name, desired) def test_os_path_join(self): self.check('import os; os.path.join', 'os.path.join') def test_builtin(self): self.check('TypeError', 'builtins.TypeError') class TestFullNameWithGotoDefinitions(MixinTestFullName, TestCase): operation = 'infer' def test_tuple_mapping(self): self.check(""" import re any_re = re.compile('.*') any_re""", 'typing.Pattern') def test_from_import(self): self.check('from os import path', 'os.path') class TestFullNameWithCompletions(MixinTestFullName, TestCase): operation = 'complete' class TestFullDefinedName(TestCase): """ Test combination of ``obj.full_name`` and ``jedi.Script.get_names``. """ @pytest.fixture(autouse=True) def init(self, environment): self.environment = environment def check(self, source, desired): script = jedi.Script(textwrap.dedent(source), environment=self.environment) definitions = script.get_names() full_names = [d.full_name for d in definitions] self.assertEqual(full_names, desired) def test_local_names(self): self.check(""" def f(): pass class C: pass """, ['__main__.f', '__main__.C']) def test_imports(self): self.check(""" import os from os import path from os.path import join from os import path as opath """, ['os', 'os.path', 'os.path.join', 'os.path']) def test_sub_module(Script, jedi_path): """ ``full_name needs to check sys.path to actually find it's real path module path. """ sys_path = [jedi_path] project = jedi.Project('.', sys_path=sys_path) defs = Script('from jedi.api import classes; classes', project=project).infer() assert [d.full_name for d in defs] == ['jedi.api.classes'] defs = Script('import jedi.api; jedi.api', project=project).infer() assert [d.full_name for d in defs] == ['jedi.api'] def test_os_path(Script): d, = Script('from os.path import join').complete() assert d.full_name == 'os.path.join' d, = Script('import os.p').complete() assert d.full_name == 'os.path' def test_os_issues(Script): """Issue #873""" # nt is not found, because it's deleted assert [c.name for c in Script('import os\nos.nt''').complete()] == [] def test_param_name(Script): name, = Script('class X:\n def foo(bar): bar''').goto() assert name.type == 'param' assert name.full_name is None def test_variable_in_func(Script): names = Script('def f(): x = 3').get_names(all_scopes=True) x = names[-1] assert x.name == 'x' assert x.full_name == '__main__.f.x' ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/test_api/test_interpreter.py0000664000175000017500000006226500000000000021156 0ustar00davedave00000000000000""" Tests of ``jedi.api.Interpreter``. """ import sys import warnings import typing import pytest import jedi import jedi.settings from jedi.inference.compiled import mixed from importlib import import_module class _GlobalNameSpace: class SideEffectContainer: pass def get_completion(source, namespace): i = jedi.Interpreter(source, [namespace]) completions = i.complete() assert len(completions) == 1 return completions[0] def test_builtin_details(): import keyword class EmptyClass: pass variable = EmptyClass() def func(): pass cls = get_completion('EmptyClass', locals()) var = get_completion('variable', locals()) f = get_completion('func', locals()) m = get_completion('keyword', locals()) assert cls.type == 'class' assert var.type == 'instance' assert f.type == 'function' assert m.type == 'module' def test_numpy_like_non_zero(): """ Numpy-like array can't be caster to bool and need to be compacre with `is`/`is not` and not `==`/`!=` """ class NumpyNonZero: def __zero__(self): raise ValueError('Numpy arrays would raise and tell you to use .any() or all()') def __bool__(self): raise ValueError('Numpy arrays would raise and tell you to use .any() or all()') class NumpyLike: def __eq__(self, other): return NumpyNonZero() def something(self): pass x = NumpyLike() d = {'a': x} # just assert these do not raise. They (strangely) trigger different # codepath get_completion('d["a"].some', {'d': d}) get_completion('x.some', {'x': x}) def test_nested_resolve(): class XX: def x(): pass cls = get_completion('XX', locals()) func = get_completion('XX.x', locals()) assert (func.line, func.column) == (cls.line + 1, 12) def test_side_effect_completion(): """ In the repl it's possible to cause side effects that are not documented in Python code, however we want references to Python code as well. Therefore we need some mixed kind of magic for tests. """ _GlobalNameSpace.SideEffectContainer.foo = 1 side_effect = get_completion('SideEffectContainer', _GlobalNameSpace.__dict__) # It's a class that contains MixedObject. value, = side_effect._name.infer() assert isinstance(value, mixed.MixedObject) foo = get_completion('SideEffectContainer.foo', _GlobalNameSpace.__dict__) assert foo.name == 'foo' def _assert_interpreter_complete(source, namespace, completions, *, check_type=False, **kwds): script = jedi.Interpreter(source, [namespace], **kwds) cs = script.complete() actual = [c.name for c in cs] if check_type: for c in cs: c.type assert sorted(actual) == sorted(completions) def test_complete_raw_function(): from os.path import join _assert_interpreter_complete('join("").up', locals(), ['upper']) def test_complete_raw_function_different_name(): from os.path import join as pjoin _assert_interpreter_complete('pjoin("").up', locals(), ['upper']) def test_complete_raw_module(): import os _assert_interpreter_complete('os.path.join("a").up', locals(), ['upper']) def test_complete_raw_instance(): import datetime dt = datetime.datetime(2013, 1, 1) completions = ['time', 'timetz', 'timetuple', 'timestamp'] _assert_interpreter_complete('(dt - dt).ti', locals(), completions) def test_list(): array = ['haha', 1] _assert_interpreter_complete('array[0].uppe', locals(), ['upper']) _assert_interpreter_complete('array[0].real', locals(), []) # something different, no index given, still just return the right _assert_interpreter_complete('array[int].real', locals(), ['real']) _assert_interpreter_complete('array[int()].real', locals(), ['real']) # inexistent index _assert_interpreter_complete('array[2].upper', locals(), ['upper']) def test_getattr(): class Foo1: bar = [] baz = 'bar' _assert_interpreter_complete('getattr(Foo1, baz).app', locals(), ['append']) def test_slice(): class Foo1: bar = [] baz = 'xbarx' _assert_interpreter_complete('getattr(Foo1, baz[1:-1]).append', locals(), ['append']) def test_getitem_side_effects(): class Foo2: def __getitem__(self, index): # Possible side effects here, should therefore not call this. if True: raise NotImplementedError() return index foo = Foo2() _assert_interpreter_complete('foo["asdf"].upper', locals(), ['upper']) @pytest.mark.parametrize('stacklevel', [1, 2]) @pytest.mark.filterwarnings("error") def test_property_warnings(stacklevel, allow_unsafe_getattr): class Foo3: @property def prop(self): # Possible side effects here, should therefore not call this. warnings.warn("foo", DeprecationWarning, stacklevel=stacklevel) return '' foo = Foo3() expected = ['upper'] if allow_unsafe_getattr else [] _assert_interpreter_complete('foo.prop.uppe', locals(), expected) @pytest.mark.parametrize('class_is_findable', [False, True]) def test__getattr__completions(allow_unsafe_getattr, class_is_findable): class CompleteGetattr(object): def __getattr__(self, name): if name == 'foo': return self if name == 'fbar': return '' raise AttributeError(name) def __dir__(self): return ['foo', 'fbar'] + object.__dir__(self) if not class_is_findable: CompleteGetattr.__name__ = "something_somewhere" namespace = {'c': CompleteGetattr()} expected = ['foo', 'fbar'] _assert_interpreter_complete('c.f', namespace, expected) # Completions don't work for class_is_findable, because __dir__ is checked # for interpreter analysis, but if the static analysis part tries to help # it will not work. However static analysis is pretty good and understands # how gettatr works (even the ifs/comparisons). if not allow_unsafe_getattr: expected = [] _assert_interpreter_complete('c.foo.f', namespace, expected) _assert_interpreter_complete('c.foo.foo.f', namespace, expected) _assert_interpreter_complete('c.foo.uppe', namespace, []) expected_int = ['upper'] if allow_unsafe_getattr or class_is_findable else [] _assert_interpreter_complete('c.foo.fbar.uppe', namespace, expected_int) @pytest.fixture(params=[False, True]) def allow_unsafe_getattr(request, monkeypatch): monkeypatch.setattr(jedi.settings, 'allow_unsafe_interpreter_executions', request.param) return request.param def test_property_error_oldstyle(allow_unsafe_getattr): lst = [] class Foo3: @property def bar(self): lst.append(1) raise ValueError foo = Foo3() _assert_interpreter_complete('foo.bar', locals(), ['bar']) _assert_interpreter_complete('foo.bar.baz', locals(), []) if allow_unsafe_getattr: assert lst == [1] else: # There should not be side effects assert lst == [] def test_property_error_newstyle(allow_unsafe_getattr): lst = [] class Foo3(object): @property def bar(self): lst.append(1) raise ValueError foo = Foo3() _assert_interpreter_complete('foo.bar', locals(), ['bar']) _assert_interpreter_complete('foo.bar.baz', locals(), []) if allow_unsafe_getattr: assert lst == [1] else: # There should not be side effects assert lst == [] def test_property_content(): class Foo3(object): @property def bar(self): return 1 foo = Foo3() def_, = jedi.Interpreter('foo.bar', [locals()]).infer() assert def_.name == 'int' def test_param_completion(): def foo(bar): pass lambd = lambda xyz: 3 _assert_interpreter_complete('foo(bar', locals(), ['bar=']) _assert_interpreter_complete('lambd(xyz', locals(), ['xyz=']) def test_endless_yield(): lst = [1] * 10000 # If iterating over lists it should not be possible to take an extremely # long time. _assert_interpreter_complete('list(lst)[9000].rea', locals(), ['real']) def test_completion_params(): foo = lambda a, b=3: None script = jedi.Interpreter('foo', [locals()]) c, = script.complete() sig, = c.get_signatures() assert [p.name for p in sig.params] == ['a', 'b'] assert sig.params[0].infer() == [] t, = sig.params[1].infer() assert t.name == 'int' def test_completion_param_annotations(): # Need to define this function not directly in Python. Otherwise Jedi is too # clever and uses the Python code instead of the signature object. code = 'def foo(a: 1, b: str, c: int = 1.0) -> bytes: pass' exec(code, locals()) script = jedi.Interpreter('foo', [locals()]) c, = script.complete() sig, = c.get_signatures() a, b, c = sig.params assert a.infer() == [] assert [d.name for d in b.infer()] == ['str'] assert {d.name for d in c.infer()} == {'int', 'float'} assert a.description == 'param a: 1' assert b.description == 'param b: str' assert c.description == 'param c: int=1.0' d, = jedi.Interpreter('foo()', [locals()]).infer() assert d.name == 'bytes' def test_keyword_argument(): def f(some_keyword_argument): pass c, = jedi.Interpreter("f(some_keyw", [{'f': f}]).complete() assert c.name == 'some_keyword_argument=' assert c.complete == 'ord_argument=' # Make it impossible for jedi to find the source of the function. f.__name__ = 'xSOMETHING' c, = jedi.Interpreter("x(some_keyw", [{'x': f}]).complete() assert c.name == 'some_keyword_argument=' def test_more_complex_instances(): class Something: def foo(self, other): return self class Base: def wow(self): return Something() script = jedi.Interpreter('Base().wow().foo', [locals()]) c, = script.complete() assert c.name == 'foo' x = Base() script = jedi.Interpreter('x.wow().foo', [locals()]) c, = script.complete() assert c.name == 'foo' def test_repr_execution_issue(): """ Anticipate inspect.getfile executing a __repr__ of all kinds of objects. See also #919. """ class ErrorRepr: def __repr__(self): raise Exception('xyz') er = ErrorRepr() script = jedi.Interpreter('er', [locals()]) d, = script.infer() assert d.name == 'ErrorRepr' assert d.type == 'instance' def test_dir_magic_method(allow_unsafe_getattr): class CompleteAttrs(object): def __getattr__(self, name): if name == 'foo': return 1 if name == 'bar': return 2 raise AttributeError(name) def __dir__(self): return ['foo', 'bar'] + object.__dir__(self) itp = jedi.Interpreter("ca.", [{'ca': CompleteAttrs()}]) completions = itp.complete() names = [c.name for c in completions] assert ('__dir__' in names) is True assert '__class__' in names assert 'foo' in names assert 'bar' in names foo = [c for c in completions if c.name == 'foo'][0] if allow_unsafe_getattr: inst, = foo.infer() assert inst.name == 'int' assert inst.type == 'instance' else: assert foo.infer() == [] def test_name_not_findable(): class X(): if 0: NOT_FINDABLE def hidden(self): return hidden.__name__ = 'NOT_FINDABLE' setattr(X, 'NOT_FINDABLE', X.hidden) assert jedi.Interpreter("X.NOT_FINDA", [locals()]).complete() def test_stubs_working(): from multiprocessing import cpu_count defs = jedi.Interpreter("cpu_count()", [locals()]).infer() assert [d.name for d in defs] == ['int'] def test_sys_path_docstring(): # Was an issue in #1298 import jedi s = jedi.Interpreter("from sys import path\npath", namespaces=[locals()]) s.complete(line=2, column=4)[0].docstring() @pytest.mark.parametrize( 'code, completions', [ ('x[0].uppe', ['upper']), ('x[1337].uppe', ['upper']), ('x[""].uppe', ['upper']), ('x.appen', ['append']), ('y.add', ['add']), ('y[0].', []), ('list(y)[0].', []), # TODO use stubs properly to improve this. ('z[0].uppe', ['upper']), ('z[0].append', ['append']), ('z[1].uppe', ['upper']), ('z[1].append', []), ('collections.deque().app', ['append', 'appendleft']), ('deq.app', ['append', 'appendleft']), ('deq.pop', ['pop', 'popleft']), ('deq.pop().', []), ('collections.Counter("asdf").setdef', ['setdefault']), ('collections.Counter("asdf").pop().imag', ['imag']), ('list(collections.Counter("asdf").keys())[0].uppe', ['upper']), ('counter.setdefa', ['setdefault']), ('counter.pop().imag', []), # TODO stubs could make this better ('counter.keys())[0].uppe', []), ('string.upper().uppe', ['upper']), ('"".upper().uppe', ['upper']), ] ) def test_simple_completions(code, completions): x = [str] y = {1} z = {1: str, 2: list} import collections deq = collections.deque([1]) counter = collections.Counter(['asdf']) string = '' defs = jedi.Interpreter(code, [locals()]).complete() assert [d.name for d in defs] == completions def test__wrapped__(): from functools import lru_cache @lru_cache(maxsize=128) def syslogs_to_df(): pass c, = jedi.Interpreter('syslogs_to_df', [locals()]).complete() # Apparently the function starts on the line where the decorator starts. assert c.line == syslogs_to_df.__wrapped__.__code__.co_firstlineno + 1 def test_illegal_class_instance(): class X: __class__ = 1 X.__name__ = 'asdf' d, = jedi.Interpreter('foo', [{'foo': X()}]).infer() v, = d._name.infer() assert not v.is_instance() @pytest.mark.parametrize('module_name', ['sys', 'time', 'unittest.mock']) def test_core_module_completes(module_name): module = import_module(module_name) assert jedi.Interpreter('module.', [locals()]).complete() @pytest.mark.parametrize( 'code, expected, index', [ ('a(', ['a', 'b', 'c'], 0), ('b(', ['b', 'c'], 0), # Might or might not be correct, because c is given as a keyword # argument as well, but that is just what inspect.signature returns. ('c(', ['b', 'c'], 0), ] ) def test_partial_signatures(code, expected, index): import functools def func(a, b, c): pass a = functools.partial(func) b = functools.partial(func, 1) c = functools.partial(func, 1, c=2) sig, = jedi.Interpreter(code, [locals()]).get_signatures() assert sig.name == 'partial' assert [p.name for p in sig.params] == expected assert index == sig.index def test_type_var(): """This was an issue before, see Github #1369""" import typing x = typing.TypeVar('myvar') def_, = jedi.Interpreter('x', [locals()]).infer() assert def_.name == 'TypeVar' @pytest.mark.parametrize('class_is_findable', [False, True]) def test_param_annotation_completion(class_is_findable): class Foo: bar = 3 if not class_is_findable: Foo.__name__ = 'asdf' code = 'def CallFoo(x: Foo):\n x.ba' def_, = jedi.Interpreter(code, [locals()]).complete() assert def_.name == 'bar' @pytest.mark.parametrize( 'code, column, expected', [ ('strs[', 5, ["'asdf'", "'fbar'", "'foo'", Ellipsis]), ('strs[]', 5, ["'asdf'", "'fbar'", "'foo'", Ellipsis]), ("strs['", 6, ["asdf'", "fbar'", "foo'"]), ("strs[']", 6, ["asdf'", "fbar'", "foo'"]), ('strs["]', 6, ['asdf"', 'fbar"', 'foo"']), ('mixed[', 6, [r"'a\\sdf'", '1', '1.1', "b'foo'", Ellipsis]), ('mixed[1', 7, ['', '.1']), ('mixed[Non', 9, ['e']), ('implicit[10', None, ['00']), ('inherited["', None, ['blablu"']), ] ) def test_dict_completion(code, column, expected): strs = {'asdf': 1, """foo""": 2, r'fbar': 3} mixed = {1: 2, 1.10: 4, None: 6, r'a\sdf': 8, b'foo': 9} class Inherited(dict): pass inherited = Inherited(blablu=3) namespaces = [locals(), {'implicit': {1000: 3}}] comps = jedi.Interpreter(code, namespaces).complete(column=column) if Ellipsis in expected: # This means that global completions are part of this, so filter all of # that out. comps = [c for c in comps if not c._name.is_value_name and not c.is_keyword] expected = [e for e in expected if e is not Ellipsis] assert [c.complete for c in comps] == expected @pytest.mark.parametrize( 'code, types', [ ('dct[1]', ['int']), ('dct["asdf"]', ['float']), ('dct[r"asdf"]', ['float']), ('dct["a"]', ['float', 'int']), ] ) def test_dict_getitem(code, types): dct = {1: 2, "asdf": 1.0} comps = jedi.Interpreter(code, [locals()]).infer() assert [c.name for c in comps] == types @pytest.mark.parametrize('class_is_findable', [False, True]) @pytest.mark.parametrize( 'code, expected', [ ('DunderCls()[0]', 'int'), ('dunder[0]', 'int'), ('next(DunderCls())', 'float'), ('next(dunder)', 'float'), ('for x in DunderCls(): x', 'str'), #('for x in dunder: x', 'str'), ] ) def test_dunders(class_is_findable, code, expected, allow_unsafe_getattr): from typing import Iterator class DunderCls: def __getitem__(self, key) -> int: return 1 def __iter__(self, key) -> Iterator[str]: pass def __next__(self, key) -> float: pass if not class_is_findable: DunderCls.__name__ = 'asdf' dunder = DunderCls() n, = jedi.Interpreter(code, [locals()]).infer() assert n.name == expected def foo(): raise KeyError def bar(): return float @pytest.mark.parametrize( 'annotations, result, code', [ ({}, [], ''), (None, [], ''), ({'asdf': 'str'}, [], ''), ({'return': 'str'}, ['str'], ''), ({'return': 'None'}, ['NoneType'], ''), ({'return': 'str().upper'}, [], ''), ({'return': 'foo()'}, [], ''), ({'return': 'bar()'}, ['float'], ''), # typing is available via globals. ({'return': 'typing.Union[str, int]'}, ['int', 'str'], ''), ({'return': 'typing.Union["str", int]'}, ['int', 'str'] if sys.version_info >= (3, 9) else ['int'], ''), ({'return': 'typing.Union["str", 1]'}, ['str'] if sys.version_info >= (3, 11) else [], ''), ({'return': 'typing.Optional[str]'}, ['NoneType', 'str'], ''), ({'return': 'typing.Optional[str, int]'}, [], ''), # Takes only one arg ({'return': 'typing.Any'}, ['_AnyMeta'] if sys.version_info >= (3, 11) else [], ''), ({'return': 'typing.Tuple[int, str]'}, ['Tuple' if sys.version_info[:2] == (3, 6) else 'tuple'], ''), ({'return': 'typing.Tuple[int, str]'}, ['int'], 'x()[0]'), ({'return': 'typing.Tuple[int, str]'}, ['str'], 'x()[1]'), ({'return': 'typing.Tuple[int, str]'}, [], 'x()[2]'), ({'return': 'typing.List'}, ['list'], 'list'), ({'return': 'typing.List[int]'}, ['list'], 'list'), ({'return': 'typing.List[int]'}, ['int'], 'x()[0]'), ({'return': 'typing.List[int, str]'}, [], 'x()[0]'), ({'return': 'typing.Iterator[int]'}, [], 'x()[0]'), ({'return': 'typing.Iterator[int]'}, ['int'], 'next(x())'), ({'return': 'typing.Iterable[float]'}, ['float'], 'list(x())[0]'), ({'return': 'decimal.Decimal'}, [], ''), ({'return': 'lalalalallalaa'}, [], ''), ({'return': 'lalalalallalaa.lala'}, [], ''), ] ) def test_string_annotation(annotations, result, code): x = lambda foo: 1 x.__annotations__ = annotations defs = jedi.Interpreter(code or 'x()', [locals()]).infer() assert [d.name for d in defs] == result def test_name_not_inferred_properly(): """ In IPython notebook it is typical that some parts of the code that is provided was already executed. In that case if something is not properly inferred, it should still infer from the variables it already knows. """ x = 1 d, = jedi.Interpreter('x = UNDEFINED; x', [locals()]).infer() assert d.name == 'int' def test_variable_reuse(): x = 1 d, = jedi.Interpreter('y = x\ny', [locals()]).infer() assert d.name == 'int' def test_negate(): code = "x = -y" x, = jedi.Interpreter(code, [{'y': 3}]).infer(1, 0) assert x.name == 'int' value, = x._name.infer() assert value.get_safe_value() == -3 def test_complete_not_findable_class_source(): class TestClass(): ta=1 ta1=2 # Simulate the environment where the class is defined in # an interactive session and therefore inspect module # cannot find its source code and raises OSError (Py 3.10+) or TypeError. TestClass.__module__ = "__main__" # There is a pytest __main__ module we have to remove temporarily. module = sys.modules.pop("__main__") try: interpreter = jedi.Interpreter("TestClass.", [locals()]) completions = interpreter.complete(column=10, line=1) finally: sys.modules["__main__"] = module assert "ta" in [c.name for c in completions] assert "ta1" in [c.name for c in completions] def test_param_infer_default(): abs_sig, = jedi.Interpreter('abs(', [{'abs': abs}]).get_signatures() param, = abs_sig.params assert param.name == 'x' assert param.infer_default() == [] @pytest.mark.parametrize( 'code, expected', [ ("random.triangular(", ['high=', 'low=', 'mode=']), ("random.triangular(low=1, ", ['high=', 'mode=']), ("random.triangular(high=1, ", ['low=', 'mode=']), ("random.triangular(low=1, high=2, ", ['mode=']), ("random.triangular(low=1, mode=2, ", ['high=']), ], ) def test_keyword_param_completion(code, expected): import random completions = jedi.Interpreter(code, [locals()]).complete() assert expected == [c.name for c in completions if c.name.endswith('=')] @pytest.mark.parametrize('class_is_findable', [False, True]) def test_avoid_descriptor_executions_if_not_necessary(class_is_findable): counter = 0 class AvoidDescriptor(object): @property def prop(self): nonlocal counter counter += 1 return self if not class_is_findable: AvoidDescriptor.__name__ = "something_somewhere" namespace = {'b': AvoidDescriptor()} expected = ['prop'] _assert_interpreter_complete('b.pro', namespace, expected, check_type=True) assert counter == 0 _assert_interpreter_complete('b.prop.pro', namespace, expected, check_type=True) assert counter == 1 class Hello: its_me = 1 @pytest.mark.parametrize('class_is_findable', [False, True]) def test_try_to_use_return_annotation_for_property(class_is_findable): class WithProperties(object): @property def with_annotation1(self) -> str: raise BaseException @property def with_annotation2(self) -> 'str': raise BaseException @property def with_annotation3(self) -> Hello: raise BaseException @property def with_annotation4(self) -> 'Hello': raise BaseException @property def with_annotation_garbage1(self) -> 'asldjflksjdfljdslkjfsl': # noqa return Hello() @property def with_annotation_garbage2(self) -> 'sdf$@@$5*+8': # noqa return Hello() @property def without_annotation(self): return "" if not class_is_findable: WithProperties.__name__ = "something_somewhere" Hello.__name__ = "something_somewhere_else" namespace = {'p': WithProperties()} _assert_interpreter_complete('p.without_annotation.upp', namespace, ['upper']) _assert_interpreter_complete('p.with_annotation1.upp', namespace, ['upper']) _assert_interpreter_complete('p.with_annotation2.upp', namespace, ['upper']) _assert_interpreter_complete('p.with_annotation3.its', namespace, ['its_me']) _assert_interpreter_complete('p.with_annotation4.its', namespace, ['its_me']) # This is a fallback, if the annotations don't help _assert_interpreter_complete('p.with_annotation_garbage1.its', namespace, ['its_me']) _assert_interpreter_complete('p.with_annotation_garbage2.its', namespace, ['its_me']) def test_nested__getitem__(): d = {'foo': {'bar': 1}} _assert_interpreter_complete('d["fo', locals(), ['"foo"']) _assert_interpreter_complete('d["foo"]["ba', locals(), ['"bar"']) _assert_interpreter_complete('(d["foo"])["ba', locals(), ['"bar"']) _assert_interpreter_complete('((d["foo"]))["ba', locals(), ['"bar"']) @pytest.mark.parametrize('class_is_findable', [False, True]) def test_custom__getitem__(class_is_findable, allow_unsafe_getattr): class CustomGetItem: def __getitem__(self, x: int): return "asdf" if not class_is_findable: CustomGetItem.__name__ = "something_somewhere" namespace = {'c': CustomGetItem()} if not class_is_findable and not allow_unsafe_getattr: expected = [] else: expected = ['upper'] _assert_interpreter_complete('c["a"].up', namespace, expected) ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/test_api/test_keyword.py0000664000175000017500000000266100000000000020271 0ustar00davedave00000000000000""" Test of keywords and ``jedi.keywords`` """ def test_goto_keyword(Script): """ Bug: goto assignments on ``in`` used to raise AttributeError:: 'str' object has no attribute 'generate_call_path' """ Script('in').goto() def test_keyword(Script, environment): """ github jedi-vim issue #44 """ defs = Script("print").infer() assert [d.docstring() for d in defs] assert Script("import").goto() == [] completions = Script("import").complete(1, 1) assert len(completions) > 10 and 'if' in [c.name for c in completions] assert Script("assert").infer() == [] def test_keyword_attributes(Script): def_, = Script('def').complete() assert def_.name == 'def' assert def_.complete == '' assert def_.is_keyword is True assert def_.is_stub() is False assert def_.goto(only_stubs=True) == [] assert def_.goto() == [] assert def_.infer() == [] assert def_.parent() is None assert def_.docstring() assert def_.description == 'keyword def' assert def_.get_line_code() == '' assert def_.full_name is None assert def_.line is def_.column is None assert def_.in_builtin_module() is True assert def_.module_name == 'builtins' assert 'typeshed' in def_.module_path.parts assert def_.type == 'keyword' def test_none_keyword(Script, environment): none, = Script('None').complete() assert not none.docstring() assert none.name == 'None' ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/test_api/test_names.py0000664000175000017500000001214200000000000017703 0ustar00davedave00000000000000""" Tests for `api.names`. """ from textwrap import dedent import pytest def _assert_definition_names(definitions, names): assert [d.name for d in definitions] == names def _check_names(get_names, source, names): definitions = get_names(dedent(source)) _assert_definition_names(definitions, names) return definitions def test_get_definitions_flat(get_names): _check_names(get_names, """ import module class Class: pass def func(): pass data = None """, ['module', 'Class', 'func', 'data']) def test_dotted_assignment(get_names): _check_names(get_names, """ x = Class() x.y.z = None """, ['x', 'z']) # TODO is this behavior what we want? def test_multiple_assignment(get_names): _check_names(get_names, "x = y = None", ['x', 'y']) def test_multiple_imports(get_names): _check_names(get_names, """ from module import a, b from another_module import * """, ['a', 'b']) def test_nested_definitions(get_names): definitions = _check_names(get_names, """ class Class: def f(): pass def g(): pass """, ['Class']) subdefinitions = definitions[0].defined_names() _assert_definition_names(subdefinitions, ['f', 'g']) assert [d.full_name for d in subdefinitions] == ['__main__.Class.f', '__main__.Class.g'] def test_nested_class(get_names): definitions = _check_names(get_names, """ class L1: class L2: class L3: def f(): pass def f(): pass def f(): pass def f(): pass """, ['L1', 'f']) subdefs = definitions[0].defined_names() subsubdefs = subdefs[0].defined_names() _assert_definition_names(subdefs, ['L2', 'f']) _assert_definition_names(subsubdefs, ['L3', 'f']) _assert_definition_names(subsubdefs[0].defined_names(), ['f']) def test_class_fields_with_all_scopes_false(get_names): definitions = _check_names(get_names, """ from module import f g = f(f) class C: h = g def foo(x=a): bar = x return bar """, ['f', 'g', 'C', 'foo']) C_subdefs = definitions[-2].defined_names() foo_subdefs = definitions[-1].defined_names() _assert_definition_names(C_subdefs, ['h']) _assert_definition_names(foo_subdefs, ['x', 'bar']) def test_async_stmt_with_all_scopes_false(get_names): definitions = _check_names(get_names, """ from module import f import asyncio g = f(f) class C: h = g def __init__(self): pass async def __aenter__(self): pass def foo(x=a): bar = x return bar async def async_foo(duration): async def wait(): await asyncio.sleep(100) for i in range(duration//100): await wait() return duration//100*100 async with C() as cinst: d = cinst """, ['f', 'asyncio', 'g', 'C', 'foo', 'async_foo', 'cinst', 'd']) C_subdefs = definitions[3].defined_names() foo_subdefs = definitions[4].defined_names() async_foo_subdefs = definitions[5].defined_names() cinst_subdefs = definitions[6].defined_names() _assert_definition_names(C_subdefs, ['h', '__init__', '__aenter__']) _assert_definition_names(foo_subdefs, ['x', 'bar']) _assert_definition_names(async_foo_subdefs, ['duration', 'wait', 'i']) # We treat d as a name outside `async with` block _assert_definition_names(cinst_subdefs, []) def test_follow_imports(get_names): # github issue #344 imp = get_names('import datetime')[0] assert imp.name == 'datetime' datetime_names = [str(d.name) for d in imp.defined_names()] assert 'timedelta' in datetime_names def test_names_twice(get_names): code = dedent(''' def lol(): pass ''') defs = get_names(code) assert defs[0].defined_names() == [] def test_simple_name(get_names): defs = get_names('foo', references=True) assert not defs[0]._name.infer() def test_no_error(get_names): code = dedent(""" def foo(a, b): if a == 10: if b is None: print("foo") a = 20 """) func_name, = get_names(code) a, b, a20 = func_name.defined_names() assert a.name == 'a' assert b.name == 'b' assert a20.name == 'a' assert a20.goto() == [a20] @pytest.mark.parametrize( 'code, index, is_side_effect', [ ('x', 0, False), ('x.x', 0, False), ('x.x', 1, False), ('x.x = 3', 0, False), ('x.x = 3', 1, True), ('def x(x): x.x = 3', 1, False), ('def x(x): x.x = 3', 3, True), ('import sys; sys.path', 0, False), ('import sys; sys.path', 1, False), ('import sys; sys.path', 2, False), ('import sys; sys.path = []', 2, True), ] ) def test_is_side_effect(get_names, code, index, is_side_effect): names = get_names(code, references=True, all_scopes=True) assert names[index].is_side_effect() == is_side_effect def test_no_defined_names(get_names): definition, = get_names("x = (1, 2)") assert not definition.defined_names() ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/test_api/test_project.py0000664000175000017500000001652400000000000020256 0ustar00davedave00000000000000import os from pathlib import Path import pytest from ..helpers import get_example_dir, set_cwd, root_dir, test_dir from jedi import Interpreter from jedi.api import Project, get_default_project from jedi.api.project import _is_potential_project, _CONTAINS_POTENTIAL_PROJECT def test_django_default_project(Script): dir = get_example_dir('django') script = Script( "from app import models\nmodels.SomeMo", path=os.path.join(dir, 'models/x.py') ) c, = script.complete() assert c.name == "SomeModel" project = script._inference_state.project assert project._django is True assert project.sys_path is None assert project.smart_sys_path is True assert project.load_unsafe_extensions is False def test_django_default_project_of_file(Script): project = get_default_project(__file__) assert project._path == Path(__file__).parent.parent.parent def test_interpreter_project_path(): # Run from anywhere it should be the cwd. dir = Path(root_dir).joinpath('test') with set_cwd(dir): project = Interpreter('', [locals()])._inference_state.project assert project._path == dir def test_added_sys_path(inference_state): project = get_default_project() p = '/some_random_path' project.added_sys_path = [p] assert p in project._get_sys_path(inference_state) def test_load_save_project(tmpdir): project = Project(tmpdir.strpath, added_sys_path=['/foo']) project.save() loaded = Project.load(tmpdir.strpath) assert loaded.added_sys_path == ['/foo'] @pytest.mark.parametrize( 'string, full_names, kwargs', [ ('test_load_save_project', ['test_api.test_project.test_load_save_project'], {}), ('test_load_savep', [], dict(complete=True)), ('test_load_save_p', ['test_api.test_project.test_load_save_project'], dict(complete=True)), ('test_load_save_p', ['test_api.test_project.test_load_save_project'], dict(complete=True, all_scopes=True)), ('some_search_test_var', [], {}), ('some_search_test_var', ['test_api.test_project.test_search.some_search_test_var'], dict(all_scopes=True)), ('some_search_test_var', ['test_api.test_project.test_search.some_search_test_var'], dict(complete=True, all_scopes=True)), # Make sure that the searched name is not part of the file, by # splitting it up. ('some_search_test_v' + 'a', ['test_api.test_project.test_search.some_search_test_var'], dict(complete=True, all_scopes=True)), ('sample_int', ['helpers.sample_int'], {}), ('sample_int', ['helpers.sample_int'], dict(all_scopes=True)), ('sample_int.real', ['stub:builtins.int.real'], {}), ('class sample_int.real', [], {}), ('foo sample_int.real', [], {}), ('def sample_int.to_bytes', ['stub:builtins.int.to_bytes'], {}), ('function sample_int.to_bytes', ['stub:builtins.int.to_bytes'], {}), ('property sample_int.real', ['stub:builtins.int.real'], {}), # With modules ('test_project.test_search', ['test_api.test_project.test_search'], {}), ('test_project.test_searc', ['test_api.test_project.test_search'], dict(complete=True)), ('test_api.test_project.test_search', ['test_api.test_project.test_search'], {}), ('test_api.test_project.test_sear', ['test_api.test_project.test_search'], dict(complete=True)), # With namespace ('implicit_namespace_package.ns1.pkg', ['examples.implicit_namespace_package.ns1.pkg'], {}), ('implicit_namespace_package.ns1.pkg.ns1_file', ['examples.implicit_namespace_package.ns1.pkg.ns1_file'], {}), ('examples.implicit_namespace_package.ns1.pkg.ns1_file', ['examples.implicit_namespace_package.ns1.pkg.ns1_file'], {}), ('implicit_namespace_package.ns1.pkg.', ['examples.implicit_namespace_package.ns1.pkg.ns1_file'], dict(complete=True)), ('implicit_namespace_package.', ['examples.implicit_namespace_package.ns1', 'examples.implicit_namespace_package.ns2'], dict(complete=True)), # With stubs ('with_python.module', ['examples.stub_packages.with_python.module'], {}), ('with_python.modul', ['examples.stub_packages.with_python.module'], dict(complete=True)), ('no_python.foo', ['stub:examples.stub_packages.no_python.foo'], {}), ('no_python.fo', ['stub:examples.stub_packages.no_python.foo'], dict(complete=True)), ('with_python-stubs.module', [], {}), ('no_python-stubs.foo', [], {}), # Both locations are given, because they live in separate folders (one # suffixed with -stubs. ('with_python', ['examples.stub_packages.with_python'], {}), ('no_python', ['stub:examples.stub_packages.no_python'], {}), # Completion stubs ('stub_only', ['stub:completion.stub_folder.stub_only', 'stub:examples.stub_packages.with_python.stub_only'], {}), ('with_stub', ['completion.stub_folder.with_stub'], {}), ('with_stub.in_with_stub_both', ['completion.stub_folder.with_stub.in_with_stub_both'], {}), ('with_stub.in_with_stub_python', ['completion.stub_folder.with_stub.in_with_stub_python'], {}), ('with_stub.in_with_stub_stub', ['stub:completion.stub_folder.with_stub.in_with_stub_stub'], {}), # Completion stubs: Folder ('with_stub_folder', ['completion.stub_folder.with_stub_folder'], {}), ('with_stub_folder.nested_with_stub', ['completion.stub_folder.with_stub_folder.nested_with_stub'], {}), ('nested_with_stub', ['completion.stub_folder.stub_only_folder.nested_with_stub', 'completion.stub_folder.with_stub_folder.nested_with_stub'], {}), # On sys path ('sys.path', ['stub:sys.path'], {}), ('json.dumps', ['json.dumps'], {}), # stdlib + stub ('multiprocessing', ['multiprocessing'], {}), ('multiprocessin', ['multiprocessing'], dict(complete=True)), ] ) def test_search(string, full_names, kwargs): some_search_test_var = 1.0 project = Project(test_dir) if kwargs.pop('complete', False) is True: defs = project.complete_search(string, **kwargs) else: defs = project.search(string, **kwargs) assert sorted([('stub:' if d.is_stub() else '') + (d.full_name or d.name) for d in defs]) == full_names @pytest.mark.parametrize( 'string, completions, all_scopes', [ ('SomeCl', ['ass'], False), ('twic', [], False), ('twic', ['e', 'e'], True), ('test_load_save_p', ['roject'], False), ] ) def test_complete_search(Script, string, completions, all_scopes): project = Project(test_dir) defs = project.complete_search(string, all_scopes=all_scopes) assert [d.complete for d in defs] == completions @pytest.mark.parametrize( 'path,expected', [ (Path(__file__).parents[2], True), # The path of the project (Path(__file__).parents[1], False), # The path of the tests, not a project (Path.home(), None) ] ) def test_is_potential_project(path, expected): if expected is None: try: expected = bool(set(_CONTAINS_POTENTIAL_PROJECT) & set(os.listdir(path))) except OSError: expected = False assert _is_potential_project(path) == expected ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/test_api/test_refactoring.py0000664000175000017500000000755200000000000021114 0ustar00davedave00000000000000import os import shutil from textwrap import dedent from pathlib import Path import platform import pytest import jedi from test.helpers import get_example_dir @pytest.fixture() def dir_with_content(tmpdir): with open(os.path.join(tmpdir.strpath, 'modx.py'), 'w', newline='') as f: f.write('import modx\nfoo\n') # self reference return Path(tmpdir.strpath) def test_rename_mod(Script, dir_with_content): script = Script( 'import modx; modx\n', path=dir_with_content.joinpath('some_script.py'), project=jedi.Project(dir_with_content), ) refactoring = script.rename(line=1, new_name='modr') refactoring.apply() p1 = dir_with_content.joinpath('modx.py') p2 = dir_with_content.joinpath('modr.py') expected_code = 'import modr\nfoo\n' assert not p1.exists() with open(p2, newline='') as f: assert f.read() == expected_code assert refactoring.get_renames() == [(p1, p2)] assert refactoring.get_changed_files()[p1].get_new_code() == expected_code assert refactoring.get_diff() == dedent('''\ rename from modx.py rename to modr.py --- modx.py +++ modr.py @@ -1,3 +1,3 @@ -import modx +import modr foo --- some_script.py +++ some_script.py @@ -1,2 +1,2 @@ -import modx; modx +import modr; modr ''').format(dir=dir_with_content) @pytest.mark.skipif('sys.version_info[:2] < (3, 8)', message="Python 3.8 introduces dirs_exist_ok") def test_namespace_package(Script, tmpdir): origin = get_example_dir('implicit_namespace_package') shutil.copytree(origin, tmpdir.strpath, dirs_exist_ok=True) sys_path = [ os.path.join(tmpdir.strpath, 'ns1'), os.path.join(tmpdir.strpath, 'ns2') ] script_path = os.path.join(tmpdir.strpath, 'script.py') script = Script( 'import pkg\n', path=script_path, project=jedi.Project(os.path.join(tmpdir.strpath, 'does-not-exist'), sys_path=sys_path), ) refactoring = script.rename(line=1, new_name='new_pkg') refactoring.apply() old1 = os.path.join(sys_path[0], "pkg") new1 = os.path.join(sys_path[0], "new_pkg") old2 = os.path.join(sys_path[1], "pkg") new2 = os.path.join(sys_path[1], "new_pkg") assert not os.path.exists(old1) assert os.path.exists(new1) assert not os.path.exists(old2) assert os.path.exists(new2) changed, = iter(refactoring.get_changed_files().values()) assert changed.get_new_code() == "import new_pkg\n" assert refactoring.get_diff() == dedent(f'''\ rename from {old1} rename to {new1} rename from {old2} rename to {new2} --- {script_path} +++ {script_path} @@ -1,2 +1,2 @@ -import pkg +import new_pkg ''').format(dir=dir_with_content) def test_rename_none_path(Script): refactoring = Script('foo', path=None).rename(new_name='bar') with pytest.raises(jedi.RefactoringError, match='on a Script with path=None'): refactoring.apply() assert refactoring def test_diff_without_ending_newline(Script): refactoring = Script('a = 1\nb\na').rename(1, 0, new_name='c') assert refactoring.get_diff() == dedent('''\ --- +++ @@ -1,3 +1,3 @@ -a = 1 +c = 1 b -a +c ''') def test_diff_path_outside_of_project(Script): if platform.system().lower() == 'windows': abs_path = r'D:\unknown_dir\file.py' else: abs_path = '/unknown_dir/file.py' script = Script( code='foo = 1', path=abs_path, project=jedi.get_default_project() ) diff = script.rename(line=1, column=0, new_name='bar').get_diff() assert diff == dedent(f'''\ --- {abs_path} +++ {abs_path} @@ -1 +1 @@ -foo = 1 +bar = 1 ''') ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/test_api/test_search.py0000664000175000017500000000666200000000000020057 0ustar00davedave00000000000000import os import sys import pytest class SomeClass: class SomeClass: def twice(self, a): something = os return something def twice(self, b): pass def some_function(): pass @pytest.mark.parametrize( 'string, descriptions, kwargs', [ # No completions ('SomeClass', ['class SomeClass'], {}), ('SomeClass', ['class SomeClass', 'class SomeClass.SomeClass'], dict(all_scopes=True)), ('Some', [], dict(all_scopes=True)), ('os', ['module os'], {}), ('sys', ['module sys'], {}), ('sys.path', ['statement sys.path'], {}), ('sys.exit', ['function sys.exit'], {}), ('something', [], {}), ('something', ['statement SomeClass.SomeClass.twice.something'], dict(all_scopes=True)), # Completions ('class Some', ['class SomeClass', 'class SomeClass.SomeClass'], dict(all_scopes=True, complete=True)), ('class Some', ['class SomeClass'], dict(complete=True)), ('Some', ['class SomeClass', 'class SomeClass.SomeClass', 'statement SomeClass.SomeClass.twice.something', 'function SomeClass.some_function'], dict(all_scopes=True, complete=True)), ('some', ['class SomeClass', 'class SomeClass.SomeClass', 'statement SomeClass.SomeClass.twice.something', 'function SomeClass.some_function'], dict(all_scopes=True, complete=True)), # Fuzzy ('class Smelss', ['class SomeClass'], dict(complete=True, fuzzy=True)), ('class Smelss', ['class SomeClass', 'class SomeClass.SomeClass'], dict(complete=True, fuzzy=True, all_scopes=True)), # Nested ('SomeClass.SomeClass', ['class SomeClass.SomeClass'], dict(all_scopes=True)), ('SomeClass.SomeClass.twice', ['function SomeClass.SomeClass.twice'], dict(all_scopes=True)), ('SomeClass.SomeClass.twice.__call__', ['function types.FunctionType.__call__'], dict(all_scopes=True)), ('SomeClass.SomeClass.twice.something', [], dict(all_scopes=True)), ('SomeClass.twice', ['function SomeClass.twice', 'function SomeClass.SomeClass.twice'], dict(all_scopes=True)), # Nested completions ('SomeClass.twi', ['function SomeClass.twice', 'function SomeClass.SomeClass.twice'], dict(all_scopes=True, complete=True)), # Fuzzy unfortunately doesn't work ('SomeCl.twice', [], dict(all_scopes=True, complete=True, fuzzy=True)), ] ) def test_simple_search(Script, string, descriptions, kwargs): if kwargs.pop('complete', False) is True: defs = Script(path=__file__).complete_search(string, **kwargs) else: defs = Script(path=__file__).search(string, **kwargs) this_mod = 'test.test_api.test_search.' assert [d.type + ' ' + d.full_name.replace(this_mod, '') for d in defs] == descriptions @pytest.mark.parametrize( 'string, completions, fuzzy, all_scopes', [ ('SomeCl', ['ass'], False, False), ('SomeCl', [None], True, False), ('twic', [], False, False), ('some_f', [], False, False), ('twic', ['e', 'e'], False, True), ('some_f', ['unction'], False, True), ] ) def test_complete_search(Script, string, completions, fuzzy, all_scopes): defs = Script(path=__file__).complete_search(string, fuzzy=fuzzy, all_scopes=all_scopes) assert [d.complete for d in defs] == completions ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/test_api/test_settings.py0000664000175000017500000000046600000000000020446 0ustar00davedave00000000000000from jedi import api def test_add_bracket_after_function(monkeypatch, Script): settings = api.settings monkeypatch.setattr(settings, 'add_bracket_after_function', True) script = Script('''\ def foo(): pass foo''') completions = script.complete() assert completions[0].complete == '(' ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/test_api/test_signatures.py0000664000175000017500000000534500000000000020773 0ustar00davedave00000000000000import pytest _tuple_code = 'from typing import Tuple\ndef f(x: Tuple[int]): ...\nf' @pytest.mark.parametrize( 'code, expected_params, execute_annotation', [ ('def f(x: 1, y): ...\nf', [None, None], True), ('def f(x: 1, y): ...\nf', ['instance int', None], False), ('def f(x: int): ...\nf', ['instance int'], True), ('from typing import List\ndef f(x: List[int]): ...\nf', ['instance list'], True), ('from typing import List\ndef f(x: List[int]): ...\nf', ['class list'], False), (_tuple_code, ['instance tuple'], True), (_tuple_code, ['class Tuple'], False), ('x=str\ndef f(p: x): ...\nx=int\nf', ['instance int'], True), ('def f(*args, **kwargs): ...\nf', [None, None], False), ('def f(*args: int, **kwargs: str): ...\nf', ['class int', 'class str'], False), ] ) def test_param_annotation(Script, code, expected_params, execute_annotation): func, = Script(code).goto() sig, = func.get_signatures() for p, expected in zip(sig.params, expected_params): annotations = p.infer_annotation(execute_annotation=execute_annotation) if expected is None: assert not annotations else: annotation, = annotations assert annotation.description == expected @pytest.mark.parametrize( 'code, expected_params', [ ('def f(x=1, y=int, z): pass\nf', ['instance int', 'class int', None]), ('def f(*args, **kwargs): pass\nf', [None, None]), ('x=1\ndef f(p=x): pass\nx=""\nf', ['instance int']), ] ) def test_param_default(Script, code, expected_params): func, = Script(code).goto() sig, = func.get_signatures() for p, expected in zip(sig.params, expected_params): annotations = p.infer_default() if expected is None: assert not annotations else: annotation, = annotations assert annotation.description == expected @pytest.mark.parametrize( 'code, index, param_code, kind', [ ('def f(x=1): pass\nf', 0, 'x=1', 'POSITIONAL_OR_KEYWORD'), ('def f(*args:int): pass\nf', 0, '*args: int', 'VAR_POSITIONAL'), ('def f(**kwargs: List[x]): pass\nf', 0, '**kwargs: List[x]', 'VAR_KEYWORD'), ('def f(*, x:int=5): pass\nf', 0, 'x: int=5', 'KEYWORD_ONLY'), ('def f(*args, x): pass\nf', 1, 'x', 'KEYWORD_ONLY'), ] ) def test_param_kind_and_name(code, index, param_code, kind, Script): func, = Script(code).goto() sig, = func.get_signatures() param = sig.params[index] assert param.to_string() == param_code assert param.kind.name == kind def test_staticmethod(Script): s, = Script('staticmethod(').get_signatures() assert s.to_string() == 'staticmethod(f: Callable[..., Any])' ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/test_api/test_syntax_errors.py0000664000175000017500000000302200000000000021517 0ustar00davedave00000000000000""" These tests test Jedi's Parso usage. Basically there's not a lot of tests here, because we're just checking if the API works. Bugfixes should be done in parso, mostly. """ from textwrap import dedent import pytest @pytest.mark.parametrize( 'code, line, column, until_line, until_column, message', [ ('?\n', 1, 0, 1, 1, 'SyntaxError: invalid syntax'), ('x %% y', 1, 3, 1, 4, 'SyntaxError: invalid syntax'), ('"""\n\n', 1, 0, 3, 0, 'SyntaxError: EOF while scanning triple-quoted string literal'), ('(1, 2\n', 2, 0, 2, 0, 'SyntaxError: invalid syntax'), ('foo(1, 2\ndef x(): pass', 2, 0, 2, 3, 'SyntaxError: invalid syntax'), ] ) def test_simple_syntax_errors(Script, code, line, column, until_line, until_column, message): e, = Script(code).get_syntax_errors() assert e.line == line assert e.column == column assert e.until_line == until_line assert e.until_column == until_column assert e.get_message() == message @pytest.mark.parametrize( 'code', [ 'x % y', 'def x(x): pass', 'def x(x):\n pass', ] ) def test_no_syntax_errors(Script, code): assert not Script(code).get_syntax_errors() def test_multi_syntax_error(Script): code = dedent('''\ def x(): 1 def y() 1 + 1 1 *** 3 ''') x, y, power = Script(code).get_syntax_errors() assert x.line == 2 assert x.column == 0 assert y.line == 3 assert y.column == 7 assert power.line == 5 assert power.column == 4 ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/test_api/test_unicode.py0000664000175000017500000000414200000000000020227 0ustar00davedave00000000000000""" All character set and unicode related tests. """ from jedi import Project def test_unicode_script(Script): s = "import datetime; datetime.timedelta" completions = Script(s).complete() assert len(completions) assert type(completions[0].description) is str s = "author='öä'; author" completions = Script(s).complete() x = completions[0].description assert type(x) is str s = "#-*- coding: iso-8859-1 -*-\nauthor='öä'; author" s = s.encode('latin-1') completions = Script(s).complete() assert type(completions[0].description) is str def test_unicode_attribute(Script): """ github jedi-vim issue #94 """ s1 = ('#-*- coding: utf-8 -*-\nclass Person():\n' ' name = "e"\n\nPerson().name.') completions1 = Script(s1).complete() assert 'strip' in [c.name for c in completions1] s2 = ('#-*- coding: utf-8 -*-\nclass Person():\n' ' name = "é"\n\nPerson().name.') completions2 = Script(s2).complete() assert 'strip' in [c.name for c in completions2] def test_multibyte_script(Script): """ `jedi.Script` must accept multi-byte string source. """ code = "import datetime; datetime.d" comment = "# multi-byte comment あいうえおä" s = ('%s\n%s') % (code, comment) assert len(Script(s).complete(1, len(code))) def test_goto_definition_at_zero(Script): """Infer at zero sometimes raises issues.""" assert Script("a").infer(1, 1) == [] s = Script("str").infer(1, 1) assert len(s) == 1 assert list(s)[0].description == 'class str' assert Script("").infer(1, 0) == [] def test_complete_at_zero(Script): s = Script("str").complete(1, 3) assert len(s) == 1 assert list(s)[0].name == 'str' s = Script("").complete(1, 0) assert len(s) > 0 def test_wrong_encoding(Script, tmpdir): x = tmpdir.join('x.py') # Use both latin-1 and utf-8 (a really broken file). x.write_binary('foobar = 1\nä'.encode('latin-1') + 'ä'.encode('utf-8')) project = Project(tmpdir.strpath) c, = Script('import x; x.foo', project=project).complete() assert c.name == 'foobar' ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/test_api/test_usages.py0000664000175000017500000000326600000000000020076 0ustar00davedave00000000000000import pytest from ..helpers import test_dir def test_import_references(Script): s = Script("from .. import foo", path=test_dir.joinpath("foo.py")) assert [usage.line for usage in s.get_references()] == [1] def test_exclude_builtin_modules(Script): def get(include): references = Script(source).get_references(include_builtins=include) return [(d.line, d.column) for d in references] source = '''import sys\nsys.setprofile''' places = get(include=True) assert len(places) >= 3 # Includes stubs, the reference itself and the builtin places = get(include=False) # Just the reference assert places == [(2, 4)] @pytest.mark.parametrize('code, places', [ ('', [(1, 7), (4, 6)]), ('', [(2, 5)]), ('', [(2, 24), (7, 10), (11, 10)]), ('', [(6, 4), (14, 0)]), ('', [(7, 4), (8, 11)]), ('', [(7, 22), (11, 22)]), ('', [(11, 4), (12, 11)]), ('from datetime', [(1, 5)]), ('''from datetime import datetime d1 = datetime.now() d2 = datetime.now() ''', [(2, 14), (3, 14)]), ('''from datetime import timedelta t1 = timedelta(seconds=1) t2 = timedelta(seconds=2) ''', [(2, 15), (3, 15)]) ]) def test_references_scope(Script, code, places): if not code: code = '''import sys from collections import defaultdict print(sys.path) def foo(bar): baz = defaultdict(int) return baz def bar(foo): baz = defaultdict(int) return baz foo() ''' from jedi.api.project import Project project = Project('', sys_path=[], smart_sys_path=False) script = Script(code, project=project) for place in places: assert places == [(n.line, n.column) for n in script.get_references(scope='file', *place)] ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/test_cache.py0000664000175000017500000000142000000000000016030 0ustar00davedave00000000000000""" Test all things related to the ``jedi.cache`` module. """ def test_cache_get_signatures(Script): """ See github issue #390. """ def check(column, call_name, path=None): assert Script(s, path=path).get_signatures(1, column)[0].name == call_name s = 'str(int())' for i in range(3): check(8, 'int') check(4, 'str') # Can keep doing these calls and always get the right result. # Now lets specify a source_path of boo and alternate these calls, it # should still work. for i in range(3): check(8, 'int', 'boo') check(4, 'str', 'boo') def test_cache_line_split_issues(Script): """Should still work even if there's a newline.""" assert Script('int(\n').get_signatures()[0].name == 'int' ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/test_debug.py0000664000175000017500000000032100000000000016052 0ustar00davedave00000000000000import jedi from jedi import debug def test_simple(): jedi.set_debug_function() debug.speed('foo') debug.dbg('bar') debug.warning('baz') jedi.set_debug_function(None, False, False, False) ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/test_file_io.py0000664000175000017500000000155100000000000016400 0ustar00davedave00000000000000from os.path import join from jedi.file_io import FolderIO from test.helpers import get_example_dir def test_folder_io_walk(): root_dir = get_example_dir('namespace_package') iterator = FolderIO(root_dir).walk() root, folder_ios, file_ios = next(iterator) assert {f.path for f in folder_ios} == {join(root_dir, 'ns1'), join(root_dir, 'ns2')} for f in list(folder_ios): if f.path.endswith('ns1'): folder_ios.remove(f) root, folder_ios, file_ios = next(iterator) assert folder_ios assert root.path == join(root_dir, 'ns2') folder_ios.clear() assert next(iterator, None) is None def test_folder_io_walk2(): root_dir = get_example_dir('namespace_package') iterator = FolderIO(root_dir).walk() root, folder_ios, file_ios = next(iterator) folder_ios.clear() assert next(iterator, None) is None ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4743795 jedi-0.19.1/test/test_inference/0000775000175000017500000000000000000000000016354 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/test_inference/__init__.py0000664000175000017500000000000000000000000020453 0ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/test_inference/test_annotations.py0000664000175000017500000000237600000000000022332 0ustar00davedave00000000000000from textwrap import dedent import pytest def test_simple_annotations(Script, environment): """ Annotations only exist in Python 3. If annotations adhere to PEP-0484, we use them (they override inference), else they are parsed but ignored """ source = dedent("""\ def annot(a:3): return a annot('')""") assert [d.name for d in Script(source).infer()] == ['str'] source = dedent("""\ def annot_ret(a:3) -> 3: return a annot_ret('')""") assert [d.name for d in Script(source).infer()] == ['str'] source = dedent("""\ def annot(a:int): return a annot('')""") assert [d.name for d in Script(source).infer()] == ['int'] @pytest.mark.parametrize('reference', [ 'assert 1', '1', 'def x(): pass', '1, 2', r'1\n' ]) def test_illegal_forward_references(Script, environment, reference): source = 'def foo(bar: "%s"): bar' % reference assert not Script(source).infer() def test_lambda_forward_references(Script, environment): source = 'def foo(bar: "lambda: 3"): bar' # For now just receiving the 3 is ok. I'm doubting that this is what we # want. We also execute functions. Should we only execute classes? assert Script(source).infer() ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/test_inference/test_buildout_detection.py0000664000175000017500000000463400000000000023661 0ustar00davedave00000000000000import os from textwrap import dedent from pathlib import Path from jedi.inference.sys_path import _get_parent_dir_with_file, \ _get_buildout_script_paths, check_sys_path_modifications from ..helpers import get_example_dir def check_module_test(Script, code): module_context = Script(code)._get_module_context() return check_sys_path_modifications(module_context) def test_parent_dir_with_file(Script): path = Path(get_example_dir('buildout_project', 'src', 'proj_name')) parent = _get_parent_dir_with_file(path, 'buildout.cfg') assert parent is not None assert str(parent).endswith(os.path.join('test', 'examples', 'buildout_project')) def test_buildout_detection(Script): path = Path(get_example_dir('buildout_project', 'src', 'proj_name')) paths = list(_get_buildout_script_paths(path.joinpath('module_name.py'))) assert len(paths) == 1 appdir_path = os.path.normpath(os.path.join(path, '../../bin/app')) assert str(paths[0]) == appdir_path def test_append_on_non_sys_path(Script): code = dedent(""" class Dummy(object): path = [] d = Dummy() d.path.append('foo')""") paths = check_module_test(Script, code) assert not paths assert 'foo' not in paths def test_path_from_invalid_sys_path_assignment(Script): code = dedent(""" import sys sys.path = 'invalid'""") paths = check_module_test(Script, code) assert not paths assert 'invalid' not in paths def test_sys_path_with_modifications(Script): path = get_example_dir('buildout_project', 'src', 'proj_name', 'module_name.py') code = dedent(""" import os """) paths = Script(code, path=path)._inference_state.get_sys_path() assert os.path.abspath('/tmp/.buildout/eggs/important_package.egg') in paths def test_path_from_sys_path_assignment(Script): code = dedent(f""" #!/usr/bin/python import sys sys.path[0:0] = [ {os.path.abspath('/usr/lib/python3.8/site-packages')!r}, {os.path.abspath('/home/test/.buildout/eggs/important_package.egg')!r}, ] path[0:0] = [1] import important_package if __name__ == '__main__': sys.exit(important_package.main())""") paths = check_module_test(Script, code) assert 1 not in paths assert os.path.abspath('/home/test/.buildout/eggs/important_package.egg') \ in map(str, paths) ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/test_inference/test_compiled.py0000664000175000017500000001172400000000000021566 0ustar00davedave00000000000000from textwrap import dedent import sys import math from collections import Counter from datetime import datetime import pytest from jedi.inference import compiled from jedi.inference.compiled.access import DirectObjectAccess from jedi.inference.gradual.conversion import _stub_to_python_value_set from jedi.inference.syntax_tree import _infer_comparison_part def test_simple(inference_state, environment): obj = compiled.create_simple_object(inference_state, '_str_') upper, = obj.py__getattribute__('upper') objs = list(upper.execute_with_values()) assert len(objs) == 1 assert objs[0].name.string_name == 'str' def test_builtin_loading(inference_state): string, = inference_state.builtins_module.py__getattribute__('str') from_name, = string.py__getattribute__('__init__') assert from_name.tree_node assert not from_name.py__doc__() # It's a stub def test_next_docstr(inference_state, environment): if environment.version_info[:2] != sys.version_info[:2]: pytest.skip() next_ = compiled.builtin_from_name(inference_state, 'next') assert next_.tree_node is not None assert next_.py__doc__() == '' # It's a stub for non_stub in _stub_to_python_value_set(next_): assert non_stub.py__doc__() == next.__doc__ def test_parse_function_doc_illegal_docstr(): docstr = """ test_func(o doesn't have a closing bracket. """ assert ('', '') == compiled.value._parse_function_doc(docstr) def test_doc(inference_state): """ Even CompiledValue docs always return empty docstrings - not None, that's just a Jedi API definition. """ str_ = compiled.create_simple_object(inference_state, '') # Equals `''.__getnewargs__` obj, = str_.py__getattribute__('__getnewargs__') assert obj.py__doc__() == '' def test_string_literals(Script, environment): def typ(string): d = Script("a = %s; a" % string).infer()[0] return d.name assert typ('""') == 'str' assert typ('r""') == 'str' assert typ('br""') == 'bytes' assert typ('b""') == 'bytes' assert typ('u""') == 'str' def test_method_completion(Script, environment): code = dedent(''' class Foo: def bar(self): pass foo = Foo() foo.bar.__func__''') assert [c.name for c in Script(code).complete()] == ['__func__'] def test_time_docstring(Script): import time comp, = Script('import time\ntime.sleep').complete() assert comp.docstring(raw=True) == time.sleep.__doc__ expected = 'sleep(secs: float) -> None\n\n' + time.sleep.__doc__ assert comp.docstring() == expected def test_dict_values(Script, environment): assert Script('import sys\nsys.modules["alshdb;lasdhf"]').infer() def test_getitem_on_none(Script): script = Script('None[1j]') assert not script.infer() issue, = script._inference_state.analysis assert issue.name == 'type-error-not-subscriptable' def _return_int(): return 1 @pytest.mark.parametrize( 'attribute, expected_name, expected_parent', [ ('x', 'int', 'builtins'), ('y', 'int', 'builtins'), ('z', 'bool', 'builtins'), ('cos', 'cos', 'math'), ('dec', 'Decimal', 'decimal'), ('dt', 'datetime', 'datetime'), ('ret_int', '_return_int', 'test.test_inference.test_compiled'), ] ) def test_parent_context(same_process_inference_state, attribute, expected_name, expected_parent): import decimal class C: x = 1 y = int z = True cos = math.cos dec = decimal.Decimal(1) dt = datetime(2000, 1, 1) ret_int = _return_int o = compiled.CompiledValue( same_process_inference_state, DirectObjectAccess(same_process_inference_state, C) ) x, = o.py__getattribute__(attribute) assert x.py__name__() == expected_name module_name = x.parent_context.py__name__() assert module_name == expected_parent assert x.parent_context.parent_context is None @pytest.mark.parametrize( 'obj, expected_names', [ ('', ['str']), (str, ['str']), (''.upper, ['str', 'upper']), (str.upper, ['str', 'upper']), (math.cos, ['cos']), (Counter, ['Counter']), (Counter(""), ['Counter']), (Counter.most_common, ['Counter', 'most_common']), (Counter("").most_common, ['Counter', 'most_common']), ] ) def test_qualified_names(same_process_inference_state, obj, expected_names): o = compiled.CompiledValue( same_process_inference_state, DirectObjectAccess(same_process_inference_state, obj) ) assert o.get_qualified_names() == tuple(expected_names) def test_operation(Script, inference_state, create_compiled_object): b = create_compiled_object(bool) false, true = _infer_comparison_part( inference_state, b.parent_context, left=list(b.execute_with_values())[0], operator='is not', right=b, ) assert false.py__name__() == 'bool' assert true.py__name__() == 'bool' ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/test_inference/test_context.py0000664000175000017500000000115000000000000021446 0ustar00davedave00000000000000def test_module_attributes(Script): def_, = Script('__name__').complete() assert def_.name == '__name__' assert def_.line is None assert def_.column is None str_, = def_.infer() assert str_.name == 'str' def test_module__file__(Script, environment): assert not Script('__file__').infer() def_, = Script('__file__', path='example.py').infer() value = def_._name._value.get_safe_value() assert value.endswith('example.py') def_, = Script('import antigravity; antigravity.__file__').infer() value = def_._name._value.get_safe_value() assert value.endswith('.pyi') ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/test_inference/test_docstring.py0000664000175000017500000003131700000000000021766 0ustar00davedave00000000000000""" Testing of docstring related issues and especially ``jedi.docstrings``. """ import os from textwrap import dedent import pytest import jedi from ..helpers import test_dir try: import numpydoc # NOQA except ImportError: numpydoc_unavailable = True else: numpydoc_unavailable = False try: import numpy # NOQA except ImportError: numpy_unavailable = True else: numpy_unavailable = False def test_function_doc(Script): defs = Script(""" def func(): '''Docstring of `func`.''' func""").infer() assert defs[0].docstring() == 'func()\n\nDocstring of `func`.' def test_class_doc(Script): defs = Script(""" class TestClass(): '''Docstring of `TestClass`.''' TestClass""").infer() expected = 'Docstring of `TestClass`.' assert defs[0].docstring(raw=True) == expected assert defs[0].docstring() == 'TestClass()\n\n' + expected def test_class_doc_with_init(Script): d, = Script(""" class TestClass(): '''Docstring''' def __init__(self, foo, bar=3): pass TestClass""").infer() assert d.docstring() == 'TestClass(foo, bar=3)\n\nDocstring' def test_instance_doc(Script): defs = Script(""" class TestClass(): '''Docstring of `TestClass`.''' tc = TestClass() tc""").infer() assert defs[0].docstring() == 'Docstring of `TestClass`.' def test_multiple_docstrings(Script): d, = Script(""" def func(): '''Original docstring.''' x = func '''Docstring of `x`.''' x""").help() assert d.docstring() == 'Docstring of `x`.' def test_completion(Script): assert not Script(''' class DocstringCompletion(): #? [] """ asdfas """''').complete() def test_docstrings_type_dotted_import(Script): s = """ def func(arg): ''' :type arg: random.Random ''' arg.""" names = [c.name for c in Script(s).complete()] assert 'seed' in names def test_docstrings_param_type(Script): s = """ def func(arg): ''' :param str arg: some description ''' arg.""" names = [c.name for c in Script(s).complete()] assert 'join' in names def test_docstrings_type_str(Script): s = """ def func(arg): ''' :type arg: str ''' arg.""" names = [c.name for c in Script(s).complete()] assert 'join' in names def test_docstring_instance(Script): # The types hint that it's a certain kind s = dedent(""" class A: def __init__(self,a): ''' :type a: threading.Thread ''' if a is not None: a.start() self.a = a def method_b(c): ''' :type c: A ''' c.""") names = [c.name for c in Script(s).complete()] assert 'a' in names assert '__init__' in names assert 'mro' not in names # Exists only for types. def test_docstring_keyword(Script): completions = Script('assert').complete() assert 'assert' in completions[0].docstring() def test_docstring_params_formatting(Script): defs = Script(""" def func(param1, param2, param3): pass func""").infer() assert defs[0].docstring() == 'func(param1, param2, param3)' def test_import_function_docstring(Script): code = "from stub_folder import with_stub; with_stub.stub_function" path = os.path.join(test_dir, 'completion', 'import_function_docstring.py') c, = Script(code, path=path).complete() doc = 'stub_function(x: int, y: float) -> str\n\nPython docstring' assert c.docstring() == doc assert c.type == 'function' func, = c.goto(prefer_stubs=True) assert func.docstring() == doc func, = c.goto() assert func.docstring() == doc # ---- Numpy Style Tests --- @pytest.mark.skipif(numpydoc_unavailable, reason='numpydoc module is unavailable') def test_numpydoc_parameters(): s = dedent(''' def foobar(x, y): """ Parameters ---------- x : int y : str """ y.''') names = [c.name for c in jedi.Script(s).complete()] assert 'isupper' in names assert 'capitalize' in names @pytest.mark.skipif(numpydoc_unavailable, reason='numpydoc module is unavailable') def test_numpydoc_parameters_set_of_values(): s = dedent(''' def foobar(x, y): """ Parameters ---------- x : {'foo', 'bar', 100500}, optional """ x.''') names = [c.name for c in jedi.Script(s).complete()] assert 'isupper' in names assert 'capitalize' in names assert 'numerator' in names @pytest.mark.skipif(numpydoc_unavailable, reason='numpydoc module is unavailable') def test_numpydoc_parameters_set_single_value(): """ This is found in numpy masked-array I'm not too sure what this means but should not crash """ s = dedent(''' def foobar(x, y): """ Parameters ---------- x : {var}, optional """ x.''') names = [c.name for c in jedi.Script(s).complete()] # just don't crash assert names == [] @pytest.mark.skipif(numpydoc_unavailable, reason='numpydoc module is unavailable') def test_numpydoc_parameters_alternative_types(): s = dedent(''' def foobar(x, y): """ Parameters ---------- x : int or str or list """ x.''') names = [c.name for c in jedi.Script(s).complete()] assert 'isupper' in names assert 'capitalize' in names assert 'numerator' in names assert 'append' in names @pytest.mark.skipif(numpydoc_unavailable, reason='numpydoc module is unavailable') def test_numpydoc_invalid(): s = dedent(''' def foobar(x, y): """ Parameters ---------- x : int (str, py.path.local """ x.''') assert not jedi.Script(s).complete() @pytest.mark.skipif(numpydoc_unavailable, reason='numpydoc module is unavailable') def test_numpydoc_returns(): s = dedent(''' def foobar(): """ Returns ---------- x : int y : str """ return x def bazbiz(): z = foobar() z.''') names = [c.name for c in jedi.Script(s).complete()] assert 'isupper' in names assert 'capitalize' in names assert 'numerator' in names @pytest.mark.skipif(numpydoc_unavailable, reason='numpydoc module is unavailable') def test_numpydoc_returns_set_of_values(): s = dedent(''' def foobar(): """ Returns ---------- x : {'foo', 'bar', 100500} """ return x def bazbiz(): z = foobar() z.''') names = [c.name for c in jedi.Script(s).complete()] assert 'isupper' in names assert 'capitalize' in names assert 'numerator' in names @pytest.mark.skipif(numpydoc_unavailable, reason='numpydoc module is unavailable') def test_numpydoc_returns_alternative_types(): s = dedent(''' def foobar(): """ Returns ---------- int or list of str """ return x def bazbiz(): z = foobar() z.''') names = [c.name for c in jedi.Script(s).complete()] assert 'isupper' not in names assert 'capitalize' not in names assert 'numerator' in names assert 'append' in names @pytest.mark.skipif(numpydoc_unavailable, reason='numpydoc module is unavailable') def test_numpydoc_returns_list_of(): s = dedent(''' def foobar(): """ Returns ---------- list of str """ return x def bazbiz(): z = foobar() z.''') names = [c.name for c in jedi.Script(s).complete()] assert 'append' in names assert 'isupper' not in names assert 'capitalize' not in names @pytest.mark.skipif(numpydoc_unavailable, reason='numpydoc module is unavailable') def test_numpydoc_returns_obj(): s = dedent(''' def foobar(x, y): """ Returns ---------- int or random.Random """ return x + y def bazbiz(): z = foobar(x, y) z.''') script = jedi.Script(s) names = [c.name for c in script.complete()] assert 'numerator' in names assert 'seed' in names @pytest.mark.skipif(numpydoc_unavailable, reason='numpydoc module is unavailable') def test_numpydoc_yields(): s = dedent(''' def foobar(): """ Yields ---------- x : int y : str """ return x def bazbiz(): z = foobar(): z.''') names = [c.name for c in jedi.Script(s).complete()] assert 'isupper' in names assert 'capitalize' in names assert 'numerator' in names @pytest.mark.skipif(numpydoc_unavailable or numpy_unavailable, reason='numpydoc or numpy module is unavailable') def test_numpy_returns(): s = dedent(''' import numpy x = numpy.asarray([]) x.d''' ) names = [c.name for c in jedi.Script(s).complete()] assert 'diagonal' in names @pytest.mark.skipif(numpydoc_unavailable or numpy_unavailable, reason='numpydoc or numpy module is unavailable') def test_numpy_comp_returns(): s = dedent(''' import numpy x = numpy.array([]) x.d''' ) names = [c.name for c in jedi.Script(s).complete()] assert 'diagonal' in names def test_decorator(Script): code = dedent(''' def decorator(name=None): def _decorate(func): @wraps(func) def wrapper(*args, **kwargs): """wrapper docstring""" return func(*args, **kwargs) return wrapper return _decorate @decorator('testing') def check_user(f): """Nice docstring""" pass check_user''') d, = Script(code).infer() assert d.docstring(raw=True) == 'Nice docstring' def test_method_decorator(Script): code = dedent(''' def decorator(func): @wraps(func) def wrapper(*args, **kwargs): """wrapper docstring""" return func(*args, **kwargs) return wrapper class Foo(): @decorator def check_user(self, f): """Nice docstring""" pass Foo().check_user''') d, = Script(code).infer() assert d.docstring() == 'wrapper(f)\n\nNice docstring' def test_partial(Script): code = dedent(''' def foo(): 'x y z' from functools import partial x = partial(foo) x''') for p in Script(code).infer(): assert p.docstring(raw=True) == 'x y z' def test_basic_str_init_signature(Script, disable_typeshed): # See GH #1414 and GH #1426 code = dedent(''' class Foo(str): pass Foo(''') c, = Script(code).get_signatures() assert c.name == 'Foo' def test_doctest_result_completion(Script): code = '''\ """ comment >>> something = 3 somethi """ something_else = 8 ''' c1, c2 = Script(code).complete(line=5) assert c1.complete == 'ng' assert c2.complete == 'ng_else' def test_doctest_function_start(Script): code = dedent('''\ def test(a, b): """ From GH #1585 >>> a = {} >>> b = {} >>> get_remainder(a, b) == { ... "foo": 10, "bar": 7 ... } """ return ''') assert Script(code).complete(7, 8) @pytest.mark.parametrize( "name, docstring", [ ('prop1', 'Returns prop1.'), ('prop2', 'Returns None or ...'), ('prop3', 'Non-sense property.'), ('prop4', 'Django like property'), ] ) def test_property(name, docstring, goto_or_complete): code = dedent(''' from typing import Optional class Test: @property def prop1(self) -> int: """Returns prop1.""" @property def prop2(self) -> Optional[int]: """Returns None or ...""" @property def prop3(self) -> None: """Non-sense property.""" @cached_property # Not imported, but Jedi uses a heuristic def prop4(self) -> None: """Django like property""" ''') n, = goto_or_complete(code + 'Test().' + name) assert n.docstring() == docstring ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/test_inference/test_extension.py0000664000175000017500000000406700000000000022010 0ustar00davedave00000000000000""" Test compiled module """ import os import jedi from ..helpers import get_example_dir import pytest def test_completions(Script): s = Script('import _ctypes; _ctypes.') assert len(s.complete()) >= 15 def test_get_signatures_extension(Script, environment): if os.name == 'nt': func = 'LoadLibrary' else: func = 'dlopen' s = Script('import _ctypes; _ctypes.%s(' % (func,)) sigs = s.get_signatures() assert len(sigs) == 1 assert len(sigs[0].params) in (1, 2) def test_get_signatures_stdlib(Script): s = Script('import math; math.cos(') sigs = s.get_signatures() assert len(sigs) == 1 assert len(sigs[0].params) == 1 # Check only on linux 64 bit platform and Python3.8. @pytest.mark.parametrize('load_unsafe_extensions', [False, True]) @pytest.mark.skipif('sys.platform != "linux" or sys.maxsize <= 2**32 or sys.version_info[:2] != (3, 8)') def test_init_extension_module(Script, load_unsafe_extensions): """ ``__init__`` extension modules are also packages and Jedi should understand that. Originally coming from #472. This test was built by the module.c and setup.py combination you can find in the init_extension_module folder. You can easily build the `__init__.cpython-38m.so` by compiling it (create a virtualenv and run `setup.py install`. This is also why this test only runs on certain systems and Python 3.8. """ project = jedi.Project(get_example_dir(), load_unsafe_extensions=load_unsafe_extensions) s = jedi.Script( 'import init_extension_module as i\ni.', path='not_existing.py', project=project, ) if load_unsafe_extensions: assert 'foo' in [c.name for c in s.complete()] else: assert 'foo' not in [c.name for c in s.complete()] s = jedi.Script( 'from init_extension_module import foo\nfoo', path='not_existing.py', project=project, ) c, = s.complete() assert c.name == 'foo' if load_unsafe_extensions: assert c.infer() else: assert not c.infer() ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/test_inference/test_fstring.py0000664000175000017500000000034600000000000021444 0ustar00davedave00000000000000from textwrap import dedent def test_fstring_multiline(Script): code = dedent("""\ '' f'''s{ str.uppe ''' """) c, = Script(code).complete(line=2, column=9) assert c.name == 'upper' ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4743795 jedi-0.19.1/test/test_inference/test_gradual/0000775000175000017500000000000000000000000021032 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/test_inference/test_gradual/__init__.py0000664000175000017500000000000000000000000023131 0ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/test_inference/test_gradual/test_conversion.py0000664000175000017500000000544600000000000024641 0ustar00davedave00000000000000import os from parso.cache import parser_cache from test.helpers import root_dir from jedi.api.project import Project from jedi.inference.gradual.conversion import convert_names def test_sqlite3_conversion(Script): script1 = Script('import sqlite3; sqlite3.Connection') d, = script1.infer() assert not d.module_path assert d.full_name == 'sqlite3.Connection' assert convert_names([d._name], only_stubs=True) d, = script1.infer(only_stubs=True) assert d.is_stub() assert d.full_name == 'sqlite3.dbapi2.Connection' script2 = Script(path=d.module_path) d, = script2.infer(line=d.line, column=d.column) assert not d.is_stub() assert d.full_name == 'sqlite3.Connection' v, = d._name.infer() assert v.is_compiled() def test_conversion_of_stub_only(Script): project = Project(os.path.join(root_dir, 'test', 'completion', 'stub_folder')) code = 'import stub_only; stub_only.in_stub_only' d1, = Script(code, project=project).goto() assert d1.is_stub() script = Script(path=d1.module_path, project=project) d2, = script.goto(line=d1.line, column=d1.column) assert d2.is_stub() assert d2.module_path == d1.module_path assert d2.line == d1.line assert d2.column == d1.column assert d2.name == 'in_stub_only' def test_goto_on_file(Script): project = Project(os.path.join(root_dir, 'test', 'completion', 'stub_folder')) script = Script('import stub_only; stub_only.Foo', project=project) d1, = script.goto() v, = d1._name.infer() foo, bar, obj = v.py__mro__() assert foo.py__name__() == 'Foo' assert bar.py__name__() == 'Bar' assert obj.py__name__() == 'object' # Make sure we go to Bar, because Foo is a bit before: `class Foo(Bar):` script = Script(path=d1.module_path, project=project) d2, = script.goto(line=d1.line, column=d1.column + 4) assert d2.name == 'Bar' def test_goto_import(Script): code = 'from abc import ABC; ABC' d, = Script(code).goto(only_stubs=True) assert d.is_stub() d, = Script(code).goto() assert not d.is_stub() def test_stub_get_line_code(Script): code = 'from abc import ABC; ABC' script = Script(code) d, = script.goto(only_stubs=True) # Replace \r for tests on Windows assert d.get_line_code().replace('\r', '') == 'class ABC(metaclass=ABCMeta): ...\n' del parser_cache[script._inference_state.latest_grammar._hashed][d.module_path] d, = Script(path=d.module_path).goto(d.line, d.column, only_stubs=True) assert d.is_stub() assert d.get_line_code().replace('\r', '') == 'class ABC(metaclass=ABCMeta): ...\n' def test_os_stat_result(Script): d, = Script('import os; os.stat_result').goto() assert d.is_stub() n = d._name # This should not be a different stub name assert convert_names([n]) == [n] ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/test_inference/test_gradual/test_stub_loading.py0000664000175000017500000000550300000000000025120 0ustar00davedave00000000000000from functools import partial from test.helpers import get_example_dir from jedi.api.project import Project import pytest @pytest.fixture def ScriptInStubFolder(Script): path = get_example_dir('stub_packages') project = Project(path, sys_path=[path], smart_sys_path=False) return partial(Script, project=project) @pytest.mark.parametrize( ('code', 'expected'), [ ('from no_python import foo', ['int']), ('from with_python import stub_only', ['str']), ('from with_python import python_only', ['int']), ('from with_python import both', ['int']), ('from with_python import something_random', []), ('from with_python.module import in_sub_module', ['int']), ] ) def test_find_stubs_infer(ScriptInStubFolder, code, expected): defs = ScriptInStubFolder(code).infer() assert [d.name for d in defs] == expected func_without_stub_doc = 'func_without_stub(a)\n\nnostubdoc' func_with_stub_doc = 'func_with_stub(b: int) -> float\n\nwithstubdoc' @pytest.mark.parametrize( ('code', 'expected'), [ ('from with_python import stub_only', ''), ('from with_python import python_only', ''), ('from with_python import both', ''), ('import with_python; with_python.func_without_stub', ''), ('import with_python.module; with_python.module.func_without_stub', func_without_stub_doc), ('from with_python import module; module.func_without_stub', func_without_stub_doc), ('from with_python.module import func_without_stub', func_without_stub_doc), ('from with_python.module import func_without_stub as f; f', func_without_stub_doc), ('from with_python.module import func_without_stub; func_without_stub', func_without_stub_doc), ('from with_python import func_without_stub', ''), ('from with_python import func_without_stub as f; f', ''), ('from with_python import func_without_stub; func_without_stub', ''), ('import with_python; with_python.func_with_stub', func_with_stub_doc), ('import with_python.module; with_python.module.func_with_stub', func_with_stub_doc), ('from with_python import module; module.func_with_stub', func_with_stub_doc), ('from with_python.module import func_with_stub', func_with_stub_doc), ('from with_python.module import func_with_stub as f; f', func_with_stub_doc), ('from with_python.module import func_with_stub; func_with_stub', func_with_stub_doc), ('from with_python import func_with_stub', func_with_stub_doc), ('from with_python import func_with_stub as f; f', func_with_stub_doc), ('from with_python import func_with_stub; func_with_stub', func_with_stub_doc), ] ) def test_docstrings(ScriptInStubFolder, code, expected): d, = ScriptInStubFolder(code).help() assert d.docstring() == expected ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/test_inference/test_gradual/test_stubs.py0000664000175000017500000000677500000000000023622 0ustar00davedave00000000000000import os import pytest from jedi.api.project import Project from test.helpers import root_dir @pytest.mark.parametrize('type_', ['goto', 'infer']) @pytest.mark.parametrize('way', ['direct', 'indirect']) @pytest.mark.parametrize( 'kwargs', [ dict(only_stubs=False, prefer_stubs=False), dict(only_stubs=False, prefer_stubs=True), dict(only_stubs=True, prefer_stubs=False), ] ) @pytest.mark.parametrize( ('code', 'full_name', 'has_stub', 'has_python', 'options'), [ ['import os; os.walk', 'os.walk', True, True, {}], ['from collections import Counter', 'collections.Counter', True, True, {}], ['from collections', 'collections', True, True, {}], ['from collections import Counter; Counter', 'collections.Counter', True, True, {}], ['from collections import Counter; Counter()', 'collections.Counter', True, True, {}], ['from collections import Counter; Counter.most_common', 'collections.Counter.most_common', True, True, {}], ['from collections import deque', 'collections.deque', True, False, {'goto_has_python': True}], ['from keyword import kwlist; kwlist', 'typing.Sequence', True, True, {'goto_full_name': 'keyword.kwlist'}], ['from keyword import kwlist', 'typing.Sequence', True, True, {'goto_full_name': 'keyword.kwlist'}], ['from socket import AF_INET', 'socket.AddressFamily', True, False, {'goto_full_name': 'socket.AF_INET'}], ['from socket import socket', 'socket.socket', True, True, {}], ['import with_stub', 'with_stub', True, True, {}], ['import with_stub', 'with_stub', True, True, {}], ['import with_stub_folder.python_only', 'with_stub_folder.python_only', False, True, {}], ['import stub_only', 'stub_only', True, False, {}], ]) def test_infer_and_goto(Script, code, full_name, has_stub, has_python, way, kwargs, type_, options, environment): if type_ == 'infer' and full_name == 'typing.Sequence' and environment.version_info >= (3, 7): # In Python 3.7+ there's not really a sequence definition, there's just # a name that leads nowhere. has_python = False project = Project(os.path.join(root_dir, 'test', 'completion', 'stub_folder')) s = Script(code, project=project) prefer_stubs = kwargs['prefer_stubs'] only_stubs = kwargs['only_stubs'] if type_ == 'goto': full_name = options.get('goto_full_name', full_name) has_python = options.get('goto_has_python', has_python) if way == 'direct': if type_ == 'goto': defs = s.goto(follow_imports=True, **kwargs) else: defs = s.infer(**kwargs) else: goto_defs = s.goto( # Prefering stubs when we want to go to python and vice versa prefer_stubs=not (prefer_stubs or only_stubs), follow_imports=True, ) if type_ == 'goto': defs = [d for goto_def in goto_defs for d in goto_def.goto(**kwargs)] else: defs = [d for goto_def in goto_defs for d in goto_def.infer(**kwargs)] if not has_stub and only_stubs: assert not defs else: assert defs for d in defs: if prefer_stubs and has_stub: assert d.is_stub() elif only_stubs: assert d.is_stub() else: assert has_python == (not d.is_stub()) assert d.full_name == full_name assert d.is_stub() == (d.module_path.suffix == '.pyi') ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/test_inference/test_gradual/test_typeshed.py0000664000175000017500000001670500000000000024301 0ustar00davedave00000000000000import os import pytest from parso.utils import PythonVersionInfo from jedi.inference.gradual import typeshed from jedi.inference.value import TreeInstance, BoundMethod, FunctionValue, \ MethodValue, ClassValue from jedi.inference.names import StubName TYPESHED_PYTHON3 = os.path.join(typeshed.TYPESHED_PATH, 'stdlib', '3') def test_get_typeshed_directories(): def get_dirs(version_info): return { p.path.replace(str(typeshed.TYPESHED_PATH), '').lstrip(os.path.sep) for p in typeshed._get_typeshed_directories(version_info) } def transform(set_): return {x.replace('/', os.path.sep) for x in set_} dirs = get_dirs(PythonVersionInfo(3, 7)) assert dirs == transform({'stdlib/2and3', 'stdlib/3', 'stdlib/3.7', 'third_party/2and3', 'third_party/3', 'third_party/3.7'}) def test_get_stub_files(): map_ = typeshed._create_stub_map(typeshed.PathInfo(TYPESHED_PYTHON3, is_third_party=False)) assert map_['functools'].path == os.path.join(TYPESHED_PYTHON3, 'functools.pyi') def test_function(Script, environment): code = 'import threading; threading.current_thread' def_, = Script(code).infer() value = def_._name._value assert isinstance(value, FunctionValue), value def_, = Script(code + '()').infer() value = def_._name._value assert isinstance(value, TreeInstance) def_, = Script('import threading; threading.Thread').infer() assert isinstance(def_._name._value, ClassValue), def_ def test_keywords_variable(Script): code = 'import keyword; keyword.kwlist' for seq in Script(code).infer(): assert seq.name == 'Sequence' # This points towards the typeshed implementation stub_seq, = seq.goto(only_stubs=True) assert str(stub_seq.module_path).startswith(str(typeshed.TYPESHED_PATH)) def test_class(Script): def_, = Script('import threading; threading.Thread').infer() value = def_._name._value assert isinstance(value, ClassValue), value def test_instance(Script): def_, = Script('import threading; threading.Thread()').infer() value = def_._name._value assert isinstance(value, TreeInstance) def test_class_function(Script): def_, = Script('import threading; threading.Thread.getName').infer() value = def_._name._value assert isinstance(value, MethodValue), value def test_method(Script): code = 'import threading; threading.Thread().getName' def_, = Script(code).infer() value = def_._name._value assert isinstance(value, BoundMethod), value assert isinstance(value._wrapped_value, MethodValue), value def_, = Script(code + '()').infer() value = def_._name._value assert isinstance(value, TreeInstance) assert value.class_value.py__name__() == 'str' def test_sys_exc_info(Script): code = 'import sys; sys.exc_info()' none, def_ = Script(code + '[1]').infer() # It's an optional. assert def_.name == 'BaseException' assert def_.module_path == typeshed.TYPESHED_PATH.joinpath( 'stdlib', '3', 'builtins.pyi' ) assert def_.type == 'instance' assert none.name == 'NoneType' assert none.module_path is None none, def_ = Script(code + '[0]').infer() assert def_.name == 'BaseException' assert def_.type == 'class' def test_sys_getwindowsversion(Script, environment): # This should only exist on Windows, but type inference should happen # everywhere. definitions = Script('import sys; sys.getwindowsversion().major').infer() def_, = definitions assert def_.name == 'int' def test_sys_hexversion(Script): script = Script('import sys; sys.hexversion') def_, = script.complete() assert isinstance(def_._name, StubName), def_._name assert str(def_.module_path).startswith(str(typeshed.TYPESHED_PATH)) def_, = script.infer() assert def_.name == 'int' def test_math(Script): def_, = Script('import math; math.acos()').infer() assert def_.name == 'float' value = def_._name._value assert value def test_type_var(Script): def_, = Script('import typing; T = typing.TypeVar("T1")').infer() assert def_.name == 'TypeVar' assert def_.description == 'class TypeVar' @pytest.mark.parametrize( 'code, full_name', ( ('import math', 'math'), ('from math import cos', 'math.cos') ) ) def test_math_is_stub(Script, code, full_name): s = Script(code) cos, = s.infer() wanted = ('typeshed', 'stdlib', '2and3', 'math.pyi') assert cos.module_path.parts[-4:] == wanted assert cos.is_stub() is True assert cos.goto(only_stubs=True) == [cos] assert cos.full_name == full_name cos, = s.goto() assert cos.module_path.parts[-4:] == wanted assert cos.goto(only_stubs=True) == [cos] assert cos.is_stub() is True assert cos.full_name == full_name def test_goto_stubs(Script): s = Script('import os; os') os_module, = s.infer() assert os_module.full_name == 'os' assert os_module.is_stub() is False stub, = os_module.goto(only_stubs=True) assert stub.is_stub() is True os_module, = s.goto() def _assert_is_same(d1, d2): assert d1.name == d2.name assert d1.module_path == d2.module_path assert d1.line == d2.line assert d1.column == d2.column @pytest.mark.parametrize('type_', ['goto', 'infer']) @pytest.mark.parametrize( 'code', [ 'import os; os.walk', 'from collections import Counter; Counter', 'from collections import Counter; Counter()', 'from collections import Counter; Counter.most_common', 'from collections import Counter; Counter().most_common', ]) def test_goto_stubs_on_itself(Script, code, type_): """ If goto_stubs is used on an identifier in e.g. the stdlib, we should goto the stub of it. """ s = Script(code) if type_ == 'infer': def_, = s.infer() else: def_, = s.goto(follow_imports=True) stub, = def_.goto(only_stubs=True) script_on_source = Script(path=def_.module_path) if type_ == 'infer': definition, = script_on_source.infer(def_.line, def_.column) else: definition, = script_on_source.goto(def_.line, def_.column) same_stub, = definition.goto(only_stubs=True) _assert_is_same(same_stub, stub) _assert_is_same(definition, def_) assert same_stub.module_path != def_.module_path # And the reverse. script_on_stub = Script( path=same_stub.module_path, ) if type_ == 'infer': same_definition, = script_on_stub.infer(same_stub.line, same_stub.column) same_definition2, = same_stub.infer() else: same_definition, = script_on_stub.goto(same_stub.line, same_stub.column) same_definition2, = same_stub.goto() _assert_is_same(same_definition, definition) _assert_is_same(same_definition, same_definition2) def test_module_exists_only_as_stub(Script): try: import redis except ImportError: pass else: pytest.skip('redis is already installed, it should only exist as a stub for this test') redis_path = os.path.join(typeshed.TYPESHED_PATH, 'third_party', '2and3', 'redis') assert os.path.isdir(redis_path) assert not Script('import redis').infer() def test_django_exists_only_as_stub(Script): try: import django except ImportError: pass else: pytest.skip('django is already installed, it should only exist as a stub for this test') assert not Script('import django').infer() ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/test_inference/test_implicit_namespace_package.py0000664000175000017500000000715200000000000025273 0ustar00davedave00000000000000from test.helpers import get_example_dir, example_dir from jedi import Project def test_implicit_namespace_package(Script): sys_path = [get_example_dir('implicit_namespace_package', 'ns1'), get_example_dir('implicit_namespace_package', 'ns2')] project = Project('.', sys_path=sys_path) def script_with_path(*args, **kwargs): return Script(project=project, *args, **kwargs) # goto definition assert script_with_path('from pkg import ns1_file').infer() assert script_with_path('from pkg import ns2_file').infer() assert not script_with_path('from pkg import ns3_file').infer() # goto assignment tests = { 'from pkg.ns2_file import foo': 'ns2_file!', 'from pkg.ns1_file import foo': 'ns1_file!', } for source, solution in tests.items(): ass = script_with_path(source).goto() assert len(ass) == 1 assert ass[0].description == "foo = '%s'" % solution # completion completions = script_with_path('from pkg import ').complete() names = [c.name for c in completions] compare = ['ns1_file', 'ns2_file'] # must at least contain these items, other items are not important assert set(compare) == set(names) tests = { 'from pkg import ns2_file as x': 'ns2_file!', 'from pkg import ns1_file as x': 'ns1_file!' } for source, solution in tests.items(): for c in script_with_path(source + '; x.').complete(): if c.name == 'foo': completion = c solution = "foo = '%s'" % solution assert completion.description == solution c, = script_with_path('import pkg').complete() assert c.docstring() == "" def test_implicit_nested_namespace_package(Script): code = 'from implicit_nested_namespaces.namespace.pkg.module import CONST' project = Project('.', sys_path=[example_dir]) script = Script(code, project=project) result = script.infer(line=1, column=61) assert len(result) == 1 implicit_pkg, = Script(code, project=project).infer(column=10) assert implicit_pkg.type == 'namespace' assert implicit_pkg.module_path is None def test_implicit_namespace_package_import_autocomplete(Script): code = 'from implicit_name' project = Project('.', sys_path=[example_dir]) script = Script(code, project=project) compl = script.complete() assert [c.name for c in compl] == ['implicit_namespace_package'] def test_namespace_package_in_multiple_directories_autocompletion(Script): code = 'from pkg.' sys_path = [get_example_dir('implicit_namespace_package', 'ns1'), get_example_dir('implicit_namespace_package', 'ns2')] project = Project('.', sys_path=sys_path) script = Script(code, project=project) compl = script.complete() assert set(c.name for c in compl) == set(['ns1_file', 'ns2_file']) def test_namespace_package_in_multiple_directories_goto_definition(Script): code = 'from pkg import ns1_file' sys_path = [get_example_dir('implicit_namespace_package', 'ns1'), get_example_dir('implicit_namespace_package', 'ns2')] project = Project('.', sys_path=sys_path) script = Script(code, project=project) result = script.infer() assert len(result) == 1 def test_namespace_name_autocompletion_full_name(Script): code = 'from pk' sys_path = [get_example_dir('implicit_namespace_package', 'ns1'), get_example_dir('implicit_namespace_package', 'ns2')] project = Project('.', sys_path=sys_path) script = Script(code, project=project) compl = script.complete() assert set(c.full_name for c in compl) == set(['pkg']) ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/test_inference/test_imports.py0000664000175000017500000004431300000000000021467 0ustar00davedave00000000000000""" Tests of various import related things that could not be tested with "Black Box Tests". """ import os from pathlib import Path import pytest import jedi from jedi.file_io import FileIO from jedi.inference import compiled from jedi.inference import imports from jedi.api.project import Project from jedi.inference.gradual.conversion import _stub_to_python_value_set from jedi.inference.references import get_module_contexts_containing_name from ..helpers import get_example_dir, test_dir, test_dir_project, root_dir from jedi.inference.compiled.subprocess.functions import _find_module_py33, _find_module THIS_DIR = os.path.dirname(__file__) def test_find_module_basic(): """Needs to work like the old find_module.""" assert _find_module_py33('_io') == (None, False) with pytest.raises(ImportError): assert _find_module_py33('_DOESNTEXIST_') == (None, None) def test_find_module_package(): file_io, is_package = _find_module('json') assert file_io.path.parts[-2:] == ('json', '__init__.py') assert is_package is True def test_find_module_not_package(): file_io, is_package = _find_module('io') assert file_io.path.name == 'io.py' assert is_package is False pkg_zip_path = Path(get_example_dir('zipped_imports', 'pkg.zip')) def test_find_module_package_zipped(Script, inference_state, environment): sys_path = environment.get_sys_path() + [str(pkg_zip_path)] project = Project('.', sys_path=sys_path) script = Script('import pkg; pkg.mod', project=project) assert len(script.complete()) == 1 file_io, is_package = inference_state.compiled_subprocess.get_module_info( sys_path=sys_path, string='pkg', full_name='pkg' ) assert file_io is not None assert file_io.path.parts[-3:] == ('pkg.zip', 'pkg', '__init__.py') assert file_io._zip_path.name == 'pkg.zip' assert is_package is True @pytest.mark.parametrize( 'code, file, package, path', [ ('import pkg', '__init__.py', 'pkg', 'pkg'), ('import pkg', '__init__.py', 'pkg', 'pkg'), ('from pkg import module', 'module.py', 'pkg', None), ('from pkg.module', 'module.py', 'pkg', None), ('from pkg import nested', os.path.join('nested', '__init__.py'), 'pkg.nested', os.path.join('pkg', 'nested')), ('from pkg.nested', os.path.join('nested', '__init__.py'), 'pkg.nested', os.path.join('pkg', 'nested')), ('from pkg.nested import nested_module', os.path.join('nested', 'nested_module.py'), 'pkg.nested', None), ('from pkg.nested.nested_module', os.path.join('nested', 'nested_module.py'), 'pkg.nested', None), ('from pkg.namespace import namespace_module', os.path.join('namespace', 'namespace_module.py'), 'pkg.namespace', None), ('from pkg.namespace.namespace_module', os.path.join('namespace', 'namespace_module.py'), 'pkg.namespace', None), ] ) def test_correct_zip_package_behavior(Script, inference_state, environment, code, file, package, path): sys_path = environment.get_sys_path() + [str(pkg_zip_path)] pkg, = Script(code, project=Project('.', sys_path=sys_path)).infer() value, = pkg._name.infer() assert value.py__file__() == pkg_zip_path.joinpath('pkg', file) assert '.'.join(value.py__package__()) == package assert value.is_package() is (path is not None) if path is not None: assert value.py__path__() == [str(pkg_zip_path.joinpath(path))] value.string_names = None assert value.py__package__() == [] @pytest.mark.parametrize("code,names", [ ("from pkg.", {"module", "nested", "namespace"}), ("from pkg.nested.", {"nested_module"}) ]) def test_zip_package_import_complete(Script, environment, code, names): sys_path = environment.get_sys_path() + [str(pkg_zip_path)] completions = Script(code, project=Project('.', sys_path=sys_path)).complete() assert names == {c.name for c in completions} def test_find_module_not_package_zipped(Script, inference_state, environment): path = get_example_dir('zipped_imports', 'not_pkg.zip') sys_path = environment.get_sys_path() + [path] script = Script('import not_pkg; not_pkg.val', project=Project('.', sys_path=sys_path)) assert len(script.complete()) == 1 file_io, is_package = inference_state.compiled_subprocess.get_module_info( sys_path=map(str, sys_path), string='not_pkg', full_name='not_pkg' ) assert file_io.path.parts[-2:] == ('not_pkg.zip', 'not_pkg.py') assert is_package is False def test_import_not_in_sys_path(Script, environment): """ non-direct imports (not in sys.path) This is in the end just a fallback. """ path = get_example_dir() module_path = os.path.join(path, 'not_in_sys_path', 'pkg', 'module.py') # This project tests the smart path option of Project. The sys_path is # explicitly given to make sure that the path is just dumb and only # includes non-folder dependencies. project = Project(path, sys_path=environment.get_sys_path()) a = Script(path=module_path, project=project).infer(line=5) assert a[0].name == 'int' a = Script(path=module_path, project=project).infer(line=6) assert a[0].name == 'str' a = Script(path=module_path, project=project).infer(line=7) assert a[0].name == 'str' @pytest.mark.parametrize("code,name", [ ("from flask.ext import foo; foo.", "Foo"), # flask_foo.py ("from flask.ext import bar; bar.", "Bar"), # flaskext/bar.py ("from flask.ext import baz; baz.", "Baz"), # flask_baz/__init__.py ("from flask.ext import moo; moo.", "Moo"), # flaskext/moo/__init__.py ("from flask.ext.", "foo"), ("from flask.ext.", "bar"), ("from flask.ext.", "baz"), ("from flask.ext.", "moo"), pytest.param("import flask.ext.foo; flask.ext.foo.", "Foo", marks=pytest.mark.xfail), pytest.param("import flask.ext.bar; flask.ext.bar.", "Foo", marks=pytest.mark.xfail), pytest.param("import flask.ext.baz; flask.ext.baz.", "Foo", marks=pytest.mark.xfail), pytest.param("import flask.ext.moo; flask.ext.moo.", "Foo", marks=pytest.mark.xfail), ]) def test_flask_ext(Script, code, name): """flask.ext.foo is really imported from flaskext.foo or flask_foo. """ path = get_example_dir('flask-site-packages') completions = Script(code, project=Project('.', sys_path=[path])).complete() assert name in [c.name for c in completions] def test_not_importable_file(Script): src = 'import not_importable_file as x; x.' assert not Script(src, path='example.py', project=test_dir_project).complete() def test_import_unique(Script): src = "import os; os.path" defs = Script(src, path='example.py').infer() parent_contexts = [d._name._value for d in defs] assert len(parent_contexts) == len(set(parent_contexts)) def test_cache_works_with_sys_path_param(Script, tmpdir): foo_path = tmpdir.join('foo') bar_path = tmpdir.join('bar') foo_path.join('module.py').write('foo = 123', ensure=True) bar_path.join('module.py').write('bar = 123', ensure=True) foo_completions = Script( 'import module; module.', project=Project('.', sys_path=[foo_path.strpath]), ).complete() bar_completions = Script( 'import module; module.', project=Project('.', sys_path=[bar_path.strpath]), ).complete() assert 'foo' in [c.name for c in foo_completions] assert 'bar' not in [c.name for c in foo_completions] assert 'bar' in [c.name for c in bar_completions] assert 'foo' not in [c.name for c in bar_completions] def test_import_completion_docstring(Script): import abc s = Script('"""test"""\nimport ab') abc_completions = [c for c in s.complete() if c.name == 'abc'] assert len(abc_completions) == 1 assert abc_completions[0].docstring(fast=False) == abc.__doc__ # However for performance reasons not all modules are loaded and the # docstring is empty in this case. assert abc_completions[0].docstring() == '' def test_goto_definition_on_import(Script): assert Script("import sys_blabla").infer(1, 8) == [] assert len(Script("import sys").infer(1, 8)) == 1 def test_complete_on_empty_import(ScriptWithProject): path = os.path.join(test_dir, 'whatever.py') assert ScriptWithProject("from datetime import").complete()[0].name == 'import' # should just list the files in the directory assert 10 < len(ScriptWithProject("from .", path=path).complete()) < 30 # Global import assert len(ScriptWithProject("from . import", path=path).complete(1, 5)) > 30 # relative import assert 10 < len(ScriptWithProject("from . import", path=path).complete(1, 6)) < 30 # Global import assert len(ScriptWithProject("from . import classes", path=path).complete(1, 5)) > 30 # relative import assert 10 < len(ScriptWithProject("from . import classes", path=path).complete(1, 6)) < 30 wanted = {'ImportError', 'import', 'ImportWarning'} assert {c.name for c in ScriptWithProject("import").complete()} == wanted assert len(ScriptWithProject("import import", path=path).complete()) > 0 # 111 assert ScriptWithProject("from datetime import").complete()[0].name == 'import' assert ScriptWithProject("from datetime import ").complete() def test_imports_on_global_namespace_without_path(Script): """If the path is None, there shouldn't be any import problem""" completions = Script("import operator").complete() assert [c.name for c in completions] == ['operator'] completions = Script("import operator", path='example.py').complete() assert [c.name for c in completions] == ['operator'] # the first one has a path the second doesn't completions = Script("import keyword", path='example.py').complete() assert [c.name for c in completions] == ['keyword'] completions = Script("import keyword").complete() assert [c.name for c in completions] == ['keyword'] def test_named_import(Script): """named import - jedi-vim issue #8""" s = "import time as dt" assert len(Script(s, path='/').infer(1, 15)) == 1 assert len(Script(s, path='/').infer(1, 10)) == 1 def test_nested_import(Script): s = "import multiprocessing.dummy; multiprocessing.dummy" g = Script(s).goto() assert len(g) == 1 assert (g[0].line, g[0].column) != (0, 0) def test_goto(Script): sys, = Script("import sys").goto(follow_imports=True) assert sys.type == 'module' def test_os_after_from(Script): def check(source, result, column=None): completions = Script(source).complete(column=column) assert [c.name for c in completions] == result check('\nfrom os. ', ['path']) check('\nfrom os ', ['import']) check('from os ', ['import']) check('\nfrom os import whatever', ['import'], len('from os im')) check('from os\\\n', ['import']) check('from os \\\n', ['import']) def test_os_issues(Script): def import_names(*args, **kwargs): return [d.name for d in Script(*args).complete(**kwargs)] # Github issue #759 s = 'import os, s' assert 'sys' in import_names(s) assert 'os' in import_names(s, column=len(s) - 3) # Some more checks s = 'from os import path, e' assert 'environ' in import_names(s) assert 'json' not in import_names(s, column=len(s) - 1) assert 'environ' in import_names(s, column=len(s) - 1) assert 'path' in import_names(s, column=len(s) - 3) def test_path_issues(Script): """ See pull request #684 for details. """ source = '''from datetime import ''' assert Script(source).complete() def test_compiled_import_none(monkeypatch, Script): """ Related to #1079. An import might somehow fail and return None. """ script = Script('import sys') monkeypatch.setattr(compiled, 'load_module', lambda *args, **kwargs: None) def_, = script.infer() assert def_.type == 'module' value, = def_._name.infer() assert not _stub_to_python_value_set(value) @pytest.mark.parametrize( ('path', 'is_package', 'goal'), [ # Both of these tests used to return relative paths to the module # context that was initially given, but now we just work with the file # system. (os.path.join(THIS_DIR, 'test_docstring.py'), False, ('test_inference', 'test_imports')), (os.path.join(THIS_DIR, '__init__.py'), True, ('test_inference', 'test_imports')), ] ) def test_get_modules_containing_name(inference_state, path, goal, is_package): inference_state.project = Project(test_dir) module = imports._load_python_module( inference_state, FileIO(path), import_names=('ok', 'lala', 'x'), is_package=is_package, ) assert module module_context = module.as_context() input_module, found_module = get_module_contexts_containing_name( inference_state, [module_context], 'string_that_only_exists_here' ) assert input_module is module_context assert found_module.string_names == goal @pytest.mark.parametrize( 'path', ('api/whatever/test_this.py', 'api/whatever/file')) @pytest.mark.parametrize('empty_sys_path', (False, True)) def test_relative_imports_with_multiple_similar_directories(Script, path, empty_sys_path): dir = get_example_dir('issue1209') if empty_sys_path: project = Project(dir, sys_path=(), smart_sys_path=False) else: project = Project(dir) script = Script( "from . ", path=os.path.join(dir, path), project=project, ) name, import_ = script.complete() assert import_.name == 'import' assert name.name == 'api_test1' def test_relative_imports_with_outside_paths(Script): dir = get_example_dir('issue1209') project = Project(dir, sys_path=[], smart_sys_path=False) script = Script( "from ...", path=os.path.join(dir, 'api/whatever/test_this.py'), project=project, ) assert [c.name for c in script.complete()] == ['api', 'whatever'] script = Script( "from " + '.' * 100, path=os.path.join(dir, 'api/whatever/test_this.py'), project=project, ) assert not script.complete() def test_relative_imports_without_path(Script): path = get_example_dir('issue1209', 'api', 'whatever') project = Project(path, sys_path=[], smart_sys_path=False) script = Script("from . ", project=project) assert [c.name for c in script.complete()] == ['api_test1', 'import'] script = Script("from .. ", project=project) assert [c.name for c in script.complete()] == ['import', 'whatever'] script = Script("from ... ", project=project) assert [c.name for c in script.complete()] == ['api', 'import', 'whatever'] def test_relative_import_out_of_file_system(Script): code = "from " + '.' * 100 assert not Script(code).complete() script = Script(code + ' ') import_, = script.complete() assert import_.name == 'import' script = Script("from " + '.' * 100 + 'abc import ABCMeta') assert not script.infer() assert not script.complete() @pytest.mark.parametrize( 'level, directory, project_path, result', [ (1, '/a/b/c', '/a', (['b', 'c'], '/a')), (2, '/a/b/c', '/a', (['b'], '/a')), (3, '/a/b/c', '/a', ([], '/a')), (4, '/a/b/c', '/a', (None, '/')), (5, '/a/b/c', '/a', (None, None)), (1, '/', '/', ([], '/')), (2, '/', '/', (None, None)), (1, '/a/b', '/a/b/c', (None, '/a/b')), (2, '/a/b', '/a/b/c', (None, '/a')), (3, '/a/b', '/a/b/c', (None, '/')), ] ) def test_level_to_import_path(level, directory, project_path, result): assert imports._level_to_base_import_path(project_path, directory, level) == result def test_import_name_calculation(Script): s = Script(path=os.path.join(test_dir, 'completion', 'isinstance.py')) m = s._get_module_context() assert m.string_names == ('test', 'completion', 'isinstance') @pytest.mark.parametrize('name', ('builtins', 'typing')) def test_pre_defined_imports_module(Script, environment, name): path = os.path.join(root_dir, name + '.py') module = Script('', path=path)._get_module_context() assert module.string_names == (name,) assert str(module.inference_state.builtins_module.py__file__()) != path assert str(module.inference_state.typing_module.py__file__()) != path @pytest.mark.parametrize('name', ('builtins', 'typing')) def test_import_needed_modules_by_jedi(Script, environment, tmpdir, name): module_path = tmpdir.join(name + '.py') module_path.write('int = ...') script = Script( 'import ' + name, path=tmpdir.join('something.py').strpath, project=Project('.', sys_path=[tmpdir.strpath] + environment.get_sys_path()), ) module, = script.infer() assert str(module._inference_state.builtins_module.py__file__()) != module_path assert str(module._inference_state.typing_module.py__file__()) != module_path def test_import_with_semicolon(Script): names = [c.name for c in Script('xzy; from abc import ').complete()] assert 'ABCMeta' in names assert 'abc' not in names def test_relative_import_star(Script): # Coming from github #1235 source = """ from . import * furl.c """ script = Script(source, path='export.py') assert script.complete(3, len("furl.c")) @pytest.mark.parametrize('with_init', [False, True]) def test_relative_imports_without_path_and_setup_py( Script, inference_state, environment, tmpdir, with_init): # Contrary to other tests here we create a temporary folder that is not # part of a folder with a setup.py that signifies tmpdir.join('file1.py').write('do_foo = 1') other_path = tmpdir.join('other_files') other_path.join('file2.py').write('def do_nothing():\n pass', ensure=True) if with_init: other_path.join('__init__.py').write('') for name, code in [('file2', 'from . import file2'), ('file1', 'from .. import file1')]: for func in (jedi.Script.goto, jedi.Script.infer): n, = func(Script(code, path=other_path.join('test1.py').strpath)) assert n.name == name assert n.type == 'module' assert n.line == 1 def test_import_recursion(Script): path = get_example_dir('import-recursion', "cq_example.py") for c in Script(path=path).complete(3, 3): c.docstring() ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/test_inference/test_literals.py0000664000175000017500000000231500000000000021605 0ustar00davedave00000000000000import pytest from jedi.inference.value import TreeInstance def _infer_literal(Script, code, is_fstring=False): def_, = Script(code).infer() if is_fstring: assert def_.name == 'str' assert isinstance(def_._name._value, TreeInstance) return '' else: return def_._name._value.get_safe_value() def test_f_strings(Script): """ f literals are not really supported in Jedi. They just get ignored and an empty string is returned. """ assert _infer_literal(Script, 'f"asdf"', is_fstring=True) == '' assert _infer_literal(Script, 'f"{asdf} "', is_fstring=True) == '' assert _infer_literal(Script, 'F"{asdf} "', is_fstring=True) == '' assert _infer_literal(Script, 'rF"{asdf} "', is_fstring=True) == '' def test_rb_strings(Script): assert _infer_literal(Script, 'x = br"asdf"; x') == b'asdf' assert _infer_literal(Script, 'x = rb"asdf"; x') == b'asdf' def test_thousand_separators(Script): assert _infer_literal(Script, '1_2_3') == 123 assert _infer_literal(Script, '123_456_789') == 123456789 assert _infer_literal(Script, '0x3_4') == 52 assert _infer_literal(Script, '0b1_0') == 2 assert _infer_literal(Script, '0o1_0') == 8 ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/test_inference/test_mixed.py0000664000175000017500000000547200000000000021103 0ustar00davedave00000000000000from typing import Generic, TypeVar, List import pytest import jedi from jedi.inference.value import ModuleValue def interpreter(code, namespace, *args, **kwargs): return jedi.Interpreter(code, [namespace], *args, **kwargs) def test_on_code(): from functools import wraps i = interpreter("wraps.__code__", {'wraps': wraps}) assert i.infer() def test_generics_without_definition(): # Used to raise a recursion error T = TypeVar('T') class Stack(Generic[T]): def __init__(self): self.items = [] # type: List[T] def push(self, item): self.items.append(item) def pop(self): # type: () -> T return self.items.pop() class StackWrapper(): def __init__(self): self.stack = Stack() self.stack.push(1) s = StackWrapper() assert not interpreter('s.stack.pop().', locals()).complete() @pytest.mark.parametrize( 'code, expected', [ ('Foo().method()', 'str'), ('Foo.method()', 'str'), ('foo.method()', 'str'), ('Foo().read()', 'str'), ('Foo.read()', 'str'), ('foo.read()', 'str'), ] ) def test_generics_methods(code, expected, class_findable): T = TypeVar("T") class Reader(Generic[T]): @classmethod def read(cls) -> T: return cls() def method(self) -> T: return 1 class Foo(Reader[str]): def transform(self) -> int: return 42 foo = Foo() defs = jedi.Interpreter(code, [locals()]).infer() if class_findable: def_, = defs assert def_.name == expected else: assert not defs def test_mixed_module_cache(): """Caused by #1479""" interpreter = jedi.Interpreter('jedi', [{'jedi': jedi}]) d, = interpreter.infer() assert d.name == 'jedi' inference_state = interpreter._inference_state jedi_module, = inference_state.module_cache.get(('jedi',)) assert isinstance(jedi_module, ModuleValue) def test_signature(): """ For performance reasons we use the signature of the compiled object and not the tree object. """ def some_signature(foo): pass from inspect import Signature, Parameter some_signature.__signature__ = Signature([ Parameter('bar', kind=Parameter.KEYWORD_ONLY, default=1) ]) s, = jedi.Interpreter('some_signature', [locals()]).goto() assert s.docstring() == 'some_signature(*, bar=1)' def test_compiled_signature_annotation_string(): import typing def func(x: typing.Type, y: typing.Union[typing.Type, int]): pass func.__name__ = 'not_func' s, = jedi.Interpreter('func()', [locals()]).get_signatures(1, 5) assert s.params[0].description == 'param x: Type' assert s.params[1].description == 'param y: Union[Type, int]' ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/test_inference/test_namespace_package.py0000664000175000017500000000614500000000000023402 0ustar00davedave00000000000000from os.path import join import pytest import py from ..helpers import get_example_dir, example_dir from jedi import Project SYS_PATH = [get_example_dir('namespace_package', 'ns1'), get_example_dir('namespace_package', 'ns2')] def script_with_path(Script, *args, **kwargs): return Script(project=Project('.', sys_path=SYS_PATH), *args, **kwargs) def test_goto_definition(Script): assert script_with_path(Script, 'from pkg import ns1_file').infer() assert script_with_path(Script, 'from pkg import ns2_file').infer() assert not script_with_path(Script, 'from pkg import ns3_file').infer() @pytest.mark.parametrize( ('source', 'solution'), [ ('from pkg.ns2_folder.nested import foo', 'nested!'), ('from pkg.ns2_folder import foo', 'ns2_folder!'), ('from pkg.ns2_file import foo', 'ns2_file!'), ('from pkg.ns1_folder import foo', 'ns1_folder!'), ('from pkg.ns1_file import foo', 'ns1_file!'), ('from pkg import foo', 'ns1!'), ] ) def test_goto_assignment(Script, source, solution): ass = script_with_path(Script, source).goto() assert len(ass) == 1 assert ass[0].description == "foo = '%s'" % solution def test_simple_completions(Script): # completion completions = script_with_path(Script, 'from pkg import ').complete() names = [c.name for c in completions] compare = ['foo', 'ns1_file', 'ns1_folder', 'ns2_folder', 'ns2_file', 'pkg_resources', 'pkgutil', '__name__', '__path__', '__package__', '__file__', '__doc__'] # must at least contain these items, other items are not important assert set(compare) == set(names) @pytest.mark.parametrize( ('source', 'solution'), [ ('from pkg import ns2_folder as x', 'ns2_folder!'), ('from pkg import ns2_file as x', 'ns2_file!'), ('from pkg.ns2_folder import nested as x', 'nested!'), ('from pkg import ns1_folder as x', 'ns1_folder!'), ('from pkg import ns1_file as x', 'ns1_file!'), ('import pkg as x', 'ns1!'), ] ) def test_completions(Script, source, solution): for c in script_with_path(Script, source + '; x.').complete(): if c.name == 'foo': completion = c solution = "foo = '%s'" % solution assert completion.description == solution def test_nested_namespace_package(Script): code = 'from nested_namespaces.namespace.pkg import CONST' sys_path = [example_dir] project = Project('.', sys_path=sys_path) result = Script(code, project=project).infer(line=1, column=45) assert len(result) == 1 def test_relative_import(Script, environment, tmpdir): """ Attempt a relative import in a very simple namespace package. """ directory = get_example_dir('namespace_package_relative_import') # Need to copy the content in a directory where there's no __init__.py. py.path.local(directory).copy(tmpdir) file_path = join(tmpdir.strpath, "rel1.py") script = Script(path=file_path) d, = script.infer(line=1) assert d.name == 'int' d, = script.goto(line=1) assert d.name == 'name' assert d.module_name == 'rel2' ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/test_inference/test_precedence.py0000664000175000017500000000104700000000000022064 0ustar00davedave00000000000000from jedi.inference.compiled import CompiledValue import pytest @pytest.mark.parametrize('source', [ pytest.param('1 == 1'), pytest.param('1.0 == 1'), # Unfortunately for now not possible, because it's a typeshed object. pytest.param('... == ...', marks=pytest.mark.xfail), ]) def test_equals(Script, environment, source): script = Script(source) node = script._module_node.children[0] first, = script._get_module_context().infer_node(node) assert isinstance(first, CompiledValue) and first.get_safe_value() is True ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/test_inference/test_pyc.py0000664000175000017500000000453200000000000020564 0ustar00davedave00000000000000""" Test completions from *.pyc files: - generate a dummy python module - compile the dummy module to generate a *.pyc - delete the pure python dummy module - try jedi on the generated *.pyc """ import os import shutil import sys import pytest import jedi from jedi.api.environment import SameEnvironment, InterpreterEnvironment SRC = """class Foo: pass class Bar: pass """ @pytest.fixture def pyc_project_path(tmpdir): path = tmpdir.strpath dummy_package_path = os.path.join(path, "dummy_package") os.mkdir(dummy_package_path) with open(os.path.join(dummy_package_path, "__init__.py"), 'w', newline=''): pass dummy_path = os.path.join(dummy_package_path, 'dummy.py') with open(dummy_path, 'w', newline='') as f: f.write(SRC) import compileall compileall.compile_file(dummy_path) os.remove(dummy_path) # To import pyc modules, we must move them out of the __pycache__ # directory and rename them to remove ".cpython-%s%d" # see: http://stackoverflow.com/questions/11648440/python-does-not-detect-pyc-files pycache = os.path.join(dummy_package_path, "__pycache__") for f in os.listdir(pycache): dst = f.replace('.cpython-%s%s' % sys.version_info[:2], "") dst = os.path.join(dummy_package_path, dst) shutil.copy(os.path.join(pycache, f), dst) try: yield path finally: shutil.rmtree(path) @pytest.mark.parametrize('load_unsafe_extensions', [False, True]) def test_pyc(pyc_project_path, environment, load_unsafe_extensions): """ The list of completion must be greater than 2. """ path = os.path.join(pyc_project_path, 'blub.py') if not isinstance(environment, InterpreterEnvironment): # We are using the same version for pyc completions here, because it # was compiled in that version. However with interpreter environments # we also have the same version and it's easier to debug. environment = SameEnvironment() environment = environment project = jedi.Project(pyc_project_path, load_unsafe_extensions=load_unsafe_extensions) s = jedi.Script( "from dummy_package import dummy; dummy.", path=path, environment=environment, project=project, ) if load_unsafe_extensions: assert len(s.complete()) >= 2 else: assert not s.complete() ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/test_inference/test_representation.py0000664000175000017500000000176600000000000023041 0ustar00davedave00000000000000from textwrap import dedent def get_definition_and_inference_state(Script, source): first, = Script(dedent(source)).infer() return first._name._value, first._inference_state def test_function_execution(Script): """ We've been having an issue of a mutable list that was changed inside the function execution. Test if an execution always returns the same result. """ s = """ def x(): return str() x""" func, inference_state = get_definition_and_inference_state(Script, s) # Now just use the internals of the result (easiest way to get a fully # usable function). # Should return the same result both times. assert len(func.execute_with_values()) == 1 assert len(func.execute_with_values()) == 1 def test_class_mro(Script): s = """ class X(object): pass X""" cls, inference_state = get_definition_and_inference_state(Script, s) mro = cls.py__mro__() assert [c.name.string_name for c in mro] == ['X', 'object'] ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/test_inference/test_signature.py0000664000175000017500000003526700000000000022003 0ustar00davedave00000000000000from textwrap import dedent from operator import ge, lt import re import os import pytest from jedi.inference.gradual.conversion import _stub_to_python_value_set from ..helpers import get_example_dir @pytest.mark.parametrize( 'code, sig, names, op, version', [ ('import math; math.cos', 'cos(x, /)', ['x'], ge, (3, 6)), ('next', 'next(iterator, default=None, /)', ['iterator', 'default'], lt, (3, 12)), ('next', 'next()', [], ge, (3, 12)), ('str', "str(object='', /) -> str", ['object'], ge, (3, 6)), ('pow', 'pow(base, exp, mod=None)', ['base', 'exp', 'mod'], ge, (3, 8)), ('bytes.partition', 'partition(self, sep, /)', ['self', 'sep'], ge, (3, 6)), ('bytes().partition', 'partition(sep, /)', ['sep'], ge, (3, 6)), ] ) def test_compiled_signature(Script, environment, code, sig, names, op, version): if not op(environment.version_info, version): return # The test right next to it should take over. d, = Script(code).infer() value, = d._name.infer() compiled, = _stub_to_python_value_set(value) signature, = compiled.get_signatures() assert signature.to_string() == sig assert [n.string_name for n in signature.get_param_names()] == names classmethod_code = ''' class X: @classmethod def x(cls, a, b): pass @staticmethod def static(a, b): pass ''' partial_code = ''' import functools def func(a, b, c): pass a = functools.partial(func) b = functools.partial(func, 1) c = functools.partial(func, 1, c=2) d = functools.partial() ''' partialmethod_code = ''' import functools class X: def func(self, a, b, c): pass a = functools.partialmethod(func) b = functools.partialmethod(func, 1) c = functools.partialmethod(func, 1, c=2) d = functools.partialmethod() ''' @pytest.mark.parametrize( 'code, expected', [ ('def f(a, * args, x): pass\n f(', 'f(a, *args, x)'), ('def f(a, *, x): pass\n f(', 'f(a, *, x)'), ('def f(*, x= 3,**kwargs): pass\n f(', 'f(*, x=3, **kwargs)'), ('def f(x,/,y,* ,z): pass\n f(', 'f(x, /, y, *, z)'), ('def f(a, /, *, x=3, **kwargs): pass\n f(', 'f(a, /, *, x=3, **kwargs)'), (classmethod_code + 'X.x(', 'x(a, b)'), (classmethod_code + 'X().x(', 'x(a, b)'), (classmethod_code + 'X.static(', 'static(a, b)'), (classmethod_code + 'X().static(', 'static(a, b)'), (partial_code + 'a(', 'func(a, b, c)'), (partial_code + 'b(', 'func(b, c)'), (partial_code + 'c(', 'func(b)'), (partial_code + 'd(', None), (partialmethod_code + 'X().a(', 'func(a, b, c)'), (partialmethod_code + 'X().b(', 'func(b, c)'), (partialmethod_code + 'X().c(', 'func(b)'), (partialmethod_code + 'X().d(', None), (partialmethod_code + 'X.c(', 'func(a, b)'), (partialmethod_code + 'X.d(', None), ('import contextlib\n@contextlib.contextmanager\ndef f(x): pass\nf(', 'f(x)'), # typing lib ('from typing import cast\ncast(', { 'cast(typ: object, val: Any) -> Any', 'cast(typ: str, val: Any) -> Any', 'cast(typ: Type[_T], val: Any) -> _T'}), ('from typing import TypeVar\nTypeVar(', 'TypeVar(name: str, *constraints: Type[Any], bound: Union[None, Type[Any], str]=..., ' 'covariant: bool=..., contravariant: bool=...)'), ('from typing import List\nList(', None), ('from typing import List\nList[int](', None), ('from typing import Tuple\nTuple(', None), ('from typing import Tuple\nTuple[int](', None), ('from typing import Optional\nOptional(', None), ('from typing import Optional\nOptional[int](', None), ('from typing import Any\nAny(', None), ('from typing import NewType\nNewType(', 'NewType(name: str, tp: Type[_T]) -> Type[_T]'), ] ) def test_tree_signature(Script, environment, code, expected): # Only test this in the latest version, because of / if environment.version_info < (3, 8): pytest.skip() if expected is None: assert not Script(code).get_signatures() else: actual = {sig.to_string() for sig in Script(code).get_signatures()} if not isinstance(expected, set): expected = {expected} assert expected == actual @pytest.mark.parametrize( 'combination, expected', [ # Functions ('full_redirect(simple)', 'b, *, c'), ('full_redirect(simple4)', 'b, x: int'), ('full_redirect(a)', 'b, *args'), ('full_redirect(kw)', 'b, *, c, **kwargs'), ('full_redirect(akw)', 'c, *args, **kwargs'), # Non functions ('full_redirect(lambda x, y: ...)', 'y'), ('full_redirect()', '*args, **kwargs'), ('full_redirect(1)', '*args, **kwargs'), # Classes / inheritance ('full_redirect(C)', 'z, *, c'), ('full_redirect(C())', 'y'), ('full_redirect(G)', 't: T'), ('full_redirect(G[str])', '*args, **kwargs'), ('D', 'D(a, z, /)'), ('D()', 'D(x, y)'), ('D().foo', 'foo(a, *, bar, z, **kwargs)'), # Merging ('two_redirects(simple, simple)', 'a, b, *, c'), ('two_redirects(simple2, simple2)', 'x'), ('two_redirects(akw, kw)', 'a, c, *args, **kwargs'), ('two_redirects(kw, akw)', 'a, b, *args, c, **kwargs'), ('two_kwargs_redirects(simple, simple)', '*args, a, b, c'), ('two_kwargs_redirects(kw, kw)', '*args, a, b, c, **kwargs'), ('two_kwargs_redirects(simple, kw)', '*args, a, b, c, **kwargs'), ('two_kwargs_redirects(simple2, two_kwargs_redirects(simple, simple))', '*args, x, a, b, c'), ('combined_redirect(simple, simple2)', 'a, b, /, *, x'), ('combined_redirect(simple, simple3)', 'a, b, /, *, a, x: int'), ('combined_redirect(simple2, simple)', 'x, /, *, a, b, c'), ('combined_redirect(simple3, simple)', 'a, x: int, /, *, a, b, c'), ('combined_redirect(simple, kw)', 'a, b, /, *, a, b, c, **kwargs'), ('combined_redirect(kw, simple)', 'a, b, /, *, a, b, c'), ('combined_redirect(simple, simple2)', 'a, b, /, *, x'), ('combined_lot_of_args(kw, simple4)', '*, b'), ('combined_lot_of_args(simple4, kw)', '*, b, c, **kwargs'), ('combined_redirect(combined_redirect(simple2, simple4), combined_redirect(kw, simple5))', 'x, /, *, y'), ('combined_redirect(combined_redirect(simple4, simple2), combined_redirect(simple5, kw))', 'a, b, x: int, /, *, a, b, c, **kwargs'), ('combined_redirect(combined_redirect(a, kw), combined_redirect(kw, simple5))', 'a, b, /, *args, y'), ('no_redirect(kw)', '*args, **kwargs'), ('no_redirect(akw)', '*args, **kwargs'), ('no_redirect(simple)', '*args, **kwargs'), ] ) def test_nested_signatures(Script, environment, combination, expected): code = dedent(''' def simple(a, b, *, c): ... def simple2(x): ... def simple3(a, x: int): ... def simple4(a, b, x: int): ... def simple5(y): ... def a(a, b, *args): ... def kw(a, b, *, c, **kwargs): ... def akw(a, c, *args, **kwargs): ... def no_redirect(func): return lambda *args, **kwargs: func(1) def full_redirect(func): return lambda *args, **kwargs: func(1, *args, **kwargs) def two_redirects(func1, func2): return lambda *args, **kwargs: func1(*args, **kwargs) + func2(1, *args, **kwargs) def two_kwargs_redirects(func1, func2): return lambda *args, **kwargs: func1(**kwargs) + func2(1, **kwargs) def combined_redirect(func1, func2): return lambda *args, **kwargs: func1(*args) + func2(**kwargs) def combined_lot_of_args(func1, func2): return lambda *args, **kwargs: func1(1, 2, 3, 4, *args) + func2(a=3, x=1, y=1, **kwargs) class C: def __init__(self, a, z, *, c): ... def __call__(self, x, y): ... def foo(self, bar, z, **kwargs): ... class D(C): def __init__(self, *args): super().__init__(*args) def foo(self, a, **kwargs): super().foo(**kwargs) from typing import Generic, TypeVar T = TypeVar('T') class G(Generic[T]): def __init__(self, i, t: T): ... ''') code += 'z = ' + combination + '\nz(' sig, = Script(code).get_signatures() computed = sig.to_string() if not re.match(r'\w+\(', expected): expected = '(' + expected + ')' assert expected == computed def test_pow_signature(Script, environment): # See github #1357 sigs = Script('pow(').get_signatures() strings = {sig.to_string() for sig in sigs} if environment.version_info < (3, 8): assert strings == {'pow(base: _SupportsPow2[_E, _T_co], exp: _E, /) -> _T_co', 'pow(base: _SupportsPow3[_E, _M, _T_co], exp: _E, mod: _M, /) -> _T_co', 'pow(base: float, exp: float, mod: None=..., /) -> float', 'pow(base: int, exp: int, mod: None=..., /) -> Any', 'pow(base: int, exp: int, mod: int, /) -> int'} else: assert strings == {'pow(base: _SupportsPow2[_E, _T_co], exp: _E) -> _T_co', 'pow(base: _SupportsPow3[_E, _M, _T_co], exp: _E, mod: _M) -> _T_co', 'pow(base: float, exp: float, mod: None=...) -> float', 'pow(base: int, exp: int, mod: None=...) -> Any', 'pow(base: int, exp: int, mod: int) -> int'} @pytest.mark.parametrize( 'code, signature', [ [dedent(''' # identifier:A import functools def f(x): pass def x(f): @functools.wraps(f) def wrapper(*args): return f(*args) return wrapper x(f)('''), 'f(x, /)'], [dedent(''' # identifier:B import functools def f(x): pass def x(f): @functools.wraps(f) def wrapper(): # Have no arguments here, but because of wraps, the signature # should still be f's. return 1 return wrapper x(f)('''), 'f()'], [dedent(''' # identifier:C import functools def f(x: int, y: float): pass @functools.wraps(f) def wrapper(*args, **kwargs): return f(*args, **kwargs) wrapper('''), 'f(x: int, y: float)'], [dedent(''' # identifier:D def f(x: int, y: float): pass def wrapper(*args, **kwargs): return f(*args, **kwargs) wrapper('''), 'wrapper(x: int, y: float)'], ] ) def test_wraps_signature(Script, code, signature): sigs = Script(code).get_signatures() assert {sig.to_string() for sig in sigs} == {signature} @pytest.mark.parametrize( 'start, start_params', [ ['@dataclass\nclass X:', []], ['@dataclass(eq=True)\nclass X:', []], [dedent(''' class Y(): y: int @dataclass class X(Y):'''), []], [dedent(''' @dataclass class Y(): y: int z = 5 @dataclass class X(Y):'''), ['y']], ] ) def test_dataclass_signature(Script, skip_pre_python37, start, start_params): code = dedent(''' name: str foo = 3 price: float quantity: int = 0.0 X(''') code = 'from dataclasses import dataclass\n' + start + code sig, = Script(code).get_signatures() assert [p.name for p in sig.params] == start_params + ['name', 'price', 'quantity'] quantity, = sig.params[-1].infer() assert quantity.name == 'int' price, = sig.params[-2].infer() assert price.name == 'float' @pytest.mark.parametrize( 'start, start_params', [ ['@define\nclass X:', []], ['@frozen\nclass X:', []], ['@define(eq=True)\nclass X:', []], [dedent(''' class Y(): y: int @define class X(Y):'''), []], [dedent(''' @define class Y(): y: int z = 5 @define class X(Y):'''), ['y']], ] ) def test_attrs_signature(Script, skip_pre_python37, start, start_params): has_attrs = bool(Script('import attrs').infer()) if not has_attrs: raise pytest.skip("attrs needed in target environment to run this test") code = dedent(''' name: str foo = 3 price: float quantity: int = 0.0 X(''') # attrs exposes two namespaces code = 'from attrs import define, frozen\n' + start + code sig, = Script(code).get_signatures() assert [p.name for p in sig.params] == start_params + ['name', 'price', 'quantity'] quantity, = sig.params[-1].infer() assert quantity.name == 'int' price, = sig.params[-2].infer() assert price.name == 'float' @pytest.mark.parametrize( 'stmt, expected', [ ('args = 1', 'wrapped(*args, b, c)'), ('args = (1,)', 'wrapped(*args, c)'), ('kwargs = 1', 'wrapped(b, /, **kwargs)'), ('kwargs = dict(b=3)', 'wrapped(b, /, **kwargs)'), ] ) def test_param_resolving_to_static(Script, stmt, expected): code = dedent('''\ def full_redirect(func): def wrapped(*args, **kwargs): {stmt} return func(1, *args, **kwargs) return wrapped def simple(a, b, *, c): ... full_redirect(simple)('''.format(stmt=stmt)) sig, = Script(code).get_signatures() assert sig.to_string() == expected @pytest.mark.parametrize( 'code', [ 'from file import with_overload; with_overload(', 'from file import *\nwith_overload(', ] ) def test_overload(Script, code): dir_ = get_example_dir('typing_overload') x1, x2 = Script(code, path=os.path.join(dir_, 'foo.py')).get_signatures() assert x1.to_string() == 'with_overload(x: int, y: int) -> float' assert x2.to_string() == 'with_overload(x: str, y: list) -> float' def test_enum(Script): script = Script('''\ from enum import Enum class Planet(Enum): MERCURY = (3.303e+23, 2.4397e6) VENUS = (4.869e+24, 6.0518e6) def __init__(self, mass, radius): self.mass = mass # in kilograms self.radius = radius # in meters Planet.MERCURY''') completion, = script.complete() assert not completion.get_signatures() ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/test_inference/test_stdlib.py0000664000175000017500000000526300000000000021254 0ustar00davedave00000000000000""" Tests of various stdlib related things that could not be tested with "Black Box Tests". """ from textwrap import dedent import pytest @pytest.mark.parametrize(['letter', 'expected'], [ ('n', ['name']), ('s', ['smart']), ]) def test_namedtuple_str(letter, expected, Script): source = dedent("""\ import collections Person = collections.namedtuple('Person', 'name smart') dave = Person('Dave', False) dave.%s""") % letter result = Script(source).complete() completions = set(r.name for r in result) assert completions == set(expected) def test_namedtuple_list(Script): source = dedent("""\ import collections Cat = collections.namedtuple('Person', ['legs', u'length', 'large']) garfield = Cat(4, '85cm', True) garfield.l""") result = Script(source).complete() completions = set(r.name for r in result) assert completions == {'legs', 'length', 'large'} def test_namedtuple_content(Script): source = dedent("""\ import collections Foo = collections.namedtuple('Foo', ['bar', 'baz']) named = Foo(baz=4, bar=3.0) unnamed = Foo(4, '') """) def d(source): x, = Script(source).infer() return x.name assert d(source + 'unnamed.bar') == 'int' assert d(source + 'unnamed.baz') == 'str' assert d(source + 'named.bar') == 'float' assert d(source + 'named.baz') == 'int' def test_nested_namedtuples(Script): """ From issue #730. """ s = Script(dedent(''' import collections Dataset = collections.namedtuple('Dataset', ['data']) Datasets = collections.namedtuple('Datasets', ['train']) train_x = Datasets(train=Dataset('data_value')) train_x.train.''')) assert 'data' in [c.name for c in s.complete()] def test_namedtuple_infer(Script): source = dedent(""" from collections import namedtuple Foo = namedtuple('Foo', 'id timestamp gps_timestamp attributes') Foo""") from jedi.api import Script d1, = Script(source).infer() assert d1.get_line_code() == "class Foo(tuple):\n" assert d1.module_path is None assert d1.docstring() == 'Foo(id, timestamp, gps_timestamp, attributes)' def test_re_sub(Script, environment): """ This whole test was taken out of completion/stdlib.py, because of the version differences. """ def run(code): defs = Script(code).infer() return {d.name for d in defs} names = run("import re; re.sub('a', 'a', 'f')") assert names == {'str'} # This param is missing because of overloading. names = run("import re; re.sub('a', 'a')") assert names == {'str', 'bytes'} ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/test_inference/test_sys_path.py0000664000175000017500000001021700000000000021620 0ustar00davedave00000000000000import os from glob import glob import sys import shutil from pathlib import Path import pytest from ..helpers import skip_if_windows, skip_if_not_windows, get_example_dir from jedi.inference import sys_path from jedi.api.environment import create_environment def test_paths_from_assignment(Script): def paths(src): script = Script(src, path='/foo/bar.py') expr_stmt = script._module_node.children[0] return set(sys_path._paths_from_assignment(script._get_module_context(), expr_stmt)) # Normalize paths for Windows. path_a = Path('/foo/a').absolute() path_b = Path('/foo/b').absolute() path_c = Path('/foo/c').absolute() assert paths('sys.path[0:0] = ["a"]') == {path_a} assert paths('sys.path = ["b", 1, x + 3, y, "c"]') == {path_b, path_c} assert paths('sys.path = a = ["a"]') == {path_a} # Fail for complicated examples. assert paths('sys.path, other = ["a"], 2') == set() def test_venv_and_pths(venv_path, environment): pjoin = os.path.join if os.name == 'nt': if environment.version_info < (3, 11): site_pkg_path = pjoin(venv_path, 'lib', 'site-packages') else: site_pkg_path = pjoin(venv_path, 'Lib', 'site-packages') else: site_pkg_path = glob(pjoin(venv_path, 'lib', 'python*', 'site-packages'))[0] shutil.rmtree(site_pkg_path) shutil.copytree(get_example_dir('sample_venvs', 'pth_directory'), site_pkg_path) virtualenv = create_environment(venv_path) venv_paths = virtualenv.get_sys_path() ETALON = [ # For now disable egg-links. I have no idea how they work... ~ dave #pjoin('/path', 'from', 'egg-link'), #pjoin(site_pkg_path, '.', 'relative', 'egg-link', 'path'), site_pkg_path, pjoin(site_pkg_path, 'dir-from-foo-pth'), '/foo/smth.py:module', # Not sure why it's added twice. It has to do with site.py which is not # something we can change. However this obviously also doesn't matter. '/foo/smth.py:from_func', '/foo/smth.py:from_func', ] # Ensure that pth and egg-link paths were added. assert venv_paths[-len(ETALON):] == ETALON # Ensure that none of venv dirs leaked to the interpreter. assert not set(sys.path).intersection(ETALON) _s = ['/a', '/b', '/c/d/'] @pytest.mark.parametrize( 'sys_path_, module_path, expected, is_package', [ (_s, '/a/b', ('b',), False), (_s, '/a/b/c', ('b', 'c'), False), (_s, '/a/b.py', ('b',), False), (_s, '/a/b/c.py', ('b', 'c'), False), (_s, '/x/b.py', None, False), (_s, '/c/d/x.py', ('x',), False), (_s, '/c/d/x.py', ('x',), False), (_s, '/c/d/x/y.py', ('x', 'y'), False), # If dots are in there they also resolve. These are obviously illegal # in Python, but Jedi can handle them. Give the user a bit more freedom # that he will have to correct eventually. (_s, '/a/b.c.py', ('b.c',), False), (_s, '/a/b.d/foo.bar.py', ('b.d', 'foo.bar'), False), (_s, '/a/.py', None, False), (_s, '/a/c/.py', None, False), (['/foo'], '/foo/bar/__init__.py', ('bar',), True), (['/foo'], '/foo/bar/baz/__init__.py', ('bar', 'baz'), True), skip_if_windows(['/foo'], '/foo/bar.so', ('bar',), False), skip_if_windows(['/foo'], '/foo/bar/__init__.so', ('bar',), True), skip_if_not_windows(['/foo'], '/foo/bar.pyd', ('bar',), False), skip_if_not_windows(['/foo'], '/foo/bar/__init__.pyd', ('bar',), True), (['/foo'], '/x/bar.py', None, False), (['/foo'], '/foo/bar.xyz', ('bar.xyz',), False), (['/foo', '/foo/bar'], '/foo/bar/baz', ('baz',), False), (['/foo/bar', '/foo'], '/foo/bar/baz', ('baz',), False), (['/'], '/bar/baz.py', ('bar', 'baz',), False), ]) def test_transform_path_to_dotted(sys_path_, module_path, expected, is_package): # transform_path_to_dotted expects normalized absolute paths. sys_path_ = [os.path.abspath(path) for path in sys_path_] module_path = os.path.abspath(module_path) assert sys_path.transform_path_to_dotted(sys_path_, Path(module_path)) \ == (expected, is_package) ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/test_integration.py0000664000175000017500000000751100000000000017317 0ustar00davedave00000000000000import os import sys from collections import namedtuple import pytest from . import helpers from jedi.common import indent_block from jedi import RefactoringError def assert_case_equal(case, actual, desired): """ Assert ``actual == desired`` with formatted message. This is not needed for typical pytest use case, but as we need ``--assert=plain`` (see ../pytest.ini) to workaround some issue due to pytest magic, let's format the message by hand. """ assert actual == desired, """ Test %r failed. actual = %s desired = %s """ % (case, indent_block(str(actual)), indent_block(str(desired))) def assert_static_analysis(case, actual, desired): """A nicer formatting for static analysis tests.""" a = set(actual) d = set(desired) assert actual == desired, """ Test %r failed. not raised = %s unspecified = %s """ % (case, sorted(d - a), sorted(a - d)) def test_completion(case, monkeypatch, environment, has_django): skip_reason = case.get_skip_reason(environment) if skip_reason is not None: pytest.skip(skip_reason) if (not has_django) and case.path.endswith('django.py'): pytest.skip('Needs django to be installed to run this test.') if case.path.endswith("pytest.py"): # to test finding pytest fixtures from external plugins # add a stub pytest plugin to the project sys_path... pytest_plugin_dir = str(helpers.get_example_dir("pytest_plugin_package")) case._project.added_sys_path = [pytest_plugin_dir] # ... and mock the entry points to include it # see https://docs.pytest.org/en/stable/how-to/writing_plugins.html#setuptools-entry-points if sys.version_info >= (3, 8): def mock_entry_points(*, group=None): import importlib.metadata entries = [importlib.metadata.EntryPoint( name=None, value="pytest_plugin.plugin", group="pytest11", )] if sys.version_info >= (3, 10): assert group == "pytest11" return entries else: assert group is None return {"pytest11": entries} monkeypatch.setattr("importlib.metadata.entry_points", mock_entry_points) else: def mock_iter_entry_points(group): assert group == "pytest11" EntryPoint = namedtuple("EntryPoint", ["module_name"]) return [EntryPoint("pytest_plugin.plugin")] monkeypatch.setattr("pkg_resources.iter_entry_points", mock_iter_entry_points) repo_root = helpers.root_dir monkeypatch.chdir(os.path.join(repo_root, 'jedi')) case.run(assert_case_equal, environment) def test_static_analysis(static_analysis_case, environment): skip_reason = static_analysis_case.get_skip_reason(environment) if skip_reason is not None: pytest.skip(skip_reason) else: static_analysis_case.run(assert_static_analysis, environment) def test_refactor(refactor_case, environment): """ Run refactoring test case. :type refactor_case: :class:`.refactor.RefactoringCase` """ desired_result = refactor_case.get_desired_result() if refactor_case.type == 'error': with pytest.raises(RefactoringError) as e: refactor_case.refactor(environment) assert e.value.args[0] == desired_result.strip() elif refactor_case.type == 'text': refactoring = refactor_case.refactor(environment) assert not refactoring.get_renames() text = ''.join(f.get_new_code() for f in refactoring.get_changed_files().values()) assert_case_equal(refactor_case, text, desired_result) else: diff = refactor_case.refactor(environment).get_diff() assert_case_equal(refactor_case, diff, desired_result) ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1696238359.4743795 jedi-0.19.1/test/test_parso_integration/0000775000175000017500000000000000000000000020145 5ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/test_parso_integration/__init__.py0000664000175000017500000000000000000000000022244 0ustar00davedave00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/test_parso_integration/test_basic.py0000664000175000017500000000357200000000000022646 0ustar00davedave00000000000000from textwrap import dedent import pytest from parso import parse def test_form_feed_characters(Script): s = "\f\nclass Test(object):\n pass" Script(s).get_signatures(line=2, column=18) def check_p(src): module_node = parse(src) assert src == module_node.get_code() return module_node def test_if(Script): src = dedent('''\ def func(): x = 3 if x: def y(): return x return y() func() ''') # Two parsers needed, one for pass and one for the function. check_p(src) assert [d.name for d in Script(src).infer(8, 6)] == ['int'] def test_class_and_if(Script): src = dedent("""\ class V: def __init__(self): pass if 1: c = 3 def a_func(): return 1 # COMMENT a_func()""") check_p(src) assert [d.name for d in Script(src).infer()] == ['int'] def test_add_to_end(Script): """ The diff parser doesn't parse everything again. It just updates with the help of caches, this is an example that didn't work. """ a = dedent("""\ class Abc(): def abc(self): self.x = 3 class Two(Abc): def g(self): self """) # ^ here is the first completion b = " def h(self):\n" \ " self." def complete(code, line=None, column=None): script = Script(code, path='example.py') assert script.complete(line, column) complete(a, 7, 12) complete(a + b) a = a[:-1] + '.\n' complete(a, 7, 13) complete(a + b) def test_tokenizer_with_string_literal_backslash(Script): c = Script("statement = u'foo\\\n'; statement").infer() assert c[0]._name._value.get_safe_value() == 'foo' def test_ellipsis_without_getitem(Script, environment): def_, = Script('x=...;x').infer() assert def_.name == 'ellipsis' ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/test_parso_integration/test_error_correction.py0000664000175000017500000000200300000000000025131 0ustar00davedave00000000000000from textwrap import dedent def test_error_correction_with(Script): source = """ with open() as f: try: f.""" comps = Script(source).complete() assert len(comps) > 30 # `open` completions have a closed attribute. assert [1 for c in comps if c.name == 'closed'] def test_string_literals(Script): """Simplified case of jedi-vim#377.""" source = dedent(""" x = ur''' def foo(): pass """) script = Script(dedent(source)) assert script._get_module_context().tree_node.end_pos == (6, 0) assert not script.complete() def test_incomplete_function(Script): source = '''return ImportErr''' script = Script(dedent(source)) assert script.complete(1, 3) def test_decorator_string_issue(Script): """ Test case from #589 """ source = dedent('''\ """ @""" def bla(): pass bla.''') s = Script(source) assert s.complete() assert s._get_module_context().tree_node.get_code() == source ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/test_parso_integration/test_parser_utils.py0000664000175000017500000000530300000000000024273 0ustar00davedave00000000000000import gc from pathlib import Path from jedi import parser_utils from parso import parse from parso.cache import parser_cache from parso.python import tree import pytest class TestCallAndName: def get_call(self, source): # Get the simple_stmt and then the first one. node = parse(source).children[0] if node.type == 'simple_stmt': return node.children[0] return node def test_name_and_call_positions(self): name = self.get_call('name\nsomething_else') assert name.value == 'name' assert name.start_pos == (1, 0) assert name.end_pos == (1, 4) leaf = self.get_call('1.0\n') assert leaf.value == '1.0' assert parser_utils.safe_literal_eval(leaf.value) == 1.0 assert leaf.start_pos == (1, 0) assert leaf.end_pos == (1, 3) def test_call_type(self): call = self.get_call('hello') assert isinstance(call, tree.Name) def test_literal_type(self): literal = self.get_call('1.0') assert isinstance(literal, tree.Literal) assert type(parser_utils.safe_literal_eval(literal.value)) == float literal = self.get_call('1') assert isinstance(literal, tree.Literal) assert type(parser_utils.safe_literal_eval(literal.value)) == int literal = self.get_call('"hello"') assert isinstance(literal, tree.Literal) assert parser_utils.safe_literal_eval(literal.value) == 'hello' def test_hex_values_in_docstring(): source = r''' def foo(object): """ \xff """ return 1 ''' doc = parser_utils.clean_scope_docstring(next(parse(source).iter_funcdefs())) assert doc == '\xff' @pytest.mark.parametrize( 'code,signature', [ ('def my_function(x, typed: Type, z):\n return', 'my_function(x, typed: Type, z)'), ('def my_function(x, y, z) -> str:\n return', 'my_function(x, y, z) -> str'), ('lambda x, y, z: x + y * z\n', '(x, y, z)') ]) def test_get_signature(code, signature): node = parse(code, version='3.8').children[0] if node.type == 'simple_stmt': node = node.children[0] assert parser_utils.get_signature(node) == signature def test_parser_cache_clear(Script): """ If parso clears its cache, Jedi should not keep those resources, they should be freed. """ script = Script("a = abs\na", path=Path(__file__).parent / 'parser_cache_test_foo.py') script.complete() module_id = id(script._module_node) del parser_cache[script._inference_state.grammar._hashed][script.path] del script gc.collect() assert module_id not in [id(m) for m in gc.get_referrers(tree.Module)] ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/test_settings.py0000664000175000017500000000223300000000000016630 0ustar00davedave00000000000000import pytest from jedi import settings from jedi.inference.compiled import CompiledValueName from jedi.inference.compiled.value import CompiledModule @pytest.fixture() def auto_import_json(monkeypatch): monkeypatch.setattr(settings, 'auto_import_modules', ['json']) def test_base_auto_import_modules(auto_import_json, Script): loads, = Script('import json; json.loads').infer() assert isinstance(loads._name, CompiledValueName) value, = loads._name.infer() assert isinstance(value.parent_context._value, CompiledModule) def test_auto_import_modules_imports(auto_import_json, Script): main, = Script('from json import tool; tool.main').infer() assert isinstance(main._name, CompiledValueName) def test_cropped_file_size(monkeypatch, get_names, Script): code = 'class Foo(): pass\n' monkeypatch.setattr( settings, '_cropped_file_size', len(code) ) foo, = get_names(code + code) assert foo.line == 1 # It should just not crash if we are outside of the cropped range. script = Script(code + code + 'Foo') assert not script.infer() assert 'Foo' in [c.name for c in script.complete()] ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1696238274.0 jedi-0.19.1/test/test_utils.py0000664000175000017500000000750200000000000016134 0ustar00davedave00000000000000try: import readline except ImportError: readline = False import unittest from jedi import utils @unittest.skipIf(not readline, "readline not found") class TestSetupReadline(unittest.TestCase): class NameSpace(object): pass def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) self.namespace = self.NameSpace() utils.setup_readline(self.namespace) def complete(self, text): completer = readline.get_completer() i = 0 completions = [] while True: completion = completer(text, i) if completion is None: break completions.append(completion) i += 1 return completions def test_simple(self): assert self.complete('list') == ['list'] assert self.complete('importerror') == ['ImportError'] s = "print(BaseE" assert self.complete(s) == [s + 'xception'] def test_nested(self): assert self.complete('list.Insert') == ['list.insert'] assert self.complete('list().Insert') == ['list().insert'] def test_magic_methods(self): assert self.complete('list.__getitem__') == ['list.__getitem__'] assert self.complete('list().__getitem__') == ['list().__getitem__'] def test_modules(self): import sys import os self.namespace.sys = sys self.namespace.os = os try: assert self.complete('os.path.join') == ['os.path.join'] string = 'os.path.join("a").upper' assert self.complete(string) == [string] c = {'os.' + d for d in dir(os) if d.startswith('ch')} assert set(self.complete('os.ch')) == set(c) finally: del self.namespace.sys del self.namespace.os def test_calls(self): s = 'str(bytes' assert self.complete(s) == [s, 'str(BytesWarning'] def test_import(self): s = 'from os.path import a' assert set(self.complete(s)) == {s + 'ltsep', s + 'bspath'} assert self.complete('import keyword') == ['import keyword'] import os s = 'from os import ' goal = {s + el for el in dir(os)} # There are minor differences, e.g. the dir doesn't include deleted # items as well as items that are not only available on linux. difference = set(self.complete(s)).symmetric_difference(goal) difference = { x for x in difference if all(not x.startswith('from os import ' + s) for s in ['_', 'O_', 'EX_', 'MFD_', 'SF_', 'ST_', 'CLD_', 'POSIX_SPAWN_', 'P_', 'RWF_', 'CLONE_', 'SCHED_']) } # There are quite a few differences, because both Windows and Linux # (posix and nt) libraries are included. assert len(difference) < 30 def test_local_import(self): s = 'import test.test_utils' assert self.complete(s) == [s] def test_preexisting_values(self): self.namespace.a = range(10) assert set(self.complete('a.')) == {'a.' + n for n in dir(range(1))} del self.namespace.a def test_colorama(self): """ Only test it if colorama library is available. This module is being tested because it uses ``setattr`` at some point, which Jedi doesn't understand, but it should still work in the REPL. """ try: # if colorama is installed import colorama except ImportError: pass else: self.namespace.colorama = colorama assert self.complete('colorama') assert self.complete('colorama.Fore.BLACK') == ['colorama.Fore.BLACK'] del self.namespace.colorama def test_version_info(): assert utils.version_info()[:2] > (0, 7)