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

build/lib/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/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/build/lib/clitt/addons/widman/widgets/__init__.py

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

build/lib/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

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

@@ -1,246 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-
-"""
-   @project: HsPyLib-Clitt
-   @package: clitt.addons.widman.widgets
-      @file: widget_punch.py
-   @created: Thu, 20 Sep 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 clitt.addons.widman.widget import Widget
-from clitt.addons.widman.widgets.widget_time_calc import WidgetTimeCalc
-from clitt.core.icons.font_awesome.widget_icons import WidgetIcons
-from clitt.core.term.terminal import Terminal
-from hspylib.core.enums.charset import Charset
-from hspylib.core.exception.exceptions import WidgetExecutionError
-from hspylib.core.tools.commons import syserr, sysout
-from hspylib.core.zoned_datetime import now
-from hspylib.modules.application.argparse.argument_parser import HSArgumentParser
-from hspylib.modules.application.exit_status import ExitStatus
-from hspylib.modules.application.version import Version
-from textwrap import dedent
-from typing import List
-
-import argparse
-import os
-import re
-import sys
-
-
-class WidgetPunch(Widget):
-    """HsPyLib Widget to Report current system memory usage"""
-
-    # fmt: off
-    WIDGET_ICON = WidgetIcons.PUNCH
-    WIDGET_NAME = "Punch"
-    VERSION     = Version(0, 1, 0)
-    TOOLTIP     = "!!! PUNCH THE CLOCK !!!"
-    USAGE       = dedent("""
-    "Usage: ${FUNCNAME[0]} [options] <args>"
-
-      Options: '
-        -l        : List all registered punches.'
-        -e        : Edit current punch file.'
-        -r        : Reset punches for the current week and save the previous one.'
-        -w <week> : Report (list) all punches of specified week using the pattern: week-N.punch.'
-
-      Notes: '
-        When no arguments are provided it will !!PUNCH THE CLOCK!!.'
-    """)
-
-    HHS_DIR             = os.getenv("HHS_PUNCH_FILE", os.getenv("HOME", "/"))
-
-    HHS_PUNCH_FILE      = os.getenv("HHS_PUNCH_FILE", f"-{HHS_DIR}/.punches")
-
-    DATE_STAMP          = now("%a %d-%m-%Y")
-
-    TIME_STAMP          = now("%H:%M")
-
-    WEEK_STAMP          = int(now("%V"))
-
-    RE_TODAY_PUNCH_LINE = rf"({DATE_STAMP}).*"
-
-    RE_PUNCH_LINE       = r"^((Mon|Tue|Wed|Thu|Fri|Sat|Sun) )(([0-9]+-?)+) =>.*"
-
-    MAX_PUNCHES         = 7  # 7 week days. Do you work on Saturdays and Sundays ?? :~
-
-    # fmt: on
-
-    @staticmethod
-    def _daily_total(daily_punches: List[str], decimal: bool = False) -> str:
-        """Calculate the total time from the daily punches.
-        :param daily_punches the list of daily punches.
-        :param decimal return the total as a decimal number.
-        """
-        # Up to 3 pairs of timestamps: morning, afternoon and evening
-        if (n := len(daily_punches)) > 0 and n % 2 == 0:
-            stamps = []
-            stamps += [daily_punches[1], "-", daily_punches[0], "+"] if n // 2 >= 1 else []  # Morning
-            stamps += [daily_punches[3], "-", daily_punches[2], "+"] if n // 2 >= 2 else []  # Afternoon
-            stamps += [daily_punches[5], "-", daily_punches[4]] if n // 2 >= 3 else []  # Evening
-            h, m, _ = WidgetTimeCalc.calc_time(*stamps)
-            m = WidgetTimeCalc.to_decimal(m) if decimal else m
-            return f"{'%GREEN%' if h >= 8 else '%RED%'}{h:02d}{'.' if decimal else ':'}{m:02d}%NC%"
-
-        return f"%RED%--{'.' if decimal else ':'}--%NC%"
-
-    def __init__(self) -> None:
-        super().__init__(self.WIDGET_ICON, self.WIDGET_NAME, self.TOOLTIP, self.USAGE, self.VERSION)
-
-        self._exit_code = ExitStatus.SUCCESS
-        self._fn = self._do_the_punch
-        self._args = None
-        self._today = None
-        self._punches = []
-        self._total_hour = self._total_min = 0
-        self._week_num = self.WEEK_STAMP
-
-    def execute(self, *args) -> ExitStatus:
-        # Create the current week punch file if it does not yet exist.
-        if not os.path.exists(self.HHS_PUNCH_FILE):
-            with open(self.HHS_PUNCH_FILE, "w", encoding=Charset.UTF_8.val) as f_punch:
-                f_punch.write(f"{now('%d-%m-%Y')} => ")
-
-        ret_val = self._parse_args(*args)
-
-        if not ret_val:
-            return ExitStatus.ABORTED
-
-        if self._args:
-            if "list" == self._args.action:
-                self._punches = self._read_punches(self.HHS_PUNCH_FILE)
-                self._fn = self._list_punches
-            elif "week" == self._args.action:
-                punch_dir = os.path.dirname(self.HHS_PUNCH_FILE)
-                self._week_num = self._args.week_num
-                self._punches = self._read_punches(f"{punch_dir}/week-{self._week_num:02d}.punch")
-                self._fn = self._list_punches
-            elif "edit" == self._args.action:
-                self._fn = self._edit_punches
-            elif "reset" == self._args.action:
-                self._fn = self._reset_punches
-        else:
-            self._punches = self._read_punches(self.HHS_PUNCH_FILE)
-
-        self._fn()
-
-        return ExitStatus.SUCCESS
-
-    def _parse_args(self, *args) -> bool:
-        """When arguments are passed from the command line, parse them.
-        :param args the widget arguments
-        """
-
-        if not args:
-            return True
-
-        parser = HSArgumentParser(
-            prog="punch",
-            prefix_chars="+",
-            formatter_class=argparse.RawDescriptionHelpFormatter,
-            description="PUNCH-THE-CLOCK. This is a helper tool to aid with the timesheet.",
-        )
-
-        subparsers = parser.add_subparsers(title="action", dest="action")
-        subparsers.add_parser("list", help="list all registered punches.")
-        subparsers.add_parser("edit", help="edit current punch file.")
-        subparsers.add_parser("reset", help="reset punches for the current week and save the previous one.")
-
-        w_parser = subparsers.add_parser("week", help="list all punches of the specified week-num (week-N.punch).")
-        w_parser.add_argument("week_num", type=int, default=1, help="the week number")
-
-        self._args = parser.parse_args(args)
-
-        return bool(self._args)
-
-    def _read_punches(self, punch_file: str) -> List[str]:
-        """Read all punches from the punch file.
-        :param punch_file the punch file path
-        """
-        if not os.path.exists(punch_file):
-            syserr(f"Punch file '{punch_file}' not found !")
-            raise FileNotFoundError(f"Punch file '{punch_file}' not found !")
-
-        with open(punch_file, "r", encoding=Charset.UTF_8.val) as f_punch:
-            all_punches = list(
-                map(self._set_today, filter(lambda l: re.match(self.RE_PUNCH_LINE, l), f_punch.readlines()))
-            )
-            if len(all_punches) > self.MAX_PUNCHES:
-                sysout(f"%RED%Punch file contains more than {self.MAX_PUNCHES} punch lines !%NC%")
-                sys.exit(int(str(ExitStatus.FAILED.value)))
-            return all_punches
-
-    def _is_today(self, punch_line: str) -> bool:
-        """Whether the punch line refer to today's date.
-        :param punch_line a line read from the punch file (following the punch syntax).
-        """
-        return bool(re.match(self.RE_TODAY_PUNCH_LINE, punch_line))
-
-    def _set_today(self, punch_line: str) -> str:
-        """Set the today's date if the line represents today.
-        :param punch_line a line read from the punch file (following the punch syntax).
-        """
-        if not self._today and self._is_today(punch_line):
-            self._today = punch_line
-        return punch_line
-
-    def _do_the_punch(self) -> None:
-        """Punch the clock."""
-        with open(self.HHS_PUNCH_FILE, "w", encoding=Charset.UTF_8.val) as f_punch:
-            if not self._today:  # Write the first punch of the day
-                self._today = f"{self.DATE_STAMP} => {self.TIME_STAMP}"
-                self._punches.append(self._today)
-            elif self._today.count(":") < 6:  # Only allowed 3 groups of 3 pairs of punches
-                pat = rf"({self.DATE_STAMP}) => (.*)"
-                if mat := re.match(pat, self._today):
-                    self._today = re.sub(pat, f"{mat.group(1)} => {mat.group(2)} {self.TIME_STAMP} ", self._today)
-                else:
-                    raise WidgetExecutionError("Invalid punch file!")
-                self._punches[-1] = self._today
-            list(map(f_punch.write, [f"{punch.strip()}\n" for punch in self._punches]))
-        sysout(f"{re.sub(self.DATE_STAMP, '%GREEN%Today%NC%', self._today)} ")
-
-    def _list_punches(self) -> None:
-        """List all punches from the punch file."""
-        total = 0, 0
-        total_dec = 0, 0
-        sysout(f"\n%WHITE%Week-{self._week_num:02d} Punches%NC%")
-        sysout("-" * 82)
-        for punch_line in self._punches:
-            daily_punches = punch_line[17:].strip().split()
-            n = len(daily_punches)
-            padding = "." * (35 if n == 0 else (36 - n * 6))
-            line_color = "%BLUE%" if self._is_today(punch_line) else ""
-            sysout(f"{line_color}{punch_line[:17]} {' '.join(daily_punches) + (' ' if n % 2 != 0 else '')}", end="")
-            daily_total = self._daily_total(daily_punches)
-            daily_total_dec = self._daily_total(daily_punches, decimal=True)
-            if n > 0 and n % 2 == 0:
-                sysout(f" {padding} : Subtotal = {daily_total} -> {daily_total_dec}%NC%")
-                total = WidgetTimeCalc.calc_time(f"{total[0]}:{total[1]}", "+", daily_total[-9:-4])
-                total_dec = total[0], WidgetTimeCalc.to_decimal(total[1])
-            else:
-                sysout(f"{daily_total}%NC%")
-        sysout("-" * 82)
-        bh, bm, _ = WidgetTimeCalc.calc_time(f"{total[0]}:{total[1]}", "-", "40:00")
-        balance = f"{'%BLUE%' if bh >= 0 else '%RED%'}{bh:02d}:{bm:02d}%NC%"
-        totals = f"{total[0]:02d}:{total[1]:02d} -> {total_dec[0]:02d}.{total_dec[1]:02d}"
-        sysout(f"%WHITE%Total: ({totals})  Balance: {balance}\n")
-
-    def _edit_punches(self) -> None:
-        """Open the default system editor to edit punches."""
-        Terminal.open(self.HHS_PUNCH_FILE)
-
-    def _reset_punches(self) -> None:
-        """Rename the punch file as a weekly punch file and reset current punch file."""
-        punch_dir = os.path.dirname(self.HHS_PUNCH_FILE)
-        new_name = f"{punch_dir}/week-{self._week_num:02d}.punch"
-        if os.path.exists(new_name):
-            sysout(f"%RED%Punch file '{new_name}' already exists!")
-        else:
-            os.rename(self.HHS_PUNCH_FILE, new_name)
-            sysout(f"%YELLOW%Punch file {self.HHS_PUNCH_FILE} renamed to {new_name}")