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

build/lib/build/lib/clitt/core/tui/line_input/keyboard_input.py

@@ -0,0 +1,229 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+"""
+   @project: HsPyLib-AskAI
+   @package: main.clitt.core.tui.line_input
+      @file: keyboard_input.py
+   @created: Wed, 17 Jan 2024
+    @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.term.terminal import Terminal
+from clitt.core.tui.tui_component import TUIComponent
+from hspylib.modules.cli.keyboard import Keyboard
+from hspylib.modules.cli.vt100.vt_color import VtColor
+from typing import Dict, List, Optional
+
+import pyperclip
+
+
+class KeyboardInput(TUIComponent):
+    """Provides a keyboard input for terminal UIs with undo and history."""
+
+    # Current history index.
+    _HIST_INDEX: int = 0
+
+    # Dict containing all previously accepted inputs.
+    _HISTORY: Dict[int, str] = {0: ""}
+
+    # Stack containing current input changes.
+    _UNDO_HISTORY: List[str] = []
+
+    # Stack containing current input reverts.
+    _REDO_HISTORY: List[str] = []
+
+    @staticmethod
+    def preload_history(history: List[str]) -> None:
+        """Preload the input with the provided dictionary."""
+        rev_history = reversed(history)
+        for entry in rev_history:
+            KeyboardInput._add_history(entry)
+        KeyboardInput._HIST_INDEX = 0
+
+    @staticmethod
+    def forget_history() -> None:
+        """Forget all input history entries."""
+        tmp: str = KeyboardInput._HISTORY[0]
+        KeyboardInput._HISTORY.clear()
+        KeyboardInput._HISTORY[0] = tmp
+
+    @staticmethod
+    def history() -> List[str]:
+        """Return the actual input history."""
+        return list(filter(lambda v: v, KeyboardInput._HISTORY.values()))
+
+    @staticmethod
+    def _add_history(input_text: str) -> None:
+        """Add the following input to the history set.
+        :param input_text: The input text to add to the history.
+        """
+        if input_text and input_text not in list(KeyboardInput._HISTORY.values())[1:]:
+            idx: int = max(1, len(KeyboardInput._HISTORY))
+            KeyboardInput._HISTORY[idx] = input_text
+            KeyboardInput._HIST_INDEX = idx
+
+    @classmethod
+    def _next_in_history(cls) -> Optional[str]:
+        index = min(len(cls._HISTORY) - 1, cls._HIST_INDEX + 1)
+        text = cls._HISTORY.get(index, "")
+        cls._HIST_INDEX = index
+        return text or cls._HISTORY[0]
+
+    @classmethod
+    def _prev_in_history(cls) -> Optional[str]:
+        index = max(0, cls._HIST_INDEX - 1)
+        text = cls._HISTORY.get(index, "")
+        cls._HIST_INDEX = index
+        return text or cls._HISTORY[0]
+
+    @classmethod
+    def _undo(cls) -> Optional[str]:
+        text = cls._UNDO_HISTORY.pop() if cls._UNDO_HISTORY else None
+        if cls._HISTORY[0] not in cls._REDO_HISTORY:
+            cls._REDO_HISTORY.append(cls._HISTORY[0])
+        return text
+
+    @classmethod
+    def _redo(cls) -> Optional[str]:
+        text = cls._REDO_HISTORY.pop() if cls._REDO_HISTORY else None
+        if cls._HISTORY[0] not in cls._UNDO_HISTORY:
+            cls._UNDO_HISTORY.append(cls._HISTORY[0])
+        return text
+
+    def __init__(
+        self,
+        prompt: str = "",
+        prompt_color: VtColor = VtColor.NC,
+        text_color: VtColor = VtColor.NC,
+        navbar_enable: bool = False,
+    ):
+        super().__init__(prompt)
+        self._prompt_color = prompt_color
+        self._text_color = text_color
+        self._navbar_enable = navbar_enable
+        self._input_index = 0
+        self._input_text: str = ""
+        self._HISTORY[0] = ""
+
+    @property
+    def length(self) -> int:
+        return len(self._input_text) if self._input_text else 0
+
+    def _prepare_render(self, auto_wrap: bool = True, show_cursor: bool = True) -> None:
+        Terminal.set_auto_wrap(auto_wrap)
+        Terminal.set_show_cursor(show_cursor)
+        self.cursor.save()
+
+    def _loop(self, break_keys: List[Keyboard] = None) -> Keyboard:
+        break_keys = break_keys or Keyboard.break_keys()
+        keypress = Keyboard.VK_NONE
+
+        # Wait for user interaction
+        while not self._done and keypress and keypress not in break_keys:
+            # Menu Renderization
+            if self._re_render:
+                self.render()
+            # Navigation input
+            keypress = self.handle_keypress()
+
+        return keypress
+
+    def execute(self) -> Optional[str | Keyboard]:
+        self.write(f"{self._prompt_color.placeholder}{self.title}{self._text_color.placeholder}")
+        self._prepare_render()
+        keypress = self._loop() or Keyboard.VK_ESC
+
+        if keypress.isEnter():
+            self._add_history(self._input_text)
+            self._UNDO_HISTORY.clear()
+            self._REDO_HISTORY.clear()
+        elif keypress == Keyboard.VK_ESC:
+            self._input_text = None
+
+        self.writeln("%NC%")
+
+        return self._input_text
+
+    def render(self) -> None:
+        Terminal.set_show_cursor(False)
+        self.cursor.restore()
+        self.write(self._input_text)
+        self._terminal.cursor.erase(Direction.RIGHT)
+        self._re_render = False
+        self._set_cursor_pos()
+        Terminal.set_show_cursor()
+
+    def navbar(self, **kwargs) -> str:
+        pass
+
+    def handle_keypress(self) -> Keyboard:
+        if keypress := Keyboard.wait_keystroke():
+            match keypress:
+                case Keyboard.VK_BACKSPACE:
+                    if self._input_index > 0:
+                        self._input_index = max(0, self._input_index - 1)
+                        self._update_input(
+                            self._input_text[: self._input_index] + self._input_text[1 + self._input_index :]
+                        )
+                case Keyboard.VK_DELETE:
+                    self._update_input(
+                        self._input_text[: self._input_index] + self._input_text[1 + self._input_index :]
+                    )
+                case Keyboard.VK_CTRL_F:  # Forget history
+                    self.forget_history()
+                case Keyboard.VK_CTRL_P:  # Paste from clipboard
+                    text = (pyperclip.paste() or "").replace("\n", "↵")
+                    self._update_input(
+                        self._input_text[: self._input_index] + text + self._input_text[self._input_index :]
+                    )
+                    self._input_index += len(text)
+                case Keyboard.VK_CTRL_R:  # Reset contents
+                    self._input_index = 0
+                    self._update_input("")
+                case Keyboard.VK_LEFT:
+                    self._input_index = max(0, self._input_index - 1)
+                case Keyboard.VK_RIGHT:
+                    self._input_index = min(self.length, self._input_index + 1)
+                case Keyboard.VK_UP:
+                    self._input_text = self._next_in_history()
+                    self._input_index = self.length
+                case Keyboard.VK_DOWN:
+                    self._input_text = self._prev_in_history()
+                    self._input_index = self.length
+                case Keyboard.VK_HOME:
+                    self._input_index = 0
+                case Keyboard.VK_END:
+                    self._input_index = self.length
+                case _ as key if key.val.isprintable():
+                    self._update_input(
+                        self._input_text[: self._input_index] + key.val + self._input_text[self._input_index :]
+                    )
+                    self._input_index += 1
+                case _ as key if key in Keyboard.break_keys():
+                    self._done = True
+                case _:
+                    self._input_text = keypress
+                    self._done = True
+            self._re_render = True
+
+        return keypress
+
+    def _set_cursor_pos(self):
+        """Set the cursor position on the input."""
+        index_offset = max(0, self.length - self._input_index)
+        self.screen.cursor.move(index_offset, Direction.LEFT)
+
+    def _update_input(self, text: str) -> str:
+        """Update the value of the input.
+        :param text: The text to be set.
+        """
+        self._UNDO_HISTORY.append(self._input_text)
+        self._HISTORY[0] = text if text not in self._HISTORY else self._input_text
+        self._input_text = text
+        return text

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

@@ -0,0 +1,31 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+"""
+   @project: HsPyLib-AskAI
+   @package: main.clitt.core.tui.line_input
+      @file: line_input.py
+   @created: Wed, 17 Jan 2024
+    @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.line_input.keyboard_input import KeyboardInput
+from hspylib.modules.cli.keyboard import Keyboard
+from hspylib.modules.cli.vt100.vt_color import VtColor
+from typing import Optional
+
+
+def line_input(
+    prompt: str = "", prompt_color: VtColor = VtColor.NC, text_color: VtColor = VtColor.NC, navbar_enable: bool = False
+) -> Optional[str | Keyboard]:
+    """Read a string from standard input.
+    :param prompt: The message to be displayed to the user.
+    :param prompt_color: The color of the prompt text.
+    :param text_color: The color of the input text.
+    :param navbar_enable: Whether to display the navbar or not.
+    """
+    ptt = KeyboardInput(prompt, prompt_color, text_color, navbar_enable)
+    return ptt.execute()

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

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

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

