wizlib 2.0.19__py3-none-any.whl → 3.0.0__py3-none-any.whl

wizlib/app.py

@@ -8,13 +8,16 @@ from wizlib.command import WizHelpCommand
 from wizlib.super_wrapper import SuperWrapper
 from wizlib.parser import WizParser
 from wizlib.ui import UI
-from wizlib.ui.shell_ui import ShellUI
 
 
 RED = '\033[91m'
 RESET = '\033[0m'
 
 
+class AppCancellation(BaseException):
+    pass
+
+
 class WizApp:
     """Root of all WizLib-based CLI applications. Subclass it. Can be
     instantiated and then run multiple commands."""
@@ -22,67 +25,74 @@ class WizApp:
     base_command = None
     name = ''
 
+    # Set some default types so linting works
+    ui: UI
+
     @classmethod
     def main(cls):  # pragma: nocover
         """Call this from a __main__ entrypoint"""
-        cls.run(*sys.argv[1:], debug=os.getenv('DEBUG'))
+        cls.start(*sys.argv[1:], debug=os.getenv('DEBUG'))
 
     @classmethod
-    def run(cls, *args, debug=False):
+    def start(cls, *args, debug=False):
         """Call this from a Python entrypoint"""
         try:
-            cls.initialize()
-            app = cls(*args)
-            command = app.first_command
-            result = command.execute()
-            if result:
-                print(result, file=sys.stdout, end='')
-                if sys.stdout.isatty():  # pragma: nocover
-                    print()
-            if command.status:
-                print(command.status, file=sys.stderr)
-        except Exception as error:
+            parser = WizParser(prog=cls.name)
+            for handler in cls.base_command.handlers:
+                handler.add_args(parser)
+            ns, more = parser.parse_known_args(args)
+            app = cls.initialize(**vars(ns))
+            more = more if more else [cls.base_command.default]
+            app.run(*more)
+        except AppCancellation as cancellation:
+            if str(cancellation):
+                print(str(cancellation), file=sys.stderr)
+        except BaseException as error:
             if debug:
                 raise error
             else:
-                print(f"\n{RED}{type(error).__name__}: " +
-                      f"{error}{RESET}\n", file=sys.stderr)
+                name = type(error).__name__
+                print(f"\n{RED}{name}{': ' if str(error) else ''}" +
+                      f"{error}{RESET}", file=sys.stderr)
                 sys.exit(1)
 
     @classmethod
-    def initialize(cls):
-        """Set up the app class to parse arguments"""
-        cls.parser = WizParser(
-            prog=cls.name,
-            exit_on_error=False)
+    def initialize(cls, **vals):
+        """Converts argparse values (strings) into actual handlers and
+        instantiates the app"""
+        handlers = {}
         for handler in cls.base_command.handlers:
-            cls.parser.add_argument(
-                f"--{handler.name}",
-                f"-{handler.name[0]}",
-                **handler.option_properties(cls))
+            val = vals[handler.name] if (
+                handler.name in vals) else handler.default
+            handlers[handler.name] = handler.setup(val)
+        return cls(**handlers)
 
-        subparsers = cls.parser.add_subparsers(dest='command')
-        for command in cls.base_command.family_members('name'):
+    def __init__(self, **handlers):
+        for name, handler in handlers.items():
+            handler.app = self
+            setattr(self, name, handler)
+        self.parser = WizParser()
+        subparsers = self.parser.add_subparsers(dest='command')
+        for command in self.base_command.family_members('name'):
             key = command.get_member_attr('key')
             aliases = [key] if key else []
             subparser = subparsers.add_parser(command.name, aliases=aliases)
             command.add_args(subparser)
 
-    def __init__(self, *args):
-        args = args if args else [self.base_command.default]
-        if not hasattr(self, 'parser'):
-            self.__class__.initialize()
-        self.vals = vars(self.parser.parse_args(args))
-        self.first_command = self.get_command(**self.vals)
-
-    def get_command(self, **vals):
-        """Returns a single command"""
+    def run(self, *args):
+        vals = vars(self.parser.parse_args(args))
         if 'help' in vals:
             return WizHelpCommand(**vals)
