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

build/lib/clitt/core/term/terminal.py

@@ -1,203 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-
-"""
-   @project: HsPyLib
-   @package: hspylib.modules.cli.vt100
-      @file: terminal.py
-   @created: Tue, 11 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
-"""
-import atexit
-import logging as log
-import os
-import platform
-import select
-import shlex
-import signal
-import sys
-from subprocess import CalledProcessError, Popen, PIPE
-from typing import Any, Optional, Tuple, List, Iterable
-
-from hspylib.core.enums.charset import Charset
-from hspylib.core.metaclass.singleton import Singleton
-from hspylib.core.tools.commons import sysout
-from hspylib.modules.application.exit_status import ExitStatus
-from hspylib.modules.cli.keyboard import Keyboard
-from hspylib.modules.cli.vt100.vt_100 import Vt100
-
-from clitt.core.exception.exceptions import NotATerminalError
-from clitt.core.term.cursor import Cursor
-from clitt.core.term.screen import Screen
-
-
-class Terminal(metaclass=Singleton):
-    """Utility class to provide terminal features."""
-
-    INSTANCE = None
-
-    @staticmethod
-    def is_a_tty() -> bool:
-        return sys.stdout.isatty()
-
-    @staticmethod
-    def _chain_pipes(cmd_list: Iterable, **kwargs) -> Popen:
-        """Run commands in PIPE, return the last process in chain.
-        :param cmd_list: the command list to be executed.
-        """
-        if "stdout" in kwargs:
-            del kwargs["stdout"]
-        if "stderr" in kwargs:
-            del kwargs["stderr"]
-        if "stdin" in kwargs:
-            del kwargs["stdin"]
-        commands = map(shlex.split, cmd_list) if 'shell' not in kwargs else cmd_list
-        first_cmd, *rest_cmds = commands
-        if len(rest_cmds) > 0:
-            procs: List[Popen] = [Popen(first_cmd, stdout=PIPE, stderr=PIPE, **kwargs)]
-            for cmd in rest_cmds:
-                last_stdout = procs[-1].stdout
-                procs.append(Popen(cmd, stdin=last_stdout, stdout=PIPE, stderr=PIPE, **kwargs))
-            return procs[-1]
-        return Popen(first_cmd, stdout=PIPE, stderr=PIPE, **kwargs)
-
-    @staticmethod
-    def shell_exec(cmd_line: str, **kwargs) -> Tuple[Optional[str], ExitStatus]:
-        """Execute command with arguments and return it's run status.
-        :param cmd_line: the command line to be executed.
-        """
-        proc = Terminal._chain_pipes(cmd_line.split("|"), **kwargs)
-        log.info("Executing shell command: %s", cmd_line)
-        output, err_out = proc.communicate()
-        ret_code = ExitStatus.FAILED if err_out else ExitStatus.SUCCESS
-        log.info("Execution result: %s", ret_code)
-        return output.decode(Charset.UTF_8.val) if output else err_out.decode(Charset.UTF_8.val), ret_code
-
-    @staticmethod
-    def shell_poll(cmd_line: str, **kwargs) -> None:
-        """Execute command with arguments and continuously poll it's output.
-        :param cmd_line: the command line to be executed.
-        """
-        if "stdout" in kwargs:
-            del kwargs["stdout"]  # Deleted because it's forbidden
-        if "stderr" in kwargs:
-            del kwargs["stderr"]  # Deleted because it's forbidden
-        if "shell" in kwargs:
-            del kwargs["shell"]  # Deleted because we don't want to use it
-        try:
-            log.info("Polling shell command: %s", cmd_line)
-            cmd_args = list(filter(None, shlex.split(cmd_line)))
-            with Popen(cmd_args, stdout=PIPE, stderr=PIPE, **kwargs) as proc:
-                process = select.poll()
-                process.register(proc.stdout)
-                process.register(proc.stderr)
-                while not Keyboard.kbhit():
-                    if poll_obj := process.poll(0.5):
-                        line = proc.stdout.readline()
-                        sysout(line.decode(Charset.UTF_8.val) if isinstance(line, bytes) else line.strip(), end="")
-                        log.debug("Polling returned: %s", str(poll_obj))
-                os.killpg(os.getpgid(proc.pid), signal.SIGTERM)
-        except (InterruptedError, KeyboardInterrupt):
-            log.warning("Polling process has been interrupted command='%s'", cmd_line)
-        except CalledProcessError as err:
-            log.error("Command failed: %s => %s", cmd_line, err)
-
-    @staticmethod
-    def open(filename: str) -> None:
-        """Open the specified file using the default editor."""
-        my_os = os.environ.get("HHS_MY_OS", platform.system())
-        if "Darwin" == my_os:
-            Terminal.shell_exec(f"open {filename}")
-        elif "Linux" == my_os:
-            Terminal.shell_exec(f"xdg-open {filename}")
-        else:
-            raise NotImplementedError(f"OS '{my_os}' is not supported")
-
-    @classmethod
-    def restore(cls) -> None:
-        """Clear the terminal and restore default attributes [wrap,cursor,echo]."""
-        cls.set_attributes(show_cursor=True, auto_wrap=True, enable_echo=True)
-        cls.alternate_screen(False)
-        sysout("%MOD(0)%", end="")
-
-    @classmethod
-    def set_enable_echo(cls, enabled: bool = True) -> None:
-        """Enable echo in the terminal.
-        :param enabled: whether is enabled or not.
-        """
-        if not cls.is_a_tty():
-            log.warning(NotATerminalError("set_enable_echo:: Requires a terminal (TTY)"))
-            return
-
-        os.popen(f"stty {'echo -raw' if enabled else 'raw -echo min 0'}").read()
-
-    @classmethod
-    def set_auto_wrap(cls, auto_wrap: bool = True) -> None:
-        """Set auto-wrap mode in the terminal.
-        :param auto_wrap: whether auto_wrap is set or not.
-        """
-        if not cls.is_a_tty():
-            log.warning(NotATerminalError("set_auto_wrap:: Requires a terminal (TTY)"))
-            return
-
-        sysout(Vt100.set_auto_wrap(auto_wrap), end="")
-
-    @classmethod
-    def set_show_cursor(cls, show_cursor: bool = True) -> None:
-        """Show or hide cursor in the terminal.
-        :param show_cursor: whether to show or hide he cursor.
-        """
-        if not cls.is_a_tty():
-            log.warning(NotATerminalError("set_show_cursor:: Requires a terminal (TTY)"))
-            return
-
-        sysout(Vt100.set_show_cursor(show_cursor), end="")
-
-    @classmethod
-    def set_attributes(cls, **attrs) -> None:
-        """Wrapper to set all terminal attributes at once."""
-        # fmt: off
-        enable_echo = attrs['enable_echo']
-        auto_wrap = attrs['auto_wrap']
-        show_cursor = attrs['show_cursor']
-        # fmt: on
-        if enable_echo is not None:
-            cls.set_enable_echo(enable_echo)
-        if auto_wrap is not None:
-            cls.set_auto_wrap(auto_wrap)
-        if show_cursor is not None:
-            cls.set_show_cursor(show_cursor)
-
-    @classmethod
-    def clear(cls) -> None:
-        """Clear terminal and move the cursor to HOME position (0, 0)."""
-        cls.INSTANCE.screen.clear()
-
-    @classmethod
-    def echo(cls, obj: Any, end: str = os.linesep) -> None:
-        """Write the string representation of the object to the screen."""
-        cls.INSTANCE.screen.cursor.write(obj, end=end)
-
-    @classmethod
-    def alternate_screen(cls, enable: bool) -> None:
-        """Switch to the alternate screen buffer on/off."""
-        cls.INSTANCE.screen.alternate = enable
-
-    def __init__(self):
-        self._screen = Screen.INSTANCE or Screen()
-        atexit.register(self.restore)
-
-    @property
-    def screen(self) -> Screen:
-        return self._screen
-
-    @property
-    def cursor(self) -> Cursor:
-        return self.screen.cursor
-
-
-assert Terminal().INSTANCE is not None, "Failed to create Terminal instance"

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

