hspylib-clitt 0.9.120__py3-none-any.whl → 0.9.121__py3-none-any.whl

build/lib/build/lib/clitt/core/tui/minput/minput.py

@@ -1,44 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-
-"""
-   @project: HsPyLib
-   @package: clitt.core.tui.minput
-      @file: minput.py
-   @created: Tue, 4 May 2021
-    @author: <B>H</B>ugo <B>S</B>aporetti <B>J</B>unior"
-      @site: https://github.com/yorevs/hspylib
-   @license: MIT - Please refer to <https://opensource.org/licenses/MIT>
-
-   Copyright·(c)·2024,·HSPyLib
-"""
-from clitt.core.tui.minput.form_field import FormField
-from clitt.core.tui.minput.menu_input import MenuInput
-from hspylib.core.enums.charset import Charset
-from hspylib.core.namespace import Namespace
-from hspylib.core.preconditions import check_argument
-from hspylib.core.tools.text_tools import quote, snakecase
-from typing import List, Optional
-
-import os
-
-
-def minput(
-    form_fields: List[FormField], title: str = "Please fill all fields of the form fields below", output: str = None
-) -> Optional[Namespace]:
-    """
-    Terminal UI menu form input method.
-    :param form_fields: the provided form items to input from.
-    :param title: the title to be displayed before the form.
-    :param output: optional output file containing the marked items.
-    :return: a namespace containing all form values.
-    """
-    check_argument(len(form_fields) > 0, "Must provide at least one form field!")
-    result = MenuInput(title, form_fields).execute()
-
-    if result and output:
-        with open(output, "w", encoding=Charset.UTF_8.val) as f_out:
-            for name, value in zip(result.attributes, result.values):
-                f_out.write(f"{snakecase(name, screaming=True)}={quote(value)}" + os.linesep)
-
-    return result

build/lib/build/lib/clitt/core/tui/minput/minput_utils.py

