jedi

Awesome autocompletion, static analysis and refactoring library for python

5,757

508

5,757

View on GitHub

Top Related Projects

python-lsp-server

1,865

Fork of the python-language-server project, maintained by the Spyder IDE team and the community

pylance-release

1,693

Documentation and issues for Pylance

Quick Overview

Jedi is a static analysis tool and autocompletion library for Python. It provides intelligent code completion, go-to-definition, and refactoring capabilities for Python developers, making it a powerful tool for IDEs and text editors.

Pros

Highly accurate code completion and analysis
Supports multiple Python versions (2.7 and 3.x)
Integrates well with various IDEs and text editors
Actively maintained and regularly updated

Cons

Can be slower compared to some other completion engines
Occasional false positives in certain edge cases
Limited support for some newer Python features
Requires careful configuration for optimal performance

Code Examples

Basic autocompletion:

import jedi

script = jedi.Script("import os\nos.")
completions = script.complete(1, 3)
for completion in completions:
    print(completion.name)

This code demonstrates basic autocompletion for the os module.

Go to definition:

import jedi

script = jedi.Script("def my_function():\n    pass\n\nmy_function()")
definitions = script.goto(3, 0, follow_imports=True)
for definition in definitions:
    print(f"{definition.name} at line {definition.line}, column {definition.column}")

This example shows how to find the definition of a function.

Get docstring:

import jedi

script = jedi.Script("import math\nmath.sin")
help = script.help(2, 5)
if help:
    print(help[0].docstring())

This code retrieves and prints the docstring for the math.sin function.

Getting Started

To use Jedi in your project, follow these steps:

Install Jedi using pip:
```
pip install jedi
```
Import Jedi in your Python script:
```
import jedi
```
Create a Jedi Script object with your source code:
```
script = jedi.Script("your_python_code_here")
```

Use Jedi's features like completion, go-to-definition, or help:

completions = script.complete(line, column)
definitions = script.goto(line, column, follow_imports=True)
help = script.help(line, column)

Competitor Comparisons

pyright

13,105

Static Type Checker for Python

Pros of Pyright

Faster performance, especially for large codebases
More accurate type checking and inference
Better support for modern Python features and type annotations

Cons of Pyright

Steeper learning curve and more complex configuration
Less integration with popular text editors and IDEs
Requires TypeScript runtime, which may be a drawback for some users

Code Comparison

Jedi:

import jedi

script = jedi.Script("import os\nos.")
completions = script.complete(1, 3)
print([c.name for c in completions])

Pyright:

# No direct code equivalent for Pyright
# Pyright is typically used as a language server or through CLI
# It doesn't have a Python API like Jedi

Pyright is primarily used as a language server or through command-line interface, while Jedi provides a Python API for direct integration into applications. This fundamental difference makes a direct code comparison less relevant.

Both tools serve similar purposes but cater to different use cases and preferences. Jedi is more lightweight and easier to integrate, while Pyright offers more advanced features and better performance for large projects.

mypy

18,182

Optional static typing for Python

Pros of mypy

Static type checking for Python, enhancing code reliability
Integrates well with popular IDEs and text editors
Supports gradual typing, allowing incremental adoption

Cons of mypy

Requires type annotations, which can be time-consuming to add
May produce false positives in complex code structures
Learning curve for effective use of type hints and annotations

Code Comparison

mypy:

def greet(name: str) -> str:
    return f"Hello, {name}!"

result: str = greet("Alice")

Jedi:

def greet(name):
    return f"Hello, {name}!"

result = greet("Alice")

mypy focuses on static type checking, requiring explicit type annotations. Jedi, on the other hand, is primarily an autocompletion and static analysis tool that infers types without requiring annotations. While mypy enhances code reliability through type checking, Jedi excels in providing intelligent code completion and navigation features.

Both tools serve different purposes in the Python ecosystem. mypy is ideal for projects prioritizing type safety and catching potential errors early, while Jedi is better suited for developers seeking advanced autocompletion and code navigation capabilities without the need for explicit type annotations.

python-lsp-server

1,865

Fork of the python-language-server project, maintained by the Spyder IDE team and the community

Pros of python-lsp-server

Implements the Language Server Protocol (LSP), providing a standardized interface for various IDEs and editors
Offers a broader range of features beyond code completion, including diagnostics and code actions
Supports multiple Python language tools and can be extended with plugins

Cons of python-lsp-server

May have higher resource usage due to its comprehensive feature set
Potentially more complex setup and configuration compared to Jedi
Might have slower startup time for small projects or quick edits

