Added DeduplicateCompleter and ConditionalCompleter.

Also added a `deduplicate` argument to merge_completers.

Author: jonathanslenders

prompt_toolkit/completion/__init__.py

@@ -2,12 +2,14 @@
     CompleteEvent,
     Completer,
     Completion,
+    ConditionalCompleter,
     DummyCompleter,
     DynamicCompleter,
     ThreadedCompleter,
     get_common_complete_suffix,
     merge_completers,
 )
+from .deduplicate import DeduplicateCompleter
 from .filesystem import ExecutableCompleter, PathCompleter
 from .fuzzy_completer import FuzzyCompleter, FuzzyWordCompleter
 from .nested import NestedCompleter
@@ -21,6 +23,7 @@
     "DummyCompleter",
     "DynamicCompleter",
     "CompleteEvent",
+    "ConditionalCompleter",
     "merge_completers",
     "get_common_complete_suffix",
     # Filesystem.
@@ -33,4 +36,6 @@
     "NestedCompleter",
     # Word completer.
     "WordCompleter",
+    # Deduplicate
+    "DeduplicateCompleter",
 ]

prompt_toolkit/completion/base.py

@@ -5,6 +5,7 @@
 
 from prompt_toolkit.document import Document
 from prompt_toolkit.eventloop import generator_to_async_generator
+from prompt_toolkit.filters import FilterOrBool, to_filter
 from prompt_toolkit.formatted_text import AnyFormattedText, StyleAndTextTuples
 
 __all__ = [
@@ -14,6 +15,7 @@
     "DummyCompleter",
     "DynamicCompleter",
     "CompleteEvent",
+    "ConditionalCompleter",
     "merge_completers",
     "get_common_complete_suffix",
 ]
@@ -275,6 +277,42 @@ def __repr__(self) -> str:
         return "DynamicCompleter(%r -> %r)" % (self.get_completer, self.get_completer())
 
 
+class ConditionalCompleter(Completer):
+    """
+    Wrapper around any other completer that will enable/disable the completions
+    depending on whether the received condition is satisfied.
+
+    :param completer: :class:`.Completer` instance.
+    :param filter: :class:`.Filter` instance.
+    """
+
+    def __init__(self, completer: Completer, filter: FilterOrBool) -> None:
+        self.completer = completer
+        self.filter = to_filter(filter)
+
+    def __repr__(self) -> str:
+        return "ConditionalCompleter(%r, filter=%r)" % (self.completer, self.filter)
+
+    def get_completions(
+        self, document: Document, complete_event: CompleteEvent
+    ) -> Iterable[Completion]:
+        # Get all completions in a blocking way.
+        if self.filter():
+            for c in self.completer.get_completions(document, complete_event):
+                yield c
+
+    async def get_completions_async(
+        self, document: Document, complete_event: CompleteEvent
+    ) -> AsyncGenerator[Completion, None]:
+
+        # Get all completions in a non-blocking way.
+        if self.filter():
+            async for item in self.completer.get_completions_async(
+                document, complete_event
+            ):
+                yield item
+
+
 class _MergedCompleter(Completer):
     """
     Combine several completers into one.
@@ -295,16 +333,27 @@ async def get_completions_async(
         self, document: Document, complete_event: CompleteEvent
     ) -> AsyncGenerator[Completion, None]:
 
-        # Get all completions from the other completers in a blocking way.
+        # Get all completions from the other completers in a non-blocking way.
         for completer in self.completers:
             async for item in completer.get_completions_async(document, complete_event):
                 yield item
 
 
-def merge_completers(completers: Sequence[Completer]) -> _MergedCompleter:
+def merge_completers(
+    completers: Sequence[Completer], deduplicate: bool = False
+) -> Completer:
     """
     Combine several completers into one.
+
+    :param deduplicate: If `True`, wrap the result in a `DeduplicateCompleter`
+        so that completions that would result in the same text will be
+        deduplicated.
     """
+    if deduplicate:
+        from .deduplicate import DeduplicateCompleter
+
+        return DeduplicateCompleter(_MergedCompleter(completers))
+
     return _MergedCompleter(completers)
 
 

prompt_toolkit/completion/deduplicate.py

@@ -0,0 +1,43 @@
+from typing import Iterable, Set
+
+from prompt_toolkit.document import Document
+
+from .base import CompleteEvent, Completer, Completion
+
+__all__ = ["DeduplicateCompleter"]
+
+
+class DeduplicateCompleter(Completer):
+    """
+    Wrapper around a completer that removes duplicates. Only the first unique
+    completions are kept.
+
+    Completions are considered to be a duplicate if they result in the same
+    document text when they would be applied.
+    """
+
+    def __init__(self, completer: Completer) -> None:
+        self.completer = completer
+
+    def get_completions(
+        self, document: Document, complete_event: CompleteEvent
+    ) -> Iterable[Completion]:
+        # Keep track of the document strings we'd get after applying any completion.
+        found_so_far: Set[str] = set()
+
+        for completion in self.completer.get_completions(document, complete_event):
+            text_if_applied = (
+                document.text[: document.cursor_position + completion.start_position]
+                + completion.text
+                + document.text[document.cursor_position :]
+            )
+
+            if text_if_applied == document.text:
+                # Don't include completions that don't have any effect at all.
+                continue
+
+            if text_if_applied in found_so_far:
+                continue
+
+            found_so_far.add(text_if_applied)
+            yield completion

tests/test_completion.py

@@ -6,10 +6,12 @@
 
 from prompt_toolkit.completion import (
     CompleteEvent,
+    DeduplicateCompleter,
     FuzzyWordCompleter,
     NestedCompleter,
     PathCompleter,
     WordCompleter,
+    merge_completers,
 )
 from prompt_toolkit.document import Document
 
@@ -439,3 +441,28 @@ def test_nested_completer():
         Document("show ip interface br"), CompleteEvent()
     )
     assert {c.text for c in completions} == {"brief"}
+
+
+def test_deduplicate_completer():
+    def create_completer(deduplicate: bool):
+        return merge_completers(
+            [
+                WordCompleter(["hello", "world", "abc", "def"]),
+                WordCompleter(["xyz", "xyz", "abc", "def"]),
+            ],
+            deduplicate=deduplicate,
+        )
+
+    completions = list(
+        create_completer(deduplicate=False).get_completions(
+            Document(""), CompleteEvent()
+        )
+    )
+    assert len(completions) == 8
+
+    completions = list(
+        create_completer(deduplicate=True).get_completions(
+            Document(""), CompleteEvent()
+        )
+    )
+    assert len(completions) == 5