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

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

@@ -0,0 +1,54 @@
+#!/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/build/lib/clitt/addons/widman/widgets/__init__.py

@@ -0,0 +1,14 @@
+# _*_ coding: utf-8 _*_
+#
+# hspylib-clitt v0.9.120
+#
+# 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.120'

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

@@ -0,0 +1,110 @@
+#!/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/build/lib/clitt/addons/widman/widgets/widget_punch.py

@@ -0,0 +1,246 @@
+#!/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}")