mirror of
https://github.com/davidhalter/jedi.git
synced 2025-12-06 22:14:27 +08:00
111 lines
4.4 KiB
ReStructuredText
111 lines
4.4 KiB
ReStructuredText
.. 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.) <repl-completion>`
|
|
- 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 <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 <https://github.com/davidhalter/jedi/issues/1059>`_ 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.
|