@@ -0,0 +1,43 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+"""
+   @project: HsPyLib
+   @package: clitt.core.tui.mchoose
+      @file: mchoose.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.mchoose.menu_choose import MenuChoose
+from hspylib.core.enums.charset import Charset
+from typing import List, Optional, TypeVar
+
+T = TypeVar("T")
+
+
+def mchoose(
+    items: List[T],
+    checked: bool | List[bool] = False,
+    title: str = "Please choose among the options",
+    output: str = None,
+) -> Optional[List[T]]:
+    """
+    Terminal UI menu choose input method.
+    :param items: the provided items to choose from.
+    :param checked: whether all items ate initially marked or not.
+    :param title: the title to be displayed before the options.
+    :param output: optional output file containing the marked items.
+    :return: the list of marked items.
+    """
+
+    result = MenuChoose(title, items, checked).execute()
+
+    if result and output:
+        with open(output, "w", encoding=Charset.UTF_8.val) as f_out:
+            f_out.write(" ".join(result))
+
+    return result

build/lib/build/lib/clitt/core/tui/mchoose/menu_choose.py

@@ -0,0 +1,192 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+"""
+   @project: HsPyLib
+   @package: clitt.core.tui.mchoose
+      @file: menu_choose.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.core.tools.commons import to_bool
+from hspylib.core.tools.dict_tools import get_or_default
+from hspylib.modules.cli.keyboard import Keyboard
+from typing import List, Optional, TypeAlias, TypeVar
+
+T = TypeVar("T")
+
+MChooseItems: TypeAlias = List[T]
+
+
+class MenuChoose(TUIComponent):
+    """Terminal UI menu choose input method."""
+
+    NAV_ICONS = NavIcons.compose(NavIcons.UP, NavIcons.DOWN)
+
+    ROW_OFFSET = 5
+
+    MIN_ROWS = 3
+
+    def __init__(self, title: str, items: MChooseItems, checked: bool | List[bool] = False):
+
+        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)
+        # Initialize all options
+        if isinstance(checked, bool):
+            self.sel_options = [checked for _ in range(len(items))]
+        else:
+            # Check both sizes
+            self.sel_options = [get_or_default(checked, i, 0) for i in range(len(items))]
+
+    def execute(self) -> Optional[MChooseItems]:
+        if len(self.items) == 0:
+            return None
+
+        self._prepare_render()
+        keypress = self._loop()
+
+        return [op for idx, op in enumerate(self.items) if self.sel_options[idx]] if keypress.isEnter() else None
+
+    def render(self) -> None:
+        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)
+            mark = self.prefs.checked_icon if to_bool(self.sel_options[idx]) else self.prefs.unchecked_icon
+            # fmt: off
+            line_fmt = (
+                "  {:>" + f"{len(str(length))}" + "}  "
+                + "{:>" + f"{len(selector)}" + "}  "
+                + "{:>" + f"{len(str(mark))}" + "}  "
+                + "{:<" + f"{self.max_line_length}" + "}  "
+            )
+            # fmt: on
+            self.draw_line(line_fmt, idx + 1, selector, mark, 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] Accept  [{self.NAV_ICONS}] "
+            f"Navigate  [Space] Mark  [I] Invert  [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 Keyboard.VK_SPACE:
+                    self._handle_space()
+                case _ as key if key in [Keyboard.VK_i, Keyboard.VK_I]:
+                    self._handle_key_i()
+                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.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.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 _handle_space(self) -> None:
+        """TODO"""
+        if self.sel_options[self.sel_index] == 0:
+            self.sel_options[self.sel_index] = 1
+        else:
+            self.sel_options[self.sel_index] = 0
+        self._re_render = True
+
+    def _handle_key_i(self) -> None:
+        """TODO"""
+        self.sel_options = [(0 if op == 1 else 1) for op in self.sel_options]
+        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/mdashboard/__init__.py

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

