geolysis 0.7.3__tar.gz → 0.9.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: geolysis
-Version: 0.7.3
+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
@@ -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.9.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.9.0}/geolysis/__init__.py

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

{geolysis-0.7.3 → geolysis-0.9.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.9.0}/geolysis/bearing_capacity/abc/cohl/_core.py

@@ -1,7 +1,7 @@
 from abc import ABC, abstractmethod
 
-from geolysis.foundation import FoundationSize
-from geolysis.utils import validators, exceptions as exc
+from geolysis.foundation import Foundation
+from geolysis.utils import validators
 
 
 class AllowableBearingCapacity(ABC):
@@ -10,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
@@ -31,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.7.3 → 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.7.3 → 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.7.3 → 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.7.3 → geolysis-0.9.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.
@@ -134,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)
 
@@ -146,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.7.3 → 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.7.3 → geolysis-0.9.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.9.0}/geolysis/foundation.py

@@ -5,10 +5,10 @@ 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",
+           "Foundation",
            "FoundationType",
            "Shape",
            "StripFooting",
@@ -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):
@@ -214,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
 
@@ -236,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
@@ -247,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
@@ -296,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)."""
@@ -334,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
@@ -356,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
@@ -376,10 +400,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,12 +414,15 @@ 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,
-                          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.7.3 → geolysis-0.9.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",
@@ -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."""
@@ -713,17 +718,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 +742,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.9.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.7.3 → 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.7.3 → geolysis-0.9.0}/geolysis.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: geolysis
-Version: 0.7.3
+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
@@ -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.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.7.3 → geolysis-0.9.0}/tests/test_soil_classifier.py

@@ -4,18 +4,21 @@ 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):
         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):
         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):
         create_soil_classifier(liquid_limit=30.4,
                                plastic_limit=15.9,
@@ -54,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.7.3 → geolysis-0.9.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)