@@ -1,20 +0,0 @@
-# _*_ coding: utf-8 _*_
-#
-# hspylib-clitt v0.9.116
-#
-# Package: main.build.lib.build.lib.clitt.core.tui
-"""Package initialization."""
-
-__all__ = [
-    'line_input', 
-    'mchoose', 
-    'mdashboard', 
-    'menu', 
-    'minput', 
-    'mselect', 
-    'table', 
-    'tui_application', 
-    'tui_component', 
-    'tui_preferences'
-]
-__version__ = '0.9.116'

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

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

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

@@ -1,228 +0,0 @@
-#!/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
-"""
-
-import pyperclip
-from hspylib.modules.cli.keyboard import Keyboard
-from hspylib.modules.cli.vt100.vt_color import VtColor
-from typing import Optional, List, Dict
-
-from clitt.core.term.commons import Direction, Portion
-from clitt.core.term.terminal import Terminal
-from clitt.core.tui.tui_component import TUIComponent
-
-
-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."""
-        for entry in history:
-            KeyboardInput._add_history(entry)
-
-    @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:]:
-            KeyboardInput._HISTORY[max(1, len(KeyboardInput._HISTORY))] = input_text
-            KeyboardInput._HIST_INDEX += 1
-
-    @classmethod
-    def _next_in_history(cls) -> Optional[str]:
-        index = min(len(cls._HISTORY), cls._HIST_INDEX + 1)
-        text = cls._HISTORY.get(index, "")
-        cls._HIST_INDEX = min(len(cls._HISTORY) - 1, index)
-        return text or cls._HISTORY[0]
-
-    @classmethod
-    def _prev_in_history(cls) -> Optional[str]:
-        index = max(1, cls._HIST_INDEX)
-        text = cls._HISTORY.get(index, "")
-        cls._HIST_INDEX = max(1, index - 1)
-        return text
-
-    @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):
-        super().__init__(prompt)
-        self._prompt_color = prompt_color
-        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 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._prepare_render()
-        keypress = self._loop()
-
-        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("")
-
-        return self._input_text
-
-    def render(self) -> None:
-        Terminal.set_show_cursor(False)
-        self.cursor.restore()
-        self._terminal.cursor.erase(Portion.LINE)
-        self.write(f"{self._prompt_color.placeholder}{self.title}%NC%")
-        self.write(self._input_text)
-        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:
-                    self.forget_history()
-                case Keyboard.VK_CTRL_P:
-                    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:
-                    self._input_index = 0
-                    self._update_input("")
-                case Keyboard.VK_CTRL_U:  # Undo
-                    undo_text = self._undo()
-                    self._input_text = undo_text
-                    self._input_index = self.length
-                    self._HISTORY[0] = self._input_text
-                case Keyboard.VK_CTRL_K:  # redo
-                    redo_text = self._redo()
-                    self._input_text = redo_text if redo_text else self._input_text
-                    self._input_index = self.length
-                    self._HISTORY[0] = self._input_text
-                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._prev_in_history()
-                    self._input_index = self.length
-                case Keyboard.VK_DOWN:
-                    self._input_text = self._next_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/clitt/core/tui/line_input/line_input.py

@@ -1,43 +0,0 @@
-#!/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 hspylib.modules.cli.keyboard import Keyboard
-from hspylib.modules.cli.vt100.vt_color import VtColor
-from typing import Optional
-
-from clitt.core.tui.line_input.keyboard_input import KeyboardInput
-
-
-def line_input(
-    prompt: str = "",
-    prompt_color: VtColor = VtColor.NC,
-) -> 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.
-    """
-    ptt = KeyboardInput(prompt, prompt_color)
-    return ptt.execute()
-
-
-if __name__ == "__main__":
-    hist = ["Hugo", "Joao", "Koko", "Hugo"]
-    KeyboardInput.preload_history(hist)
-    print("-=" * 30)
-    while (i := line_input("What is it? ")) not in ["bye", ""]:
-        if isinstance(i, Keyboard):
-            print(i)
-        else:
-            print("Input:", i)
-    print(KeyboardInput.history())

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

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

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

@@ -1,44 +0,0 @@
-#!/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 hspylib.core.enums.charset import Charset
-from typing import List, Optional, TypeVar
-
-from clitt.core.tui.mchoose.menu_choose import MenuChoose
-
-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