Implemented a generic FuzzyCompleter that wraps around any other Completer.

Author: jonathanslenders

examples/prompts/auto-completion/fuzzy-custom-completer.py

@@ -0,0 +1,43 @@
+#!/usr/bin/env python
+"""
+Demonstration of a custom completer wrapped in a `FuzzyCompleter` for fuzzy
+matching.
+"""
+from __future__ import unicode_literals
+from prompt_toolkit.completion import Completion, Completer, FuzzyCompleter
+from prompt_toolkit.output.color_depth import ColorDepth
+from prompt_toolkit.shortcuts import prompt, CompleteStyle
+
+
+colors = ['red', 'blue', 'green', 'orange', 'purple', 'yellow', 'cyan',
+ 'magenta', 'pink']
+
+
+class ColorCompleter(Completer):
+ def get_completions(self, document, complete_event):
+ word = document.get_word_before_cursor()
+ for color in colors:
+ if color.startswith(word):
+ yield Completion(
+ color,
+ start_position=-len(word),
+ style='fg:' + color,
+ selected_style='fg:white bg:' + color)
+
+
+def main():
+ # Simple completion menu.
+ print('(The completion menu displays colors.)')
+ prompt('Type a color: ', completer=FuzzyCompleter(ColorCompleter()))
+
+ # Multi-column menu.
+ prompt('Type a color: ', completer=FuzzyCompleter(ColorCompleter()),
+ complete_style=CompleteStyle.MULTI_COLUMN)
+
+ # Readline-like
+ prompt('Type a color: ', completer=FuzzyCompleter(ColorCompleter()),
+ complete_style=CompleteStyle.READLINE_LIKE)
+
+
+if __name__ == '__main__':
+ main()

examples/prompts/auto-completion/fuzzycompletion.py renamed to examples/prompts/auto-completion/fuzzy-word-completer.py

@@ -2,7 +2,7 @@
 from .base import Completion, Completer, ThreadedCompleter, DummyCompleter, DynamicCompleter, CompleteEvent, merge_completers, get_common_complete_suffix
 from .filesystem import PathCompleter, ExecutableCompleter
 from .word_completer import WordCompleter
-from .fuzzy_completer import FuzzyWordCompleter
+from .fuzzy_completer import FuzzyCompleter, FuzzyWordCompleter
 
 __all__ = [
  # Base.
@@ -21,5 +21,6 @@
 
  # Word completer.
  'WordCompleter',
+ 'FuzzyCompleter',
  'FuzzyWordCompleter',
 ]

prompt_toolkit/completion/__init__.py

@@ -4,59 +4,90 @@
 from collections import namedtuple
 from six import string_types
 
-from prompt_toolkit.completion import Completer, Completion
+from prompt_toolkit.document import Document
+from prompt_toolkit.filters import to_filter
+
+from .base import Completer, Completion
+from .word_completer import WordCompleter
 
 __all__ = [
+ 'FuzzyCompleter',
  'FuzzyWordCompleter',
 ]
 
 
-class FuzzyWordCompleter(Completer):
+class FuzzyCompleter(Completer):
  """
- Fuzzy completion on a list of words.
+ Fuzzy completion.
+ This wraps any other completer and turns it into a fuzzy completer.
 
  If the list of words is: ["leopard" , "gorilla", "dinosaur", "cat", "bee"]
  Then trying to complete "oar" would yield "leopard" and "dinosaur", but not
  the others, because they match the regular expression 'o.*a.*r'.
+ Similar, in another application "djm" could expand to "django_migrations".
 
  The results are sorted by relevance, which is defined as the start position
  and the length of the match.
 
- See: https://blog.amjith.com/fuzzyfinder-in-10-lines-of-python
+ Notice that this is not really a tool to work around spelling mistakes,
+ like what would be possible with difflib. The purpose is rather to have a
+ quicker or more intuitive way to filter the given completions, especially
+ when many completions have a common prefix.
 
- :param words: List of words or callable that returns a list of words.
- :param meta_dict: Optional dict mapping words to their meta-information.
- :param WORD: When True, use WORD characters.
- :param sort_results: Boolean to determine whether to sort the results (default: True).
+ Fuzzy algorithm is based on this post:
+ https://blog.amjith.com/fuzzyfinder-in-10-lines-of-python
 
- Fuzzy algorithm is based on this post: https://blog.amjith.com/fuzzyfinder-in-10-lines-of-python
+ :param completer: A :class:`~.Completer` instance.
+ :param WORD: When True, use WORD characters.
+ :param pattern: Regex pattern which selects the characters before the
+ cursor that are considered for the fuzzy matching.
+ :param enable_fuzzy: (bool or `Filter`) Enabled the fuzzy behavior. For
+ easily turning fuzzyness on or off according to a certain condition.
  """
