hspylib-clitt 0.9.116__py3-none-any.whl → 0.9.117__py3-none-any.whl

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)

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

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

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

@@ -1,123 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-
-"""
-   @project: HsPyLib-Clitt
-   @package: clitt.addons.widman
-      @file: widman.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.addons.widman.widget_entry import WidgetEntry
-from clitt.core.tui.mdashboard.dashboard_item import DashboardItem
-from clitt.core.tui.mdashboard.mdashboard import mdashboard
-from hspylib.core.exception.exceptions import WidgetExecutionError, WidgetNotFoundError
-from hspylib.core.metaclass.singleton import Singleton
-from hspylib.core.preconditions import check_state
-from hspylib.core.tools.commons import get_path
-from hspylib.core.tools.text_tools import camelcase
-from hspylib.modules.application.application import Application
-from hspylib.modules.application.exit_status import ExitStatus
-
-import atexit
-import os
-import sys
-
-HERE = get_path(__file__)
-
-
-class WidgetManager(metaclass=Singleton):
-    """HsPyLib widget manager that handles HsPyLib widgets."""
-
-    WIDGETS_PATH = HERE / "widgets"
-
-    @staticmethod
-    def _name_matches(expected_name: str, provided_name: str) -> bool:
-        """Check if two names matches using defined naming rules.
-        :param expected_name the expected widget name.
-        :param provided_name the provided widget name (read from file).
-        """
-
-        return (
-            expected_name.lower() == provided_name.lower()
-            or expected_name == provided_name.capitalize()
-            or expected_name == camelcase(provided_name, capitalized=True)
-            or expected_name.lower() == provided_name.lower().replace("_", "")
-        )
-
-    def __init__(self, parent_app: Application):
-        self._parent_app = parent_app
-        self._widgets = []
-        self._lookup_paths = os.environ.get("HHS_WIDGETS_PATH", "").split(":")
-        self._lookup_paths.insert(0, str(WidgetManager.WIDGETS_PATH))
-        list(map(sys.path.append, self._lookup_paths))
-        check_state(self._search_widgets() > 0, "Unable to find any widgets from: {}", self._lookup_paths)
-
-    def execute(self, widget_name: str, *widget_args) -> None:
-        """Execute the specified widget.
-        :param widget_name the widget name.
-        :param widget_args the arguments to be provided to the widget.
-        """
-
-        widget = self._import_widget(camelcase(widget_name, capitalized=True))
-        try:
-            atexit.register(widget.cleanup)
-            exit_code = widget.execute(*widget_args)
-            if exit_code in [ExitStatus.ERROR, ExitStatus.FAILED]:
-                raise WidgetExecutionError(f"Widget '{widget_name}' failed to execute. exit_code={exit_code}")
-        except Exception as err:
-            raise WidgetExecutionError(f"Unable to execute widget '{widget_name}' -> {err}") from err
-
-    def dashboard(self) -> None:
-        """Display all available widgets from the widget lookup paths on a dashboard."""
-
-        items = []
-        try:
-            for widget_entry in self._widgets:
-                widget = self._import_widget(widget_entry.name)
-                item = DashboardItem(
-                    widget.icon(), f"{widget.name()} v{widget.version()}: {widget.tooltip()}", widget.execute
-                )
-                items.append(item)
-            check_state(len(items) > 0, "No widgets found from: {}", str(self._lookup_paths))
-            mdashboard(items, "Please select a widget to execute")
-        except Exception as err:
-            raise WidgetExecutionError(f"Failed to execute widget :: {str(err)}") from err
-
-    # pylint: disable=cell-var-from-loop
-    def _search_widgets(self) -> int:
-        """Search and load all widgets from the widget lookup paths."""
-
-        for path in self._lookup_paths:
-            for root, _, files in os.walk(path):
-                filtered = list(filter(lambda p: p.startswith(WidgetEntry.MODULE_PREFIX) and p.endswith("py"), files))
-                widgets = list(map(lambda w: WidgetEntry(w, f"{root}/{w}"), filtered))
-                self._widgets.extend(widgets)
-
-        return len(self._widgets)
-
-    def _import_widget(self, widget_name: str) -> Widget:
-        """Find, import and return a widget specified by the widget name.
-        :param widget_name the widget name.
-        """
-        widget_entry = next((w for w in self._widgets if self._name_matches(widget_name, w.name)), None)
-        if not widget_entry:
-            raise WidgetNotFoundError(
-                f"Widget '{widget_name}' was not found on widget lookup paths: {str(self._lookup_paths)}"
-            )
-        try:
-            widget_module = __import__(widget_entry.module)
-        except ModuleNotFoundError as err:
-            raise WidgetNotFoundError(
-                f"Widget '{widget_name}' was not found on widget lookup paths: {str(self._lookup_paths)}"
-            ) from err
-        widget_clazz = getattr(widget_module, widget_entry.clazz)
-        widget = widget_clazz()
-        check_state(isinstance(widget, Widget), 'All widgets must inherit from "clitt.addons.widman.Widget"')
-
-        return widget

build/lib/clitt/core/__init__.py

@@ -1,15 +0,0 @@
-# _*_ coding: utf-8 _*_
-#
-# hspylib-clitt v0.9.116
-#
-# Package: main.build.lib.build.lib.clitt.core
-"""Package initialization."""
-
-__all__ = [
-    'exception', 
-    'icons', 
-    'preferences', 
-    'term', 
-    'tui'
-]
-__version__ = '0.9.116'

build/lib/clitt/core/exception/__init__.py

@@ -1,11 +0,0 @@
-# _*_ coding: utf-8 _*_
-#
-# hspylib-clitt v0.9.116
-#
-# Package: main.build.lib.build.lib.clitt.core.exception
-"""Package initialization."""
-
-__all__ = [
-    'exceptions'
-]
-__version__ = '0.9.116'

build/lib/clitt/core/exception/exceptions.py

@@ -1,18 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-
-"""
-   @project: HsPyLib
-   @package: clitt.core.exceptions
-      @file: exceptions.py
-   @created: Fri, 7 Jul 2023
-    @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
-"""
-
-
-class NotATerminalError(NotImplementedError):
-    """Raised when a TTY terminal is required"""

build/lib/clitt/core/icons/__init__.py

@@ -1,12 +0,0 @@
-# _*_ coding: utf-8 _*_
-#
-# hspylib-clitt v0.9.116
-#
-# Package: main.build.lib.build.lib.clitt.core.icons
-"""Package initialization."""
-
-__all__ = [
-    'emojis', 
-    'font_awesome'
-]
-__version__ = '0.9.116'

build/lib/clitt/core/icons/emojis/__init__.py

@@ -1,12 +0,0 @@
-# _*_ coding: utf-8 _*_
-#
-# hspylib-clitt v0.9.116
-#
-# Package: main.build.lib.build.lib.clitt.core.icons.emojis
-"""Package initialization."""
-
-__all__ = [
-    'emojis', 
-    'face_smiling'
-]
-__version__ = '0.9.116'

build/lib/clitt/core/icons/emojis/emojis.py

@@ -1,41 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-
-"""
-   @project: HsPyLib-Clitt
-   @package: clitt.core.icons.emojis
-      @file: emojis.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 emoji.core import emojize
-from hspylib.core.enums.enumeration import Enumeration
-from hspylib.core.tools.commons import sysout
-
-
-class Emoji(Enumeration):
-    """
-    Emoji codes
-    Full list of emojis can be found here:
-      - https://unicode.org/emoji/charts/emoji-list.html
-    """
-
-    @staticmethod
-    def emj_print(emoji_str: str, end: str = "") -> None:
-        """Print an emoji
-        :param emoji_str the emoji to be printed.
-        :param end string appended after the last value, default a newline.
-        """
-        sysout(f"{emojize(emoji_str)} ", end=end)
-
-    def __str__(self) -> str:
-        return str(self.value)
-
-    @property
-    def placeholder(self) -> str:
-        return f":{self.name}:"