geolysis 0.7.3__tar.gz → 0.8.0__tar.gz

{geolysis-0.7.3 → geolysis-0.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: geolysis
-Version: 0.7.3
+Version: 0.8.0
 Summary: geolysis is an opensource software for geotechnical engineering analysis and modeling.
 Author-email: Patrick Boateng <boatengpato.pb@gmail.com>
 License: MIT License
@@ -134,7 +134,6 @@ Here are brief descriptions of the `geolysis` projects:
 
 - [Installation](#installation)
 - [Usage Example](#usage-example)
-- [Features](#features)
 - [Documentation](#documentation)
 - [Contributing](#contributing)
 - [License](#license)

{geolysis-0.7.3 → geolysis-0.8.0}/README.md

@@ -102,7 +102,6 @@ Here are brief descriptions of the `geolysis` projects:
 
 - [Installation](#installation)
 - [Usage Example](#usage-example)
-- [Features](#features)
 - [Documentation](#documentation)
 - [Contributing](#contributing)
 - [License](#license)

{geolysis-0.7.3 → geolysis-0.8.0}/geolysis/__init__.py

@@ -1,5 +1,5 @@
 from . import foundation, soil_classifier, spt
 
-__version__ = "0.7.3"
+__version__ = "0.8.0"
 
 __all__ = ["foundation", "soil_classifier", "spt"]

{geolysis-0.7.3 → geolysis-0.8.0}/geolysis/bearing_capacity/abc/cohl/__init__.py

@@ -3,12 +3,11 @@ allowable bearing capacity calculations using methods like Bowles, Meyerhof,
 and Terzaghi for various foundation types and shapes.
 """
 import enum
-from codecs import backslashreplace_errors
 from typing import Optional
 
 from geolysis.foundation import FoundationType, Shape, create_foundation
 from geolysis.utils import enum_repr, inf
-from geolysis.utils.exceptions import EnumErrorMsg
+from geolysis.utils.exceptions import ErrorMsg, ValidationError
 
 from ._core import AllowableBearingCapacity
 from .bowles_abc import BowlesABC4MatFoundation, BowlesABC4PadFoundation
@@ -99,25 +98,27 @@ def create_allowable_bearing_capacity(corrected_spt_n_value: float,
     :raises ValueError: Raised if an invalid footing ``shape`` is provided.
     """
 
-    msg = EnumErrorMsg(param_name="abc_type",
-                       param_value=abc_type,
-                       param_type=ABCType)
+    msg = ErrorMsg(param_name="abc_type",
+                   param_value=abc_type,
+                   symbol="in",
+                   param_value_bound=list(ABCType))
 
     if abc_type is None:
-        raise ValueError(msg)
+        raise ValidationError(msg)
 
     try:
         abc_type = ABCType(str(abc_type).casefold())
     except ValueError as e:
-        raise ValueError(msg) from e
+        raise ValidationError(msg) from e
 
     try:
         foundation_type = FoundationType(str(foundation_type).casefold())
     except ValueError as e:
-        msg = EnumErrorMsg(param_name="foundation_type",
-                           param_value=foundation_type,
-                           param_type=FoundationType)
-        raise ValueError(msg) from e
+        msg = ErrorMsg(param_name="foundation_type",
+                       param_value=foundation_type,
+                       symbol="in",
+                       param_value_bound=list(FoundationType))
+        raise ValidationError(msg) from e
 
     # exception from create_foundation will automaatically propagate
     # no need to catch and handle it.

{geolysis-0.7.3 → geolysis-0.8.0}/geolysis/bearing_capacity/abc/cohl/_core.py

@@ -1,7 +1,8 @@
 from abc import ABC, abstractmethod
 
 from geolysis.foundation import FoundationSize
-from geolysis.utils import validators, exceptions as exc
+from geolysis.utils import exceptions as exc
+from geolysis.utils import validators
 
 
 class AllowableBearingCapacity(ABC):

{geolysis-0.7.3 → geolysis-0.8.0}/geolysis/bearing_capacity/ubc/__init__.py

@@ -8,7 +8,7 @@ from typing import Optional
 
 from geolysis.foundation import Shape, create_foundation
 from geolysis.utils import enum_repr
-from geolysis.utils.exceptions import EnumErrorMsg
+from geolysis.utils.exceptions import ErrorMsg, ValidationError
 
 from ._core import UltimateBearingCapacity
 from .hansen_ubc import HansenUltimateBearingCapacity
@@ -116,17 +116,18 @@ def create_ultimate_bearing_capacity(friction_angle: float,
     :raises ValueError: Raised if an invalid footing shape is provided.
     """
 
-    msg = EnumErrorMsg(param_name="ubc_type",
-                       param_value=ubc_type,
-                       param_type=UBCType)
+    msg = ErrorMsg(param_name="ubc_type",
+                   param_value=ubc_type,
+                   symbol="in",
+                   param_value_bound=list(UBCType))
 
     if ubc_type is None:
-        raise ValueError(msg)
+        raise ValidationError(msg)
 
     try:
         ubc_type = UBCType(str(ubc_type).casefold())
     except ValueError as e:
-        raise ValueError(msg) from e
+        raise ValidationError(msg) from e
 
     # exception from create_foundation will automatically propagate
     # no need to catch and handle it.

{geolysis-0.7.3 → geolysis-0.8.0}/geolysis/bearing_capacity/ubc/terzaghi_ubc.py

@@ -60,7 +60,7 @@ class TerzaghiUltimateBearingCapacity(UltimateBearingCapacity, ABC):
 
         :Equation:
 
-        .. math:: N_{\gamma} &=  (N_q - 1) \cdot \tan(1.4\phi)
+        .. math:: N_{\gamma} =  (N_q - 1) \cdot \tan(1.4\phi)
         """
         return n_gamma(self.friction_angle)
 

{geolysis-0.7.3 → geolysis-0.8.0}/geolysis/foundation.py

@@ -5,7 +5,7 @@ from abc import ABC, abstractmethod
 from typing import Optional, TypeVar
 
 from .utils import enum_repr, inf, isclose, validators
-from .utils.exceptions import EnumErrorMsg, ErrorMsg
+from .utils.exceptions import ErrorMsg, ValidationError
 
 __all__ = ["create_foundation",
            "FoundationSize",
@@ -31,8 +31,10 @@ class Shape(enum.StrEnum):
 @enum_repr
 class FoundationType(enum.StrEnum):
     """Enumeration of foundation types."""
-    PAD = ISOLATED = enum.auto()
-    MAT = RAFT = enum.auto()
+    PAD = enum.auto()
+    ISOLATED = PAD
+    MAT = enum.auto()
+    RAFT = MAT
 
 
 class FootingSize(ABC):
@@ -376,10 +378,11 @@ def create_foundation(depth: float,
     try:
         shape = Shape(str(shape).casefold())
     except ValueError as e:
-        msg = EnumErrorMsg(param_name="shape",
-                           param_value=shape,
-                           param_type=Shape)
-        raise ValueError(msg) from e
+        msg = ErrorMsg(param_name="shape",
+                       param_value=shape,
+                       symbol="in",
+                       param_value_bound=list(Shape))
+        raise ValidationError(msg) from e
 
     if shape is Shape.STRIP:
         footing_size = StripFooting(width=width)
@@ -389,8 +392,10 @@ def create_foundation(depth: float,
         footing_size = CircularFooting(diameter=width)
     else:  # RECTANGLE
         if not length:
-            msg = ErrorMsg(msg="Length of footing must be provided.")
-            raise ValueError(msg)
+            msg = ErrorMsg(param_name="length",
+                           param_value=length,
+                           msg="Length of footing must be provided.")
+            raise ValidationError(msg)
         footing_size = RectangularFooting(width=width, length=length)
 
     return FoundationSize(depth=depth,

{geolysis-0.7.3 → geolysis-0.8.0}/geolysis/soil_classifier.py

@@ -5,7 +5,7 @@ import enum
 from typing import NamedTuple, Optional, Sequence
 
 from .utils import enum_repr, isclose, round_, validators
-from .utils.exceptions import EnumErrorMsg, ErrorMsg
+from .utils.exceptions import ErrorMsg, ValidationError
 
 __all__ = ["ClfType",
            "AtterbergLimits",
@@ -713,17 +713,18 @@ def create_soil_classifier(liquid_limit: float,
     :raises ValueError: Raises ValueError if ``sand`` is not provided for
                         :class:`USCS` classification.
     """
-    msg = EnumErrorMsg(param_name="clf_type",
-                       param_value=clf_type,
-                       param_type=ClfType)
+    msg = ErrorMsg(param_name="clf_type",
+                   param_value=clf_type,
+                   symbol="in",
+                   param_value_bound=list(ClfType))
 
     if clf_type is None:
-        raise ValueError(msg)
+        raise ValidationError(msg)
 
     try:
         clf_type = ClfType(str(clf_type).casefold())
     except ValueError as e:
-        raise ValueError(msg) from e
+        raise ValidationError(msg) from e
 
     atterberg_lmts = AtterbergLimits(liquid_limit=liquid_limit,
                                      plastic_limit=plastic_limit)
@@ -736,8 +737,10 @@ def create_soil_classifier(liquid_limit: float,
 
     # USCS classification
     if not sand:
-        msg = ErrorMsg("sand must be specified for USCS classification")
-        raise ValueError(msg)
+        msg = ErrorMsg(param_name="sand",
+                       param_value=sand,
+                       msg="sand must be specified for USCS classification")
+        raise ValidationError(msg)
 
     psd = PSD(fines=fines, sand=sand, d_10=d_10, d_30=d_30, d_60=d_60)
     clf = USCS(atterberg_limits=atterberg_lmts, psd=psd, organic=organic)

{geolysis-0.7.3 → geolysis-0.8.0}/geolysis/spt.py

@@ -4,10 +4,10 @@ as well as calculating design N-values.
 """
 import enum
 from abc import abstractmethod
-from typing import Final, Sequence, Literal
+from typing import Final, Literal, Sequence
 
 from .utils import enum_repr, isclose, log10, mean, round_, sqrt, validators
-from .utils.exceptions import EnumErrorMsg, ErrorMsg, ValidationError
+from .utils.exceptions import ErrorMsg, ValidationError
 
 __all__ = ["SPTNDesign",
            "HammerType",
@@ -51,14 +51,21 @@ class SPTNDesign:
         return self._corrected_spt_n_values
 
     @corrected_spt_n_values.setter
+    @validators.le(100.0)
+    @validators.gt(0.0)
     @validators.min_len(1)
     def corrected_spt_n_values(self, val: Sequence[float]) -> None:
-        for v in val:
-            if v <= 0.0 or v > 100:
-                raise ValidationError(
-                    "SPT N-values must be between 0.0 and 100.")
         self._corrected_spt_n_values = val
 
+    @property
+    def method(self):
+        return self._method
+
+    @method.setter
+    @validators.in_(("min", "avg", "wgt"))
+    def method(self, val: str) -> None:
+        self._method = val
+
     @staticmethod
     def _avg_spt_n_design(vals) -> float:
         return mean(vals)
@@ -105,11 +112,8 @@ class SPTNDesign:
             return self._min_spt_n_design(self.corrected_spt_n_values)
         elif self.method == "avg":
             return self._avg_spt_n_design(self.corrected_spt_n_values)
-        elif self.method == "wgt":
+        else:  # method="wgt"
             return self._wgt_spt_n_design(self.corrected_spt_n_values)
-        else:
-            msg = ErrorMsg("method must be 'min', 'avg', or 'wgt'")
-            raise ValueError(msg)
 
 
 @enum_repr
@@ -227,6 +231,24 @@ class EnergyCorrection:
     def rod_length(self, val: float) -> None:
         self._rod_length = val
 
+    @property
+    def hammer_type(self) -> HammerType:
+        return self._hammer_type
+
+    @hammer_type.setter
+    @validators.in_(tuple(HammerType))
+    def hammer_type(self, val: HammerType) -> None:
+        self._hammer_type = val
+
+    @property
+    def sampler_type(self) -> SamplerType:
+        return self._sampler_type
+
+    @sampler_type.setter
+    @validators.in_(tuple(SamplerType))
+    def sampler_type(self, val: SamplerType) -> None:
+        self._sampler_type = val
+
     @property
     def hammer_efficiency(self) -> float:
         """Hammer efficiency correction factor."""
@@ -558,10 +580,11 @@ def create_overburden_pressure_correction(std_spt_n_value: float, eop,
     try:
         opc_type = OPCType(str(opc_type).casefold())
     except ValueError as e:
-        msg = EnumErrorMsg(param_name="opc_type",
-                           param_value=opc_type,
-                           param_type=OPCType)
-        raise ValueError(msg) from e
+        msg = ErrorMsg(param_name="opc_type",
+                       param_value=opc_type,
+                       symbol="in",
+                       param_value_bound=list(OPCType))
+        raise ValidationError(msg) from e
 
     opc_class = _opctypes[opc_type]
     opc_corr = opc_class(std_spt_n_value=std_spt_n_value, eop=eop)

geolysis-0.8.0/geolysis/utils/exceptions.py

@@ -0,0 +1,52 @@
+from collections import UserString
+from typing import Any
+
+
+class _ErrorMsg(UserString):
+    def __init__(self, param_name: str = None,
+                 param_value: Any = None,
+                 symbol: str = None,
+                 param_value_bound: Any = None,
+                 msg: str = None):
+        if not msg:
+            msg = f"{param_name}: {param_value!r} must be {symbol} {param_value_bound}"
+
+        self.param_name = param_name
+        self.param_value = param_value
+        self.symbol = symbol
+        self.param_value_bound = param_value_bound
+        self.msg = msg
+
+        super().__init__(msg)
+
+    def __add__(self, other):
+        if isinstance(other, str):
+            self.data = self.data + other
+            self.msg = self.data
+            return self
+        return NotImplemented
+
+    def __radd__(self, other):
+        if isinstance(other, str):
+            self.data = other + self.data
+            self.msg = self.data
+            return self
+        return NotImplemented
+
+
+class ErrorMsg(_ErrorMsg):
+    pass
+
+
+class ValidationError(ValueError):
+    """Exception raised when a validation error occurs."""
+
+    def __init__(self, error: ErrorMsg):
+        super().__init__(error)
+        self.error = error
+
+
+class SettlementError(ValidationError):
+    """Raised when tolerable settlement is greater than the maximum
+    allowable settlement.
+    """

geolysis-0.8.0/geolysis/utils/validators.py

@@ -0,0 +1,129 @@
+"""validators"""
+import operator
+from functools import wraps
+from typing import Any, Callable, Iterable, TypeAlias
+
+from .exceptions import ErrorMsg, ValidationError
+
+Number: TypeAlias = int | float
+
+
+class _Validator:
+
+    def __init__(self, bound: Any, /, *,
+                 symbol: str,
+                 func: Callable,
+                 exc_type: Callable,
+                 err_msg: str):
+        """
+
+        """
+        self.bound = bound
+        self.symbol = symbol
+        self.func = func
+        self.exc_type = exc_type
+        self.err_msg = err_msg
+
+
+class _NumValidator(_Validator):
+
+    def _check_val(self, v: Number, fname: str):
+        if not self.func(v, self.bound):
+            msg = ErrorMsg(msg=self.err_msg,
+                           param_name=fname,
+                           param_value=v,
+                           symbol=self.symbol,
+                           param_value_bound=self.bound)
+            raise self.exc_type(msg)
+
+    def __call__(self, fn):
+        @wraps(fn)
+        def wrapper(obj, val):
+            if isinstance(val, Iterable):
+                for v in val:
+                    self._check_val(v, fn.__name__)
+            else:
+                self._check_val(val, fn.__name__)
+
+            fn(obj, val)
+
+        return wrapper
+
+
+class _LenValidator(_Validator):
+    def _check_val(self, v: Iterable[Any], fname: str):
+        if not self.func(len(v), self.bound):
+            msg = ErrorMsg(msg=self.err_msg,
+                           param_name=fname,
+                           param_value=v,
+                           symbol=self.symbol,
+                           param_value_bound=self.bound)
+            msg = "Length of " + msg
+            raise self.exc_type(msg)
+
+    def __call__(self, fn):
+        @wraps(fn)
+        def wrapper(obj, val: Iterable):
+            self._check_val(val, fn.__name__)
+            fn(obj, val)
+
+        return wrapper
+
+
+class _InValidator(_Validator):
+    def _check_val(self, v, fname):
+        if not self.func(self.bound, v):
+            msg = ErrorMsg(msg=self.err_msg,
+                           param_name=fname,
+                           param_value=v,
+                           symbol=self.symbol,
+                           param_value_bound=self.bound)
+            raise self.exc_type(msg)
+
+    def __call__(self, fn):
+        @wraps(fn)
+        def wrapper(obj, val):
+            self._check_val(val, fn.__name__)
+            fn(obj, val)
+
+        return wrapper
+
+
+def in_(val: Iterable[Any], /, *, exc_type=ValidationError, err_msg=None):
+    return _InValidator(val, symbol="in", func=operator.contains,
+                        exc_type=exc_type, err_msg=err_msg)
+
+
+def min_len(val: int, /, *, exc_type=ValidationError, err_msg=None):
+    return _LenValidator(val, symbol=">=", func=operator.ge,
+                         exc_type=exc_type, err_msg=err_msg)
+
+
+def lt(val: Number, /, *, exc_type=ValidationError, err_msg=None):
+    return _NumValidator(val, symbol="<", func=operator.lt,
+                         exc_type=exc_type, err_msg=err_msg)
+
+
+def le(val: Number, /, *, exc_type=ValidationError, err_msg=None):
+    return _NumValidator(val, symbol="<=", func=operator.le,
+                         exc_type=exc_type, err_msg=err_msg)
+
+
+def eq(val: Number, /, *, exc_type=ValidationError, err_msg=None):
+    return _NumValidator(val, symbol="==", func=operator.eq,
+                         exc_type=exc_type, err_msg=err_msg)
+
+
+def ne(val: Number, /, *, exc_type=ValidationError, err_msg=None):
+    return _NumValidator(val, symbol="!=", func=operator.ne,
+                         exc_type=exc_type, err_msg=err_msg)
+
+
+def ge(val: Number, /, *, exc_type=ValidationError, err_msg=None):
+    return _NumValidator(val, symbol=">=", func=operator.ge,
+                         exc_type=exc_type, err_msg=err_msg)
+
+
+def gt(val: Number, /, *, exc_type=ValidationError, err_msg=None):
+    return _NumValidator(val, symbol=">", func=operator.gt,
+                         exc_type=exc_type, err_msg=err_msg)

{geolysis-0.7.3 → geolysis-0.8.0}/geolysis.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: geolysis
-Version: 0.7.3
+Version: 0.8.0
 Summary: geolysis is an opensource software for geotechnical engineering analysis and modeling.
 Author-email: Patrick Boateng <boatengpato.pb@gmail.com>
 License: MIT License
@@ -134,7 +134,6 @@ Here are brief descriptions of the `geolysis` projects:
 
 - [Installation](#installation)
 - [Usage Example](#usage-example)
-- [Features](#features)
 - [Documentation](#documentation)
 - [Contributing](#contributing)
 - [License](#license)

{geolysis-0.7.3 → geolysis-0.8.0}/tests/test_soil_classifier.py

@@ -6,17 +6,20 @@ from geolysis.soil_classifier import (PSD, AtterbergLimits,
 
 def test_create_soil_classifier():
     with pytest.raises(ValueError):
+        # Did not provide a classification (clf_type) value
         create_soil_classifier(liquid_limit=30.4,
                                plastic_limit=15.9,
                                fines=40.20)
 
     with pytest.raises(ValueError):
+        # Provided a wrong value for clf_type
         create_soil_classifier(liquid_limit=30.4,
                                plastic_limit=15.9,
                                fines=40.20,
                                clf_type="IS")
 
     with pytest.raises(ValueError):
+        # Did not provide sand for USCS classification
         create_soil_classifier(liquid_limit=30.4,
                                plastic_limit=15.9,
                                fines=40.20,

{geolysis-0.7.3 → geolysis-0.8.0}/tests/test_spt.py

@@ -1,18 +1,18 @@
 import pytest
 
-from geolysis.spt import (BazaraaPeckOPC, DilatancyCorrection,
-                          EnergyCorrection, GibbsHoltzOPC, HammerType,
-                          LiaoWhitmanOPC, PeckOPC, SamplerType, SkemptonOPC,
-                          SPTNDesign, create_overburden_pressure_correction)
+from geolysis.spt import (DilatancyCorrection, EnergyCorrection, HammerType,
+                          SamplerType, SPTNDesign,
+                          create_overburden_pressure_correction)
+from geolysis.utils.exceptions import ValidationError
 
 
 def test_create_spt_correction_errors():
-    with pytest.raises(ValueError):
+    with pytest.raises(ValidationError):
         create_overburden_pressure_correction(std_spt_n_value=34,
                                               eop=100, opc_type="TERZAGHI")
 
 
-class TestSPTDesign:
+class TestSPTNDesign:
 
     def test_spt_n_design(self):
         spt_design = SPTNDesign([7.0, 15.0, 18], method="min")
@@ -24,20 +24,26 @@ class TestSPTDesign:
         assert spt_design.n_design() == pytest.approx(9.4)
 
     def test_errors(self):
-        with pytest.raises(ValueError):
+        # Provided an empty value for corrected_spt_n_values
+        with pytest.raises(ValidationError):
             SPTNDesign(corrected_spt_n_values=[])
 
-        with pytest.raises(ValueError):
-            spt_design = SPTNDesign(corrected_spt_n_values=[7.0, 15.0, 18],
-                                    method="max")
-            spt_design.n_design()
+        # Provided an invalid method
+        with pytest.raises(ValidationError):
+            SPTNDesign(corrected_spt_n_values=[7.0, 15.0, 18], method="max")
 
-        with pytest.raises(ValueError):
+        # corrected_spt_n_values is greater than 100
+        with pytest.raises(ValidationError):
             SPTNDesign(corrected_spt_n_values=[22, 44, 120])
 
-        with pytest.raises(ValueError):
+        # corrected_spt_n_values is 0.0
+        with pytest.raises(ValidationError):
             SPTNDesign(corrected_spt_n_values=[0.0, 15.0, 18])
 
+        # corrected_spt_n_values is less than 0.0
+        with pytest.raises(ValidationError):
+            SPTNDesign(corrected_spt_n_values=[-10, 15.0, 18])
+
 
 class TestEnergyCorrection:
 
@@ -66,6 +72,15 @@ class TestEnergyCorrection:
         assert energy_corr.standardized_spt_n_value() == pytest.approx(
             expected)
 
+    def test_errors(self):
+        # Provided an invalid value for hammer_type
+        with pytest.raises(ValidationError):
+            EnergyCorrection(recorded_spt_n_value=22, hammer_type="manual")
+
+        # Provided an invalid value for sampler_type
+        with pytest.raises(ValidationError):
+            EnergyCorrection(recorded_spt_n_value=22, sampler_type="std")
+
 
 class TestGibbsHoltzOPC:
 

geolysis-0.7.3/geolysis/utils/exceptions.py

@@ -1,36 +0,0 @@
-from typing import Unpack, TypedDict, NotRequired, Any, Optional
-
-
-class _ErrorParams(TypedDict):
-    param_name: NotRequired[str]
-    param_value: NotRequired[Any]
-    param_type: NotRequired[Any]
-
-
-class ErrorMsg(str):
-
-    @staticmethod
-    def __new__(cls, msg):
-        return super().__new__(cls, msg)
-
-
-class EnumErrorMsg(ErrorMsg):
-
-    @staticmethod
-    def __new__(cls, *args, msg: Optional[str] = None,
-                **kwargs: Unpack[_ErrorParams]):
-        err_msg = msg if msg else (
-            f"Invalid value for {kwargs['param_name']}: {kwargs['param_value']}, "
-            f"Supported types are: {list(kwargs['param_type'])}")
-
-        return super().__new__(cls, err_msg)
-
-
-class ValidationError(ValueError):
-    """Exception raised when a validation error occurs."""
-
-
-class SettlementError(ValueError):
-    """Raised when tolerable settlement is greater than the maximum
-    allowable settlement.
-    """

geolysis-0.7.3/geolysis/utils/validators.py

@@ -1,101 +0,0 @@
-"""validators"""
-import operator
-from typing import Callable, TypeAlias, Optional
-from functools import wraps
-
-from .exceptions import ValidationError
-
-Number: TypeAlias = int | float
-
-
-def _num_validator(bound: float, /, *,
-                   compare_symbol: str,
-                   compare_fn: Callable,
-                   exc_type: Callable,
-                   err_msg: str):
-    def dec(fn):
-        @wraps(fn)
-        def wrapper(obj, val):
-            if not compare_fn(val, bound):
-                msg = f"{fn.__name__} must be {compare_symbol} {bound}"
-                raise exc_type(err_msg if err_msg else msg)
-            fn(obj, val)
-
-        return wrapper
-
-    return dec
-
-
-def _len_validator(bound: float, /, *,
-                   compare_symbol: str,
-                   compare_fn: Callable,
-                   exc_type: Callable,
-                   err_msg: str):
-    def dec(fn):
-        @wraps(fn)
-        def wrapper(obj, val):
-            _len = len(val)
-            if not compare_fn(_len, bound):
-                msg = f"Length of '{fn.__name__}' must be {compare_symbol} {bound}"
-                raise exc_type(err_msg if err_msg else msg)
-            fn(obj, val)
-
-        return wrapper
-
-    return dec
-
-
-def min_len(m_len: int, /, *,
-            exc_type=ValidationError,
-            err_msg: Optional[str] = None):
-    return _len_validator(m_len, compare_symbol=">=",
-                          compare_fn=operator.ge,
-                          exc_type=exc_type, err_msg=err_msg)
-
-
-def lt(val: Number, /, *, exc_type=ValidationError,
-       err_msg: Optional[str] = None):
-    return _num_validator(val, compare_symbol="<",
-                          compare_fn=operator.lt,
-                          exc_type=exc_type,
-                          err_msg=err_msg)
-
-
-def le(val: Number, /, *, exc_type=ValidationError,
-       err_msg: Optional[str] = None):
-    return _num_validator(val, compare_symbol="<=",
-                          compare_fn=operator.le,
-                          exc_type=exc_type,
-                          err_msg=err_msg)
-
-
-def eq(val: Number, /, *, exc_type=ValidationError,
-       err_msg: Optional[str] = None):
-    return _num_validator(val, compare_symbol="==",
-                          compare_fn=operator.eq,
-                          exc_type=exc_type,
-                          err_msg=err_msg)
-
-
-def ne(val: Number, /, *, exc_type=ValidationError,
-       err_msg: Optional[str] = None):
-    return _num_validator(val, compare_symbol="!=",
-                          compare_fn=operator.ne,
-                          exc_type=exc_type,
-                          err_msg=err_msg)
-
-
-def ge(val: Number, /, *, exc_type=ValidationError,
-       err_msg: Optional[str] = None):
-    return _num_validator(val, compare_symbol=">=",
-                          compare_fn=operator.ge,
-                          exc_type=exc_type,
-                          err_msg=err_msg)
-
-
-def gt(val: Number, /, *, exc_type=ValidationError,
-       err_msg: Optional[str] = None):
-    return _num_validator(val, compare_symbol=">",
-                          compare_fn=operator.gt,
-                          exc_type=exc_type,
-                          err_msg=err_msg)