build/lib/build/lib/clitt/core/tui/mdashboard/dashboard_builder.py

@@ -0,0 +1,54 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+"""
+   @project: HsPyLib
+   @package: clitt.core.tui.mdashboard
+      @file: dashboard_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.icons.font_awesome.awesome import Awesome
+from clitt.core.tui.mdashboard.dashboard_item import DashboardItem
+from typing import Callable, List, Optional
+
+
+class DashboardBuilder:
+    """Dashboard builder."""
+
+    @staticmethod
+    class DashboardItemBuilder:
+        """Dashboard item builder."""
+
+        def __init__(self, parent: "DashboardBuilder"):
+            self._parent = parent
+            self._item = DashboardItem()
+
+        def icon(self, icon: Awesome) -> "DashboardBuilder.DashboardItemBuilder":
+            self._item.icon = icon
+            return self
+
+        def tooltip(self, tooltip: str) -> "DashboardBuilder.DashboardItemBuilder":
+            self._item.tooltip = tooltip
+            return self
+
+        def on_trigger(self, on_trigger: Callable) -> Optional["DashboardBuilder.DashboardItemBuilder"]:
+            self._item.on_trigger = on_trigger
+            return self
+
+        def build(self) -> "DashboardBuilder":
+            self._parent.items.append(self._item)
+            return self._parent
+
+    def __init__(self):
+        self.items = []
+
+    def item(self) -> DashboardItemBuilder:
+        return DashboardBuilder.DashboardItemBuilder(self)
+
+    def build(self) -> List[DashboardItem]:
+        return self.items

build/lib/build/lib/clitt/core/tui/mdashboard/dashboard_item.py

@@ -0,0 +1,31 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+"""
+   @project: HsPyLib
+   @package: clitt.core.tui.mdashboard
+      @file: dashboard_item.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.awesome import Awesome
+from typing import Callable, Optional
+
+
+class DashboardItem:
+    """Represent a dashboard item."""
+
+    def __init__(self, icon: Awesome = None, tooltip: str = None, on_trigger: Optional[Callable] = None):
+        self.icon = icon
+        self.tooltip = tooltip
+        self.on_trigger = on_trigger
+
+    def __str__(self):
+        return f'{self.icon} "{self.tooltip}" -> {self.on_trigger}'
+
+    def __repr__(self):
+        return str(self)

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

@@ -0,0 +1,26 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+"""
+   @project: HsPyLib
+   @package: clitt.core.tui.mdashboard
+      @file: mdashboard.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.mdashboard.dashboard_item import DashboardItem
+from clitt.core.tui.mdashboard.menu_dashboard import MenuDashBoard
+from typing import List, Optional
+
+
+def mdashboard(items: List[DashboardItem], title: str = "Please select one item") -> Optional[DashboardItem]:
+    """
+    Wrapper for the Menu Dashboard.
+    :param items: the provided dashboard items to select from.
+    :param title: the title to be displayed before the options.
+    """
+    return MenuDashBoard(title, items).execute()