geolysis 0.8.0__tar.gz → 0.9.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: geolysis
-Version: 0.8.0
+Version: 0.9.0
 Summary: geolysis is an opensource software for geotechnical engineering analysis and modeling.
 Author-email: Patrick Boateng <boatengpato.pb@gmail.com>
 License: MIT License

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

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

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

@@ -1,7 +1,6 @@
 from abc import ABC, abstractmethod
 
-from geolysis.foundation import FoundationSize
-from geolysis.utils import exceptions as exc
+from geolysis.foundation import Foundation
 from geolysis.utils import validators
 
 
@@ -11,7 +10,7 @@ class AllowableBearingCapacity(ABC):
 
     def __init__(self, corrected_spt_n_value: float,
                  tol_settlement: float,
-                 foundation_size: FoundationSize) -> None:
+                 foundation_size: Foundation) -> None:
         self.corrected_spt_n_value = corrected_spt_n_value
         self.tol_settlement = tol_settlement
         self.foundation_size = foundation_size
@@ -32,7 +31,7 @@ class AllowableBearingCapacity(ABC):
         return self._tol_settlement
 
     @tol_settlement.setter
-    @validators.le(25.4, exc_type=exc.SettlementError)
+    @validators.le(25.4)
     def tol_settlement(self, tol_settlement: float) -> None:
         self._tol_settlement = tol_settlement
 

{geolysis-0.8.0 → geolysis-0.9.0}/geolysis/bearing_capacity/abc/cohl/bowles_abc.py

@@ -1,4 +1,4 @@
-from geolysis.foundation import FoundationSize
+from geolysis.foundation import Foundation
 from geolysis.utils import round_
 
 from ._core import AllowableBearingCapacity
