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

build/lib/clitt/addons/appman/appman.py

@@ -1,305 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-
-"""
-   @project: HsPyLib-Clitt
-   @package: clitt.addons.appman
-      @file: appman.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.addons.appman.appman_enums import AppExtension, AppType
-from clitt.core.term.terminal import Terminal
-from clitt.core.tui.minput.input_validator import InputValidator
-from clitt.core.tui.minput.minput import MenuInput, minput
-from hspylib.core.enums.charset import Charset
-from hspylib.core.enums.http_code import HttpCode
-from hspylib.core.metaclass.singleton import Singleton
-from hspylib.core.namespace import Namespace
-from hspylib.core.preconditions import check_argument
-from hspylib.core.tools.commons import get_path, syserr, sysout
-from hspylib.core.tools.text_tools import camelcase, ensure_endswith
-from hspylib.modules.application.application import Application
-from hspylib.modules.application.exit_status import ExitStatus
-from hspylib.modules.application.version import Version
-from hspylib.modules.fetch.fetch import get
-from textwrap import dedent
-from typing import List
-
-import os
-import stat
-import urllib3
-
-HERE = get_path(__file__)
-
-INITIAL_REVISION = Version.initial()
-
-WELCOME_MESSAGE = f"My Application v{INITIAL_REVISION}"
-
-
-class AppManager(metaclass=Singleton):
-    """HsPyLib application manager that helps creating HsPyLib based applications and widgets."""
-
-    # The directory containing all template files
-    TEMPLATES = HERE / "templates"
-
-    # The general gradle properties
-    GRADLE_PROPS = dedent(
-        """
-        app_name    = '{}'
-        app_version = '{}'
-
-        pythonVersion=3
-        pyrccVersion=5
-
-        author="<Author>")
-        mailTo="<MailTo")
-        siteUrl="<SiteUrl>")
-    """
-    )
-
-    @staticmethod
-    def prompt() -> Namespace:
-        """Prompt for the application info."""
-        # fmt: off
-        form_fields = MenuInput.builder() \
-            .field() \
-                .label('App Name') \
-                .validator(InputValidator.words()) \
-                .min_max_length(1, 40) \
-                .value('my_app') \
-                .build() \
-            .field() \
-                .label('App Type') \
-                .itype('select') \
-                .value(f"{AppType.APP}|{AppType.QT_APP}|{AppType.WIDGET}") \
-                .build() \
-            .field() \
-                .label('Dest Dir') \
-                .validator(InputValidator.anything()) \
-                .min_max_length(3, 80) \
-                .value(os.getenv('HOME', os.getcwd())) \
-                .build() \
-            .field() \
-                .label('Initialize gradle') \
-                .itype('checkbox') \
-                .value(True) \
-                .build() \
-            .field() \
-                .label('Initialize git') \
-                .itype('checkbox') \
-                .value(True) \
-                .build() \
-            .build()
-        # fmt: on
-        return minput(form_fields)
-
-    def __init__(self, parent_app: Application) -> None:
-        self._parent_app = parent_app
-        self._app_name = None
-        self._app_dir = None
-        self._init_gradle_flag = False
-        self._init_git_flag = False
-
-    def create(self, app_name: str, app_type: AppType, app_ext: List[AppExtension], dest_dir: str) -> None:
-        """Create the application based on the parameters.
-        :param app_name the application name.
-        :param app_type the application type (qt-app, widgets, ...)
-        :param app_ext the application extensions (gradle, git, ...).
-        :param dest_dir the project destination directory (dest_dir/app_name).
-        """
-        sysout(f'Creating "{app_name}" at {dest_dir}')
-        try:
-            check_argument(os.path.exists(dest_dir), "Destination not found: {}", dest_dir)
-            self._app_name = app_name
-            if app_type == AppType.APP:
-                self._app_dir = f"{dest_dir}/{app_name}"
-                self._create_app(app_name, app_ext)
-            elif app_type == AppType.WIDGET:
-                self._app_dir = f"{dest_dir}"
-                self._create_widget(app_name)
-            elif app_type == AppType.QT_APP:
-                self._app_dir = f"{dest_dir}/{app_name}"
-                self._create_qt_app(app_name, app_ext)
-            else:
-                raise TypeError(f"Unsupported application type: {app_type}")
-        except OSError as err:
-            syserr(f'Could not create application "{app_name}"!\n  => {str(err)}')
-            self._parent_app.exit(ExitStatus.FAILED.val)
-
-        sysout(f"Successfully created the {app_type.value} {app_name}")
-
-    def _create_app(self, app_name: str, app_ext: List[AppExtension]) -> None:
-        """Create a Simple HsPyLib application.
-        :param app_name the application name.
-        :param app_ext the application extensions (gradle, git, ...).
-        """
-        sysout(f"Application: {app_name}")
-        self._create_base_app_struct(app_name)
-        self._mkfile(
-            f"src/main/{self._app_name}/__main__.py",
-            (self.TEMPLATES / "main.py.tpl").read_text().replace("%APP_NAME%", self._app_name),
-        )
-        self._apply_extensions(app_name, app_ext)
-
-    def _create_qt_app(self, app_name: str, app_ext: List[AppExtension]) -> None:
-        """Create an HsPyLib QT application.
-        :param app_name the application name.
-        :param app_ext the application extensions (gradle, git, ...).
-        """
-        sysout(f"QT Application: {app_name}")
-        self._create_base_app_struct(app_name)
-        self._mkdir(f"src/main/{self._app_name}/resources/forms")
-        self._mkfile(
-            f"src/main/{self._app_name}/resources/forms/main_qt_view.ui",
-            (self.TEMPLATES / "main_qt_view.ui.tpl").read_text(),
-        )
-        self._mkdir(f"src/main/{self._app_name}/view")
-        self._mkfile(
-            f"src/main/{self._app_name}/view/main_qt_view.py",
-            (self.TEMPLATES / "main_qt_view.py.tpl").read_text().replace("%APP_NAME%", self._app_name),
-        )
-        self._mkfile(
-            f"src/main/{self._app_name}/__main__.py",
-            (self.TEMPLATES / "main_qt.py.tpl").read_text().replace("%APP_NAME%", self._app_name),
-        )
-        self._apply_extensions(app_name, app_ext)
-
-    def _create_widget(self, app_name: str) -> None:
-        """Create an HsPyLib Widget application.
-        :param app_name the application name.
-        """
-        widget_name = camelcase(app_name).replace("_", "").replace(" ", "")
-        sysout(f"Widget: {widget_name}")
-        self._mkfile(
-            f"widget_{app_name.lower()}.py",
-            (self.TEMPLATES / "widget.py.tpl")
-            .read_text()
-            .replace("_WIDGET_NAME_", f"{camelcase(app_name, capitalized=True)}"),
-        )
-
-    def _create_base_app_struct(self, app_name: str) -> None:
-        """Create a base HsPyLib application structure and files.
-        :param app_name the application name.
-        """
-        self._mkdir()
-        self._mkfile("README.md", f"# {app_name}")
-        self._mkfile("MANIFEST.in")
-        self._mkdir("src")
-        self._mkdir("src/test")
-        self._mkfile("src/test/test_main.py", (self.TEMPLATES / "test_main.py.tpl").read_text())
-        self._mkdir("src/test/resources")
-        self._mkfile("src/test/resources/application-test.properties", "# Main test application property file")
-        self._mkdir("src/main")
-        self._mkdir(f"src/main/{self._app_name}")
-        self._mkfile(f"src/main/{self._app_name}/__classpath__.py", (self.TEMPLATES / "classpath.py.tpl").read_text())
-        self._mkfile(f"src/main/{self._app_name}/.version", str(INITIAL_REVISION))
-        self._mkfile(f"src/main/{self._app_name}/welcome.txt", WELCOME_MESSAGE)
-        self._mkdir(f"src/main/{self._app_name}/resources")
-        self._mkfile(f"src/main/{self._app_name}/resources/application.properties", "# Main application property file")
-        self._mkfile(".env", "# Type in here the environment variables your app requires")
-        self._mkfile("run.sh", (self.TEMPLATES / "run.sh.tpl").read_text().replace("%APP_NAME%", self._app_name))
-        self._chmod("run.sh")
-
-    def _mkdir(self, folder_name: str = "") -> None:
-        """Create a directory from the destination path, or the destination path itself.
-        :param folder_name the directory to be created.
-        """
-        dir_path = f"{self._app_dir}/{folder_name}"
-        sysout(f"  |- {dir_path}")
-        os.mkdir(dir_path)
-
-    def _mkfile(self, file_name: str, file_content: str = "") -> None:
-        """Create a file from the destination path with the specified content.
-        :param file_name the file name.
-        :param file_content the text based content of the file.
-        """
-        file_path = f"{self._app_dir}/{file_name}"
-        sysout(f"  |- {file_path}")
-        with open(f"{file_path}", "w", encoding=Charset.UTF_8.val) as fh:
-            fh.write(ensure_endswith(file_content, os.linesep))
-
-    def _chmod(self, file_name: str) -> None:
-        """Give execute permissions to the file.
-        :param file_name the file name
-        """
-        file_path = f"{self._app_dir}/{file_name}"
-        st = os.stat(file_path)
-        os.chmod(file_path, st.st_mode | stat.S_IEXEC)
-
-    def _apply_extensions(self, app_name: str, app_ext: List[AppExtension]) -> None:
-        """Apply the selected extensions to the app.
-        :param app_name the application name.
-        :param app_ext the application extensions (gradle, git, ...).
-        """
-        result = True
-
-        if result and AppExtension.GIT in app_ext:
-            sysout("Initializing git repository")
-            result &= self._init_git()
-        if result and AppExtension.GRADLE in app_ext:
-            sysout("Applying gradle extensions")
-            result &= self._init_gradle(app_name)
-
-        if result:
-            sysout("All app extensions successfully applied!")
-        else:
-            syserr("Failed to apply app extensions!")
-
-    def _init_gradle(self, app_name: str) -> bool:
-        """Initialize the as a gradle project.
-        :param app_name the application name.
-        """
-        sysout(f'Initializing "{app_name}" gradle project [press ENTER to continue] ...')
-        output, exit_code = Terminal.shell_exec(
-            f"gradle init --project-name {app_name} --type basic --dsl groovy", cwd=self._app_dir
-        )
-        sysout(f"Gradle execution result: {exit_code}%EOL%{output}%EOL%")
-
-        if exit_code == ExitStatus.SUCCESS:
-            sysout("Downloading gradle extensions ...")
-            self._download_gradle_ext("badges.gradle")
-            self._download_gradle_ext("build-info.gradle")
-            self._download_gradle_ext("dependencies.gradle")
-            self._download_gradle_ext("docgen.gradle")
-            self._download_gradle_ext("docker.gradle")
-            self._download_gradle_ext("pypi-publish.gradle")
-            self._download_gradle_ext("python.gradle")
-            sysout("Creating gradle files")
-            self._mkfile("gradle.properties", self.GRADLE_PROPS.format(self._app_name, INITIAL_REVISION).strip())
-            self._mkfile(
-                "build.gradle", (self.TEMPLATES / "build.gradle.tpl").read_text().replace("%APP_NAME%", self._app_name)
-            )
-            self._mkfile("dependencies.hspd", (self.TEMPLATES / "dependencies.hspd.tpl").read_text())
-            sysout("Building gradle project, please wait ...")
-            output, exit_code = Terminal.shell_exec("./gradlew buildOnly", cwd=self._app_dir)
-            sysout(f"Gradle execution result: {output}")
-
-        return exit_code == ExitStatus.SUCCESS
-
-    def _init_git(self) -> bool:
-        """Initialize a git repository for the project."""
-        self._mkfile(".gitignore", (self.TEMPLATES / "gitignore.tpl").read_text())
-        sysout("Initializing git repository ...")
-        output, exit_code = Terminal.shell_exec("git init", cwd=self._app_dir)
-        sysout(f"Git init result: {exit_code}%EOL%{output}%EOL%")
-        if exit_code:
-            sysout("Creating first commit")
-            Terminal.shell_exec("git add .", cwd=self._app_dir)
-            output, exit_code = Terminal.shell_exec('git commit -m "First commit [@HsPyLib]"', cwd=self._app_dir)
-            sysout(f"Git commit result: {exit_code}%EOL%{output}%EOL%")
-
-        return exit_code == ExitStatus.SUCCESS
-
-    def _download_gradle_ext(self, gradle_ext: str) -> None:
-        """Download a gradle extension from the HsPyLib repository.
-        :param gradle_ext the HsPyLib gradle extension to download.
-        """
-        urllib3.disable_warnings()  # Disable this warning because we trust our project repo
-        resp = get(f"https://raw.githubusercontent.com/yorevs/hspylib/master/gradle/{gradle_ext}")
-        check_argument(resp.status_code == HttpCode.OK, "Unable to download extension: '{}'", gradle_ext)
-        self._mkfile(f"gradle/{gradle_ext}", resp.body)

build/lib/clitt/addons/appman/appman_enums.py

@@ -1,39 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-
-"""
-   @project: HsPyLib-Clitt
-   @package: clitt.addons.appman
-      @file: appman_enums.py
-   @created: Fri, 29 Jul 2022
-    @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
-from typing import List
-
-
-class AppExtension(Enumeration):
-    """Appman available extensions."""
-
-    # fmt: off
-    GRADLE  = 'gradle'
-    GIT     = 'git'
-    # fmt: on
-
-
-class AppType(Enumeration):
-    """Appman supported application types."""
-
-    # fmt: off
-    APP     = 'app'
-    QT_APP  = 'qt-app'
-    WIDGET  = 'widget'
-    # fmt: on
-
-    @staticmethod
-    def choices() -> List[str]:
-        return AppType.values()

