I am done

rl/Lib/site-packages/pyreadline3/__init__.py

@@ -0,0 +1,37 @@
+# -*- coding: utf-8 -*-
+# *****************************************************************************
+#       Copyright (C) 2003-2006 Gary Bishop.
+#       Copyright (C) 2006-2020 Jorgen Stenarson. <jorgen.stenarson@bostream.nu>
+#       Copyright (C) 2020 Bassem Girgis. <brgirgis@gmail.com>
+#
+#  Distributed under the terms of the BSD License.  The full license is in
+#  the file COPYING, distributed as part of this software.
+# *****************************************************************************
+
+
+from platform import system
+from importlib.metadata import version, PackageNotFoundError
+
+from . import (
+    clipboard,
+    console,
+    lineeditor,
+    logger,
+    modes,
+    rlmain,
+    unicode_helper,
+)
+from .rlmain import *
+
+_S = system()
+
+if _S.lower() != "windows":
+    raise RuntimeError("pyreadline3 is for Windows only, not {}.".format(_S))
+
+del system, _S
+
+try:
+    __version__ = version("pyreadline3")
+except PackageNotFoundError:
+    # package is not installed
+    pass

rl/Lib/site-packages/pyreadline3/clipboard/__init__.py

@@ -0,0 +1,16 @@
+# -*- coding: utf-8 -*-
+# *****************************************************************************
+#     Copyright (C) 2006-2020 Jorgen Stenarson. <jorgen.stenarson@bostream.nu>
+#     Copyright (C) 2020 Bassem Girgis. <brgirgis@gmail.com>
+#
+#  Distributed under the terms of the BSD License.  The full license is in
+#  the file COPYING, distributed as part of this software.
+# *****************************************************************************
+
+from .api import set_clipboard_text
+from .get_clipboard_text_and_convert import get_clipboard_text_and_convert
+
+__all__ = [
+    "set_clipboard_text",
+    "get_clipboard_text_and_convert",
+]

rl/Lib/site-packages/pyreadline3/clipboard/api.py

@@ -0,0 +1,27 @@
+# -*- coding: utf-8 -*-
+# *****************************************************************************
+#     Copyright (C) 2006-2020 Jorgen Stenarson. <jorgen.stenarson@bostream.nu>
+#     Copyright (C) 2020 Bassem Girgis. <brgirgis@gmail.com>
+#
+#  Distributed under the terms of the BSD License.  The full license is in
+#  the file COPYING, distributed as part of this software.
+# *****************************************************************************
+
+from pyreadline3.py3k_compat import is_ironpython
+
+if is_ironpython:
+    try:
+        from .ironpython_clipboard import get_clipboard_text, set_clipboard_text
+    except ImportError:
+        from .no_clipboard import get_clipboard_text, set_clipboard_text
+
+else:
+    try:
+        from .win32_clipboard import get_clipboard_text, set_clipboard_text
+    except ImportError:
+        from .no_clipboard import get_clipboard_text, set_clipboard_text
+
+__all__ = [
+    "get_clipboard_text",
+    "set_clipboard_text",
+]

rl/Lib/site-packages/pyreadline3/clipboard/get_clipboard_text_and_convert.py

@@ -0,0 +1,75 @@
+# -*- coding: utf-8 -*-
+# *****************************************************************************
+#     Copyright (C) 2006-2020 Jorgen Stenarson. <jorgen.stenarson@bostream.nu>
+#     Copyright (C) 2020 Bassem Girgis. <brgirgis@gmail.com>
+#
+#  Distributed under the terms of the BSD License.  The full license is in
+#  the file COPYING, distributed as part of this software.
+# *****************************************************************************
+
+from typing import Any, List, Tuple
+
+from .api import get_clipboard_text
+
+
+def _make_num(x: Any) -> Any:
+    try:
+        return int(x)
+    except ValueError:
+        try:
+            return float(x)
+        except ValueError:
+            try:
+                return complex(x)
+            except ValueError:
+                return x
+
+
+def _make_list_of_list(txt: str) -> Tuple[
+    List[List[Any]],
+    bool,
+]:
+
+    ut = []
+    flag = False
+
+    for line in [x for x in txt.split("\r\n") if x != ""]:
+        words = [_make_num(x) for x in line.split("\t")]
+
+        if str in list(map(type, words)):
+            flag = True
+
+        ut.append(words)
+
+    return (
+        ut,
+        flag,
+    )
+
+
+def get_clipboard_text_and_convert(paste_list: bool = False) -> str:
+    """Get txt from clipboard. if paste_list==True the convert tab separated
+    data to list of lists. Enclose list of list in array() if all elements are
+    numeric"""
+
+    txt = get_clipboard_text()
+
+    if not txt:
+        return ""
+
+    if not paste_list:
+        return txt
+
+    if "\t" not in txt:
+        return txt
+
+    array, flag = _make_list_of_list(txt)
+
+    if flag:
+        txt = repr(array)
+    else:
+        txt = "array(%s)" % repr(array)
+
+    txt = "".join([c for c in txt if c not in " \t\r\n"])
+
+    return txt

rl/Lib/site-packages/pyreadline3/clipboard/ironpython_clipboard.py

@@ -0,0 +1,31 @@
+# -*- coding: utf-8 -*-
+# *****************************************************************************
+#     Copyright (C) 2006-2020 Jorgen Stenarson. <jorgen.stenarson@bostream.nu>
+#     Copyright (C) 2020 Bassem Girgis. <brgirgis@gmail.com>
+#
+#  Distributed under the terms of the BSD License.  The full license is in
+#  the file COPYING, distributed as part of this software.
+# *****************************************************************************
+
+
+import clr
+import System.Windows.Forms.Clipboard as cb
+
+clr.AddReferenceByPartialName("System.Windows.Forms")
+
+
+def get_clipboard_text() -> str:
+    text = ""
+    if cb.ContainsText():
+        text = cb.GetText()
+
+    return text
+
+
+def set_clipboard_text(text: str) -> None:
+    cb.SetText(text)
+
+
+if __name__ == "__main__":
+    txt = get_clipboard_text()  # display last text clipped
+    print(txt)

rl/Lib/site-packages/pyreadline3/clipboard/no_clipboard.py

@@ -0,0 +1,19 @@
+# -*- coding: utf-8 -*-
+# *****************************************************************************
+#     Copyright (C) 2006-2020 Jorgen Stenarson. <jorgen.stenarson@bostream.nu>
+#     Copyright (C) 2020 Bassem Girgis. <brgirgis@gmail.com>
+#
+#  Distributed under the terms of the BSD License.  The full license is in
+#  the file COPYING, distributed as part of this software.
+# *****************************************************************************
+
+GLOBAL_CLIPBOARD_BUFFER = ""
+
+
+def get_clipboard_text() -> str:
+    return GLOBAL_CLIPBOARD_BUFFER
+
+
+def set_clipboard_text(text: str) -> None:
+    global GLOBAL_CLIPBOARD_BUFFER
+    GLOBAL_CLIPBOARD_BUFFER = text

rl/Lib/site-packages/pyreadline3/clipboard/obsolete.py

@@ -0,0 +1,30 @@
+# -*- coding: utf-8 -*-
+# *****************************************************************************
+#     Copyright (C) 2006-2020 Jorgen Stenarson. <jorgen.stenarson@bostream.nu>
+#     Copyright (C) 2020 Bassem Girgis. <brgirgis@gmail.com>
+#
+#  Distributed under the terms of the BSD License.  The full license is in
+#  the file COPYING, distributed as part of this software.
+# *****************************************************************************
+
+from typing import Any, List
+
+from .api import set_clipboard_text
+
+
+def _make_tab(lists: List[Any]) -> str:
+    if hasattr(lists, "tolist"):
+        lists = lists.tolist()
+
+    ut = []
+    for rad in lists:
+        if type(rad) in [list, tuple]:
+            ut.append("\t".join(["%s" % x for x in rad]))
+        else:
+            ut.append("%s" % rad)
+
+    return "\n".join(ut)
+
+
+def _send_data(lists: List[Any]) -> None:
+    set_clipboard_text(_make_tab(lists))

rl/Lib/site-packages/pyreadline3/clipboard/win32_clipboard.py

@@ -0,0 +1,157 @@
+# -*- coding: utf-8 -*-
+# *****************************************************************************
+#     Copyright (C) 2003-2006 Jack Trainor.
+#     Copyright (C) 2006-2020 Jorgen Stenarson. <jorgen.stenarson@bostream.nu>
+#     Copyright (C) 2020 Bassem Girgis. <brgirgis@gmail.com>
+#
+#  Distributed under the terms of the BSD License.  The full license is in
+#  the file COPYING, distributed as part of this software.
+# *****************************************************************************
+###################################
+#
+# Based on recipe posted to ctypes-users
+# see archive
+# http://aspn.activestate.com/ASPN/Mail/Message/ctypes-users/1771866
+#
+#
+
+##########################################################################
+#
+# The Python win32clipboard lib functions work well enough ... except that they
+# can only cut and paste items from within one application, not across
+# applications or processes.
+#
+# I've written a number of Python text filters I like to run on the contents of
+# the clipboard so I need to call the Windows clipboard API with global memory
+# for my filters to work properly.
+#
+# Here's some sample code solving this problem using ctypes.
+#
+# This is my first work with ctypes.  It's powerful stuff, but passing
+# arguments in and out of functions is tricky.  More sample code would have
+# been helpful, hence this contribution.
+#
+##########################################################################
+
+import ctypes
+import ctypes.wintypes as wintypes
+from ctypes import (
+    addressof,
+    c_buffer,
+    c_char_p,
+    c_int,
+    c_size_t,
+    c_void_p,
+    c_wchar_p,
+    cast,
+    create_unicode_buffer,
+    sizeof,
+    windll,
+    wstring_at,
+)
+from typing import Union
+
+from pyreadline3.keysyms.winconstants import CF_UNICODETEXT, GHND
+from pyreadline3.unicode_helper import ensure_unicode
+
+OpenClipboard = windll.user32.OpenClipboard
+OpenClipboard.argtypes = [wintypes.HWND]
+OpenClipboard.restype = wintypes.BOOL
+
+EmptyClipboard = windll.user32.EmptyClipboard
+
+GetClipboardData = windll.user32.GetClipboardData
+GetClipboardData.argtypes = [wintypes.UINT]
+GetClipboardData.restype = wintypes.HANDLE
+
+GetClipboardFormatName = windll.user32.GetClipboardFormatNameA
+GetClipboardFormatName.argtypes = [wintypes.UINT, c_char_p, c_int]
+
+SetClipboardData = windll.user32.SetClipboardData
+SetClipboardData.argtypes = [wintypes.UINT, wintypes.HANDLE]
+SetClipboardData.restype = wintypes.HANDLE
+
+EnumClipboardFormats = windll.user32.EnumClipboardFormats
+EnumClipboardFormats.argtypes = [c_int]
+
+CloseClipboard = windll.user32.CloseClipboard
+CloseClipboard.argtypes = []
+
+
+GlobalAlloc = windll.kernel32.GlobalAlloc
+GlobalAlloc.argtypes = [wintypes.UINT, c_size_t]
+GlobalAlloc.restype = wintypes.HGLOBAL
+GlobalLock = windll.kernel32.GlobalLock
+GlobalLock.argtypes = [wintypes.HGLOBAL]
+GlobalLock.restype = c_void_p
+GlobalUnlock = windll.kernel32.GlobalUnlock
+GlobalUnlock.argtypes = [c_int]
+
+_strncpy = ctypes.windll.kernel32.lstrcpynW
+_strncpy.restype = c_wchar_p
+_strncpy.argtypes = [c_wchar_p, c_wchar_p, c_size_t]
+
+
+def _enum() -> None:
+    OpenClipboard(0)
+
+    q = EnumClipboardFormats(0)
+    while q:
+        q = EnumClipboardFormats(q)
+
+    CloseClipboard()
+
+
+def _get_format_name(format_str: str) -> bytes:
+    buffer = c_buffer(100)
+    bufferSize = sizeof(buffer)
+
+    OpenClipboard(0)
+
+    GetClipboardFormatName(format_str, buffer, bufferSize)
+
+    CloseClipboard()
+
+    return buffer.value
+
+
+def get_clipboard_text() -> str:
+    text = ""
+
+    if OpenClipboard(0):
+        h_clip_mem = GetClipboardData(CF_UNICODETEXT)
+
+        if h_clip_mem:
+            text = wstring_at(GlobalLock(h_clip_mem))
+            GlobalUnlock(h_clip_mem)
+
+        CloseClipboard()
+
+    return text
+
+
+def set_clipboard_text(text: Union[str, bytes]) -> None:
+    buffer = create_unicode_buffer(ensure_unicode(text))
+    buffer_size = sizeof(buffer)
+
+    h_global_mem = GlobalAlloc(GHND, c_size_t(buffer_size))
+    GlobalLock.restype = c_void_p
+    lp_global_mem = GlobalLock(h_global_mem)
+
+    _strncpy(
+        cast(lp_global_mem, c_wchar_p),
+        cast(addressof(buffer), c_wchar_p),
+        c_size_t(buffer_size),
+    )
+
+    GlobalUnlock(c_int(h_global_mem))
+
+    if OpenClipboard(0):
+        EmptyClipboard()
+        SetClipboardData(CF_UNICODETEXT, h_global_mem)
+        CloseClipboard()
+
+
+if __name__ == "__main__":
+    txt = get_clipboard_text()  # display last text clipped
+    print(txt)

rl/Lib/site-packages/pyreadline3/configuration/pyreadlineconfig.ini

@@ -0,0 +1,89 @@
+#Bind keys for exit (keys only work on empty lines
+#disable_readline(True)		#Disable pyreadline3 completely.
+from __future__ import absolute_import
+debug_output("off")             #"on" saves log info to./pyreadline_debug_log.txt
+                                #"on_nologfile" only enables print warning messages
+bind_exit_key("Control-d")
+bind_exit_key("Control-z")
+
+#Commands for moving	
+bind_key("Home",                "beginning_of_line")
+bind_key("End",                 "end_of_line")
+bind_key("Left",                "backward_char")
+bind_key("Control-b",           "backward_char")
+bind_key("Right",               "forward_char")
+bind_key("Control-f",           "forward_char")
+bind_key("Alt-f",               "forward_word")
+bind_key("Alt-b",               "backward_word")
+bind_key("Clear",               "clear_screen")
+bind_key("Control-l",           "clear_screen")
+bind_key("Control-a",           "beginning_of_line")
+bind_key("Control-e",           "end_of_line")
+#bind_key("Control-l",          "redraw_current_line")
+
+#Commands for Manipulating the History
+bind_key("Return",              "accept_line")
+bind_key("Control-p",           "previous_history")
+bind_key("Control-n",           "next_history")
+bind_key("Up",                  "history_search_backward")
+bind_key("Down",                "history_search_forward")
+bind_key("Alt-<",               "beginning_of_history")
+bind_key("Alt->",               "end_of_history")
+bind_key("Control-r",           "reverse_search_history")
+bind_key("Control-s",           "forward_search_history")
+bind_key("Alt-p",               "non_incremental_reverse_search_history")
+bind_key("Alt-n",               "non_incremental_forward_search_history")
+
+bind_key("Control-z",           "undo")
+bind_key("Control-_",           "undo")
+
+#Commands for Changing Text
+bind_key("Delete",              "delete_char")
+bind_key("Control-d",           "delete_char")
+bind_key("BackSpace",           "backward_delete_char")
+#bind_key("Control-Shift-v",    "quoted_insert")
+bind_key("Control-space",       "self_insert")
+bind_key("Control-BackSpace",   "backward_delete_word")
+
+#Killing and Yanking
+bind_key("Control-k",           "kill_line")
+bind_key("Control-shift-k",     "kill_whole_line")
+bind_key("Escape",              "kill_whole_line")
+bind_key("Meta-d",              "kill_word")
+bind_key("Control-w",           "unix_word_rubout")
+#bind_key("Control-Delete",     "forward_kill_word")
+
+#Copy paste
+bind_key("Shift-Right",         "forward_char_extend_selection")
+bind_key("Shift-Left",          "backward_char_extend_selection")
+bind_key("Shift-Control-Right", "forward_word_extend_selection")
+bind_key("Shift-Control-Left",  "backward_word_extend_selection")
+bind_key("Control-m",           "set_mark")
+
+bind_key("Control-Shift-x",     "copy_selection_to_clipboard")
+#bind_key("Control-c",           "copy_selection_to_clipboard")  #Needs allow_ctrl_c(True) below to be uncommented
+bind_key("Control-q",           "copy_region_to_clipboard")
+bind_key('Control-Shift-v',     "paste_mulitline_code")
+bind_key("Control-x",           "cut_selection_to_clipboard")
+
+bind_key("Control-v",           "paste")
+bind_key("Control-y",           "yank")
+bind_key("Alt-v",               "ipython_paste")
+
+#Unbinding keys:
+#un_bind_key("Home")
+
+#Other
+bell_style("none") #modes: none, audible, visible(not implemented)
+show_all_if_ambiguous("on")
+mark_directories("on")
+completer_delims(" \t\n\"\\'`@$><=;|&{(?")
+complete_filesystem("off")
+debug_output("off")
+#allow_ctrl_c(True)  #(Allows use of ctrl-c as copy key, still propagate keyboardinterrupt when not waiting for input)
+
+history_filename("~/.pythonhistory")
+history_length(200) #value of -1 means no limit
+
+#set_mode("vi")  #will cause following bind_keys to bind to vi mode as well as activate vi mode
+#ctrl_c_tap_time_interval(0.3)

rl/Lib/site-packages/pyreadline3/configuration/startup.py

@@ -0,0 +1,38 @@
+# -*- coding: UTF-8 -*-
+# Example snippet to use in a PYTHONSTARTUP file
+
+
+try:
+    import atexit
+
+    # pyreadline3.rlmain.config_path=r"c:\xxx\pyreadlineconfig.ini"
+    import readline
+
+    import pyreadline3.rlmain
+    import pyreadline3.unicode_helper
+
+    #
+    #
+    # Normally the codepage for pyreadline3 is set to be sys.stdout.encoding
+    # if you need to change this uncomment the following line
+    # pyreadline3.unicode_helper.pyreadline_codepage="utf8"
+except ImportError:
+    print("Module readline not available.")
+else:
+    # import tab completion functionality
+    import rlcompleter
+
+    # Override completer from rlcompleter to disable automatic ( on callable
+    completer_obj = rlcompleter.Completer()
+
+    def nop(val, word):
+        return word
+
+    completer_obj._callable_postfix = nop
+    readline.set_completer(completer_obj.complete)
+
+    # activate tab completion
+    readline.parse_and_bind("tab: complete")
+    readline.read_history_file()
+    atexit.register(readline.write_history_file)
+    del readline, rlcompleter, atexit

rl/Lib/site-packages/pyreadline3/console/__init__.py

@@ -0,0 +1,16 @@
+from pyreadline3.py3k_compat import is_ironpython
+
+if is_ironpython:
+    try:
+        from .ironpython_console import *
+    except ImportError as x:
+        raise ImportError(
+            "Could not find a console implementation for local " "ironpython version"
+        ) from x
+else:
+    try:
+        from .console import *
+    except ImportError as x:
+        raise ImportError(
+            "Could not find a console implementation for local " "python version"
+        ) from x

rl/Lib/site-packages/pyreadline3/console/ansi.py

@@ -0,0 +1,253 @@
+# -*- coding: ISO-8859-1 -*-
+
+
+import os
+import re
+import sys
+
+terminal_escape = re.compile("(\001?\033\\[[0-9;]*m\002?)")
+escape_parts = re.compile("\001?\033\\[([0-9;]*)m\002?")
+
+
+class AnsiState(object):
+    def __init__(
+        self,
+        bold=False,
+        inverse=False,
+        color="white",
+        background="black",
+        backgroundbold=False,
+    ):
+        self.bold = bold
+        self.inverse = inverse
+        self.color = color
+        self.background = background
+        self.backgroundbold = backgroundbold
+
+    trtable = {
+        "black": 0,
+        "red": 4,
+        "green": 2,
+        "yellow": 6,
+        "blue": 1,
+        "magenta": 5,
+        "cyan": 3,
+        "white": 7,
+    }
+    revtable = dict(zip(trtable.values(), trtable.keys()))
+
+    def get_winattr(self):
+        attr = 0
+        if self.bold:
+            attr |= 0x0008
+        if self.backgroundbold:
+            attr |= 0x0080
+        if self.inverse:
+            attr |= 0x4000
+        attr |= self.trtable[self.color]
+        attr |= self.trtable[self.background] << 4
+        return attr
+
+    def set_winattr(self, attr):
+        self.bold = bool(attr & 0x0008)
+        self.backgroundbold = bool(attr & 0x0080)
+        self.inverse = bool(attr & 0x4000)
+        self.color = self.revtable[attr & 0x0007]
+        self.background = self.revtable[(attr & 0x0070) >> 4]
+
+    winattr = property(get_winattr, set_winattr)
+
+    def __repr__(self):
+        return (
+            "AnsiState(bold=%s,inverse=%s,color=%9s,"
+            "background=%9s,backgroundbold=%s)# 0x%x"
+            % (
+                self.bold,
+                self.inverse,
+                '"%s"' % self.color,
+                '"%s"' % self.background,
+                self.backgroundbold,
+                self.winattr,
+            )
+        )
+
+    def copy(self):
+        x = AnsiState()
+        x.bold = self.bold
+        x.inverse = self.inverse
+        x.color = self.color
+        x.background = self.background
+        x.backgroundbold = self.backgroundbold
+        return x
+
+
+defaultstate = AnsiState(False, False, "white")
+
+trtable = {
+    0: "black",
+    1: "red",
+    2: "green",
+    3: "yellow",
+    4: "blue",
+    5: "magenta",
+    6: "cyan",
+    7: "white",
+}
+
+
+class AnsiWriter(object):
+    def __init__(self, default=defaultstate):
+        if isinstance(defaultstate, AnsiState):
+            self.defaultstate = default
+        else:
+            self.defaultstate = AnsiState()
+            self.defaultstate.winattr = defaultstate
+
+    def write_color(self, text, attr=None):
+        """write text at current cursor position and interpret color escapes.
+
+        return the number of characters written.
+        """
+        if isinstance(attr, AnsiState):
+            defaultstate = attr
+        elif attr is None:  # use attribute form initial console
+            attr = self.defaultstate.copy()
+        else:
+            defaultstate = AnsiState()
+            defaultstate.winattr = attr
+            attr = defaultstate
+        chunks = terminal_escape.split(text)
+        n = 0  # count the characters we actually write, omitting the escapes
+        res = []
+        for chunk in chunks:
+            m = escape_parts.match(chunk)
+            if m:
+                parts = m.group(1).split(";")
+                if len(parts) == 1 and parts[0] == "0":
+                    attr = self.defaultstate.copy()
+                    continue
+                for part in parts:
+                    if part == "0":  # No text attribute
+                        attr = self.defaultstate.copy()
+                        attr.bold = False
+                    elif part == "7":  # switch on reverse
+                        attr.inverse = True
+                    # switch on bold (i.e. intensify foreground color)
+                    elif part == "1":
+                        attr.bold = True
+                    elif len(part) == 2:
+                        if part == "22":  # Normal foreground color
+                            attr.bold = False
+                        elif "30" <= part <= "37":  # set foreground color
+                            attr.color = trtable[int(part) - 30]
+                        elif part == "39":  # Default foreground color
+                            attr.color = self.defaultstate.color
+                        elif "40" <= part <= "47":  # set background color
+                            attr.background = trtable[int(part) - 40]
+                        elif part == "49":  # Default background color
+                            attr.background = self.defaultstate.background
+                continue
+            n += len(chunk)
+
+            res.append((attr.copy(), chunk))
+
+        return n, res
+
+    def parse_color(self, text, attr=None):
+        n, res = self.write_color(text, attr)
+        return n, [attr.winattr for attr, text in res]
+
+
+def write_color(text, attr=None):
+    a = AnsiWriter(defaultstate)
+    return a.write_color(text, attr)
+
+
+def write_color_old(text, attr=None):
+    """write text at current cursor position and interpret color escapes.
+
+    return the number of characters written.
+    """
+    res = []
+    chunks = terminal_escape.split(text)
+    n = 0  # count the characters we actually write, omitting the escapes
+    if attr is None:  # use attribute from initial console
+        attr = 15
+    for chunk in chunks:
+        m = escape_parts.match(chunk)
+        if m:
+            for part in m.group(1).split(";"):
+                if part == "0":  # No text attribute
+                    attr = 0
+                elif part == "7":  # switch on reverse
+                    attr |= 0x4000
+                # switch on bold (i.e. intensify foreground color)
+                if part == "1":
+                    attr |= 0x08
+                elif len(part) == 2 and "30" <= part <= "37":  # set foreground color
+                    part = int(part) - 30
+                    # we have to mirror bits
+                    attr = (
+                        (attr & ~0x07)
+                        | ((part & 0x1) << 2)
+                        | (part & 0x2)
+                        | ((part & 0x4) >> 2)
+                    )
+                elif len(part) == 2 and "40" <= part <= "47":  # set background color
+                    part = int(part) - 40
+                    # we have to mirror bits
+                    attr = (
+                        (attr & ~0x70)
+                        | ((part & 0x1) << 6)
+                        | ((part & 0x2) << 4)
+                        | ((part & 0x4) << 2)
+                    )
+                # ignore blink, underline and anything we don't understand
+            continue
+        n += len(chunk)
+        if chunk:
+            res.append(("0x%x" % attr, chunk))
+    return res
+
+
+# trtable={0:"black",1:"red",2:"green",3:"yellow",4:"blue",5:"magenta",6:"cyan",7:"white"}
+
+if __name__ == "__main__x":
+    import pprint
+
+    pprint = pprint.pprint
+
+    s = "\033[0;31mred\033[0;32mgreen\033[0;33myellow\033[0;34mblue\033[0;35mmagenta\033[0;36mcyan\033[0;37mwhite\033[0m"
+    pprint(write_color(s))
+    pprint(write_color_old(s))
+    s = "\033[1;31mred\033[1;32mgreen\033[1;33myellow\033[1;34mblue\033[1;35mmagenta\033[1;36mcyan\033[1;37mwhite\033[0m"
+    pprint(write_color(s))
+    pprint(write_color_old(s))
+
+    s = "\033[0;7;31mred\033[0;7;32mgreen\033[0;7;33myellow\033[0;7;34mblue\033[0;7;35mmagenta\033[0;7;36mcyan\033[0;7;37mwhite\033[0m"
+    pprint(write_color(s))
+    pprint(write_color_old(s))
+    s = "\033[1;7;31mred\033[1;7;32mgreen\033[1;7;33myellow\033[1;7;34mblue\033[1;7;35mmagenta\033[1;7;36mcyan\033[1;7;37mwhite\033[0m"
+    pprint(write_color(s))
+    pprint(write_color_old(s))
+
+
+if __name__ == "__main__":
+    import pprint
+
+    import console
+
+    pprint = pprint.pprint
+
+    c = console.Console()
+    c.write_color("dhsjdhs")
+    c.write_color("\033[0;32mIn [\033[1;32m1\033[0;32m]:")
+    print
+    pprint(write_color("\033[0;32mIn [\033[1;32m1\033[0;32m]:"))
+
+if __name__ == "__main__x":
+    import pprint
+
+    pprint = pprint.pprint
+    s = "\033[0;31mred\033[0;32mgreen\033[0;33myellow\033[0;34mblue\033[0;35mmagenta\033[0;36mcyan\033[0;37mwhite\033[0m"
+    pprint(write_color(s))

rl/Lib/site-packages/pyreadline3/console/console.py

