wizlib 3.2.0__py3-none-any.whl → 3.4.0__py3-none-any.whl

wizlib/config_handler.py

@@ -1,13 +1,16 @@
 from argparse import Namespace
+from functools import cached_property
 from pathlib import Path
 import os
 from dataclasses import dataclass
+import re
+import shlex
+import subprocess
 from unittest.mock import patch
 
-from yaml import load
-from yaml import Loader
-from wizlib.handler import Handler
+import yaml
 
+from wizlib.handler import Handler
 from wizlib.error import ConfigHandlerError
 from wizlib.parser import WizParser
 
@@ -24,14 +27,33 @@ class ConfigHandler(Handler):
 
     name = 'config'
 
-    def __init__(self, file=None):
+    @classmethod
+    def setup(cls, val):
+        """Allow for alternative setup, passing in an injected data value as a
+        dict, bypassing file loading, for testing. Possible long-term
+        alternative to .fake() below."""
+
+        if isinstance(val, str) or isinstance(val, Path):
+            return cls(file=val)
+        elif isinstance(val, dict) or isinstance(val, list):
+            return cls(data=val)
+
+    def __init__(self, file: str = None, data: dict = None):
+        """Initiatlize with either a yaml file path or a data block to inject
+        (for testing)"""
         self.file = file
+        self.injected_data = data
         self.cache = {}
 
-    @property
-    def yaml(self):
-        if hasattr(self, '_yaml'):
-            return self._yaml
+    @cached_property
+    def data(self):
+        """Returns the full set of configuration data, typically loaded from a
+        yaml file. Is cached in code."""
+
+        # If yaml_dict was provided, use it directly
+        if self.injected_data is not None:
+            return self.injected_data
+
         path = None
         if self.file:
             path = Path(self.file)
@@ -46,34 +68,41 @@ class ConfigHandler(Handler):
                 path = homepath
         if path:
             with open(path) as file:
-                self._yaml = load(file, Loader=Loader)
-                return self._yaml
+                data = yaml.safe_load(file)
+                return data
 
     @staticmethod
     def env(name):
         if (envvar := name.upper().replace('-', '_')) in os.environ:
             return os.environ[envvar]
 
-    def get(self, key: str):
-        """Return the value for the requested config entry"""
+    def get(self, data_path: str):
+        """Return the value for the requested config entry. If the value is a
+        string, evaluate it for shell-type expressions using $(...) syntax. Can
+        also return a dict or array. Note that the value returned is cached
+        against the data_path, so future calls may not address nested paths.
+
+        data_path: Hyphen-separated path through the yaml/dict hierarchy."""
 
         # If we already found the value, return it
-        if key in self.cache:
-            return self.cache[key]
+        if data_path in self.cache:
+            return self.cache[data_path]
 
         # Environment variables take precedence
-        if (result := self.env(key)):
-            self.cache[key] = result
+        if (result := self.env(data_path)):
+            self.cache[data_path] = result
             return result
 
-        # Otherwise look at the YAML
-        if (yaml := self.yaml):
-            split = key.split('-')
-            while (val := split.pop(0)) and (val in yaml):
-                yaml = yaml[val] if val in yaml else None
+        # Otherwise look at the YAML or injected data
+        if (data := self.data):
+            split = data_path.split('-')
+            while (key := split.pop(0)) and (key in data):
+                data = data[key] if key in data else None
                 if not split:
-                    self.cache[key] = yaml
-                    return yaml
+                    if isinstance(data, str):
+                        data = evaluate_string(data)
+                    self.cache[data_path] = data
+                    return data
 
     @classmethod
     def fake(cls, **vals):
@@ -81,3 +110,17 @@ class ConfigHandler(Handler):
         self = cls()
         self.cache = {k.replace('_', '-'): vals[k] for k in vals}
         return self
+
+
+def os_process(match):
+    """Run a subprocess in shell form"""
+    command_string = match.group(1).strip()
+    command = shlex.split(command_string)
+    result = subprocess.run(command, capture_output=True)
+    return result.stdout.decode().strip()
+
+
+def evaluate_string(yaml: str) -> str:
+    """Evaluate shell commands in string values"""
+    text = yaml.strip()
+    return re.sub(r'\$\((.*?)\)', os_process, text)

wizlib/io.py