@@ -34,7 +34,7 @@ class BowlesABC4PadFoundation(AllowableBearingCapacity):
 
     def __init__(self, corrected_spt_n_value: float,
                  tol_settlement: float,
-                 foundation_size: FoundationSize) -> None:
+                 foundation_size: Foundation) -> None:
         """
         :param corrected_spt_n_value: Statistical average of corrected SPT
                                       N-value (55% energy with overburden 
@@ -46,7 +46,7 @@ class BowlesABC4PadFoundation(AllowableBearingCapacity):
         :type tol_settlement: float
 
         :param foundation_size: Size of the foundation.
-        :type foundation_size: FoundationSize
+        :type foundation_size: Foundation
         """
         super().__init__(corrected_spt_n_value=corrected_spt_n_value,
                          tol_settlement=tol_settlement,

{geolysis-0.8.0 → geolysis-0.9.0}/geolysis/bearing_capacity/abc/cohl/meyerhof_abc.py

@@ -1,4 +1,4 @@
-from geolysis.foundation import FoundationSize
+from geolysis.foundation import Foundation
 from geolysis.utils import round_
 
 from ._core import AllowableBearingCapacity
@@ -33,7 +33,7 @@ class MeyerhofABC4PadFoundation(AllowableBearingCapacity):
 
     def __init__(self, corrected_spt_n_value: float,
                  tol_settlement: float,
-                 foundation_size: FoundationSize):
+                 foundation_size: Foundation):
         """
         :param corrected_spt_n_value: Average uncorrected SPT N-value (60% 
                                       energy with dilatancy (water) correction 
@@ -46,7 +46,7 @@ class MeyerhofABC4PadFoundation(AllowableBearingCapacity):
         :type tol_settlement: float
 
         :param foundation_size: Size of the foundation.
-        :type foundation_size: FoundationSize
+        :type foundation_size: Foundation
         """
         super().__init__(corrected_spt_n_value=corrected_spt_n_value,
                          tol_settlement=tol_settlement,

{geolysis-0.8.0 → geolysis-0.9.0}/geolysis/bearing_capacity/abc/cohl/terzaghi_abc.py

@@ -1,4 +1,4 @@
-from geolysis.foundation import FoundationSize
+from geolysis.foundation import Foundation
 from geolysis.utils import round_
 
 from ._core import AllowableBearingCapacity
@@ -40,7 +40,7 @@ class TerzaghiABC4PadFoundation(AllowableBearingCapacity):
 
     def __init__(self, corrected_spt_n_value: float,
                  tol_settlement: float,
-                 foundation_size: FoundationSize) -> None:
+                 foundation_size: Foundation) -> None:
         """
         :param corrected_spt_n_value: Lowest (or average) uncorrected SPT 
                                       N-value (60% energy) within the foundation 
@@ -52,7 +52,7 @@ class TerzaghiABC4PadFoundation(AllowableBearingCapacity):
         :type tol_settlement: float
 
         :param foundation_size: Size of the foundation.
-        :type foundation_size: FoundationSize
+        :type foundation_size: Foundation
         """
         super().__init__(corrected_spt_n_value=corrected_spt_n_value,
                          tol_settlement=tol_settlement,

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

@@ -135,6 +135,7 @@ def create_ultimate_bearing_capacity(friction_angle: float,
                                  width=width,
                                  length=length,
                                  eccentricity=eccentricity,
+                                 load_angle=load_angle,
                                  ground_water_level=ground_water_level,
                                  shape=shape)
 
@@ -147,6 +148,5 @@ def create_ultimate_bearing_capacity(friction_angle: float,
                     cohesion=cohesion,
                     moist_unit_wgt=moist_unit_wgt,
                     foundation_size=fnd_size,
-                    load_angle=load_angle,
                     apply_local_shear=apply_local_shear)
     return ubc

{geolysis-0.8.0 → geolysis-0.9.0}/geolysis/bearing_capacity/ubc/_core.py

@@ -1,6 +1,6 @@
 from abc import ABC, abstractmethod
 
-from geolysis.foundation import FoundationSize
+from geolysis.foundation import Foundation
 from geolysis.utils import arctan, round_, tan, validators
 
 
@@ -8,8 +8,8 @@ class UltimateBearingCapacity(ABC):
     def __init__(self, friction_angle: float,
                  cohesion: float,
                  moist_unit_wgt: float,
-                 foundation_size: FoundationSize,
-                 load_angle: float = 0.0,
+                 foundation_size: Foundation,
+                 # load_angle: float = 0.0,
                  apply_local_shear: bool = False) -> None:
         r"""
         :param friction_angle: Internal angle of friction for general shear 
@@ -23,11 +23,7 @@ class UltimateBearingCapacity(ABC):
         :type moist_unit_wgt: float
 
         :param foundation_size: Size of the foundation.
-        :type foundation_size: FoundationSize
-
-        :param load_angle: Inclination of the applied load with the  vertical 
-                           (:math:`\alpha^{\circ}`), defaults to 0.0.
-        :type load_angle: float, optional
+        :type foundation_size: Foundation
 
         :param apply_local_shear: Indicate whether bearing capacity failure is
                                   general shear or local shear failure,
@@ -37,7 +33,6 @@ class UltimateBearingCapacity(ABC):
         self.friction_angle = friction_angle
         self.cohesion = cohesion
         self.moist_unit_wgt = moist_unit_wgt
-        self.load_angle = load_angle
         self.foundation_size = foundation_size
         self.apply_local_shear = apply_local_shear
 
@@ -97,15 +92,9 @@ class UltimateBearingCapacity(ABC):
         self._moist_unit_wgt = val
 
     @property
-    def load_angle(self) -> float:
+    def load_angle(self):
         """Inclination of the applied load with the  vertical."""
-        return self._load_angle
-
-    @load_angle.setter
-    @validators.le(90.0)
-    @validators.ge(0.0)
-    def load_angle(self, val: float):
-        self._load_angle = val
+        return self.foundation_size.load_angle
 
     @property
     def s_c(self) -> float:

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

@@ -8,7 +8,7 @@ from .utils import enum_repr, inf, isclose, validators
 from .utils.exceptions import ErrorMsg, ValidationError
 
 __all__ = ["create_foundation",
-           "FoundationSize",
+           "Foundation",
            "FoundationType",
            "Shape",
            "StripFooting",
@@ -216,15 +216,16 @@ class RectangularFooting(FootingSize):
         self._length = val
 
 
-class FoundationSize:
+class Foundation:
     """A simple class representing a foundation structure."""
 
     def __init__(self, depth: float,
                  footing_size: FootingSize,
                  eccentricity: float = 0.0,
+                 load_angle: float = 0.0,
                  ground_water_level: Optional[float] = None,
                  foundation_type: FoundationType = FoundationType.PAD) -> None:
-        """
+        r"""
         :param depth: Depth of foundation (m).
         :type depth: float
 
@@ -238,6 +239,10 @@ class FoundationSize:
                              foundation footing.
         :type eccentricity: float, optional
 
+        :param load_angle: Inclination of the applied load with the  vertical
+                           (:math:`\alpha^{\circ}`), defaults to 0.0.
+        :type load_angle: float, optional
+
         :param ground_water_level: Depth of the water below ground level (m),
                                    defaults to None.
         :type ground_water_level: float, optional
@@ -249,6 +254,7 @@ class FoundationSize:
         self.depth = depth
         self.footing_size = footing_size
         self.eccentricity = eccentricity
+        self.load_angle = load_angle
 
         self._ground_water_level = ground_water_level
         self._foundation_type = foundation_type
@@ -298,6 +304,17 @@ class FoundationSize:
     def eccentricity(self, val: float) -> None:
         self._eccentricity = val
 
+    @property
+    def load_angle(self) -> float:
+        """Inclination of the applied load with the  vertical."""
+        return self._load_angle
+
+    @load_angle.setter
+    @validators.le(90.0)
+    @validators.ge(0.0)
+    def load_angle(self, val: float):
+        self._load_angle = val
+
     @property
     def ground_water_level(self) -> Optional[float]:
         """Depth of the water below ground level (m)."""
@@ -336,10 +353,11 @@ def create_foundation(depth: float,
                       width: float,
                       length: Optional[float] = None,
                       eccentricity: float = 0.0,
+                      load_angle: float = 0.0,
                       ground_water_level: Optional[float] = None,
                       foundation_type: FoundationType = FoundationType.PAD,
-                      shape: Shape | str = Shape.SQUARE) -> FoundationSize:
-    """A factory function that encapsulate the creation of a foundation.
+                      shape: Shape | str = Shape.SQUARE) -> Foundation:
+    r"""A factory function that encapsulate the creation of a foundation.
 
     :param depth: Depth of foundation (m).
     :type depth: float
@@ -358,6 +376,10 @@ def create_foundation(depth: float,
                          foundation footing .
     :type eccentricity: float, optional
 
+    :param load_angle: Inclination of the applied load with the  vertical
+                           (:math:`\alpha^{\circ}`), defaults to 0.0.
+    :type load_angle: float, optional
+
     :param ground_water_level: Depth of the water below ground level (m),
                                defaults to None.
     :type ground_water_level: float, optional
@@ -398,8 +420,9 @@ def create_foundation(depth: float,
             raise ValidationError(msg)
         footing_size = RectangularFooting(width=width, length=length)
 
-    return FoundationSize(depth=depth,
-                          eccentricity=eccentricity,
-                          ground_water_level=ground_water_level,
-                          foundation_type=foundation_type,
-                          footing_size=footing_size)
+    return Foundation(depth=depth,
+                      eccentricity=eccentricity,
+                      load_angle=load_angle,
+                      ground_water_level=ground_water_level,
+                      foundation_type=foundation_type,
+                      footing_size=footing_size)

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

@@ -117,9 +117,6 @@ class AtterbergLimits:
                               3mm thick. (molded without breaking)
         :type plastic_limit: float
         """