@@ -0,0 +1,901 @@
+# -*- coding: utf-8 -*-
+# *****************************************************************************
+#       Copyright (C) 2003-2006 Gary Bishop.
+#       Copyright (C) 2006-2020 Jorgen Stenarson. <jorgen.stenarson@bostream.nu>
+#       Copyright (C) 2020 Bassem Girgis. <brgirgis@gmail.com>
+#
+#  Distributed under the terms of the BSD License.  The full license is in
+#  the file COPYING, distributed as part of this software.
+# *****************************************************************************
+
+
+from .event import Event
+
+"""Cursor control and color for the Windows console.
+
+This was modeled after the C extension of the same name by Fredrik Lundh.
+"""
+
+# primitive debug printing that won't interfere with the screen
+
+import os
+import re
+import sys
+import traceback
+
+import pyreadline3.unicode_helper as unicode_helper
+from pyreadline3.console.ansi import AnsiState, AnsiWriter
+from pyreadline3.keysyms import KeyPress, make_KeyPress
+from pyreadline3.logger import log
+from pyreadline3.unicode_helper import ensure_str, ensure_unicode
+
+try:
+    import ctypes.util
+    from ctypes import *
+    from ctypes.wintypes import *
+
+    from _ctypes import call_function
+except ImportError:
+    raise ImportError("You need ctypes to run this code")
+
+
+def nolog(string):
+    pass
+
+
+log = nolog
+
+
+# some constants we need
+STD_INPUT_HANDLE = -10
+STD_OUTPUT_HANDLE = -11
+ENABLE_WINDOW_INPUT = 0x0008
+ENABLE_MOUSE_INPUT = 0x0010
+ENABLE_PROCESSED_INPUT = 0x0001
+WHITE = 0x7
+BLACK = 0
+MENU_EVENT = 0x0008
+KEY_EVENT = 0x0001
+MOUSE_MOVED = 0x0001
+MOUSE_EVENT = 0x0002
+WINDOW_BUFFER_SIZE_EVENT = 0x0004
+FOCUS_EVENT = 0x0010
+MENU_EVENT = 0x0008
+VK_SHIFT = 0x10
+VK_CONTROL = 0x11
+VK_MENU = 0x12
+GENERIC_READ = int(0x80000000)
+GENERIC_WRITE = 0x40000000
+
+# Windows structures we'll need later
+
+
+class COORD(Structure):
+    _fields_ = [("X", c_short), ("Y", c_short)]
+
+
+class SMALL_RECT(Structure):
+    _fields_ = [
+        ("Left", c_short),
+        ("Top", c_short),
+        ("Right", c_short),
+        ("Bottom", c_short),
+    ]
+
+
+class CONSOLE_SCREEN_BUFFER_INFO(Structure):
+    _fields_ = [
+        ("dwSize", COORD),
+        ("dwCursorPosition", COORD),
+        ("wAttributes", c_short),
+        ("srWindow", SMALL_RECT),
+        ("dwMaximumWindowSize", COORD),
+    ]
+
+
+class CHAR_UNION(Union):
+    _fields_ = [("UnicodeChar", c_wchar), ("AsciiChar", c_char)]
+
+
+class CHAR_INFO(Structure):
+    _fields_ = [("Char", CHAR_UNION), ("Attributes", c_short)]
+
+
+class KEY_EVENT_RECORD(Structure):
+    _fields_ = [
+        ("bKeyDown", c_byte),
+        ("pad2", c_byte),
+        ("pad1", c_short),
+        ("wRepeatCount", c_short),
+        ("wVirtualKeyCode", c_short),
+        ("wVirtualScanCode", c_short),
+        ("uChar", CHAR_UNION),
+        ("dwControlKeyState", c_int),
+    ]
+
+
+class MOUSE_EVENT_RECORD(Structure):
+    _fields_ = [
+        ("dwMousePosition", COORD),
+        ("dwButtonState", c_int),
+        ("dwControlKeyState", c_int),
+        ("dwEventFlags", c_int),
+    ]
+
+
+class WINDOW_BUFFER_SIZE_RECORD(Structure):
+    _fields_ = [("dwSize", COORD)]
+
+
+class MENU_EVENT_RECORD(Structure):
+    _fields_ = [("dwCommandId", c_uint)]
+
+
+class FOCUS_EVENT_RECORD(Structure):
+    _fields_ = [("bSetFocus", c_byte)]
+
+
+class INPUT_UNION(Union):
+    _fields_ = [
+        ("KeyEvent", KEY_EVENT_RECORD),
+        ("MouseEvent", MOUSE_EVENT_RECORD),
+        ("WindowBufferSizeEvent", WINDOW_BUFFER_SIZE_RECORD),
+        ("MenuEvent", MENU_EVENT_RECORD),
+        ("FocusEvent", FOCUS_EVENT_RECORD),
+    ]
+
+
+class INPUT_RECORD(Structure):
+    _fields_ = [("EventType", c_short), ("Event", INPUT_UNION)]
+
+
+class CONSOLE_CURSOR_INFO(Structure):
+    _fields_ = [("dwSize", c_int), ("bVisible", c_byte)]
+
+
+# I didn't want to have to individually import these so I made a list, they are
+# added to the Console class later in this file.
+
+funcs = [
+    "AllocConsole",
+    "CreateConsoleScreenBuffer",
+    "FillConsoleOutputAttribute",
+    "FillConsoleOutputCharacterW",
+    "FreeConsole",
+    "GetConsoleCursorInfo",
+    "GetConsoleMode",
+    "GetConsoleScreenBufferInfo",
+    "GetConsoleTitleW",
+    "GetProcAddress",
+    "GetStdHandle",
+    "PeekConsoleInputW",
+    "ReadConsoleInputW",
+    "ScrollConsoleScreenBufferW",
+    "SetConsoleActiveScreenBuffer",
+    "SetConsoleCursorInfo",
+    "SetConsoleCursorPosition",
+    "SetConsoleMode",
+    "SetConsoleScreenBufferSize",
+    "SetConsoleTextAttribute",
+    "SetConsoleTitleW",
+    "SetConsoleWindowInfo",
+    "WriteConsoleW",
+    "WriteConsoleOutputCharacterW",
+    "WriteFile",
+]
+
+# I don't want events for these keys, they are just a bother for my application
+key_modifiers = {
+    VK_SHIFT: 1,
+    VK_CONTROL: 1,
+    VK_MENU: 1,  # alt key
+    0x5B: 1,  # windows key
+}
+
+
+def split_block(text, size=1000):
+    return [text[start : start + size] for start in range(0, len(text), size)]
+
+
+class Console(object):
+    """Console driver for Windows."""
+
+    def __init__(self, newbuffer=0):
+        """Initialize the Console object.
+
+        newbuffer=1 will allocate a new buffer so the old content will be restored
+        on exit.
+        """
+        # Do I need the following line? It causes a console to be created whenever
+        # readline is imported into a pythonw application which seems wrong. Things
+        # seem to work without it...
+        # self.AllocConsole()
+
+        if newbuffer:
+            self.hout = self.CreateConsoleScreenBuffer(
+                GENERIC_READ | GENERIC_WRITE, 0, None, 1, None
+            )
+            self.SetConsoleActiveScreenBuffer(self.hout)
+        else:
+            self.hout = self.GetStdHandle(STD_OUTPUT_HANDLE)
+
+        self.hin = self.GetStdHandle(STD_INPUT_HANDLE)
+        self.inmode = DWORD(0)
+        self.GetConsoleMode(self.hin, byref(self.inmode))
+        self.SetConsoleMode(self.hin, 0xF)
+        info = CONSOLE_SCREEN_BUFFER_INFO()
+        self.GetConsoleScreenBufferInfo(self.hout, byref(info))
+        self.attr = info.wAttributes
+        self.saveattr = info.wAttributes  # remember the initial colors
+        self.defaultstate = AnsiState()
+        self.defaultstate.winattr = info.wAttributes
+        self.ansiwriter = AnsiWriter(self.defaultstate)
+
+        background = self.attr & 0xF0
+        for escape in self.escape_to_color:
+            if self.escape_to_color[escape] is not None:
+                self.escape_to_color[escape] |= background
+        log("initial attr=%x" % self.attr)
+        self.softspace = 0  # this is for using it as a file-like object
+        self.serial = 0
+
+        self.pythondll = ctypes.pythonapi
+        self.inputHookPtr = c_void_p.from_address(
+            addressof(self.pythondll.PyOS_InputHook)
+        ).value
+
+        self.pythondll.PyMem_RawMalloc.restype = c_size_t
+        self.pythondll.PyMem_RawMalloc.argtypes = [c_size_t]
+        setattr(Console, "PyMem_Malloc", self.pythondll.PyMem_RawMalloc)
+
+    def __del__(self):
+        """Cleanup the console when finished."""
+        # I don't think this ever gets called
+        self.SetConsoleTextAttribute(self.hout, self.saveattr)
+        self.SetConsoleMode(self.hin, self.inmode)
+        self.FreeConsole()
+
+    def _get_top_bot(self):
+        info = CONSOLE_SCREEN_BUFFER_INFO()
+        self.GetConsoleScreenBufferInfo(self.hout, byref(info))
+        rect = info.srWindow
+        top = rect.Top
+        bot = rect.Bottom
+        return top, bot
+
+    def fixcoord(self, x, y):
+        """Return a long with x and y packed inside,
+        also handle negative x and y."""
+        if x < 0 or y < 0:
+            info = CONSOLE_SCREEN_BUFFER_INFO()
+            self.GetConsoleScreenBufferInfo(self.hout, byref(info))
+            if x < 0:
+                x = info.srWindow.Right - x
+                y = info.srWindow.Bottom + y
+
+        # this is a hack! ctypes won't pass structures but COORD is
+        # just like a long, so this works.
+        return c_int(y << 16 | x)
+
+    def pos(self, x=None, y=None):
+        """Move or query the window cursor."""
+        if x is None:
+            info = CONSOLE_SCREEN_BUFFER_INFO()
+            self.GetConsoleScreenBufferInfo(self.hout, byref(info))
+            return (info.dwCursorPosition.X, info.dwCursorPosition.Y)
+        else:
+            return self.SetConsoleCursorPosition(self.hout, self.fixcoord(x, y))
+
+    def home(self):
+        """Move to home."""
+        self.pos(0, 0)
+
+    # Map ANSI color escape sequences into Windows Console Attributes
+
+    terminal_escape = re.compile("(\001?\033\\[[0-9;]+m\002?)")
+    escape_parts = re.compile("\001?\033\\[([0-9;]+)m\002?")
+    escape_to_color = {
+        "0;30": 0x0,  # black
+        "0;31": 0x4,  # red
+        "0;32": 0x2,  # green
+        "0;33": 0x4 + 0x2,  # brown?
+        "0;34": 0x1,  # blue
+        "0;35": 0x1 + 0x4,  # purple
+        "0;36": 0x2 + 0x4,  # cyan
+        "0;37": 0x1 + 0x2 + 0x4,  # grey
+        "1;30": 0x1 + 0x2 + 0x4,  # dark gray
+        "1;31": 0x4 + 0x8,  # red
+        "1;32": 0x2 + 0x8,  # light green
+        "1;33": 0x4 + 0x2 + 0x8,  # yellow
+        "1;34": 0x1 + 0x8,  # light blue
+        "1;35": 0x1 + 0x4 + 0x8,  # light purple
+        "1;36": 0x1 + 0x2 + 0x8,  # light cyan
+        "1;37": 0x1 + 0x2 + 0x4 + 0x8,  # white
+        "0": None,
+    }
+
+    # This pattern should match all characters that change the cursor position differently
+    # than a normal character.
+    motion_char_re = re.compile("([\n\r\t\010\007])")
+
+    def write_scrolling(self, text, attr=None):
+        """write text at current cursor position while watching for scrolling.
+
+        If the window scrolls because you are at the bottom of the screen
+        buffer, all positions that you are storing will be shifted by the
+        scroll amount. For example, I remember the cursor position of the
+        prompt so that I can redraw the line but if the window scrolls,
+        the remembered position is off.
+
+        This variant of write tries to keep track of the cursor position
+        so that it will know when the screen buffer is scrolled. It
+        returns the number of lines that the buffer scrolled.
+
+        """
+        text = ensure_unicode(text)
+        x, y = self.pos()
+        w, h = self.size()
+        scroll = 0  # the result
+        # split the string into ordinary characters and funny characters
+        chunks = self.motion_char_re.split(text)
+        for chunk in chunks:
+            n = self.write_color(chunk, attr)
+            if len(chunk) == 1:  # the funny characters will be alone
+                if chunk[0] == "\n":  # newline
+                    x = 0
+                    y += 1
+                elif chunk[0] == "\r":  # carriage return
+                    x = 0
+                elif chunk[0] == "\t":  # tab
+                    x = 8 * (int(x / 8) + 1)
+                    if x > w:  # newline
+                        x -= w
+                        y += 1
+                elif chunk[0] == "\007":  # bell
+                    pass
+                elif chunk[0] == "\010":
+                    x -= 1
+                    if x < 0:
+                        y -= 1  # backed up 1 line
+                else:  # ordinary character
+                    x += 1
+                if x == w:  # wrap
+                    x = 0
+                    y += 1
+                if y == h:  # scroll
+                    scroll += 1
+                    y = h - 1
+            else:  # chunk of ordinary characters
+                x += n
+                l = int(x / w)  # lines we advanced
+                x = x % w  # new x value
+                y += l
+                if y >= h:  # scroll
+                    scroll += y - h + 1
+                    y = h - 1
+        return scroll
+
+    def write_color(self, text, attr=None):
+        text = ensure_unicode(text)
+        n, res = self.ansiwriter.write_color(text, attr)
+        junk = DWORD(0)
+        for attr, chunk in res:
+            log("console.attr:%s" % (attr))
+            log("console.chunk:%s" % (chunk))
+            self.SetConsoleTextAttribute(self.hout, attr.winattr)
+            for short_chunk in split_block(chunk):
+                self.WriteConsoleW(
+                    self.hout, short_chunk, len(short_chunk), byref(junk), None
+                )
+        return n
+
+    def write_plain(self, text, attr=None):
+        """write text at current cursor position."""
+        text = ensure_unicode(text)
+        log('write("%s", %s)' % (text, attr))
+        if attr is None:
+            attr = self.attr
+        junk = DWORD(0)
+        self.SetConsoleTextAttribute(self.hout, attr)
+        for short_chunk in split_block(chunk):
+            self.WriteConsoleW(
+                self.hout,
+                ensure_unicode(short_chunk),
+                len(short_chunk),
+                byref(junk),
+                None,
+            )
+        return len(text)
+
+    # This function must be used to ensure functioning with EMACS
+    # Emacs sets the EMACS environment variable
+    if "EMACS" in os.environ:
+
+        def write_color(self, text, attr=None):
+            text = ensure_str(text)
+            junk = DWORD(0)
+            self.WriteFile(self.hout, text, len(text), byref(junk), None)
+            return len(text)
+
+        write_plain = write_color
+
+    # make this class look like a file object
+    def write(self, text):
+        text = ensure_unicode(text)
+        log('write("%s")' % text)
+        return self.write_color(text)
+
+    # write = write_scrolling
+
+    def isatty(self):
+        return True
+
+    def flush(self):
+        pass
+
+    def page(self, attr=None, fill=" "):
+        """Fill the entire screen."""
+        if attr is None:
+            attr = self.attr
+        if len(fill) != 1:
+            raise ValueError
+        info = CONSOLE_SCREEN_BUFFER_INFO()
+        self.GetConsoleScreenBufferInfo(self.hout, byref(info))
+        if info.dwCursorPosition.X != 0 or info.dwCursorPosition.Y != 0:
+            self.SetConsoleCursorPosition(self.hout, self.fixcoord(0, 0))
+
+        w = info.dwSize.X
+        n = DWORD(0)
+        for y in range(info.dwSize.Y):
+            self.FillConsoleOutputAttribute(
+                self.hout, attr, w, self.fixcoord(0, y), byref(n)
+            )
+            self.FillConsoleOutputCharacterW(
+                self.hout, ord(fill[0]), w, self.fixcoord(0, y), byref(n)
+            )
+
+        self.attr = attr
+
+    def text(self, x, y, text, attr=None):
+        """Write text at the given position."""
+        if attr is None:
+            attr = self.attr
+
+        pos = self.fixcoord(x, y)
+        n = DWORD(0)
+        self.WriteConsoleOutputCharacterW(self.hout, text, len(text), pos, byref(n))
+        self.FillConsoleOutputAttribute(self.hout, attr, n, pos, byref(n))
+
+    def clear_to_end_of_window(self):
+        top, bot = self._get_top_bot()
+        pos = self.pos()
+        w, h = self.size()
+        self.rectangle((pos[0], pos[1], w, pos[1] + 1))
+        if pos[1] < bot:
+            self.rectangle((0, pos[1] + 1, w, bot + 1))
+
+    def rectangle(self, rect, attr=None, fill=" "):
+        """Fill Rectangle."""
+        x0, y0, x1, y1 = rect
+        n = DWORD(0)
+        if attr is None:
+            attr = self.attr
+        for y in range(y0, y1):
+            pos = self.fixcoord(x0, y)
+            self.FillConsoleOutputAttribute(self.hout, attr, x1 - x0, pos, byref(n))
+            self.FillConsoleOutputCharacterW(
+                self.hout, ord(fill[0]), x1 - x0, pos, byref(n)
+            )
+
+    def scroll(self, rect, dx, dy, attr=None, fill=" "):
+        """Scroll a rectangle."""
+        if attr is None:
+            attr = self.attr
+        x0, y0, x1, y1 = rect
+        source = SMALL_RECT(x0, y0, x1 - 1, y1 - 1)
+        dest = self.fixcoord(x0 + dx, y0 + dy)
+        style = CHAR_INFO()
+        style.Char.AsciiChar = ensure_str(fill[0])
+        style.Attributes = attr
+
+        return self.ScrollConsoleScreenBufferW(
+            self.hout, byref(source), byref(source), dest, byref(style)
+        )
+
+    def scroll_window(self, lines):
+        """Scroll the window by the indicated number of lines."""
+        info = CONSOLE_SCREEN_BUFFER_INFO()
+        self.GetConsoleScreenBufferInfo(self.hout, byref(info))
+        rect = info.srWindow
+        log("sw: rtop=%d rbot=%d" % (rect.Top, rect.Bottom))
+        top = rect.Top + lines
+        bot = rect.Bottom + lines
+        h = bot - top
+        maxbot = info.dwSize.Y - 1
+        if top < 0:
+            top = 0
+            bot = h
+        if bot > maxbot:
+            bot = maxbot
+            top = bot - h
+
+        nrect = SMALL_RECT()
+        nrect.Top = top
+        nrect.Bottom = bot
+        nrect.Left = rect.Left
+        nrect.Right = rect.Right
+        log("sn: top=%d bot=%d" % (top, bot))
+        r = self.SetConsoleWindowInfo(self.hout, True, byref(nrect))
+        log("r=%d" % r)
+
+    def get(self):
+        """Get next event from queue."""
+        inputHookFunc = c_void_p.from_address(self.inputHookPtr).value
+
+        Cevent = INPUT_RECORD()
+        count = DWORD(0)
+        while True:
+            if inputHookFunc:
+                call_function(inputHookFunc, ())
+            status = self.ReadConsoleInputW(self.hin, byref(Cevent), 1, byref(count))
+            if status and count.value == 1:
+                e = event(self, Cevent)
+                return e
+
+    def getkeypress(self):
+        """Return next key press event from the queue, ignoring others."""
+        while True:
+            e = self.get()
+            if e.type == "KeyPress" and e.keycode not in key_modifiers:
+                log("console.getkeypress %s" % e)
+                if e.keyinfo.keyname == "next":
+                    self.scroll_window(12)
+                elif e.keyinfo.keyname == "prior":
+                    self.scroll_window(-12)
+                else:
+                    return e
+            elif (e.type == "KeyRelease") and (
+                e.keyinfo == KeyPress("S", False, True, False, "S")
+                or e.keyinfo == KeyPress("C", False, True, False, "C")
+            ):
+                log("getKeypress:%s,%s,%s" % (e.keyinfo, e.keycode, e.type))
+                return e
+
+    def getchar(self):
+        """Get next character from queue."""
+
+        Cevent = INPUT_RECORD()
+        count = DWORD(0)
+        while True:
+            status = self.ReadConsoleInputW(self.hin, byref(Cevent), 1, byref(count))
+            if (
+                status
+                and (count.value == 1)
+                and (Cevent.EventType == 1)
+                and Cevent.Event.KeyEvent.bKeyDown
+            ):
+                sym = keysym(Cevent.Event.KeyEvent.wVirtualKeyCode)
+                if len(sym) == 0:
+                    sym = Cevent.Event.KeyEvent.uChar.AsciiChar
+                return sym
+
+    def peek(self):
+        """Check event queue."""
+        Cevent = INPUT_RECORD()
+        count = DWORD(0)
+        status = self.PeekConsoleInputW(self.hin, byref(Cevent), 1, byref(count))
+        if status and count == 1:
+            return event(self, Cevent)
+
+    def title(self, txt=None):
+        """Set/get title."""
+        if txt:
+            self.SetConsoleTitleW(txt)
+        else:
+            buffer = create_unicode_buffer(200)
+            n = self.GetConsoleTitleW(buffer, 200)
+            if n > 0:
+                return buffer.value[:n]
+
+    def size(self, width=None, height=None):
+        """Set/get window size."""
+        info = CONSOLE_SCREEN_BUFFER_INFO()
+        status = self.GetConsoleScreenBufferInfo(self.hout, byref(info))
+        if not status:
+            return None
+        if width is not None and height is not None:
+            wmin = info.srWindow.Right - info.srWindow.Left + 1
+            hmin = info.srWindow.Bottom - info.srWindow.Top + 1
+            # print wmin, hmin
+            width = max(width, wmin)
+            height = max(height, hmin)
+            # print width, height
+            self.SetConsoleScreenBufferSize(self.hout, self.fixcoord(width, height))
+        else:
+            return (info.dwSize.X, info.dwSize.Y)
+
+    def cursor(self, visible=None, size=None):
+        """Set cursor on or off."""
+        info = CONSOLE_CURSOR_INFO()
+        if self.GetConsoleCursorInfo(self.hout, byref(info)):
+            if visible is not None:
+                info.bVisible = visible
+            if size is not None:
+                info.dwSize = size
+            self.SetConsoleCursorInfo(self.hout, byref(info))
+
+    def bell(self):
+        self.write("\007")
+
+    def next_serial(self):
+        """Get next event serial number."""
+        self.serial += 1
+        return self.serial
+
+
+# add the functions from the dll to the class
+for func in funcs:
+    setattr(Console, func, getattr(windll.kernel32, func))
+
+
+_strncpy = ctypes.windll.kernel32.lstrcpynA
+_strncpy.restype = c_char_p
+_strncpy.argtypes = [c_char_p, c_char_p, c_size_t]
+
+
+LPVOID = c_void_p
+LPCVOID = c_void_p
+FARPROC = c_void_p
+LPDWORD = POINTER(DWORD)
+
+Console.AllocConsole.restype = BOOL
+Console.AllocConsole.argtypes = []  # void
+Console.CreateConsoleScreenBuffer.restype = HANDLE
+Console.CreateConsoleScreenBuffer.argtypes = [
+    DWORD,
+    DWORD,
+    c_void_p,
+    DWORD,
+    LPVOID,
+]  # DWORD, DWORD, SECURITY_ATTRIBUTES*, DWORD, LPVOID
+Console.FillConsoleOutputAttribute.restype = BOOL
+Console.FillConsoleOutputAttribute.argtypes = [
+    HANDLE,
+    WORD,
+    DWORD,
+    c_int,
+    LPDWORD,
+]  # HANDLE, WORD, DWORD, COORD, LPDWORD
+Console.FillConsoleOutputCharacterW.restype = BOOL
+Console.FillConsoleOutputCharacterW.argtypes = [
+    HANDLE,
+    c_ushort,
+    DWORD,
+    c_int,
+    LPDWORD,
+]  # HANDLE, TCHAR, DWORD, COORD, LPDWORD
+Console.FreeConsole.restype = BOOL
+Console.FreeConsole.argtypes = []  # void
+Console.GetConsoleCursorInfo.restype = BOOL
+Console.GetConsoleCursorInfo.argtypes = [
+    HANDLE,
+    c_void_p,
+]  # HANDLE, PCONSOLE_CURSOR_INFO
+Console.GetConsoleMode.restype = BOOL
+Console.GetConsoleMode.argtypes = [HANDLE, LPDWORD]  # HANDLE, LPDWORD
+Console.GetConsoleScreenBufferInfo.restype = BOOL
+Console.GetConsoleScreenBufferInfo.argtypes = [
+    HANDLE,
+    c_void_p,
+]  # HANDLE, PCONSOLE_SCREEN_BUFFER_INFO
+Console.GetConsoleTitleW.restype = DWORD
+Console.GetConsoleTitleW.argtypes = [c_wchar_p, DWORD]  # LPTSTR , DWORD
+Console.GetProcAddress.restype = FARPROC
+Console.GetProcAddress.argtypes = [HMODULE, c_char_p]  # HMODULE , LPCSTR
+Console.GetStdHandle.restype = HANDLE
+Console.GetStdHandle.argtypes = [DWORD]
+Console.PeekConsoleInputW.restype = BOOL
+# HANDLE, PINPUT_RECORD, DWORD, LPDWORD
+Console.PeekConsoleInputW.argtypes = [HANDLE, c_void_p, DWORD, LPDWORD]
+Console.ReadConsoleInputW.restype = BOOL
+# HANDLE, PINPUT_RECORD, DWORD, LPDWORD
+Console.ReadConsoleInputW.argtypes = [HANDLE, c_void_p, DWORD, LPDWORD]
+Console.ScrollConsoleScreenBufferW.restype = BOOL
+Console.ScrollConsoleScreenBufferW.argtypes = [
+    HANDLE,
+    c_void_p,
+    c_void_p,
+    c_int,
+    c_void_p,
+]  # HANDLE, SMALL_RECT*, SMALL_RECT*, COORD, LPDWORD
+Console.SetConsoleActiveScreenBuffer.restype = BOOL
+Console.SetConsoleActiveScreenBuffer.argtypes = [HANDLE]  # HANDLE
+Console.SetConsoleCursorInfo.restype = BOOL
+Console.SetConsoleCursorInfo.argtypes = [
+    HANDLE,
+    c_void_p,
+]  # HANDLE, CONSOLE_CURSOR_INFO*
+Console.SetConsoleCursorPosition.restype = BOOL
+Console.SetConsoleCursorPosition.argtypes = [HANDLE, c_int]  # HANDLE, COORD
+Console.SetConsoleMode.restype = BOOL
+Console.SetConsoleMode.argtypes = [HANDLE, DWORD]  # HANDLE, DWORD
+Console.SetConsoleScreenBufferSize.restype = BOOL
+Console.SetConsoleScreenBufferSize.argtypes = [HANDLE, c_int]  # HANDLE, COORD
+Console.SetConsoleTextAttribute.restype = BOOL
+Console.SetConsoleTextAttribute.argtypes = [HANDLE, WORD]  # HANDLE, WORD
+Console.SetConsoleTitleW.restype = BOOL
+Console.SetConsoleTitleW.argtypes = [c_wchar_p]  # LPCTSTR
+Console.SetConsoleWindowInfo.restype = BOOL
+Console.SetConsoleWindowInfo.argtypes = [
+    HANDLE,
+    BOOL,
+    c_void_p,
+]  # HANDLE, BOOL, SMALL_RECT*
+Console.WriteConsoleW.restype = BOOL
+# HANDLE, VOID*, DWORD, LPDWORD, LPVOID
+Console.WriteConsoleW.argtypes = [HANDLE, c_void_p, DWORD, LPDWORD, LPVOID]
+Console.WriteConsoleOutputCharacterW.restype = BOOL
+Console.WriteConsoleOutputCharacterW.argtypes = [
+    HANDLE,
+    c_wchar_p,
+    DWORD,
+    c_int,
+    LPDWORD,
+]  # HANDLE, LPCTSTR, DWORD, COORD, LPDWORD
+Console.WriteFile.restype = BOOL
+# HANDLE, LPCVOID , DWORD, LPDWORD , LPOVERLAPPED
+Console.WriteFile.argtypes = [HANDLE, LPCVOID, DWORD, LPDWORD, c_void_p]
+
+
+VkKeyScan = windll.user32.VkKeyScanA
+
+
+class event(Event):
+    """Represent events from the console."""
+
+    def __init__(self, console, input):
+        """Initialize an event from the Windows input structure."""
+        self.type = "??"
+        self.serial = console.next_serial()
+        self.width = 0
+        self.height = 0
+        self.x = 0
+        self.y = 0
+        self.char = ""
+        self.keycode = 0
+        self.keysym = "??"
+        # a tuple with (control, meta, shift, keycode) for dispatch
+        self.keyinfo = None
+        self.width = None
+
+        if input.EventType == KEY_EVENT:
+            if input.Event.KeyEvent.bKeyDown:
+                self.type = "KeyPress"
+            else:
+                self.type = "KeyRelease"
+            self.char = input.Event.KeyEvent.uChar.UnicodeChar
+            self.keycode = input.Event.KeyEvent.wVirtualKeyCode
+            self.state = input.Event.KeyEvent.dwControlKeyState
+            self.keyinfo = make_KeyPress(self.char, self.state, self.keycode)
+
+        elif input.EventType == MOUSE_EVENT:
+            if input.Event.MouseEvent.dwEventFlags & MOUSE_MOVED:
+                self.type = "Motion"
+            else:
+                self.type = "Button"
+            self.x = input.Event.MouseEvent.dwMousePosition.X
+            self.y = input.Event.MouseEvent.dwMousePosition.Y
+            self.state = input.Event.MouseEvent.dwButtonState
+        elif input.EventType == WINDOW_BUFFER_SIZE_EVENT:
+            self.type = "Configure"
+            self.width = input.Event.WindowBufferSizeEvent.dwSize.X
+            self.height = input.Event.WindowBufferSizeEvent.dwSize.Y
+        elif input.EventType == FOCUS_EVENT:
+            if input.Event.FocusEvent.bSetFocus:
+                self.type = "FocusIn"
+            else:
+                self.type = "FocusOut"
+        elif input.EventType == MENU_EVENT:
+            self.type = "Menu"
+            self.state = input.Event.MenuEvent.dwCommandId
+
+
+def getconsole(buffer=1):
+    """Get a console handle.
+
+    If buffer is non-zero, a new console buffer is allocated and
+    installed.  Otherwise, this returns a handle to the current
+    console buffer"""
+
+    c = Console(buffer)
+
+    return c
+
+
+# The following code uses ctypes to allow a Python callable to
+# substitute for GNU readline within the Python interpreter. Calling
+# raw_input or other functions that do input, inside your callable
+# might be a bad idea, then again, it might work.
+
+# The Python callable can raise EOFError or KeyboardInterrupt and
+# these will be translated into the appropriate outputs from readline
+# so that they will then be translated back!
+
+# If the Python callable raises any other exception, a traceback will
+# be printed and readline will appear to return an empty line.
+
+# I use ctypes to create a C-callable from a Python wrapper that
+# handles the exceptions and gets the result into the right form.
+
+
+# the type for our C-callable wrapper
+HOOKFUNC23 = CFUNCTYPE(c_char_p, c_void_p, c_void_p, c_char_p)
+
+readline_hook = None  # the python hook goes here
+readline_ref = None  # reference to the c-callable to keep it alive
+
+
+def hook_wrapper_23(stdin, stdout, prompt):
+    """Wrap a Python readline so it behaves like GNU readline."""
+    try:
+        # call the Python hook
+        res = ensure_str(readline_hook(prompt))
+        # make sure it returned the right sort of thing
+        if res and not isinstance(res, bytes):
+            raise TypeError("readline must return a string.")
+    except KeyboardInterrupt:
+        # GNU readline returns 0 on keyboard interrupt
+        return 0
+    except EOFError:
+        # It returns an empty string on EOF
+        res = ensure_str("")
+    except BaseException:
+        print("Readline internal error", file=sys.stderr)
+        traceback.print_exc()
+        res = ensure_str("\n")
+    # we have to make a copy because the caller expects to free the result
+    n = len(res)
+    p = Console.PyMem_Malloc(n + 1)
+    _strncpy(cast(p, c_char_p), res, n + 1)
+    return p
+
+
+def install_readline(hook):
+    """Set up things for the interpreter to call
+    our function like GNU readline."""
+    global readline_hook, readline_ref
+    # save the hook so the wrapper can call it
+    readline_hook = hook
+    # get the address of PyOS_ReadlineFunctionPointer so we can update it
+    PyOS_RFP = c_void_p.from_address(
+        Console.GetProcAddress(
+            sys.dllhandle, "PyOS_ReadlineFunctionPointer".encode("ascii")
+        )
+    )
+    # save a reference to the generated C-callable so it doesn't go away
+    readline_ref = HOOKFUNC23(hook_wrapper_23)
+    # get the address of the function
+    func_start = c_void_p.from_address(addressof(readline_ref)).value
+    # write the function address into PyOS_ReadlineFunctionPointer
+    PyOS_RFP.value = func_start
+
+
+if __name__ == "__main__":
+    import sys
+    import time
+
+    def p(char):
+        return chr(VkKeyScan(ord(char)) & 0xFF)
+
+    c = Console(0)
+    sys.stdout = c
+    sys.stderr = c
+    c.page()
+    print(p("d"), p("D"))
+    c.pos(5, 10)
+    c.write("hi there")
+    print("some printed output")
+    for i in range(10):
+        q = c.getkeypress()
+        print(q)
+    del c