@@ -6,22 +6,32 @@ import sys
 import readchar
 
 from wizlib.parser import WizArgumentError
+from wizlib.ui.shell import ESC
 
 
-ISATTY = all(s.isatty() for s in (sys.stdin, sys.stdout, sys.stderr))
+# Is it OK to read tty input? Patch this for testing
 
+TTY_OK = True
 
-def isatty():
-    return ISATTY
+# ISATTY = all(s.isatty() for s in (sys.stdin, sys.stdout, sys.stderr))
 
 
-def stream():
-    return '' if ISATTY else sys.stdin.read()
+# def isatty():
+#     return ISATTY
 
 
-def ttyin():
-    if ISATTY:
-        return readchar.readkey()
+# def stream():
+#     return '' if ISATTY else sys.stdin.read()
+
+
+def ttyin():  # pragma: nocover
+    """Read a character from the tty (via readchar). Patch this for testing."""
+    if TTY_OK:
+        key = readchar.readkey()
+        # Handle specialized escape sequences
+        if key == ESC + '[1;':
+            key = key + readchar.readkey() + readchar.readkey()
+        return key
     else:
         raise WizArgumentError(
             'Command designed for interactive use')

wizlib/stream_handler.py

@@ -1,6 +1,4 @@
-# In a non-interactive, non-testing mode, route input from stdin to the output.
-# When testing, read from the object provided (probably a StreamIO)
-
+import os
 from pathlib import Path
 import sys
 
@@ -10,33 +8,29 @@ import wizlib.io
 
 
 class StreamHandler(Handler):
-    """Handle non-interactive input, such as via a pipe in a shell. Only runs
-    when not in a tty."""
+    """Handle non-interactive input, such as via a pipe in a shell. Only
+    applies when not in a tty. Doesn't actually stream anything and should
+    probably be called PipedInputHandler in a future major upgrade."""
 
     name = 'stream'
-    text: str = ''
 
     def __init__(self, file=None):
-        self.file = file
-
-    def read(self):
-        """Play like a file, sorta"""
-        if self.file:
-            return Path(self.file).read_text()
+        if file:
+            self._text = Path(file).read_text()
+        elif sys.stdin.isatty():
+            self._text = ''
         else:
-            return wizlib.io.stream()
+            self._text = sys.stdin.read()
+            # Reset sys.stdin to tty for possible interactions
+            # if os.path.exists(os.ctermid()):
+            try:
+                sys.stdin = open(os.ctermid(), 'r')
+            except OSError:
+                pass
 
     @property
     def text(self):
-        """Legacy approach - deprecated"""
-        return self.read()
-
-    # def __str__(self):
-    #     return self.text
-
-    # @classmethod
-    # def fake(cls, value):
-    #     """Return a fake StreamHandler with forced values, for testing"""
-    #     handler = cls(stdin=False)
-    #     handler.text = value
-    #     return handler
+        return self._text
+    
+    def read(self):
+        return self.text

wizlib/test_case.py

@@ -9,7 +9,8 @@ class WizLibTestCase(TestCase):
     """Wrap your test cases in this class to use the patches correctly"""
 
     def setUp(self):
-        self.notty = patch('wizlib.io.isatty', Mock(return_value=False))
+        """Test cases should never use true interaction"""
+        self.notty = patch('wizlib.io.TTY_OK', False)
         self.notty.start()
 
     def tearDown(self):
@@ -18,13 +19,16 @@ class WizLibTestCase(TestCase):
     @staticmethod
     def patch_stream(val: str):
         """Patch stream input such as pipes for stream handler"""
-        mock = Mock(return_value=val)
-        return patch('wizlib.io.stream', mock)
+        # mock = Mock(return_value=val)
+        # return patch('wizlib.io.stream', mock)
+        # return patch('wizlib.stream_handler.StreamHandler.read', mock)
+        return patch('wizlib.stream_handler.StreamHandler.text', val)
 
     @staticmethod
-    def patch_ttyin(val: str):
+    def patch_ttyin(val:str='\n'):
         """Patch input typed by a user in shell ui"""
         mock = Mock(side_effect=val)
+        # mock = Mock(return_value = val)
         return patch('wizlib.io.ttyin', mock)
 
     @staticmethod

wizlib/ui/shell/__init__.py

