geolysis 0.7.2__py3-none-any.whl → 0.8.0__py3-none-any.whl

geolysis/__init__.py

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

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/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/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/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/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/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/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
+from .utils.exceptions import ErrorMsg, ValidationError
 
 __all__ = ["SPTNDesign",
            "HammerType",
@@ -51,10 +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:
         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)
@@ -101,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
@@ -223,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."""
@@ -300,6 +326,7 @@ class OPC:
         return self._std_spt_n_value
 
     @std_spt_n_value.setter
+    @validators.le(100)
     @validators.gt(0.0)
     def std_spt_n_value(self, val: float) -> None:
         self._std_spt_n_value = val
@@ -494,6 +521,7 @@ class DilatancyCorrection:
         return self._corr_spt_n_value
 
     @corr_spt_n_value.setter
+    @validators.le(100.0)
     @validators.gt(0.0)
     def corr_spt_n_value(self, val: float) -> None:
         self._corr_spt_n_value = val
@@ -552,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/utils/exceptions.py

@@ -1,36 +1,52 @@
-from typing import Unpack, TypedDict, NotRequired, Any, Optional
+from collections import UserString
+from typing import Any
 
 
-class _ErrorParams(TypedDict):
-    param_name: NotRequired[str]
-    param_value: NotRequired[Any]
-    param_type: NotRequired[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
 
-class ErrorMsg(str):
+        super().__init__(msg)
 
-    @staticmethod
-    def __new__(cls, msg):
-        return super().__new__(cls, 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 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 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(ValueError):
+class SettlementError(ValidationError):
     """Raised when tolerable settlement is greater than the maximum
     allowable settlement.
     """

geolysis/utils/validators.py

@@ -1,101 +1,129 @@
 """validators"""
 import operator
-from typing import Callable, TypeAlias, Optional
 from functools import wraps
+from typing import Any, Callable, Iterable, TypeAlias
 
-from .exceptions import ValidationError
+from .exceptions import ErrorMsg, 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):
+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 not compare_fn(val, bound):
-                msg = f"{fn.__name__} must be {compare_symbol} {bound}"
-                raise exc_type(err_msg if err_msg else msg)
+            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
 
-    return dec
 
+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 _len_validator(bound: float, /, *,
-                   compare_symbol: str,
-                   compare_fn: Callable,
-                   exc_type: Callable,
-                   err_msg: str):
-    def dec(fn):
+    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):
-            _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)
+            self._check_val(val, fn.__name__)
             fn(obj, val)
 
         return wrapper
 
-    return dec
+
+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(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 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: Optional[str] = None):
-    return _num_validator(val, compare_symbol="<",
-                          compare_fn=operator.lt,
-                          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: Optional[str] = None):
-    return _num_validator(val, compare_symbol="<=",
-                          compare_fn=operator.le,
-                          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: Optional[str] = None):
-    return _num_validator(val, compare_symbol="==",
-                          compare_fn=operator.eq,
-                          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: Optional[str] = None):
-    return _num_validator(val, compare_symbol="!=",
-                          compare_fn=operator.ne,
-                          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: Optional[str] = None):
-    return _num_validator(val, compare_symbol=">=",
-                          compare_fn=operator.ge,
-                          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: Optional[str] = None):
-    return _num_validator(val, compare_symbol=">",
-                          compare_fn=operator.gt,
-                          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.2.dist-info → geolysis-0.8.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: geolysis
-Version: 0.7.2
+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.8.0.dist-info/RECORD

@@ -0,0 +1,24 @@
+geolysis/__init__.py,sha256=bn4Oh6O9s3McKkLWpVE_XT6DYNMWK-aqLHviet6uFoY,122
+geolysis/foundation.py,sha256=jo6jBP1V4WZRgJOkgR_MI4b3c1AgCeBq246bCZJxTCc,11856
+geolysis/soil_classifier.py,sha256=4wEZo3E2CvJt7WQh2V3KMjPvbqoyWeFkb_kCgQtR85Q,27018
+geolysis/spt.py,sha256=ix0kHhOXeaIRhfqxq3CTueDpLRlPCfeSz8KyqQSwF8k,18208
+geolysis/bearing_capacity/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+geolysis/bearing_capacity/abc/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+geolysis/bearing_capacity/abc/cohl/__init__.py,sha256=En8EQMz8LV0rCy8EZZXHkUOfBe7KBnw2Kz-Q8SpU7HM,5454
+geolysis/bearing_capacity/abc/cohl/_core.py,sha256=LpXXaIGfq8jafSSi5b6tdTbdy1SMAtV_vm5id9ZeRVI,1653
+geolysis/bearing_capacity/abc/cohl/bowles_abc.py,sha256=kUAZWR5exvRNoOB6pXoxmyOiQorPNtnZwBoaXCk9z0I,4096
+geolysis/bearing_capacity/abc/cohl/meyerhof_abc.py,sha256=3iriC_pQCKRf_4QtDm8163lnKNZUvJ9M7c7ZyRRrID8,4056
+geolysis/bearing_capacity/abc/cohl/terzaghi_abc.py,sha256=EOGfA7_IM0vCa5gLBaBOiEgop4nKBtghoA5EZC7k9dM,5308
+geolysis/bearing_capacity/ubc/__init__.py,sha256=e87E_V13rZM80mXPzZKCqcftUX2es_222r17uMR7qGc,6039
+geolysis/bearing_capacity/ubc/_core.py,sha256=xia-ygcbjF3a9eVh6hzp61LPVJfHHCiztb1J8_W2apE,6177
+geolysis/bearing_capacity/ubc/hansen_ubc.py,sha256=exkYLUG4W8AecJVbYC4lnE58KbssVUsjI0lJ7Mu5pqw,7170
+geolysis/bearing_capacity/ubc/terzaghi_ubc.py,sha256=TokZUUlP62R9zFtokzZVY57M6cEoKy1-T5wy0hvQxGU,6513
+geolysis/bearing_capacity/ubc/vesic_ubc.py,sha256=zlFI26tY_L1LCb6T7q4NY4E0pTivdjYyTttp-VcIlvk,7405
+geolysis/utils/__init__.py,sha256=713rJNWVFLrP4CNon4i-xUf5rF5eA40Ydg-F1UV8o-0,2339
+geolysis/utils/exceptions.py,sha256=4tsB3e7k_FzYSSqEWd0KungaRviqiBoYkLh4ipAyFeA,1387
+geolysis/utils/validators.py,sha256=vgQLreUdKXB0mBCZrfto9o2Z8rqgtPXJ8XQPzhjAT3w,4012
+geolysis-0.8.0.dist-info/licenses/LICENSE.txt,sha256=ap6sMs3lT7ICbEXBhgihwH1BTCVcjmCQkIkwVnil1Ak,1065
+geolysis-0.8.0.dist-info/METADATA,sha256=vLwq6Zl56dxwYw-ry_dA6XovKHm5-KH1BJgKyFuciNg,7211
+geolysis-0.8.0.dist-info/WHEEL,sha256=wXxTzcEDnjrTwFYjLPcsW_7_XihufBwmpiBeiXNBGEA,91
+geolysis-0.8.0.dist-info/top_level.txt,sha256=9mnQgOaCRr11dtXff8X-q3FfXjRONd6kHseSy5q2y8g,9
+geolysis-0.8.0.dist-info/RECORD,,

{geolysis-0.7.2.dist-info → geolysis-0.8.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (79.0.0)
+Generator: setuptools (80.1.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

geolysis-0.7.2.dist-info/RECORD

@@ -1,24 +0,0 @@
-geolysis/__init__.py,sha256=AvRgv11HmUiEzG07RQS3vGM6j234EtzUPJKnSGUBePo,122
-geolysis/foundation.py,sha256=gxI6bLbUrxQNhoKJis5glDysnI6PgqBkMM9m5CQztsg,11695
-geolysis/soil_classifier.py,sha256=2C-4hpgXNo2DUgXKcokUh3qjAH70qvgOCnxsL_NnmTw,26880
-geolysis/spt.py,sha256=7C8FPwwUej_YLkLAMMyUVhWYoh9FH4__6g5_G8NSas0,17507
-geolysis/bearing_capacity/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-geolysis/bearing_capacity/abc/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-geolysis/bearing_capacity/abc/cohl/__init__.py,sha256=sWhQJj5klrenbwgaBAWRM23BQCcudZM4Ztwg8auxNw8,5399
-geolysis/bearing_capacity/abc/cohl/_core.py,sha256=ZQrjK4d89OMNhLRg9PczRpwkT6xiRRcn2sq603Fsobc,1627
-geolysis/bearing_capacity/abc/cohl/bowles_abc.py,sha256=kUAZWR5exvRNoOB6pXoxmyOiQorPNtnZwBoaXCk9z0I,4096
-geolysis/bearing_capacity/abc/cohl/meyerhof_abc.py,sha256=3iriC_pQCKRf_4QtDm8163lnKNZUvJ9M7c7ZyRRrID8,4056
-geolysis/bearing_capacity/abc/cohl/terzaghi_abc.py,sha256=EOGfA7_IM0vCa5gLBaBOiEgop4nKBtghoA5EZC7k9dM,5308
-geolysis/bearing_capacity/ubc/__init__.py,sha256=Q9VJhjgcz1heFjj0zgvASUFekNS683_BZBfTJsfxPcE,5983
-geolysis/bearing_capacity/ubc/_core.py,sha256=xia-ygcbjF3a9eVh6hzp61LPVJfHHCiztb1J8_W2apE,6177
-geolysis/bearing_capacity/ubc/hansen_ubc.py,sha256=exkYLUG4W8AecJVbYC4lnE58KbssVUsjI0lJ7Mu5pqw,7170
-geolysis/bearing_capacity/ubc/terzaghi_ubc.py,sha256=zoTf2pVTd1zN_6-yuNK9njo-8rn4o3CSccAEiivc2AE,6514
-geolysis/bearing_capacity/ubc/vesic_ubc.py,sha256=zlFI26tY_L1LCb6T7q4NY4E0pTivdjYyTttp-VcIlvk,7405
-geolysis/utils/__init__.py,sha256=713rJNWVFLrP4CNon4i-xUf5rF5eA40Ydg-F1UV8o-0,2339
-geolysis/utils/exceptions.py,sha256=ivuyxqz0B7nmA5sXMfw4o7KPnQHoaGbLHmJCEiCEaAc,929
-geolysis/utils/validators.py,sha256=g18NIlLaNSIjlBwRLkUQr68qcYnwzo5qcfY5y_GoO1Y,3205
-geolysis-0.7.2.dist-info/licenses/LICENSE.txt,sha256=ap6sMs3lT7ICbEXBhgihwH1BTCVcjmCQkIkwVnil1Ak,1065
-geolysis-0.7.2.dist-info/METADATA,sha256=XjRf0LvX0IAhJgp2mkMk-uNTTsuwgHZ4iovkMwC2oUI,7235
-geolysis-0.7.2.dist-info/WHEEL,sha256=pxyMxgL8-pra_rKaQ4drOZAegBVuX-G_4nRHjjgWbmo,91
-geolysis-0.7.2.dist-info/top_level.txt,sha256=9mnQgOaCRr11dtXff8X-q3FfXjRONd6kHseSy5q2y8g,9
-geolysis-0.7.2.dist-info/RECORD,,