rl/Lib/site-packages/pyreadline3/console/console_attributes.py

@@ -0,0 +1,15 @@
+FOREGROUND_BLUE = 0x0001
+FOREGROUND_GREEN = 0x0002
+FOREGROUND_RED = 0x0004
+FOREGROUND_INTENSITY = 0x0008
+BACKGROUND_BLUE = 0x0010
+BACKGROUND_GREEN = 0x0020
+BACKGROUND_RED = 0x0040
+BACKGROUND_INTENSITY = 0x0080
+COMMON_LVB_LEADING_BYTE = 0x0100
+COMMON_LVB_TRAILING_BYTE = 0x0200
+COMMON_LVB_GRID_HORIZONTAL = 0x0400
+COMMON_LVB_GRID_LVERTICAL = 0x0800
+COMMON_LVB_GRID_RVERTICAL = 0x1000
+COMMON_LVB_REVERSE_VIDEO = 0x2000
+COMMON_LVB_UNDERSCORE = 0x4000

rl/Lib/site-packages/pyreadline3/console/consolebase.py

@@ -0,0 +1,50 @@
+class baseconsole(object):
+    def __init__(self):
+        pass
+
+    def bell(self):
+        raise NotImplementedError
+
+    def pos(self, x=None, y=None):
+        """Move or query the window cursor."""
+        raise NotImplementedError
+
+    def size(self):
+        raise NotImplementedError
+
+    def rectangle(self, rect, attr=None, fill=" "):
+        """Fill Rectangle."""
+        raise NotImplementedError
+
+    def write_scrolling(self, text, attr=None):
+        """write text at current cursor position while watching for scrolling.
+
+        If the window scrolls because you are at the bottom of the screen
+        buffer, all positions that you are storing will be shifted by the
+        scroll amount. For example, I remember the cursor position of the
+        prompt so that I can redraw the line but if the window scrolls,
+        the remembered position is off.
+
+        This variant of write tries to keep track of the cursor position
+        so that it will know when the screen buffer is scrolled. It
+        returns the number of lines that the buffer scrolled.
+
+        """
+        raise NotImplementedError
+
+    def getkeypress(self):
+        """Return next key press event from the queue, ignoring others."""
+        raise NotImplementedError
+
+    def write(self, text):
+        raise NotImplementedError
+
+    def page(self, attr=None, fill=" "):
+        """Fill the entire screen."""
+        raise NotImplementedError
+
+    def isatty(self):
+        return True
+
+    def flush(self):
+        pass

rl/Lib/site-packages/pyreadline3/console/event.py

@@ -0,0 +1,37 @@
+class Event(object):
+    """Represent events from the console."""
+
+    def __init__(self, console, input):
+        pass
+
+    def __repr__(self):
+        """Display an event for debugging."""
+        if self.type in ["KeyPress", "KeyRelease"]:
+            chr = self.char
+            if ord(chr) < ord("A"):
+                chr = "?"
+            s = "%s char='%s'%d keysym='%s' keycode=%d:%x state=%x keyinfo=%s" % (
+                self.type,
+                chr,
+                ord(self.char),
+                self.keysym,
+                self.keycode,
+                self.keycode,
+                self.state,
+                self.keyinfo,
+            )
+        elif self.type in ["Motion", "Button"]:
+            s = "%s x=%d y=%d state=%x" % (self.type, self.x, self.y, self.state)
+        elif self.type == "Configure":
+            s = "%s w=%d h=%d" % (self.type, self.width, self.height)
+        elif self.type in ["FocusIn", "FocusOut"]:
+            s = self.type
+        elif self.type == "Menu":
+            s = "%s state=%x" % (self.type, self.state)
+        else:
+            s = "unknown event type"
+        return s
+
+
+#    def __str__(self):
+#        return "('%s',%s,%s,%s)"%(self.char,self.key,self.state,self.keyinfo)

rl/Lib/site-packages/pyreadline3/console/ironpython_console.py

@@ -0,0 +1,469 @@
+# -*- coding: utf-8 -*-
+# *****************************************************************************
+#       Copyright (C) 2003-2006 Gary Bishop.
+#       Copyright (C) 2006-2020 Jorgen Stenarson. <jorgen.stenarson@bostream.nu>
+#       Copyright (C) 2020 Bassem Girgis. <brgirgis@gmail.com>
+#
+#  Distributed under the terms of the BSD License.  The full license is in
+#  the file COPYING, distributed as part of this software.
+# *****************************************************************************
+
+
+import os
+import re
+
+import IronPythonConsole
+import System
+from pyreadline3.console.ansi import AnsiState
+from pyreadline3.keysyms import (
+    make_keyinfo,
+    make_KeyPress,
+    make_KeyPress_from_keydescr,
+    make_keysym,
+)
+from pyreadline3.logger import log
+
+from .event import Event
+
+"""Cursor control and color for the .NET console.
+"""
+
+#
+# Ironpython requires a patch to work do:
+#
+# In file PythonCommandLine.cs patch line:
+#    class PythonCommandLine
+#    {
+
+# to:
+#    public class PythonCommandLine
+#    {
+#
+#
+#
+# primitive debug printing that won't interfere with the screen
+
+import sys
+
+import clr
+
+clr.AddReferenceToFileAndPath(sys.executable)
+
+
+color = System.ConsoleColor
+
+ansicolor = {
+    "0;30": color.Black,
+    "0;31": color.DarkRed,
+    "0;32": color.DarkGreen,
+    "0;33": color.DarkYellow,
+    "0;34": color.DarkBlue,
+    "0;35": color.DarkMagenta,
+    "0;36": color.DarkCyan,
+    "0;37": color.DarkGray,
+    "1;30": color.Gray,
+    "1;31": color.Red,
+    "1;32": color.Green,
+    "1;33": color.Yellow,
+    "1;34": color.Blue,
+    "1;35": color.Magenta,
+    "1;36": color.Cyan,
+    "1;37": color.White,
+}
+
+winattr = {
+    "black": 0,
+    "darkgray": 0 + 8,
+    "darkred": 4,
+    "red": 4 + 8,
+    "darkgreen": 2,
+    "green": 2 + 8,
+    "darkyellow": 6,
+    "yellow": 6 + 8,
+    "darkblue": 1,
+    "blue": 1 + 8,
+    "darkmagenta": 5,
+    "magenta": 5 + 8,
+    "darkcyan": 3,
+    "cyan": 3 + 8,
+    "gray": 7,
+    "white": 7 + 8,
+}
+
+
+class Console(object):
+    """Console driver for Windows."""
+
+    def __init__(self, newbuffer=0):
+        """Initialize the Console object.
+
+        newbuffer=1 will allocate a new buffer so the old content will be restored
+        on exit.
+        """
+        self.serial = 0
+        self.attr = System.Console.ForegroundColor
+        self.saveattr = winattr[str(System.Console.ForegroundColor).lower()]
+        self.savebg = System.Console.BackgroundColor
+        log("initial attr=%s" % self.attr)
+
+    def _get(self):
+        top = System.Console.WindowTop
+        log("WindowTop:%s" % top)
+        return top
+
+    def _set(self, value):
+        top = System.Console.WindowTop
+        log("Set WindowTop:old:%s,new:%s" % (top, value))
+
+    WindowTop = property(_get, _set)
+    del _get, _set
+
+    def __del__(self):
+        """Cleanup the console when finished."""
+        # I don't think this ever gets called
+        pass
+
+    def pos(self, x=None, y=None):
+        """Move or query the window cursor."""
+        if x is not None:
+            System.Console.CursorLeft = x
+        else:
+            x = System.Console.CursorLeft
+        if y is not None:
+            System.Console.CursorTop = y
+        else:
+            y = System.Console.CursorTop
+        return x, y
+
+    def home(self):
+        """Move to home."""
+        self.pos(0, 0)
+
+    # Map ANSI color escape sequences into Windows Console Attributes
+
+    terminal_escape = re.compile("(\001?\033\\[[0-9;]*m\002?)")
+    escape_parts = re.compile("\001?\033\\[([0-9;]*)m\002?")
+
+    # This pattern should match all characters that change the cursor position differently
+    # than a normal character.
+    motion_char_re = re.compile("([\n\r\t\010\007])")
+
+    def write_scrolling(self, text, attr=None):
+        """write text at current cursor position while watching for scrolling.
+
+        If the window scrolls because you are at the bottom of the screen
+        buffer, all positions that you are storing will be shifted by the
+        scroll amount. For example, I remember the cursor position of the
+        prompt so that I can redraw the line but if the window scrolls,
+        the remembered position is off.
+
+        This variant of write tries to keep track of the cursor position
+        so that it will know when the screen buffer is scrolled. It
+        returns the number of lines that the buffer scrolled.
+
+        """
+        x, y = self.pos()
+        w, h = self.size()
+        scroll = 0  # the result
+
+        # split the string into ordinary characters and funny characters
+        chunks = self.motion_char_re.split(text)
+        for chunk in chunks:
+            n = self.write_color(chunk, attr)
+            if len(chunk) == 1:  # the funny characters will be alone
+                if chunk[0] == "\n":  # newline
+                    x = 0
+                    y += 1
+                elif chunk[0] == "\r":  # carriage return
+                    x = 0
+                elif chunk[0] == "\t":  # tab
+                    x = 8 * (int(x / 8) + 1)
+                    if x > w:  # newline
+                        x -= w
+                        y += 1
+                elif chunk[0] == "\007":  # bell
+                    pass
+                elif chunk[0] == "\010":
+                    x -= 1
+                    if x < 0:
+                        y -= 1  # backed up 1 line
+                else:  # ordinary character
+                    x += 1
+                if x == w:  # wrap
+                    x = 0
+                    y += 1
+                if y == h:  # scroll
+                    scroll += 1
+                    y = h - 1
+            else:  # chunk of ordinary characters
+                x += n
+                l = int(x / w)  # lines we advanced
+                x = x % w  # new x value
+                y += l
+                if y >= h:  # scroll
+                    scroll += y - h + 1
+                    y = h - 1
+        return scroll
+
+    trtable = {
+        0: color.Black,
+        4: color.DarkRed,
+        2: color.DarkGreen,
+        6: color.DarkYellow,
+        1: color.DarkBlue,
+        5: color.DarkMagenta,
+        3: color.DarkCyan,
+        7: color.Gray,
+        8: color.DarkGray,
+        4 + 8: color.Red,
+        2 + 8: color.Green,
+        6 + 8: color.Yellow,
+        1 + 8: color.Blue,
+        5 + 8: color.Magenta,
+        3 + 8: color.Cyan,
+        7 + 8: color.White,
+    }
+
+    def write_color(self, text, attr=None):
+        """write text at current cursor position and interpret color escapes.
+
+        return the number of characters written.
+        """
+        log('write_color("%s", %s)' % (text, attr))
+        chunks = self.terminal_escape.split(text)
+        log("chunks=%s" % repr(chunks))
+        bg = self.savebg
+        n = 0  # count the characters we actually write, omitting the escapes
+        if attr is None:  # use attribute from initial console
+            attr = self.attr
+        try:
+            fg = self.trtable[(0x000F & attr)]
+            bg = self.trtable[(0x00F0 & attr) >> 4]
+        except TypeError:
+            fg = attr
+
+        for chunk in chunks:
+            m = self.escape_parts.match(chunk)
+            if m:
+                log(m.group(1))
+                attr = ansicolor.get(m.group(1), self.attr)
+            n += len(chunk)
+            System.Console.ForegroundColor = fg
+            System.Console.BackgroundColor = bg
+            System.Console.Write(chunk)
+        return n
+
+    def write_plain(self, text, attr=None):
+        """write text at current cursor position."""
+        log('write("%s", %s)' % (text, attr))
+        if attr is None:
+            attr = self.attr
+        n = c_int(0)
+        self.SetConsoleTextAttribute(self.hout, attr)
+        self.WriteConsoleA(self.hout, text, len(text), byref(n), None)
+        return len(text)
+
+    if "EMACS" in os.environ:
+
+        def write_color(self, text, attr=None):
+            junk = c_int(0)
+            self.WriteFile(self.hout, text, len(text), byref(junk), None)
+            return len(text)
+
+        write_plain = write_color
+
+    # make this class look like a file object
+    def write(self, text):
+        log('write("%s")' % text)
+        return self.write_color(text)
+
+    # write = write_scrolling
+
+    def isatty(self):
+        return True
+
+    def flush(self):
+        pass
+
+    def page(self, attr=None, fill=" "):
+        """Fill the entire screen."""
+        System.Console.Clear()
+
+    def text(self, x, y, text, attr=None):
+        """Write text at the given position."""
+        self.pos(x, y)
+        self.write_color(text, attr)
+
+    def clear_to_end_of_window(self):
+        oldtop = self.WindowTop
+        lastline = self.WindowTop + System.Console.WindowHeight
+        pos = self.pos()
+        w, h = self.size()
+        length = w - pos[0] + min((lastline - pos[1] - 1), 5) * w - 1
+        self.write_color(length * " ")
+        self.pos(*pos)
+        self.WindowTop = oldtop
+
+    def rectangle(self, rect, attr=None, fill=" "):
+        """Fill Rectangle."""
+        oldtop = self.WindowTop
+        oldpos = self.pos()
+        # raise NotImplementedError
+        x0, y0, x1, y1 = rect
+        if attr is None:
+            attr = self.attr
+        if fill:
+            rowfill = fill[:1] * abs(x1 - x0)
+        else:
+            rowfill = " " * abs(x1 - x0)
+        for y in range(y0, y1):
+            System.Console.SetCursorPosition(x0, y)
+            self.write_color(rowfill, attr)
+        self.pos(*oldpos)
+
+    def scroll(self, rect, dx, dy, attr=None, fill=" "):
+        """Scroll a rectangle."""
+        raise NotImplementedError
+
+    def scroll_window(self, lines):
+        """Scroll the window by the indicated number of lines."""
+        top = self.WindowTop + lines
+        if top < 0:
+            top = 0
+        if top + System.Console.WindowHeight > System.Console.BufferHeight:
+            top = System.Console.BufferHeight
+        self.WindowTop = top
+
+    def getkeypress(self):
+        """Return next key press event from the queue, ignoring others."""
+        ck = System.ConsoleKey
+        while True:
+            e = System.Console.ReadKey(True)
+            if e.Key == System.ConsoleKey.PageDown:  # PageDown
+                self.scroll_window(12)
+            elif e.Key == System.ConsoleKey.PageUp:  # PageUp
+                self.scroll_window(-12)
+            elif str(e.KeyChar) == "\000":  # Drop deadkeys
+                log("Deadkey: %s" % e)
+                return event(self, e)
+            else:
+                return event(self, e)
+
+    def title(self, txt=None):
+        """Set/get title."""
+        if txt:
+            System.Console.Title = txt
+        else:
+            return System.Console.Title
+
+    def size(self, width=None, height=None):
+        """Set/get window size."""
+        sc = System.Console
+        if width is not None and height is not None:
+            sc.BufferWidth, sc.BufferHeight = width, height
+        else:
+            return sc.BufferWidth, sc.BufferHeight
+
+        if width is not None and height is not None:
+            sc.WindowWidth, sc.WindowHeight = width, height
+        else:
+            return sc.WindowWidth - 1, sc.WindowHeight - 1
+
+    def cursor(self, visible=True, size=None):
+        """Set cursor on or off."""
+        System.Console.CursorVisible = visible
+
+    def bell(self):
+        System.Console.Beep()
+
+    def next_serial(self):
+        """Get next event serial number."""
+        self.serial += 1
+        return self.serial
+
+
+class event(Event):
+    """Represent events from the console."""
+
+    def __init__(self, console, input):
+        """Initialize an event from the Windows input structure."""
+        self.type = "??"
+        self.serial = console.next_serial()
+        self.width = 0
+        self.height = 0
+        self.x = 0
+        self.y = 0
+        self.char = str(input.KeyChar)
+        self.keycode = input.Key
+        self.state = input.Modifiers
+        log("%s,%s,%s" % (input.Modifiers, input.Key, input.KeyChar))
+        self.type = "KeyRelease"
+        self.keysym = make_keysym(self.keycode)
+        self.keyinfo = make_KeyPress(self.char, self.state, self.keycode)
+
+
+def make_event_from_keydescr(keydescr):
+    def input():
+        return 1
+
+    input.KeyChar = "a"
+    input.Key = System.ConsoleKey.A
+    input.Modifiers = System.ConsoleModifiers.Shift
+    input.next_serial = input
+    e = event(input, input)
+    del input.next_serial
+    keyinfo = make_KeyPress_from_keydescr(keydescr)
+    e.keyinfo = keyinfo
+    return e
+
+
+CTRL_C_EVENT = make_event_from_keydescr("Control-c")
+
+
+def install_readline(hook):
+    def hook_wrap():
+        try:
+            res = hook()
+        except KeyboardInterrupt as x:  # this exception does not seem to be caught
+            res = ""
+        except EOFError:
+            return None
+        if res[-1:] == "\n":
+            return res[:-1]
+        else:
+            return res
+
+    class IronPythonWrapper(IronPythonConsole.IConsole):
+        def ReadLine(self, autoIndentSize):
+            return hook_wrap()
+
+        def Write(self, text, style):
+            System.Console.Write(text)
+
+        def WriteLine(self, text, style):
+            System.Console.WriteLine(text)
+
+    IronPythonConsole.PythonCommandLine.MyConsole = IronPythonWrapper()
+
+
+if __name__ == "__main__":
+    import sys
+    import time
+
+    c = Console(0)
+    sys.stdout = c
+    sys.stderr = c
+    c.page()
+    c.pos(5, 10)
+    c.write("hi there")
+    c.title("Testing console")
+    #    c.bell()
+    print()
+    print("size", c.size())
+    print("  some printed output")
+    for i in range(10):
+        e = c.getkeypress()
+        print(e.Key, chr(e.KeyChar), ord(e.KeyChar), e.Modifiers)
+    del c
+
+    System.Console.Clear()

rl/Lib/site-packages/pyreadline3/error.py

@@ -0,0 +1,16 @@
+# -*- coding: utf-8 -*-
+# *****************************************************************************
+#       Copyright (C) 2006-2020  Jorgen Stenarson. <jorgen.stenarson@bostream.nu>
+#       Copyright (C) 2020 Bassem Girgis. <brgirgis@gmail.com>
+#
+#  Distributed under the terms of the BSD License.  The full license is in
+#  the file COPYING, distributed as part of this software.
+# *****************************************************************************
+
+
+class ReadlineError(Exception):
+    pass
+
+
+class GetSetError(ReadlineError):
+    pass

rl/Lib/site-packages/pyreadline3/get_doc.py

@@ -0,0 +1,22 @@
+import sys
+import textwrap
+
+from .py3k_compat import is_callable
+
+rlmain = sys.modules["readline"]
+rl = rlmain.rl
+
+
+def get_doc(rl_):
+    methods = [(x, getattr(rl_, x)) for x in dir(rl_) if is_callable(getattr(rl_, x))]
+    return [(x, m.__doc__) for x, m in methods if m.__doc__]
+
+
+def get_rest(rl_):
+    q = get_doc(rl_)
+    out = []
+    for funcname, doc in q:
+        out.append(funcname)
+        out.append("\n".join(textwrap.wrap(doc, 80, initial_indent="   ")))
+        out.append("")
+    return out

rl/Lib/site-packages/pyreadline3/keysyms/__init__.py

@@ -0,0 +1,14 @@
+from pyreadline3.py3k_compat import is_ironpython
+
+from . import winconstants
+
+if is_ironpython:
+    try:
+        from .ironpython_keysyms import *
+    except ImportError as x:
+        raise ImportError("Could not import keysym for local ironpython version") from x
+else:
+    try:
+        from .keysyms import *
+    except ImportError as x:
+        raise ImportError("Could not import keysym for local python version") from x

rl/Lib/site-packages/pyreadline3/keysyms/common.py

@@ -0,0 +1,198 @@
+# -*- coding: utf-8 -*-
+# *****************************************************************************
+#       Copyright (C) 2003-2006 Gary Bishop.
+#       Copyright (C) 2006-2020 Jorgen Stenarson. <jorgen.stenarson@bostream.nu>
+#       Copyright (C) 2020 Bassem Girgis. <brgirgis@gmail.com>
+#
+#  Distributed under the terms of the BSD License.  The full license is in
+#  the file COPYING, distributed as part of this software.
+# *****************************************************************************
+# table for translating virtual keys to X windows key symbols
+
+
+try:
+    set
+except NameError:
+    from sets import Set as set
+
+from pyreadline3.unicode_helper import ensure_unicode
+
+validkey = set(
+    [
+        "cancel",
+        "backspace",
+        "tab",
+        "clear",
+        "return",
+        "shift_l",
+        "control_l",
+        "alt_l",
+        "pause",
+        "caps_lock",
+        "escape",
+        "space",
+        "prior",
+        "next",
+        "end",
+        "home",
+        "left",
+        "up",
+        "right",
+        "down",
+        "select",
+        "print",
+        "execute",
+        "snapshot",
+        "insert",
+        "delete",
+        "help",
+        "f1",
+        "f2",
+        "f3",
+        "f4",
+        "f5",
+        "f6",
+        "f7",
+        "f8",
+        "f9",
+        "f10",
+        "f11",
+        "f12",
+        "f13",
+        "f14",
+        "f15",
+        "f16",
+        "f17",
+        "f18",
+        "f19",
+        "f20",
+        "f21",
+        "f22",
+        "f23",
+        "f24",
+        "num_lock",
+        "scroll_lock",
+        "vk_apps",
+        "vk_processkey",
+        "vk_attn",
+        "vk_crsel",
+        "vk_exsel",
+        "vk_ereof",
+        "vk_play",
+        "vk_zoom",
+        "vk_noname",
+        "vk_pa1",
+        "vk_oem_clear",
+        "numpad0",
+        "numpad1",
+        "numpad2",
+        "numpad3",
+        "numpad4",
+        "numpad5",
+        "numpad6",
+        "numpad7",
+        "numpad8",
+        "numpad9",
+        "divide",
+        "multiply",
+        "add",
+        "subtract",
+        "vk_decimal",
+    ]
+)
+
+escape_sequence_to_special_key = {
+    "\\e[a": "up",
+    "\\e[b": "down",
+    "del": "delete",
+}
+
+
+class KeyPress(object):
+    def __init__(self, char="", shift=False, control=False, meta=False, keyname=""):
+        if control or meta or shift:
+            char = char.upper()
+        self.info = dict(
+            char=char, shift=shift, control=control, meta=meta, keyname=keyname
+        )
+
+    def create(name):
+        def get(self):
+            return self.info[name]
+
+        def set(self, value):
+            self.info[name] = value
+
+        return property(get, set)
+
+    char = create("char")
+    shift = create("shift")
+    control = create("control")
+    meta = create("meta")
+    keyname = create("keyname")
+
+    def __repr__(self):
+        return "(%s,%s,%s,%s)" % tuple(map(ensure_unicode, self.tuple()))
+
+    def tuple(self):
+        if self.keyname:
+            return (self.control, self.meta, self.shift, self.keyname)
+        else:
+            if self.control or self.meta or self.shift:
+                return (self.control, self.meta, self.shift, self.char.upper())
+            else:
+                return (self.control, self.meta, self.shift, self.char)
+
+    def __eq__(self, other):
+        if isinstance(other, KeyPress):
+            s = self.tuple()
+            o = other.tuple()
+            return s == o
+        else:
+            return False
+
+
+def make_KeyPress_from_keydescr(keydescr):
+    keyinfo = KeyPress()
+    if len(keydescr) > 2 and keydescr[:1] == '"' and keydescr[-1:] == '"':
+        keydescr = keydescr[1:-1]
+
+    while True:
+        lkeyname = keydescr.lower()
+        if lkeyname.startswith("control-"):
+            keyinfo.control = True
+            keydescr = keydescr[8:]
+        elif lkeyname.startswith("ctrl-"):
+            keyinfo.control = True
+            keydescr = keydescr[5:]
+        elif keydescr.lower().startswith("\\c-"):
+            keyinfo.control = True
+            keydescr = keydescr[3:]
+        elif keydescr.lower().startswith("\\m-"):
+            keyinfo.meta = True
+            keydescr = keydescr[3:]
+        elif keydescr in escape_sequence_to_special_key:
+            keydescr = escape_sequence_to_special_key[keydescr]
+        elif lkeyname.startswith("meta-"):
+            keyinfo.meta = True
+            keydescr = keydescr[5:]
+        elif lkeyname.startswith("alt-"):
+            keyinfo.meta = True
+            keydescr = keydescr[4:]
+        elif lkeyname.startswith("shift-"):
+            keyinfo.shift = True
+            keydescr = keydescr[6:]
+        else:
+            if len(keydescr) > 1:
+                if keydescr.strip().lower() in validkey:
+                    keyinfo.keyname = keydescr.strip().lower()
+                    keyinfo.char = ""
+                else:
+                    raise IndexError("Not a valid key: '%s'" % keydescr)
+            else:
+                keyinfo.char = keydescr
+            return keyinfo
+
+
+if __name__ == "__main__":
+    import startup

rl/Lib/site-packages/pyreadline3/keysyms/ironpython_keysyms.py

@@ -0,0 +1,213 @@
+# -*- coding: utf-8 -*-
+# *****************************************************************************
+#       Copyright (C) 2003-2006 Gary Bishop.
+#       Copyright (C) 2006-2020 Jorgen Stenarson. <jorgen.stenarson@bostream.nu>
+#       Copyright (C) 2020 Bassem Girgis. <brgirgis@gmail.com>
+#
+#  Distributed under the terms of the BSD License.  The full license is in
+#  the file COPYING, distributed as part of this software.
+# *****************************************************************************
+
+
+import System
+
+from .common import KeyPress, make_KeyPress_from_keydescr, validkey
+
+c32 = System.ConsoleKey
+Shift = System.ConsoleModifiers.Shift
+Control = System.ConsoleModifiers.Control
+Alt = System.ConsoleModifiers.Alt
+# table for translating virtual keys to X windows key symbols
+code2sym_map = {
+    # c32.CANCEL:    'Cancel',
+    c32.Backspace: "BackSpace",
+    c32.Tab: "Tab",
+    c32.Clear: "Clear",
+    c32.Enter: "Return",
+    # c32.Shift:     'Shift_L',
+    # c32.Control:   'Control_L',
+    # c32.Menu:      'Alt_L',
+    c32.Pause: "Pause",
+    # c32.Capital:   'Caps_Lock',
+    c32.Escape: "Escape",
+    # c32.Space:     'space',
+    c32.PageUp: "Prior",
+    c32.PageDown: "Next",
+    c32.End: "End",
+    c32.Home: "Home",
+    c32.LeftArrow: "Left",
+    c32.UpArrow: "Up",
+    c32.RightArrow: "Right",
+    c32.DownArrow: "Down",
+    c32.Select: "Select",
+    c32.Print: "Print",
+    c32.Execute: "Execute",
+    # c32.Snapshot:  'Snapshot',
+    c32.Insert: "Insert",
+    c32.Delete: "Delete",
+    c32.Help: "Help",
+    c32.F1: "F1",
+    c32.F2: "F2",
+    c32.F3: "F3",
+    c32.F4: "F4",
+    c32.F5: "F5",
+    c32.F6: "F6",
+    c32.F7: "F7",
+    c32.F8: "F8",
+    c32.F9: "F9",
+    c32.F10: "F10",
+    c32.F11: "F11",
+    c32.F12: "F12",
+    c32.F13: "F13",
+    c32.F14: "F14",
+    c32.F15: "F15",
+    c32.F16: "F16",
+    c32.F17: "F17",
+    c32.F18: "F18",
+    c32.F19: "F19",
+    c32.F20: "F20",
+    c32.F21: "F21",
+    c32.F22: "F22",
+    c32.F23: "F23",
+    c32.F24: "F24",
+    # c32.Numlock:    'Num_Lock,',
+    # c32.Scroll:     'Scroll_Lock',
+    # c32.Apps:       'VK_APPS',
+    # c32.ProcesskeY: 'VK_PROCESSKEY',
+    # c32.Attn:       'VK_ATTN',
+    # c32.Crsel:      'VK_CRSEL',
+    # c32.Exsel:      'VK_EXSEL',
+    # c32.Ereof:      'VK_EREOF',
+    # c32.Play:       'VK_PLAY',
+    # c32.Zoom:       'VK_ZOOM',
+    # c32.Noname:     'VK_NONAME',
+    # c32.Pa1:        'VK_PA1',
+    c32.OemClear: "VK_OEM_CLEAR",
+    c32.NumPad0: "NUMPAD0",
+    c32.NumPad1: "NUMPAD1",
+    c32.NumPad2: "NUMPAD2",
+    c32.NumPad3: "NUMPAD3",
+    c32.NumPad4: "NUMPAD4",
+    c32.NumPad5: "NUMPAD5",
+    c32.NumPad6: "NUMPAD6",
+    c32.NumPad7: "NUMPAD7",
+    c32.NumPad8: "NUMPAD8",
+    c32.NumPad9: "NUMPAD9",
+    c32.Divide: "Divide",
+    c32.Multiply: "Multiply",
+    c32.Add: "Add",
+    c32.Subtract: "Subtract",
+    c32.Decimal: "VK_DECIMAL",
+}
+
+# function to handle the mapping
+
+
+def make_keysym(keycode):
+    try:
+        sym = code2sym_map[keycode]
+    except KeyError:
+        sym = ""
+    return sym
+
+
+sym2code_map = {}
+for code, sym in code2sym_map.items():
+    sym2code_map[sym.lower()] = code
+
+
+def key_text_to_keyinfo(keytext):
+    """Convert a GNU readline style textual description of a key to keycode with modifiers"""
+    if keytext.startswith('"'):  # "
+        return keyseq_to_keyinfo(keytext[1:-1])
+    else:
+        return keyname_to_keyinfo(keytext)
+
+
+def char_to_keyinfo(char, control=False, meta=False, shift=False):
+    vk = ord(char)
+    if vk & 0xFFFF == 0xFFFF:
+        print('VkKeyScan("%s") = %x' % (char, vk))
+        raise ValueError("bad key")
+    if vk & 0x100:
+        shift = True
+    if vk & 0x200:
+        control = True
+    if vk & 0x400:
+        meta = True
+    return (control, meta, shift, vk & 0xFF)
+
+
+def keyname_to_keyinfo(keyname):
+    control = False
+    meta = False
+    shift = False
+
+    while True:
+        lkeyname = keyname.lower()
+        if lkeyname.startswith("control-"):
+            control = True
+            keyname = keyname[8:]
+        elif lkeyname.startswith("ctrl-"):
+            control = True
+            keyname = keyname[5:]
+        elif lkeyname.startswith("meta-"):
+            meta = True
+            keyname = keyname[5:]
+        elif lkeyname.startswith("alt-"):
+            meta = True
+            keyname = keyname[4:]
+        elif lkeyname.startswith("shift-"):
+            shift = True
+            keyname = keyname[6:]
+        else:
+            if len(keyname) > 1:
+                return (control, meta, shift, sym2code_map.get(keyname.lower(), " "))
+            else:
+                return char_to_keyinfo(keyname, control, meta, shift)
+
+
+def keyseq_to_keyinfo(keyseq):
+    res = []
+    control = False
+    meta = False
+    shift = False
+
+    while True:
+        if keyseq.startswith("\\C-"):
+            control = True
+            keyseq = keyseq[3:]
+        elif keyseq.startswith("\\M-"):
+            meta = True
+            keyseq = keyseq[3:]
+        elif keyseq.startswith("\\e"):
+            res.append(char_to_keyinfo("\033", control, meta, shift))
+            control = meta = shift = False
+            keyseq = keyseq[2:]
+        elif len(keyseq) >= 1:
+            res.append(char_to_keyinfo(keyseq[0], control, meta, shift))
+            control = meta = shift = False
+            keyseq = keyseq[1:]
+        else:
+            return res[0]
+
+
+def make_keyinfo(keycode, state):
+    control = False
+    meta = False
+    shift = False
+    return (control, meta, shift, keycode)
+
+
+def make_KeyPress(char, state, keycode):
+
+    shift = bool(int(state) & int(Shift))
+    control = bool(int(state) & int(Control))
+    meta = bool(int(state) & int(Alt))
+    keyname = code2sym_map.get(keycode, "").lower()
+    if control and meta:  # equivalent to altgr so clear flags
+        control = False
+        meta = False
+    elif control:
+        char = str(keycode)
+    return KeyPress(char, shift, control, meta, keyname)

