hspylib-clitt 0.9.32__py3-none-any.whl → 0.9.34__py3-none-any.whl

clitt/.version

@@ -1 +1 @@
-0.9.32
+0.9.34

clitt/__init__.py

@@ -1,6 +1,6 @@
 # _*_ coding: utf-8 _*_
 #
-# hspylib-clitt v0.9.32
+# hspylib-clitt v0.9.34
 #
 # Package: main.clitt
 """Package initialization."""
@@ -9,4 +9,4 @@ __all__ = [
   'addons', 
   'core'
 ]
-__version__ = '0.9.32'
+__version__ = '0.9.34'

clitt/addons/__init__.py

@@ -1,6 +1,6 @@
 # _*_ coding: utf-8 _*_
 #
-# hspylib-clitt v0.9.32
+# hspylib-clitt v0.9.34
 #
 # Package: main.clitt.addons
 """Package initialization."""
@@ -10,4 +10,4 @@ __all__ = [
   'setman', 
   'widman'
 ]
-__version__ = '0.9.32'
+__version__ = '0.9.34'

clitt/addons/appman/__init__.py

@@ -1,6 +1,6 @@
 # _*_ coding: utf-8 _*_
 #
-# hspylib-clitt v0.9.32
+# hspylib-clitt v0.9.34
 #
 # Package: main.clitt.addons.appman
 """Package initialization."""
@@ -10,4 +10,4 @@ __all__ = [
   'appman_enums', 
   'templates'
 ]
-__version__ = '0.9.32'
+__version__ = '0.9.34'

clitt/addons/appman/templates/__init__.py

@@ -1,6 +1,6 @@
 # _*_ coding: utf-8 _*_
 #
-# hspylib-clitt v0.9.32
+# hspylib-clitt v0.9.34
 #
 # Package: main.clitt.addons.appman.templates
 """Package initialization."""
@@ -8,4 +8,4 @@
 __all__ = [
   
 ]
-__version__ = '0.9.32'
+__version__ = '0.9.34'

clitt/addons/setman/__init__.py

@@ -1,6 +1,6 @@
 # _*_ coding: utf-8 _*_
 #
-# hspylib-clitt v0.9.32
+# hspylib-clitt v0.9.34
 #
 # Package: main.clitt.addons.setman
 """Package initialization."""
@@ -13,4 +13,4 @@ __all__ = [
   'setman_repository', 
   'setman_service'
 ]
-__version__ = '0.9.32'
+__version__ = '0.9.34'

clitt/addons/widman/__init__.py

@@ -1,6 +1,6 @@
 # _*_ coding: utf-8 _*_
 #
-# hspylib-clitt v0.9.32
+# hspylib-clitt v0.9.34
 #
 # Package: main.clitt.addons.widman
 """Package initialization."""
@@ -11,4 +11,4 @@ __all__ = [
   'widgets', 
   'widman'
 ]
-__version__ = '0.9.32'
+__version__ = '0.9.34'

clitt/addons/widman/widgets/__init__.py

@@ -1,6 +1,6 @@
 # _*_ coding: utf-8 _*_
 #
-# hspylib-clitt v0.9.32
+# hspylib-clitt v0.9.34
 #
 # Package: main.clitt.addons.widman.widgets
 """Package initialization."""
@@ -11,4 +11,4 @@ __all__ = [
   'widget_send_msg', 
   'widget_time_calc'
 ]
-__version__ = '0.9.32'
+__version__ = '0.9.34'

clitt/core/__init__.py

@@ -1,6 +1,6 @@
 # _*_ coding: utf-8 _*_
 #
-# hspylib-clitt v0.9.32
+# hspylib-clitt v0.9.34
 #
 # Package: main.clitt.core
 """Package initialization."""
@@ -9,4 +9,4 @@ __all__ = [
   'icons', 
   'tui'
 ]
-__version__ = '0.9.32'
+__version__ = '0.9.34'

clitt/core/icons/__init__.py

@@ -1,6 +1,6 @@
 # _*_ coding: utf-8 _*_
 #
