wizlib 2.0.15__tar.gz → 2.0.17__tar.gz

{wizlib-2.0.15 → wizlib-2.0.17}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: wizlib
-Version: 2.0.15
+Version: 2.0.17
 Summary: Framework for flexible and powerful command-line applications
 License: MIT
 Author: Steampunk Wizard

{wizlib-2.0.15 → wizlib-2.0.17}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "wizlib"
-version = "2.0.15"
+version = "2.0.17"
 description = "Framework for flexible and powerful command-line applications"
 authors = ["Steampunk Wizard <wizlib@steampunkwizard.ca>"]
 license = "MIT"

{wizlib-2.0.15 → wizlib-2.0.17}/wizlib/ui/__init__.py

@@ -2,12 +2,6 @@
 # interfaces (shell, curses, Slack, etc) to drive the same data model without
 # the data model needing specific UI knowledge.
 #
-# Possibly outdated info: The UI keeps a reference to the Handler. The Handler
-# will bring a Command with it, and this is the main root command. In the case
-# of a Shell-type UI, that is the command to be executed. In the case of an
-# interactive UI, it's really just a placeholder; the UI will instantiate other
-# commands as it proceeds. But the Handler won't know about those.
-#
 # Commands might call back to the UI for confirmations or arguments that are
 # previously omitted, using the get_ methods.
 
@@ -45,41 +39,52 @@ from wizlib.class_family import ClassFamily
 
 @dataclass
 class Choice:
-    """One option of several"""
+    """A single option, equivalent to a single radio button or select option in
+    HTML.
+
+    text - text of the option
+
+    keys - keystrokes that might indicate this option in a keyboard-driven UI
+
+    action - what to do when chosen
+    """
 
-    keys: list[str] = field(default_factory=list)
-    words: list[str] = field(default_factory=list)
+    text: str = ''
+    keys: str = ''
     action: object = None
 
     @property
     def key(self):
-        return self.keys[0]
-
-    @property
-    def word(self):
-        return self.words[0]
+        return self.keys[0] if self.keys else ''
 
     def hit_key(self, key):
         return key in self.keys
 
-    def hit_word(self, word):
-        return word in self.words
+    def hit_text(self, text):
+        return self.text.startswith(text)
 
+    @property
     def value(self):
-        return self.word if (self.action is None) else self.action
+        return self.text if (self.action is None) else self.action
+
+    @property
+    def key_prompt(self):
+        """Text with keystroke in parens"""
+        for key in self.keys:
+            if key in self.text:
+                pre, it, post = self.text.partition(key)
+                return f"{pre}({it}){post}"
+        return f"({self.keys[0]}){self.text}"
 
-    # def call(self, *args, **kwargs):
-    #     if callable(self.action):
-    #         return self.action(*args, **kwargs)
 
+# TODO: Decide whether the Prompt/Chooser division makes sense
 
-@dataclass
 class Prompt:
     """Tell the user what kind of input to provide"""
 
-    intro: str = ""
-    default: str = ""
-    choices: list = field(default_factory=list)
+    def __init__(self, intro: str = '', default: str = ''):
+        self.intro = intro
+        self.default = default
 
     @property
     def prompt_string(self):
@@ -90,35 +95,50 @@ class Prompt:
         if self.default:
             result.append(f"[{self.default}]")
         for choice in self.choices:
-            if choice.word == self.default:
+            if choice.text == self.default:
                 continue
-            pre, it, post = choice.word.partition(choice.key)
-            result.append(f"{pre}({it}){post}")
+            result.append(choice.key_prompt)
         return " ".join(result) + ": "
 
 
-@dataclass
 class Chooser(Prompt):
     """Hold a set of choices and get the result"""
 
+    def __init__(self, intro: str = '', default: str = '', choices=None):
+        super().__init__(intro, default)
+        if isinstance(choices, dict):
+            self.choices = [Choice(choices[k], k) for k in choices]
+        elif isinstance(choices, list):
+            self.choices = [(c if isinstance(c, Choice) else Choice(c))
+                            for c in choices]
+        else:
+            self.choices = []
+
     def add_choice(self, *args, **kwargs):
         choice = Choice(*args, **kwargs)
         self.choices.append(choice)
 
     def choice_by_key(self, key):