- def __init__(self, words, meta_dict=None, WORD=False, sort_results=True):
- assert callable(words) or all(isinstance(w, string_types) for w in words)
+ def __init__(self, completer, WORD=False, pattern=None, enable_fuzzy=True):
+ assert isinstance(completer, Completer)
+ assert pattern is None or pattern.startswith('^')
 
- self.words = words
- self.meta_dict = meta_dict or {}
- self.sort_results = sort_results
+ self.completer = completer
+ self.pattern = pattern
  self.WORD = WORD
+ self.pattern = pattern
+ self.enable_fuzzy = to_filter(enable_fuzzy)
 
  def get_completions(self, document, complete_event):
- # Get list of words.
- words = self.words
- if callable(words):
- words = words()
+ if self.enable_fuzzy():
+ return self._get_fuzzy_completions(document, complete_event)
+ else:
+ return self.completer.get_completions(document, complete_event)
+
+ def _get_pattern(self):
+ if self.pattern:
+ return self.pattern
+ if self.WORD:
+ return r'[^\s]+'
+ return '^[a-zA-Z0-9_]*'
+
+ def _get_fuzzy_completions(self, document, complete_event):
+ word_before_cursor = document.get_word_before_cursor(
+ pattern=re.compile(self._get_pattern()))
+
+ # Get completions
+ document2 = Document(
+ text=document.text[:document.cursor_position - len(word_before_cursor)],
+ cursor_position=document.cursor_position - len(word_before_cursor))
 
- word_before_cursor = document.get_word_before_cursor(WORD=self.WORD)
+ completions = list(self.completer.get_completions(document2, complete_event))
 
  fuzzy_matches = []
  pat = '.*?'.join(map(re.escape, word_before_cursor))
  pat = '(?=({0}))'.format(pat) # lookahead regex to manage overlapping matches
  regex = re.compile(pat, re.IGNORECASE)
- for word in words:
- matches = list(regex.finditer(word))
+ for compl in completions:
+ matches = list(regex.finditer(compl.text))
  if matches:
  # Prefer the match, closest to the left, then shortest.
  best = min(matches, key=lambda m: (m.start(), len(m.group(1))))
- fuzzy_matches.append(_FuzzyMatch(len(best.group(1)), best.start(), word))
+ fuzzy_matches.append(_FuzzyMatch(len(best.group(1)), best.start(), compl))
 
  def sort_key(fuzzy_match):
  " Sort by start position, then by the length of the match. "
@@ -65,45 +96,76 @@ def sort_key(fuzzy_match):
  fuzzy_matches = sorted(fuzzy_matches, key=sort_key)
 
  for match in fuzzy_matches:
- display_meta = self.meta_dict.get(match.word, '')
-
+ # Include these completions, but set the correct `display`
+ # attribute and `start_position`.
  yield Completion(
- match.word,
- -len(word_before_cursor),
- display_meta=display_meta,
- display=self._get_display(match, word_before_cursor))
+ match.completion.text,
+ start_position=match.completion.start_position - len(word_before_cursor),
+ display_meta=match.completion.display_meta,
+ display=self._get_display(match, word_before_cursor),
+ style=match.completion.style)
 
  def _get_display(self, fuzzy_match, word_before_cursor):
  """
  Generate formatted text for the display label.
  """
  m = fuzzy_match
+ word = m.completion.text
 
  if m.match_length == 0:
  # No highlighting when we have zero length matches (no input text).
- return m.word
+ return word
 
  result = []
 
  # Text before match.