-# hspylib-clitt v0.9.32
+# hspylib-clitt v0.9.34
 #
 # Package: main.clitt.core.icons
 """Package initialization."""
@@ -9,4 +9,4 @@ __all__ = [
   'emojis', 
   'font_awesome'
 ]
-__version__ = '0.9.32'
+__version__ = '0.9.34'

clitt/core/icons/emojis/__init__.py

@@ -1,6 +1,6 @@
 # _*_ coding: utf-8 _*_
 #
-# hspylib-clitt v0.9.32
+# hspylib-clitt v0.9.34
 #
 # Package: main.clitt.core.icons.emojis
 """Package initialization."""
@@ -9,4 +9,4 @@ __all__ = [
   'emojis', 
   'face_smiling'
 ]
-__version__ = '0.9.32'
+__version__ = '0.9.34'

clitt/core/icons/font_awesome/__init__.py

@@ -1,6 +1,6 @@
 # _*_ coding: utf-8 _*_
 #
-# hspylib-clitt v0.9.32
+# hspylib-clitt v0.9.34
 #
 # Package: main.clitt.core.icons.font_awesome
 """Package initialization."""
@@ -14,4 +14,4 @@ __all__ = [
   'nav_icons', 
   'widget_icons'
 ]
-__version__ = '0.9.32'
+__version__ = '0.9.34'

clitt/core/tui/__init__.py

@@ -1,6 +1,6 @@
 # _*_ coding: utf-8 _*_
 #
-# hspylib-clitt v0.9.32
+# hspylib-clitt v0.9.34
 #
 # Package: main.clitt.core.tui
 """Package initialization."""
@@ -17,4 +17,4 @@ __all__ = [
   'tui_preferences', 
   'tui_screen'
 ]
-__version__ = '0.9.32'
+__version__ = '0.9.34'

clitt/core/tui/mchoose/__init__.py

@@ -1,6 +1,6 @@
 # _*_ coding: utf-8 _*_
 #
-# hspylib-clitt v0.9.32
+# hspylib-clitt v0.9.34
 #
 # Package: main.clitt.core.tui.mchoose
 """Package initialization."""
@@ -9,4 +9,4 @@ __all__ = [
   'mchoose', 
   'menu_choose'
 ]
-__version__ = '0.9.32'
+__version__ = '0.9.34'

clitt/core/tui/mdashboard/__init__.py

@@ -1,6 +1,6 @@
 # _*_ coding: utf-8 _*_
 #
-# hspylib-clitt v0.9.32
+# hspylib-clitt v0.9.34
 #
 # Package: main.clitt.core.tui.mdashboard
 """Package initialization."""
@@ -11,4 +11,4 @@ __all__ = [
   'mdashboard', 
   'menu_dashboard'
 ]
-__version__ = '0.9.32'
+__version__ = '0.9.34'

clitt/core/tui/menu/__init__.py

@@ -1,6 +1,6 @@
 # _*_ coding: utf-8 _*_
 #
-# hspylib-clitt v0.9.32
+# hspylib-clitt v0.9.34
 #
 # Package: main.clitt.core.tui.menu
 """Package initialization."""
@@ -13,4 +13,4 @@ __all__ = [
   'tui_menu_ui', 
   'tui_menu_view'
 ]
-__version__ = '0.9.32'
+__version__ = '0.9.34'

clitt/core/tui/minput/__init__.py

@@ -1,12 +1,13 @@
 # _*_ coding: utf-8 _*_
 #