-        if liquid_limit < plastic_limit:
-            raise ValueError("liquid_limit cannot be less than plastic_limit")
-
         self.liquid_limit = liquid_limit
         self.plastic_limit = plastic_limit
 
@@ -141,6 +138,14 @@ class AtterbergLimits:
     @plastic_limit.setter
     @validators.ge(0.0)
     def plastic_limit(self, val: float) -> None:
+        if self.liquid_limit < val:
+            msg = ErrorMsg(param_name="plastic_limit",
+                           param_value=val,
+                           param_value_bound=f"<{self.liquid_limit}",
+                           msg=f"plastic_limit: {val} cannot be greater than "
+                               f"liquid_limit: {self.liquid_limit}")
+            raise ValidationError(msg)
+
         self._plastic_limit = val
 
     @property
@@ -421,12 +426,12 @@ class AASHTO:
         plasticity_idx = self.atterberg_limits.plasticity_index
         fines = self.fines
 
-        var_a = 1.0 if (x_0 := fines - 35.0) < 0.0 else min(x_0, 40.0)
-        var_b = 1.0 if (x_0 := liquid_lmt - 40.0) < 0.0 else min(x_0, 20.0)
-        var_c = 1.0 if (x_0 := fines - 15.0) < 0.0 else min(x_0, 40.0)
-        var_d = 1.0 if (x_0 := plasticity_idx - 10.0) < 0.0 else min(x_0, 20.0)
+        x_1 = 1.0 if (x_0 := fines - 35.0) < 0.0 else min(x_0, 40.0)
+        x_2 = 1.0 if (x_0 := liquid_lmt - 40.0) < 0.0 else min(x_0, 20.0)
+        x_3 = 1.0 if (x_0 := fines - 15.0) < 0.0 else min(x_0, 40.0)
+        x_4 = 1.0 if (x_0 := plasticity_idx - 10.0) < 0.0 else min(x_0, 20.0)
 
-        return var_a * (0.2 + 0.005 * var_b) + 0.01 * var_c * var_d
+        return x_1 * (0.2 + 0.005 * x_2) + 0.01 * x_3 * x_4
 
     def classify(self) -> SoilClf:
         """Return the AASHTO classification of the soil."""

{geolysis-0.8.0 → geolysis-0.9.0}/geolysis/utils/__init__.py

@@ -67,18 +67,19 @@ def enum_repr(cls):
     return cls
 
 
