I am trying to use jedi to complete python code inside a PyQt application, using QCompleter and QStringListModel to store the possible completion.

Here's a simple working demo:

#!/usr/bin/env python3

from PyQt5.QtCore import *
from PyQt5.QtWidgets import *
import jedi
import sys

class JediEdit(QLineEdit):
    def __init__(self, parent=None):
        super().__init__(parent)

        self._model = QStringListModel()
        self._compl = QCompleter()
        self._compl.setModel(self._model)
        self.setCompleter(self._compl)
        self.textEdited.connect(self.update_model)

    def update_model(self, cur_text):
        script = jedi.Script(cur_text)
        compl = script.completions()
        strings = list(cur_text + c.complete for c in compl) 
        self._model.setStringList(strings)

if __name__ == '__main__':
    app = QApplication(sys.argv)
    line = JediEdit()
    line.show()
    sys.exit(app.exec_())

If you run the application and write a code which is not completing anything (e.g. or foo =), the completion will actually show all the possible tokens that can go in that position.

So, if I run and write a space in the field, lots of things pops up, from abs to __version__.

I would like to prevent this: is it possible to query jedi.Script to understand if the token is being completed or if a completely new token is starting?

EDIT: another little question: say that I am running an interpreter which is detached from jedi current state. How can I provide local and global variables to jedi.Script so that it will take into account those, instead of its own completions?

Autocompletion

Jedi's autocompletion will always show all possible tokens in a place. That's the whole point in autocompletion.

If you don't want that behavior just scan the last few characters for whitespace and certain other characters like = or :, it would be a very simple regex command. (You could also try to look up Jedi's internals and use the way how Jedi knows about this context. However I'm not going to tell you, because it's not a public API and IMHO regex calls suffice.)

In the future something like that might be possible. (See https://github.com/davidhalter/jedi/issues/253).

Now that I think about it, there might be another way that you could experiment with this: You can try to play with Completion.name and Completion.complete. The latter only gives you what could come after the current token, while the name would be the full thing. So you can compare and if they are equal than you might not want to display anything. Have fun playing with the API :-)

Interpreter

If you're running an interpreter, you can use jedi.Interpreter to combine code with actual Python objects. It's pretty flexible. But please note that the current Interpreter (0.8.1) is very buggy. Please use the master branch from Github (0.9.0).