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

build/lib/build/lib/build/lib/build/lib/clitt/core/tui/menu/tui_menu_ui.py

@@ -1,98 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-
-"""
-   @project: HsPyLib
-   @package: clitt.core.tui.menu
-      @file: tui_menu_ui.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.term.terminal import Terminal
-from clitt.core.tui.menu.tui_menu import TUIMenu
-from clitt.core.tui.tui_preferences import TUIPreferences
-from hspylib.core.metaclass.singleton import Singleton
-from hspylib.core.preconditions import check_not_none
-
-
-class TUIMenuUi(metaclass=Singleton):
-    """Provide a menu for terminal UIs. Each sub-item must belong to the TUIMenu class and can be an instance of
-    TUIMenuItem, TUIMenuAction or TUIMenuView.
-    """
-
-    APP_TITLE = "Main Menu"
-
-    # fmt: off
-    PREFS = TUIPreferences.INSTANCE
-
-    SCREEN = Terminal.INSTANCE.screen
-
-    MENU_LINE = f"{'--' * PREFS.title_line_length}"
-
-    MENU_TITLE_FMT = (
-        f"{PREFS.title_color}"
-        f"+{MENU_LINE}+%EOL%"
-        "|{title:^" + str(2 * PREFS.title_line_length) + "s}|%EOL%"
-        f"+{MENU_LINE}+%EOL%%NC%"
-    )
-    # fmt: on
-
-    @classmethod
-    def render_app_title(cls, app_title: str = None) -> None:
-        """Render the application title."""
-        cls.SCREEN.clear()
-        cls.SCREEN.cursor.writeln(cls.MENU_TITLE_FMT.format(title=app_title or cls.APP_TITLE))
-
-    @staticmethod
-    def back(source: TUIMenu) -> TUIMenu:
-        """Return the parent menu from the source of the event.
-        :param source: the source menu of the event.
-        """
-        return source.parent
-
-    def __init__(self, main_menu: TUIMenu, title: str = "Main Menu"):
-        check_not_none(main_menu)
-        super().__init__()
-        TUIMenuUi.APP_TITLE = title
-        self._done: bool = False
-        self._curr_menu: TUIMenu = main_menu
-        self._prev_menu = None
-        self._next_menu = None
-
-    def execute(self) -> None:
-        """Execute the terminal menu UI flow."""
-
-        self._prepare_render()
-
-        while not self._done:
-            if self._curr_menu:
-                self._next_menu = self._curr_menu.execute()
-                if self._next_menu:
-                    self._change_menu(
-                        self._next_menu
-                        if isinstance(self._next_menu, TUIMenu)
-                        else next((menu for menu in self._next_menu if menu), None)
-                    )
-                else:
-                    self._done = True
-            else:
-                self._done = True
-
-    def _prepare_render(self, auto_wrap: bool = True, show_cursor: bool = False, clear_screen: bool = True) -> None:
-        """Prepare the screen for renderization."""
-        Terminal.set_auto_wrap(auto_wrap)
-        Terminal.set_show_cursor(show_cursor)
-        if clear_screen:
-            self.SCREEN.clear()
-        self.SCREEN.cursor.save()
-
-    def _change_menu(self, new_menu: TUIMenu) -> None:
-        """Change the current menu and keep track about the previous one.
-        :param new_menu: the menu to be changed to.
-        """
-        self._prev_menu = self._curr_menu
-        self._curr_menu = new_menu

build/lib/build/lib/build/lib/build/lib/clitt/core/tui/menu/tui_menu_view.py

@@ -1,57 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-
-"""
-   @project: HsPyLib
-   @package: clitt.core.tui.menu
-      @file: tui_menu_view.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.term.commons import Direction
-from clitt.core.tui.menu.tui_menu import OnTrigger_Cb, TUIMenu
-from clitt.core.tui.menu.tui_menu_ui import TUIMenuUi
-from typing import Callable, Optional
-
-
-class TUIMenuView(TUIMenu):
-    """Represent a menu view without submenus. Each view can have a view to be displayed. If no view is provided, it
-    will behave like an action.
-    """
-
-    def __init__(
-        self,
-        parent: TUIMenu,
-        title: Optional[str] = None,
-        tooltip: Optional[str] = None,
-        display_text: Optional[str] = None,
-    ):
-        super().__init__(parent, title or "Menu View", tooltip or f"Access the '{title}' view")
-        self._on_render: OnTrigger_Cb = self._display_content
-        self._content: str = display_text or f"%ED0%This is a view: {self.title}"
-
-    def on_render(self, on_render: str | OnTrigger_Cb) -> None:
-        if isinstance(on_render, str):
-            self._content = on_render
-            self._on_render = self._display_content
-        elif isinstance(on_render, Callable):
-            self._on_render = on_render
-            self._content = f"This is a view: {self.title}"
-
-    def execute(self) -> Optional[TUIMenu]:
-        self.render()
-        return self._on_trigger(self)
-
-    def render(self) -> None:
-        TUIMenuUi.render_app_title()
-        self._on_render()
-        self.draw_navbar(self.navbar())
-
-    def _display_content(self) -> None:
-        self.cursor.erase(Direction.DOWN)
-        self.writeln(self._content)
-        self.wait_keystroke()

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

