wizlib 2.0.10__tar.gz → 2.0.12__tar.gz

{wizlib-2.0.10 → wizlib-2.0.12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: wizlib
-Version: 2.0.10
+Version: 2.0.12
 Summary: Framework for flexible and powerful command-line applications
 License: MIT
 Author: Steampunk Wizard
@@ -11,7 +11,9 @@ Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.11
 Requires-Dist: PyYAML (>=6.0.1,<7.0.0)
 Requires-Dist: gnureadline (>=8.1.2,<9.0.0) ; sys_platform == "darwin"
+Requires-Dist: myst-parser (>=2.0.0,<3.0.0)
 Requires-Dist: pyreadline3 (>=3.4.1,<4.0.0) ; sys_platform == "win32"
+Requires-Dist: readchar (>=4.0.5,<5.0.0)
 Description-Content-Type: text/markdown
 
 # WizLib

{wizlib-2.0.10 → wizlib-2.0.12}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "wizlib"
-version = "2.0.10"
+version = "2.0.12"
 description = "Framework for flexible and powerful command-line applications"
 authors = ["Steampunk Wizard <wizlib@steampunkwizard.ca>"]
 license = "MIT"
@@ -11,18 +11,16 @@ python = ">=3.11,<3.12"
 PyYAML = "^6.0.1"
 pyreadline3 = { version="^3.4.1", markers="sys_platform=='win32'" }
 gnureadline = { version="^8.1.2", markers="sys_platform=='darwin'" }
+myst-parser = "^2.0.0"
+readchar = "^4.0.5"
 
 [tool.poetry.group.dev.dependencies]
 coverage = "^7.3.1"
 pycodestyle = "^2.11.0"
 autopep8 = "^2.0.4"
+sphinx = "^7.2.6"
+sphinx-bootstrap-theme = "^0.8.1"
 
 [build-system]
 requires = ["poetry-core"]
 build-backend = "poetry.core.masonry.api"
-
-[tool.poetry-dynamic-versioning]
-enable = false
-vcs = "git"
-format = "{base}"
-

{wizlib-2.0.10 → wizlib-2.0.12}/wizlib/app.py

@@ -7,6 +7,8 @@ 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'
@@ -31,7 +33,6 @@ class WizApp:
         try:
             cls.initialize()
             app = cls(*args)
-            # if app.ready:
             command = app.first_command
             result = command.execute()
             if result:
@@ -58,8 +59,8 @@ class WizApp:
             cls.parser.add_argument(
                 f"--{handler.name}",
                 f"-{handler.name[0]}",
-                type=handler.named(cls.name),
-                default='')
+                **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')
@@ -68,12 +69,15 @@ class WizApp:
             command.add_args(subparser)
 
     def __init__(self, *args):
+        self.shell = ShellUI()
         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):
-        """Run a single command"""
+        """Returns a single command"""
         if 'help' in vals:
             return WizHelpCommand(**vals)
         else:

{wizlib-2.0.10 → wizlib-2.0.12}/wizlib/command.py

@@ -5,6 +5,7 @@ from wizlib.class_family import ClassFamily
 from wizlib.config_handler import ConfigHandler
 from wizlib.input_handler import InputHandler
 from wizlib.super_wrapper import SuperWrapper
+from wizlib.ui import UI
 
 
 class WizCommand(ClassFamily, SuperWrapper):
@@ -12,6 +13,7 @@ class WizCommand(ClassFamily, SuperWrapper):
 
     status = ''
     handlers = []
+    ui: UI = None
 
     @classmethod
     def add_args(self, parser):
