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

build/lib/build/lib/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/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}")

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

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