The Jedi Linter is currently in an alpha version and can be tested by calling
python-mjedilinter.

Jedi would in theory support refactoring, but we have never publicized it,
because it’s not production ready. If you’re interested in helping out here,
let me know. With the latest parser changes, it should be very easy to actually
make it work.

Syntax errors and other strange stuff may lead to undefined behaviour of the
completion. Jedi is NOT a Python compiler, that tries to correct you. It
is a tool that wants to help you. But YOU have to know Python, not Jedi.

Legacy Python 2 Features

This framework should work for both Python 2/3. However, some things were just
not as pythonic in Python 2 as things should be. To keep things simple, some
older Python 2 features have been left out:

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 write import
hooks in Jedi, which preload stuff. However, once loaded, this is not a
problem anymore. The same is true for huge modules like PySide, wx,
etc.

Security

Security is an important issue for Jedi. Therefore no Python code is
executed. As long as you write pure python, everything is evaluated
statically. But: If you use builtin modules (c_builtin) there is no other
option than to execute those modules. However: Execute isn’t that critical (as
e.g. in pythoncomplete, which used to execute every import!), because it
means one import and no more. So basically the only dangerous thing is using
the import itself. If your c_builtin uses some strange initializations, it
might be dangerous. But if it does you’re screwed anyways, because eventualy
you’re going to execute your code, which executes the import.

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

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 hasn’t so much to do with Star Wars. It’s part of my
second name.

After I explained Guido van Rossum, how some parts of my auto-completion work,
he said (we drank a beer or two):

“Oh, that worries me...”

When it’s finished, I hope he’ll like it :-)

I actually started Jedi, because there were no good solutions available for VIM.
Most auto-completions just didn’t work well. The only good solution was PyCharm.
But I like my good old VIM. Rope was never really intended to be an
auto-completion (and also I really hate project folders for my Python scripts).
It’s more of a refactoring suite. So I decided to do my own version of a
completion, which would execute non-dangerous code. But I soon realized, that
this wouldn’t work. So I built an extremely recursive thing which understands
many of Python’s key features.

By the way, I really tried to program it as understandable as possible. But I
think understanding it might need quite some time, because of its recursive
nature.