-        chosenlist = [o.value for o in self.choices if o.hit_key(key)]
-        return self._choose(chosenlist)
+        if key == '\n':
+            choice = self.default
+        else:
+            choice = next(
+                (o.value for o in self.choices if key in o.keys), None)
+        return choice() if callable(choice) else choice
 
-    def choice_by_word(self, word):
-        chosenlist = [o.value for o in self.choices if o.hit_word(word)]
-        return self._choose(chosenlist)
+    def choices_by_text(self, text):
+        return [o.value for o in self.choices if o.hit_text(text)]
 
-    def _choose(self, chosenlist):
-        choice = next(iter(chosenlist), None)
-        if callable(choice):
-            return choice()
-        else:
-            return choice
+    # def choice_by_word(self, word):
+    #     chosenlist = [o.value for o in self.choices if o.hit_word(word)]
+    #     return self._choose(chosenlist)
+
+    # def _choose(self, chosenlist):
+    #     choice = next(iter(chosenlist), None)
+    #     if callable(choice):
+    #         return choice()
+    #     else:
+    #         return choice
 
 
 @dataclass
@@ -131,8 +151,8 @@ class UI(ClassFamily):
 #     def start(self):
 #         pass
 
-#     # TODO: Make get_option an abstract method
-#     def get_option(self, chooser: Chooser):
+#     # TODO: Make get_option_mini an abstract method
+#     def get_option_mini(self, chooser: Chooser):
 #         """Get an option from a list from the user"""
 #         pass
 

wizlib-2.0.17/wizlib/ui/shell_line_editor.py