rl/Lib/site-packages/pyreadline3/keysyms/keysyms.py

@@ -0,0 +1,138 @@
+# -*- coding: utf-8 -*-
+# *****************************************************************************
+#       Copyright (C) 2003-2006 Gary Bishop.
+#       Copyright (C) 2006-2020 Jorgen Stenarson. <jorgen.stenarson@bostream.nu>
+#       Copyright (C) 2020 Bassem Girgis. <brgirgis@gmail.com>
+#
+#  Distributed under the terms of the BSD License.  The full license is in
+#  the file COPYING, distributed as part of this software.
+# *****************************************************************************
+
+
+from ctypes import windll
+
+from . import winconstants as c32
+from .common import KeyPress
+
+# table for translating virtual keys to X windows key symbols
+
+code2sym_map = {
+    c32.VK_CANCEL: "cancel",
+    c32.VK_BACK: "backspace",
+    c32.VK_TAB: "tab",
+    c32.VK_CLEAR: "clear",
+    c32.VK_RETURN: "return",
+    c32.VK_SHIFT: "shift_l",
+    c32.VK_CONTROL: "control_l",
+    c32.VK_MENU: "alt_l",
+    c32.VK_PAUSE: "pause",
+    c32.VK_CAPITAL: "caps_lock",
+    c32.VK_ESCAPE: "escape",
+    c32.VK_SPACE: "space",
+    c32.VK_PRIOR: "prior",
+    c32.VK_NEXT: "next",
+    c32.VK_END: "end",
+    c32.VK_HOME: "home",
+    c32.VK_LEFT: "left",
+    c32.VK_UP: "up",
+    c32.VK_RIGHT: "right",
+    c32.VK_DOWN: "down",
+    c32.VK_SELECT: "select",
+    c32.VK_PRINT: "print",
+    c32.VK_EXECUTE: "execute",
+    c32.VK_SNAPSHOT: "snapshot",
+    c32.VK_INSERT: "insert",
+    c32.VK_DELETE: "delete",
+    c32.VK_HELP: "help",
+    c32.VK_F1: "f1",
+    c32.VK_F2: "f2",
+    c32.VK_F3: "f3",
+    c32.VK_F4: "f4",
+    c32.VK_F5: "f5",
+    c32.VK_F6: "f6",
+    c32.VK_F7: "f7",
+    c32.VK_F8: "f8",
+    c32.VK_F9: "f9",
+    c32.VK_F10: "f10",
+    c32.VK_F11: "f11",
+    c32.VK_F12: "f12",
+    c32.VK_F13: "f13",
+    c32.VK_F14: "f14",
+    c32.VK_F15: "f15",
+    c32.VK_F16: "f16",
+    c32.VK_F17: "f17",
+    c32.VK_F18: "f18",
+    c32.VK_F19: "f19",
+    c32.VK_F20: "f20",
+    c32.VK_F21: "f21",
+    c32.VK_F22: "f22",
+    c32.VK_F23: "f23",
+    c32.VK_F24: "f24",
+    c32.VK_NUMLOCK: "num_lock,",
+    c32.VK_SCROLL: "scroll_lock",
+    c32.VK_APPS: "vk_apps",
+    c32.VK_PROCESSKEY: "vk_processkey",
+    c32.VK_ATTN: "vk_attn",
+    c32.VK_CRSEL: "vk_crsel",
+    c32.VK_EXSEL: "vk_exsel",
+    c32.VK_EREOF: "vk_ereof",
+    c32.VK_PLAY: "vk_play",
+    c32.VK_ZOOM: "vk_zoom",
+    c32.VK_NONAME: "vk_noname",
+    c32.VK_PA1: "vk_pa1",
+    c32.VK_OEM_CLEAR: "vk_oem_clear",
+    c32.VK_NUMPAD0: "numpad0",
+    c32.VK_NUMPAD1: "numpad1",
+    c32.VK_NUMPAD2: "numpad2",
+    c32.VK_NUMPAD3: "numpad3",
+    c32.VK_NUMPAD4: "numpad4",
+    c32.VK_NUMPAD5: "numpad5",
+    c32.VK_NUMPAD6: "numpad6",
+    c32.VK_NUMPAD7: "numpad7",
+    c32.VK_NUMPAD8: "numpad8",
+    c32.VK_NUMPAD9: "numpad9",
+    c32.VK_DIVIDE: "divide",
+    c32.VK_MULTIPLY: "multiply",
+    c32.VK_ADD: "add",
+    c32.VK_SUBTRACT: "subtract",
+    c32.VK_DECIMAL: "vk_decimal",
+}
+
+VkKeyScan = windll.user32.VkKeyScanA
+
+
+def char_to_keyinfo(char, control=False, meta=False, shift=False):
+    k = KeyPress()
+    vk = VkKeyScan(ord(char))
+    if vk & 0xFFFF == 0xFFFF:
+        print('VkKeyScan("%s") = %x' % (char, vk))
+        raise ValueError("bad key")
+    if vk & 0x100:
+        k.shift = True
+    if vk & 0x200:
+        k.control = True
+    if vk & 0x400:
+        k.meta = True
+    k.char = chr(vk & 0xFF)
+    return k
+
+
+def make_KeyPress(char, state, keycode):
+    control = (state & (4 + 8)) != 0
+    meta = (state & (1 + 2)) != 0
+    shift = (state & 0x10) != 0
+    if control and not meta:  # Matches ctrl- chords should pass keycode as char
+        char = chr(keycode)
+    elif control and meta:  # Matches alt gr and should just pass on char
+        control = False
+        meta = False
+    try:
+        keyname = code2sym_map[keycode]
+    except KeyError:
+        keyname = ""
+    out = KeyPress(char, shift, control, meta, keyname)
+    return out
+
+
+if __name__ == "__main__":
+    import startup

rl/Lib/site-packages/pyreadline3/keysyms/winconstants.py

@@ -0,0 +1,172 @@
+# This file contains constants that are normally found in win32all
+# But included here to avoid the dependency
+
+
+VK_LBUTTON = 1
+VK_RBUTTON = 2
+VK_CANCEL = 3
+VK_MBUTTON = 4
+VK_XBUTTON1 = 5
+VK_XBUTTON2 = 6
+VK_BACK = 8
+VK_TAB = 9
+VK_CLEAR = 12
+VK_RETURN = 13
+VK_SHIFT = 16
+VK_CONTROL = 17
+VK_MENU = 18
+VK_PAUSE = 19
+VK_CAPITAL = 20
+VK_KANA = 0x15
+VK_HANGEUL = 0x15
+VK_HANGUL = 0x15
+VK_JUNJA = 0x17
+VK_FINAL = 0x18
+VK_HANJA = 0x19
+VK_KANJI = 0x19
+VK_ESCAPE = 0x1B
+VK_CONVERT = 0x1C
+VK_NONCONVERT = 0x1D
+VK_ACCEPT = 0x1E
+VK_MODECHANGE = 0x1F
+VK_SPACE = 32
+VK_PRIOR = 33
+VK_NEXT = 34
+VK_END = 35
+VK_HOME = 36
+VK_LEFT = 37
+VK_UP = 38
+VK_RIGHT = 39
+VK_DOWN = 40
+VK_SELECT = 41
+VK_PRINT = 42
+VK_EXECUTE = 43
+VK_SNAPSHOT = 44
+VK_INSERT = 45
+VK_DELETE = 46
+VK_HELP = 47
+VK_LWIN = 0x5B
+VK_RWIN = 0x5C
+VK_APPS = 0x5D
+VK_SLEEP = 0x5F
+VK_NUMPAD0 = 0x60
+VK_NUMPAD1 = 0x61
+VK_NUMPAD2 = 0x62
+VK_NUMPAD3 = 0x63
+VK_NUMPAD4 = 0x64
+VK_NUMPAD5 = 0x65
+VK_NUMPAD6 = 0x66
+VK_NUMPAD7 = 0x67
+VK_NUMPAD8 = 0x68
+VK_NUMPAD9 = 0x69
+VK_MULTIPLY = 0x6A
+VK_ADD = 0x6B
+VK_SEPARATOR = 0x6C
+VK_SUBTRACT = 0x6D
+VK_DECIMAL = 0x6E
+VK_DIVIDE = 0x6F
+VK_F1 = 0x70
+VK_F2 = 0x71
+VK_F3 = 0x72
+VK_F4 = 0x73
+VK_F5 = 0x74
+VK_F6 = 0x75
+VK_F7 = 0x76
+VK_F8 = 0x77
+VK_F9 = 0x78
+VK_F10 = 0x79
+VK_F11 = 0x7A
+VK_F12 = 0x7B
+VK_F13 = 0x7C
+VK_F14 = 0x7D
+VK_F15 = 0x7E
+VK_F16 = 0x7F
+VK_F17 = 0x80
+VK_F18 = 0x81
+VK_F19 = 0x82
+VK_F20 = 0x83
+VK_F21 = 0x84
+VK_F22 = 0x85
+VK_F23 = 0x86
+VK_F24 = 0x87
+VK_NUMLOCK = 0x90
+VK_SCROLL = 0x91
+VK_LSHIFT = 0xA0
+VK_RSHIFT = 0xA1
+VK_LCONTROL = 0xA2
+VK_RCONTROL = 0xA3
+VK_LMENU = 0xA4
+VK_RMENU = 0xA5
+VK_BROWSER_BACK = 0xA6
+VK_BROWSER_FORWARD = 0xA7
+VK_BROWSER_REFRESH = 0xA8
+VK_BROWSER_STOP = 0xA9
+VK_BROWSER_SEARCH = 0xAA
+VK_BROWSER_FAVORITES = 0xAB
+VK_BROWSER_HOME = 0xAC
+VK_VOLUME_MUTE = 0xAD
+VK_VOLUME_DOWN = 0xAE
+VK_VOLUME_UP = 0xAF
+VK_MEDIA_NEXT_TRACK = 0xB0
+VK_MEDIA_PREV_TRACK = 0xB1
+VK_MEDIA_STOP = 0xB2
+VK_MEDIA_PLAY_PAUSE = 0xB3
+VK_LAUNCH_MAIL = 0xB4
+VK_LAUNCH_MEDIA_SELECT = 0xB5
+VK_LAUNCH_APP1 = 0xB6
+VK_LAUNCH_APP2 = 0xB7
+VK_OEM_1 = 0xBA
+VK_OEM_PLUS = 0xBB
+VK_OEM_COMMA = 0xBC
+VK_OEM_MINUS = 0xBD
+VK_OEM_PERIOD = 0xBE
+VK_OEM_2 = 0xBF
+VK_OEM_3 = 0xC0
+VK_OEM_4 = 0xDB
+VK_OEM_5 = 0xDC
+VK_OEM_6 = 0xDD
+VK_OEM_7 = 0xDE
+VK_OEM_8 = 0xDF
+VK_OEM_102 = 0xE2
+VK_PROCESSKEY = 0xE5
+VK_PACKET = 0xE7
+VK_ATTN = 0xF6
+VK_CRSEL = 0xF7
+VK_EXSEL = 0xF8
+VK_EREOF = 0xF9
+VK_PLAY = 0xFA
+VK_ZOOM = 0xFB
+VK_NONAME = 0xFC
+VK_PA1 = 0xFD
+VK_OEM_CLEAR = 0xFE
+
+CF_TEXT = 1
+CF_BITMAP = 2
+CF_METAFILEPICT = 3
+CF_SYLK = 4
+CF_DIF = 5
+CF_TIFF = 6
+CF_OEMTEXT = 7
+CF_DIB = 8
+CF_PALETTE = 9
+CF_PENDATA = 10
+CF_RIFF = 11
+CF_WAVE = 12
+CF_UNICODETEXT = 13
+CF_ENHMETAFILE = 14
+CF_HDROP = 15
+CF_LOCALE = 16
+CF_MAX = 17
+CF_OWNERDISPLAY = 128
+CF_DSPTEXT = 129
+CF_DSPBITMAP = 130
+CF_DSPMETAFILEPICT = 131
+CF_DSPENHMETAFILE = 142
+CF_PRIVATEFIRST = 512
+CF_PRIVATELAST = 767
+CF_GDIOBJFIRST = 768
+CF_GDIOBJLAST = 1023
+
+
+GPTR = 64
+GHND = 66

rl/Lib/site-packages/pyreadline3/lineeditor/history.py

@@ -0,0 +1,284 @@
+# -*- coding: utf-8 -*-
+# *****************************************************************************
+#       Copyright (C) 2006-2020 Jorgen Stenarson. <jorgen.stenarson@bostream.nu>
+#       Copyright (C) 2020 Bassem Girgis. <brgirgis@gmail.com>
+#
+#  Distributed under the terms of the BSD License.  The full license is in
+#  the file COPYING, distributed as part of this software.
+# *****************************************************************************
+
+import re, operator, string, sys, os, io
+
+from pyreadline3.logger import log
+from pyreadline3.unicode_helper import ensure_str, ensure_unicode
+
+from . import lineobj
+
+
+class EscapeHistory(Exception):
+    pass
+
+
+class LineHistory(object):
+    def __init__(self):
+        self.history = []
+        self._history_length = 100
+        self._history_cursor = 0
+        # Cannot expand unicode strings correctly on python2.4
+        self.history_filename = os.path.expanduser(ensure_str("~/.history"))
+        self.lastcommand = None
+        self.query = ""
+        self.last_search_for = ""
+
+    def get_current_history_length(self):
+        """Return the number of lines currently in the history.
+        (This is different from get_history_length(), which returns
+        the maximum number of lines that will be written to a history file.)"""
+        value = len(self.history)
+        log("get_current_history_length:%d" % value)
+        return value
+
+    def get_history_length(self):
+        """Return the desired length of the history file. Negative values imply
+        unlimited history file size."""
+        value = self._history_length
+        log("get_history_length:%d" % value)
+        return value
+
+    def get_history_item(self, index):
+        """Return the current contents of history item at index (starts with index 1)."""
+        item = self.history[index - 1]
+        log("get_history_item: index:%d item:%r" % (index, item))
+        return item.get_line_text()
+
+    def set_history_length(self, value):
+        log("set_history_length: old:%d new:%d" % (self._history_length, value))
+        self._history_length = value
+
+    def get_history_cursor(self):
+        value = self._history_cursor
+        log("get_history_cursor:%d" % value)
+        return value
+
+    def set_history_cursor(self, value):
+        log("set_history_cursor: old:%d new:%d" % (self._history_cursor, value))
+        self._history_cursor = value
+
+    history_length = property(get_history_length, set_history_length)
+    history_cursor = property(get_history_cursor, set_history_cursor)
+
+    def clear_history(self):
+        """Clear readline history."""
+        self.history[:] = []
+        self.history_cursor = 0
+
+    def read_history_file(self, filename=None):
+        """Load a readline history file."""
+        if filename is None:
+            filename = self.history_filename
+        try:
+            with io.open(filename, "rt", errors="replace") as fd:
+                for line in fd:
+                    self.add_history(lineobj.ReadLineTextBuffer(line.rstrip()))
+        except IOError:
+            self.history = []
+            self.history_cursor = 0
+
+    def write_history_file(self, filename=None):
+        """Save a readline history file."""
+        if filename is None:
+            filename = self.history_filename
+        with io.open(filename, "wt", errors="replace") as fp:
+            fp.writelines(
+                tuple(
+                    line.get_line_text()+"\n"
+                    for line in self.history[-self.history_length :]
+                )
+            )
+
+    def add_history(self, line):
+        """Append a line to the history buffer, as if it was the last line typed."""
+        line = ensure_unicode(line)
+        if not hasattr(line, "get_line_text"):
+            line = lineobj.ReadLineTextBuffer(line)
+        if not line.get_line_text():
+            pass
+        elif (
+            len(self.history) > 0
+            and self.history[-1].get_line_text() == line.get_line_text()
+        ):
+            pass
+        else:
+            self.history.append(line)
+        self.history_cursor = len(self.history)
+
+    def previous_history(self, current):  # (C-p)
+        """Move back through the history list, fetching the previous command."""
+        if self.history_cursor == len(self.history):
+            # do not use add_history since we do not want to increment cursor
+            self.history.append(current.copy())
+
+        if self.history_cursor > 0:
+            self.history_cursor -= 1
+            current.set_line(self.history[self.history_cursor].get_line_text())
+            current.point = lineobj.EndOfLine
+
+    def next_history(self, current):  # (C-n)
+        """Move forward through the history list, fetching the next command."""
+        if self.history_cursor < len(self.history) - 1:
+            self.history_cursor += 1
+            current.set_line(self.history[self.history_cursor].get_line_text())
+
+    def beginning_of_history(self):  # (M-<)
+        """Move to the first line in the history."""
+        self.history_cursor = 0
+        if len(self.history) > 0:
+            self.l_buffer = self.history[0]
+
+    def end_of_history(self, current):  # (M->)
+        """Move to the end of the input history, i.e., the line currently
+        being entered."""
+        self.history_cursor = len(self.history)
+        current.set_line(self.history[-1].get_line_text())
+
+    def reverse_search_history(self, searchfor, startpos=None):
+        if startpos is None:
+            startpos = self.history_cursor
+        origpos = startpos
+
+        result = lineobj.ReadLineTextBuffer("")
+
+        for idx, line in list(enumerate(self.history))[startpos:0:-1]:
+            if searchfor in line:
+                startpos = idx
+                break
+
+        # If we get a new search without change in search term it means
+        # someone pushed ctrl-r and we should find the next match
+        if self.last_search_for == searchfor and startpos > 0:
+            startpos -= 1
+            for idx, line in list(enumerate(self.history))[startpos:0:-1]:
+                if searchfor in line:
+                    startpos = idx
+                    break
+
+        if self.history:
+            result = self.history[startpos].get_line_text()
+        else:
+            result = ""
+        self.history_cursor = startpos
+        self.last_search_for = searchfor
+        log(
+            "reverse_search_history: old:%d new:%d result:%r"
+            % (origpos, self.history_cursor, result)
+        )
+        return result
+
+    def forward_search_history(self, searchfor, startpos=None):
+        if startpos is None:
+            startpos = min(
+                self.history_cursor, max(0, self.get_current_history_length() - 1)
+            )
+        # origpos = startpos
+
+        result = lineobj.ReadLineTextBuffer("")
+
+        for idx, line in list(enumerate(self.history))[startpos:]:
+            if searchfor in line:
+                startpos = idx
+                break
+
+        # If we get a new search without change in search term it means
+        # someone pushed ctrl-r and we should find the next match
+        if (
+            self.last_search_for == searchfor
+            and startpos < self.get_current_history_length() - 1
+        ):
+            startpos += 1
+            for idx, line in list(enumerate(self.history))[startpos:]:
+                if searchfor in line:
+                    startpos = idx
+                    break
+
+        if self.history:
+            result = self.history[startpos].get_line_text()
+        else:
+            result = ""
+        self.history_cursor = startpos
+        self.last_search_for = searchfor
+        return result
+
+    def _search(self, direction, partial):
+        try:
+            if (
+                self.lastcommand != self.history_search_forward
+                and self.lastcommand != self.history_search_backward
+            ):
+                self.query = "".join(partial[0 : partial.point].get_line_text())
+            hcstart = max(self.history_cursor, 0)
+            hc = self.history_cursor + direction
+            while (direction < 0 and hc >= 0) or (
+                direction > 0 and hc < len(self.history)
+            ):
+                h = self.history[hc]
+                if not self.query:
+                    self.history_cursor = hc
+                    result = lineobj.ReadLineTextBuffer(h, point=len(h.get_line_text()))
+                    return result
+                elif h.get_line_text().startswith(self.query) and (
+                    h != partial.get_line_text()
+                ):
+                    self.history_cursor = hc
+                    result = lineobj.ReadLineTextBuffer(h, point=partial.point)
+                    return result
+                hc += direction
+            else:
+                if len(self.history) == 0:
+                    pass
+                elif hc >= len(self.history) and not self.query:
+                    self.history_cursor = len(self.history)
+                    return lineobj.ReadLineTextBuffer("", point=0)
+                elif (
+                    self.history[max(min(hcstart, len(self.history) - 1), 0)]
+                    .get_line_text()
+                    .startswith(self.query)
+                    and self.query
+                ):
+                    return lineobj.ReadLineTextBuffer(
+                        self.history[max(min(hcstart, len(self.history) - 1), 0)],
+                        point=partial.point,
+                    )
+                else:
+                    return lineobj.ReadLineTextBuffer(partial, point=partial.point)
+                return lineobj.ReadLineTextBuffer(
+                    self.query, point=min(len(self.query), partial.point)
+                )
+        except IndexError:
+            raise
+
+    def history_search_forward(self, partial):  # ()
+        """Search forward through the history for the string of characters
+        between the start of the current line and the point. This is a
+        non-incremental search. By default, this command is unbound."""
+        return self._search(1, partial)
+
+    def history_search_backward(self, partial):  # ()
+        """Search backward through the history for the string of characters
+        between the start of the current line and the point. This is a
+        non-incremental search. By default, this command is unbound."""
+
+        return self._search(-1, partial)
+
+
+if __name__ == "__main__":
+    q = LineHistory()
+    r = LineHistory()
+    s = LineHistory()
+    RL = lineobj.ReadLineTextBuffer
+    q.add_history(RL("aaaa"))
+    q.add_history(RL("aaba"))
+    q.add_history(RL("aaca"))
+    q.add_history(RL("akca"))
+    q.add_history(RL("bbb"))
+    q.add_history(RL("ako"))
+    r.add_history(RL("ako"))

rl/Lib/site-packages/pyreadline3/lineeditor/lineobj.py

