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

build/lib/build/lib/build/lib/clitt/utils/git_utils.py

@@ -0,0 +1,66 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+"""
+   @project: HsPyLib
+   @package: clitt.utils
+      @file: git_utils.py
+   @created: Nov 14, 2019
+    @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 hspylib.modules.application.exit_status import ExitStatus
+from typing import Tuple
+
+
+class GitTools:
+    """TODO"""
+
+    @staticmethod
+    def top_level_dir() -> Tuple[str, ExitStatus]:
+        """TODO"""
+        return Terminal.shell_exec("git rev-parse --show-toplevel")
+
+    @staticmethod
+    def current_branch() -> Tuple[str, ExitStatus]:
+        """TODO"""
+        return Terminal.shell_exec("git symbolic-ref --short HEAD")
+
+    @staticmethod
+    def changelog(from_tag: str, to_tag: str) -> Tuple[str, ExitStatus]:
+        """TODO"""
+        return Terminal.shell_exec(f"git log --oneline --pretty='format:%h %ad %s' --date=short {from_tag}^..{to_tag}^")
+
+    @staticmethod
+    def unreleased() -> Tuple[str, ExitStatus]:
+        """TODO"""
+        latest_tag = Terminal.shell_exec("git describe --tags --abbrev=0 HEAD^")
+        return Terminal.shell_exec(f"git log --oneline --pretty='format:%h %ad %s' --date=short '{latest_tag}'..HEAD")
+
+    @staticmethod
+    def release_date(tag_name: str) -> Tuple[str, ExitStatus]:
+        """TODO"""
+        return Terminal.shell_exec(f"git log -1 --pretty='format:%ad' --date=short {tag_name}")
+
+    @staticmethod
+    def tag_list() -> Tuple[str, ExitStatus]:
+        """TODO"""
+        return Terminal.shell_exec("git log --tags --simplify-by-decoration --pretty='format:%ci %d'")
+
+    @staticmethod
+    def create_tag(version: str, commit_id: str = "HEAD", description: str = None) -> Tuple[str, ExitStatus]:
+        """TODO"""
+        return Terminal.shell_exec(f"git tag -a v{version} {commit_id} -m '{description or version}'")
+
+    @staticmethod
+    def search_logs(filter_by: str = ".*") -> Tuple[str, ExitStatus]:
+        """TODO"""
+        return Terminal.shell_exec(f"git log --grep='{filter_by}' --pretty=format:'%h %ad %s' --date=short")
+
+    @staticmethod
+    def show_file(filename: str, commit_id: str = "HEAD") -> Tuple[str, ExitStatus]:
+        return Terminal.shell_exec(f"git show {commit_id}:{filename}")

build/lib/build/lib/clitt/__classpath__.py

@@ -0,0 +1,28 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+"""
+   @project: HsPyLib-Clitt
+   @package: clitt
+      @file: __classpath__.py
+   @created: Fri, 23 Dec 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.metaclass.classpath import Classpath
+from hspylib.core.tools.commons import get_path, run_dir
+
+
+class _Classpath(Classpath):
+    """Provide a class to help locating user-defined classes, packages, sources and resources."""
+
+    def __init__(self):
+        super().__init__(get_path(__file__), get_path(run_dir()), (get_path(__file__) / "resources"))
+
+
+# Instantiate the classpath singleton
+assert (classpath := _Classpath().INSTANCE) is not None, "Failed to create Classpath instance"

build/lib/build/lib/clitt/__init__.py

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

build/lib/build/lib/clitt/__main__.py