-# hspylib-clitt v0.9.32
+# hspylib-clitt v0.9.34
 #
 # Package: main.clitt.core.tui.minput
 """Package initialization."""
 
 __all__ = [
   'access_type', 
+  'field_builder', 
   'form_builder', 
   'form_field', 
   'input_type', 
@@ -15,4 +16,4 @@ __all__ = [
   'minput', 
   'minput_utils'
 ]
-__version__ = '0.9.32'
+__version__ = '0.9.34'

clitt/core/tui/minput/field_builder.py

@@ -0,0 +1,112 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+"""
+   @project: HsPyLib
+   @package: clitt.core.tui.minput
+      @file: field_builder.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 2023, HsPyLib team
+"""
+import re
+from functools import reduce
+from typing import Any
+
+from hspylib.core.preconditions import check_argument
+from hspylib.core.tools.commons import str_to_bool
+from hspylib.core.tools.text_tools import snakecase
+
+from clitt.core.tui.minput.access_type import AccessType
+from clitt.core.tui.minput.form_field import FIELD_VALIDATOR_FNC, FormField
+from clitt.core.tui.minput.input_type import InputType
+from clitt.core.tui.minput.input_validator import InputValidator
+from clitt.core.tui.minput.minput_utils import get_selected, MASK_SYMBOLS, unpack_masked, VALUE_SEPARATORS
+
+
+class FieldBuilder:
+    """MenuInput form field builder."""
+
+    @staticmethod
+    def _validate_field(field: FormField) -> bool:
+        match field.itype:
+            case InputType.MASKED:
+                value, mask = unpack_masked(field.value)
+                valid = reduce(lambda n, m: n + m, list(map(lambda s: mask[len(value):].count(s), MASK_SYMBOLS))) == 0
+            case InputType.CHECKBOX:
+                valid = isinstance(field.value, bool)
+            case InputType.SELECT:
+                _, value = get_selected(field.value)
+                length = len(str(value or ''))
+                valid = field.min_length <= length <= field.max_length
+            case _:
+                length = len(str(field.value or ''))
+                valid = field.min_length <= length <= field.max_length
+        return valid
+
+    def __init__(self, parent: Any):
+        self._parent = parent
+        self._label = "Label"
+        self._dest = None
+        self._itype = InputType.TEXT
+        self._access_type = AccessType.READ_WRITE
+        self._min_max_length = 5, 30
+        self._value = ""
+        self._validator = InputValidator.anything(), self._validate_field
+
+    def label(self, label: str) -> "FieldBuilder":
+        self._label = label
+        return self
+
+    def dest(self, dest: str) -> "FieldBuilder":
+        self._dest = dest
+        return self
+
+    def itype(self, itype: str) -> "FieldBuilder":
+        self._itype = InputType.of_value(itype)
+        return self
+
+    def min_max_length(self, min_length: int, max_length: int) -> "FieldBuilder":
+        check_argument(max_length >= min_length, "Invalid field length: ({}-{})", min_length, max_length)
+        check_argument(
+            max_length > 0 and min_length > 0, "Invalid field length: ({}-{})", min_length, max_length
+        )
+        self._min_max_length = min_length, max_length
+        return self
+
+    def access_type(self, access_type: str) -> "FieldBuilder":
+        self._access_type = AccessType.of_value(access_type)
+        return self
+
+    def value(self, value: Any | None) -> "FieldBuilder":
+        self._value = value
+        return self
+
+    def validator(
+        self,
+        input_validator: InputValidator = None,
+        field_validator: FIELD_VALIDATOR_FNC = None) -> "FieldBuilder":
+        self._validator = input_validator, field_validator or self._validate_field
+        return self
+
+    def build(self) -> Any:
+        if self._itype == InputType.CHECKBOX:
+            self._value = str_to_bool(str(self._value))
+        elif self._itype == InputType.SELECT:
+            parts = re.split(VALUE_SEPARATORS, re.sub('[<>]', '', str(self._value or '')))
+            self._min_max_length = len(min(parts, key=len)), len(max(parts, key=len))
+        elif self._itype == InputType.MASKED:
+            _, mask = unpack_masked(str(self._value))
+            min_max = reduce(lambda n, m: n + m, list(map(lambda s: mask.count(s), MASK_SYMBOLS)))
+            self._min_max_length = min_max, min_max
+        self._dest = self._dest or snakecase(self._label)
+        self._parent.fields.append(FormField(
+            self._label, self._dest, self._itype,
+            self._min_max_length[0], self._min_max_length[1],
+            self._access_type, self._value, self._validator[0], self._validator[1]
+        ))
+
+        return self._parent

clitt/core/tui/minput/form_builder.py

@@ -15,104 +15,25 @@
 import re
 from typing import Any, List
 
-from hspylib.core.preconditions import check_argument
-from hspylib.core.tools.commons import str_to_bool
 from hspylib.core.tools.dict_tools import get_or_default
-from hspylib.core.tools.text_tools import snakecase
 
-from clitt.core.tui.minput.access_type import AccessType
+from clitt.core.tui.minput.field_builder import FieldBuilder
 from clitt.core.tui.minput.form_field import FormField
-from clitt.core.tui.minput.input_type import InputType
 from clitt.core.tui.minput.input_validator import InputValidator
-from clitt.core.tui.minput.minput_utils import unpack_masked
 
 
 class FormBuilder:
     """MenuInput form builder."""
 
-    @staticmethod
-    def or_else_get(options: tuple | list, index: int, default_value: Any = None) -> Any:
-        """TODO"""
-        return get_or_default(options, index, default_value) or default_value
-
-    class FieldBuilder:
-        """MenuInput form field builder."""
-
-        def __init__(self, parent: Any):
-            self.parent = parent
-            self.field = FormField()
-
-        def label(self, label: str) -> "FormBuilder.FieldBuilder":
-            self.field.label = label
-            return self
-
-        def dest(self, dest: str) -> "FormBuilder.FieldBuilder":
-            self.field.dest = dest
-            return self
-
-        def itype(self, itype: str) -> "FormBuilder.FieldBuilder":
-            self.field.itype = InputType.of_value(itype)
-            return self
-
-        def validator(self, validator: InputValidator) -> "FormBuilder.FieldBuilder":
-            self.field.input_validator = validator
-            return self
-
-        def min_max_length(self, min_length: int, max_length: int) -> "FormBuilder.FieldBuilder":
-            check_argument(max_length >= min_length, "Not a valid field length: ({}-{})", min_length, max_length)
-            check_argument(
-                max_length > 0 and min_length > 0, "Not a valid field length: ({}-{})", min_length, max_length
-            )
-            self.field.min_length = min_length
-            self.field.max_length = max_length
-            return self
-
-        def access_type(self, access_type: str) -> "FormBuilder.FieldBuilder":
-            self.field.access_type = AccessType.of_value(access_type)
-            return self
-
-        def value(self, value: Any | None) -> "FormBuilder.FieldBuilder":
-            check_argument(
-                not value or self.field.assign(value, True),
-                'Not a valid value: "{}". Validation pattern="{}"',
-                value,
-                self.field.input_validator,
-            )
-            return self
-
-        def build(self) -> Any:
-            self.field.itype = self.field.itype or InputType.TEXT
-            if self.field.itype == InputType.CHECKBOX:
-                self.field.value = "1" if str_to_bool(str(self.field.value)) else "0"
-                self.field.min_length = self.field.max_length = 1
-                self.validator(InputValidator.custom(r"[01]"))
-            elif self.field.itype == InputType.SELECT:
-                self.field.min_length = self.field.max_length = 1
-                self.validator(InputValidator.anything())
-            elif self.field.itype == InputType.MASKED:
-                _, mask = unpack_masked(self.field.value)
-                self.field.min_length = self.field.max_length = len(mask)
-                self.validator(
-                    InputValidator.custom(
-                        mask
-                        .replace("#", "[0-9]")
-                        .replace("@", "[a-zA-Z]")
-                        .replace("%", "[a-zA-Z0-9]")
-                        .replace("*", ".")
-                    ))
-            self.field.label = self.field.label or "Field"
-            self.field.dest = self.field.dest or f"{snakecase(self.field.label)}"
-            self.field.min_length = self.field.min_length or 1
-            self.field.max_length = self.field.max_length or 30
-            self.field.access_type = self.field.access_type or AccessType.READ_WRITE
-            self.field.value = self.field.value if self.field.value else ""
-            self.parent.fields.append(self.field)
-            return self.parent
-
     def __init__(self) -> None:
         self.fields = []
+        self._fn_validate = None
+
+    @staticmethod
+    def get_attr(parts: List[str], index: int, default_value: Any = None) -> str:
+        return get_or_default(parts, index, default_value) or default_value
 
-    def from_tokenized(self, tokenized_fields: List[str]) -> 'FormBuilder':
+    def from_tokenized(self, minput_tokens: List[str], separator: str = '|') -> 'FormBuilder':
         """Construct the forms based on string tokens.
 
          Field tokens (in-order):
@@ -123,30 +44,30 @@ class FormBuilder:
                [Perm] : The field permissions. One of {r|[rw]}. Where \"r\" for Read Only ; \"rw\" for Read & Write.
               [Value] : The initial value of the field. This field may not be blank if the field is read only.
         """
-        for tk_field in tokenized_fields:
-            parts = list(map(str.strip, tk_field.split('|')))
-            validator_fn = getattr(InputValidator, self.or_else_get(parts, 2, 'anything'))
-            min_max = list(map(int, map(str.strip, self.or_else_get(parts, 3, '1/30').split('/'))))
-            access = re.sub('^rw$', 'read-write', self.or_else_get(parts, 4, 'rw'))
+        for tk_field in minput_tokens:
+            parts = list(map(str.strip, tk_field.split(separator)))
+            validator_fn = getattr(InputValidator, self.get_attr(parts, 2, 'anything'))
+            min_max = list(map(int, map(str.strip, self.get_attr(parts, 3, '5/30').split('/'))))
+            access = re.sub('^rw$', 'read-write', self.get_attr(parts, 4, 'rw'))
             access = re.sub('^r$', 'read-only', access)
             # fmt: off
             self.field() \
-                .label(self.or_else_get(parts, 0, 'Label')) \
-                .itype(self.or_else_get(parts, 1, 'text')) \
+                .label(self.get_attr(parts, 0, 'Label')) \
+                .itype(self.get_attr(parts, 1, 'text')) \
                 .min_max_length(
-                    self.or_else_get(min_max, 0, 1),
-                    self.or_else_get(min_max, 1, 30)
+                    get_or_default(min_max, 0, 5),
+                    get_or_default(min_max, 1, 30)
                 ) \
                 .access_type(access) \
                 .validator(validator_fn()) \
-                .value(self.or_else_get(parts, 5, None)) \
+                .value(self.get_attr(parts, 5, None)) \
                 .build()
             # fmt: on
 
         return self
 
     def field(self) -> Any:
-        return FormBuilder.FieldBuilder(self)
+        return FieldBuilder(self)
 
-    def build(self) -> list:
+    def build(self) -> List[FormField]:
         return self.fields

clitt/core/tui/minput/form_field.py

@@ -12,12 +12,17 @@
 
    Copyright 2023, HsPyLib team
 """
+from typing import Any, Callable, Optional, TypeVar
+
+from hspylib.core.exception.exceptions import InvalidInputError
 
 from clitt.core.icons.font_awesome.form_icons import FormIcons
 from clitt.core.tui.minput.access_type import AccessType
 from clitt.core.tui.minput.input_type import InputType
 from clitt.core.tui.minput.input_validator import InputValidator
-from typing import Any
+from clitt.core.tui.minput.minput_utils import get_selected, MASK_SYMBOLS, toggle_selected, unpack_masked
+
+FIELD_VALIDATOR_FNC = TypeVar("FIELD_VALIDATOR_FNC", bound=Callable[['FormField'], bool])
 
 
 class FormField:
@@ -28,30 +33,81 @@ class FormField:
         label: str = None,
         dest: str = None,
         itype: InputType = InputType.TEXT,
-        min_length: int = 0,
+        min_length: int = 5,
         max_length: int = 30,
         access_type: AccessType = AccessType.READ_WRITE,
         value: Any = "",
-        input_validator: InputValidator = None,
+        input_validator: InputValidator = InputValidator.anything(),
+        field_validator: FIELD_VALIDATOR_FNC = None
     ):
-        self.label = label
-        self.dest = dest
-        self.itype = itype
-        self.min_length = min_length
-        self.max_length = max_length
-        self.access_type = access_type
-        self.value = value
-        self.input_validator = input_validator or InputValidator.anything(min_length, max_length)
+        self._label = label
+        self._dest = dest
+        self._itype = itype
+        self._min_length = min_length
+        self._max_length = max_length
+        self._access_type = access_type
+        self.input_validator = input_validator
+        self.field_validator = field_validator
+        self._value = self.assign(value)
 
     def __str__(self) -> str:
-        return f"{self.label}: {self.itype}({self.min_length}-{self.max_length}) [{self.access_type}] = '{self.value}'"
+        return (
+            f"[{self.label}, {self.itype.name}({self.min_length}/{self.max_length})"
+            f"<{self.access_type}> = '{self.value or ''}']"
+        )
 
     def __repr__(self):
         return str(self)
 
     @property
-    def width(self) -> int:
-        return len(str(self.value)) if self.itype != InputType.SELECT else 1
+    def label(self) -> str:
+        return self._label
+
+    @property
+    def dest(self) -> str:
+        return self._dest
+
+    @property
+    def itype(self) -> InputType:
+        return self._itype
+
+    @property
+    def min_length(self) -> int:
+        return self._min_length
+
+    @property
+    def max_length(self) -> int:
+        return self._max_length
+
+    @property
+    def access_type(self) -> AccessType:
+        return self._access_type
+
+    @property
+    def value(self) -> Optional[Any]:
+        return self._value
+
+    @value.setter
+    def value(self, new_value: Any) -> None:
+        self._value = self.assign(new_value)
+
+    @property
+    def length(self) -> int:
+        """Get the field real length, depending on the field type."""
+        real_value = str(self.value or '')
+        match self.itype:
+            case InputType.CHECKBOX:
+                real_value = '1'
+            case InputType.SELECT:
+                _, real_value = get_selected(str(self.value))
+            case InputType.MASKED:
+                real_value, mask = unpack_masked(str(self.value))
+                idx = len(real_value)
+                while idx < len(mask) and mask[idx] not in MASK_SYMBOLS:
+                    idx += 1
+                return idx
+
+        return len(real_value)
 
     @property
     def icon(self) -> FormIcons:
@@ -83,13 +139,36 @@ class FormField:
         """Whether this field value can be set or not."""
         return self.access_type == AccessType.READ_WRITE
 
-    def assign(self, value: Any, skip_validation: bool = False) -> bool:
-        """Assign a value for this field.Must match the input validator, otherwise an exception will be thrown."""
-        if skip_validation or self.validate_input(value):
-            self.value = value
-            return True
-        return False
+    def assign(self, value: Any) -> Any:
+        """Assign a value for this field. Must match the input validator, otherwise an exception will be thrown.
+        :param value: TODO
+        """
+        valid = True
+        if value is not None and self.input_validator:
+            match self.itype:
+                case InputType.MASKED:
+                    unpack_masked(value)
+                case InputType.SELECT:
+                    toggle_selected(value)
+                case InputType.CHECKBOX:
+                    valid = isinstance(value, bool)
+                case _:
+                    valid = all([self.validate_input(val) for val in str(value)])
+
+        if not valid:
+            raise InvalidInputError(f"Value {value} is invalid!")
+
+        self._value = value
+
+        return self._value
 
     def validate_input(self, value: Any = None) -> bool:
-        """Validate the input using the assigned validator."""
-        return self.input_validator.validate(str(value) or str(self.value)) if self.input_validator else False
+        """Validate the input using the assigned validator.
+        :param value: the value to validate against.
+        """
+        return self.input_validator(str(value)) if self.input_validator else True
+
+    def validate_field(self) -> bool:
+        """Validate the field using the assigned validator function.
+        """
+        return self.field_validator(self) if self.field_validator else False