@@ -38,3 +38,9 @@ class S(StrEnum):
     MAGENTA = ESC + '[35m'
     CYAN = ESC + '[36m'
     CLEAR = ESC + '[2J'
+
+    # Alternative keys that can be configured in a terminal emulator
+    CUSTOM_END = ESC + '[1;5C'
+    CUSTOM_BEGINNING = ESC + '[1;5D'
+    CUSTOM_RIGHTWORD = ESC + '[1;3C'
+    CUSTOM_LEFTWORD = ESC + '[1;3D'

wizlib/ui/shell/line_editor.py

@@ -5,47 +5,47 @@ import re
 from wizlib.ui.shell import S
 import wizlib.io
 
-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.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", _)
-    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)
+# 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.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", _)
+#     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 write(key):
@@ -92,10 +92,7 @@ class ShellLineEditor:  # pragma: nocover
             if key == S.RETURN:
                 break
             if key.isprintable():
-                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.write_key(key)
                 self.fillstate = FillState.USER
             elif (key in [S.BACKSPACE, S.KILL]) and self.has_fill:
                 # Backspace clears the fill
@@ -113,13 +110,13 @@ class ShellLineEditor:  # pragma: nocover
             elif key == S.RIGHT and self.pos < len(self.buf):
                 self.move_right()
                 self.fillstate = FillState.USER
-            elif key == S.BEGINNING and self.pos > 0:
+            elif (key in [S.BEGINNING, S.CUSTOM_BEGINNING]) and self.pos > 0:
                 self.move_beginning()
                 self.fillstate = FillState.USER
-            elif key == S.END and self.has_fill:
+            elif (key in [S.END, S.CUSTOM_END]) and self.has_fill:
                 self.accept_fill()
                 self.fillstate = FillState.USER
-            elif key == S.END and self.pos < len(self.buf):
+            elif (key in [S.END, S.CUSTOM_END]) and self.pos < len(self.buf):
                 self.move_end_buf()
                 self.fillstate = FillState.USER
             elif key == S.TAB and (choices := self.valid_choices):
@@ -128,13 +125,25 @@ class ShellLineEditor:  # pragma: nocover
             elif key == S.SHIFT_TAB and self.index > -1:
                 self.index = (self.index - 1) % len(self.valid_choices)
                 self.fillstate = FillState.TAB
-            elif key == S.LEFT_WORD and self.pos > 0:
+            elif (key in [S.LEFT_WORD, S.CUSTOM_LEFTWORD]) 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 == S.RIGHT_WORD and self.pos < len(self.buf):
+            elif (key in [S.RIGHT_WORD, S.CUSTOM_RIGHTWORD]) and self.has_fill:
+                fill = self.fill
+                self.fillstate = FillState.USER
+                while fill:
+                    char = fill[0]
+                    self.write_key(char)
+                    fill = fill[1:]
+                    if char in S.SEPARATORS:
+                        self.fillstate = FillState.TAB
+                        self.index = self.valid_choices.index(self.buf + fill)
+                        break
+            elif (key in [S.RIGHT_WORD, S.CUSTOM_RIGHTWORD]) 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):
@@ -151,6 +160,12 @@ class ShellLineEditor:  # pragma: nocover
         write(S.RETURN)
         return self.buf
 
+    def write_key(self, key):
+        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
+
     def is_sep(self, pos):
         return (self.buf[pos] in S.SEPARATORS)
 

wizlib/ui/shell_ui.py

@@ -4,6 +4,7 @@ import sys
 from wizlib.ui import UI, Chooser, Emphasis
 from wizlib.ui.shell.line_editor import ShellLineEditor
 from wizlib.ui.shell import S
