hspylib-clitt 0.9.118__py3-none-any.whl → 0.9.119__py3-none-any.whl

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

@@ -0,0 +1,44 @@
+#!/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/build/lib/clitt/core/tui/minput/minput_utils.py

@@ -0,0 +1,156 @@
+#!/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/build/lib/clitt/core/tui/mselect/__init__.py

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

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

@@ -0,0 +1,170 @@
+#!/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/build/lib/clitt/core/tui/mselect/mselect.py

@@ -0,0 +1,36 @@
+#!/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/build/lib/clitt/core/tui/table/__init__.py

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

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

@@ -0,0 +1,47 @@
+#!/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]