Improved autocompletion:

- Added fuzzy completion.
- Added dictionary key completion (for keys which are strings).
- Highlighting of Python keywords in completion drop down.

Author: jonathanslenders

examples/ptpython_config/config.py

@@ -61,6 +61,10 @@ def configure(repl):
     # completion menu is shown.)
     repl.complete_while_typing = True
 
+    # Fuzzy and dictionary completion.
+    self.enable_fuzzy_completion = False
+    self.enable_dictionary_completion = False
+
     # Vi mode.
     repl.vi_mode = False
 

ptpython/completer.py

@@ -6,7 +6,10 @@
 
 from ptpython.utils import get_jedi_script_from_document
 
+import keyword
+import ast
 import re
+import six
 
 __all__ = (
     'PythonCompleter',
@@ -17,11 +20,14 @@ class PythonCompleter(Completer):
     """
     Completer for Python code.
     """
-    def __init__(self, get_globals, get_locals):
+    def __init__(self, get_globals, get_locals, get_enable_dictionary_completion):
         super(PythonCompleter, self).__init__()
 
         self.get_globals = get_globals
         self.get_locals = get_locals
+        self.get_enable_dictionary_completion = get_enable_dictionary_completion
+
+        self.dictionary_completer = DictionaryCompleter(get_globals, get_locals)
 
         self._path_completer_cache = None
         self._path_completer_grammar_cache = None
@@ -108,7 +114,16 @@ def get_completions(self, document, complete_event):
         """
         Get Python completions.
         """
-        # Do Path completions
+        # Do dictionary key completions.
+        if self.get_enable_dictionary_completion():
+            has_dict_completions = False
+            for c in self.dictionary_completer.get_completions(document, complete_event):
+                has_dict_completions = True
+                yield c
+            if has_dict_completions:
+                return
+
+        # Do Path completions (if there were no dictionary completions).
         if complete_event.completion_requested or self._complete_path_while_typing(document):
             for c in self._path_completer.get_completions(document, complete_event):
                 yield c
@@ -162,5 +177,107 @@ def get_completions(self, document, complete_event):
                     pass
                 else:
                     for c in completions:
-                        yield Completion(c.name_with_symbols, len(c.complete) - len(c.name_with_symbols),
-                                         display=c.name_with_symbols)
+                        yield Completion(
+                            c.name_with_symbols, len(c.complete) - len(c.name_with_symbols),
+                            display=c.name_with_symbols,
+                            style=_get_style_for_name(c.name_with_symbols))
+
+
+class DictionaryCompleter(Completer):
+    """
+    Experimental completer for Python dictionary keys.
+
+    Warning: This does an `eval` on the Python object before the open square
+             bracket, which is potentially dangerous. It doesn't match on
+             function calls, so it only triggers attribute access.
+    """
+    def __init__(self, get_globals, get_locals):
+        super(DictionaryCompleter, self).__init__()
+
+        self.get_globals = get_globals
+        self.get_locals = get_locals
+
+        self.pattern = re.compile(
+            r'''
+                # Any expression safe enough to eval while typing.
+                # No operators, except dot, and only other dict lookups.
+                # Technically, this can be unsafe of course, if bad code runs
+                # in `__getattr__` or ``__getitem__``.
+                (
+                    # Variable name
+                    [a-zA-Z0-9_]+
+
+                    \s*
+
+                    (?:
+                        # Attribute access.
+                        \s* \. \s* [a-zA-Z0-9_]+ \s*
+
+                        |
+
+                        # Item lookup.
+                        # (We match the square brackets. We don't care about
+                        # matching quotes here in the regex. Nested square
+                        # brackets are not supported.)
+                        \s* \[ [a-zA-Z0-9_'"\s]+ \] \s*
+                    )*
+                )
+
+                # Dict loopup to complete (square bracket open + start of
+                # string).
+                \[
+                \s* ([a-zA-Z0-9_'"]*)$
+            ''',
+            re.VERBOSE
+        )
+
+    def get_completions(self, document, complete_event):
+        match = self.pattern.search(document.text_before_cursor)
+        if match is not None:
+            object_var, key = match.groups()
+            object_var = object_var.strip()
+
+            # Do lookup of `object_var` in the context.
+            try:
+                result = eval(object_var, self.get_globals(), self.get_locals())
+            except BaseException as e:
+                return  # Many exception, like NameError can be thrown here.
+
+            # If this object is a dictionary, complete the keys.
+            if isinstance(result, dict):
+                # Try to evaluate the key.
+                key_obj = key
+                for k in [key, key + '"', key + "'"]:
+                    try:
+                        key_obj = ast.literal_eval(k)
+                    except (SyntaxError, ValueError):
+                        continue
+                    else:
+                        break
+
+                for k in result:
+                    if six.text_type(k).startswith(key_obj):
+                        yield Completion(
+                            six.text_type(repr(k)),
+                            - len(key),
+                            display=six.text_type(repr(k))
+                        )
+
+try:
+    import builtins
+    _builtin_names = dir(builtins)
+except ImportError:  # Python 2.
+    _builtin_names = []
+
+
+def _get_style_for_name(name):
+    """
+    Return completion style to use for this name.
+    """
+    if name in _builtin_names:
+        return 'class:completion.builtin'
+
+    if keyword.iskeyword(name):
+        return 'class:completion.keyword'
+
+    return ''

ptpython/python_input.py

@@ -25,6 +25,7 @@
 from prompt_toolkit.styles import DynamicStyle, SwapLightAndDarkStyleTransformation, ConditionalStyleTransformation, AdjustBrightnessStyleTransformation, merge_style_transformations
 from prompt_toolkit.utils import is_windows
 from prompt_toolkit.validation import ConditionalValidator
+from prompt_toolkit.completion import FuzzyCompleter
 
 from .completer import PythonCompleter
 from .history_browser import History
@@ -151,7 +152,10 @@ def __init__(self,
         self.get_globals = get_globals or (lambda: {})
         self.get_locals = get_locals or self.get_globals
 
-        self._completer = _completer or PythonCompleter(self.get_globals, self.get_locals)
+        self._completer = _completer or FuzzyCompleter(
+            PythonCompleter(self.get_globals, self.get_locals,
+                            lambda: self.enable_dictionary_completion),
+            enable_fuzzy=Condition(lambda: self.enable_fuzzy_completion))
         self._validator = _validator or PythonValidator(self.get_compiler_flags)
         self._lexer = _lexer or PygmentsLexer(PythonLexer)
 
@@ -193,6 +197,8 @@ def __init__(self,
                                             # with the current input.
 
         self.enable_syntax_highlighting = True
+        self.enable_fuzzy_completion = False
+        self.enable_dictionary_completion = False
         self.swap_light_and_dark = False
         self.highlight_matching_parenthesis = False
         self.show_sidebar = False  # Currently show the sidebar.
@@ -433,6 +439,23 @@ def get_values():
                            'on': lambda: enable('complete_while_typing') and disable('enable_history_search'),
                            'off': lambda: disable('complete_while_typing'),
                        }),
+                Option(title='Enable fuzzy completion',
+                       description="Enable fuzzy completion.",
+                       get_current_value=lambda: ['off', 'on'][self.enable_fuzzy_completion],
+                       get_values=lambda: {
+                           'on': lambda: enable('enable_fuzzy_completion'),
+                           'off': lambda: disable('enable_fuzzy_completion'),
+                       }),
+                Option(title='Dictionary completion',
+                       description='Enable experimental dictionary completion.\n'
+                                   'WARNING: this does "eval" on fragments of\n'
+                                   '         your Python input and is\n'
+                                   '         potentially unsafe.',
+                       get_current_value=lambda: ['off', 'on'][self.enable_dictionary_completion],
+                       get_values=lambda: {
+                           'on': lambda: enable('enable_dictionary_completion'),
+                           'off': lambda: disable('enable_dictionary_completion'),
+                       }),
                 Option(title='History search',
                        description='When pressing the up-arrow, filter the history on input starting '
                                    'with the current text. (Not compatible with "Complete while typing".)',

ptpython/style.py

@@ -83,6 +83,13 @@ def generate_style(python_style, ui_style):
     'out':                                    '#ff0000',
     'out.number':                             '#ff0000',
 
+    # Completions.
+    'completion.builtin':                     '',
+    'completion.keyword':                     'fg:#008800',
+
+    'completion.keyword fuzzymatch.inside':   'fg:#008800',
+    'completion.keyword fuzzymatch.outside':  'fg:#44aa44',
+
     # Separator between windows. (Used above docstring.)
     'separator':                              '#bbbbbb',
 

setup.py

@@ -18,7 +18,7 @@
     install_requires = [
         'docopt',
         'jedi>=0.9.0',
-        'prompt_toolkit>=2.0.6,<2.1.0',
+        'prompt_toolkit>=2.0.8,<2.1.0',
         'pygments',
     ],
     classifiers=[