geolysis 0.6.2__py3-none-any.whl → 0.7.1__py3-none-any.whl

geolysis/__init__.py

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

geolysis/bearing_capacity/abc/cohl/__init__.py

@@ -3,10 +3,12 @@ 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 ErrorMsg, enum_repr, inf
+from geolysis.utils import enum_repr, inf
+from geolysis.utils.exceptions import EnumErrorMsg
 
 from ._core import AllowableBearingCapacity
 from .bowles_abc import BowlesABC4MatFoundation, BowlesABC4PadFoundation
@@ -22,6 +24,22 @@ class ABCType(enum.StrEnum):
     TERZAGHI = enum.auto()
 
 
+abc_classes = {
+    ABCType.BOWLES: {
+        FoundationType.PAD: BowlesABC4PadFoundation,
+        FoundationType.MAT: BowlesABC4MatFoundation,
+    },
+    ABCType.MEYERHOF: {
+        FoundationType.PAD: MeyerhofABC4PadFoundation,
+        FoundationType.MAT: MeyerhofABC4MatFoundation,
+    },
+    ABCType.TERZAGHI: {
+        FoundationType.PAD: TerzaghiABC4PadFoundation,
+        FoundationType.MAT: TerzaghiABC4MatFoundation,
+    }
+}
+
+
 def create_allowable_bearing_capacity(corrected_spt_n_value: float,
                                       tol_settlement: float,
                                       depth: float,
@@ -81,9 +99,9 @@ def create_allowable_bearing_capacity(corrected_spt_n_value: float,
     :raises ValueError: Raised if an invalid footing ``shape`` is provided.
     """
 
-    msg = ErrorMsg(param_name="abc_type",
-                   param_value=abc_type,
-                   param_type=ABCType)
+    msg = EnumErrorMsg(param_name="abc_type",
+                       param_value=abc_type,
+                       param_type=ABCType)
 
     if abc_type is None:
         raise ValueError(msg)
@@ -96,9 +114,9 @@ def create_allowable_bearing_capacity(corrected_spt_n_value: float,
     try:
         foundation_type = FoundationType(str(foundation_type).casefold())
     except ValueError as e:
-        msg = ErrorMsg(param_name="foundation_type",
-                       param_value=foundation_type,
-                       param_type=FoundationType)
+        msg = EnumErrorMsg(param_name="foundation_type",
+                           param_value=foundation_type,
+                           param_type=FoundationType)
         raise ValueError(msg) from e
 
     # exception from create_foundation will automaatically propagate
@@ -110,20 +128,6 @@ def create_allowable_bearing_capacity(corrected_spt_n_value: float,
                                  ground_water_level=ground_water_level,
                                  foundation_type=foundation_type,
                                  shape=shape)
-    abc_classes = {
-        ABCType.BOWLES: {
-            FoundationType.PAD: BowlesABC4PadFoundation,
-            FoundationType.MAT: BowlesABC4MatFoundation,
-        },
-        ABCType.MEYERHOF: {
-            FoundationType.PAD: MeyerhofABC4PadFoundation,
-            FoundationType.MAT: MeyerhofABC4MatFoundation,
-        },
-        ABCType.TERZAGHI: {
-            FoundationType.PAD: TerzaghiABC4PadFoundation,
-            FoundationType.MAT: TerzaghiABC4MatFoundation,
-        }
-    }
 
     abc_class = abc_classes[abc_type][fnd_size.foundation_type]
     abc = abc_class(corrected_spt_n_value=corrected_spt_n_value,

geolysis/bearing_capacity/abc/cohl/_core.py

@@ -1,13 +1,7 @@
 from abc import ABC, abstractmethod
 
 from geolysis.foundation import FoundationSize
-from geolysis.utils import validators
-
-
-class SettlementError(ValueError):
-    """Raised when tolerable settlement is greater than the maximum 
-    allowable settlement.
-    """
+from geolysis.utils import validators, exceptions as exc
 
 
 class AllowableBearingCapacity(ABC):
@@ -37,7 +31,7 @@ class AllowableBearingCapacity(ABC):
         return self._tol_settlement
 
     @tol_settlement.setter
-    @validators.le(25.4, exc_type=SettlementError)
+    @validators.le(25.4, exc_type=exc.SettlementError)
     def tol_settlement(self, tol_settlement: float) -> None:
         self._tol_settlement = tol_settlement
 

geolysis/bearing_capacity/ubc/__init__.py

@@ -7,7 +7,8 @@ import enum
 from typing import Optional
 
 from geolysis.foundation import Shape, create_foundation
-from geolysis.utils import ErrorMsg, enum_repr
+from geolysis.utils import enum_repr
+from geolysis.utils.exceptions import EnumErrorMsg
 
 from ._core import UltimateBearingCapacity
 from .hansen_ubc import HansenUltimateBearingCapacity
@@ -34,6 +35,16 @@ class UBCType(enum.StrEnum):
     VESIC = enum.auto()
 
 
+ubc_classes = {
+    UBCType.HANSEN: HansenUltimateBearingCapacity,
+    UBCType.TERZAGHI: {Shape.STRIP: TerzaghiUBC4StripFooting,
+                       Shape.CIRCLE: TerzaghiUBC4CircularFooting,
+                       Shape.SQUARE: TerzaghiUBC4SquareFooting,
+                       Shape.RECTANGLE: TerzaghiUBC4RectangularFooting},
+    UBCType.VESIC: VesicUltimateBearingCapacity,
+}
+
+
 def create_ultimate_bearing_capacity(friction_angle: float,
                                      cohesion: float,
                                      moist_unit_wgt: float,
@@ -43,8 +54,8 @@ def create_ultimate_bearing_capacity(friction_angle: float,
                                      eccentricity: float = 0.0,
                                      ground_water_level: Optional[
                                          float] = None,
-                                     load_angle=0.0,
-                                     apply_local_shear=False,
+                                     load_angle: float = 0.0,
+                                     apply_local_shear: bool = False,
                                      shape: Shape | str = Shape.SQUARE,
                                      ubc_type: Optional[UBCType | str] = None,
                                      ) -> UltimateBearingCapacity:
@@ -105,9 +116,9 @@ def create_ultimate_bearing_capacity(friction_angle: float,
     :raises ValueError: Raised if an invalid footing shape is provided.
     """
 
-    msg = ErrorMsg(param_name="ubc_type",
-                   param_value=ubc_type,
-                   param_type=UBCType)
+    msg = EnumErrorMsg(param_name="ubc_type",
+                       param_value=ubc_type,
+                       param_type=UBCType)
 
     if ubc_type is None:
         raise ValueError(msg)
@@ -125,14 +136,6 @@ def create_ultimate_bearing_capacity(friction_angle: float,
                                  eccentricity=eccentricity,
                                  ground_water_level=ground_water_level,
                                  shape=shape)
-    ubc_classes = {
-        UBCType.HANSEN: HansenUltimateBearingCapacity,
-        UBCType.TERZAGHI: {Shape.STRIP: TerzaghiUBC4StripFooting,
-                           Shape.CIRCLE: TerzaghiUBC4CircularFooting,
-                           Shape.SQUARE: TerzaghiUBC4SquareFooting,
-                           Shape.RECTANGLE: TerzaghiUBC4RectangularFooting},
-        UBCType.VESIC: VesicUltimateBearingCapacity,
-    }
 
     if ubc_type == UBCType.TERZAGHI:
         ubc_class = ubc_classes[ubc_type][fnd_size.footing_shape]

geolysis/bearing_capacity/ubc/_core.py

@@ -9,8 +9,8 @@ class UltimateBearingCapacity(ABC):
                  cohesion: float,
                  moist_unit_wgt: float,
                  foundation_size: FoundationSize,
-                 load_angle=0.0,
-                 apply_local_shear=False) -> None:
+                 load_angle: float = 0.0,
+                 apply_local_shear: bool = False) -> None:
         r"""
         :param friction_angle: Internal angle of friction for general shear 
                                failure (degrees).

geolysis/foundation.py

@@ -4,7 +4,8 @@ import enum
 from abc import ABC, abstractmethod
 from typing import Optional, TypeVar
 
-from .utils import ErrorMsg, enum_repr, inf, isclose, validators
+from .utils import enum_repr, inf, isclose, validators
+from .utils.exceptions import EnumErrorMsg, ErrorMsg
 
 __all__ = ["create_foundation",
            "FoundationSize",
@@ -319,7 +320,9 @@ class FoundationSize:
         """Returns the :attr:`effective_width`, :attr:`length`, and
         :attr:`footing_shape` of the foundation footing.
         """
-        width, length, shape = self.effective_width, self.length, self.footing_shape
+        width, length, shape = (self.effective_width,
+                                self.length,
+                                self.footing_shape)
 
         if not isclose(width, length) and shape != Shape.STRIP:
             shape = Shape.RECTANGLE
@@ -373,7 +376,9 @@ def create_foundation(depth: float,
     try:
         shape = Shape(str(shape).casefold())
     except ValueError as e:
-        msg = ErrorMsg(param_name="shape", param_value=shape, param_type=Shape)
+        msg = EnumErrorMsg(param_name="shape",
+                           param_value=shape,
+                           param_type=Shape)
         raise ValueError(msg) from e
 
     if shape is Shape.STRIP:

geolysis/soil_classifier.py

@@ -4,7 +4,8 @@ USCS and AASHTO, based on particle size distribution and  Atterberg limits.
 import enum
 from typing import NamedTuple, Optional, Sequence
 
-from .utils import ErrorMsg, enum_repr, isclose, round_, validators
+from .utils import enum_repr, isclose, round_, validators
+from .utils.exceptions import EnumErrorMsg, ErrorMsg
 
 __all__ = ["ClfType",
            "AtterbergLimits",
@@ -220,7 +221,9 @@ class _SizeDistribution:
     Features obtained from the Particle Size Distribution graph.
     """
 