-        else:
-            command_name = vals.pop('command')
-            command_class = self.base_command.family_member(
-                'name', command_name)
-            if not command_class:
-                raise Exception(f"Unknown command {command_name}")
-            return command_class(**vals)
+        command_name = vals.pop('command')
+        command_class = self.base_command.family_member(
+            'name', command_name)
+        if not command_class:
+            raise Exception(f"Unknown command {command_name}")
+        command = command_class(self, **vals)
+        result = command.execute()
+        if result:
+            print(result, end='')
+            if sys.stdout.isatty():  # pragma: nocover
+                print()
+        if command.status:
+            print(command.status, file=sys.stderr)

wizlib/class_family.py

@@ -48,10 +48,11 @@ class ClassFamily:
         return hits
 
     @classmethod
-    def family_attrs(self, attribute):
+    def family_attrs(self, attribute):  # pragma: nocover
         """
         Return a set of all the values of a specific attribute that exist in
-        the family. The set avoids repetition of values in the result.
+        the family. The set avoids repetition of values in the result. This is
+        a legacy method, not currently tested or used.
         """
         # Put myself into a set if I qualify
         if self.has_member_attrs(attribute):

wizlib/command.py

@@ -3,11 +3,15 @@ from pathlib import Path
 
 from wizlib.class_family import ClassFamily
 from wizlib.config_handler import ConfigHandler
-from wizlib.input_handler import InputHandler
+from wizlib.stream_handler import StreamHandler
 from wizlib.super_wrapper import SuperWrapper
 from wizlib.ui import UI
 
 
+class CommandCancellation(BaseException):
+    pass
+
+
 class WizCommand(ClassFamily, SuperWrapper):
     """Define all the args you want, but stdin always works."""
 
@@ -21,12 +25,10 @@ class WizCommand(ClassFamily, SuperWrapper):
         Add global arguments in the base class. Not wrapped."""
         pass
 
-    def __init__(self, **vals):
+    def __init__(self, app=None, **vals):
+        self.app = app
         for key in vals:
             setattr(self, key, vals[key])
-        for handler in self.handlers:
-            if handler.name not in vals:
-                setattr(self, handler.name, handler.setup()())
 
     def handle_vals(self):
         """Clean up vals, calculate any, ask through UI, etc. - override
@@ -43,9 +45,12 @@ class WizCommand(ClassFamily, SuperWrapper):
     def execute(self, method, *args, **kwargs):
         """Actually perform the command - override and wrap this via
         SuperWrapper"""
-        self.handle_vals()
-        result = method(self, *args, **kwargs)
-        return result
+        try:
+            self.handle_vals()
+            result = method(self, *args, **kwargs)
+            return result
+        except CommandCancellation as cancellation:
+            self.status = str(cancellation) if str(cancellation) else None
 
 
 class WizHelpCommand(WizCommand):

wizlib/config_handler.py

@@ -9,6 +9,7 @@ from yaml import Loader
 from wizlib.handler import Handler
 
 from wizlib.error import ConfigHandlerError
+from wizlib.parser import WizParser
 
 
 class ConfigHandler(Handler):
@@ -23,8 +24,8 @@ class ConfigHandler(Handler):
 
     name = 'config'
 
-    def __init__(self, value=None):
-        self.file = value
+    def __init__(self, file=None):
+        self.file = file
         self.cache = {}
 
     @property
@@ -34,10 +35,10 @@ class ConfigHandler(Handler):
         path = None
         if self.file:
             path = Path(self.file)
-        elif self.appname:
-            localpath = Path.cwd() / f".{self.appname}.yml"
-            homepath = Path.home() / f".{self.appname}.yml"
-            if (envvar := self.env(self.appname + '-config')):
+        elif self.app and self.app.name:
+            localpath = Path.cwd() / f".{self.app.name}.yml"
+            homepath = Path.home() / f".{self.app.name}.yml"
+            if (envvar := self.env(self.app.name + '-config')):
                 path = Path(envvar)
             elif (localpath.is_file()):
                 path = localpath