@@ -31,6 +33,13 @@ class WizCommand(ClassFamily, SuperWrapper):
         this and call super().handle_vals()."""
         pass
 
+    def provided(self, argument):
+        """Was an argument provided?"""
+        value = None
+        if hasattr(self, argument):
+            value = getattr(self, argument)
+        return True if (value is False) else bool(value)
+
     def execute(self, method, *args, **kwargs):
         """Actually perform the command - override and wrap this via
         SuperWrapper"""

{wizlib-2.0.10 → wizlib-2.0.12}/wizlib/handler.py

@@ -6,6 +6,14 @@ class Handler:
 
     appname = None
 
+    @classmethod
+    def option_properties(cls, app):
+        """Argparse keyword arguments for this optional arg"""
+        return {
+            'type': cls.named(app.name),
+            'default': ''
+        }
+
     @classmethod
     def named(cls, name):
         """Subclass of the handler that holds the app name as a closure"""

{wizlib-2.0.10 → wizlib-2.0.12}/wizlib/input_handler.py

@@ -3,6 +3,8 @@ import sys
 
 from wizlib.handler import Handler
 
+INTERACTIVE = sys.stdin.isatty()
+
 
 class InputHandler(Handler):
 
@@ -12,7 +14,7 @@ class InputHandler(Handler):
     def __init__(self, file=None, stdin=True):
         if file:
             self.text = Path(file).read_text()
-        elif stdin and (not sys.stdin.isatty()):
+        elif stdin and (not INTERACTIVE):
             self.text = sys.stdin.read()
 
     def __str__(self):

wizlib-2.0.12/wizlib/ui/__init__.py

@@ -0,0 +1,182 @@
+# Abstract classes for UIs. The idea here is to allow many different user
+# interfaces (shell, curses, Slack, etc) to drive the same data model without
+# the data model needing specific UI knowledge.
+#
+# 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.
+
+#
+# UI end classes must implement the following interface:
+#
+# __init__(handler): Takes the handler and hangs on to it. Implemented in the
+# main base class.
+#
+# start(): No arguments. Actually performs the operation of the UI. It might be
+# short running (in the case of a shell UI) or long-running (in the case of an
+# interactive UI).
+#
+# output(intro=""): Output some multi-line text explaining an action, usually a
+# list of items being acted upon.
+#
+# get_string(prompt, default=""): For arguments that are omitted, get a string
+# from the user. The prompt is just a word (like "Description") telling the
+# user what to input.
+#
+# get_confirmation(verb): For delete-oriented commands to confirm with the user
+# before proceeding. Verb is what we're asking the user to confirm. Description
+# can be multiple lines, as with get_string. Returns a boolean saying whether
+# the action is confirmed.
+
+import os
+import re
+import shutil
+import subprocess
+from dataclasses import dataclass, field
+from enum import Enum
+from io import StringIO
+from pathlib import Path
+from tempfile import NamedTemporaryFile
+
+from wizlib.class_family import ClassFamily
+
+
+@dataclass
+class Choice:
+    """One option of several"""
+
+    keys: list[str] = field(default_factory=list)
+    words: list[str] = field(default_factory=list)
+    action: object = None
+
+    @property
+    def key(self):
+        return self.keys[0]
+
+    @property
+    def word(self):
+        return self.words[0]
+
+    def hit_key(self, key):
+        return key in self.keys
+
+    def hit_word(self, word):
+        return word in self.words
+
+    def value(self):
+        return self.word if (self.action is None) else self.action
+
+    # def call(self, *args, **kwargs):
+    #     if callable(self.action):
+    #         return self.action(*args, **kwargs)
+
+
+@dataclass
+class Prompt:
+    """Tell the user what kind of input to provide"""
+
+    intro: str = ""
+    default: str = ""
+    choices: list = field(default_factory=list)
+
+    @property
+    def prompt_string(self):
+        """Simple prompt string for stdio, no colours"""
+        result = []
+        if self.intro:
+            result.append(self.intro)
+        if self.default:
+            result.append(f"[{self.default}]")
+        for choice in self.choices:
+            if choice.word == self.default:
+                continue
+            pre, it, post = choice.word.partition(choice.key)
+            result.append(f"{pre}({it}){post}")
+        return " ".join(result) + ": "
+
+
+@dataclass
+class Chooser(Prompt):
+    """Hold a set of choices and get the result"""
+
+    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)
+
+    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 an abstract method
+#     def get_option(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

wizlib-2.0.12/wizlib/ui/shell_ui.py

@@ -0,0 +1,31 @@
+import sys
+
+from readchar import readkey
+from wizlib.rlinput import rlinput
+from wizlib.ui import UI
+
+
+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(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 sys.stdin.isatty():
+            key = readkey()
+        else:
+            key = input()
+        print(file=sys.stderr, flush=True)
+        return chooser.choice_by_key(key)

wizlib-2.0.12/wizlib/ui_handler.py

@@ -0,0 +1,32 @@
+from pathlib import Path
+import sys
+
+from wizlib.handler import Handler
+from wizlib.ui import UI
+
+# INTERACTIVE = sys.stdin.isatty()
+
+
+class UIHandler(Handler):
+    """A sort of proxy-handler for the UI class family, which drives user
+    interactions (if any) during and between command execution. In this case,
+    the handler only contains class-level methods, because the action actually
+    returns the UI itself for the command to use."""
+
+    name = 'ui'
+
+    @classmethod
+    def option_properties(cls, app):
+        """Argparse keyword arguments for this optional arg"""
+        return {
+            # 'choices': ['shell'],
+            'default': 'shell',
+            'help': 'Only option currently is "shell" (the default)',
+            'type': cls.ui
+        }
+
+    @classmethod
+    def ui(cls, uitype):
+        """Instead of instantiating the handler, return the chosen UI
+        object."""
+        return UI.family_member('name', uitype)()