-    def __init__(self, d_10: float = 0, d_30: float = 0, d_60: float = 0):
+    def __init__(self, d_10: float = 0.0,
+                 d_30: float = 0.0,
+                 d_60: float = 0.0):
         self.d_10 = d_10
         self.d_30 = d_30
         self.d_60 = d_60
@@ -382,7 +385,7 @@ class AASHTO:
     """
 
     def __init__(self, atterberg_limits: AtterbergLimits,
-                 fines: float, add_group_idx=True):
+                 fines: float, add_group_idx: bool = True):
         """
         :param atterberg_limits: Atterberg limits of soil sample.
         :type atterberg_limits: AtterbergLimits
@@ -710,9 +713,9 @@ def create_soil_classifier(liquid_limit: float,
     :raises ValueError: Raises ValueError if ``sand`` is not provided for
                         :class:`USCS` classification.
     """
-    msg = ErrorMsg(param_name="clf_type",
-                   param_value=clf_type,
-                   param_type=ClfType)
+    msg = EnumErrorMsg(param_name="clf_type",
+                       param_value=clf_type,
+                       param_type=ClfType)
 
     if clf_type is None:
         raise ValueError(msg)
@@ -732,8 +735,8 @@ def create_soil_classifier(liquid_limit: float,
         return clf
 
     # USCS classification
-    if sand is None:
-        msg = ErrorMsg(msg=f"sand must be specified for USCS classification")
+    if not sand:
+        msg = ErrorMsg("sand must be specified for USCS classification")
         raise ValueError(msg)
 
     psd = PSD(fines=fines, sand=sand, d_10=d_10, d_30=d_30, d_60=d_60)

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
+from typing import Final, Sequence, Literal
 
-from .utils import (ErrorMsg, enum_repr, isclose, log10, mean, round_, sqrt,
-                    validators)
+from .utils import enum_repr, isclose, log10, mean, round_, sqrt, validators
+from .utils.exceptions import EnumErrorMsg, ErrorMsg
 
 __all__ = ["SPTNDesign",
            "HammerType",
@@ -35,13 +35,15 @@ class SPTNDesign:
     N-value from the base.
     """
 
-    def __init__(self, corrected_spt_n_values: Sequence[float]) -> None:
+    def __init__(self, corrected_spt_n_values: Sequence[float],
+                 method: Literal["min", "avg", "wgt"] = "wgt") -> None:
         """
         :param corrected_spt_n_values: Corrected SPT N-values within the
                                        foundation influence zone.
         :type corrected_spt_n_values: Sequence[float]
         """
         self.corrected_spt_n_values = corrected_spt_n_values
+        self.method = method
 
     @property
     def corrected_spt_n_values(self) -> Sequence[float]:
@@ -53,44 +55,58 @@ class SPTNDesign:
     def corrected_spt_n_values(self, val: Sequence[float]) -> None:
         self._corrected_spt_n_values = val
 
-    @round_(ndigits=1)
-    def average_spt_n_design(self) -> float:
-        """Calculates the average of the corrected SPT N-values within the
-        foundation influence zone.
-        """
-        return mean(self.corrected_spt_n_values)
-
-    @round_(ndigits=1)
-    def minimum_spt_n_design(self):
-        """The lowest SPT N-value within the influence zone can be taken as the
-        :math:`N_{design}` as suggested by ``Terzaghi & Peck (1948)``.
-        """
-        return min(self.corrected_spt_n_values)
+    @staticmethod
+    def _avg_spt_n_design(vals) -> float:
+        return mean(vals)
 
-    @round_(ndigits=1)
-    def weighted_spt_n_design(self):
-        r"""Calculates the weighted average of the corrected SPT N-values
-        within the foundation influence zone.
+    @staticmethod
+    def _min_spt_n_design(vals):
+        return min(vals)
 
-        :Equation:
-
-        .. math::
-
-            N_{design} = \dfrac{\sum_{i=1}^{n} \frac{N_i}{i^2}}
-                         {\sum_{i=1}^{n}\frac{1}{i^2}}
-        """
+    @staticmethod
+    def _wgt_spt_n_design(vals):
 
         sum_total = 0.0
         sum_wgts = 0.0
 
-        for i, corr_spt_n_val in enumerate(self.corrected_spt_n_values,
-                                           start=1):
+        for i, corr_spt_n_val in enumerate(vals, start=1):
             wgt = 1 / i ** 2
             sum_total += wgt * corr_spt_n_val
             sum_wgts += wgt
 
         return sum_total / sum_wgts
 
+    @round_(ndigits=1)
+    def n_design(self):
+        r"""Calculates the SPT N-design within the foundation influence zone.
+
+        If ``method="min"``, it returns the minimum N-value within the foundation
+        influence zone as the SPT N-design value. This approach was suggested
+        by ``Terzaghi & Peck (1948)``.
+
+        if ``method="avg"``, it returns the average N-value within the foundation
+        influence zone as the SPT N-design value.
+
+        if ``method="wgt"``, it returns the weighted average N-value within the
+        foundation influence zone as the SPT N-design value.
+
+        :Equation:
+
+        .. math::
+
+            N_{design} = \dfrac{\sum_{i=1}^{n} \frac{N_i}{i^2}}
+                         {\sum_{i=1}^{n}\frac{1}{i^2}}
+        """
+        if self.method == "min":
+            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":
+            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
 class HammerType(enum.StrEnum):
@@ -510,6 +526,13 @@ class OPCType(enum.StrEnum):
     SKEMPTON = enum.auto()
 
 
+_opctypes = {OPCType.GIBBS: GibbsHoltzOPC,
+             OPCType.BAZARAA: BazaraaPeckOPC,
+             OPCType.PECK: PeckOPC,
+             OPCType.LIAO: LiaoWhitmanOPC,
+             OPCType.SKEMPTON: SkemptonOPC}
+
+
 def create_overburden_pressure_correction(std_spt_n_value: float, eop,
                                           opc_type: OPCType | str = OPCType.GIBBS) -> OPC:
     """A factory function that encapsulates the creation of overburden
@@ -529,18 +552,12 @@ def create_overburden_pressure_correction(std_spt_n_value: float, eop,
     try:
         opc_type = OPCType(str(opc_type).casefold())
     except ValueError as e:
-        msg = ErrorMsg(param_name="opc_type",
-                       param_value=opc_type,
-                       param_type=OPCType)
+        msg = EnumErrorMsg(param_name="opc_type",
+                           param_value=opc_type,
+                           param_type=OPCType)
         raise ValueError(msg) from e
 
-    opc_types = {OPCType.GIBBS: GibbsHoltzOPC,
-                 OPCType.BAZARAA: BazaraaPeckOPC,
-                 OPCType.PECK: PeckOPC,
-                 OPCType.LIAO: LiaoWhitmanOPC,
-                 OPCType.SKEMPTON: SkemptonOPC}
-
-    opc_class = opc_types[opc_type]
+    opc_class = _opctypes[opc_type]
     opc_corr = opc_class(std_spt_n_value=std_spt_n_value, eop=eop)
 
     return opc_corr

geolysis/utils/__init__.py

@@ -88,25 +88,3 @@ def round_(ndigits: int | Callable[..., SupportsRound]) -> Callable:
         return wrapper
 
     return dec
-
-
-class _ErrorParams(TypedDict):
-    param_name: NotRequired[str]
-    param_value: NotRequired[Any]
-    param_type: NotRequired[Any]
-
-
-class ErrorMsg(str):
-
-    @staticmethod
-    def __new__(cls, *args, msg: Optional[str] = None,
-                **kw: Unpack[_ErrorParams]):
-        if msg:
-            return super().__new__(cls, msg)
-
-        # Assume kwargs contains values for param_name, param_value,
-        # param_type, if not, KeyError exception is raised
-
-        msg = (f"Invalid value for {kw['param_name']}: {kw['param_value']}, "
-               f"Supported types are: {list(kw['param_type'])}")
-        return super().__new__(cls, msg)

geolysis/utils/exceptions.py

@@ -0,0 +1,36 @@
+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/utils/validators.py

@@ -1,6 +1,9 @@
 """validators"""
 import operator
-from typing import Callable, TypeAlias
+from typing import Callable, TypeAlias, Optional
+from functools import wraps
+
+from .exceptions import ValidationError
 
 Number: TypeAlias = int | float
 
@@ -8,8 +11,10 @@ Number: TypeAlias = int | float
 def _num_validator(bound: float, /, *,
                    compare_symbol: str,
                    compare_fn: Callable,
-                   exc_type: Callable, err_msg: str):
+                   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}"
@@ -24,8 +29,10 @@ def _num_validator(bound: float, /, *,
 def _len_validator(bound: float, /, *,
                    compare_symbol: str,
                    compare_fn: Callable,
-                   exc_type: Callable, err_msg: str):
+                   exc_type: Callable,
+                   err_msg: str):
     def dec(fn):
+        @wraps(fn)
         def wrapper(obj, val):
             _len = len(val)
             if not compare_fn(_len, bound):
@@ -38,43 +45,57 @@ def _len_validator(bound: float, /, *,
     return dec
 
 
-def min_len(m_len: int, /, *, exc_type=ValueError, err_msg=None):
+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=ValueError, err_msg=None):
+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)
+                          exc_type=exc_type,
+                          err_msg=err_msg)
 
 
-def le(val: Number, /, *, exc_type=ValueError, err_msg=None):
+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)
+                          exc_type=exc_type,
+                          err_msg=err_msg)
 
 
-def eq(val: Number, /, *, exc_type=ValueError, err_msg=None):
+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)
+                          exc_type=exc_type,
+                          err_msg=err_msg)
 
 
-def ne(val: Number, /, *, exc_type=ValueError, err_msg=None):
+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)
+                          exc_type=exc_type,
+                          err_msg=err_msg)
 
 
-def ge(val: Number, /, *, exc_type=ValueError, err_msg=None):
+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)
+                          exc_type=exc_type,
+                          err_msg=err_msg)
 
 
-def gt(val: Number, /, *, exc_type=ValueError, err_msg=None):
+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)
+                          exc_type=exc_type,
+                          err_msg=err_msg)

{geolysis-0.6.2.dist-info → geolysis-0.7.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: geolysis
-Version: 0.6.2
+Version: 0.7.1
 Summary: geolysis is an opensource software for geotechnical engineering analysis and modeling.
 Author-email: Patrick Boateng <boatengpato.pb@gmail.com>
 License: MIT License
@@ -97,6 +97,10 @@ Here are brief descriptions of these projects:
   </tr>
 </table>
 
+# Microsoft Excel Example
+
+![geolysis excel example](geolysis_excel_example.gif)
+
 ## Project Structure
 
     .

geolysis-0.7.1.dist-info/RECORD

@@ -0,0 +1,24 @@
+geolysis/__init__.py,sha256=doEthTEMHHK5V-a9L90VQf2YQ_nWHKbtT0fuyV19j38,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.1.dist-info/licenses/LICENSE.txt,sha256=ap6sMs3lT7ICbEXBhgihwH1BTCVcjmCQkIkwVnil1Ak,1065
+geolysis-0.7.1.dist-info/METADATA,sha256=Ul3uVbiX7sIty2eYbxzNuQV0yVH46HLIQwhQARR91JQ,7450
+geolysis-0.7.1.dist-info/WHEEL,sha256=pxyMxgL8-pra_rKaQ4drOZAegBVuX-G_4nRHjjgWbmo,91
+geolysis-0.7.1.dist-info/top_level.txt,sha256=9mnQgOaCRr11dtXff8X-q3FfXjRONd6kHseSy5q2y8g,9
+geolysis-0.7.1.dist-info/RECORD,,

{geolysis-0.6.2.dist-info → geolysis-0.7.1.dist-info}/WHEEL

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

geolysis-0.6.2.dist-info/RECORD

@@ -1,23 +0,0 @@
-geolysis/__init__.py,sha256=alTIUitHv3ycqyUd5oyvqfDXUO18StbWiT2LXd6lF6Q,122
-geolysis/foundation.py,sha256=bZ0LnONv1xvouhEesbAs9oGTg2YP4d_JEXDPx9Um19c,11528
-geolysis/soil_classifier.py,sha256=dH1JdmnJpnqxwFRhI19hPkCdCUQaGqEyIyycWOcKVMk,26786
-geolysis/spt.py,sha256=-9yJwzu2qEMbXogoozvDpwlWA0u6D1aNajgCzcY6ZrA,16901
-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=VwCd0zm5adeUP3T5lJr6ANzXNp2vaFttT1wtlG5ebpo,5345
-geolysis/bearing_capacity/abc/cohl/_core.py,sha256=ddyVTCTIqolllOwcX7s-czYO2bPAmKTlkvFAj3LNRqc,1744
-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=7Ud0JbaIBiI0xmw-aRhG9lR6ZT0DMCel7lPtwKCBJNs,5943
-geolysis/bearing_capacity/ubc/_core.py,sha256=CmhJyGi_GTy4DupX7m-PXlEdVmxZOgc2BVF9owByxOg,6160
-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=AY0FHUCElIqveYsB2uGl6OEpaesWVoRIDY0nHejB-0A,2989
-geolysis/utils/validators.py,sha256=nMZi044cbAcsgiH4yxKDELhIFuUMy7Rn8kgGzXWjEcA,2674
-geolysis-0.6.2.dist-info/licenses/LICENSE.txt,sha256=ap6sMs3lT7ICbEXBhgihwH1BTCVcjmCQkIkwVnil1Ak,1065
-geolysis-0.6.2.dist-info/METADATA,sha256=vcECcPdALMlUhaUVhwVJ_C4aMq6X7cm9NrkYeBr0IJo,7368
-geolysis-0.6.2.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-geolysis-0.6.2.dist-info/top_level.txt,sha256=9mnQgOaCRr11dtXff8X-q3FfXjRONd6kHseSy5q2y8g,9
-geolysis-0.6.2.dist-info/RECORD,,