@@ -0,0 +1,139 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+"""
+   @project: hspylib
+   @package: hspylib
+      @file: __main__.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.__classpath__ import classpath
+from clitt.addons.appman.appman import AppManager
+from clitt.addons.appman.appman_enums import AppExtension, AppType
+from clitt.addons.widman.widman import WidgetManager
+from clitt.core.tui.tui_application import TUIApplication
+from hspylib.core.enums.charset import Charset
+from hspylib.core.enums.enumeration import Enumeration
+from hspylib.core.tools.commons import run_dir, syserr
+from hspylib.core.tools.text_tools import strip_linebreaks
+from hspylib.modules.application.exit_status import ExitStatus
+from hspylib.modules.application.version import Version
+
+import sys
+
+
+class Main(TUIApplication):
+    """HsPyLib CLI Terminal Tools - Create professional CLI applications."""
+
+    # The welcome message
+    DESCRIPTION = classpath.get_source("welcome.txt").read_text(encoding=Charset.UTF_8.val)
+
+    # Location of the .version file
+    VERSION_DIR = classpath.source_path()
+
+    class Addon(Enumeration):
+        """HsPyLib addon types."""
+
+        # fmt: off
+        APPMAN      = 'appman'
+        WIDGETS     = 'widgets'
+        # fmt: on
+
+        @property
+        def val(self) -> str:
+            return str(self.value)
+
+    def __init__(self, app_name: str):
+        version = Version.load(load_dir=self.VERSION_DIR)
+        super().__init__(app_name, version, self.DESCRIPTION.format(version))
+
+    def _setup_arguments(self) -> None:
+        """Initialize application parameters and options."""
+
+        # fmt: off
+        self._with_chained_args('application', 'the HsPyLib-Clitt addon to run') \
+            .argument(
+                    self.Addon.APPMAN.val,
+                    'app Application Manager: Create HsPyLib-Clitt based python applications') \
+                .add_option(
+                    'dest-dir', 'd', 'dest-dir',
+                    'the destination directory. If omitted, the current directory will be used.',
+                    nargs='?', default=self._run_dir) \
+                .add_parameter(
+                    'app-name', 'the application name', nargs='?') \
+                .add_parameter(
+                    'app-type',
+                    'the application type. Appman is going to scaffold a basic application based on the app type',
+                    choices=AppType.choices(), nargs='?') \
+                .add_parameter(
+                    'app-ext',
+                    '"gradle" is going to initialize you project with gradle (requires gradle). '
+                    '"git" is going to initialize a git repository (requires git)', nargs='*') \
+            .argument(self.Addon.WIDGETS.val, 'app Widgets Manager: Execute an HsPyLib widget') \
+                .add_parameter(
+                    'widget-name',
+                    'the name of the widget to be executed. If omitted, all available widgets will be '
+                    'presented in a dashboard',
+                    nargs='?') \
+                .add_parameter(
+                    'widget-args', "the widget's arguments (if applicable)", nargs='*')
+
+    def _main(self, *params, **kwargs) -> ExitStatus:
+        """Main entry point handler."""
+        return self._exec_application()
+
+    def _exec_application(self) -> ExitStatus:
+        """Execute the application main flow."""
+
+        app = self.get_arg("application")
+        if app == self.Addon.APPMAN.val:
+            self.start_appman()
+        elif app == self.Addon.WIDGETS.val:
+            self.start_widman()
+        else:
+            syserr(f"### Invalid Addon application: {app}")
+            self.usage(ExitStatus.FAILED)
+
+        return ExitStatus.SUCCESS
+
+    def start_widman(self) -> None:
+        """Start the Widman application."""
+        addon = WidgetManager(self)
+        widget_name = self.get_arg("widget-name")
+        if widget_name:
+            widget_args = list(map(strip_linebreaks, self.get_arg("widget-args")))
+            addon.execute(widget_name, *widget_args)
+        else:
+            addon.dashboard()
+
+    def start_appman(self) -> None:
+        """Start the Appman application."""
+        addon = AppManager(self)
+        app_type = self.get_arg("app-type")
+        if app_type:
+            app_ext = self.get_arg("app-ext")
+            addon.create(
+                self.get_arg("app-name"),
+                AppType.of_value(app_type),
+                list(map(AppExtension.value_of, app_ext)) if app_ext else [],
+                self.get_arg("dest-dir") or run_dir(),
+            )
+        else:
+            args = addon.prompt()
+            if args:
+                app_ext = []
+                if args.initialize_gradle:
+                    app_ext.append(AppExtension.GRADLE)
+                if args.initialize_git:
+                    app_ext.append(AppExtension.GIT)
+                addon.create(args.app_name, AppType.of_value(args.app_type), list(app_ext), args.dest_dir or run_dir())
+
+
+# Application entry point
+if __name__ == "__main__":
+    Main("clitt").INSTANCE.run(sys.argv[1:])

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

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

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

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

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

@@ -0,0 +1,305 @@
+#!/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/build/lib/clitt/addons/appman/appman_enums.py

@@ -0,0 +1,39 @@
+#!/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/build/lib/clitt/addons/appman/templates/__init__.py

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

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

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