wizlib 3.0.1__tar.gz → 3.1.1__tar.gz

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

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

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

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

wizlib-3.1.1/wizlib/app.py

@@ -0,0 +1,112 @@
+from argparse import ArgumentError
+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 WizArgumentError, 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."""
+
+    # Name of this app, used in argparse (override)
+    name = ''
+
+    # Base command class, typically defined in command/__init__.py (override)
+    base = None
+
+    # List of Handler classes used by this app (override)
+    handlers = []
+
+    # 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:
+            cls.initialize()
+            try:
+                ns = cls.parser.parse_args(args)
+                if (ns.command is None) and (not hasattr(ns, 'help')):
+                    ns = cls.dparser.parse_args(args)
+            except ArgumentError as e:
+                ns = cls.dparser.parse_args(args)
+            app = cls(**vars(ns))
+            app.run(**vars(ns))
+        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):
+        """Set up the parser for the app class"""
+        cls.parser = WizParser(prog=cls.name)
+        subparsers = cls.parser.add_subparsers(dest='command')
+        for command in cls.base.family_members('name'):
+            key = command.get_member_attr('key')
+            aliases = [key] if key else []
+            subparser = subparsers.add_parser(command.name, aliases=aliases)
+            if command.name == cls.base.default:
+                cls.dparser = subparser
+            command.add_args(subparser)
+        for handler in cls.handlers:
+            handler.add_args(cls.parser)
+            handler.add_args(cls.dparser)
+
+    def __init__(self, **vals):
+        """Create the app. Only interested in the handlers from the parsed
+        values passed in"""
+        for hcls in self.handlers:
+            val = vals[hcls.name] if (hcls.name in vals) else hcls.default
+            handler = hcls.setup(val)
+            handler.app = self
+            setattr(self, hcls.name, handler)
+
+    def run(self, **vals):
+        """Perform a command. May be called more than once. Only interested in
+        the command itself and its specific arguments from the values passed
+        in."""
+        if 'help' in vals:
+            ccls = WizHelpCommand
+        else:
+            c = 'command'
+            cname = (vals.pop(c) if c in vals else None) or self.base.default
+            ccls = self.base.family_member('name', cname)
+            if not ccls:
+                raise Exception(f"Unknown command {cname}")
+        command = ccls(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-3.0.1 → wizlib-3.1.1}/wizlib/command.py

@@ -18,7 +18,6 @@ class WizCommand(ClassFamily, SuperWrapper):
     """Define all the args you want, but stdin always works."""
 
     status = ''
-    handlers = []  # TODO: Move to app
 
     @classmethod
     def add_args(self, parser):

{wizlib-3.0.1 → wizlib-3.1.1}/wizlib/parser.py

@@ -14,6 +14,8 @@ import sys
 import os
 
 
+# We found the help process a little clumsy
+
 class WizHelpAction(Action):
 
     def __init__(self,

{wizlib-3.0.1 → wizlib-3.1.1}/wizlib/ui/shell_ui.py

@@ -3,7 +3,6 @@ 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

wizlib-3.0.1/wizlib/app.py

@@ -1,98 +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
-
-
-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-3.0.1/wizlib/rlinput.py

@@ -1,71 +0,0 @@
-try:  # pragma: nocover
-    import gnureadline as readline
-except ImportError:  # pragma: nocover
-    import readline
-import sys
-
-
-# Use tab for completion
-readline.parse_and_bind('tab: complete')
-
-# Only a space separates words
-readline.set_completer_delims(' ')
-
-
-# Readline defaults to complete with local filenames. Definitely not what we
-# want.
-
-def null_complete(text, start):  # pragma: nocover
-    return None
-
-
-readline.set_completer(null_complete)
-
-
-def rlinput(prompt: str = "", default: str = "",
-            options: list = None):  # pragma: nocover
-    """
-    Get input with preset default and/or tab completion of options
-
-    Parameters:
-
-    prompt:str - string to output before requesting input, same as in the
-    input() function
-
-    default:str - value with which to prepopulate the response, can be cleared
-    with ctrl-a, ctrl-k
-
-    options:list - list of choices for tab completion
-    """
-
-    # Clean out the options
-    options = [o.strip() + " " for o in options] if options else []
-
-    # Create the completer using the options
-    def complete(text, state):
-        results = [x for x in options if x.startswith(text)] + [None]
-        return results[state]
-    readline.set_completer(complete)
-
-    # Insert the default when we launch
-    def start():
-        readline.insert_text(default)
-    readline.set_startup_hook(start)
-
-    # Actually perform the input
-    try:
-        value = input(prompt)
-    finally:
-        readline.set_startup_hook()
-        readline.set_completer(null_complete)
-    return value.strip()
-
-
-def tryit():  # pragma: nocover
-    """Quick and dirty tester function"""
-    return rlinput(prompt='>',
-                   options=['a-b', 'a-c', 'b-a'])
-
-
-if __name__ == '__main__':
-    tryit()