@@ -1,156 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-
-"""
-   @project: HsPyLib
-   @package: clitt.core.tui.minput
-      @file: minput_utils.py
-   @created: Thu, 20 May 2021
-    @author: <B>H</B>ugo <B>S</B>aporetti <B>J</B>unior"
-      @site: https://github.com/yorevs/hspylib
-   @license: MIT - Please refer to <https://opensource.org/licenses/MIT>
-
-   Copyright·(c)·2024,·HSPyLib
-"""
-from clitt.core.term.screen import Screen
-from hspylib.core.exception.exceptions import InvalidInputError
-from typing import Any, Optional, Tuple
-
-import re
-
-MASK_SYMBOLS = ["#", "@", "%", "*"]
-
-VALUE_SEPARATORS = r"[|,;]"
-
-VALUE_SELECTORS = r"[<>]"
-
-
-def detail_len(field: Any) -> int:
-    """Return the length of the details, according to the form field.
-    :param field: the form field to get details.
-    """
-    max_len = len(str(field.max_length))
-    return 1 + (2 * max_len)
-
-
-def mi_print(screen: Screen, text: str, prefix: str = None, field_len: int = 0, end: str = "") -> None:
-    """Special menu input print.
-    :param screen: the component's screen.
-    :param text: the text to be printed.
-    :param prefix the text to print before the text.
-    :param field_len: the length of the field.
-    :param end: string appended after the last value, default an empty string.
-    """
-    fmt = ("{}" if prefix else "") + "{:<" + str(field_len) + "} : "
-    if prefix:
-        screen.cursor.write(fmt.format(prefix, text), end=end)
-    else:
-        screen.cursor.write(fmt.format(text or ""), end=end)
-
-
-def mi_print_err(screen: Screen, text: str) -> None:
-    """Special menu input print error message.
-    :param screen: the component's screen.
-    :param text: the text to be printed.
-    """
-    screen.cursor.write(f"%RED%{text}%NC%")
-
-
-def toggle_selected(tokenized_values: str) -> str:
-    """Toggle the 'select' component value. Selects the next value on the token sequence.
-    :param tokenized_values: the 'select' component tokenized values.
-    """
-    values = re.split(VALUE_SEPARATORS, tokenized_values)
-    cur_idx = next((idx for idx, val in enumerate(values) if val.find("<") >= 0), -1)
-    if cur_idx < 0:
-        if len(values) > 1:
-            values[1] = f"<{values[1]}>"
-        else:
-            values[0] = f"<{values[0]}>"
-        return "|".join(values)
-    unselected = list(map(lambda x: re.sub(VALUE_SELECTORS, "", x), values))
-    # fmt: off
-    return '|'.join([
-        f'<{val}>'
-        if idx == (cur_idx + 1) or ((cur_idx + 1) >= len(unselected) and idx == 0)
-        else val for idx, val in enumerate(unselected)
-    ])
-    # fmt: on
-
-
-def get_selected(tokenized_values: str) -> Optional[Tuple[int, str]]:
-    """Get the selected value from the 'select' component tokens.
-    :param tokenized_values: the 'select' component tokenized values.
-    """
-    values = re.split(VALUE_SEPARATORS, tokenized_values)
-    # fmt: off
-    sel_item = next((
-        re.sub(VALUE_SELECTORS, '', val)
-        for val in values if val.startswith('<') and val.endswith('>')
-    ), values[0])
-    # fmt: on
-    try:
-        return values.index(sel_item), sel_item
-    except ValueError:
-        try:
-            return values.index(f"<{sel_item}>"), sel_item
-        except ValueError:
-            return -1, sel_item
-
-
-def unpack_masked(value: str) -> Tuple[str, str]:
-    """Unpack all values of the 'masked' component.
-    :param value: the masked values to unpack.
-    """
-    if value:
-        parts = re.split(VALUE_SEPARATORS, value)
-        return parts[0], parts[1] if len(parts) == 2 else ""
-
-    return "", ""
-
-
-def append_masked(value: str, mask: str, keypress_value: chr) -> str:
-    """Append a value to the masked field.
-    :param value: the masked field current value.
-    :param mask: the masked field's mask.
-    :param keypress_value: the value to append (it can be a part of the mask itself).
-    """
-    idx = len(value)
-    masked_value = value
-    if idx < len(mask):
-        if keypress_value == mask[idx]:
-            return f"{value}{keypress_value}|{mask}"
-        while idx < len(mask) and mask[idx] not in MASK_SYMBOLS:
-            masked_value += mask[idx]
-            idx += 1
-        if mask and idx < len(mask):
-            mask_re = mask_regex(mask, idx)
-            if re.search(mask_re, keypress_value):
-                masked_value += keypress_value
-            else:
-                raise InvalidInputError(f"Value '{keypress_value}' is invalid. Expecting: {mask_re}")
-
-    return f"{masked_value}|{mask}"
-
-
-def over_masked(value: str, mask: str) -> str:
-    """
-    Return the value to be printed by a 'masked' input field. A placeholder value will be used for unfilled values.
-    :param value: the masked field current value.
-    :param mask: the masked field's mask.
-    """
-    if value:
-        over_masked_val = ""
-        for idx, element in enumerate(mask):
-            if element in MASK_SYMBOLS:
-                over_masked_val += value[idx] if idx < len(value) else mask[idx]
-            else:
-                over_masked_val += element
-        return over_masked_val
-
-    return mask
-
-
-def mask_regex(mask: str, idx: int) -> str:
-    """Return a regex matching the index of the mask."""
-    return mask[idx].replace("#", "[0-9]").replace("@", "[a-zA-Z]").replace("%", "[a-zA-Z0-9]").replace("*", ".")

build/lib/build/lib/clitt/core/tui/mselect/__init__.py

@@ -1,12 +0,0 @@
-# _*_ coding: utf-8 _*_
-#
-# hspylib-clitt v0.9.120
-#
-# Package: main.build.lib.build.lib.build.lib.clitt.core.tui.mselect
-"""Package initialization."""
-
-__all__ = [
-    'menu_select', 
-    'mselect'
-]
-__version__ = '0.9.120'

build/lib/build/lib/clitt/core/tui/mselect/menu_select.py