@@ -0,0 +1,866 @@
+# -*- coding: utf-8 -*-
+# *****************************************************************************
+#       Copyright (C) 2006-2020 Jorgen Stenarson. <jorgen.stenarson@bostream.nu>
+#       Copyright (C) 2020 Bassem Girgis. <brgirgis@gmail.com>
+#
+#  Distributed under the terms of the BSD License.  The full license is in
+#  the file COPYING, distributed as part of this software.
+# *****************************************************************************
+
+
+import pyreadline3.clipboard as clipboard
+from pyreadline3.unicode_helper import biter, ensure_unicode
+
+from . import wordmatcher
+
+# set to true to copy every addition to kill ring to clipboard
+kill_ring_to_clipboard = False
+
+
+class NotAWordError(IndexError):
+    pass
+
+
+def quote_char(c):
+    if ord(c) > 0:
+        return c
+
+
+# ############# Line positioner ########################
+
+
+class LinePositioner(object):
+    def __call__(self, line):
+        NotImplementedError("Base class !!!")
+
+
+class NextChar(LinePositioner):
+    def __call__(self, line):
+        if line.point < len(line.line_buffer):
+            return line.point + 1
+        else:
+            return line.point
+
+
+NextChar = NextChar()
+
+
+class PrevChar(LinePositioner):
+    def __call__(self, line):
+        if line.point > 0:
+            return line.point - 1
+        else:
+            return line.point
+
+
+PrevChar = PrevChar()
+
+
+class NextWordStart(LinePositioner):
+    def __call__(self, line):
+        return line.next_start_segment(line.line_buffer, line.is_word_token)[line.point]
+
+
+NextWordStart = NextWordStart()
+
+
+class NextWordEnd(LinePositioner):
+    def __call__(self, line):
+        return line.next_end_segment(line.line_buffer, line.is_word_token)[line.point]
+
+
+NextWordEnd = NextWordEnd()
+
+
+class PrevWordStart(LinePositioner):
+    def __call__(self, line):
+        return line.prev_start_segment(line.line_buffer, line.is_word_token)[line.point]
+
+
+PrevWordStart = PrevWordStart()
+
+
+class WordStart(LinePositioner):
+    def __call__(self, line):
+        if line.is_word_token(line.get_line_text()[Point(line) : Point(line) + 1]):
+            if Point(line) > 0 and line.is_word_token(
+                line.get_line_text()[Point(line) - 1 : Point(line)]
+            ):
+                return PrevWordStart(line)
+            else:
+                return line.point
+        else:
+            raise NotAWordError("Point is not in a word")
+
+
+WordStart = WordStart()
+
+
+class WordEnd(LinePositioner):
+    def __call__(self, line):
+        if line.is_word_token(line.get_line_text()[Point(line) : Point(line) + 1]):
+            if line.is_word_token(
+                line.get_line_text()[Point(line) + 1 : Point(line) + 2]
+            ):
+                return NextWordEnd(line)
+            else:
+                return line.point
+        else:
+            raise NotAWordError("Point is not in a word")
+
+
+WordEnd = WordEnd()
+
+
+class PrevWordEnd(LinePositioner):
+    def __call__(self, line):
+        return line.prev_end_segment(line.line_buffer, line.is_word_token)[line.point]
+
+
+PrevWordEnd = PrevWordEnd()
+
+
+class PrevSpace(LinePositioner):
+    def __call__(self, line):
+        point = line.point
+        if line[point - 1 : point].get_line_text() == " ":
+            while point > 0 and line[point - 1 : point].get_line_text() == " ":
+                point -= 1
+        while point > 0 and line[point - 1 : point].get_line_text() != " ":
+            point -= 1
+        return point
+
+
+PrevSpace = PrevSpace()
+
+
+class StartOfLine(LinePositioner):
+    def __call__(self, line):
+        return 0
+
+
+StartOfLine = StartOfLine()
+
+
+class EndOfLine(LinePositioner):
+    def __call__(self, line):
+        return len(line.line_buffer)
+
+
+EndOfLine = EndOfLine()
+
+
+class Point(LinePositioner):
+    def __call__(self, line):
+        return line.point
+
+
+Point = Point()
+
+
+class Mark(LinePositioner):
+    def __call__(self, line):
+        return line.mark
+
+
+k = Mark()
+
+all_positioners = sorted(
+    [
+        (value.__class__.__name__, value)
+        for key, value in globals().items()
+        if isinstance(value, LinePositioner)
+    ]
+)
+
+# ############## LineSlice #################
+
+
+class LineSlice(object):
+    def __call__(self, line):
+        NotImplementedError("Base class !!!")
+
+
+class CurrentWord(LineSlice):
+    def __call__(self, line):
+        return slice(WordStart(line), WordEnd(line), None)
+
+
+CurrentWord = CurrentWord()
+
+
+class NextWord(LineSlice):
+    def __call__(self, line):
+        work = TextLine(line)
+        work.point = NextWordStart
+        start = work.point
+        stop = NextWordEnd(work)
+        return slice(start, stop)
+
+
+NextWord = NextWord()
+
+
+class PrevWord(LineSlice):
+    def __call__(self, line):
+        work = TextLine(line)
+        work.point = PrevWordEnd
+        stop = work.point
+        start = PrevWordStart(work)
+        return slice(start, stop)
+
+
+PrevWord = PrevWord()
+
+
+class PointSlice(LineSlice):
+    def __call__(self, line):
+        return slice(Point(line), Point(line) + 1, None)
+
+
+PointSlice = PointSlice()
+
+
+# ##############  TextLine  ######################
+
+
+class TextLine(object):
+    def __init__(self, txtstr, point=None, mark=None):
+        self.line_buffer = []
+        self._point = 0
+        self.mark = -1
+        self.undo_stack = []
+        self.overwrite = False
+        if isinstance(txtstr, TextLine):  # copy
+            self.line_buffer = txtstr.line_buffer[:]
+            if point is None:
+                self.point = txtstr.point
+            else:
+                self.point = point
+            if mark is None:
+                self.mark = txtstr.mark
+            else:
+                self.mark = mark
+        else:
+            self._insert_text(txtstr)
+            if point is None:
+                self.point = 0
+            else:
+                self.point = point
+            if mark is None:
+                self.mark = -1
+            else:
+                self.mark = mark
+
+        self.is_word_token = wordmatcher.is_word_token
+        self.next_start_segment = wordmatcher.next_start_segment
+        self.next_end_segment = wordmatcher.next_end_segment
+        self.prev_start_segment = wordmatcher.prev_start_segment
+        self.prev_end_segment = wordmatcher.prev_end_segment
+
+    def push_undo(self):
+        l_text = self.get_line_text()
+        if self.undo_stack and l_text == self.undo_stack[-1].get_line_text():
+            self.undo_stack[-1].point = self.point
+        else:
+            self.undo_stack.append(self.copy())
+
+    def pop_undo(self):
+        if len(self.undo_stack) >= 2:
+            self.undo_stack.pop()
+            self.set_top_undo()
+            self.undo_stack.pop()
+        else:
+            self.reset_line()
+            self.undo_stack = []
+
+    def set_top_undo(self):
+        if self.undo_stack:
+            undo = self.undo_stack[-1]
+            self.line_buffer = undo.line_buffer
+            self.point = undo.point
+            self.mark = undo.mark
+        else:
+            pass
+
+    def __repr__(self):
+        return 'TextLine("%s",point=%s,mark=%s)' % (
+            self.line_buffer,
+            self.point,
+            self.mark,
+        )
+
+    def copy(self):
+        return self.__class__(self)
+
+    def set_point(self, value):
+        if isinstance(value, LinePositioner):
+            value = value(self)
+        assert value <= len(self.line_buffer)
+        if value > len(self.line_buffer):
+            value = len(self.line_buffer)
+        self._point = value
+
+    def get_point(self):
+        return self._point
+
+    point = property(get_point, set_point)
+
+    def visible_line_width(self, position=Point):
+        """Return the visible width of the text up to position."""
+        extra_char_width = len(
+            [None for c in self[:position].line_buffer if 0x2013 <= ord(c) <= 0xFFFD]
+        )
+        return (
+            len(self[:position].quoted_text())
+            + self[:position].line_buffer.count("\t") * 7
+            + extra_char_width
+        )
+
+    def quoted_text(self):
+        quoted = [quote_char(c) for c in self.line_buffer]
+        return "".join(map(ensure_unicode, quoted))
+
+    def get_line_text(self):
+        buf = self.line_buffer
+        buf = list(map(ensure_unicode, buf))
+        return "".join(buf)
+
+    def set_line(self, text, cursor=None):
+        self.line_buffer = [c for c in str(text)]
+        if cursor is None:
+            self.point = len(self.line_buffer)
+        else:
+            self.point = cursor
+
+    def reset_line(self):
+        self.line_buffer = []
+        self.point = 0
+
+    def end_of_line(self):
+        self.point = len(self.line_buffer)
+
+    def _insert_text(self, text, argument=1):
+        text = text * argument
+        if self.overwrite:
+            for c in biter(text):
+                # if self.point:
+                self.line_buffer[self.point] = c
+                self.point += 1
+        else:
+            for c in biter(text):
+                self.line_buffer.insert(self.point, c)
+                self.point += 1
+
+    def __getitem__(self, key):
+        # Check if key is LineSlice, convert to regular slice
+        # and continue processing
+        if isinstance(key, LineSlice):
+            key = key(self)
+        if isinstance(key, slice):
+            if key.step is None:
+                pass
+            else:
+                raise RuntimeError('step is not "None"')
+            if key.start is None:
+                start = StartOfLine(self)
+            elif isinstance(key.start, LinePositioner):
+                start = key.start(self)
+            else:
+                start = key.start
+            if key.stop is None:
+                stop = EndOfLine(self)
+            elif isinstance(key.stop, LinePositioner):
+                stop = key.stop(self)
+            else:
+                stop = key.stop
+            return self.__class__(self.line_buffer[start:stop], point=0)
+        elif isinstance(key, LinePositioner):
+            return self.line_buffer[key(self)]
+        elif isinstance(key, tuple):
+            # Multiple slice not allowed
+            raise IndexError("Cannot use step in line buffer indexing")
+        else:
+            # return TextLine(self.line_buffer[key])
+            return self.line_buffer[key]
+
+    def __delitem__(self, key):
+        point = self.point
+        if isinstance(key, LineSlice):
+            key = key(self)
+        if isinstance(key, slice):
+            start = key.start
+            stop = key.stop
+            if isinstance(start, LinePositioner):
+                start = start(self)
+            elif start is None:
+                start = 0
+            if isinstance(stop, LinePositioner):
+                stop = stop(self)
+            elif stop is None:
+                stop = EndOfLine(self)
+        elif isinstance(key, LinePositioner):
+            start = key(self)
+            stop = start + 1
+        else:
+            start = key
+            stop = key + 1
+        prev = self.line_buffer[:start]
+        rest = self.line_buffer[stop:]
+        self.line_buffer = prev + rest
+        if point > stop:
+            self.point = point - (stop - start)
+        elif point >= start and point <= stop:
+            self.point = start
+
+    def __setitem__(self, key, value):
+        if isinstance(key, LineSlice):
+            key = key(self)
+        if isinstance(key, slice):
+            start = key.start
+            stop = key.stop
+        elif isinstance(key, LinePositioner):
+            start = key(self)
+            stop = start + 1
+        else:
+            start = key
+            stop = key + 1
+        prev = self.line_buffer[:start]
+        value = self.__class__(value).line_buffer
+        rest = self.line_buffer[stop:]
+        out = prev + value + rest
+        if len(out) >= len(self):
+            self.point = len(self)
+        self.line_buffer = out
+
+    def __len__(self):
+        return len(self.line_buffer)
+
+    def upper(self):
+        self.line_buffer = [x.upper() for x in self.line_buffer]
+        return self
+
+    def lower(self):
+        self.line_buffer = [x.lower() for x in self.line_buffer]
+        return self
+
+    def capitalize(self):
+        self.set_line(self.get_line_text().capitalize(), self.point)
+        return self
+
+    def startswith(self, txt):
+        return self.get_line_text().startswith(txt)
+
+    def endswith(self, txt):
+        return self.get_line_text().endswith(txt)
+
+    def __contains__(self, txt):
+        return txt in self.get_line_text()
+
+
+class ReadLineTextBuffer(TextLine):
+    def __init__(self, txtstr, point=None, mark=None):
+        super().__init__(txtstr, point, mark)
+
+        self.enable_win32_clipboard = True
+        self.selection_mark = -1
+        self.enable_selection = True
+        self.kill_ring = []
+
+    def __repr__(self):
+        return "ReadLineTextBuffer" '("%s",point=%s,mark=%s,selection_mark=%s)' % (
+            self.line_buffer,
+            self.point,
+            self.mark,
+            self.selection_mark,
+        )
+
+    def insert_text(self, char, argument=1):
+        self.delete_selection()
+        self.selection_mark = -1
+        self._insert_text(char, argument)
+
+    def to_clipboard(self):
+        if self.enable_win32_clipboard:
+            clipboard.set_clipboard_text(self.get_line_text())
+
+    # Movement
+
+    def beginning_of_line(self):
+        self.selection_mark = -1
+        self.point = StartOfLine
+
+    def end_of_line(self):
+        self.selection_mark = -1
+        self.point = EndOfLine
+
+    def forward_char(self, argument=1):
+        if argument < 0:
+            self.backward_char(-argument)
+        self.selection_mark = -1
+        for _ in range(argument):
+            self.point = NextChar
+
+    def backward_char(self, argument=1):
+        if argument < 0:
+            self.forward_char(-argument)
+        self.selection_mark = -1
+        for _ in range(argument):
+            self.point = PrevChar
+
+    def forward_word(self, argument=1):
+        if argument < 0:
+            self.backward_word(-argument)
+        self.selection_mark = -1
+        for _ in range(argument):
+            self.point = NextWordStart
+
+    def backward_word(self, argument=1):
+        if argument < 0:
+            self.forward_word(-argument)
+        self.selection_mark = -1
+        for _ in range(argument):
+            self.point = PrevWordStart
+
+    def forward_word_end(self, argument=1):
+        if argument < 0:
+            self.backward_word_end(-argument)
+        self.selection_mark = -1
+        for _ in range(argument):
+            self.point = NextWordEnd
+
+    def backward_word_end(self, argument=1):
+        if argument < 0:
+            self.forward_word_end(-argument)
+        self.selection_mark = -1
+        for _ in range(argument):
+            self.point = NextWordEnd
+
+    # Movement select
+    def beginning_of_line_extend_selection(self):
+        if self.enable_selection and self.selection_mark < 0:
+            self.selection_mark = self.point
+        self.point = StartOfLine
+
+    def end_of_line_extend_selection(self):
+        if self.enable_selection and self.selection_mark < 0:
+            self.selection_mark = self.point
+        self.point = EndOfLine
+
+    def forward_char_extend_selection(self, argument=1):
+        if argument < 0:
+            self.backward_char_extend_selection(-argument)
+        if self.enable_selection and self.selection_mark < 0:
+            self.selection_mark = self.point
+        for _ in range(argument):
+            self.point = NextChar
+
+    def backward_char_extend_selection(self, argument=1):
+        if argument < 0:
+            self.forward_char_extend_selection(-argument)
+        if self.enable_selection and self.selection_mark < 0:
+            self.selection_mark = self.point
+        for _ in range(argument):
+            self.point = PrevChar
+
+    def forward_word_extend_selection(self, argument=1):
+        if argument < 0:
+            self.backward_word_extend_selection(-argument)
+        if self.enable_selection and self.selection_mark < 0:
+            self.selection_mark = self.point
+        for _ in range(argument):
+            self.point = NextWordStart
+
+    def backward_word_extend_selection(self, argument=1):
+        if argument < 0:
+            self.forward_word_extend_selection(-argument)
+        if self.enable_selection and self.selection_mark < 0:
+            self.selection_mark = self.point
+        for _ in range(argument):
+            self.point = PrevWordStart
+
+    def forward_word_end_extend_selection(self, argument=1):
+        if argument < 0:
+            self.backward_word_end_extend_selection(-argument)
+        if self.enable_selection and self.selection_mark < 0:
+            self.selection_mark = self.point
+        for _ in range(argument):
+            self.point = NextWordEnd
+
+    def backward_word_end_extend_selection(self, argument=1):
+        if argument < 0:
+            self.forward_word_end_extend_selection(-argument)
+        if self.enable_selection and self.selection_mark < 0:
+            self.selection_mark = self.point
+        for _ in range(argument):
+            self.point = PrevWordEnd
+
+    # delete
+
+    def delete_selection(self):
+        if self.enable_selection and self.selection_mark >= 0:
+            if self.selection_mark < self.point:
+                del self[self.selection_mark : self.point]
+                self.selection_mark = -1
+            else:
+                del self[self.point : self.selection_mark]
+                self.selection_mark = -1
+            return True
+        else:
+            self.selection_mark = -1
+            return False
+
+    def delete_char(self, argument=1):
+        if argument < 0:
+            self.backward_delete_char(-argument)
+        if self.delete_selection():
+            argument -= 1
+        for _ in range(argument):
+            del self[Point]
+
+    def backward_delete_char(self, argument=1):
+        if argument < 0:
+            self.delete_char(-argument)
+        if self.delete_selection():
+            argument -= 1
+        for _ in range(argument):
+            if self.point > 0:
+                self.backward_char()
+                self.delete_char()
+
+    def forward_delete_word(self, argument=1):
+        if argument < 0:
+            self.backward_delete_word(-argument)
+        if self.delete_selection():
+            argument -= 1
+        for _ in range(argument):
+            del self[Point:NextWordStart]
+
+    def backward_delete_word(self, argument=1):
+        if argument < 0:
+            self.forward_delete_word(-argument)
+        if self.delete_selection():
+            argument -= 1
+        for _ in range(argument):
+            del self[PrevWordStart:Point]
+
+    def delete_current_word(self):
+        if not self.delete_selection():
+            del self[CurrentWord]
+        self.selection_mark = -1
+
+    def delete_horizontal_space(self):
+        if self[Point] in " \t":
+            del self[PrevWordEnd:NextWordStart]
+        self.selection_mark = -1
+
+    # Case
+
+    def upcase_word(self):
+        p = self.point
+        try:
+            self[CurrentWord] = self[CurrentWord].upper()
+            self.point = p
+        except NotAWordError:
+            pass
+
+    def downcase_word(self):
+        p = self.point
+        try:
+            self[CurrentWord] = self[CurrentWord].lower()
+            self.point = p
+        except NotAWordError:
+            pass
+
+    def capitalize_word(self):
+        p = self.point
+        try:
+            self[CurrentWord] = self[CurrentWord].capitalize()
+            self.point = p
+        except NotAWordError:
+            pass
+
+    # Transpose
+
+    def transpose_chars(self):
+        p2 = Point(self)
+        if p2 == 0:
+            return
+        elif p2 == len(self):
+            p2 = p2 - 1
+        p1 = p2 - 1
+        self[p2], self[p1] = self[p1], self[p2]
+        self.point = p2 + 1
+
+    def transpose_words(self):
+        word1 = TextLine(self)
+        word2 = TextLine(self)
+        if self.point == len(self):
+            word2.point = PrevWordStart
+            word1.point = PrevWordStart(word2)
+        else:
+            word1.point = PrevWordStart
+            word2.point = NextWordStart
+        stop1 = NextWordEnd(word1)
+        stop2 = NextWordEnd(word2)
+        start1 = word1.point
+        start2 = word2.point
+        self[start2:stop2] = word1[Point:NextWordEnd]
+        self[start1:stop1] = word2[Point:NextWordEnd]
+        self.point = stop2
+
+    # Kill
+
+    def kill_line(self):
+        self.add_to_kill_ring(self[self.point :])
+        del self.line_buffer[self.point :]
+
+    def kill_whole_line(self):
+        self.add_to_kill_ring(self[:])
+        del self[:]
+
+    def backward_kill_line(self):
+        del self[StartOfLine:Point]
+
+    def unix_line_discard(self):
+        del self[StartOfLine:Point]
+
+    def kill_word(self):
+        """Kills to next word ending"""
+        del self[Point:NextWordEnd]
+
+    def backward_kill_word(self):
+        """Kills to next word ending"""
+        if not self.delete_selection():
+            del self[PrevWordStart:Point]
+        self.selection_mark = -1
+
+    def forward_kill_word(self):
+        """Kills to next word ending"""
+        if not self.delete_selection():
+            del self[Point:NextWordEnd]
+        self.selection_mark = -1
+
+    def unix_word_rubout(self):
+        if not self.delete_selection():
+            del self[PrevSpace:Point]
+        self.selection_mark = -1
+
+    def kill_region(self):
+        pass
+
+    def copy_region_as_kill(self):
+        pass
+
+    def copy_backward_word(self):
+        pass
+
+    def copy_forward_word(self):
+        pass
+
+    def yank(self):
+        self.paste_from_kill_ring()
+
+    def yank_pop(self):
+        pass
+
+    # Mark
+
+    def set_mark(self):
+        self.mark = self.point
+
+    def exchange_point_and_mark(self):
+        pass
+
+    def copy_region_to_clipboard(self):  # ()
+        """Copy the text in the region to the windows clipboard."""
+        if self.enable_win32_clipboard:
+            mark = min(self.mark, len(self.line_buffer))
+            cursor = min(self.point, len(self.line_buffer))
+            if self.mark == -1:
+                return
+            begin = min(cursor, mark)
+            end = max(cursor, mark)
+            toclipboard = "".join(self.line_buffer[begin:end])
+            clipboard.set_clipboard_text(toclipboard)
+
+    def copy_selection_to_clipboard(self):  # ()
+        """Copy the text in the region to the windows clipboard."""
+        if (
+            self.enable_win32_clipboard
+            and self.enable_selection
+            and self.selection_mark >= 0
+        ):
+            selection_mark = min(self.selection_mark, len(self.line_buffer))
+            cursor = min(self.point, len(self.line_buffer))
+            if self.selection_mark == -1:
+                return
+            begin = min(cursor, selection_mark)
+            end = max(cursor, selection_mark)
+            toclipboard = "".join(self.line_buffer[begin:end])
+            clipboard.set_clipboard_text(toclipboard)
+
+    def cut_selection_to_clipboard(self):  # ()
+        self.copy_selection_to_clipboard()
+        self.delete_selection()
+
+    # Paste
+
+    # Kill ring
+
+    def add_to_kill_ring(self, txt):
+        self.kill_ring = [txt]
+        if kill_ring_to_clipboard:
+            clipboard.set_clipboard_text(txt.get_line_text())
+
+    def paste_from_kill_ring(self):
+        if self.kill_ring:
+            self.insert_text(self.kill_ring[0])
+
+
+##################################################################
+q = ReadLineTextBuffer("asff asFArw  ewrWErhg", point=8)
+q = TextLine("asff asFArw  ewrWErhg", point=8)
+
+
+def show_pos(buff, pos, chr="."):
+    l_n = len(buff.line_buffer)
+
+    def choice(is_bool):
+        if is_bool:
+            return chr
+        else:
+            return " "
+
+    return "".join([choice(pos == idx) for idx in range(l_n + 1)])
+
+
+def test_positioner(buff, points, positioner):
+    print((" %s " % positioner.__class__.__name__).center(40, "-"))
+    buffstr = buff.line_buffer
+
+    print('"%s"' % (buffstr))
+    for point in points:
+        b = TextLine(buff, point=point)
+        out = [" "] * (len(buffstr) + 1)
+        pos = positioner(b)
+        if pos == point:
+            out[pos] = "&"
+        else:
+            out[point] = "."
+            out[pos] = "^"
+        print('"%s"' % ("".join(out)))
+
+
+if __name__ == "__main__":
+
+    print('%-15s "%s"' % ("Position", q.get_line_text()))
+    print('%-15s "%s"' % ("Point", show_pos(q, q.point)))
+
+    for name, positioner_q in all_positioners:
+        pos_q = positioner_q(q)
+
+        print('%-15s "%s"' % (name, show_pos(q, pos_q, "^")))
+
+    l_t = ReadLineTextBuffer("kjjk asads   asad")
+    l_t.point = EndOfLine

rl/Lib/site-packages/pyreadline3/lineeditor/wordmatcher.py

@@ -0,0 +1,124 @@
+# -*- coding: utf-8 -*-
+# *****************************************************************************
+#       Copyright (C) 2006-2020 Jorgen Stenarson. <jorgen.stenarson@bostream.nu>
+#       Copyright (C) 2020 Bassem Girgis. <brgirgis@gmail.com>
+#
+#  Distributed under the terms of the BSD License.  The full license is in
+#  the file COPYING, distributed as part of this software.
+# *****************************************************************************
+
+
+import re
+
+
+def str_find_all(in_str, ch):
+    result = []
+    index = 0
+    while index >= 0:
+        index = in_str.find(ch, index)
+        if index >= 0:
+            result.append(index)
+            index += 1
+    return result
+
+
+word_pattern = re.compile("(x*)")
+
+
+def markwords(in_str, is_wordfun):
+    markers = {True: "x", False: "o"}
+    return "".join([markers[is_wordfun(ch)] for ch in in_str])
+
+
+def split_words(in_str, is_wordfun):
+    return [x for x in word_pattern.split(markwords(in_str, is_wordfun)) if x != ""]
+
+
+def mark_start_segment(in_str, is_segment):
+    def mark_start(s):
+        if s[0:1] == "x":
+            return "s" + s[1:]
+        else:
+            return s
+
+    return "".join(map(mark_start, split_words(in_str, is_segment)))
+
+
+def mark_end_segment(in_str, is_segment):
+    def mark_start(s):
+        if s[0:1] == "x":
+            return s[:-1] + "s"
+        else:
+            return s
+
+    return "".join(map(mark_start, split_words(in_str, is_segment)))
+
+
+def mark_start_segment_index(in_str, is_segment):
+    return str_find_all(mark_start_segment(in_str, is_segment), "s")
+
+
+def mark_end_segment_index(in_str, is_segment):
+    return [x + 1 for x in str_find_all(mark_end_segment(in_str, is_segment), "s")]
+
+
+# ###############  Following are used in lineobj  ###########################
+
+
+def is_word_token(in_str):
+    return not is_non_word_token(in_str)
+
+
+def is_non_word_token(in_str):
+    if len(in_str) != 1 or in_str in " \t\n":
+        return True
+    else:
+        return False
+
+
+def next_start_segment(in_str, is_segment):
+    in_str = "".join(in_str)
+    result = []
+    for start in mark_start_segment_index(in_str, is_segment):
+        result[len(result) : start] = [start for x in range(start - len(result))]
+    result[len(result) : len(in_str)] = [
+        len(in_str) for x in range(len(in_str) - len(result) + 1)
+    ]
+    return result
+
+
+def next_end_segment(in_str, is_segment):
+    in_str = "".join(in_str)
+    result = []
+    for start in mark_end_segment_index(in_str, is_segment):
+        result[len(result) : start] = [start for x in range(start - len(result))]
+    result[len(result) : len(in_str)] = [
+        len(in_str) for x in range(len(in_str) - len(result) + 1)
+    ]
+    return result
+
+
+def prev_start_segment(in_str, is_segment):
+    in_str = "".join(in_str)
+    result = []
+    prev = 0
+    for start in mark_start_segment_index(in_str, is_segment):
+        result[len(result) : start + 1] = [prev for x in range(start - len(result) + 1)]
+        prev = start
+    result[len(result) : len(in_str)] = [
+        prev for x in range(len(in_str) - len(result) + 1)
+    ]
+    return result
+
+
+def prev_end_segment(in_str, is_segment):
+    in_str = "".join(in_str)
+    result = []
+    prev = 0
+    for start in mark_end_segment_index(in_str, is_segment):
+        result[len(result) : start + 1] = [prev for x in range(start - len(result) + 1)]
+        prev = start
+    result[len(result) : len(in_str)] = [
+        len(in_str) for x in range(len(in_str) - len(result) + 1)
+    ]
+    return result

rl/Lib/site-packages/pyreadline3/logger/__init__.py

@@ -0,0 +1,26 @@
+# -*- coding: utf-8 -*-
+# *****************************************************************************
+#     Copyright (C) 2006-2020 Jorgen Stenarson. <jorgen.stenarson@bostream.nu>
+#     Copyright (C) 2020 Bassem Girgis. <brgirgis@gmail.com>
+#
+#  Distributed under the terms of the BSD License.  The full license is in
+#  the file COPYING, distributed as part of this software.
+# *****************************************************************************
+
+from .control import (
+    start_file_log,
+    start_socket_log,
+    stop_file_log,
+    stop_logging,
+    stop_socket_log,
+)
+from .log import log
+
+__all__ = [
+    "start_file_log",
+    "start_socket_log",
+    "stop_file_log",
+    "stop_logging",
+    "stop_socket_log",
+    "log",
+]

rl/Lib/site-packages/pyreadline3/logger/control.py

@@ -0,0 +1,75 @@
+# -*- coding: utf-8 -*-
+# *****************************************************************************
+#     Copyright (C) 2006-2020 Jorgen Stenarson. <jorgen.stenarson@bostream.nu>
+#     Copyright (C) 2020 Bassem Girgis. <brgirgis@gmail.com>
+#
+#  Distributed under the terms of the BSD License.  The full license is in
+#  the file COPYING, distributed as part of this software.
+# *****************************************************************************
+
+import os
+from logging import FileHandler, Formatter, StreamHandler
+from logging.handlers import DEFAULT_TCP_LOGGING_PORT
+from typing import Optional
+
+from .logger import LOGGER
+from .socket_stream import SocketStream
+
+_default_formatter_str = os.environ.get("PYREADLINE_FORMATTER", "%(message)s")
+
+SOCKET_HANDLER: Optional["StreamHandler[SocketStream]"] = None
+FILE_HANDLER: Optional[FileHandler] = None
+
+
+def start_socket_log(
+    host: str = "localhost",
+    port: int = DEFAULT_TCP_LOGGING_PORT,
+    formatter_str: str = _default_formatter_str,
+) -> None:
+    global SOCKET_HANDLER
+
+    if SOCKET_HANDLER is not None:
+        return
+
+    SOCKET_HANDLER = StreamHandler(SocketStream(host, port))
+    SOCKET_HANDLER.setFormatter(Formatter(formatter_str))
+
+    LOGGER.addHandler(SOCKET_HANDLER)
+
+
+def stop_socket_log() -> None:
+    global SOCKET_HANDLER
+
+    if SOCKET_HANDLER is None:
+        return
+
+    LOGGER.removeHandler(SOCKET_HANDLER)
+
+    SOCKET_HANDLER = None
+
+
+def start_file_log(filename: str) -> None:
+    global FILE_HANDLER
+
+    if FILE_HANDLER is not None:
+        return
+
+    FILE_HANDLER = FileHandler(filename, "w")
+    LOGGER.addHandler(FILE_HANDLER)
+
+
+def stop_file_log() -> None:
+    global FILE_HANDLER
+
+    if FILE_HANDLER is None:
+        return
+
+    LOGGER.removeHandler(FILE_HANDLER)
+
+    FILE_HANDLER.close()
+    FILE_HANDLER = None
+
+
+def stop_logging() -> None:
+    stop_file_log()
+    stop_socket_log()

rl/Lib/site-packages/pyreadline3/logger/log.py

@@ -0,0 +1,18 @@
+# -*- coding: utf-8 -*-
+# *****************************************************************************
+#     Copyright (C) 2006-2020 Jorgen Stenarson. <jorgen.stenarson@bostream.nu>
+#     Copyright (C) 2020 Bassem Girgis. <brgirgis@gmail.com>
+#
+#  Distributed under the terms of the BSD License.  The full license is in
+#  the file COPYING, distributed as part of this software.
+# *****************************************************************************
+
+from pyreadline3.unicode_helper import ensure_str
+
+from .logger import LOGGER
+
+
+def log(record: str) -> None:
+    s = ensure_str(record)
+
+    LOGGER.debug(s)

rl/Lib/site-packages/pyreadline3/logger/logger.py

@@ -0,0 +1,20 @@
+# -*- coding: utf-8 -*-
+# *****************************************************************************
+#     Copyright (C) 2006-2020 Jorgen Stenarson. <jorgen.stenarson@bostream.nu>
+#     Copyright (C) 2020 Bassem Girgis. <brgirgis@gmail.com>
+#
+#  Distributed under the terms of the BSD License.  The full license is in
+#  the file COPYING, distributed as part of this software.
+# *****************************************************************************
+
+import logging
+import os
+
+from .null_handler import NULLHandler
+
+_default_log_level = os.environ.get("PYREADLINE_LOG", "DEBUG")
+
+LOGGER = logging.getLogger("PYREADLINE")
+LOGGER.setLevel(_default_log_level)
+LOGGER.propagate = False
+LOGGER.addHandler(NULLHandler())

rl/Lib/site-packages/pyreadline3/logger/null_handler.py

@@ -0,0 +1,16 @@
+# -*- coding: utf-8 -*-
+# *****************************************************************************
+#     Copyright (C) 2006-2020 Jorgen Stenarson. <jorgen.stenarson@bostream.nu>
+#     Copyright (C) 2020 Bassem Girgis. <brgirgis@gmail.com>
+#
+#  Distributed under the terms of the BSD License.  The full license is in
+#  the file COPYING, distributed as part of this software.
+# *****************************************************************************
+
+from logging import Handler, LogRecord
+
+
+class NULLHandler(Handler):
+
+    def emit(self, record: LogRecord) -> None:
+        pass

rl/Lib/site-packages/pyreadline3/logger/socket_stream.py

@@ -0,0 +1,35 @@
+# -*- coding: utf-8 -*-
+# *****************************************************************************
+#     Copyright (C) 2006-2020 Jorgen Stenarson. <jorgen.stenarson@bostream.nu>
+#     Copyright (C) 2020 Bassem Girgis. <brgirgis@gmail.com>
+#
+#  Distributed under the terms of the BSD License.  The full license is in
+#  the file COPYING, distributed as part of this software.
+# *****************************************************************************
+
+from socket import AF_INET, SOCK_DGRAM, socket
+
+from pyreadline3.unicode_helper import ensure_str
+
+
+class SocketStream:
+    def __init__(
+        self,
+        host: str,
+        port: int,
+    ) -> None:
+        self.__host = host
+        self.__port = port
+        self.__socket = socket(AF_INET, SOCK_DGRAM)
+
+    def write(self, record: str) -> None:
+        self.__socket.sendto(
+            ensure_str(record),
+            (self.__host, self.__port),
+        )
+
+    def flush(self) -> None:
+        pass
+
+    def close(self) -> None:
+        pass

rl/Lib/site-packages/pyreadline3/modes/__init__.py

@@ -0,0 +1,7 @@
+from . import emacs, notemacs, vi
+
+__all__ = ["emacs", "notemacs", "vi"]
+
+editingmodes = [emacs.EmacsMode, notemacs.NotEmacsMode, vi.ViMode]
+
+# add check to ensure all modes have unique mode names

rl/Lib/site-packages/pyreadline3/modes/basemode.py