@@ -77,11 +78,6 @@ class ConfigHandler(Handler):
     @classmethod
     def fake(cls, **vals):
         """Return a fake ConfigHandler with forced values, for testing"""
-        handler = cls()
-
-        def fake_env(name):
-            key = name.replace('-', '_')
-            if key in vals:
-                return vals[key]
-        handler.env = fake_env
-        return handler
+        self = cls()
+        self.cache = {k.replace('_', '-'): vals[k] for k in vals}
+        return self

wizlib/handler.py

@@ -1,25 +1,24 @@
 from argparse import Action
 
+from wizlib.parser import WizParser
+
 
 class Handler:
     """Base class for handlers"""
 
-    appname = None
     default = ''
+    app = None
 
     @classmethod
-    def option_properties(cls, app):
-        """Argparse keyword arguments for this optional arg"""
-        return {
-            'type': cls.setup(app.name),
-            'default': cls.default
-        }
+    def add_args(cls, parser: WizParser):
+        parser.add_argument(
+            f"--{cls.name}",
+            f"-{cls.name[0]}",
+            default=cls.default)
 
     @classmethod
-    def setup(cls, name=None):
-        """Return a callable that returns an instance of the handler object
-        that's referenced by commands. In the default case, an instance of the
-        handler class itself that knows the name of the app."""
-        class NamedHandler(cls):
-            appname = name
-        return NamedHandler
+    def setup(cls, val):
+        return cls(val)
+
+    def __init__(self, val=None):
+        pass

wizlib/{input_handler.py → stream_handler.py}

@@ -2,13 +2,14 @@ from pathlib import Path
 import sys
 
 from wizlib.handler import Handler
+from wizlib.parser import WizParser
 
 INTERACTIVE = sys.stdin.isatty()
 
 
-class InputHandler(Handler):
+class StreamHandler(Handler):
 
-    name = 'input'
+    name = 'stream'
     text: str = ''
 
     def __init__(self, file=None, stdin=True):
@@ -22,7 +23,7 @@ class InputHandler(Handler):
 
     @classmethod
     def fake(cls, value):
-        """Return a fake InputHandler with forced values, for testing"""
+        """Return a fake StreamHandler with forced values, for testing"""
         handler = cls(stdin=False)
         handler.text = value
         return handler

wizlib/ui/__init__.py

@@ -37,6 +37,14 @@ from tempfile import NamedTemporaryFile
 from wizlib.class_family import ClassFamily
 
 