-def round_(ndigits: int | Callable[..., SupportsRound]) -> Callable:
+def round_(ndigits: int) -> Callable:
     """A decorator that rounds the result of a callable to a specified number
     of decimal places.
 
     The returned value of the callable should support the ``__round__`` dunder
-    method and should be a numeric value. ``ndigits`` can either be an int
-    which will indicate the number of decimal places to round to or a
-    callable. If ``ndigits`` is callable the default decimal places is 2.
+    method and should be a numeric value.
 
-    TypeError is raised when ``ndigits`` is neither an int nor a callable.
+    TypeError is raised when ``ndigits`` is not an int.
     """
 
+    if not isinstance(ndigits, int):
+        raise TypeError("ndigits must be an int")
+
     def dec(fn) -> Callable[..., float]:
         @functools.wraps(fn)
         def wrapper(*args, **kwargs) -> float:

geolysis-0.9.0/geolysis/utils/exceptions.py

@@ -0,0 +1,65 @@
+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}"
+
+        super().__init__(msg)
+
+        self.param_name = param_name
+        self.param_value = param_value
+        self.symbol = symbol
+        self.param_value_bound = param_value_bound
+
+    @property
+    def msg(self):
+        return self.data
+
+    def __add__(self, other):
+        msg = self.msg + str(other)
+        return self.__class__(param_name=self.param_name,
+                              param_value=self.param_value,
+                              symbol=self.symbol,
+                              param_value_bound=self.param_value_bound,
+                              msg=msg)
+
+    def __radd__(self, other):
+        msg = str(other) + self.msg
+        return self.__class__(param_name=self.param_name,
+                              param_value=self.param_value,
+                              symbol=self.symbol,
+                              param_value_bound=self.param_value_bound,
+                              msg=msg)
+
+    def __repr__(self) -> str:
+        return f"ErrorMsg(param_name={self.param_name}, " \
+               f"param_value={self.param_value}, " \
+               f"symbol={self.symbol}, " \
+               f"param_value_bound={self.param_value_bound}, msg={self.msg!r})"
+
+    def to_dict(self) -> dict:
+        return {
+            "param_name": self.param_name,
+            "param_value": self.param_value,
+            "symbol": self.symbol,
+            "param_value_bound": self.param_value_bound,
+            "message": self.msg
+        }
+
+
+class ValidationError(ValueError):
+    """Exception raised when a validation error occurs."""
+
+    def __init__(self, error: ErrorMsg):
+        super().__init__(error)
+        self.error = error
+
+    def __repr__(self):
+        return f"ValidationError(error={self.error!r})"

geolysis-0.9.0/geolysis/utils/validators.py

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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: geolysis
-Version: 0.8.0
+Version: 0.9.0
 Summary: geolysis is an opensource software for geotechnical engineering analysis and modeling.
 Author-email: Patrick Boateng <boatengpato.pb@gmail.com>
 License: MIT License

{geolysis-0.8.0 → geolysis-0.9.0}/tests/test_foundation.py

@@ -1,6 +1,6 @@
 import unittest
 
-from geolysis.foundation import (CircularFooting, FoundationSize,
+from geolysis.foundation import (CircularFooting, Foundation,
                                  RectangularFooting, Shape, SquareFooting,
                                  StripFooting, create_foundation)
 
@@ -53,9 +53,9 @@ class TestFoundation(unittest.TestCase):
 
     def test_foundation_size(self):
         footing = StripFooting(width=2.0)
-        foundation = FoundationSize(depth=1.5,
-                                    footing_size=footing,
-                                    eccentricity=0.1)
+        foundation = Foundation(depth=1.5,
+                                footing_size=footing,
+                                eccentricity=0.1)
         self.assertEqual(foundation.depth, 1.5)
         self.assertEqual(foundation.width, 2.0)
         self.assertEqual(foundation.length, float('inf'))

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

@@ -4,22 +4,22 @@ from geolysis.soil_classifier import (PSD, AtterbergLimits,
                                       create_soil_classifier)
 
 
-def test_create_soil_classifier():
+def test_create_soil_classifier_errors():
+    # Did not provide a classification (clf_type) value
     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)
 
+    # Provided a wrong value for clf_type
     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")
 
+    # Did not provide sand for USCS classification
     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,
@@ -57,6 +57,7 @@ class TestAtterbergLimits:
         assert al.consistency_index(nmc=nmc) == pytest.approx(expected)
 
     def test_errors(self):
+        # Plastic limit is greater than liquid limit
         with pytest.raises(ValueError):
             AtterbergLimits(liquid_limit=15.0, plastic_limit=25.0)
 

geolysis-0.8.0/geolysis/utils/exceptions.py

@@ -1,52 +0,0 @@
-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

@@ -1,129 +0,0 @@
-"""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)