@@ -0,0 +1,582 @@
+# -*- coding: utf-8 -*-
+# *****************************************************************************
+#       Copyright (C) 2003-2006 Gary Bishop.
+#       Copyright (C) 2006-2020 Jorgen Stenarson. <jorgen.stenarson@bostream.nu>
+#       Copyright (C) 2020 Bassem Girgis. <brgirgis@gmail.com>
+#
+#  Distributed under the terms of the BSD License.  The full license is in
+#  the file COPYING, distributed as part of this software.
+# *****************************************************************************
+
+
+import glob
+import math
+import os
+import re
+import sys
+
+import pyreadline3.clipboard as clipboard
+import pyreadline3.lineeditor.history as history
+import pyreadline3.lineeditor.lineobj as lineobj
+from pyreadline3.error import ReadlineError
+from pyreadline3.keysyms.common import make_KeyPress_from_keydescr
+from pyreadline3.logger import log
+from pyreadline3.py3k_compat import is_callable, is_ironpython
+from pyreadline3.unicode_helper import ensure_str, ensure_unicode
+
+
+class BaseMode(object):
+    mode = "base"
+
+    def __init__(self, rlobj):
+        self.argument = 0
+        self.rlobj = rlobj
+        self.exit_dispatch = {}
+        self.key_dispatch = {}
+        self.argument = 1
+        self.prevargument = None
+        self.l_buffer = lineobj.ReadLineTextBuffer("")
+        self._history = history.LineHistory()
+        self.completer_delims = " \t\n\"\\'`@$><=;|&{("
+        self.show_all_if_ambiguous = "on"
+        self.mark_directories = "on"
+        self.complete_filesystem = "off"
+        self.completer = None
+        self.begidx = 0
+        self.endidx = 0
+        self.tabstop = 4
+        self.startup_hook = None
+        self.pre_input_hook = None
+        self.first_prompt = True
+        self.cursor_size = 25
+
+        self.prompt = ">>> "
+
+        # Paste settings
+        # assumes data on clipboard is path if shorter than 300 characters and doesn't contain \t or \n
+        # and replace \ with / for easier use in ipython
+        self.enable_ipython_paste_for_paths = True
+
+        # automatically convert tabseparated data to list of lists or array
+        # constructors
+        self.enable_ipython_paste_list_of_lists = True
+        self.enable_win32_clipboard = True
+
+        self.paste_line_buffer = []
+
+        self._sub_modes = []
+
+    def __repr__(self):
+        return "<BaseMode>"
+
+    def _gs(x):
+        def g(self):
+            return getattr(self.rlobj, x)
+
+        def s(self, q):
+            setattr(self.rlobj, x, q)
+
+        return g, s
+
+    def _g(x):
+        def g(self):
+            return getattr(self.rlobj, x)
+
+        return g
+
+    def _argreset(self):
+        val = self.argument
+        self.argument = 0
+        if val == 0:
+            val = 1
+        return val
+
+    argument_reset = property(_argreset)
+
+    # used in readline
+    ctrl_c_tap_time_interval = property(*_gs("ctrl_c_tap_time_interval"))
+    allow_ctrl_c = property(*_gs("allow_ctrl_c"))
+    _print_prompt = property(_g("_print_prompt"))
+    _update_line = property(_g("_update_line"))
+    console = property(_g("console"))
+    prompt_begin_pos = property(_g("prompt_begin_pos"))
+    prompt_end_pos = property(_g("prompt_end_pos"))
+
+    # used in completer _completions
+    # completer_delims=property(*_gs("completer_delims"))
+    _bell = property(_g("_bell"))
+    bell_style = property(_g("bell_style"))
+
+    # used in emacs
+    _clear_after = property(_g("_clear_after"))
+    _update_prompt_pos = property(_g("_update_prompt_pos"))
+
+    # not used in basemode or emacs
+
+    def process_keyevent(self, keyinfo):
+        raise NotImplementedError
+
+    def readline_setup(self, prompt=""):
+        self.l_buffer.selection_mark = -1
+        if self.first_prompt:
+            self.first_prompt = False
+            if self.startup_hook:
+                try:
+                    self.startup_hook()
+                except BaseException:
+                    print("startup hook failed")
+                    traceback.print_exc()
+
+        self.l_buffer.reset_line()
+        self.prompt = prompt
+
+        if self.pre_input_hook:
+            try:
+                self.pre_input_hook()
+            except BaseException:
+                print("pre_input_hook failed")
+                traceback.print_exc()
+                self.pre_input_hook = None
+
+    # ###################################
+
+    def finalize(self):
+        """Every bindable command should call this function for cleanup.
+        Except those that want to set argument to a non-zero value.
+        """
+        self.argument = 0
+
+    def add_history(self, text):
+        self._history.add_history(lineobj.ReadLineTextBuffer(text))
+
+    # Create key bindings:
+
+    def rl_settings_to_string(self):
+        out = ["%-20s: %s" % ("show all if ambigous", self.show_all_if_ambiguous)]
+        out.append("%-20s: %s" % ("mark_directories", self.mark_directories))
+        out.append("%-20s: %s" % ("bell_style", self.bell_style))
+        out.append("------------- key bindings ------------")
+        tablepat = "%-7s %-7s %-7s %-15s %-15s "
+        out.append(tablepat % ("Control", "Meta", "Shift", "Keycode/char", "Function"))
+        bindings = sorted(
+            [(k[0], k[1], k[2], k[3], v.__name__) for k, v in self.key_dispatch.items()]
+        )
+        for key in bindings:
+            out.append(tablepat % (key))
+        return out
+
+    def _bind_key(self, key, func):
+        """setup the mapping from key to call the function."""
+        if not is_callable(func):
+            print("Trying to bind non method to keystroke:%s,%s" % (key, func))
+            raise ReadlineError(
+                "Trying to bind non method to keystroke:%s,%s,%s,%s"
+                % (key, func, type(func), type(self._bind_key))
+            )
+        keyinfo = make_KeyPress_from_keydescr(key.lower()).tuple()
+        log(">>>%s -> %s<<<" % (keyinfo, func.__name__))
+        self.key_dispatch[keyinfo] = func
+
+    def _bind_exit_key(self, key):
+        """setup the mapping from key to call the function."""
+        keyinfo = make_KeyPress_from_keydescr(key.lower()).tuple()
+        self.exit_dispatch[keyinfo] = None
+
+    def init_editing_mode(self, e):  # (C-e)
+        """When in vi command mode, this causes a switch to emacs editing
+        mode."""
+
+        raise NotImplementedError
+
+    # completion commands
+
+    def _get_completions(self):
+        """Return a list of possible completions for the string ending at the point.
+        Also set begidx and endidx in the process."""
+        completions = []
+        self.begidx = self.l_buffer.point
+        self.endidx = self.l_buffer.point
+        buf = self.l_buffer.line_buffer
+        if self.completer:
+            # get the string to complete
+            while self.begidx > 0:
+                self.begidx -= 1
+                if buf[self.begidx] in self.completer_delims:
+                    self.begidx += 1
+                    break
+            text = ensure_str("".join(buf[self.begidx : self.endidx]))
+            log('complete text="%s"' % ensure_unicode(text))
+            i = 0
+            while True:
+                try:
+                    r = self.completer(ensure_unicode(text), i)
+                except IndexError:
+                    break
+                i += 1
+                if r is None:
+                    break
+                elif r and r not in completions:
+                    completions.append(r)
+                else:
+                    pass
+            log("text completions=<%s>" % list(map(ensure_unicode, completions)))
+        if (self.complete_filesystem == "on") and not completions:
+            # get the filename to complete
+            while self.begidx > 0:
+                self.begidx -= 1
+                if buf[self.begidx] in " \t\n":
+                    self.begidx += 1
+                    break
+            text = ensure_str("".join(buf[self.begidx : self.endidx]))
+            log('file complete text="%s"' % ensure_unicode(text))
+            completions = list(
+                map(
+                    ensure_unicode,
+                    glob.glob(os.path.expanduser(text) + "*".encode("ascii")),
+                )
+            )
+            if self.mark_directories == "on":
+                mc = []
+                for f in completions:
+                    if os.path.isdir(f):
+                        mc.append(f + os.sep)
+                    else:
+                        mc.append(f)
+                completions = mc
+            log("fnames=<%s>" % list(map(ensure_unicode, completions)))
+        return completions
+
+    def _display_completions(self, completions):
+        if not completions:
+            return
+        self.console.write("\n")
+        wmax = max(map(len, completions))
+        w, h = self.console.size()
+        cols = max(1, int((w - 1) / (wmax + 1)))
+        rows = int(math.ceil(float(len(completions)) / cols))
+        for row in range(rows):
+            s = ""
+            for col in range(cols):
+                i = col * rows + row
+                if i < len(completions):
+                    self.console.write(completions[i].ljust(wmax + 1))
+            self.console.write("\n")
+        if is_ironpython:
+            self.prompt = sys.ps1
+        self._print_prompt()
+
+    def complete(self, e):  # (TAB)
+        """Attempt to perform completion on the text before point. The
+        actual completion performed is application-specific. The default is
+        filename completion."""
+        completions = self._get_completions()
+        if completions:
+            cprefix = commonprefix(completions)
+            if len(cprefix) > 0:
+                rep = [c for c in cprefix]
+                point = self.l_buffer.point
+                self.l_buffer[self.begidx : self.endidx] = rep
+                self.l_buffer.point = point + len(rep) - (self.endidx - self.begidx)
+            if len(completions) > 1:
+                if self.show_all_if_ambiguous == "on":
+                    self._display_completions(completions)
+                else:
+                    self._bell()
+        else:
+            self._bell()
+        self.finalize()
+
+    def possible_completions(self, e):  # (M-?)
+        """List the possible completions of the text before point."""
+        completions = self._get_completions()
+        self._display_completions(completions)
+        self.finalize()
+
+    def insert_completions(self, e):  # (M-*)
+        """Insert all completions of the text before point that would have
+        been generated by possible-completions."""
+        completions = self._get_completions()
+        b = self.begidx
+        e = self.endidx
+        for comp in completions:
+            rep = [c for c in comp]
+            rep.append(" ")
+            self.l_buffer[b:e] = rep
+            b += len(rep)
+            e = b
+        self.line_cursor = b
+        self.finalize()
+
+    def menu_complete(self, e):  # ()
+        """Similar to complete, but replaces the word to be completed with a
+        single match from the list of possible completions. Repeated
+        execution of menu-complete steps through the list of possible
+        completions, inserting each match in turn. At the end of the list of
+        completions, the bell is rung (subject to the setting of bell-style)
+        and the original text is restored. An argument of n moves n
+        positions forward in the list of matches; a negative argument may be
+        used to move backward through the list. This command is intended to
+        be bound to TAB, but is unbound by default."""
+        self.finalize()
+
+    # Methods below here are bindable emacs functions
+
+    def insert_text(self, string):
+        """Insert text into the command line."""
+        self.l_buffer.insert_text(string, self.argument_reset)
+        self.finalize()
+
+    def beginning_of_line(self, e):  # (C-a)
+        """Move to the start of the current line."""
+        self.l_buffer.beginning_of_line()
+        self.finalize()
+
+    def end_of_line(self, e):  # (C-e)
+        """Move to the end of the line."""
+        self.l_buffer.end_of_line()
+        self.finalize()
+
+    def forward_char(self, e):  # (C-f)
+        """Move forward a character."""
+        self.l_buffer.forward_char(self.argument_reset)
+        self.finalize()
+
+    def backward_char(self, e):  # (C-b)
+        """Move back a character."""
+        self.l_buffer.backward_char(self.argument_reset)
+        self.finalize()
+
+    def forward_word(self, e):  # (M-f)
+        """Move forward to the end of the next word. Words are composed of
+        letters and digits."""
+        self.l_buffer.forward_word(self.argument_reset)
+        self.finalize()
+
+    def backward_word(self, e):  # (M-b)
+        """Move back to the start of the current or previous word. Words are
+        composed of letters and digits."""
+        self.l_buffer.backward_word(self.argument_reset)
+        self.finalize()
+
+    def forward_word_end(self, e):  # ()
+        """Move forward to the end of the next word. Words are composed of
+        letters and digits."""
+        self.l_buffer.forward_word_end(self.argument_reset)
+        self.finalize()
+
+    def backward_word_end(self, e):  # ()
+        """Move forward to the end of the next word. Words are composed of
+        letters and digits."""
+        self.l_buffer.backward_word_end(self.argument_reset)
+        self.finalize()
+
+    # Movement with extend selection
+    def beginning_of_line_extend_selection(self, e):
+        """Move to the start of the current line."""
+        self.l_buffer.beginning_of_line_extend_selection()
+        self.finalize()
+
+    def end_of_line_extend_selection(self, e):
+        """Move to the end of the line."""
+        self.l_buffer.end_of_line_extend_selection()
+        self.finalize()
+
+    def forward_char_extend_selection(self, e):
+        """Move forward a character."""
+        self.l_buffer.forward_char_extend_selection(self.argument_reset)
+        self.finalize()
+
+    def backward_char_extend_selection(self, e):
+        """Move back a character."""
+        self.l_buffer.backward_char_extend_selection(self.argument_reset)
+        self.finalize()
+
+    def forward_word_extend_selection(self, e):
+        """Move forward to the end of the next word. Words are composed of
+        letters and digits."""
+        self.l_buffer.forward_word_extend_selection(self.argument_reset)
+        self.finalize()
+
+    def backward_word_extend_selection(self, e):
+        """Move back to the start of the current or previous word. Words are
+        composed of letters and digits."""
+        self.l_buffer.backward_word_extend_selection(self.argument_reset)
+        self.finalize()
+
+    def forward_word_end_extend_selection(self, e):
+        """Move forward to the end of the next word. Words are composed of
+        letters and digits."""
+        self.l_buffer.forward_word_end_extend_selection(self.argument_reset)
+        self.finalize()
+
+    def backward_word_end_extend_selection(self, e):
+        """Move forward to the end of the next word. Words are composed of
+        letters and digits."""
+        self.l_buffer.forward_word_end_extend_selection(self.argument_reset)
+        self.finalize()
+
+    # Change case
+
+    def upcase_word(self, e):  # (M-u)
+        """Uppercase the current (or following) word. With a negative
+        argument, uppercase the previous word, but do not move the cursor."""
+        self.l_buffer.upcase_word()
+        self.finalize()
+
+    def downcase_word(self, e):  # (M-l)
+        """Lowercase the current (or following) word. With a negative
+        argument, lowercase the previous word, but do not move the cursor."""
+        self.l_buffer.downcase_word()
+        self.finalize()
+
+    def capitalize_word(self, e):  # (M-c)
+        """Capitalize the current (or following) word. With a negative
+        argument, capitalize the previous word, but do not move the cursor."""
+        self.l_buffer.capitalize_word()
+        self.finalize()
+
+    # #######
+
+    def clear_screen(self, e):  # (C-l)
+        """Clear the screen and redraw the current line, leaving the current
+        line at the top of the screen."""
+        self.console.page()
+        self.finalize()
+
+    def redraw_current_line(self, e):  # ()
+        """Refresh the current line. By default, this is unbound."""
+        self.finalize()
+
+    def accept_line(self, e):  # (Newline or Return)
+        """Accept the line regardless of where the cursor is. If this line
+        is non-empty, it may be added to the history list for future recall
+        with add_history(). If this line is a modified history line, the
+        history line is restored to its original state."""
+        self.finalize()
+        return True
+
+    def delete_char(self, e):  # (C-d)
+        """Delete the character at point. If point is at the beginning of
+        the line, there are no characters in the line, and the last
+        character typed was not bound to delete-char, then return EOF."""
+        self.l_buffer.delete_char(self.argument_reset)
+        self.finalize()
+
+    def backward_delete_char(self, e):  # (Rubout)
+        """Delete the character behind the cursor. A numeric argument means
+        to kill the characters instead of deleting them."""
+        self.l_buffer.backward_delete_char(self.argument_reset)
+        self.finalize()
+
+    def backward_delete_word(self, e):  # (Control-Rubout)
+        """Delete the character behind the cursor. A numeric argument means
+        to kill the characters instead of deleting them."""
+        self.l_buffer.backward_delete_word(self.argument_reset)
+        self.finalize()
+
+    def forward_delete_word(self, e):  # (Control-Delete)
+        """Delete the character behind the cursor. A numeric argument means
+        to kill the characters instead of deleting them."""
+        self.l_buffer.forward_delete_word(self.argument_reset)
+        self.finalize()
+
+    def delete_horizontal_space(self, e):  # ()
+        """Delete all spaces and tabs around point. By default, this is unbound."""
+        self.l_buffer.delete_horizontal_space()
+        self.finalize()
+
+    def self_insert(self, e):  # (a, b, A, 1, !, ...)
+        """Insert yourself."""
+        if (
+            e.char and ord(e.char) != 0
+        ):  # don't insert null character in buffer, can happen with dead keys.
+            self.insert_text(e.char)
+        self.finalize()
+
+    # Paste from clipboard
+
+    def paste(self, e):
+        """Paste windows clipboard.
+        Assume single line strip other lines and end of line markers and trailing spaces
+        """  # (Control-v)
+        if self.enable_win32_clipboard:
+            txt = clipboard.get_clipboard_text_and_convert(False)
+            txt = txt.split("\n")[0].strip("\r").strip("\n")
+            log("paste: >%s<" % list(map(ord, txt)))
+            self.insert_text(txt)
+        self.finalize()
+
+    def paste_mulitline_code(self, e):
+        """Paste windows clipboard as multiline code.
+        Removes any empty lines in the code"""
+        reg = re.compile("\r?\n")
+        if self.enable_win32_clipboard:
+            txt = clipboard.get_clipboard_text_and_convert(False)
+            t = reg.split(txt)
+            t = [row for row in t if row.strip() != ""]  # remove empty lines
+            if t != [""]:
+                self.insert_text(t[0])
+                self.add_history(self.l_buffer.copy())
+                self.paste_line_buffer = t[1:]
+                log("multi: >%s<" % self.paste_line_buffer)
+                return True
+            else:
+                return False
+        self.finalize()
+
+    def ipython_paste(self, e):
+        """Paste windows clipboard. If enable_ipython_paste_list_of_lists is
+        True then try to convert tabseparated data to repr of list of lists or
+        repr of array.
+        If enable_ipython_paste_for_paths==True then change \\ to / and spaces
+        to \\space"""
+        if self.enable_win32_clipboard:
+            txt = clipboard.get_clipboard_text_and_convert(
+                self.enable_ipython_paste_list_of_lists
+            )
+            if self.enable_ipython_paste_for_paths:
+                if len(txt) < 300 and ("\t" not in txt) and ("\n" not in txt):
+                    txt = txt.replace("\\", "/").replace(" ", r"\ ")
+            self.insert_text(txt)
+        self.finalize()
+
+    def copy_region_to_clipboard(self, e):  # ()
+        """Copy the text in the region to the windows clipboard."""
+        self.l_buffer.copy_region_to_clipboard()
+        self.finalize()
+
+    def copy_selection_to_clipboard(self, e):  # ()
+        """Copy the text in the region to the windows clipboard."""
+        self.l_buffer.copy_selection_to_clipboard()
+        self.finalize()
+
+    def cut_selection_to_clipboard(self, e):  # ()
+        """Copy the text in the region to the windows clipboard."""
+        self.l_buffer.cut_selection_to_clipboard()
+        self.finalize()
+
+    def dump_functions(self, e):  # ()
+        """Print all of the functions and their key bindings to the Readline
+        output stream. If a numeric argument is supplied, the output is
+        formatted in such a way that it can be made part of an inputrc
+        file. This command is unbound by default."""
+        print()
+        txt = "\n".join(self.rl_settings_to_string())
+        print(txt)
+        self._print_prompt()
+        self.finalize()
+
+
+def commonprefix(m):
+    "Given a list of pathnames, returns the longest common leading component"
+    if not m:
+        return ""
+    prefix = m[0]
+    for item in m:
+        for i in range(len(prefix)):
+            if prefix[: i + 1].lower() != item[: i + 1].lower():
+                prefix = prefix[:i]
+                if i == 0:
+                    return ""
+                break
+    return prefix

rl/Lib/site-packages/pyreadline3/modes/emacs.py