@@ -1,19 +0,0 @@
-# _*_ coding: utf-8 _*_
-#
-# hspylib-clitt v0.9.116
-#
-# Package: main.build.lib.build.lib.build.lib.build.lib.clitt.core.tui.minput
-"""Package initialization."""
-
-__all__ = [
-    'access_type', 
-    'field_builder', 
-    'form_builder', 
-    'form_field', 
-    'input_type', 
-    'input_validator', 
-    'menu_input', 
-    'minput', 
-    'minput_utils'
-]
-__version__ = '0.9.116'

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

@@ -1,26 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-
-"""
-   @project: HsPyLib
-   @package: clitt.core.tui.minput
-      @file: access_type.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 hspylib.core.enums.enumeration import Enumeration
-
-
-class AccessType(Enumeration):
-    """MenuInput input field access types."""
-
-    # fmt: off
-    NO_ACCESS   = "no-access"
-    READ_ONLY   = "read-only"
-    READ_WRITE  = "read-write"
-    # fmt: on

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

@@ -1,117 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-
-"""
-   @project: HsPyLib
-   @package: clitt.core.tui.minput
-      @file: field_builder.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.tui.minput.access_type import AccessType
-from clitt.core.tui.minput.form_field import FieldValidator_Fn, FormField
-from clitt.core.tui.minput.input_type import InputType
-from clitt.core.tui.minput.input_validator import InputValidator
-from clitt.core.tui.minput.minput_utils import get_selected, MASK_SYMBOLS, unpack_masked, VALUE_SEPARATORS
-from functools import reduce
-from hspylib.core.preconditions import check_argument
-from hspylib.core.tools.commons import to_bool
-from hspylib.core.tools.text_tools import snakecase
-from operator import add
-from typing import Any
-
-import re
-
-
-class FieldBuilder:
-    """MenuInput form field builder."""
-
-    @staticmethod
-    def _validate_field(field: FormField) -> bool:
-        match field.itype:
-            case InputType.MASKED:
-                value, mask = unpack_masked(field.value)
-                valid = reduce(add, list(map(mask[len(value) :].count, MASK_SYMBOLS))) == 0
-            case InputType.CHECKBOX:
-                valid = isinstance(field.value, bool)
-            case InputType.SELECT:
-                _, value = get_selected(field.value)
-                length = len(str(value or ""))
-                valid = field.min_length <= length <= field.max_length
-            case _:
-                length = len(str(field.value or ""))
-                valid = field.min_length <= length <= field.max_length
-        return valid
-
-    def __init__(self, parent: Any):
-        self._parent = parent
-        self._label = "Label"
-        self._dest = None
-        self._itype = InputType.TEXT
-        self._access_type = AccessType.READ_WRITE
-        self._min_max_length = 5, 30
-        self._value = ""
-        self._validator = InputValidator.anything(), self._validate_field
-
-    def label(self, label: str) -> "FieldBuilder":
-        self._label = label
-        return self
-
-    def dest(self, dest: str) -> "FieldBuilder":
-        self._dest = dest
-        return self
-
-    def itype(self, itype: str) -> "FieldBuilder":
-        self._itype = InputType.of_value(itype)
-        return self
-
-    def min_max_length(self, min_length: int, max_length: int) -> "FieldBuilder":
-        check_argument(max_length >= min_length, "Invalid field length: ({}-{})", min_length, max_length)
-        check_argument(max_length > 0 and min_length >= 0, "Invalid field length: ({}-{})", min_length, max_length)
-        self._min_max_length = min_length, max_length
-        return self
-
-    def access_type(self, access_type: str) -> "FieldBuilder":
-        self._access_type = AccessType.of_value(access_type)
-        return self
-
-    def value(self, value: Any | None) -> "FieldBuilder":
-        self._value = value
-        return self
-
-    def validator(
-        self, input_validator: InputValidator = None, field_validator: FieldValidator_Fn = None
-    ) -> "FieldBuilder":
-        self._validator = input_validator, field_validator or self._validate_field
-        return self
-
-    def build(self) -> Any:
-        if self._itype == InputType.CHECKBOX:
-            self._value = to_bool(str(self._value))
-        elif self._itype == InputType.SELECT:
-            parts = re.split(VALUE_SEPARATORS, re.sub("[<>]", "", str(self._value or "")))
-            self._min_max_length = len(min(parts, key=len)), len(max(parts, key=len))
-        elif self._itype == InputType.MASKED:
-            _, mask = unpack_masked(str(self._value))
-            min_max = reduce(add, list(map(mask.count, MASK_SYMBOLS)))
-            self._min_max_length = min_max, min_max
-        self._dest = self._dest or snakecase(self._label)
-        self._parent.fields.append(
-            FormField(
-                self._label,
-                self._dest,
-                self._itype,
-                self._min_max_length[0],
-                self._min_max_length[1],
-                self._access_type,
-                self._value,
-                self._validator[0],
-                self._validator[1],
-            )
-        )
-
-        return self._parent

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