Code Comparison

python-lsp-server configuration:

from pylsp_mypy import add_mypy_to_config

def pylsp_settings(config):
    add_mypy_to_config(config)
    return config

Jedi usage:

import jedi

script = jedi.Script("import os\nos.")
completions = script.complete(1, 3)

Summary

python-lsp-server provides a more comprehensive solution for Python development environments, implementing the LSP standard and offering extensibility. However, it may be overkill for simpler projects or environments where a lightweight solution like Jedi suffices. Jedi focuses primarily on code completion and analysis, making it more straightforward for basic use cases but potentially limiting for complex development workflows.

pylance-release

1,693

Documentation and issues for Pylance

Pros of Pylance

More advanced type checking and inference capabilities
Faster performance, especially for large codebases
Tighter integration with Visual Studio Code

Cons of Pylance

Closed-source and proprietary, limiting community contributions
Limited to Visual Studio Code, not usable in other editors or IDEs
May have a steeper learning curve for configuration and customization

Code Comparison

Jedi:

import jedi

script = jedi.Script("import os\nos.")
completions = script.complete(1, 3)

Pylance:

# Pylance works automatically in VS Code
import os
os.  # Autocomplete suggestions appear here

Summary

Jedi is an open-source Python autocompletion and static analysis library, while Pylance is a proprietary language server for Python, developed by Microsoft. Pylance offers more advanced features and better performance, but is limited to VS Code. Jedi is more flexible and can be integrated into various editors and tools, but may not have as advanced type inference capabilities.

Convert designs to code with AI

Introducing Visual Copilot: A new AI model to turn Figma designs to high quality code using your components.

Try Visual Copilot

README

#################################################################################### 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 <https://github.com/davidhalter/jedi-vim>_. 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 <https://marketplace.visualstudio.com/items?itemName=ms-python.python>_)
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 <https://projects.kde.org/projects/kde/applications/kate/repository/show?rev=KDE%2F4.13>_]
Atom_ (autocomplete-python-jedi_)
GNOME Builder_ (with support for GObject Introspection)
Gedit (gedi_)
wdb_ - Web Debugger
Eric IDE_
IPython 6.0.0+ <https://ipython.readthedocs.io/en/stable/whatsnew/version6.html>_
xonsh shell <https://xon.sh/contents.html>_ has jedi extension <https://xon.sh/xontribs.html#jedi>_

and many more!

There are a few language servers that use Jedi:

jedi-language-server <https://github.com/pappasam/jedi-language-server>_
python-language-server <https://github.com/palantir/python-language-server>_ (currently unmaintained)
python-lsp-server <https://github.com/python-lsp/python-lsp-server>_ (fork from python-language-server)
anakin-language-server <https://github.com/muffinmad/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 <https://github.com/davidhalter/jedi>_ (master branch should always be kind of stable/working).

Docs are available at https://jedi.readthedocs.org/en/latest/ <https://jedi.readthedocs.org/en/latest/>. Pull requests with enhancements and/or fixes are awesome and most welcome. Jedi uses semantic versioning <https://semver.org/>.

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 <https://github.com/davidhalter/jedi/>. Alternatively you can also ask on Stack Overflow <https://stackoverflow.com/questions/tagged/python-jedi>_ with the label python-jedi.

Installation

Check out the docs <https://jedi.readthedocs.org/en/latest/docs/installation.html>_.

Features and Limitations

Jedi's features are listed here: Features <https://jedi.readthedocs.org/en/latest/docs/features.html>_.

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 <https://jedi.readthedocs.org/en/latest/docs/api.html#environments>_ very well.

Tips on how to use Jedi efficiently can be found here <https://jedi.readthedocs.org/en/latest/docs/features.html#recipes>_.

API

You can find a comprehensive documentation for the API here <https://jedi.readthedocs.org/en/latest/docs/api.html>_.

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 <https://vimeo.com/122332037>_ how REPL completion can look like. For the python shell you can enable tab completion in a REPL <https://jedi.readthedocs.org/en/latest/docs/usage.html#tab-completion-in-the-python-shell>_.

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 <https://jedi.readthedocs.org/en/latest/docs/development.html>_.

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 <https://jedi.readthedocs.org/en/latest/docs/testing.html>_.

Acknowledgements

Thanks a lot to all the contributors <https://jedi.readthedocs.org/en/latest/docs/acknowledgements.html>_!

Top Related Projects

Convert designs to code with AI

Introducing Visual Copilot: A new AI model to turn Figma designs to high quality code using your components.

Try Visual Copilot