@@ -0,0 +1,716 @@
+# -*- coding: utf-8 -*-
+# *****************************************************************************
+#       Copyright (C) 2003-2006 Gary Bishop.
+#       Copyright (C) 2006-2020 Jorgen Stenarson. <jorgen.stenarson@bostream.nu>
+#       Copyright (C) 2020 Bassem Girgis. <brgirgis@gmail.com>
+#
+#  Distributed under the terms of the BSD License.  The full license is in
+#  the file COPYING, distributed as part of this software.
+# *****************************************************************************
+
+
+import pyreadline3.lineeditor.lineobj as lineobj
+from pyreadline3.lineeditor.lineobj import Point
+from pyreadline3.logger import log
+
+from . import basemode
+
+
+class IncrementalSearchPromptMode(object):
+    def __init__(self, rlobj):
+        pass
+
+    def _process_incremental_search_keyevent(self, keyinfo):
+        log("_process_incremental_search_keyevent")
+        keytuple = keyinfo.tuple()
+        # dispatch_func = self.key_dispatch.get(keytuple, default)
+        revtuples = []
+        fwdtuples = []
+        for ktuple, func in self.key_dispatch.items():
+            if func == self.reverse_search_history:
+                revtuples.append(ktuple)
+            elif func == self.forward_search_history:
+                fwdtuples.append(ktuple)
+
+        log("IncrementalSearchPromptMode %s %s" % (keyinfo, keytuple))
+        if keyinfo.keyname == "backspace":
+            self.subsearch_query = self.subsearch_query[:-1]
+            if len(self.subsearch_query) > 0:
+                self.line = self.subsearch_fun(self.subsearch_query)
+            else:
+                self._bell()
+                self.line = ""  # empty query means no search result
+        elif keyinfo.keyname in ["return", "escape"]:
+            self._bell()
+            self.prompt = self.subsearch_oldprompt
+            self.process_keyevent_queue = self.process_keyevent_queue[:-1]
+            self._history.history_cursor = len(self._history.history)
+            if keyinfo.keyname == "escape":
+                self.l_buffer.set_line(self.subsearch_old_line)
+            return True
+        elif keyinfo.keyname:
+            pass
+        elif keytuple in revtuples:
+            self.subsearch_fun = self._history.reverse_search_history
+            self.subsearch_prompt = "reverse-i-search%d`%s': "
+            self.line = self.subsearch_fun(self.subsearch_query)
+        elif keytuple in fwdtuples:
+            self.subsearch_fun = self._history.forward_search_history
+            self.subsearch_prompt = "forward-i-search%d`%s': "
+            self.line = self.subsearch_fun(self.subsearch_query)
+        elif keyinfo.control == False and keyinfo.meta == False:
+            self.subsearch_query += keyinfo.char
+            self.line = self.subsearch_fun(self.subsearch_query)
+        else:
+            pass
+        self.prompt = self.subsearch_prompt % (
+            self._history.history_cursor,
+            self.subsearch_query,
+        )
+        self.l_buffer.set_line(self.line)
+
+    def _init_incremental_search(self, searchfun, init_event):
+        """Initialize search prompt"""
+        log("init_incremental_search")
+        self.subsearch_query = ""
+        self.subsearch_fun = searchfun
+        self.subsearch_old_line = self.l_buffer.get_line_text()
+
+        queue = self.process_keyevent_queue
+        queue.append(self._process_incremental_search_keyevent)
+
+        self.subsearch_oldprompt = self.prompt
+
+        if (
+            self.previous_func != self.reverse_search_history
+            and self.previous_func != self.forward_search_history
+        ):
+            self.subsearch_query = self.l_buffer[0:Point].get_line_text()
+
+        if self.subsearch_fun == self.reverse_search_history:
+            self.subsearch_prompt = "reverse-i-search%d`%s': "
+        else:
+            self.subsearch_prompt = "forward-i-search%d`%s': "
+
+        self.prompt = self.subsearch_prompt % (self._history.history_cursor, "")
+
+        if self.subsearch_query:
+            self.line = self._process_incremental_search_keyevent(init_event)
+        else:
+            self.line = ""
+
+
+class SearchPromptMode(object):
+    def __init__(self, rlobj):
+        pass
+
+    def _process_non_incremental_search_keyevent(self, keyinfo):
+        keytuple = keyinfo.tuple()
+        log("SearchPromptMode %s %s" % (keyinfo, keytuple))
+        history = self._history
+
+        if keyinfo.keyname == "backspace":
+            self.non_inc_query = self.non_inc_query[:-1]
+        elif keyinfo.keyname in ["return", "escape"]:
+            if self.non_inc_query:
+                if self.non_inc_direction == -1:
+                    res = history.reverse_search_history(self.non_inc_query)
+                else:
+                    res = history.forward_search_history(self.non_inc_query)
+
+            self._bell()
+            self.prompt = self.non_inc_oldprompt
+            self.process_keyevent_queue = self.process_keyevent_queue[:-1]
+            self._history.history_cursor = len(self._history.history)
+            if keyinfo.keyname == "escape":
+                self.l_buffer = self.non_inc_oldline
+            else:
+                self.l_buffer.set_line(res)
+            return False
+        elif keyinfo.keyname:
+            pass
+        elif keyinfo.control == False and keyinfo.meta == False:
+            self.non_inc_query += keyinfo.char
+        else:
+            pass
+        self.prompt = self.non_inc_oldprompt + ":" + self.non_inc_query
+
+    def _init_non_i_search(self, direction):
+        self.non_inc_direction = direction
+        self.non_inc_query = ""
+        self.non_inc_oldprompt = self.prompt
+        self.non_inc_oldline = self.l_buffer.copy()
+        self.l_buffer.reset_line()
+        self.prompt = self.non_inc_oldprompt + ":"
+        queue = self.process_keyevent_queue
+        queue.append(self._process_non_incremental_search_keyevent)
+
+    def non_incremental_reverse_search_history(self, e):  # (M-p)
+        """Search backward starting at the current line and moving up
+        through the history as necessary using a non-incremental search for
+        a string supplied by the user."""
+        return self._init_non_i_search(-1)
+
+    def non_incremental_forward_search_history(self, e):  # (M-n)
+        """Search forward starting at the current line and moving down
+        through the the history as necessary using a non-incremental search
+        for a string supplied by the user."""
+        return self._init_non_i_search(1)
+
+
+class LeaveModeTryNext(Exception):
+    pass
+
+
+class DigitArgumentMode(object):
+    def __init__(self, rlobj):
+        pass
+
+    def _process_digit_argument_keyevent(self, keyinfo):
+        log("DigitArgumentMode.keyinfo %s" % keyinfo)
+        keytuple = keyinfo.tuple()
+        log("DigitArgumentMode.keytuple %s %s" % (keyinfo, keytuple))
+        if keyinfo.keyname in ["return"]:
+            self.prompt = self._digit_argument_oldprompt
+            self.process_keyevent_queue = self.process_keyevent_queue[:-1]
+            return True
+        elif keyinfo.keyname:
+            pass
+        elif (
+            keyinfo.char in "0123456789"
+            and keyinfo.control == False
+            and keyinfo.meta == False
+        ):
+            log("arg %s %s" % (self.argument, keyinfo.char))
+            self.argument = self.argument * 10 + int(keyinfo.char)
+        else:
+            self.prompt = self._digit_argument_oldprompt
+            raise LeaveModeTryNext
+        self.prompt = "(arg: %s) " % self.argument
+
+    def _init_digit_argument(self, keyinfo):
+        """Initialize search prompt"""
+        c = self.console
+        line = self.l_buffer.get_line_text()
+        self._digit_argument_oldprompt = self.prompt
+        queue = self.process_keyevent_queue
+        queue = self.process_keyevent_queue
+        queue.append(self._process_digit_argument_keyevent)
+
+        if keyinfo.char == "-":
+            self.argument = -1
+        elif keyinfo.char in "0123456789":
+            self.argument = int(keyinfo.char)
+        log("<%s> %s" % (self.argument, type(self.argument)))
+        self.prompt = "(arg: %s) " % self.argument
+        log("arg-init %s %s" % (self.argument, keyinfo.char))
+
+
+class EmacsMode(
+    DigitArgumentMode, IncrementalSearchPromptMode, SearchPromptMode, basemode.BaseMode
+):
+    mode = "emacs"
+
+    def __init__(self, rlobj):
+        basemode.BaseMode.__init__(self, rlobj)
+        IncrementalSearchPromptMode.__init__(self, rlobj)
+        SearchPromptMode.__init__(self, rlobj)
+        DigitArgumentMode.__init__(self, rlobj)
+        self._keylog = lambda x, y: None
+        self.previous_func = None
+        self.prompt = ">>> "
+        self._insert_verbatim = False
+        self.next_meta = False  # True to force meta on next character
+
+        self.process_keyevent_queue = [self._process_keyevent]
+
+    def __repr__(self):
+        return "<EmacsMode>"
+
+    def add_key_logger(self, logfun):
+        """logfun should be function that takes disp_fun and line_""" """buffer object """
+        self._keylog = logfun
+
+    def process_keyevent(self, keyinfo):
+        try:
+            r = self.process_keyevent_queue[-1](keyinfo)
+        except LeaveModeTryNext:
+            self.process_keyevent_queue = self.process_keyevent_queue[:-1]
+            r = self.process_keyevent(keyinfo)
+        if r:
+            self.add_history(self.l_buffer.copy())
+            return True
+        return False
+
+    def _process_keyevent(self, keyinfo):
+        """return True when line is final"""
+        # Process exit keys. Only exit on empty line
+        log("_process_keyevent <%s>" % keyinfo)
+
+        def nop(e):
+            pass
+
+        if self.next_meta:
+            self.next_meta = False
+            keyinfo.meta = True
+        keytuple = keyinfo.tuple()
+
+        if self._insert_verbatim:
+            self.insert_text(keyinfo)
+            self._insert_verbatim = False
+            self.argument = 0
+            return False
+
+        if keytuple in self.exit_dispatch:
+            pars = (self.l_buffer, lineobj.EndOfLine(self.l_buffer))
+            log("exit_dispatch:<%s, %s>" % pars)
+            if lineobj.EndOfLine(self.l_buffer) == 0:
+                raise EOFError
+        if keyinfo.keyname or keyinfo.control or keyinfo.meta:
+            default = nop
+        else:
+            default = self.self_insert
+        dispatch_func = self.key_dispatch.get(keytuple, default)
+
+        log("readline from keyboard:<%s,%s>" % (keytuple, dispatch_func))
+
+        r = None
+        if dispatch_func:
+            r = dispatch_func(keyinfo)
+            self._keylog(dispatch_func, self.l_buffer)
+            self.l_buffer.push_undo()
+
+        self.previous_func = dispatch_func
+        return r
+
+    # History commands
+    def previous_history(self, e):  # (C-p)
+        """Move back through the history list, fetching the previous
+        command."""
+        self._history.previous_history(self.l_buffer)
+        self.l_buffer.point = lineobj.EndOfLine
+        self.finalize()
+
+    def next_history(self, e):  # (C-n)
+        """Move forward through the history list, fetching the next
+        command."""
+        self._history.next_history(self.l_buffer)
+        self.finalize()
+
+    def beginning_of_history(self, e):  # (M-<)
+        """Move to the first line in the history."""
+        self._history.beginning_of_history()
+        self.finalize()
+
+    def end_of_history(self, e):  # (M->)
+        """Move to the end of the input history, i.e., the line currently
+        being entered."""
+        self._history.end_of_history(self.l_buffer)
+        self.finalize()
+
+    def reverse_search_history(self, e):  # (C-r)
+        """Search backward starting at the current line and moving up
+        through the history as necessary. This is an incremental search."""
+        log("rev_search_history")
+        self._init_incremental_search(self._history.reverse_search_history, e)
+        self.finalize()
+
+    def forward_search_history(self, e):  # (C-s)
+        """Search forward starting at the current line and moving down
+        through the the history as necessary. This is an incremental
+        search."""
+        log("fwd_search_history")
+        self._init_incremental_search(self._history.forward_search_history, e)
+        self.finalize()
+
+    def history_search_forward(self, e):  # ()
+        """Search forward through the history for the string of characters
+        between the start of the current line and the point. This is a
+        non-incremental search. By default, this command is unbound."""
+        if self.previous_func and hasattr(self._history, self.previous_func.__name__):
+            self._history.lastcommand = getattr(
+                self._history, self.previous_func.__name__
+            )
+        else:
+            self._history.lastcommand = None
+        q = self._history.history_search_forward(self.l_buffer)
+        self.l_buffer = q
+        self.l_buffer.point = q.point
+        self.finalize()
+
+    def history_search_backward(self, e):  # ()
+        """Search backward through the history for the string of characters
+        between the start of the current line and the point. This is a
+        non-incremental search. By default, this command is unbound."""
+        if self.previous_func and hasattr(self._history, self.previous_func.__name__):
+            self._history.lastcommand = getattr(
+                self._history, self.previous_func.__name__
+            )
+        else:
+            self._history.lastcommand = None
+        q = self._history.history_search_backward(self.l_buffer)
+        self.l_buffer = q
+        self.l_buffer.point = q.point
+        self.finalize()
+
+    def yank_nth_arg(self, e):  # (M-C-y)
+        """Insert the first argument to the previous command (usually the
+        second word on the previous line) at point. With an argument n,
+        insert the nth word from the previous command (the words in the
+        previous command begin with word 0). A negative argument inserts the
+        nth word from the end of the previous command."""
+        self.finalize()
+
+    def yank_last_arg(self, e):  # (M-. or M-_)
+        """Insert last argument to the previous command (the last word of
+        the previous history entry). With an argument, behave exactly like
+        yank-nth-arg. Successive calls to yank-last-arg move back through
+        the history list, inserting the last argument of each line in turn."""
+        self.finalize()
+
+    def forward_backward_delete_char(self, e):  # ()
+        """Delete the character under the cursor, unless the cursor is at
+        the end of the line, in which case the character behind the cursor
+        is deleted. By default, this is not bound to a key."""
+        self.finalize()
+
+    def quoted_insert(self, e):  # (C-q or C-v)
+        """Add the next character typed to the line verbatim. This is how to
+        insert key sequences like C-q, for example."""
+        self._insert_verbatim = True
+        self.finalize()
+
+    def tab_insert(self, e):  # (M-TAB)
+        """Insert a tab character."""
+        cursor = min(self.l_buffer.point, len(self.l_buffer.line_buffer))
+        ws = " " * (self.tabstop - (cursor % self.tabstop))
+        self.insert_text(ws)
+        self.finalize()
+
+    def transpose_chars(self, e):  # (C-t)
+        """Drag the character before the cursor forward over the character
+        at the cursor, moving the cursor forward as well. If the insertion
+        point is at the end of the line, then this transposes the last two
+        characters of the line. Negative arguments have no effect."""
+        self.l_buffer.transpose_chars()
+        self.finalize()
+
+    def transpose_words(self, e):  # (M-t)
+        """Drag the word before point past the word after point, moving
+        point past that word as well. If the insertion point is at the end
+        of the line, this transposes the last two words on the line."""
+        self.l_buffer.transpose_words()
+        self.finalize()
+
+    def overwrite_mode(self, e):  # ()
+        """Toggle overwrite mode. With an explicit positive numeric
+        argument, switches to overwrite mode. With an explicit non-positive
+        numeric argument, switches to insert mode. This command affects only
+        emacs mode; vi mode does overwrite differently. Each call to
+        readline() starts in insert mode. In overwrite mode, characters
+        bound to self-insert replace the text at point rather than pushing
+        the text to the right. Characters bound to backward-delete-char
+        replace the character before point with a space."""
+        self.finalize()
+
+    def kill_line(self, e):  # (C-k)
+        """Kill the text from point to the end of the line."""
+        self.l_buffer.kill_line()
+        self.finalize()
+
+    def backward_kill_line(self, e):  # (C-x Rubout)
+        """Kill backward to the beginning of the line."""
+        self.l_buffer.backward_kill_line()
+        self.finalize()
+
+    def unix_line_discard(self, e):  # (C-u)
+        """Kill backward from the cursor to the beginning of the current
+        line."""
+        # how is this different from backward_kill_line?
+        self.l_buffer.unix_line_discard()
+        self.finalize()
+
+    def kill_whole_line(self, e):  # ()
+        """Kill all characters on the current line, no matter where point
+        is. By default, this is unbound."""
+        self.l_buffer.kill_whole_line()
+        self.finalize()
+
+    def kill_word(self, e):  # (M-d)
+        """Kill from point to the end of the current word, or if between
+        words, to the end of the next word. Word boundaries are the same as
+        forward-word."""
+        self.l_buffer.kill_word()
+        self.finalize()
+
+    forward_kill_word = kill_word
+
+    def backward_kill_word(self, e):  # (M-DEL)
+        """Kill the word behind point. Word boundaries are the same as
+        backward-word."""
+        self.l_buffer.backward_kill_word()
+        self.finalize()
+
+    def unix_word_rubout(self, e):  # (C-w)
+        """Kill the word behind point, using white space as a word
+        boundary. The killed text is saved on the kill-ring."""
+        self.l_buffer.unix_word_rubout()
+        self.finalize()
+
+    def kill_region(self, e):  # ()
+        """Kill the text in the current region. By default, this command is
+        unbound."""
+        self.finalize()
+
+    def copy_region_as_kill(self, e):  # ()
+        """Copy the text in the region to the kill buffer, so it can be
+        yanked right away. By default, this command is unbound."""
+        self.finalize()
+
+    def copy_backward_word(self, e):  # ()
+        """Copy the word before point to the kill buffer. The word
+        boundaries are the same as backward-word. By default, this command
+        is unbound."""
+        self.finalize()
+
+    def copy_forward_word(self, e):  # ()
+        """Copy the word following point to the kill buffer. The word
+        boundaries are the same as forward-word. By default, this command is
+        unbound."""
+        self.finalize()
+
+    def yank(self, e):  # (C-y)
+        """Yank the top of the kill ring into the buffer at point."""
+        self.l_buffer.yank()
+        self.finalize()
+
+    def yank_pop(self, e):  # (M-y)
+        """Rotate the kill-ring, and yank the new top. You can only do this
+        if the prior command is yank or yank-pop."""
+        self.l_buffer.yank_pop()
+        self.finalize()
+
+    def delete_char_or_list(self, e):  # ()
+        """Deletes the character under the cursor if not at the beginning or
+        end of the line (like delete-char). If at the end of the line,
+        behaves identically to possible-completions. This command is unbound
+        by default."""
+        self.finalize()
+
+    def start_kbd_macro(self, e):  # (C-x ()
+        """Begin saving the characters typed into the current keyboard
+        macro."""
+        self.finalize()
+
+    def end_kbd_macro(self, e):  # (C-x ))
+        """Stop saving the characters typed into the current keyboard macro
+        and save the definition."""
+        self.finalize()
+
+    def call_last_kbd_macro(self, e):  # (C-x e)
+        """Re-execute the last keyboard macro defined, by making the
+        characters in the macro appear as if typed at the keyboard."""
+        self.finalize()
+
+    def re_read_init_file(self, e):  # (C-x C-r)
+        """Read in the contents of the inputrc file, and incorporate any
+        bindings or variable assignments found there."""
+        self.finalize()
+
+    def abort(self, e):  # (C-g)
+        """Abort the current editing command and ring the terminals bell
+        (subject to the setting of bell-style)."""
+        self._bell()
+        self.finalize()
+
+    def do_uppercase_version(self, e):  # (M-a, M-b, M-x, ...)
+        """If the metafied character x is lowercase, run the command that is
+        bound to the corresponding uppercase character."""
+        self.finalize()
+
+    def prefix_meta(self, e):  # (ESC)
+        """Metafy the next character typed. This is for keyboards without a
+        meta key. Typing ESC f is equivalent to typing M-f."""
+        self.next_meta = True
+        self.finalize()
+
+    def undo(self, e):  # (C-_ or C-x C-u)
+        """Incremental undo, separately remembered for each line."""
+        self.l_buffer.pop_undo()
+        self.finalize()
+
+    def revert_line(self, e):  # (M-r)
+        """Undo all changes made to this line. This is like executing the
+        undo command enough times to get back to the beginning."""
+        self.finalize()
+
+    def tilde_expand(self, e):  # (M-~)
+        """Perform tilde expansion on the current word."""
+        self.finalize()
+
+    def set_mark(self, e):  # (C-@)
+        """Set the mark to the point. If a numeric argument is supplied, the
+        mark is set to that position."""
+        self.l_buffer.set_mark()
+        self.finalize()
+
+    def exchange_point_and_mark(self, e):  # (C-x C-x)
+        """Swap the point with the mark. The current cursor position is set
+        to the saved position, and the old cursor position is saved as the
+        mark."""
+        self.finalize()
+
+    def character_search(self, e):  # (C-])
+        """A character is read and point is moved to the next occurrence of
+        that character. A negative count searches for previous occurrences."""
+        self.finalize()
+
+    def character_search_backward(self, e):  # (M-C-])
+        """A character is read and point is moved to the previous occurrence
+        of that character. A negative count searches for subsequent
+        occurrences."""
+        self.finalize()
+
+    def insert_comment(self, e):  # (M-#)
+        """Without a numeric argument, the value of the comment-begin
+        variable is inserted at the beginning of the current line. If a
+        numeric argument is supplied, this command acts as a toggle: if the
+        characters at the beginning of the line do not match the value of
+        comment-begin, the value is inserted, otherwise the characters in
+        comment-begin are deleted from the beginning of the line. In either
+        case, the line is accepted as if a newline had been typed."""
+        self.finalize()
+
+    def dump_variables(self, e):  # ()
+        """Print all of the settable variables and their values to the
+        Readline output stream. If a numeric argument is supplied, the
+        output is formatted in such a way that it can be made part of an
+        inputrc file. This command is unbound by default."""
+        self.finalize()
+
+    def dump_macros(self, e):  # ()
+        """Print all of the Readline key sequences bound to macros and the
+        strings they output. If a numeric argument is supplied, the output
+        is formatted in such a way that it can be made part of an inputrc
+        file. This command is unbound by default."""
+        self.finalize()
+
+    def digit_argument(self, e):  # (M-0, M-1, ... M--)
+        """Add this digit to the argument already accumulating, or start a
+        new argument. M-- starts a negative argument."""
+        self._init_digit_argument(e)
+        # Should not finalize
+
+    def universal_argument(self, e):  # ()
+        """This is another way to specify an argument. If this command is
+        followed by one or more digits, optionally with a leading minus
+        sign, those digits define the argument. If the command is followed
+        by digits, executing universal-argument again ends the numeric
+        argument, but is otherwise ignored. As a special case, if this
+        command is immediately followed by a character that is neither a
+        digit or minus sign, the argument count for the next command is
+        multiplied by four. The argument count is initially one, so
+        executing this function the first time makes the argument count
+        four, a second time makes the argument count sixteen, and so on. By
+        default, this is not bound to a key."""
+        # Should not finalize
+
+    # Create key bindings:
+    def init_editing_mode(self, e):  # (C-e)
+        """When in vi command mode, this causes a switch to emacs editing
+        mode."""
+        self._bind_exit_key("Control-d")
+        self._bind_exit_key("Control-z")
+
+        # I often accidentally hold the shift or control while typing space
+        self._bind_key("space", self.self_insert)
+        self._bind_key("Shift-space", self.self_insert)
+        self._bind_key("Control-space", self.self_insert)
+        self._bind_key("Return", self.accept_line)
+        self._bind_key("Left", self.backward_char)
+        self._bind_key("Control-b", self.backward_char)
+        self._bind_key("Right", self.forward_char)
+        self._bind_key("Control-f", self.forward_char)
+        self._bind_key("Control-h", self.backward_delete_char)
+        self._bind_key("BackSpace", self.backward_delete_char)
+        self._bind_key("Control-BackSpace", self.backward_delete_word)
+
+        self._bind_key("Home", self.beginning_of_line)
+        self._bind_key("End", self.end_of_line)
+        self._bind_key("Delete", self.delete_char)
+        self._bind_key("Control-d", self.delete_char)
+        self._bind_key("Clear", self.clear_screen)
+        self._bind_key("Alt-f", self.forward_word)
+        self._bind_key("Alt-b", self.backward_word)
+        self._bind_key("Control-l", self.clear_screen)
+        self._bind_key("Control-p", self.previous_history)
+        self._bind_key("Up", self.history_search_backward)
+        self._bind_key("Control-n", self.next_history)
+        self._bind_key("Down", self.history_search_forward)
+        self._bind_key("Control-a", self.beginning_of_line)
+        self._bind_key("Control-e", self.end_of_line)
+        self._bind_key("Alt-<", self.beginning_of_history)
+        self._bind_key("Alt->", self.end_of_history)
+        self._bind_key("Control-r", self.reverse_search_history)
+        self._bind_key("Control-s", self.forward_search_history)
+        self._bind_key("Control-Shift-r", self.forward_search_history)
+        self._bind_key("Alt-p", self.non_incremental_reverse_search_history)
+        self._bind_key("Alt-n", self.non_incremental_forward_search_history)
+        self._bind_key("Control-z", self.undo)
+        self._bind_key("Control-_", self.undo)
+        self._bind_key("Escape", self.kill_whole_line)
+        self._bind_key("Meta-d", self.kill_word)
+        self._bind_key("Control-Delete", self.forward_delete_word)
+        self._bind_key("Control-w", self.unix_word_rubout)
+        # self._bind_key('Control-Shift-v',   self.quoted_insert)
+        self._bind_key("Control-v", self.paste)
+        self._bind_key("Alt-v", self.ipython_paste)
+        self._bind_key("Control-y", self.yank)
+        self._bind_key("Control-k", self.kill_line)
+        self._bind_key("Control-m", self.set_mark)
+        self._bind_key("Control-q", self.copy_region_to_clipboard)
+        #        self._bind_key('Control-shift-k',  self.kill_whole_line)
+        self._bind_key("Control-Shift-v", self.paste_mulitline_code)
+        self._bind_key("Control-Right", self.forward_word_end)
+        self._bind_key("Control-Left", self.backward_word)
+        self._bind_key("Shift-Right", self.forward_char_extend_selection)
+        self._bind_key("Shift-Left", self.backward_char_extend_selection)
+        self._bind_key("Shift-Control-Right", self.forward_word_end_extend_selection)
+        self._bind_key("Shift-Control-Left", self.backward_word_extend_selection)
+        self._bind_key("Shift-Home", self.beginning_of_line_extend_selection)
+        self._bind_key("Shift-End", self.end_of_line_extend_selection)
+        self._bind_key("numpad0", self.self_insert)
+        self._bind_key("numpad1", self.self_insert)
+        self._bind_key("numpad2", self.self_insert)
+        self._bind_key("numpad3", self.self_insert)
+        self._bind_key("numpad4", self.self_insert)
+        self._bind_key("numpad5", self.self_insert)
+        self._bind_key("numpad6", self.self_insert)
+        self._bind_key("numpad7", self.self_insert)
+        self._bind_key("numpad8", self.self_insert)
+        self._bind_key("numpad9", self.self_insert)
+        self._bind_key("add", self.self_insert)
+        self._bind_key("subtract", self.self_insert)
+        self._bind_key("multiply", self.self_insert)
+        self._bind_key("divide", self.self_insert)
+        self._bind_key("vk_decimal", self.self_insert)
+        log("RUNNING INIT EMACS")
+        for i in range(0, 10):
+            self._bind_key("alt-%d" % i, self.digit_argument)
+        self._bind_key("alt--", self.digit_argument)
+
+
+# make it case insensitive
+def commonprefix(m):
+    "Given a list of pathnames, returns the longest common leading component"
+    if not m:
+        return ""
+    prefix = m[0]
+    for item in m:
+        for i in range(len(prefix)):
+            if prefix[: i + 1].lower() != item[: i + 1].lower():
+                prefix = prefix[:i]
+                if i == 0:
+                    return ""
+                break
+    return prefix

rl/Lib/site-packages/pyreadline3/modes/notemacs.py

@@ -0,0 +1,612 @@
+# -*- coding: utf-8 -*-
+# *****************************************************************************
+#       Copyright (C) 2003-2006 Gary Bishop.
+#       Copyright (C) 2006-2020 Jorgen Stenarson. <jorgen.stenarson@bostream.nu>
+#       Copyright (C) 2020 Bassem Girgis. <brgirgis@gmail.com>
+#
+#  Distributed under the terms of the BSD License.  The full license is in
+#  the file COPYING, distributed as part of this software.
+# *****************************************************************************
+
+
+import os
+
+import pyreadline3.lineeditor.history as history
+import pyreadline3.lineeditor.lineobj as lineobj
+import pyreadline3.logger as logger
+from pyreadline3.logger import log
+
+from . import basemode
+
+
+class NotEmacsMode(basemode.BaseMode):
+    mode = "notemacs"
+
+    def __init__(self, rlobj):
+        super().__init__(rlobj)
+
+    def __repr__(self):
+        return "<NotEmacsMode>"
+
+    def _readline_from_keyboard(self):
+        c = self.console
+        while True:
+            self._update_line()
+            event = c.getkeypress()
+            if self.next_meta:
+                self.next_meta = False
+                control, meta, shift, code = event.keyinfo
+                event.keyinfo = (control, True, shift, code)
+
+            # Process exit keys. Only exit on empty line
+            if event.keyinfo in self.exit_dispatch:
+                if lineobj.EndOfLine(self.l_buffer) == 0:
+                    raise EOFError
+
+            dispatch_func = self.key_dispatch.get(event.keyinfo, self.self_insert)
+            log("readline from keyboard:%s" % (event.keyinfo,))
+            r = None
+            if dispatch_func:
+                r = dispatch_func(event)
+                self.l_buffer.push_undo()
+
+            self.previous_func = dispatch_func
+            if r:
+                self._update_line()
+                break
+
+    def readline(self, prompt=""):
+        """Try to act like GNU readline."""
+        # handle startup_hook
+        if self.first_prompt:
+            self.first_prompt = False
+            if self.startup_hook:
+                try:
+                    self.startup_hook()
+                except BaseException:
+                    print("startup hook failed")
+                    traceback.print_exc()
+
+        c = self.console
+        self.l_buffer.reset_line()
+        self.prompt = prompt
+        self._print_prompt()
+
+        if self.pre_input_hook:
+            try:
+                self.pre_input_hook()
+            except BaseException:
+                print("pre_input_hook failed")
+                traceback.print_exc()
+                self.pre_input_hook = None
+
+        log("in readline: %s" % self.paste_line_buffer)
+        if len(self.paste_line_buffer) > 0:
+            self.l_buffer = lineobj.ReadlineTextBuffer(self.paste_line_buffer[0])
+            self._update_line()
+            self.paste_line_buffer = self.paste_line_buffer[1:]
+            c.write("\r\n")
+        else:
+            self._readline_from_keyboard()
+            c.write("\r\n")
+
+        self.add_history(self.l_buffer.copy())
+
+        log("returning(%s)" % self.l_buffer.get_line_text())
+        return self.l_buffer.get_line_text() + "\n"
+
+    # Methods below here are bindable emacs functions
+
+    def beginning_of_line(self, e):  # (C-a)
+        """Move to the start of the current line."""
+        self.l_buffer.beginning_of_line()
+
+    def end_of_line(self, e):  # (C-e)
+        """Move to the end of the line."""
+        self.l_buffer.end_of_line()
+
+    def forward_char(self, e):  # (C-f)
+        """Move forward a character."""
+        self.l_buffer.forward_char()
+
+    def backward_char(self, e):  # (C-b)
+        """Move back a character."""
+        self.l_buffer.backward_char()
+
+    def forward_word(self, e):  # (M-f)
+        """Move forward to the end of the next word. Words are composed of
+        letters and digits."""
+        self.l_buffer.forward_word()
+
+    def backward_word(self, e):  # (M-b)
+        """Move back to the start of the current or previous word. Words are
+        composed of letters and digits."""
+        self.l_buffer.backward_word()
+
+    def clear_screen(self, e):  # (C-l)
+        """Clear the screen and redraw the current line, leaving the current
+        line at the top of the screen."""
+        self.console.page()
+
+    def redraw_current_line(self, e):  # ()
+        """Refresh the current line. By default, this is unbound."""
+        pass
+
+    def accept_line(self, e):  # (Newline or Return)
+        """Accept the line regardless of where the cursor is. If this line
+        is non-empty, it may be added to the history list for future recall
+        with add_history(). If this line is a modified history line, the
+        history line is restored to its original state."""
+        return True
+
+    # History commands
+    def previous_history(self, e):  # (C-p)
+        """Move back through the history list, fetching the previous command."""
+        self._history.previous_history(self.l_buffer)
+
+    def next_history(self, e):  # (C-n)
+        """Move forward through the history list, fetching the next command."""
+        self._history.next_history(self.l_buffer)
+
+    def beginning_of_history(self, e):  # (M-<)
+        """Move to the first line in the history."""
+        self._history.beginning_of_history()
+
+    def end_of_history(self, e):  # (M->)
+        """Move to the end of the input history, i.e., the line currently
+        being entered."""
+        self._history.end_of_history(self.l_buffer)
+
+    def _i_search(self, searchfun, direction, init_event):
+        c = self.console
+        line = self.get_line_buffer()
+        query = ""
+        hc_start = self._history.history_cursor  # + direction
+        while True:
+            x, y = self.prompt_end_pos
+            c.pos(0, y)
+            if direction < 0:
+                prompt = "reverse-i-search"
+            else:
+                prompt = "forward-i-search"
+
+            scroll = c.write_scrolling("%s`%s': %s" % (prompt, query, line))
+            self._update_prompt_pos(scroll)
+            self._clear_after()
+
+            event = c.getkeypress()
+            if event.keysym == "BackSpace":
+                if len(query) > 0:
+                    query = query[:-1]
+                    self._history.history_cursor = hc_start
+                else:
+                    self._bell()
+            elif (
+                event.char in string.letters + string.digits + string.punctuation + " "
+            ):
+                self._history.history_cursor = hc_start
+                query += event.char
+            elif event.keyinfo == init_event.keyinfo:
+                self._history.history_cursor += direction
+                line = searchfun(query)
+                pass
+            else:
+                if event.keysym != "Return":
+                    self._bell()
+                break
+            line = searchfun(query)
+
+        px, py = self.prompt_begin_pos
+        c.pos(0, py)
+        self.l_buffer.set_line(line)
+        self._print_prompt()
+        self._history.history_cursor = len(self._history.history)
+
+    def reverse_search_history(self, e):  # (C-r)
+        """Search backward starting at the current line and moving up
+        through the history as necessary. This is an incremental search."""
+        #        print("HEJ")
+        #        self.console.bell()
+        self._i_search(self._history.reverse_search_history, -1, e)
+
+    def forward_search_history(self, e):  # (C-s)
+        """Search forward starting at the current line and moving down
+        through the the history as necessary. This is an incremental search."""
+        #        print("HEJ")
+        #        self.console.bell()
+        self._i_search(self._history.forward_search_history, 1, e)
+
+    def non_incremental_reverse_search_history(self, e):  # (M-p)
+        """Search backward starting at the current line and moving up
+        through the history as necessary using a non-incremental search for
+        a string supplied by the user."""
+        self._history.non_incremental_reverse_search_history(self.l_buffer)
+
+    def non_incremental_forward_search_history(self, e):  # (M-n)
+        """Search forward starting at the current line and moving down
+        through the the history as necessary using a non-incremental search
+        for a string supplied by the user."""
+        self._history.non_incremental_reverse_search_history(self.l_buffer)
+
+    def history_search_forward(self, e):  # ()
+        """Search forward through the history for the string of characters
+        between the start of the current line and the point. This is a
+        non-incremental search. By default, this command is unbound."""
+        self.l_buffer = self._history.history_search_forward(self.l_buffer)
+
+    def history_search_backward(self, e):  # ()
+        """Search backward through the history for the string of characters
+        between the start of the current line and the point. This is a
+        non-incremental search. By default, this command is unbound."""
+        self.l_buffer = self._history.history_search_backward(self.l_buffer)
+
+    def yank_nth_arg(self, e):  # (M-C-y)
+        """Insert the first argument to the previous command (usually the
+        second word on the previous line) at point. With an argument n,
+        insert the nth word from the previous command (the words in the
+        previous command begin with word 0). A negative argument inserts the
+        nth word from the end of the previous command."""
+        pass
+
+    def yank_last_arg(self, e):  # (M-. or M-_)
+        """Insert last argument to the previous command (the last word of
+        the previous history entry). With an argument, behave exactly like
+        yank-nth-arg. Successive calls to yank-last-arg move back through
+        the history list, inserting the last argument of each line in turn."""
+        pass
+
+    def delete_char(self, e):  # (C-d)
+        """Delete the character at point. If point is at the beginning of
+        the line, there are no characters in the line, and the last
+        character typed was not bound to delete-char, then return EOF."""
+        self.l_buffer.delete_char()
+
+    def backward_delete_char(self, e):  # (Rubout)
+        """Delete the character behind the cursor. A numeric argument means
+        to kill the characters instead of deleting them."""
+        self.l_buffer.backward_delete_char()
+
+    def forward_backward_delete_char(self, e):  # ()
+        """Delete the character under the cursor, unless the cursor is at
+        the end of the line, in which case the character behind the cursor
+        is deleted. By default, this is not bound to a key."""
+        pass
+
+    def quoted_insert(self, e):  # (C-q or C-v)
+        """Add the next character typed to the line verbatim. This is how to
+        insert key sequences like C-q, for example."""
+        e = self.console.getkeypress()
+        self.insert_text(e.char)
+
+    def tab_insert(self, e):  # (M-TAB)
+        """Insert a tab character."""
+        cursor = min(self.l_buffer.point, len(self.l_buffer.line_buffer))
+        ws = " " * (self.tabstop - (cursor % self.tabstop))
+        self.insert_text(ws)
+
+    def self_insert(self, e):  # (a, b, A, 1, !, ...)
+        """Insert yourself."""
+        if (
+            ord(e.char) != 0
+        ):  # don't insert null character in buffer, can happen with dead keys.
+            self.insert_text(e.char)
+
+    def transpose_chars(self, e):  # (C-t)
+        """Drag the character before the cursor forward over the character
+        at the cursor, moving the cursor forward as well. If the insertion
+        point is at the end of the line, then this transposes the last two
+        characters of the line. Negative arguments have no effect."""
+        self.l_buffer.transpose_chars()
+
+    def transpose_words(self, e):  # (M-t)
+        """Drag the word before point past the word after point, moving
+        point past that word as well. If the insertion point is at the end
+        of the line, this transposes the last two words on the line."""
+        self.l_buffer.transpose_words()
+
+    def upcase_word(self, e):  # (M-u)
+        """Uppercase the current (or following) word. With a negative
+        argument, uppercase the previous word, but do not move the cursor."""
+        self.l_buffer.upcase_word()
+
+    def downcase_word(self, e):  # (M-l)
+        """Lowercase the current (or following) word. With a negative
+        argument, lowercase the previous word, but do not move the cursor."""
+        self.l_buffer.downcase_word()
+
+    def capitalize_word(self, e):  # (M-c)
+        """Capitalize the current (or following) word. With a negative
+        argument, capitalize the previous word, but do not move the cursor."""
+        self.l_buffer.capitalize_word()
+
+    def overwrite_mode(self, e):  # ()
+        """Toggle overwrite mode. With an explicit positive numeric
+        argument, switches to overwrite mode. With an explicit non-positive
+        numeric argument, switches to insert mode. This command affects only
+        emacs mode; vi mode does overwrite differently. Each call to
+        readline() starts in insert mode. In overwrite mode, characters
+        bound to self-insert replace the text at point rather than pushing
+        the text to the right. Characters bound to backward-delete-char
+        replace the character before point with a space."""
+        pass
+
+    def kill_line(self, e):  # (C-k)
+        """Kill the text from point to the end of the line."""
+        self.l_buffer.kill_line()
+
+    def backward_kill_line(self, e):  # (C-x Rubout)
+        """Kill backward to the beginning of the line."""
+        self.l_buffer.backward_kill_line()
+
+    def unix_line_discard(self, e):  # (C-u)
+        """Kill backward from the cursor to the beginning of the current line."""
+        # how is this different from backward_kill_line?
+        self.l_buffer.unix_line_discard()
+
+    def kill_whole_line(self, e):  # ()
+        """Kill all characters on the current line, no matter where point
+        is. By default, this is unbound."""
+        self.l_buffer.kill_whole_line()
+
+    def kill_word(self, e):  # (M-d)
+        """Kill from point to the end of the current word, or if between
+        words, to the end of the next word. Word boundaries are the same as
+        forward-word."""
+        self.l_buffer.kill_word()
+
+    def backward_kill_word(self, e):  # (M-DEL)
+        """Kill the word behind point. Word boundaries are the same as
+        backward-word."""
+        self.l_buffer.backward_kill_word()
+
+    def unix_word_rubout(self, e):  # (C-w)
+        """Kill the word behind point, using white space as a word
+        boundary. The killed text is saved on the kill-ring."""
+        self.l_buffer.unix_word_rubout()
+
+    def delete_horizontal_space(self, e):  # ()
+        """Delete all spaces and tabs around point. By default, this is unbound."""
+        pass
+
+    def kill_region(self, e):  # ()
+        """Kill the text in the current region. By default, this command is unbound."""
+        pass
+
+    def copy_region_as_kill(self, e):  # ()
+        """Copy the text in the region to the kill buffer, so it can be
+        yanked right away. By default, this command is unbound."""
+        pass
+
+    def copy_region_to_clipboard(self, e):  # ()
+        """Copy the text in the region to the windows clipboard."""
+        if self.enable_win32_clipboard:
+            mark = min(self.l_buffer.mark, len(self.l_buffer.line_buffer))
+            cursor = min(self.l_buffer.point, len(self.l_buffer.line_buffer))
+            if self.l_buffer.mark == -1:
+                return
+            begin = min(cursor, mark)
+            end = max(cursor, mark)
+            toclipboard = "".join(self.l_buffer.line_buffer[begin:end])
+            clipboard.set_clipboard_text(str(toclipboard))
+
+    def copy_backward_word(self, e):  # ()
+        """Copy the word before point to the kill buffer. The word
+        boundaries are the same as backward-word. By default, this command
+        is unbound."""
+        pass
+
+    def copy_forward_word(self, e):  # ()
+        """Copy the word following point to the kill buffer. The word
+        boundaries are the same as forward-word. By default, this command is
+        unbound."""
+        pass
+
+    def paste(self, e):
+        """Paste windows clipboard"""
+        if self.enable_win32_clipboard:
+            txt = clipboard.get_clipboard_text_and_convert(False)
+            self.insert_text(txt)
+
+    def paste_mulitline_code(self, e):
+        """Paste windows clipboard"""
+        reg = re.compile("\r?\n")
+        if self.enable_win32_clipboard:
+            txt = clipboard.get_clipboard_text_and_convert(False)
+            t = reg.split(txt)
+            t = [row for row in t if row.strip() != ""]  # remove empty lines
+            if t != [""]:
+                self.insert_text(t[0])
+                self.add_history(self.l_buffer.copy())
+                self.paste_line_buffer = t[1:]
+                log("multi: %s" % self.paste_line_buffer)
+                return True
+            else:
+                return False
+
+    def ipython_paste(self, e):
+        """Paste windows clipboard. If enable_ipython_paste_list_of_lists is
+        True then try to convert tabseparated data to repr of list of lists or
+        repr of array"""
+        if self.enable_win32_clipboard:
+            txt = clipboard.get_clipboard_text_and_convert(
+                self.enable_ipython_paste_list_of_lists
+            )
+            if self.enable_ipython_paste_for_paths:
+                if len(txt) < 300 and ("\t" not in txt) and ("\n" not in txt):
+                    txt = txt.replace("\\", "/").replace(" ", r"\ ")
+            self.insert_text(txt)
+
+    def yank(self, e):  # (C-y)
+        """Yank the top of the kill ring into the buffer at point."""
+        pass
+
+    def yank_pop(self, e):  # (M-y)
+        """Rotate the kill-ring, and yank the new top. You can only do this
+        if the prior command is yank or yank-pop."""
+        pass
+
+    def digit_argument(self, e):  # (M-0, M-1, ... M--)
+        """Add this digit to the argument already accumulating, or start a
+        new argument. M-- starts a negative argument."""
+        pass
+
+    def universal_argument(self, e):  # ()
+        """This is another way to specify an argument. If this command is
+        followed by one or more digits, optionally with a leading minus
+        sign, those digits define the argument. If the command is followed
+        by digits, executing universal-argument again ends the numeric
+        argument, but is otherwise ignored. As a special case, if this
+        command is immediately followed by a character that is neither a
+        digit or minus sign, the argument count for the next command is
+        multiplied by four. The argument count is initially one, so
+        executing this function the first time makes the argument count
+        four, a second time makes the argument count sixteen, and so on. By
+        default, this is not bound to a key."""
+        pass
+
+    def delete_char_or_list(self, e):  # ()
+        """Deletes the character under the cursor if not at the beginning or
+        end of the line (like delete-char). If at the end of the line,
+        behaves identically to possible-completions. This command is unbound
+        by default."""
+        pass
+
+    def start_kbd_macro(self, e):  # (C-x ()
+        """Begin saving the characters typed into the current keyboard macro."""
+        pass
+
+    def end_kbd_macro(self, e):  # (C-x ))
+        """Stop saving the characters typed into the current keyboard macro
+        and save the definition."""
+        pass
+
+    def call_last_kbd_macro(self, e):  # (C-x e)
+        """Re-execute the last keyboard macro defined, by making the
+        characters in the macro appear as if typed at the keyboard."""
+        pass
+
+    def re_read_init_file(self, e):  # (C-x C-r)
+        """Read in the contents of the inputrc file, and incorporate any
+        bindings or variable assignments found there."""
+        pass
+
+    def abort(self, e):  # (C-g)
+        """Abort the current editing command and ring the terminals bell
+        (subject to the setting of bell-style)."""
+        self._bell()
+
+    def do_uppercase_version(self, e):  # (M-a, M-b, M-x, ...)
+        """If the metafied character x is lowercase, run the command that is
+        bound to the corresponding uppercase character."""
+        pass
+
+    def prefix_meta(self, e):  # (ESC)
+        """Metafy the next character typed. This is for keyboards without a
+        meta key. Typing ESC f is equivalent to typing M-f."""
+        self.next_meta = True
+
+    def undo(self, e):  # (C-_ or C-x C-u)
+        """Incremental undo, separately remembered for each line."""
+        self.l_buffer.pop_undo()
+
+    def revert_line(self, e):  # (M-r)
+        """Undo all changes made to this line. This is like executing the
+        undo command enough times to get back to the beginning."""
+        pass
+
+    def tilde_expand(self, e):  # (M-~)
+        """Perform tilde expansion on the current word."""
+        pass
+
+    def set_mark(self, e):  # (C-@)
+        """Set the mark to the point. If a numeric argument is supplied, the
+        mark is set to that position."""
+        self.l_buffer.set_mark()
+
+    def exchange_point_and_mark(self, e):  # (C-x C-x)
+        """Swap the point with the mark. The current cursor position is set
+        to the saved position, and the old cursor position is saved as the
+        mark."""
+        pass
+
+    def character_search(self, e):  # (C-])
+        """A character is read and point is moved to the next occurrence of
+        that character. A negative count searches for previous occurrences."""
+        pass
+
+    def character_search_backward(self, e):  # (M-C-])
+        """A character is read and point is moved to the previous occurrence
+        of that character. A negative count searches for subsequent
+        occurrences."""
+        pass
+
+    def insert_comment(self, e):  # (M-#)
+        """Without a numeric argument, the value of the comment-begin
+        variable is inserted at the beginning of the current line. If a
+        numeric argument is supplied, this command acts as a toggle: if the
+        characters at the beginning of the line do not match the value of
+        comment-begin, the value is inserted, otherwise the characters in
+        comment-begin are deleted from the beginning of the line. In either
+        case, the line is accepted as if a newline had been typed."""
+        pass
+
+    def dump_functions(self, e):  # ()
+        """Print all of the functions and their key bindings to the Readline
+        output stream. If a numeric argument is supplied, the output is
+        formatted in such a way that it can be made part of an inputrc
+        file. This command is unbound by default."""
+        pass
+
+    def dump_variables(self, e):  # ()
+        """Print all of the settable variables and their values to the
+        Readline output stream. If a numeric argument is supplied, the
+        output is formatted in such a way that it can be made part of an
+        inputrc file. This command is unbound by default."""
+        pass
+
+    def dump_macros(self, e):  # ()
+        """Print all of the Readline key sequences bound to macros and the
+        strings they output. If a numeric argument is supplied, the output
+        is formatted in such a way that it can be made part of an inputrc
+        file. This command is unbound by default."""
+        pass
+
+    # Create key bindings:
+
+    def init_editing_mode(self, e):  # (C-e)
+        """When in vi command mode, this causes a switch to emacs editing
+        mode."""
+
+        self._bind_exit_key("Control-d")
+        self._bind_exit_key("Control-z")
+
+        # I often accidentally hold the shift or control while typing space
+        self._bind_key("Shift-space", self.self_insert)
+        self._bind_key("Control-space", self.self_insert)
+        self._bind_key("Return", self.accept_line)
+        self._bind_key("Left", self.backward_char)
+        self._bind_key("Control-b", self.backward_char)
+        self._bind_key("Right", self.forward_char)
+        self._bind_key("Control-f", self.forward_char)
+        self._bind_key("BackSpace", self.backward_delete_char)
+        self._bind_key("Home", self.beginning_of_line)
+        self._bind_key("End", self.end_of_line)
+        self._bind_key("Delete", self.delete_char)
+        self._bind_key("Control-d", self.delete_char)
+        self._bind_key("Clear", self.clear_screen)
+
+
+# make it case insensitive
+def commonprefix(m):
+    "Given a list of pathnames, returns the longest common leading component"
+    if not m:
+        return ""
+    prefix = m[0]
+    for item in m:
+        for i in range(len(prefix)):
+            if prefix[: i + 1].lower() != item[: i + 1].lower():
+                prefix = prefix[:i]
+                if i == 0:
+                    return ""
+                break
+    return prefix