- result.append(('class:fuzzymatch.outside', m.word[:m.start_pos]))
+ result.append(('class:fuzzymatch.outside', word[:m.start_pos]))
 
  # The match itself.
  characters = list(word_before_cursor)
 
- for c in m.word[m.start_pos:m.start_pos + m.match_length]:
+ for c in word[m.start_pos:m.start_pos + m.match_length]:
  classname = 'class:fuzzymatch.inside'
- if characters and c == characters[0]:
+ if characters and c.lower() == characters[0].lower():
  classname += '.character'
  del characters[0]
 
  result.append((classname, c))
 
  # Text after match.
  result.append(
- ('class:fuzzymatch.outside', m.word[m.start_pos + m.match_length:]))
+ ('class:fuzzymatch.outside', word[m.start_pos + m.match_length:]))
 
  return result
 
 
-_FuzzyMatch = namedtuple('_FuzzyMatch', 'match_length start_pos word')
+class FuzzyWordCompleter(Completer):
+ """
+ Fuzzy completion on a list of words.
+
+ (This is basically a `WordCompleter` wrapped in a `FuzzyCompleter`.)
+
+ :param words: List of words or callable that returns a list of words.
+ :param meta_dict: Optional dict mapping words to their meta-information.
+ :param WORD: When True, use WORD characters.
+ """
+ def __init__(self, words, meta_dict=None, WORD=False):
+ assert callable(words) or all(isinstance(w, string_types) for w in words)
+
+ self.words = words
+ self.meta_dict = meta_dict or {}
+ self.WORD = WORD
+
+ self.word_completer = WordCompleter(
+ words=lambda: self.words,
+ WORD=self.WORD)
+
+ self.fuzzy_completer = FuzzyCompleter(
+ self.word_completer,
+ WORD=self.WORD)
+
+ def get_completions(self, document, complete_event):
+ return self.fuzzy_completer.get_completions(document, complete_event)
+
+
+_FuzzyMatch = namedtuple('_FuzzyMatch', 'match_length start_pos completion')

prompt_toolkit/completion/fuzzy_completer.py

@@ -407,32 +407,50 @@ def find_backwards(self, sub, in_current_line=False, ignore_case=False, count=1)
  except StopIteration:
  pass
 
- def get_word_before_cursor(self, WORD=False):
+ def get_word_before_cursor(self, WORD=False, pattern=None):
  """
  Give the word before the cursor.
  If we have whitespace before the cursor this returns an empty string.
+
+ :param pattern: (None or compiled regex). When given, use this regex
+ pattern.
  """
- if self.text_before_cursor[-1:].isspace():
+ text_before_cursor = self.text_before_cursor
+ start = self.find_start_of_previous_word(WORD=WORD, pattern=pattern)
+
+ if start is None:
+ # Space before the cursor or no text before cursor.
  return ''
- else:
- return self.text_before_cursor[self.find_start_of_previous_word(WORD=WORD):]
 
- def find_start_of_previous_word(self, count=1, WORD=False):
+ return text_before_cursor[len(text_before_cursor) + start:]
+
+ def find_start_of_previous_word(self, count=1, WORD=False, pattern=None):
  """
  Return an index relative to the cursor position pointing to the start
  of the previous word. Return `None` if nothing was found.
+
+ :param pattern: (None or compiled regex). When given, use this regex
+ pattern.
  """
+ assert not (WORD and pattern)
+
  # Reverse the text before the cursor, in order to do an efficient
  # backwards search.
  text_before_cursor = self.text_before_cursor[::-1]
 
- regex = _FIND_BIG_WORD_RE if WORD else _FIND_WORD_RE
+ if pattern:
+ regex = pattern
+ elif WORD:
+ regex = _FIND_BIG_WORD_RE
+ else:
+ regex = _FIND_WORD_RE
+
  iterator = regex.finditer(text_before_cursor)
 
  try:
  for i, match in enumerate(iterator):
  if i + 1 == count:
- return - match.end(1)
+ return - match.end(0)
  except StopIteration:
  pass
 

prompt_toolkit/document.py

@@ -315,6 +315,7 @@ def get_words():
  assert [c.text for c in completions] == ['abc', 'aaa']
  assert called[0] == 2
 
+
 def test_fuzzy_completer():
  collection = [
  'migrations.py',