@@ -1,72 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-
-"""
-   @project: HsPyLib
-   @package: clitt.core.tui.minput
-      @file: form_builder.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.tui.minput.field_builder import FieldBuilder
-from clitt.core.tui.minput.form_field import FormField
-from clitt.core.tui.minput.input_validator import InputValidator
-from hspylib.core.tools.dict_tools import get_or_default
-from typing import Any, List
-
-import re
-
-
-class FormBuilder:
-    """MenuInput form builder."""
-
-    def __init__(self) -> None:
-        self.fields = []
-        self._fn_validate = None
-
-    @staticmethod
-    def get_attr(parts: List[str], index: int, default_value: Any = None) -> str:
-        return get_or_default(parts, index, default_value) or default_value
-
-    def from_tokenized(self, minput_tokens: List[str], separator: chr = "|") -> "FormBuilder":
-        """Construct the forms based on string tokens.
-
-         Field tokens (in-order):
-              <Label> : The field label. Consisting only of alphanumeric characters and under‐scores.
-               [Mode] : The input mode. One of {[text]|password|checkbox|select}.
-               [Type] : The input type. One of {letters|numbers|words|[anything]}.
-        [Min/Max len] : The minimum and maximum length of characters allowed. Defaults to [0/30].
-               [Perm] : The field permissions. One of {r|[rw]}. Where \"r\" for Read Only ; \"rw\" for Read & Write.
-              [Value] : The initial value of the field. This field may not be blank if the field is read only.
-        """
-        for tk_field in minput_tokens:
-            parts = list(map(str.strip, tk_field.split(separator)))
-            validator_fn = getattr(InputValidator, self.get_attr(parts, 2, "anything"))
-            min_max = list(map(int, map(str.strip, self.get_attr(parts, 3, "5/30").split("/"))))
-            access = re.sub("^rw$", "read-write", self.get_attr(parts, 4, "rw"))
-            access = re.sub("^r$", "read-only", access)
-            # fmt: off
-            self.field() \
-                .label(self.get_attr(parts, 0, 'Label')) \
-                .itype(self.get_attr(parts, 1, 'text')) \
-                .min_max_length(
-                    get_or_default(min_max, 0, 5),
-                    get_or_default(min_max, 1, 30)
-                ) \
-                .access_type(access) \
-                .validator(validator_fn()) \
-                .value(self.get_attr(parts, 5, None)) \
-                .build()
-            # fmt: on
-
-        return self
-
-    def field(self) -> Any:
-        return FieldBuilder(self)
-
-    def build(self) -> List[FormField]:
-        return self.fields

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

@@ -1,180 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-
-"""
-   @project: HsPyLib
-   @package: clitt.core.tui.minput
-      @file: form_field.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.icons.font_awesome.form_icons import FormIcons
-from clitt.core.tui.minput.access_type import AccessType
-from clitt.core.tui.minput.input_type import InputType
-from clitt.core.tui.minput.input_validator import InputValidator
-from clitt.core.tui.minput.minput_utils import get_selected, MASK_SYMBOLS, toggle_selected, unpack_masked
-from hspylib.core.exception.exceptions import InvalidInputError
-from hspylib.core.tools.text_tools import xstr
-from typing import Any, Callable, Optional, TypeAlias
-
-FieldValidator_Fn: TypeAlias = Callable[["FormField"], bool]
-
-
-class FormField:
-    """Represent a MenuInput form field."""
-
-    def __init__(
-        self,
-        label: str = None,
-        dest: str = None,
-        itype: InputType = InputType.TEXT,
-        min_length: int = 5,
-        max_length: int = 30,
-        access_type: AccessType = AccessType.READ_WRITE,
-        value: Any = "",
-        input_validator: InputValidator = InputValidator.anything(),
-        field_validator: FieldValidator_Fn = None,
-        tooltip: str = None,
-    ):
-        self._label = label
-        self._tooltip = tooltip
-        self._dest = dest
-        self._itype = itype
-        self._min_length = min_length
-        self._max_length = max_length
-        self._access_type = access_type
-        self.input_validator = input_validator
-        self.field_validator = field_validator
-        self._value = self.assign(value)
-
-    def __str__(self) -> str:
-        return (
-            f"[{self.label}, {self.itype.name}({self.min_length}/{self.max_length})"
-            f"<{self.access_type}> = '{self.value or ''}']"
-        )
-
-    def __repr__(self):
-        return str(self)
-
-    @property
-    def label(self) -> str:
-        return self._label
-
-    @property
-    def tooltip(self) -> str:
-        return self._tooltip
-
-    @property
-    def dest(self) -> str:
-        return self._dest
-
-    @property
-    def itype(self) -> InputType:
-        return self._itype
-
-    @property
-    def min_length(self) -> int:
-        return self._min_length
-
-    @property
-    def max_length(self) -> int:
-        return self._max_length
-
-    @property
-    def access_type(self) -> AccessType:
-        return self._access_type
-
-    @property
-    def value(self) -> Optional[Any]:
-        return self._value
-
-    @value.setter
-    def value(self, new_value: Any) -> None:
-        self._value = self.assign(new_value)
-
-    @property
-    def length(self) -> int:
-        """Get the field real length, depending on the field type."""
-        real_value = str(self.value or "")
-        match self.itype:
-            case InputType.CHECKBOX:
-                real_value = "1"
-            case InputType.SELECT:
-                _, real_value = get_selected(str(self.value))
-            case InputType.MASKED:
-                real_value, mask = unpack_masked(str(self.value))
-                idx = len(real_value)
-                while idx < len(mask) and mask[idx] not in MASK_SYMBOLS:
-                    idx += 1
-                return idx
-
-        return len(real_value)
-
-    @property
-    def icon(self) -> FormIcons:
-        if self.access_type == AccessType.READ_ONLY:
-            return FormIcons.LOCKED
-        match self.itype:
-            case InputType.PASSWORD:
-                icon = FormIcons.HIDDEN
-            case InputType.CHECKBOX:
-                icon = FormIcons.MARKED
-            case InputType.SELECT:
-                icon = FormIcons.SELECTABLE
-            case InputType.MASKED:
-                icon = FormIcons.MASKED
-            case InputType.TEXT:
-                if self.input_validator.pattern_type == InputValidator.PatternType.NUMBERS:
-                    icon = FormIcons.NUMBERS
-                elif self.input_validator.pattern_type == InputValidator.PatternType.LETTERS:
-                    icon = FormIcons.LETTERS
-                elif self.input_validator.pattern_type == InputValidator.PatternType.WORDS:
-                    icon = FormIcons.WORDS
-                elif self.input_validator.pattern_type == InputValidator.PatternType.CUSTOM:
-                    icon = FormIcons.CUSTOM
-                else:
-                    icon = FormIcons.EDITABLE
-            case _:
-                icon = FormIcons.QUESTION_CIRCLE
-        return icon
-
-    def can_write(self) -> bool:
-        """Whether this field value can be set or not."""
-        return self.access_type == AccessType.READ_WRITE
-
-    def assign(self, value: Any) -> Any:
-        """Assign a value for this field. Must match the input validator, otherwise an exception will be thrown.
-        :param value: TODO
-        """
-        valid = True
-        if value is not None and self.input_validator:
-            match self.itype:
-                case InputType.MASKED:
-                    unpack_masked(value)
-                case InputType.SELECT:
-                    toggle_selected(value)
-                case InputType.CHECKBOX:
-                    valid = isinstance(value, bool)
-                case _:
-                    valid = all(self.validate_input(val) for val in xstr(value))
-
-        if not valid:
-            raise InvalidInputError(f"Value {value} is invalid!")
-
-        self._value = value
-
-        return self._value
-
-    def validate_input(self, value: Any = None) -> bool:
-        """Validate the input using the assigned validator.
-        :param value: the value to validate against.
-        """
-        return self.input_validator(str(value)) if self.input_validator else True
-
-    def validate_field(self) -> bool:
-        """Validate the field using the assigned validator function."""
-        return self.field_validator(self) if self.field_validator else False

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

@@ -1,30 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-
-"""
-   @project: HsPyLib
-   @package: clitt.core.tui.minput
-      @file: input_type.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 hspylib.core.enums.enumeration import Enumeration
-
-
-class InputType(Enumeration):
-    """MenuInput input field types."""
-
-    # fmt: off
-    TEXT        = "text"
-    PASSWORD    = "password"
-    CHECKBOX    = "checkbox"
-    SELECT      = "select"
-    MASKED      = "masked"
-    # fmt: on
-
-    def __repr__(self):
-        return str(self)