rl/Lib/site-packages/pyreadline3/py3k_compat.py

@@ -0,0 +1,35 @@
+import sys
+from collections.abc import Callable
+from typing import Any, Dict, Optional
+
+is_ironpython = "IronPython" in sys.version
+
+
+def is_callable(x: Any) -> bool:
+    return isinstance(x, Callable)
+
+
+def execfile(
+    fname: str,
+    glob: Dict[str, Any],
+    loc: Optional[Dict[str, Any]] = None,
+) -> None:
+    loc = loc if (loc is not None) else glob
+
+    with open(
+        fname,
+        "r",
+        encoding="utf-8",
+    ) as file:
+        file_contents = file.read()
+
+    # pylint: disable=W0122
+    exec(
+        compile(
+            file_contents,
+            fname,
+            "exec",
+        ),
+        glob,
+        loc,
+    )

rl/Lib/site-packages/pyreadline3/rlmain.py

@@ -0,0 +1,632 @@
+# -*- coding: utf-8 -*-
+# *****************************************************************************
+#       Copyright (C) 2003-2006 Gary Bishop.
+#       Copyright (C) 2006-2020 Jorgen Stenarson. <jorgen.stenarson@bostream.nu>
+#       Copyright (C) 2020 Bassem Girgis. <brgirgis@gmail.com>
+#
+#  Distributed under the terms of the BSD License.  The full license is in
+#  the file COPYING, distributed as part of this software.
+# *****************************************************************************
+
+
+import os
+import re
+import sys
+import time
+from glob import glob
+
+import pyreadline3
+import pyreadline3.clipboard as clipboard
+import pyreadline3.console as console
+import pyreadline3.lineeditor.history as history
+import pyreadline3.lineeditor.lineobj as lineobj
+import pyreadline3.logger as logger
+from pyreadline3.keysyms.common import make_KeyPress_from_keydescr
+from pyreadline3.py3k_compat import is_ironpython
+from pyreadline3.unicode_helper import ensure_str, ensure_unicode
+
+from .error import GetSetError, ReadlineError
+from .logger import log
+from .modes import editingmodes
+from .py3k_compat import execfile, is_callable
+
+# an attempt to implement readline for Python in Python using ctypes
+
+
+if is_ironpython:  # ironpython does not provide a prompt string to readline
+    import System
+
+    default_prompt = ">>> "
+else:
+    default_prompt = ""
+
+
+class MockConsoleError(Exception):
+    pass
+
+
+class MockConsole(object):
+    """object used during refactoring. Should raise errors when someone tries
+    to use it.
+    """
+
+    def __setattr__(self, _name, _value):
+        raise MockConsoleError("Should not try to get attributes from MockConsole")
+
+    def cursor(self, size=50):
+        pass
+
+
+class BaseReadline(object):
+    def __init__(self):
+        self.allow_ctrl_c = False
+        self.ctrl_c_tap_time_interval = 0.3
+
+        self.debug = False
+        self.bell_style = "none"
+        self.mark = -1
+        self.console = MockConsole()
+        self.disable_readline = False
+        # this code needs to follow l_buffer and history creation
+        self.editingmodes = [mode(self) for mode in editingmodes]
+        for mode in self.editingmodes:
+            mode.init_editing_mode(None)
+        self.mode = self.editingmodes[0]
+
+        self.read_inputrc()
+        log("\n".join(self.mode.rl_settings_to_string()))
+
+        self.callback = None
+
+    def parse_and_bind(self, string):
+        """Parse and execute single line of a readline init file."""
+        try:
+            log('parse_and_bind("%s")' % string)
+            if string.startswith("#"):
+                return
+            if string.startswith("set"):
+                m = re.compile(r"set\s+([-a-zA-Z0-9]+)\s+(.+)\s*$").match(string)
+                if m:
+                    var_name = m.group(1)
+                    val = m.group(2)
+                    try:
+                        setattr(self.mode, var_name.replace("-", "_"), val)
+                    except AttributeError:
+                        log('unknown var="%s" val="%s"' % (var_name, val))
+                else:
+                    log('bad set "%s"' % string)
+                return
+            m = re.compile(r"\s*(\S+)\s*:\s*([-a-zA-Z]+)\s*$").match(string)
+            if m:
+                key = m.group(1)
+                func_name = m.group(2)
+                py_name = func_name.replace("-", "_")
+                try:
+                    func = getattr(self.mode, py_name)
+                except AttributeError:
+                    log('unknown func key="%s" func="%s"' % (key, func_name))
+                    if self.debug:
+                        print(
+                            "pyreadline3 parse_and_bind error, unknown "
+                            'function to bind: "%s"' % func_name
+                        )
+                    return
+                self.mode._bind_key(key, func)
+        except BaseException:
+            log("error")
+            raise
+
+    def _set_prompt(self, prompt):
+        self.mode.prompt = prompt
+
+    def _get_prompt(self):
+        return self.mode.prompt
+
+    prompt = property(_get_prompt, _set_prompt)
+
+    def get_line_buffer(self):
+        """Return the current contents of the line buffer."""
+        return self.mode.l_buffer.get_line_text()
+
+    def insert_text(self, string):
+        """Insert text into the command line."""
+        self.mode.insert_text(string)
+
+    def read_init_file(self, filename=None):
+        """Parse a readline initialization file. The default filename is the last filename used."""
+        log('read_init_file("%s")' % filename)
+
+    # History file book keeping methods (non-bindable)
+
+    def add_history(self, line):
+        """Append a line to the history buffer, as if it was the last line typed."""
+        self.mode._history.add_history(line)
+
+    def get_current_history_length(self):
+        """Return the number of lines currently in the history.
+        (This is different from get_history_length(), which returns
+        the maximum number of lines that will be written to a history file.)"""
+        return self.mode._history.get_current_history_length()
+
+    def get_history_length(self):
+        """Return the desired length of the history file.
+
+        Negative values imply unlimited history file size."""
+        return self.mode._history.get_history_length()
+
+    def set_history_length(self, length):
+        """Set the number of lines to save in the history file.
+
+        write_history_file() uses this value to truncate the history file
+        when saving. Negative values imply unlimited history file size.
+        """
+        self.mode._history.set_history_length(length)
+
+    def get_history_item(self, index):
+        """Return the current contents of history item at index."""
+        return self.mode._history.get_history_item(index)
+
+    def clear_history(self):
+        """Clear readline history"""
+        self.mode._history.clear_history()
+
+    def read_history_file(self, filename=None):
+        """Load a readline history file. The default filename is ~/.history."""
+        if filename is None:
+            filename = self.mode._history.history_filename
+        log("read_history_file from %s" % ensure_unicode(filename))
+        self.mode._history.read_history_file(filename)
+
+    def write_history_file(self, filename=None):
+        """Save a readline history file. The default filename is ~/.history."""
+        self.mode._history.write_history_file(filename)
+
+    # Completer functions
+
+    def set_completer(self, function=None):
+        """Set or remove the completer function.
+
+        If function is specified, it will be used as the new completer
+        function; if omitted or None, any completer function already
+        installed is removed. The completer function is called as
+        function(text, state), for state in 0, 1, 2, ..., until it returns a
+        non-string value. It should return the next possible completion
+        starting with text.
+        """
+        log("set_completer")
+        self.mode.completer = function
+
+    def get_completer(self):
+        """Get the completer function."""
+        log("get_completer")
+        return self.mode.completer
+
+    def get_begidx(self):
+        """Get the beginning index of the readline tab-completion scope."""
+        return self.mode.begidx
+
+    def get_endidx(self):
+        """Get the ending index of the readline tab-completion scope."""
+        return self.mode.endidx
+
+    def set_completer_delims(self, string):
+        """Set the readline word delimiters for tab-completion."""
+        self.mode.completer_delims = string
+
+    def get_completer_delims(self):
+        """Get the readline word delimiters for tab-completion."""
+        return self.mode.completer_delims
+
+    def set_startup_hook(self, function=None):
+        """Set or remove the startup_hook function.
+
+        If function is specified, it will be used as the new startup_hook
+        function; if omitted or None, any hook function already installed is
+        removed. The startup_hook function is called with no arguments just
+        before readline prints the first prompt.
+
+        """
+        self.mode.startup_hook = function
+
+    def set_pre_input_hook(self, function=None):
+        """Set or remove the pre_input_hook function.
+
+        If function is specified, it will be used as the new pre_input_hook
+        function; if omitted or None, any hook function already installed is
+        removed. The pre_input_hook function is called with no arguments
+        after the first prompt has been printed and just before readline
+        starts reading input characters.
+
+        """
+        self.mode.pre_input_hook = function
+
+    # Functions that are not relevant for all Readlines but should at least
+    # have a NOP
+
+    def _bell(self):
+        pass
+
+    #
+    # Standard call, not available for all implementations
+    #
+
+    def readline(self, prompt=""):
+        raise NotImplementedError
+
+    #
+    # Callback interface
+    #
+    def process_keyevent(self, keyinfo):
+        return self.mode.process_keyevent(keyinfo)
+
+    def readline_setup(self, prompt=""):
+        return self.mode.readline_setup(prompt)
+
+    def keyboard_poll(self):
+        return self.mode._readline_from_keyboard_poll()
+
+    def callback_handler_install(self, prompt, callback):
+        """bool readline_callback_handler_install ( string prompt, callback callback)
+        Initializes the readline callback interface and terminal, prints the prompt and returns immediately
+        """
+        self.callback = callback
+        self.readline_setup(prompt)
+
+    def callback_handler_remove(self):
+        """Removes a previously installed callback handler and restores terminal settings"""
+        self.callback = None
+
+    def callback_read_char(self):
+        """Reads a character and informs the readline callback interface when a line is received"""
+        if self.keyboard_poll():
+            line = self.get_line_buffer() + "\n"
+            # however there is another newline added by
+            # self.mode.readline_setup(prompt) which is called by callback_handler_install
+            # this differs from GNU readline
+            self.add_history(self.mode.l_buffer)
+            # TADA:
+            self.callback(line)
+
+    def read_inputrc(
+        self,  # in 2.4 we cannot call expanduser with unicode string
+        inputrcpath=os.path.expanduser(ensure_str("~/pyreadlineconfig.ini")),
+    ):
+        modes = dict([(x.mode, x) for x in self.editingmodes])
+        mode = self.editingmodes[0].mode
+
+        def setmode(name):
+            self.mode = modes[name]
+
+        def bind_key(key, name):
+            import types
+
+            if is_callable(name):
+                modes[mode]._bind_key(key, types.MethodType(name, modes[mode]))
+            elif hasattr(modes[mode], name):
+                modes[mode]._bind_key(key, getattr(modes[mode], name))
+            else:
+                print("Trying to bind unknown command '%s' to key '%s'" % (name, key))
+
+        def un_bind_key(key):
+            keyinfo = make_KeyPress_from_keydescr(key).tuple()
+            if keyinfo in modes[mode].key_dispatch:
+                del modes[mode].key_dispatch[keyinfo]
+
+        def bind_exit_key(key):
+            modes[mode]._bind_exit_key(key)
+
+        def un_bind_exit_key(key):
+            keyinfo = make_KeyPress_from_keydescr(key).tuple()
+            if keyinfo in modes[mode].exit_dispatch:
+                del modes[mode].exit_dispatch[keyinfo]
+
+        def setkill_ring_to_clipboard(killring):
+            import pyreadline3.lineeditor.lineobj
+
+            pyreadline3.lineeditor.lineobj.kill_ring_to_clipboard = killring
+
+        def sethistoryfilename(filename):
+            self.mode._history.history_filename = os.path.expanduser(
+                ensure_str(filename)
+            )
+
+        def setbellstyle(mode):
+            self.bell_style = mode
+
+        def disable_readline(mode):
+            self.disable_readline = mode
+
+        def sethistorylength(length):
+            self.mode._history.history_length = int(length)
+
+        def allow_ctrl_c(mode):
+            log("allow_ctrl_c:%s:%s" % (self.allow_ctrl_c, mode))
+            self.allow_ctrl_c = mode
+
+        def setbellstyle(mode):
+            self.bell_style = mode
+
+        def show_all_if_ambiguous(mode):
+            self.mode.show_all_if_ambiguous = mode
+
+        def ctrl_c_tap_time_interval(mode):
+            self.ctrl_c_tap_time_interval = mode
+
+        def mark_directories(mode):
+            self.mode.mark_directories = mode
+
+        def completer_delims(delims):
+            self.mode.completer_delims = delims
+
+        def complete_filesystem(delims):
+            self.mode.complete_filesystem = delims.lower()
+
+        def enable_ipython_paste_for_paths(boolean):
+            self.mode.enable_ipython_paste_for_paths = boolean
+
+        def debug_output(
+            on, filename="pyreadline_debug_log.txt"
+        ):  # Not implemented yet
+            if on in ["on", "on_nologfile"]:
+                self.debug = True
+
+            if on == "on":
+                logger.start_file_log(filename)
+                logger.start_socket_log()
+                logger.log("STARTING LOG")
+            elif on == "on_nologfile":
+                logger.start_socket_log()
+                logger.log("STARTING LOG")
+            else:
+                logger.log("STOPING LOG")
+                logger.stop_file_log()
+                logger.stop_socket_log()
+
+        _color_trtable = {
+            "black": 0,
+            "darkred": 4,
+            "darkgreen": 2,
+            "darkyellow": 6,
+            "darkblue": 1,
+            "darkmagenta": 5,
+            "darkcyan": 3,
+            "gray": 7,
+            "red": 4 + 8,
+            "green": 2 + 8,
+            "yellow": 6 + 8,
+            "blue": 1 + 8,
+            "magenta": 5 + 8,
+            "cyan": 3 + 8,
+            "white": 7 + 8,
+        }
+
+        def set_prompt_color(color):
+            self.prompt_color = self._color_trtable.get(color.lower(), 7)
+
+        def set_input_color(color):
+            self.command_color = self._color_trtable.get(color.lower(), 7)
+
+        loc = {
+            "version": pyreadline3.__version__,
+            "mode": mode,
+            "modes": modes,
+            "set_mode": setmode,
+            "bind_key": bind_key,
+            "disable_readline": disable_readline,
+            "bind_exit_key": bind_exit_key,
+            "un_bind_key": un_bind_key,
+            "un_bind_exit_key": un_bind_exit_key,
+            "bell_style": setbellstyle,
+            "mark_directories": mark_directories,
+            "show_all_if_ambiguous": show_all_if_ambiguous,
+            "completer_delims": completer_delims,
+            "complete_filesystem": complete_filesystem,
+            "debug_output": debug_output,
+            "history_filename": sethistoryfilename,
+            "history_length": sethistorylength,
+            "set_prompt_color": set_prompt_color,
+            "set_input_color": set_input_color,
+            "allow_ctrl_c": allow_ctrl_c,
+            "ctrl_c_tap_time_interval": ctrl_c_tap_time_interval,
+            "kill_ring_to_clipboard": setkill_ring_to_clipboard,
+            "enable_ipython_paste_for_paths": enable_ipython_paste_for_paths,
+        }
+        if os.path.isfile(inputrcpath):
+            try:
+                execfile(inputrcpath, loc, loc)
+            except Exception as x:
+                raise
+                import traceback
+
+                print("Error reading .pyinputrc", file=sys.stderr)
+                filepath, lineno = traceback.extract_tb(sys.exc_info()[2])[1][:2]
+                print("Line: %s in file %s" % (lineno, filepath), file=sys.stderr)
+                print(x, file=sys.stderr)
+                raise ReadlineError("Error reading .pyinputrc")
+
+    def redisplay(self):
+        pass
+
+
+class Readline(BaseReadline):
+    """Baseclass for readline based on a console"""
+
+    def __init__(self):
+        super().__init__()
+
+        self.console = console.Console()
+        self.selection_color = self.console.saveattr << 4
+        self.command_color = None
+        self.prompt_color = None
+        self.size = self.console.size()
+
+        # variables you can control with parse_and_bind
+
+    #  To export as readline interface
+
+    # Internal functions
+
+    def _bell(self):
+        """ring the bell if requested."""
+        if self.bell_style == "none":
+            pass
+        elif self.bell_style == "visible":
+            raise NotImplementedError("Bellstyle visible is not implemented yet.")
+        elif self.bell_style == "audible":
+            self.console.bell()
+        else:
+            raise ReadlineError("Bellstyle %s unknown." % self.bell_style)
+
+    def _clear_after(self):
+        c = self.console
+        x, y = c.pos()
+        w, h = c.size()
+        c.rectangle((x, y, w + 1, y + 1))
+        c.rectangle((0, y + 1, w, min(y + 3, h)))
+
+    def _set_cursor(self):
+        c = self.console
+        xc, yc = self.prompt_end_pos
+        w, h = c.size()
+        xc += self.mode.l_buffer.visible_line_width()
+        while xc >= w:
+            xc -= w
+            yc += 1
+        c.pos(xc, yc)
+
+    def _print_prompt(self):
+        c = self.console
+        x, y = c.pos()
+
+        n = c.write_scrolling(self.prompt, self.prompt_color)
+        self.prompt_begin_pos = (x, y - n)
+        self.prompt_end_pos = c.pos()
+        self.size = c.size()
+
+    def _update_prompt_pos(self, n):
+        if n != 0:
+            bx, by = self.prompt_begin_pos
+            ex, ey = self.prompt_end_pos
+            self.prompt_begin_pos = (bx, by - n)
+            self.prompt_end_pos = (ex, ey - n)
+
+    def _update_line(self):
+        c = self.console
+        l_buffer = self.mode.l_buffer
+        c.cursor(0)  # Hide cursor avoiding flicking
+        c.pos(*self.prompt_begin_pos)
+        self._print_prompt()
+        ltext = l_buffer.quoted_text()
+        if l_buffer.enable_selection and (l_buffer.selection_mark >= 0):
+            start = len(l_buffer[: l_buffer.selection_mark].quoted_text())
+            stop = len(l_buffer[: l_buffer.point].quoted_text())
+            if start > stop:
+                stop, start = start, stop
+            n = c.write_scrolling(ltext[:start], self.command_color)
+            n = c.write_scrolling(ltext[start:stop], self.selection_color)
+            n = c.write_scrolling(ltext[stop:], self.command_color)
+        else:
+            n = c.write_scrolling(ltext, self.command_color)
+
+        x, y = c.pos()  # Preserve one line for Asian IME(Input Method Editor) statusbar
+        w, h = c.size()
+        if (y >= h - 1) or (n > 0):
+            c.scroll_window(-1)
+            c.scroll((0, 0, w, h), 0, -1)
+            n += 1
+
+        self._update_prompt_pos(n)
+        if hasattr(
+            c, "clear_to_end_of_window"
+        ):  # Work around function for ironpython due
+            c.clear_to_end_of_window()  # to System.Console's lack of FillFunction
+        else:
+            self._clear_after()
+
+        # Show cursor, set size vi mode changes size in insert/overwrite mode
+        c.cursor(1, size=self.mode.cursor_size)
+        self._set_cursor()
+
+    def callback_read_char(self):
+        # Override base to get automatic newline
+        """Reads a character and informs the readline callback interface when a line is received"""
+        if self.keyboard_poll():
+            line = self.get_line_buffer() + "\n"
+            self.console.write("\r\n")
+            # however there is another newline added by
+            # self.mode.readline_setup(prompt) which is called by callback_handler_install
+            # this differs from GNU readline
+            self.add_history(self.mode.l_buffer)
+            # TADA:
+            self.callback(line)
+
+    def event_available(self):
+        return self.console.peek() or (len(self.paste_line_buffer) > 0)
+
+    def _readline_from_keyboard(self):
+        while True:
+            if self._readline_from_keyboard_poll():
+                break
+
+    def _readline_from_keyboard_poll(self):
+        pastebuffer = self.mode.paste_line_buffer
+        if len(pastebuffer) > 0:
+            # paste first line in multiline paste buffer
+            self.l_buffer = lineobj.ReadLineTextBuffer(pastebuffer[0])
+            self._update_line()
+            self.mode.paste_line_buffer = pastebuffer[1:]
+            return True
+
+        c = self.console
+
+        def nop(e):
+            pass
+
+        try:
+            event = c.getkeypress()
+        except KeyboardInterrupt:
+            event = self.handle_ctrl_c()
+        try:
+            result = self.mode.process_keyevent(event.keyinfo)
+        except EOFError:
+            logger.stop_logging()
+            raise
+        self._update_line()
+        return result
+
+    def readline_setup(self, prompt=""):
+        BaseReadline.readline_setup(self, prompt)
+        self._print_prompt()
+        self._update_line()
+
+    def readline(self, prompt=""):
+        self.readline_setup(prompt)
+        self.ctrl_c_timeout = time.time()
+        self._readline_from_keyboard()
+        self.console.write("\r\n")
+        log("returning(%s)" % self.get_line_buffer())
+        return self.get_line_buffer() + "\n"
+
+    def handle_ctrl_c(self):
+        from pyreadline3.console.event import Event
+        from pyreadline3.keysyms.common import KeyPress
+
+        log("KBDIRQ")
+        event = Event(0, 0)
+        event.char = "c"
+        event.keyinfo = KeyPress(
+            "c", shift=False, control=True, meta=False, keyname=None
+        )
+        if self.allow_ctrl_c:
+            now = time.time()
+            if (now - self.ctrl_c_timeout) < self.ctrl_c_tap_time_interval:
+                log("Raise KeyboardInterrupt")
+                raise KeyboardInterrupt
+            else:
+                self.ctrl_c_timeout = now
+        else:
+            raise KeyboardInterrupt
+        return event
+
+    def redisplay(self):
+        BaseReadline.redisplay(self)

rl/Lib/site-packages/pyreadline3/unicode_helper.py

@@ -0,0 +1,53 @@
+# -*- coding: utf-8 -*-
+# *****************************************************************************
+#       Copyright (C) 2006-2020 Jorgen Stenarson. <jorgen.stenarson@bostream.nu>
+#       Copyright (C) 2020 Bassem Girgis. <brgirgis@gmail.com>
+#
+#  Distributed under the terms of the BSD License.  The full license is in
+#  the file COPYING, distributed as part of this software.
+# *****************************************************************************
+import sys
+from typing import Iterable, Union
+
+#: Also support non-latin chars.
+_pyreadline_fallback_codepage = "utf-8"
+try:
+    pyreadline_codepage = sys.stdout.encoding
+except AttributeError:
+    # This error occurs when pdb imports readline and doctest has replaced
+    # stdout with stdout collector. We will assume ascii codepage
+    pyreadline_codepage = _pyreadline_fallback_codepage
+
+if pyreadline_codepage is None:
+    pyreadline_codepage = _pyreadline_fallback_codepage
+
+
+def ensure_unicode(text: Union[str, bytes]) -> str:
+    """helper to ensure that text passed to WriteConsoleW is unicode"""
+
+    if isinstance(text, bytes):
+        try:
+            return text.decode(pyreadline_codepage, "replace")
+        except (LookupError, TypeError):
+            return text.decode(errors="replace")
+
+    return text
+
+
+def ensure_str(text: Union[str, bytes]) -> bytes:
+    """Convert unicode to str using pyreadline_codepage"""
+
+    if isinstance(text, str):
+        try:
+            return text.encode(pyreadline_codepage, "replace")
+        except (LookupError, TypeError):
+            return text.encode(errors="replace")
+
+    return text
+
+
+def biter(text: bytes) -> Iterable[bytes]:
+    if isinstance(text, bytes):
+        return (s.to_bytes(1, "big") for s in text)
+
+    return iter(text)