@@ -1,170 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-
-"""
-   @project: HsPyLib
-   @package: clitt.core.tui.mselect
-      @file: menu_select.py
-   @created: Wed, 17 May 2023
-    @author: <B>H</B>ugo <B>S</B>aporetti <B>J</B>unior"
-      @site: https://github.com/yorevs/hspylib
-   @license: MIT - Please refer to <https://opensource.org/licenses/MIT>
-
-   Copyright·(c)·2024,·HSPyLib
-"""
-from clitt.core.icons.font_awesome.nav_icons import NavIcons
-from clitt.core.term.commons import Direction, Portion
-from clitt.core.tui.tui_component import TUIComponent
-from hspylib.modules.cli.keyboard import Keyboard
-from typing import List, Optional, TypeAlias, TypeVar
-
-T = TypeVar("T")
-
-MSelectItems: TypeAlias = List[T]
-
-
-class MenuSelect(TUIComponent):
-    """Terminal UI menu select input method"""
-
-    NAV_ICONS = NavIcons.compose(NavIcons.UP, NavIcons.DOWN)
-
-    ROW_OFFSET = 5
-
-    MIN_ROWS = 3
-
-    def __init__(self, title: str, items: MSelectItems):
-        super().__init__(title)
-        self._items = items
-        self._show_from = 0
-        self._show_to = self._max_rows()
-        self._diff_index = self._show_to - self._show_from
-        self._sel_index = 0
-        self._max_line_length = max(len(str(item)) for item in items)
-
-    def execute(self) -> Optional[T]:
-        """Execute the component's main flow."""
-
-        if (length := len(self._items)) == 0:
-            return None
-        if length == 1:  # When only one option is provided, select the element at index 0 and return
-            return self._items[0]
-
-        self._prepare_render()
-        keypress = self._loop()
-
-        return self._items[self._sel_index] if keypress.isEnter() else None
-
-    def render(self) -> None:
-        """Renders the TUI component."""
-
-        length = len(self._items)
-        self.cursor.restore()
-        self.writeln(f"{self.prefs.title_color.placeholder}{self.title}%EOL%%NC%")
-
-        for idx in range(self._show_from, self._show_to):
-            if idx >= length:
-                break  # When the index is greater than the number of items, stop rendering
-
-            option_line = str(self._items[idx])
-            self.cursor.erase(Portion.LINE)
-            # Print the selector if the index is currently selected
-            selector = self.draw_selector(idx == self._sel_index)
-            # fmt: off
-            line_fmt = (
-                "  {:>" + f"{len(str(length))}" + "}  "
-                + "{:>" + f"{len(selector)}" + "}  "
-                + "{:<" + f"{self._max_line_length}" + "}  "
-            )
-            # fmt: on
-            self.draw_line(line_fmt, idx + 1, selector, option_line)
-
-        self.draw_navbar(self.navbar(to=length))
-        self._re_render = False
-
-    def navbar(self, **kwargs) -> str:
-        return (
-            f"%EOL%{self.prefs.navbar_color.placeholder}"
-            f"[Enter] Select  [{self.NAV_ICONS}] "
-            f"Navigate  [Esc] Quit  [1..{kwargs['to']}] Goto: %NC%"
-        )
-
-    def handle_keypress(self) -> Keyboard:
-        if keypress := Keyboard.wait_keystroke():
-            match keypress:
-                case _ as key if key in Keyboard.break_keys():
-                    self._done = True
-                case Keyboard.VK_UP:
-                    self._handle_key_up()
-                case Keyboard.VK_DOWN:
-                    self._handle_key_down()
-                case Keyboard.VK_TAB:
-                    self._handle_tab()
-                case Keyboard.VK_SHIFT_TAB:
-                    self._handle_shift_tab()
-                case _ as key if key in Keyboard.digits():
-                    self._handle_digit(keypress)
-
-        return keypress
-
-    def _handle_digit(self, digit: Keyboard) -> None:
-        """TODO"""
-        length = len(self._items)
-        typed_index = digit.value
-        self.cursor.write(f"{digit.value}")  # echo the digit typed
-        index_len = 1
-        while len(typed_index) < len(str(length)):
-            keystroke = Keyboard.wait_keystroke()
-            if not keystroke or not keystroke.isdigit():
-                typed_index = None if keystroke != Keyboard.VK_ENTER else typed_index
-                break
-            typed_index = f"{typed_index}{keystroke.value if keystroke else ''}"
-            self.cursor.write(f"{keystroke.value if keystroke else ''}")
-            index_len += 1
-        # Erase the index typed by the user
-        self.cursor.move(index_len, Direction.LEFT)
-        self.cursor.erase(Direction.RIGHT)
-        if typed_index and 1 <= int(typed_index) <= length:
-            self._show_to = max(int(typed_index), self._diff_index)
-            self._show_from = self._show_to - self._diff_index
-            self._sel_index = int(typed_index) - 1
-            self._re_render = True
-
-    def _handle_key_up(self) -> None:
-        """TODO"""
-        if self._sel_index == self._show_from and self._show_from > 0:
-            self._show_from -= 1
-            self._show_to -= 1
-        if self._sel_index - 1 >= 0:
-            self._sel_index -= 1
-            self._re_render = True
-
-    def _handle_key_down(self) -> None:
-        """TODO"""
-        length = len(self._items)
-        if self._sel_index + 1 == self._show_to and self._show_to < length:
-            self._show_from += 1
-            self._show_to += 1
-        if self._sel_index + 1 < length:
-            self._sel_index += 1
-            self._re_render = True
-
-    def _handle_tab(self) -> None:
-        """TODO"""
-        length = len(self._items)
-        page_index = min(self._show_to + self._diff_index, length)
-        self._show_to = max(page_index, self._diff_index)
-        self._show_from = self._show_to - self._diff_index
-        self._sel_index = self._show_from
-        self._re_render = True
-
-    def _handle_shift_tab(self) -> None:
-        """TODO"""
-        page_index = max(self._show_from - self._diff_index, 0)
-        self._show_from = min(page_index, self._diff_index)
-        self._show_to = self._show_from + self._diff_index
-        self._sel_index = self._show_from
-        self._re_render = True
-
-    def _max_rows(self) -> int:
-        screen_lines = self.screen.lines - self.ROW_OFFSET
-        return min(self.prefs.max_rows, screen_lines)

