gh-130472: Integrate fancycompleter with the new repl, to get colored tab completions

Lib/_colorize.py

@@ -7,15 +7,19 @@
 
 class ANSIColors:
     BACKGROUND_YELLOW = "\x1b[43m"
+    BOLD_BLUE = "\x1b[1;34m"
     BOLD_GREEN = "\x1b[1;32m"
     BOLD_MAGENTA = "\x1b[1;35m"
     BOLD_RED = "\x1b[1;31m"
+    BOLD_TEAL = "\x1b[1;36m"
+    BOLD_YELLOW =  "\x1b[1;33m"
     BLACK = "\x1b[30m"
     GREEN = "\x1b[32m"
     GREY = "\x1b[90m"
     MAGENTA = "\x1b[35m"
     RED = "\x1b[31m"
     RESET = "\x1b[0m"
+    TEAL = "\x1b[36m"
     YELLOW = "\x1b[33m"
 
 

Lib/_pyrepl/fancycompleter.py

@@ -0,0 +1,205 @@
+#   Copyright 2010-2025 Antonio Cuni
+#                       Daniel Hahler
+#
+#                        All Rights Reserved
+"""
+Colorful TAB completion for Python prompt
+"""
+from _pyrepl import readline
+from _colorize import ANSIColors
+import rlcompleter
+import types
+from itertools import count
+
+
+class DefaultConfig:
+
+    consider_getitems = True
+    use_colors = 'auto'
+
+    color_by_type = {
+        types.BuiltinMethodType: ANSIColors.BOLD_TEAL,
+        types.MethodType: ANSIColors.BOLD_TEAL,
+        type((42).__add__): ANSIColors.BOLD_TEAL,
+        type(int.__add__): ANSIColors.BOLD_TEAL,
+        type(str.replace): ANSIColors.BOLD_TEAL,
+
+        types.FunctionType: ANSIColors.BOLD_BLUE,
+        types.BuiltinFunctionType: ANSIColors.BOLD_BLUE,
+
+        type: ANSIColors.BOLD_MAGENTA,
+
+        types.ModuleType: ANSIColors.TEAL,
+        type(None): ANSIColors.GREY,
+        str: ANSIColors.BOLD_GREEN,
+        bytes: ANSIColors.BOLD_GREEN,
+        int: ANSIColors.BOLD_YELLOW,
+        float: ANSIColors.BOLD_YELLOW,
+        complex: ANSIColors.BOLD_YELLOW,
+        bool: ANSIColors.BOLD_YELLOW,
+    }
+
+    def setup(self):
+        import _colorize
+        if self.use_colors == 'auto':
+            colors = _colorize.get_colors()
+            self.use_colors = colors.RED != ""
+
+
+class Completer(rlcompleter.Completer):
+    """
+    When doing someting like a.b.<TAB>, display only the attributes of
+    b instead of the full a.b.attr string.
+
+    Optionally, display the various completions in different colors
+    depending on the type.
+    """
+    def __init__(self, namespace=None, Config=DefaultConfig):
+        rlcompleter.Completer.__init__(self, namespace)
+        self.config = Config()
+        self.config.setup()
+
+        # XXX: double check what happens in this case once fancycompleter works
+        if False and hasattr(readline, '_setup'):
+            # this is needed to offer pyrepl a better chance to patch
+            # raw_input. Usually, it does at import time, but is we are under
+            # pytest with output captured, at import time we don't have a
+            # terminal and thus the raw_input hook is not installed
+            readline._setup()
+
+        if self.config.use_colors:
+            readline.parse_and_bind('set dont-escape-ctrl-chars on')
+        if self.config.consider_getitems:
+            delims = readline.get_completer_delims()
+            delims = delims.replace('[', '')
+            delims = delims.replace(']', '')
+            readline.set_completer_delims(delims)
+
+    def complete(self, text, state):
+        """
+        stolen from:
+        http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/496812
+        """
+        if text == "":
+            return ['\t', None][state]
+        else:
+            return rlcompleter.Completer.complete(self, text, state)
+
+    def _callable_postfix(self, val, word):
+        # disable automatic insertion of '(' for global callables:
+        # this method exists only in Python 2.6+
+        return word
+
+    def global_matches(self, text):
+        import keyword
+        names = rlcompleter.Completer.global_matches(self, text)
+        prefix = commonprefix(names)
+        if prefix and prefix != text:
+            return [prefix]
+
+        names.sort()
+        values = []
+        for name in names:
+            clean_name = name.rstrip(': ')
+            if clean_name in keyword.kwlist:
+                values.append(None)
+            else:
+                try:
+                    values.append(eval(name, self.namespace))
+                except Exception as exc:
+                    values.append(None)
+        if self.config.use_colors and names:
+            return self.colorize_matches(names, values)
+        return names
+
+    def attr_matches(self, text):
+        expr, attr = text.rsplit('.', 1)
+        if '(' in expr or ')' in expr:  # don't call functions
+            return []
+        try:
+            thisobject = eval(expr, self.namespace)
+        except Exception:
+            return []
+
+        # get the content of the object, except __builtins__
+        words = set(dir(thisobject))
+        words.discard("__builtins__")
+
+        if hasattr(thisobject, '__class__'):
+            words.add('__class__')
+            words.update(rlcompleter.get_class_members(thisobject.__class__))
+        names = []
+        values = []
+        n = len(attr)
+        if attr == '':
+            noprefix = '_'
+        elif attr == '_':
+            noprefix = '__'
+        else:
+            noprefix = None
+        words = sorted(words)
+        while True:
+            for word in words:
+                if (word[:n] == attr and
+                        not (noprefix and word[:n+1] == noprefix)):
+                    try:
+                        val = getattr(thisobject, word)
+                    except Exception:
+                        val = None  # Include even if attribute not set
+
+                    names.append(word)
+                    values.append(val)
+            if names or not noprefix:
+                break
+            if noprefix == '_':
+                noprefix = '__'
+            else:
+                noprefix = None
+
+        if not names:
+            return []
+
+        if len(names) == 1:
+            return ['%s.%s' % (expr, names[0])]  # only option, no coloring.
+
+        prefix = commonprefix(names)
+        if prefix and prefix != attr:
+            return ['%s.%s' % (expr, prefix)]  # autocomplete prefix
+
+        if self.config.use_colors:
+            return self.colorize_matches(names, values)
+
+        if prefix:
+            names += [' ']
+        return names
+
+    def colorize_matches(self, names, values):
+        matches = [self.color_for_obj(i, name, obj)
+                   for i, name, obj
+                   in zip(count(), names, values)]
+        # We add a space at the end to prevent the automatic completion of the
+        # common prefix, which is the ANSI ESCAPE sequence.
+        return matches + [' ']
+
+    def color_for_obj(self, i, name, value):
+        t = type(value)
+        color = self.config.color_by_type.get(t, ANSIColors.RESET)
+        # hack: prepend an (increasing) fake escape sequence,
+        # so that readline can sort the matches correctly.
+        N = f"\x1b[{i:03d};00m"
+        return f"{N}{color}{name}{ANSIColors.RESET}"
+
+
+def commonprefix(names, base=''):
+    """ return the common prefix of all 'names' starting with 'base'
+    """
+    if base:
+        names = [x for x in names if x.startswith(base)]
+    if not names:
+        return ''
+    s1 = min(names)
+    s2 = max(names)
+    for i, c in enumerate(s1):
+        if c != s2[i]:
+            return s1[:i]
+    return s1

Lib/_pyrepl/readline.py

@@ -35,6 +35,7 @@
 from site import gethistoryfile   # type: ignore[attr-defined]
 import sys
 from rlcompleter import Completer as RLCompleter
+from .fancycompleter import Completer as FancyCompleter
 
 from . import commands, historical_reader
 from .completing_reader import CompletingReader
@@ -587,7 +588,12 @@ def _setup(namespace: Mapping[str, Any]) -> None:
     # set up namespace in rlcompleter, which requires it to be a bona fide dict
     if not isinstance(namespace, dict):
         namespace = dict(namespace)
-    _wrapper.config.readline_completer = RLCompleter(namespace).complete
+
+    if os.getenv('PYTHON_BASIC_COMPLETER'):
+        Completer = RLCompleter
+    else:
+        Completer = FancyCompleter
+    _wrapper.config.readline_completer = Completer(namespace).complete
 
     # this is not really what readline.c does.  Better than nothing I guess
     import builtins