@@ -0,0 +1,236 @@
+from enum import Enum
+import sys
+import re
+
+from readchar import readkey
+
+
+if (sys.platform == "win32"):
+    import ctypes
+    from ctypes import wintypes
+else:
+    import termios
+
+# https://stackoverflow.com/questions/35526014/how-can-i-get-the-cursors-position-in-an-ansi-terminal
+
+
+def cursorPos():  # pragma: nocover
+    if (sys.platform == "win32"):
+        OldStdinMode = ctypes.wintypes.DWORD()
+        OldStdoutMode = ctypes.wintypes.DWORD()
+        kernel32 = ctypes.windll.kernel32
+        kernel32.GetConsoleMode(
+            kernel32.GetStdHandle(-10), ctypes.byref(OldStdinMode))
+        kernel32.SetConsoleMode(kernel32.GetStdHandle(-10), 0)
+        kernel32.GetConsoleMode(
+            kernel32.GetStdHandle(-11), ctypes.byref(OldStdoutMode))
+        kernel32.SetConsoleMode(kernel32.GetStdHandle(-11), 7)
+    else:
+        OldStdinMode = termios.tcgetattr(sys.stdin)
+        _ = termios.tcgetattr(sys.stdin)
+        _[3] = _[3] & ~(termios.ECHO | termios.ICANON)
+        termios.tcsetattr(sys.stdin, termios.TCSAFLUSH, _)
+    try:
+        _ = ""
+        sys.stdout.write("\x1b[6n")
+        sys.stdout.flush()
+        while not (_ := _ + sys.stdin.read(1)).endswith('R'):
+            True
+        res = re.match(r".*\[(?P<y>\d*);(?P<x>\d*)R", _)
+    finally:
+        if (sys.platform == "win32"):
+            kernel32.SetConsoleMode(kernel32.GetStdHandle(-10), OldStdinMode)
+            kernel32.SetConsoleMode(kernel32.GetStdHandle(-11), OldStdoutMode)
+        else:
+            termios.tcsetattr(sys.stdin, termios.TCSAFLUSH, OldStdinMode)
+    if (res):
+        return (res.group("x"), res.group("y"))
+    return (-1, -1)
+
+
+def sequence(hexes: str) -> str:
+    return bytes.fromhex(hexes).decode()
+
+
+LEFT = sequence("1b5b44")
+RIGHT = sequence("1b5b43")
+BACKSPACE = sequence("7f")
+BEGINNING = sequence("01")
+END = sequence("05")
+RETURN = sequence("0a")
+ESC = sequence("1b")
+TAB = sequence("09")
+SHIFT_TAB = sequence("1b5b5a")
+LEFT_WORD = sequence("1b62")
+RIGHT_WORD = sequence("1b66")
+KILL = sequence("0b")
+
+RESET = ESC + "[0m"
+FAINT = ESC + "[2m"
+BOLD = ESC + "[1m"
+
+WORD_SEPARATORS = ' -_.,'
+
+
+def write(key):
+    sys.stderr.write(key)
+    sys.stderr.flush()
+
+
+# "Fill" refers to the lighter text in the editor, to the right of (or instead
+# of) user-typed text.
+#
+# States:
+# - USER: User has typed something, so no fill
+# - TAB: User has hit tab or shift-tab, show tab completion if any
+# - DEFAULT: editor has a default value and user has typed nothing, so show
+#   default if any
+# - BLANK: user hit backspace to clear the fill
+
+FillState = Enum('FillState', 'USER TAB DEFAULT BLANK')
+
+
+class ShellLineEditor:  # pragma: nocover
+
+    buf = ''
+    pos = 0
+    index = -1
+
+    def __init__(self, choices=[], default=''):
+        """Parameters:
+
+        choices: List of string options for tab completion
+
+        default: Starting string value, can be accepted by user pressing return
+        """
+        self.choices = choices
+        self.default = default
+        self.fillstate = FillState.DEFAULT
+
+    def edit(self):
+        write(RESET)
+        while True:
+            self.write_fill()
+            key = readkey()
+            self.clear_fill()
+            if key == RETURN:
+                break
+            if key.isprintable():
+                write(BOLD + key + self.buf[self.pos:] +
+                      ('\b' * (len(self.buf) - self.pos)) + RESET)
+                self.buf = self.buf[:self.pos] + key + self.buf[self.pos:]
+                self.pos += 1
+                self.fillstate = FillState.USER
+            elif (key in [BACKSPACE, KILL]) and self.has_fill:
+                # Backspace clears the fill
+                self.fillstate = FillState.BLANK
+            elif (key == BACKSPACE) and (self.pos > 0):
+                write(BOLD + '\b' + self.buf[self.pos:] + ' ' +
+                      ('\b' * (1 + len(self.buf) - self.pos)) + RESET)
+                self.buf = self.buf[:self.pos-1] + self.buf[self.pos:]
+                self.pos -= 1
+                self.fillstate = FillState.USER if (
+                    self.pos > 0) else FillState.DEFAULT
+            elif key == LEFT and self.pos > 0:
+                self.move_left()
+                self.fillstate = FillState.USER
+            elif key == RIGHT and self.pos < len(self.buf):
+                self.move_right()
+                self.fillstate = FillState.USER
+            elif key == BEGINNING and self.pos > 0:
+                self.move_beginning()
+                self.fillstate = FillState.USER
+            elif key == END and self.has_fill:
+                self.accept_fill()
+                self.fillstate = FillState.USER
+            elif key == END and self.pos < len(self.buf):
+                self.move_end_buf()
+                self.fillstate = FillState.USER
+            elif key == TAB and (choices := self.valid_choices):
+                self.index = (self.index + 1) % len(choices)
+                self.fillstate = FillState.TAB
+            elif key == SHIFT_TAB and self.index > -1:
+                self.index = (self.index - 1) % len(self.valid_choices)
+                self.fillstate = FillState.TAB
+            elif key == LEFT_WORD and self.pos > 0:
+                while (self.pos > 0) and self.is_sep(self.pos - 1):
+                    self.move_left()
+                while (self.pos > 0) and not self.is_sep(self.pos - 1):
+                    self.move_left()
+                self.fillstate = FillState.USER
+            elif key == RIGHT_WORD and self.pos < len(self.buf):
+                while (self.pos < len(self.buf)) and self.is_sep(self.pos):
+                    self.move_right()
+                while (self.pos < len(self.buf)) and not self.is_sep(self.pos):
+                    self.move_right()
+                self.fillstate = FillState.USER
+            elif key == KILL:
+                chars = len(self.buf) - self.pos
+                write(' ' * chars + '\b' * chars)
+                self.buf = self.buf[:self.pos]
+                self.fillstate = FillState.USER
+            else:
+                pass
+        self.accept_fill()
+        write(RETURN)
+        return self.buf
+
+    def is_sep(self, pos):
+        return (self.buf[pos] in WORD_SEPARATORS)
+
+    @property
+    def has_fill(self):
+        return self.fillstate in [FillState.DEFAULT, FillState.TAB]
+
+    def accept_fill(self):
+        if self.has_fill:
+            write(BOLD + self.fill + RESET)
+            self.buf += self.fill
+            self.pos = len(self.buf)
+
+    def move_left(self):
+        write(LEFT)
+        self.pos -= 1
+
+    def move_right(self):
+        write(RIGHT)
+        self.pos += 1
+
+    def move_beginning(self):
+        while self.pos > 0:
+            self.move_left()
+
+    def move_end_buf(self):
+        while self.pos < len(self.buf):
+            self.move_right()
+
+    def write_fill(self):
+        if self.fillstate in [FillState.DEFAULT, FillState.TAB]:
+            self.move_end_buf()
+            write(FAINT + self.fill + '\b' * len(self.fill) + RESET)
+
+    def clear_fill(self):
+        if self.has_fill:
+            self.move_end_buf()
+            write(' ' * len(self.fill) + '\b' * len(self.fill))
+
+    @property
+    def fill(self):
+        if self.fillstate == FillState.TAB:
+            choice = self.valid_choices[self.index]
+            return choice[len(self.last_word):]
+        elif self.fillstate == FillState.DEFAULT:
+            return self.default
+        else:
+            return ''
+
+    @property
+    def last_word(self):
+        index = next((c for c in reversed(range(len(self.buf)))
+                     if self.buf[c] in WORD_SEPARATORS), -1)
+        return self.buf[index+1:]
+
+    @property
+    def valid_choices(self):
+        # return [c for c in self.choices if c.startswith(self.buf)]
+        return [c for c in self.choices if c.startswith(self.last_word)]