build/lib/clitt/addons/appman/templates/__init__.py

@@ -1,11 +0,0 @@
-# _*_ coding: utf-8 _*_
-#
-# hspylib-clitt v0.9.116
-#
-# Package: main.build.lib.build.lib.clitt.addons.appman.templates
-"""Package initialization."""
-
-__all__ = [
-    
-]
-__version__ = '0.9.116'

build/lib/clitt/addons/widman/__init__.py

@@ -1,14 +0,0 @@
-# _*_ coding: utf-8 _*_
-#
-# hspylib-clitt v0.9.116
-#
-# Package: main.build.lib.build.lib.clitt.addons.widman
-"""Package initialization."""
-
-__all__ = [
-    'widget', 
-    'widget_entry', 
-    'widgets', 
-    'widman'
-]
-__version__ = '0.9.116'

build/lib/clitt/addons/widman/widget.py

@@ -1,70 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-
-"""
-   @project: HsPyLib-Clitt
-   @package: clitt.addons.widman
-      @file: widget.py
-   @created: Fri, 29 Jul 2022
-    @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 abc import ABC, abstractmethod
-from clitt.core.icons.font_awesome.awesome import Awesome
-from hspylib.modules.application.exit_status import ExitStatus
-from hspylib.modules.application.version import Version
-from textwrap import dedent
-
-
-class Widget(ABC):
-    """HsPyLib_Widman base class. All widgets must inherit from this class to properly work."""
-
-    _USAGE_FMT = dedent(
-        """
-    HsPyLib Widget: {} v{}
-
-    {}
-
-    {}
-    """
-    )
-
-    def __init__(self, icon: Awesome, name: str, tooltip: str, usage: str, version: Version):
-        self._icon = icon
-        self._name = name
-        self._tooltip = tooltip
-        self._usage = usage
-        self._version = version
-
-    @abstractmethod
-    def execute(self, *args) -> ExitStatus:
-        """Execute the widget main flow.
-        :param args the widget arguments
-        """
-
-    def cleanup(self) -> None:
-        """Execute the widget cleanup."""
-
-    def icon(self) -> Awesome:
-        """Return the widget icon."""
-        return self._icon
-
-    def name(self) -> str:
-        """Return the name about the widget."""
-        return self._name
-
-    def tooltip(self) -> str:
-        """Return a tooltip information about the widget."""
-        return self._tooltip
-
-    def version(self) -> str:
-        """Return the version of the widget."""
-        return str(self._version)
-
-    def usage(self) -> str:
-        """Return a usage message about the widget."""
-        return self._USAGE_FMT.format(self._name, self._version, self._tooltip, self._usage)

build/lib/clitt/addons/widman/widget_entry.py

@@ -1,54 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-
-"""
-   @project: HsPyLib-Clitt
-   @package: clitt.addons.widman
-      @file: widget_entry.py
-   @created: Fri, 04 Jun 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.tools.text_tools import camelcase
-
-import os
-
-
-class WidgetEntry:
-    """Placeholder object for a HsPyLib::Widman Widget and details about it."""
-
-    # fmt: off
-    MODULE_PREFIX   = "widget_"
-    CLASS_PREFIX    = "Widget"
-    # fmt: on
-
-    def __init__(self, file: str, path: str):
-        self._module = os.path.splitext(file)[0]
-        self._name = camelcase(self.module.replace(self.MODULE_PREFIX, ""), capitalized=True)
-        self._clazz = f"{self.CLASS_PREFIX}{self.name.replace('_', '')}"
-        self._path = path
-
-    def __str__(self):
-        return f"{self.name}: {self.module}.{self.clazz} => {self.path}"
-
-    def __repr__(self):
-        return str(self)
-
-    @property
-    def name(self) -> str:
-        return self._name
-
-    @property
-    def module(self) -> str:
-        return self._module
-
-    @property
-    def clazz(self) -> str:
-        return self._clazz
-
-    @property
-    def path(self) -> str:
-        return self._path

