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

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}")

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

@@ -0,0 +1,272 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+"""
+   @project: HsPyLib-Clitt
+   @package: clitt.addons.widman.widgets
+      @file: widget_send_msg.py
+   @created: Thu, 26 Aug 2017
+    @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.tui.minput.input_validator import InputValidator
+from clitt.core.tui.minput.minput import MenuInput, minput
+from hspylib.core.exception.exceptions import WidgetExecutionError
+from hspylib.core.tools.commons import hook_exit_signals, sysout
+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 hspylib.modules.cli.keyboard import Keyboard
+from textwrap import dedent
+from time import sleep
+
+import os
+import socket
+import threading
+
+
+class WidgetSendMsg(Widget):
+    """HsPyLib Widget to send TCP/UDP messages (multi-threaded)"""
+
+    # fmt: off
+    MAX_THREADS     = 1000
+    NET_TYPE_UDP    = "UDP"
+    NET_TYPE_TCP    = "TCP"
+
+    WIDGET_ICON     = WidgetIcons.NETWORK
+    WIDGET_NAME     = "SendMsg"
+    VERSION         = Version(0, 3, 0)
+    TOOLTIP         = "Multi-Threaded IP Message Sender. Sends TCP/UDP messages"
+    USAGE           = dedent(f"""Usage: SendMsg [options]
+
+      Options:
+        +n, ++net_type   <network_type>     : The network type to be used. Either udp or tcp ( default is tcp ).
+        +p, ++port       <port_num>         : The port number [1-65535] ( default is 12345).
+        +a, ++address    <host_address>     : The address of the datagram receiver ( default is 127.0.0.1 ).
+        +k, ++packets    <num_packets>      : The number of max datagrams to be send. If zero is specified, then the app
+                                              is going to send indefinitely ( default is 100 ).
+        +i, ++interval   <interval_MS>      : The interval in seconds between each datagram ( default is 1 Second ).
+        +t, ++threads    <threads_num>      : Number of threads [1-{MAX_THREADS}] to be opened to send simultaneously
+                                              ( default is 1 ).
+        +m, ++message    <message/filename> : The message to be sent. If the message matches a filename, then the file
+                                              contents sent instead.
+
+        E.g:. send-msg.py +n tcp +m "Hello" +p 12345 +a 0.0.0.0 +k 100 +i 500 +t 2
+    """)
+    # 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.net_type = None
+        self.host = None
+        self.packets = None
+        self.interval = None
+        self.threads = None
+        self.message = None
+        self._args = None
+        self.socket = None
+        self.counter = 1
+
+    def execute(self, *args) -> ExitStatus:
+        hook_exit_signals(self.cleanup)
+        if args and args[0] in ["-h", "--help"]:
+            sysout(self.usage())
+            return ExitStatus.SUCCESS
+        if args and args[0] in ["-v", "--version"]:
+            sysout(self.version())
+            return ExitStatus.SUCCESS
+        if args and not self._parse_args(*args):
+            return ExitStatus.ERROR
+        if not args and not self._prompt():
+            return ExitStatus.ERROR
+        if not args and not self._args:
+            return ExitStatus.ERROR
+
+        self.net_type = self._args.net_type or self.NET_TYPE_TCP
+        self.host = (self._args.address or "127.0.0.1", self._args.port or 12345)
+        self.packets = self._args.packets or 100
+        self.interval = self._args.interval or 1
+        self.threads = self._args.threads or 1
+
+        if self._args.message and os.path.isfile(self._args.message):
+            file_size = os.stat(self._args.message).st_size
+            sysout(f"Reading contents from file: {self._args.message} ({file_size}) [Bs] instead")
+            with open(self._args.message, "r", encoding="utf-8") as f_msg:
+                self.message = f_msg.read()
+        else:
+            self.message = self._args.message or f"This is a {self._args.net_type} test %(count)"
+
+        self._start_send()
+
+        Keyboard.wait_keystroke()
+
+        return ExitStatus.SUCCESS
+
+    def cleanup(self) -> None:
+        """Stops workers and close socket connection."""
+        sysout("Terminating threads%NC%")
+        self.is_alive = False
+        if self.net_type == self.NET_TYPE_TCP:
+            sysout("Closing TCP connection")
+            self.socket.close()
+
+    def _prompt(self) -> bool:
+        """When no input is provided (e.g:. when executed from dashboard). Prompt the user for the info."""
+        # fmt: off
+        form_fields = MenuInput.builder() \
+            .field() \
+                .label('Net Type') \
+                .itype('select') \
+                .value(f"{self.NET_TYPE_TCP}|{self.NET_TYPE_UDP}") \
+                .build() \
+            .field() \
+                .label('Address') \
+                .validator(InputValidator.custom(r"^([0-9]{0,3}){0,1}(\.[0-9]{0,3}){0,3}$")) \
+                .value('127.0.0.1') \
+                .build() \
+            .field() \
+                .label('Port') \
+                .validator(InputValidator.numbers()) \
+                .min_max_length(2, 5) \
+                .value(12345) \
+                .build() \
+            .field() \
+                .label('Packets') \
+                .validator(InputValidator.numbers()) \
+                .min_max_length(1, 4) \
+                .value(100) \
+                .build() \
+            .field() \
+                .label('Interval') \
+                .validator(InputValidator.numbers()) \
+                .min_max_length(1, 4) \
+                .value(1) \
+                .build() \
+            .field() \
+                .label('Threads') \
+                .validator(InputValidator.numbers()) \
+                .min_max_length(1, 4) \
+                .value(1) \
+                .build() \
+            .field() \
+                .label('Message') \
+                .validator(InputValidator.anything()) \
+                .min_max_length(1, 40) \
+                .value('This is a test') \
+                .build() \
+            .build()
+        # fmt: on
+        self._args = minput(form_fields)
+        sysout("%HOM%%ED2%%MOD(0)%", end="")
+
+        return len(self._args) > 1 if self._args else False
+
+    def _parse_args(self, *args):
+        """When arguments are passed from the command line, parse them.
+        :param args the widget arguments
+        """
+        parser = HSArgumentParser(
+            prog="sendmsg", prefix_chars="+", description="Sends TCP/UDP messages (multi-threaded)"
+        )
+        # fmt: off
+        parser.add_argument(
+            "+n", "++net-type", action="store", choices=["udp", "tcp"],
+            type=str, default="tcp", required=False,
+            help="The network type to be used. Either udp or tcp ( default is tcp )",
+        )
+        parser.add_argument(
+            "+a", "++address", action="store",
+            type=str, default="127.0.0.1", required=False,
+            help="The address of the datagram receiver ( default is 127.0.0.1 )",
+        )
+        parser.add_argument(
+            "+p", "++port", action="store",
+            type=int, default=12345, required=False,
+            help="The port number [1-65535] ( default is 12345)",
+        )
+        parser.add_argument(
+            "+k", "++packets", action="store",
+            type=int, default=100, required=False,
+            help="The number of max datagrams to be send. If zero is specified, then the app "
+                 "is going to send indefinitely ( default is 100 ).",
+        )
+        parser.add_argument(
+            "+i", "++interval", action="store",
+            type=float, default=1, required=False,
+            help="The interval in seconds between each datagram ( default is 1 Second )",
+        )
+        parser.add_argument(
+            "+t", "++threads", action="store",
+            type=int, default=1, required=False,
+            help=f"Number of threads [1-{self.MAX_THREADS}] to be opened to send simultaneously ( default is 1 )",
+        )
+        parser.add_argument(
+            "+m", "++message", action="store",
+            type=str, required=False,
+            help="The message to be sent. If the message matches a filename, then the file contents sent instead",
+        )
+        # fmt: on
+        self._args = parser.parse_args(*args)
+
+        return bool(self._args)
+
+    def _init_sockets(self) -> None:
+        """Initialize sockets."""
+        if self.net_type == self.NET_TYPE_UDP:
+            self.socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+        else:
+            self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+            try:
+                self.socket.connect(self.host)
+                sysout(f"Successfully connected to {self.host}")
+            except socket.error as err:
+                raise WidgetExecutionError("Unable to initialize sockets") from err
+
+    def _start_send(self) -> None:
+        """Start sending packets."""
+        thread_relief = 0.05
+        self._init_sockets()
+        sysout(
+            f"\n%ORANGE%Start sending {self.packets} "
+            f"{self.net_type.upper()} packet(s) "
+            f"every {self.interval} second(s) to {self.host} using {self.threads} thread(s)"
+        )
+        threads_num = threading.active_count()
+
+        for thread_num in range(1, int(self.threads) + 1):
+            tr = threading.Thread(target=self._send_packet, args=(thread_num,))
+            tr.daemon = True
+            tr.start()
+            sleep(thread_relief)
+
+        while self.is_alive and threading.active_count() > threads_num:
+            sleep(2 * thread_relief)
+
+    def _send_packet(self, thread_num: int) -> None:
+        """Send a packet."""
+        lock = threading.Lock()
+
+        while self.is_alive and self.packets <= 0 or self.counter <= self.packets:
+            message = self.message.replace("%(count)", str(self.counter))
+            length = len(message)
+            sysout(
+                f"%BLUE%[Thread-{thread_num:d}] "
+                f'%GREEN%Sending "{message:s}" ({length:d}) bytes, '
+                f"Pkt = {self.counter:>d}/{self.packets:>d} %NC%..."
+            )
+            if self.net_type == self.NET_TYPE_UDP:
+                self.socket.sendto(message.encode(), self.host)
+            else:
+                try:
+                    self.socket.sendall((message + "\n").encode())
+                    with lock:
+                        self.counter += 1
+                except socket.error as err:
+                    raise WidgetExecutionError("Unable to send packet") from err
+            sleep(self.interval)

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

@@ -0,0 +1,146 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+"""
+   @project: HsPyLib-Clitt
+   @package: clitt.addons.widman.widgets
+      @file: widget_time_calc.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.tui.minput.minput import MenuInput, minput
+from hspylib.core.exception.exceptions import WidgetExecutionError
+from hspylib.core.tools.commons import sysout
+from hspylib.modules.application.exit_status import ExitStatus
+from hspylib.modules.application.version import Version
+from typing import Optional, Tuple
+
+import math
+import re
+
+
+class WidgetTimeCalc(Widget):
+    """HsPyLib Widget to calculate time based operations."""
+
+    # fmt: off
+    WIDGET_ICON = WidgetIcons.CLOCK
+    WIDGET_NAME = "TimeCalc"
+    VERSION     = Version(0, 1, 0)
+    TOOLTIP     = "Calculate time based operations."
+    USAGE       = "Usage: TimeCalc [+d|++decimal] <HH1:MM1[:SS1]> <+|-> <HH2:MM2[:SS2]>"
+    # fmt: on
+
+    @staticmethod
+    def to_decimal(time_raw: int = 0) -> int:
+        """Convert a raw time into decimal.
+        :param time_raw the raw time to be converted.
+        """
+        return int(round(((time_raw / 60.00) * 100.00)))
+
+    @staticmethod
+    def calc_time(*args) -> Tuple[int, int, int]:
+        """Calculate the time resulted from the specified operations.
+        :param args the widget arguments
+        """
+        op, total_seconds = "+", 0
+        for tm in args:
+            if not tm:
+                continue
+            if re.match(r"[+-]", tm):
+                op = tm
+            elif re.match(r"^([0-9]{1,2}:?)+", tm):
+                try:
+                    parts = [int(math.floor(float(s))) for s in tm.split(":")]
+                except ValueError as err:
+                    raise WidgetExecutionError(f"Unable to extract time parts from '{tm}'") from err
+                f_hours = parts[0] if len(parts) > 0 else 0
+                f_minutes = parts[1] if len(parts) > 1 else 0
+                f_secs = parts[2] if len(parts) > 2 else 0
+                tm_amount = (f_hours * 60 + f_minutes) * 60 + f_secs
+                if op == "+":
+                    total_seconds += tm_amount
+                elif op == "-":
+                    total_seconds -= tm_amount
+            else:
+                raise WidgetExecutionError(f"Invalid time input: '{tm}'")
+        total_seconds, seconds = divmod(total_seconds, 60)
+        hours, minutes = divmod(abs(total_seconds), 60)
+
+        return hours if total_seconds > 0 else -1 * hours, minutes, seconds
+
+    def __init__(self) -> None:
+        super().__init__(self.WIDGET_ICON, self.WIDGET_NAME, self.TOOLTIP, self.USAGE, self.VERSION)
+
+        self._decimal = False
+        self._args = None
+
+    def _parse_args(self, *args) -> Optional[ExitStatus]:
+        """Parse command line arguments.
+        :param args the widget arguments
+        """
+
+        if not args and not self._read_args():
+            return ExitStatus.ABORTED
+        if args and any(a in args for a in ["+h", "++help"]):
+            sysout(self.usage())
+            return ExitStatus.SUCCESS
+        if args and any(a in args for a in ["+v", "++version"]):
+            sysout(self.version())
+            return ExitStatus.SUCCESS
+        if args and any(a in args for a in ["+d", "++decimal"]):
+            self._decimal = True
+            args = args[1:]
+        if not self._args:
+            self._args = args
+
+        return None
+
+    def execute(self, *args) -> ExitStatus:
+        ret_val = self._parse_args(*args)
+
+        if ret_val is not None:
+            return ret_val
+
+        hours, minutes, seconds = self.calc_time(*self._args)
+
+        if self._decimal:
+            print(f"{hours:02d}.{self.to_decimal(minutes):02d}.{self.to_decimal(seconds):02d}")
+        else:
+            print(f"{hours:02d}:{minutes:02d}:{seconds:02d}")
+
+        return ExitStatus.SUCCESS
+
+    def _read_args(self) -> bool:
+        """When no input is provided (e.g:. when executed from dashboard). Prompt the user for the info."""
+        # fmt: off
+        form_fields = MenuInput.builder() \
+            .field() \
+                .label('Time 1') \
+                .itype('masked') \
+                .value('|##:##:##') \
+                .build() \
+            .field() \
+                .label('Operation') \
+                .itype('select') \
+                .value('+|-') \
+                .build() \
+            .field() \
+                .label('Time 2') \
+                .itype('masked') \
+                .value('|##:##:##') \
+                .build() \
+            .build()
+        # fmt: on
+
+        result = minput(form_fields)
+        self._args = result.values if result else None
+        sysout("%HOM%%ED2%%MOD(0)%", end="")
+
+        return bool(result)