+class Emphasis(Enum):
+    """Semantic style"""
+    INFO = 1
+    GENERAL = 2
+    PRINCIPAL = 3
+    ERROR = 4
+
+
 @dataclass
 class Choice:
     """A single option, equivalent to a single radio button or select option in
@@ -129,71 +137,9 @@ class Chooser(Prompt):
     def choices_by_text(self, text):
         return [o.value for o in self.choices if o.hit_text(text)]
 
-    # 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
 class UI(ClassFamily):
-    pass
-
-#     handler: object
-
-#     # TODO: Make start an abstract method
-#     def start(self):
-#         pass
-
-#     # 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
-
-#     # TODO: Make get_string an abstract method
-#     def get_string(self, intro, default=""):
-#         """Get a string value from the user"""
-#         pass
-
-
-# # Terminal UIs include Shell and Curses, since both will rely on a
-# # terminal-based editor for the e.g. Manage command.
-
-
-# class TerminalUI(UI):
-
-#     # A convenience method to get a full textual prompt for a string input
-
-#     def full_prompt(self, prompt, default=None):
-#         if default:
-#             return f'{prompt} [{default}]: '
-#         else:
-#             return f'{prompt}: '
-
-#     # @staticmethod
-#     # def edit_text(text):
-#     #     commands = [['sensible-editor'], ['open', '-W']]
-#     #     with NamedTemporaryFile(mode="w+") as tempfile:
-#     #         tempfile.write(text)
-#     #         tempfile.seek(0)
-#     #         command = [os.environ.get('EDITOR')]
-#     #         if not command[0] or not shutil.which(command[0]):
-#     #             iterator = (c for c in commands if shutil.which(c[0]))
-#     #             command = next(filter(None, iterator), None)
-#     #             if not command:
-#     #                 raise RuntimeError(
-#     #                     "A text editor at the $EDITOR " +
-#     #                     "environment variable is required")
-#     #         subprocess.run(command + [tempfile.name])
-#     #         tempfile.seek(0)
-#     #         return tempfile.read()
-
 
-# class UserCancelError(Exception):
-#     pass
+    def send(self, value: str = '', emphasis: Emphasis = Emphasis.GENERAL):
+        pass

wizlib/ui/shell/__init__.py

@@ -0,0 +1,40 @@
+# We use an odd misc of nonprintable ASCII, ANSI escape sequences, with some
+# custom preferences. So define them all here.
+
+
+from enum import StrEnum
+
+
+def sequence(hexes: str) -> str:
+    return bytes.fromhex(hexes).decode()
+
+
+ESC = sequence("1b")
+
+# TODO: Is any of this available in the standard library?
+
+
+class S(StrEnum):
+    LEFT = sequence("1b5b44")
+    RIGHT = sequence("1b5b43")
+    BACKSPACE = sequence("7f")
+    BEGINNING = sequence("01")
+    END = sequence("05")
+    RETURN = sequence("0a")
+    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"
+    SEPARATORS = ' -_.,'
+    SPACE = ' '
+    RED = ESC + '[31m'
+    GREEN = ESC + '[32m'
+    YELLOW = ESC + '[33m'
+    BLUE = ESC + '[34m'
+    MAGENTA = ESC + '[35m'
+    CYAN = ESC + '[36m'
+    CLEAR = ESC + '[2J'

wizlib/ui/{shell_line_editor.py → shell/line_editor.py}

@@ -4,6 +4,8 @@ import re
 
 from readchar import readkey
 
+from wizlib.ui.shell import S
+
 
 if (sys.platform == "win32"):
     import ctypes
@@ -32,8 +34,8 @@ def cursorPos():  # pragma: nocover
         termios.tcsetattr(sys.stdin, termios.TCSAFLUSH, _)
     try:
         _ = ""
-        sys.stdout.write("\x1b[6n")
-        sys.stdout.flush()
+        sys.stdouS.write("\x1b[6n")
+        sys.stdouS.flush()
         while not (_ := _ + sys.stdin.read(1)).endswith('R'):
             True
         res = re.match(r".*\[(?P<y>\d*);(?P<x>\d*)R", _)
@@ -48,38 +50,13 @@ def cursorPos():  # pragma: nocover
     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 = ' -_.,'
-SPACE = ' '
-
-
 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.
+# of) user-typed texS.
 #
 # States:
 # - USER: User has typed something, so no fill
@@ -109,63 +86,63 @@ class ShellLineEditor:  # pragma: nocover
         self.fillstate = FillState.DEFAULT
 
     def edit(self):
-        write(RESET)
+        write(S.RESET)
         while True:
             self.write_fill()
             key = readkey()
             self.clear_fill()
-            if key == RETURN:
+            if key == S.RETURN:
                 break
             if key.isprintable():
-                write(BOLD + key + self.buf[self.pos:] +
-                      ('\b' * (len(self.buf) - self.pos)) + RESET)
+                write(S.BOLD + key + self.buf[self.pos:] +
+                      ('\b' * (len(self.buf) - self.pos)) + S.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:
+            elif (key in [S.BACKSPACE, S.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)
+            elif (key == S.BACKSPACE) and (self.pos > 0):
+                write(S.BOLD + '\b' + self.buf[self.pos:] + ' ' +
+                      ('\b' * (1 + len(self.buf) - self.pos)) + S.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:
+            elif key == S.LEFT and self.pos > 0:
                 self.move_left()
                 self.fillstate = FillState.USER
-            elif key == RIGHT and self.pos < len(self.buf):
+            elif key == S.RIGHT and self.pos < len(self.buf):
                 self.move_right()
                 self.fillstate = FillState.USER
-            elif key == BEGINNING and self.pos > 0:
+            elif key == S.BEGINNING and self.pos > 0:
                 self.move_beginning()
                 self.fillstate = FillState.USER
-            elif key == END and self.has_fill:
+            elif key == S.END and self.has_fill:
                 self.accept_fill()
                 self.fillstate = FillState.USER
-            elif key == END and self.pos < len(self.buf):
+            elif key == S.END and self.pos < len(self.buf):
                 self.move_end_buf()
                 self.fillstate = FillState.USER
-            elif key == TAB and (choices := self.valid_choices):
+            elif key == S.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:
+            elif key == S.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:
+            elif key == S.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):
+            elif key == S.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:
+            elif key == S.KILL:
                 chars = len(self.buf) - self.pos
                 write(' ' * chars + '\b' * chars)
                 self.buf = self.buf[:self.pos]
@@ -173,11 +150,11 @@ class ShellLineEditor:  # pragma: nocover
             else:
                 pass
         self.accept_fill()
-        write(RETURN)
+        write(S.RETURN)
         return self.buf
 
     def is_sep(self, pos):
-        return (self.buf[pos] in WORD_SEPARATORS)
+        return (self.buf[pos] in S.SEPARATORS)
 
     @property
     def has_fill(self):
@@ -185,16 +162,16 @@ class ShellLineEditor:  # pragma: nocover
 
     def accept_fill(self):
         if self.has_fill:
-            write(BOLD + self.fill + RESET)
+            write(S.BOLD + self.fill + S.RESET)
             self.buf += self.fill
             self.pos = len(self.buf)
 
     def move_left(self):
-        write(LEFT)
+        write(S.LEFT)
         self.pos -= 1
 
     def move_right(self):
-        write(RIGHT)
+        write(S.RIGHT)
         self.pos += 1
 
     def move_beginning(self):
@@ -208,7 +185,7 @@ class ShellLineEditor:  # pragma: nocover
     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)
+            write(S.FAINT + self.fill + '\b' * len(self.fill) + S.RESET)
 
     def clear_fill(self):
         if self.has_fill:
@@ -228,7 +205,7 @@ class ShellLineEditor:  # pragma: nocover
     @property
     def last_word(self):
         index = next((c for c in reversed(range(len(self.buf)))
-                     if self.buf[c] == SPACE), -1)
+                     if self.buf[c] == S.SPACE), -1)
         return self.buf[index+1:]
 
     @property

wizlib/ui/shell_ui.py

@@ -1,12 +1,22 @@
+from enum import StrEnum
 import sys
 
 from readchar import readkey
+
 from wizlib.rlinput import rlinput
-from wizlib.ui import UI
-from wizlib.ui.shell_line_editor import ShellLineEditor
+from wizlib.ui import UI, Chooser, Emphasis
+from wizlib.ui.shell.line_editor import ShellLineEditor
+from wizlib.ui.shell import S
 
 INTERACTIVE = sys.stdin.isatty()
 
+COLOR = {
+    Emphasis.INFO: S.BLUE,
+    Emphasis.GENERAL: S.CYAN,
+    Emphasis.PRINCIPAL: S.YELLOW,
+    Emphasis.ERROR: S.RED
+}
+
 
 class ShellUI(UI):
 
@@ -17,26 +27,41 @@ class ShellUI(UI):
 
     name = "shell"
 
-    def send(self, value: str):
+    def send(self, value: str = '', emphasis: Emphasis = Emphasis.GENERAL):
         """Output some text"""
+        sys.stderr.write(COLOR[emphasis] + value + S.RESET + '\n')
+        sys.stderr.flush()
+
+    def ask(self, value: str):
+        """Prompt for input"""
         if value:
-            print(value, file=sys.stderr)
+            sys.stderr.write(S.GREEN + value + S.RESET)
+            sys.stderr.flush()
 
-    def get_option_mini(self, chooser):
+    def get_option(self, chooser: 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)
-        if INTERACTIVE:
-            key = readkey()
-        else:
-            key = sys.stdin.read(1)
-        print(file=sys.stderr, flush=True)
-        return chooser.choice_by_key(key)
+        while True:
+            self.ask(chooser.prompt_string)
+            if INTERACTIVE:
+                key = readkey()
+            else:
+                key = sys.stdin.read(1)
+            out = chooser.default if key == '\n' else \
+                key if key.isprintable() else ''
+            choice = chooser.choice_by_key(key)
+            emphasis = Emphasis.ERROR if (
+                choice is None) else Emphasis.PRINCIPAL
+            self.send(out, emphasis=emphasis)
+            if choice is not None:
+                break
+        return choice
 
     def get_text(self, prompt='', choices=[], default=''):
         """Allow the user to input an arbitrary line of text, with possible tab
         completion"""
-        sys.stderr.write(prompt)
-        sys.stderr.flush()
-        value = ShellLineEditor(choices, default).edit()
+        self.ask(prompt)
+        if INTERACTIVE:
+            value = ShellLineEditor(choices, default).edit()
+        else:
+            value = input()
         return value

wizlib/ui_handler.py

@@ -15,9 +15,10 @@ class UIHandler(Handler):
     default = 'shell'
 
     @classmethod
-    def setup(cls, name=None):
-        def ui(uitype='shell'):
-            """Instead of instantiating the handler, return a new instance of
-            the chosen UI object."""
-            return UI.family_member('name', uitype)()
-        return ui
+    def setup(cls, uitype):
+        return UI.family_member('name', uitype)()
+
+    @classmethod
+    def fake(cls, val=None):
+        """Use mock_keys"""
+        return

wizlib/util.py

@@ -1,7 +1,7 @@
 from unittest.mock import Mock, patch
 
 
-RK = 'wizlib.ui.shell_line_editor.readkey'
+RK = 'wizlib.ui.shell.line_editor.readkey'
 
 
 def mock_keys(keys: str):

{wizlib-2.0.19.dist-info → wizlib-3.0.0.dist-info}/METADATA

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

wizlib-3.0.0.dist-info/RECORD

@@ -0,0 +1,20 @@
+wizlib/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+wizlib/app.py,sha256=O5126FXF2_JSGlHycMv3-ec7EfYI875wzuYsDrxq5ZI,3263
+wizlib/class_family.py,sha256=tORSVAaPeWTQMcz2DX-MQClj1GQR3vCmkALPXxHa_pk,4506
+wizlib/command.py,sha256=aiDYMBXuhKTwPN5xdv_qOrvxvXGibLnqxwQgW0aUVQo,1686
+wizlib/config_handler.py,sha256=hoDavSMiGM_7PAHI8XIwC8nxPWOZDk302ryyjluoLGg,2588
+wizlib/error.py,sha256=ypwdMOYhtgKWd48ccfOX8idmCXmm-Skwx3gkPwqJB3c,46
+wizlib/handler.py,sha256=Oz80aPhDyeY9tdppZ1dvtN-19JU5ydEDVW6jtppVoD4,446
+wizlib/parser.py,sha256=O34azN4ttVfwwAsza0hujxGxDpzc4xUEVAf26DXJS5g,1505
+wizlib/rlinput.py,sha256=l00Pa3rxNeY6LJgz8Aws_rTKoEchw33fuL8yqHF9_-o,1754
+wizlib/stream_handler.py,sha256=i1EgcBrDiYhFK-CI8At7JtUtMCNunJmSkJLSlili-as,663
+wizlib/super_wrapper.py,sha256=F834ytHqA7zegTD1ezk_uxlF9PLygh84wReuiqcI7BI,272
+wizlib/ui/__init__.py,sha256=JIFBvlqPpHyU6hnyXoherf9va1_ynFuDKlMnJn1SCm8,4249
+wizlib/ui/shell/__init__.py,sha256=sPrYe4bG_Xf7Nwssx_dqXVk9jeyYBFUjh4oLdlSOeRY,943
+wizlib/ui/shell/line_editor.py,sha256=frpsqU5NggcvEz3XeB8YyqgmlExlyx6K1CKPzvARtPk,7419
+wizlib/ui/shell_ui.py,sha256=qg7DRAYTkkIfe7BKCfclcaupA42YaAk2expIV1fSm40,2030
+wizlib/ui_handler.py,sha256=JoZadtw9DKAtGvHKP3_BJF2NaYqmcQYNdsY4PeRnOjg,634
+wizlib/util.py,sha256=x1SyL3iXot0ET2r8Jjb2ySTd_J-3Uu7J1b_CHvFgzew,156
+wizlib-3.0.0.dist-info/METADATA,sha256=t1ESltdsHBUdEP5dp4WR4VnWcYVxfLfPwULW57KPQRA,1780
+wizlib-3.0.0.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+wizlib-3.0.0.dist-info/RECORD,,

wizlib-2.0.19.dist-info/RECORD

@@ -1,19 +0,0 @@
-wizlib/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-wizlib/app.py,sha256=LCTfM4eQJOhPcmDOyHbr59IETLkU19WMSbigmUnQlO8,2919
-wizlib/class_family.py,sha256=EX1ZZmrmC2M-PV_iorHXCWqETE2thrwQE45RtHxojbs,4424
-wizlib/command.py,sha256=X6hytea4BVWl5cUN7QXqGarqCRjmFoBVdCAtxMNfWBo,1588
-wizlib/config_handler.py,sha256=alHpJzFY39XXDv94W4fLwda6hjruySADAJD944rE3HU,2639
-wizlib/error.py,sha256=ypwdMOYhtgKWd48ccfOX8idmCXmm-Skwx3gkPwqJB3c,46
-wizlib/handler.py,sha256=ddCO1h0llSRWMn5Wn952j8_Iad5D8CXDe0iboMzy8zs,693
-wizlib/input_handler.py,sha256=QFiR9CC5bkW7HofNAKZEq_hL089hbWzyrFGAjAjvozg,624
-wizlib/parser.py,sha256=O34azN4ttVfwwAsza0hujxGxDpzc4xUEVAf26DXJS5g,1505
-wizlib/rlinput.py,sha256=l00Pa3rxNeY6LJgz8Aws_rTKoEchw33fuL8yqHF9_-o,1754
-wizlib/super_wrapper.py,sha256=F834ytHqA7zegTD1ezk_uxlF9PLygh84wReuiqcI7BI,272
-wizlib/ui/__init__.py,sha256=55tzM_XphYFqm_jVxQc5vkfPLgD1Z3aqSjDl50GM44A,6139
-wizlib/ui/shell_line_editor.py,sha256=3YZmCskpJrp8Io-pBwLNF56uTG6IsBSCoiBPVUF79mI,7820
-wizlib/ui/shell_ui.py,sha256=UdlMzCB2zk5NHT6KFE6n7aAMrXRb9lEAuG_gEg8mscA,1289
-wizlib/ui_handler.py,sha256=nvMRuGVCwJ-_H59iZQ72--_tiiqXAsSHP7kYnd43P68,716
-wizlib/util.py,sha256=6crNn_nI5Ytx5yu4IzcmI0iCfwCWbCN5NOnPcrYKB1c,156
-wizlib-2.0.19.dist-info/METADATA,sha256=ctEkxTliADbtJvJWFaqYanjbESiJkep-2piMqlmHLjk,1781
-wizlib-2.0.19.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-wizlib-2.0.19.dist-info/RECORD,,