{wizlib-2.0.15 → wizlib-2.0.17}/wizlib/ui/shell_ui.py

@@ -3,6 +3,7 @@ import sys
 from readchar import readkey
 from wizlib.rlinput import rlinput
 from wizlib.ui import UI
+from wizlib.ui.shell_line_editor import ShellLineEditor
 
 INTERACTIVE = sys.stdin.isatty()
 
@@ -21,7 +22,7 @@ class ShellUI(UI):
         if value:
             print(value, file=sys.stderr)
 
-    def get_option(self, chooser):
+    def get_option_mini(self, chooser):
         """Get a choice from the user with a single keystroke"""
         # key = rlinput(chooser.prompt_string)
         print(chooser.prompt_string, end='', file=sys.stderr, flush=True)
@@ -35,5 +36,7 @@ class ShellUI(UI):
     def get_text(self, prompt):
         """Allow the user to input an arbitrary line of text"""
         sys.stderr.write(prompt)
-        value = input()
+        sys.stderr.flush()
+        value = ShellLineEditor().edit()
+        # value = input()
         return value

wizlib-2.0.17/wizlib/util.py

@@ -0,0 +1,8 @@
+from unittest.mock import Mock, patch
+
+
+RK = 'wizlib.ui.shell_line_editor.readkey'
+
+
+def mock_keys(keys: str):
+    return patch(RK, Mock(side_effect=keys))