wizlib 2.0.19__tar.gz → 3.0.1__tar.gz

{wizlib-2.0.19 → wizlib-3.0.1}/PKG-INFO

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

{wizlib-2.0.19 → wizlib-3.0.1}/pyproject.toml

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

wizlib-3.0.1/wizlib/app.py

@@ -0,0 +1,98 @@
+import sys
+from dataclasses import dataclass
+import os
+from pathlib import Path
+
+from wizlib.class_family import ClassFamily
+from wizlib.command import WizHelpCommand
+from wizlib.super_wrapper import SuperWrapper
+from wizlib.parser import WizParser
+from wizlib.ui import UI
+
+
+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."""
+
+    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.start(*sys.argv[1:], debug=os.getenv('DEBUG'))
+
+    @classmethod
+    def start(cls, *args, debug=False):
+        """Call this from a Python entrypoint"""
+        try:
+            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:
+                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, **vals):
+        """Converts argparse values (strings) into actual handlers and
+        instantiates the app"""
+        handlers = {}
+        for handler in cls.base_command.handlers:
+            val = vals[handler.name] if (
+                handler.name in vals) else handler.default
+            handlers[handler.name] = handler.setup(val)
+        return cls(**handlers)
+
+    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 run(self, *args):
+        vals = vars(self.parser.parse_args(args))
+        if 'help' in vals:
+            return WizHelpCommand(**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-2.0.19 → wizlib-3.0.1}/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-2.0.19 → wizlib-3.0.1}/wizlib/command.py

@@ -1,19 +1,24 @@
+# Note that commands once used dataclass, but no longer.
+
 from argparse import ArgumentParser
 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."""
 
     status = ''
-    handlers = []
-    ui: UI = None
+    handlers = []  # TODO: Move to app
 
     @classmethod
     def add_args(self, parser):
@@ -21,12 +26,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 +46,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-2.0.19 → wizlib-3.0.1}/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-3.0.1/wizlib/handler.py

@@ -0,0 +1,24 @@
+from argparse import Action
+
+from wizlib.parser import WizParser
+
+
+class Handler:
+    """Base class for handlers"""
+
+    default = ''
+    app = None
+
+    @classmethod
+    def add_args(cls, parser: WizParser):
+        parser.add_argument(
+            f"--{cls.name}",
+            f"-{cls.name[0]}",
+            default=cls.default)
+
+    @classmethod
+    def setup(cls, val):
+        return cls(val)
+
+    def __init__(self, val=None):
+        pass

wizlib-2.0.19/wizlib/input_handler.py → wizlib-3.0.1/wizlib/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-2.0.19 → wizlib-3.0.1}/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
@@ -119,81 +127,19 @@ class Chooser(Prompt):
         self.choices.append(choice)
 
     def choice_by_key(self, key):
-        if key == '\n':
-            choice = self.default
+        if key == '\n' and self.default:
+            choice = self.choices[0].value
         else:
             choice = next(
                 (o.value for o in self.choices if key in o.keys), None)
-        return choice() if callable(choice) else choice
+        return choice
 
     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-3.0.1/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-2.0.19/wizlib/ui/shell_line_editor.py → wizlib-3.0.1/wizlib/ui/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-3.0.1/wizlib/ui/shell_ui.py

@@ -0,0 +1,67 @@
+from enum import StrEnum
+import sys
+
+from readchar import readkey
+
+from wizlib.rlinput import rlinput
+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):
+
+    """The UI to execute one command passed in through the shell. There will be
+    limited interactivity, if the user omits an argument on the command line,
+    but otherwise this is a run and done situation.
+    """
+
+    name = "shell"
+
+    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:
+            sys.stderr.write(S.GREEN + value + S.RESET)
+            sys.stderr.flush()
+
+    def get_option(self, chooser: Chooser):
+        """Get a choice from the user with a single keystroke"""
+        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() if callable(choice) else choice
+
+    def get_text(self, prompt='', choices=[], default=''):
+        """Allow the user to input an arbitrary line of text, with possible tab
+        completion"""
+        self.ask(prompt)
+        if INTERACTIVE:
+            value = ShellLineEditor(choices, default).edit()
+        else:
+            value = input()
+        return value

{wizlib-2.0.19 → wizlib-3.0.1}/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-2.0.19 → wizlib-3.0.1}/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/wizlib/app.py

@@ -1,88 +0,0 @@
-import sys
-from dataclasses import dataclass
-import os
-from pathlib import Path
-
-from wizlib.class_family import ClassFamily
-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 WizApp:
-    """Root of all WizLib-based CLI applications. Subclass it. Can be
-    instantiated and then run multiple commands."""
-
-    base_command = None
-    name = ''
-
-    @classmethod
-    def main(cls):  # pragma: nocover
-        """Call this from a __main__ entrypoint"""
-        cls.run(*sys.argv[1:], debug=os.getenv('DEBUG'))
-
-    @classmethod
-    def run(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:
-            if debug:
-                raise error
-            else:
-                print(f"\n{RED}{type(error).__name__}: " +
-                      f"{error}{RESET}\n", 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)
-        for handler in cls.base_command.handlers:
-            cls.parser.add_argument(
-                f"--{handler.name}",
-                f"-{handler.name[0]}",
-                **handler.option_properties(cls))
-
-        subparsers = cls.parser.add_subparsers(dest='command')
-        for command in cls.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"""
-        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)

wizlib-2.0.19/wizlib/handler.py

@@ -1,25 +0,0 @@
-from argparse import Action
-
-
-class Handler:
-    """Base class for handlers"""
-
-    appname = None
-    default = ''
-
-    @classmethod
-    def option_properties(cls, app):
-        """Argparse keyword arguments for this optional arg"""
-        return {
-            'type': cls.setup(app.name),
-            '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

wizlib-2.0.19/wizlib/ui/shell_ui.py

@@ -1,42 +0,0 @@
-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()
-
-
-class ShellUI(UI):
-
-    """The UI to execute one command passed in through the shell. There will be
-    limited interactivity, if the user omits an argument on the command line,
-    but otherwise this is a run and done situation.
-    """
-
-    name = "shell"
-
-    def send(self, value: str):
-        """Output some text"""
-        if value:
-            print(value, file=sys.stderr)
-
-    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)
-        if INTERACTIVE:
-            key = readkey()
-        else:
-            key = sys.stdin.read(1)
-        print(file=sys.stderr, flush=True)
-        return chooser.choice_by_key(key)
-
-    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()
-        return value