build/lib/build/lib/clitt/core/tui/mselect/mselect.py

@@ -1,36 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-
-"""
-   @project: HsPyLib
-   @package: clitt.core.tui.mselect
-      @file: mselect.py
-   @created: Tue, 4 May 2021
-    @author: <B>H</B>ugo <B>S</B>aporetti <B>J</B>unior"
-      @site: https://github.com/yorevs/hspylib
-   @license: MIT - Please refer to <https://opensource.org/licenses/MIT>
-
-   Copyright·(c)·2024,·HSPyLib
-"""
-from clitt.core.tui.mselect.menu_select import MenuSelect
-from hspylib.core.enums.charset import Charset
-from typing import List, Optional, TypeVar
-
-T = TypeVar("T")
-
-
-def mselect(items: List[T], title: str = "Please select one", output: str = None) -> Optional[T]:
-    """
-    Terminal UI menu select input method.
-    :param items: the provided items to select from.
-    :param title: the title to be displayed before the options.
-    :param output: optional output file containing the selected item.
-    :return: the selected item.
-    """
-    result = MenuSelect(title, items).execute()
-
-    if result and output:
-        with open(output, "w", encoding=Charset.UTF_8.val) as f_out:
-            f_out.write(result)
-
-    return result

build/lib/build/lib/clitt/core/tui/table/__init__.py

@@ -1,12 +0,0 @@
-# _*_ coding: utf-8 _*_
-#
-# hspylib-clitt v0.9.120
-#
-# Package: main.build.lib.build.lib.build.lib.clitt.core.tui.table
-"""Package initialization."""
-
-__all__ = [
-    'table_enums', 
-    'table_renderer'
-]
-__version__ = '0.9.120'

build/lib/build/lib/clitt/core/tui/table/table_enums.py

@@ -1,47 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-
-"""
-   @project: HsPyLib
-   @package: clitt.core.tui.table
-      @file: table_enums.py
-   @created: Tue, 4 Jul 2023
-    @author: <B>H</B>ugo <B>S</B>aporetti <B>J</B>unior"
-      @site: https://github.com/yorevs/hspylib
-   @license: MIT - Please refer to <https://opensource.org/licenses/MIT>
-
-   Copyright·(c)·2024,·HSPyLib
-"""
-from enum import auto
-from hspylib.core.enums.enumeration import Enumeration
-from hspylib.core.tools import text_tools
-from typing import Callable
-
-
-class TextAlignment(Enumeration):
-    """Table cell/header text justification helper."""
-
-    # fmt: off
-    LEFT    = auto(), text_tools.justified_left
-    CENTER  = auto(), text_tools.justified_center
-    RIGHT   = auto(), text_tools.justified_right
-    # fmt: on
-
-    def val(self) -> Callable:
-        return self.value[1]
-
-
-class TextCase(Enumeration):
-    """Table cell/header text case helper."""
-
-    # fmt: off
-    TITLE   = auto(), text_tools.titlecase
-    SNAKE   = auto(), text_tools.snakecase
-    CAMEL   = auto(), text_tools.camelcase
-    KEBAB   = auto(), text_tools.kebabcase
-    LOWER   = auto(), text_tools.lowercase
-    UPPER   = auto(), text_tools.uppercase
-    # fmt: on
-
-    def val(self) -> Callable:
-        return self.value[1]