build/lib/clitt/addons/widman/widgets/__init__.py

@@ -1,14 +0,0 @@
-# _*_ coding: utf-8 _*_
-#
-# hspylib-clitt v0.9.116
-#
-# Package: main.build.lib.build.lib.clitt.addons.widman.widgets
-"""Package initialization."""
-
-__all__ = [
-    'widget_free', 
-    'widget_punch', 
-    'widget_send_msg', 
-    'widget_time_calc'
-]
-__version__ = '0.9.116'

build/lib/clitt/addons/widman/widgets/widget_free.py

@@ -1,110 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-
-"""
-   @project: HsPyLib-Clitt
-   @package: clitt.addons.widman.widgets
-      @file: widget_free.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.addons.widman.widget import Widget
-from clitt.core.icons.font_awesome.widget_icons import WidgetIcons
-from clitt.core.term.terminal import Terminal
-from concurrent import futures
-from hspylib.core.tools.commons import human_readable_bytes, sysout
-from hspylib.modules.application.exit_status import ExitStatus
-from hspylib.modules.application.version import Version
-from hspylib.modules.cli.keyboard import Keyboard
-from textwrap import dedent
-from time import sleep
-
-import re
-
-
-class WidgetFree(Widget):
-    """HsPyLib Widget to Report current system memory usage"""
-
-    # fmt: off
-    WIDGET_ICON = WidgetIcons.CHIP
-    WIDGET_NAME = "Free"
-    VERSION     = Version(0, 2, 0)
-    TOOLTIP     = "Report system memory usage."
-    USAGE       = "Usage: Free"
-    # fmt: on
-
-    def __init__(self) -> None:
-        super().__init__(self.WIDGET_ICON, self.WIDGET_NAME, self.TOOLTIP, self.USAGE, self.VERSION)
-        self._is_alive = True
-        self._report_interval = 1.5
-        self._exit_code = ExitStatus.SUCCESS
-
-    def execute(self, *args) -> ExitStatus:
-        with futures.ThreadPoolExecutor() as executor:
-            done = False
-            while not done and not Keyboard.kbhit():
-                future = executor.submit(self._report_usage)
-                done = not future.result()
-                if not done:
-                    sleep(self._report_interval)
-        return self._exit_code
-
-    # pylint: disable=too-many-locals
-    @staticmethod
-    def _report_usage() -> bool:
-        """Display the memory usage for the cycle."""
-        ps, ec1 = Terminal.shell_exec("ps -caxm -orss,comm")  # Get process info
-        vm, ec2 = Terminal.shell_exec("vm_stat")  # Grabbing memory characteristics
-
-        if ec1 == ExitStatus.SUCCESS and ec2 == ExitStatus.SUCCESS and ps:
-            process_lines = ps.split("\n")  # Iterate processes
-            sep = re.compile(" +")
-            rss_total = 0  # kB
-
-            for row in range(1, len(process_lines)):
-                row_text = process_lines[row].strip()
-                row_elements = sep.split(row_text)
-                if re.match("^[0-9]+$", row_elements[0]):
-                    rss = float(row_elements[0]) * 1024
-                else:
-                    rss = 0
-                rss_total += rss
-
-            vm_lines = vm.split("\n")  # Process vm_stat
-            sep = re.compile(": +")
-            vm_stats = {}
-
-            for row in range(1, len(vm_lines) - 2):
-                row_text = vm_lines[row].strip()
-                row_elements = sep.split(row_text)
-                vm_stats[(row_elements[0])] = int(row_elements[1].strip("\\.")) * 4096
-
-            wired, wu = human_readable_bytes(vm_stats["Pages wired down"])
-            active, au = human_readable_bytes(vm_stats["Pages active"])
-            inactive, iu = human_readable_bytes(vm_stats["Pages inactive"])
-            free, fu = human_readable_bytes(vm_stats["Pages free"])
-            real, ru = human_readable_bytes(rss_total)  # Total memory
-
-            sysout(
-                dedent(
-                    f"""
-            %HOM%%ED2%%MOD(0)%
-            %ORANGE%Reporting system memory usage:%NC%
-            {'-' * 30}
-            %GREEN%   Wired Memory: {wired:6s} {wu:2s}
-            %GREEN%  Active Memory: {active:6s} {au:2s}
-            %GREEN%Inactive Memory: {inactive:6s} {iu:2s}
-            %GREEN%    Free Memory: {free:6s} {fu:2s}
-            %GREEN%    Real Memory: {real:6s} {ru:2s}
-
-            %YELLOW%Press [Enter] to exit ..."""
-                )
-            )
-
-            return True
-
-        return False