+from wizlib.ui.text_wrapper import StreamingTextWrapper
 import wizlib.io
 
 COLOR = {
@@ -23,10 +24,35 @@ class ShellUI(UI):
 
     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 __init__(self):
+        super().__init__()
+        self._wrapper = None
+
+    def send(self, value: str = '', emphasis: Emphasis = Emphasis.GENERAL,
+             newline: bool = True, wrap: int = 0):
+        """Output some text
+
+        Args:
+            value: Text to output
+            emphasis: Color/emphasis style
+            newline: Whether to append a newline
+            wrap: Column width to wrap at (0 = no wrapping)
+        """
+        if wrap > 0:
+            # Initialize wrapper if needed or if width changed
+            if self._wrapper is None or self._wrapper.width != wrap:
+                self._wrapper = StreamingTextWrapper(
+                    width=wrap, output_stream=sys.stderr)
+
+            # Use streaming wrapper
+            self._wrapper.write_streaming(value, COLOR[emphasis])
+            if newline:
+                self._wrapper.write_newline()
+        else:
+            # Original behavior - no wrapping
+            end = '\n' if newline else ''
+            sys.stderr.write(COLOR[emphasis] + value + S.RESET + end)
+            sys.stderr.flush()
 
     def ask(self, value: str):
         """Prompt for input"""

wizlib/ui/text_wrapper.py

@@ -0,0 +1,103 @@
+"""
+Streaming text wrapper that provides word wrapping with backspace correction
+for a typewriter-like streaming experience.
+"""
+
+import sys
+from enum import Enum
+from wizlib.ui import Emphasis
+
+
+class StreamingTextWrapper:
+    """Handles streaming text output with word wrapping that uses backspace
+    to correct words that would overflow the line boundary.
+
+    Provides a typewriter-like streaming experience where characters are
+    written immediately, but words are moved to the next line if they
+    would overflow.
+    """
+
+    def __init__(self, width: int = 80, output_stream=None):
+        """Initialize the wrapper.
+
+        Args:
+            width: Column width to wrap at
+            output_stream: Stream to write to (defaults to sys.stderr)
+        """
+        self.width = width
+        self.output_stream = output_stream or sys.stderr
+        self._current_col = 0
+        self._word_buffer = []  # Buffer for current word being streamed
+
+    def _write_char(self, char: str, color_code: str = ''):
+        """Write a single character with optional color."""
+        if color_code:
+            self.output_stream.write(color_code + char + '\033[0m')
+        else:
+            self.output_stream.write(char)
+        self.output_stream.flush()
+
+    def _backspace_buffer(self):
+        """Backspace over the current word buffer."""
+        for _ in range(len(self._word_buffer)):
+            self.output_stream.write('\b \b')  # backspace, space, backspace
+        self.output_stream.flush()
+
+    def write_streaming(self, text: str, color_code: str = ''):
+        """Write text with streaming word wrapping.
+
+        Args:
+            text: Text to output
+            color_code: ANSI color code to apply
+        """
+        for char in text:
+            if char == '\n':
+                # Explicit newline - flush buffer and reset
+                self._word_buffer = []
+                self._write_char(char)
+                self._current_col = 0
+            elif char in ' \t':
+                # Word boundary - write the space and clear buffer
+                self._word_buffer = []
+                self._write_char(char, color_code)
+                self._current_col += 1
+            else:
+                # Regular character - add to buffer and write immediately
+                self._word_buffer.append(char)
+                self._write_char(char, color_code)
+                self._current_col += 1
+
+                # Check if this character pushed us over the width
+                if self._current_col > self.width:
+                    # Only backspace and wrap if the word can fit on a new line
+                    # If the word itself is longer than width, let it continue
+                    if len(self._word_buffer) <= self.width:
+                        # We've gone over - backspace the whole current word
+                        self._backspace_buffer()
+                        self._current_col -= len(self._word_buffer)
+
+                        # Write newline
+                        self._write_char('\n')
+                        self._current_col = 0
+
+                        # Rewrite word on new line
+                        for c in self._word_buffer:
+                            self._write_char(c, color_code)
+                            self._current_col += 1
+
+    def write_newline(self):
+        """Write a newline and reset position."""
+        self.output_stream.write('\n')
+        self.output_stream.flush()
+        self._current_col = 0
+        self._word_buffer = []
+
+    def reset_position(self):
+        """Reset the column position (useful for explicit positioning)."""
+        self._current_col = 0
+        self._word_buffer = []
+
+    @property
+    def current_column(self):
+        """Get the current column position."""
+        return self._current_col

wizlib-3.4.0.dist-info/METADATA

@@ -0,0 +1,27 @@
+Metadata-Version: 2.4
+Name: wizlib
+Version: 3.4.0
+Summary: Framework for flexible and powerful command-line applications
+License: MIT
+Author: Steampunk Wizard
+Author-email: wizlib@steampunkwizard.ca
+Requires-Python: >=3.11,<4.0
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Dist: PyYAML (>=6.0.1,<7.0.0)
+Requires-Dist: readchar (>=4.0.5,<5.0.0)
+Description-Content-Type: text/markdown
+
+
+# WizLib
+
+Build configurable CLI tools easily in Python (a framework)
+
+<a style="font-weight: bold; font-size: 1.2em;" href="https://wizlib.steamwiz.io">Documentation on SteamWiz.io</a>
+
+<a style="font-weight: 300; font-size: 0.8em;" href="https://www.flaticon.com/free-icons/wizard" title="wizard icons">Wizard icon by Freepik-Flaticon</a>
+

wizlib-3.4.0.dist-info/RECORD

@@ -0,0 +1,21 @@
+wizlib/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+wizlib/app.py,sha256=ke0NbaYC6ArmdtLTySl6VIGIGicxTsIuzW9wag6b7rU,4180
+wizlib/class_family.py,sha256=tORSVAaPeWTQMcz2DX-MQClj1GQR3vCmkALPXxHa_pk,4506
+wizlib/command.py,sha256=NO1558EYuXxfkpSmX6ljjzae8n8g4w6yytZKTJtigvo,1708
+wizlib/config_handler.py,sha256=jKQV-6iP3V3XLx-swLWUmuAaMHsFp9DN_dd6dMeaBhk,4301
+wizlib/error.py,sha256=ypwdMOYhtgKWd48ccfOX8idmCXmm-Skwx3gkPwqJB3c,46
+wizlib/handler.py,sha256=Oz80aPhDyeY9tdppZ1dvtN-19JU5ydEDVW6jtppVoD4,446
+wizlib/io.py,sha256=MWzqqXdmWmOsLs7n2KTcDodNd5YbfHMl5WuVoqsRm0Y,875
+wizlib/parser.py,sha256=yLHV0fENeApFomCRWa3I6sB1x4lk1ag4vKejWVsic64,1550
+wizlib/stream_handler.py,sha256=M8uZkzMFYCEmobq3Ji9S0Z-9fYA8v997oMyax110pAc,963
+wizlib/super_wrapper.py,sha256=msitlfFfEwnrskzTtQBEY975sh9TQPicdLVo67imuqU,315
+wizlib/test_case.py,sha256=-hhrkXST465PTr7CZfztjFD5OXoW60HeFRxV5WHsdN0,1250
+wizlib/ui/__init__.py,sha256=ve_p_g4aBujh4jIJMgKkJ6cE5PT0aeY5AgRlneDswGg,4241
+wizlib/ui/shell/__init__.py,sha256=zT_GjUpKRWAbZ_0rwbHL580vlaKLMesTDdvDApiuKDU,1154
+wizlib/ui/shell/line_editor.py,sha256=l3iPtmYsavBGnQXoV-UHMWfzUqOfsNID6-ySpTF3SIc,8163
+wizlib/ui/shell_ui.py,sha256=zsqmfL5LTnH_yqfqHUmBKhkZdb5cjRWL96vmfTrAn3U,2855
+wizlib/ui/text_wrapper.py,sha256=WYL59E9cMRv0gI2Yhrc5GJTvstRZO86uYUD7lmDiwjM,3812
+wizlib/ui_handler.py,sha256=JoZadtw9DKAtGvHKP3_BJF2NaYqmcQYNdsY4PeRnOjg,634
+wizlib-3.4.0.dist-info/METADATA,sha256=h-cK4RnxEsEfWip8YnSD7Q14FIBN43fswcO6tUuT6u8,995
+wizlib-3.4.0.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
+wizlib-3.4.0.dist-info/RECORD,,

{wizlib-3.2.0.dist-info → wizlib-3.4.0.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 1.9.1
+Generator: poetry-core 2.2.1
 Root-Is-Purelib: true
 Tag: py3-none-any

wizlib-3.2.0.dist-info/METADATA

@@ -1,45 +0,0 @@
-Metadata-Version: 2.1
-Name: wizlib
-Version: 3.2.0
-Summary: Framework for flexible and powerful command-line applications
-License: MIT
-Author: Steampunk Wizard
-Author-email: wizlib@steampunkwizard.ca
-Requires-Python: >=3.11,<3.12
-Classifier: License :: OSI Approved :: MIT License
-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
-
-A framework for command-line devops and personal productivity tools
-
-WizLib wraps the built-in ArgumentParser with a set of functions, classes, and conventions that enables:
-
-- Easy addition of loosely coupled new subcommands
-- Unified access to configuration files with a normalized approach
-- Standardized use of stdin, stdout, and stderr
-- Plugin-type system for handling alternate UIs (such as curses or even a web UI)
-- Usable completion support for user input
-- Abstracts some of the argparse complexity
-- Applies conventions to application code structure
-- Supports test-driven development and CICD
-
-## Getting started
-
-- [Home page](https://wizlib.ca) with documentation
-- [Sample project](https://gitlab.com/wizlib/sample) to get started
-- [Related projects](https://gitlab.com/wizlib) for real-world examples
-
----
-
-Logo by [Freepik](https://www.freepik.com/?_gl=1*1y9rvc9*test_ga*Mjc1MTIzODYxLjE2ODA3OTczNTg.*test_ga_523JXC6VL7*MTY4MDc5NzM1OC4xLjEuMTY4MDc5NzQxNS4zLjAuMA..*fp_ga*Mjc1MTIzODYxLjE2ODA3OTczNTg.*fp_ga_1ZY8468CQB*MTY4MDc5NzM1OC4xLjEuMTY4MDc5NzQxNS4zLjAuMA..)
-
-

wizlib-3.2.0.dist-info/RECORD

@@ -1,20 +0,0 @@
-wizlib/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-wizlib/app.py,sha256=ke0NbaYC6ArmdtLTySl6VIGIGicxTsIuzW9wag6b7rU,4180
-wizlib/class_family.py,sha256=tORSVAaPeWTQMcz2DX-MQClj1GQR3vCmkALPXxHa_pk,4506
-wizlib/command.py,sha256=NO1558EYuXxfkpSmX6ljjzae8n8g4w6yytZKTJtigvo,1708
-wizlib/config_handler.py,sha256=hoDavSMiGM_7PAHI8XIwC8nxPWOZDk302ryyjluoLGg,2588
-wizlib/error.py,sha256=ypwdMOYhtgKWd48ccfOX8idmCXmm-Skwx3gkPwqJB3c,46
-wizlib/handler.py,sha256=Oz80aPhDyeY9tdppZ1dvtN-19JU5ydEDVW6jtppVoD4,446
-wizlib/io.py,sha256=vZ1pIMtPFUZxbOv10HFDezEmlPgwPlUVP6RPwtfM9ec,506
-wizlib/parser.py,sha256=yLHV0fENeApFomCRWa3I6sB1x4lk1ag4vKejWVsic64,1550
-wizlib/stream_handler.py,sha256=7y1ckUoqTXxaCFI-XEixdBFZQZDxOv2jEEwtjWHZsUA,1066
-wizlib/super_wrapper.py,sha256=msitlfFfEwnrskzTtQBEY975sh9TQPicdLVo67imuqU,315
-wizlib/test_case.py,sha256=T5cX7yWy94hf8JuherDeBCH9Gve5tx2x_PZOte4udC0,1017
-wizlib/ui/__init__.py,sha256=ve_p_g4aBujh4jIJMgKkJ6cE5PT0aeY5AgRlneDswGg,4241
-wizlib/ui/shell/__init__.py,sha256=sPrYe4bG_Xf7Nwssx_dqXVk9jeyYBFUjh4oLdlSOeRY,943
-wizlib/ui/shell/line_editor.py,sha256=vXXsCS_i4ZCjP0su2X9W_yD1CS6MiazPAtxpiaXQ6Jc,7413
-wizlib/ui/shell_ui.py,sha256=jre7E_5vP_SceNH7GYenfXZpFf4h9Sbh9cWZZycTYk8,1911
-wizlib/ui_handler.py,sha256=JoZadtw9DKAtGvHKP3_BJF2NaYqmcQYNdsY4PeRnOjg,634
-wizlib-3.2.0.dist-info/METADATA,sha256=rKb5cRkQEpv_YjanZXOcPoGyDAz_86TjB67UNor42IM,1779
-wizlib-3.2.0.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
-wizlib-3.2.0.dist-info/RECORD,,