geolysis 0.4.5__py3-none-any.whl → 0.6.0__py3-none-any.whl

geolysis/__init__.py

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

geolysis/bearing_capacity/abc/cohl/__init__.py

@@ -1,28 +1,12 @@
-""" Allowable bearing capacity package for cohesionless soils.
-
-Enums
-=====
-
-.. autosummary::
-    :toctree: _autosummary
-    :nosignatures:
-
-    ABCType
-
-Functions
-=========
-
-.. autosummary::
-    :toctree: _autosummary
-
-    create_allowable_bearing_capacity
+"""This package provides a factory function and utilities for creating 
+allowable bearing capacity calculations using methods like Bowles, Meyerhof, 
+and Terzaghi for various foundation types and shapes.
 """
-
 import enum
 from typing import Optional
 
 from geolysis.foundation import FoundationType, Shape, create_foundation
-from geolysis.utils import enum_repr, inf
+from geolysis.utils import enum_repr, inf, ErrorMsg
 
 from ._core import AllowableBearingCapacity
 from .bowles_abc import BowlesABC4MatFoundation, BowlesABC4PadFoundation
@@ -79,14 +63,14 @@ def create_allowable_bearing_capacity(corrected_spt_n_value: float,
     :type ground_water_level: float, optional
 
     :param shape: Shape of foundation footing, defaults to
-                  :attr:`~geolysis.foundation.Shape.SQUARE`.
+                  :py:enum:mem:`~geolysis.foundation.Shape.SQUARE`.
     :type shape: str, optional
 
     :param foundation_type: Type of foundation, defaults to "pad".
     :type foundation_type: FoundationType | str, optional
 
     :param abc_type: Type of allowable bearing capacity calculation to apply.
-                     Available values can be found in :class:`ABCType`,
+                     Available values can be found in :py:enum:`ABCType`,
                      defaults to None.
     :type abc_type:  ABCType | str, optional
 
@@ -96,8 +80,10 @@ def create_allowable_bearing_capacity(corrected_spt_n_value: float,
                         footing.
     :raises ValueError: Raised if an invalid footing ``shape`` is provided.
     """
-    msg = (f"{abc_type=} is not supported, Supported "
-           f"types are: {list(ABCType)}")
+
+    msg = ErrorMsg(param_name="abc_type",
+                   param_value=abc_type,
+                   param_type=ABCType)
 
     if abc_type is None:
         raise ValueError(msg)
@@ -107,12 +93,12 @@ def create_allowable_bearing_capacity(corrected_spt_n_value: float,
     except ValueError as e:
         raise ValueError(msg) from e
 
-    msg = (f"{foundation_type=} is not supported, Supported "
-           f"types are: {list(FoundationType)}")
-
     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)
         raise ValueError(msg) from e
 
     # exception from create_foundation will automaatically propagate

geolysis/bearing_capacity/abc/cohl/_core.py

@@ -33,7 +33,7 @@ class AllowableBearingCapacity(ABC):
 
     @property
     def tol_settlement(self) -> float:
-        """Tolerable settlement foundation (mm)."""
+        """Tolerable settlement of foundation (mm)."""
         return self._tol_settlement
 
     @tol_settlement.setter

geolysis/bearing_capacity/abc/cohl/bowles_abc.py

@@ -1,14 +1,3 @@
-""" Bowles allowable bearing capacity.
-
-Classes
-=======
-
-.. autosummary::
-    :toctree: _autosummary
-
-    BowlesABC4PadFoundation
-    BowlesABC4MatFoundation
-"""
 from geolysis.foundation import FoundationSize
 from geolysis.utils import round_
 
@@ -63,7 +52,7 @@ class BowlesABC4PadFoundation(AllowableBearingCapacity):
                          tol_settlement=tol_settlement,
                          foundation_size=foundation_size)
 
-    @round_
+    @round_(ndigits=2)
     def bearing_capacity(self) -> float:
         """Calculate the allowable bearing capacity of the pad foundation."""
         n_corr = self.corrected_spt_n_value
@@ -100,7 +89,7 @@ class BowlesABC4MatFoundation(BowlesABC4PadFoundation):
     ===================  ======================================  ===========
     """
 
-    @round_
+    @round_(ndigits=2)
     def bearing_capacity(self) -> float:
         """Calculate the allowable bearing capacity of the mat foundation."""
         n_corr = self.corrected_spt_n_value

geolysis/bearing_capacity/abc/cohl/meyerhof_abc.py

@@ -1,14 +1,3 @@
-""" Meyerhof allowable bearing capacity.
-
-Classes
-=======
-
-.. autosummary::
-    :toctree: _autosummary
-
-    MeyerhofABC4PadFoundation
-    MeyerhofABC4MatFoundation
-"""
 from geolysis.foundation import FoundationSize
 from geolysis.utils import round_
 
@@ -63,7 +52,7 @@ class MeyerhofABC4PadFoundation(AllowableBearingCapacity):
                          tol_settlement=tol_settlement,
                          foundation_size=foundation_size)
 
-    @round_
+    @round_(ndigits=2)
     def bearing_capacity(self):
         """Calculates the allowable bearing capacity of the pad foundation."""
         n_corr = self.corrected_spt_n_value
@@ -100,7 +89,7 @@ class MeyerhofABC4MatFoundation(MeyerhofABC4PadFoundation):
     ===================  ======================================  ===========
     """
 
-    @round_
+    @round_(ndigits=2)
     def bearing_capacity(self):
         """Calculate the allowable bearing capacity of the mat foundation."""
         n_corr = self.corrected_spt_n_value

geolysis/bearing_capacity/abc/cohl/terzaghi_abc.py

@@ -1,14 +1,3 @@
-"""Terzaghi allowable bearing capacity.
-
-Classes
-=======
-
-.. autosummary::
-    :toctree: _autosummary
-
-    TerzaghiABC4PadFoundation
-    TerzaghiABC4MatFoundation
-"""
 from geolysis.foundation import FoundationSize
 from geolysis.utils import round_
 
@@ -92,7 +81,7 @@ class TerzaghiABC4PadFoundation(AllowableBearingCapacity):
 
         return min(cw, 2.0)
 
-    @round_
+    @round_(ndigits=2)
     def bearing_capacity(self):
         """Calculates the allowable bearing capacity of the pad foundation."""
         n_corr = self.corrected_spt_n_value
@@ -135,7 +124,7 @@ class TerzaghiABC4MatFoundation(TerzaghiABC4PadFoundation):
     ===================  ======================================  ===========
     """
 
-    @round_
+    @round_(ndigits=2)
     def bearing_capacity(self):
         """Calculates the allowable bearing capacity of the mat foundation."""
         n_corr = self.corrected_spt_n_value

geolysis/bearing_capacity/ubc/__init__.py

@@ -1,33 +1,20 @@
-""" Ultimate bearing capacity estimation package
-
-Enum
-====
-
-.. autosummary::
-    :toctree: _autosummary
-    :nosignatures:
-
-    UBCType
-
-Functions
-=========
-
-.. autosummary::
-    :toctree: _autosummary
-
-    create_ultimate_bearing_capacity
+""" 
+This package provides a factory function and utilities for creating ultimate 
+bearing capacity calculations using methods like Hansen, Terzaghi, and Vesic 
+for various foundation shapes.
 """
 import enum
 from typing import Optional
 
 from geolysis.foundation import Shape, create_foundation
-from geolysis.utils import enum_repr
+from geolysis.utils import enum_repr, ErrorMsg
 
 from ._core import UltimateBearingCapacity
 from .hansen_ubc import HansenUltimateBearingCapacity
 from .terzaghi_ubc import (TerzaghiUBC4CircularFooting,
                            TerzaghiUBC4RectangularFooting,
-                           TerzaghiUBC4SquareFooting, TerzaghiUBC4StripFooting)
+                           TerzaghiUBC4SquareFooting,
+                           TerzaghiUBC4StripFooting)
 from .vesic_ubc import VesicUltimateBearingCapacity
 
 __all__ = ["UBCType",
@@ -118,8 +105,10 @@ def create_ultimate_bearing_capacity(friction_angle: float,
                         footing.
     :raises ValueError: Raised if an invalid footing shape is provided.
     """
-    msg = (f"{ubc_type=} is not supported, Supported "
-           f"types are: {list(UBCType)}")
+
+    msg = ErrorMsg(param_name="ubc_type",
+                   param_value=ubc_type,
+                   param_type=UBCType)
 
     if ubc_type is None:
         raise ValueError(msg)

geolysis/bearing_capacity/ubc/_core.py

@@ -43,11 +43,20 @@ class UltimateBearingCapacity(ABC):
 
     @property
     def friction_angle(self) -> float:
-        """Return friction angle for local shear in the case of local shear
+        r"""Return friction angle for local shear in the case of local shear
         failure or general shear in the case of general shear failure.
+
+        :Equation:
+
+        In the case of local shear failure:
+
+        .. math::
+
+           \phi' = \tan^{-1} \left(\frac{2}{3} \tan \phi\right)
+
         """
         if self.apply_local_shear:
-            return arctan((2 / 3) * tan(self._friction_angle))
+            return arctan((2.0 / 3.0) * tan(self._friction_angle))
         return self._friction_angle
 
     @friction_angle.setter
@@ -57,8 +66,16 @@ class UltimateBearingCapacity(ABC):
 
     @property
     def cohesion(self) -> float:
-        """Return cohesion for local shear in the case of local shear failure
+        r"""Return cohesion for local shear in the case of local shear failure
         or general shear in the case of general shear failure.
+
+        :Equation:
+
+        In the case of local shear failure:
+
+        .. math::
+
+            C^{'} = \dfrac{2}{3} \cdot C
         """
         if self.apply_local_shear:
             return (2.0 / 3.0) * self._cohesion
@@ -169,8 +186,8 @@ class UltimateBearingCapacity(ABC):
         return (coef * self.moist_unit_wgt * width * self.n_gamma
                 * self.s_gamma * self.d_gamma * self.i_gamma * water_corr)
 
-    @round_
-    def bearing_capacity(self):
+    @round_(ndigits=2)
+    def bearing_capacity(self) -> float:
         """Calculates the ultimate bearing capacity."""
         return (self._cohesion_term(1.0)
                 + self._surcharge_term()

geolysis/bearing_capacity/ubc/hansen_ubc.py

@@ -1,13 +1,3 @@
-""" Hansen ultimate bearing capacity module.
-
-Classes
-=======
-
-.. autosummary::
-    :toctree: _autosummary
-
-    HansenUltimateBearingCapacity
-"""
 from geolysis.foundation import Shape
 from geolysis.utils import cos, cot, exp, isclose, pi, round_, sin, tan
 
@@ -16,25 +6,25 @@ from ._core import UltimateBearingCapacity
 __all__ = ["HansenUltimateBearingCapacity"]
 
 
-@round_
+@round_(ndigits=2)
 def n_c(friction_angle: float) -> float:
     if isclose(friction_angle, 0.0):
         return 5.14
     return cot(friction_angle) * (n_q(friction_angle) - 1.0)
 
 
-@round_
+@round_(ndigits=2)
 def n_q(friction_angle: float) -> float:
     return (tan(45.0 + friction_angle / 2.0) ** 2.0
             * exp(pi * tan(friction_angle)))
 
 
-@round_
+@round_(ndigits=2)
 def n_gamma(friction_angle: float) -> float:
     return 1.8 * (n_q(friction_angle) - 1.0) * tan(friction_angle)
 
 
-@round_
+@round_(ndigits=2)
 def s_c(f_width: float, f_length: float, f_shape: Shape) -> float:
     if f_shape == Shape.STRIP:
         return 1.0
@@ -44,7 +34,7 @@ def s_c(f_width: float, f_length: float, f_shape: Shape) -> float:
         return 1.3
 
 
-@round_
+@round_(ndigits=2)
 def s_q(f_width: float, f_length: float, f_shape: Shape) -> float:
     if f_shape == Shape.STRIP:
         return 1.0
@@ -54,7 +44,7 @@ def s_q(f_width: float, f_length: float, f_shape: Shape) -> float:
         return 1.2
 
 
-@round_
+@round_(ndigits=2)
 def s_gamma(f_width: float, f_length: float, f_shape: Shape) -> float:
     if f_shape == Shape.STRIP:
         return 1.0
@@ -66,22 +56,22 @@ def s_gamma(f_width: float, f_length: float, f_shape: Shape) -> float:
         return 0.6
 
 
-@round_
+@round_(ndigits=2)
 def d_c(f_depth: float, f_width: float) -> float:
     return 1.0 + 0.35 * f_depth / f_width
 
 
-@round_
+@round_(ndigits=2)
 def d_q(f_depth: float, f_width: float) -> float:
     return d_c(f_depth, f_width)
 
 
-@round_
+@round_(ndigits=2)
 def d_gamma() -> float:
     return 1.0
 
 
-@round_
+@round_(ndigits=2)
 def i_c(cohesion: float,
         load_angle: float,
         f_width: float,
@@ -89,12 +79,12 @@ def i_c(cohesion: float,
     return 1.0 - sin(load_angle) / (2.0 * cohesion * f_width * f_length)
 
 
-@round_
+@round_(ndigits=2)
 def i_q(load_angle: float) -> float:
     return 1.0 - (1.5 * sin(load_angle)) / cos(load_angle)
 
 
-@round_
+@round_(ndigits=2)
 def i_gamma(load_angle: float) -> float:
     return i_q(load_angle) ** 2.0
 

geolysis/bearing_capacity/ubc/terzaghi_ubc.py

@@ -1,16 +1,3 @@
-""" Terzaghi ultimate bearing capacity module.
-
-Classes
-=======
-
-.. autosummary::
-    :toctree: _autosummary
-
-    TerzaghiUBC4StripFooting
-    TerzaghiUBC4CircularFooting
-    TerzaghiUBC4SquareFooting
-    TerzaghiUBC4RectangularFooting
-"""
 from abc import ABC
 
 from geolysis.utils import cos, cot, deg2rad, exp, isclose, pi, round_, tan
@@ -23,21 +10,21 @@ __all__ = ["TerzaghiUBC4StripFooting",
            "TerzaghiUBC4RectangularFooting"]
 
 
-@round_
+@round_(ndigits=2)
 def n_c(friction_angle: float) -> float:
     if isclose(friction_angle, 0.0):
         return 5.7
     return cot(friction_angle) * (n_q(friction_angle) - 1.0)
 
 
-@round_
+@round_(ndigits=2)
 def n_q(friction_angle: float) -> float:
     return (exp((3.0 * pi / 2.0 - deg2rad(friction_angle))
                 * tan(friction_angle))
             / (2.0 * (cos(45.0 + friction_angle / 2.0)) ** 2.0))
 
 
-@round_
+@round_(ndigits=2)
 def n_gamma(friction_angle: float) -> float:
     return (n_q(friction_angle) - 1.0) * tan(1.4 * friction_angle)
 
@@ -113,7 +100,7 @@ class TerzaghiUBC4StripFooting(TerzaghiUltimateBearingCapacity):
          - —
     """
 
-    @round_
+    @round_(ndigits=2)
     def bearing_capacity(self) -> float:
         """Calculates ultimate bearing capacity for strip footing."""
         return (self._cohesion_term(1.0)
@@ -156,7 +143,7 @@ class TerzaghiUBC4CircularFooting(TerzaghiUltimateBearingCapacity):
          - —
     """
 
-    @round_
+    @round_(ndigits=2)
     def bearing_capacity(self) -> float:
         """Calculates ultimate bearing capacity for circular footing."""
         return (self._cohesion_term(1.3)
@@ -205,7 +192,7 @@ class TerzaghiUBC4RectangularFooting(TerzaghiUltimateBearingCapacity):
          - —
     """
 
-    @round_
+    @round_(ndigits=2)
     def bearing_capacity(self) -> float:
         """Calculates ultimate bearing capacity for rectangular footing."""
         width = self.foundation_size.width

geolysis/bearing_capacity/ubc/vesic_ubc.py

@@ -1,13 +1,3 @@
-"""Vesic ultimate bearing capacity module.
-
-Classes
-=======
-
-.. autosummary::
-    :toctree: _autosummary
-
-    VesicUltimateBearingCapacity
-"""
 from geolysis.foundation import Shape
 from geolysis.utils import isclose, round_, sin, tan
 
@@ -17,22 +7,22 @@ from ._core import UltimateBearingCapacity
 __all__ = ["VesicUltimateBearingCapacity"]
 
 
-@round_
+@round_(ndigits=2)
 def n_c(friction_angle: float) -> float:
     return hansen_ubc.n_c(friction_angle)
 
 
-@round_
+@round_(ndigits=2)
 def n_q(friction_angle: float) -> float:
     return hansen_ubc.n_q(friction_angle)
 
 
-@round_
+@round_(ndigits=2)
 def n_gamma(friction_angle: float) -> float:
     return 2.0 * (n_q(friction_angle) + 1.0) * tan(friction_angle)
 
 
-@round_
+@round_(ndigits=2)
 def s_c(friction_angle: float,
         f_width: float,
         f_length: float,
@@ -48,7 +38,7 @@ def s_c(friction_angle: float,
         return 1.0 + (_n_q / _n_c)
 
 
-@round_
+@round_(ndigits=2)
 def s_q(friction_angle: float,
         f_width: float,
         f_length: float,
@@ -61,7 +51,7 @@ def s_q(friction_angle: float,
         return 1.0 + tan(friction_angle)
 
 
-@round_
+@round_(ndigits=2)
 def s_gamma(f_width: float, f_length: float, f_shape: Shape) -> float:
     if f_shape == Shape.STRIP:
         return 1.0
@@ -71,34 +61,34 @@ def s_gamma(f_width: float, f_length: float, f_shape: Shape) -> float:
         return 0.6
 
 
-@round_
+@round_(ndigits=2)
 def d_c(f_depth: float, f_width: float) -> float:
     return 1.0 + 0.4 * f_depth / f_width
 
 
-@round_
+@round_(ndigits=2)
 def d_q(friction_angle: float, f_depth: float, f_width: float) -> float:
     return (1.0 + 2.0 * tan(friction_angle)
             * (1.0 - sin(friction_angle)) ** 2.0
             * (f_depth / f_width))
 
 
-@round_
+@round_(ndigits=2)
 def d_gamma() -> float:
     return 1.0
 
 
-@round_
+@round_(ndigits=2)
 def i_c(load_angle: float) -> float:
     return (1.0 - load_angle / 90.0) ** 2.0
 
 
-@round_
+@round_(ndigits=2)
 def i_q(load_angle: float) -> float:
     return i_c(load_angle)
 
 
-@round_
+@round_(ndigits=2)
 def i_gamma(friction_angle: float, load_angle: float) -> float:
     if isclose(friction_angle, 0.0):
         return 1.0

geolysis/foundation.py

@@ -1,41 +1,10 @@
-""" Basic foundation module.
-
-Enums
-=====
-
-.. autosummary::
-    :toctree: _autosummary
-    :nosignatures:
-
-    Shape
-    FoundationType
-
-Classes
-=======
-
-.. autosummary::
-    :toctree: _autosummary
-
-    StripFooting
-    CircularFooting
-    SquareFooting
-    RectangularFooting
-    FoundationSize
-
-Functions
-=========
-
-.. autosummary::
-    :toctree: _autosummary
-
-    create_foundation
-"""
-
+"""This module provides classes and utilities for modeling various foundation
+footing types, their dimensions, and properties."""
 import enum
 from abc import ABC, abstractmethod
 from typing import Optional, TypeVar
 
-from .utils import enum_repr, inf, isclose, validators
+from .utils import enum_repr, inf, isclose, validators, ErrorMsg
 
 __all__ = ["create_foundation",
            "FoundationSize",
@@ -260,18 +229,18 @@ class FoundationSize:
         :type footing_size: FootingSize
 
         :param eccentricity: The deviation of the foundation load from the
-                             center of gravity of the foundation footing,
+                             center of gravity of the foundation footing (m),
                              defaults to 0.0. This means that the foundation 
                              load aligns with the center of gravity of the 
-                             foundation footing (m).
+                             foundation footing.
         :type eccentricity: float, optional
 
         :param ground_water_level: Depth of the water below ground level (m),
-                                   defaults to inf.
+                                   defaults to None.
         :type ground_water_level: float, optional
 
         :param foundation_type: Type of foundation, defaults to
-                                :attr:`FoundationType.PAD`
+                                :py:enum:mem:`~FoundationType.PAD`
         :type foundation_type: FoundationType, optional
         """
         self.depth = depth
@@ -317,7 +286,7 @@ class FoundationSize:
     @property
     def eccentricity(self) -> float:
         """The deviation of the foundation load from the center of gravity of
-        the foundation footing.
+        the foundation footing (m).
         """
         return self._eccentricity
 
@@ -343,7 +312,7 @@ class FoundationSize:
 
     @property
     def effective_width(self) -> float:
-        """Returns the effective width of the foundation footing."""
+        """Returns the effective width of the foundation footing (m)."""
         return self.width - 2.0 * self.eccentricity
 
     def footing_params(self) -> tuple[float, float, Shape]:
@@ -389,24 +358,22 @@ def create_foundation(depth: float,
     :type ground_water_level: float, optional
 
     :param foundation_type: Type of foundation footing, defaults to
-                            FoundationType.PAD.
+                            :py:enum:mem:`~FoundationType.PAD`.
     :type foundation_type: FoundationType, optional
 
-    :param shape: Shape of foundation footing, defaults to :class:`Shape.SQUARE`
+    :param shape: Shape of foundation footing, defaults to 
+                  :py:enum:mem:`~Shape.SQUARE`
     :type shape: Shape | str, optional
 
     :raises ValueError: Raised when length is not provided for a rectangular
                         footing.
     :raises ValueError: Raised if an invalid footing shape is provided.
     """
-    shape = str(shape).casefold()
 
     try:
-        shape = Shape(shape)
+        shape = Shape(str(shape).casefold())
     except ValueError as e:
-        msg = (f"{shape=} is not supported, Supported "
-               f"types are: {list(Shape)}")
-
+        msg = ErrorMsg(param_name="shape", param_value=shape, param_type=Shape)
         raise ValueError(msg) from e
 
     if shape is Shape.STRIP:
@@ -417,7 +384,8 @@ def create_foundation(depth: float,
         footing_size = CircularFooting(diameter=width)
     else:  # RECTANGLE
         if not length:
-            raise ValueError("Length of footing must be provided.")
+            msg = ErrorMsg(msg="Length of footing must be provided.")
+            raise ValueError(msg)
         footing_size = RectangularFooting(width=width, length=length)
 
     return FoundationSize(depth=depth,

geolysis/soil_classifier.py

@@ -1,48 +1,10 @@
-""" Soil classification module.
-
-Exceptions
-==========
-
-.. autosummary::
-    :toctree: _autosummary
-
-    SizeDistError
-
-Enums
-=====
-
-.. autosummary::
-    :toctree: _autosummary
-    :nosignatures:
-
-    ClfType
-    USCSSymbol
-    AASHTOSymbol
-
-Classes
-=======
-
-.. autosummary::
-    :toctree: _autosummary
-
-    AtterbergLimits
-    PSD
-    AASHTO
-    USCS
-
-Functions
-=========
-
-.. autosummary::
-    :toctree: _autosummary
-
-    create_soil_classifier
+"""This module provides classes for soil classification using systems like 
+USCS and AASHTO, based on particle size distribution and  Atterberg limits.
 """
 import enum
-from abc import abstractmethod
-from typing import NamedTuple, Optional, Protocol, Sequence
+from typing import NamedTuple, Optional, Sequence
 
-from .utils import enum_repr, isclose, round_, validators
+from .utils import enum_repr, isclose, round_, validators, ErrorMsg
 
 __all__ = ["ClfType",
            "AtterbergLimits",
@@ -181,7 +143,7 @@ class AtterbergLimits:
         self._plastic_limit = val
 
     @property
-    @round_
+    @round_(2)
     def plasticity_index(self) -> float:
         """Plasticity index (PI) is the range of water content over which the
         soil remains in the plastic state.
@@ -210,7 +172,7 @@ class AtterbergLimits:
         """
         return 4 <= self.plasticity_index <= 7 and 10 < self.liquid_limit < 30
 
-    @round_
+    @round_(ndigits=2)
     def liquidity_index(self, nmc: float) -> float:
         r"""Return the liquidity index of the soil.
 
@@ -228,7 +190,7 @@ class AtterbergLimits:
         """
         return ((nmc - self.plastic_limit) / self.plasticity_index) * 100.0
 
-    @round_
+    @round_(2)
     def consistency_index(self, nmc: float) -> float:
         r"""Return the consistency index of the soil.
 
@@ -279,7 +241,8 @@ class _SizeDistribution:
         graded.
 
         :param coarse_soil: Coarse fraction of the soil sample. Valid arguments 
-                            are ``USCSSymbol.GRAVEL`` and ``USCSSymbol.SAND``.
+                            are :py:enum:mem:`~USCSSymbol.GRAVEL` and
+                            :py:enum:mem:`~USCSSymbol.SAND`.
         """
         if coarse_soil is USCSSymbol.GRAVEL:
             if 1 < self.coeff_of_curvature < 3 and self.coeff_of_uniformity >= 4:
@@ -336,7 +299,7 @@ class PSD:
         return USCSSymbol.SAND
 
     @property
-    @round_
+    @round_(ndigits=2)
     def coeff_of_curvature(self) -> float:
         r"""Coefficient of curvature of soil sample.
 
@@ -350,7 +313,7 @@ class PSD:
         return self.size_dist.coeff_of_curvature
 
     @property
-    @round_
+    @round_(ndigits=2)
     def coeff_of_uniformity(self) -> float:
         r"""Coefficient of uniformity of soil sample.
 
@@ -683,11 +646,6 @@ class USCS:
                 f"{coarse_material_type}{fine_material_type}")
 
 
-class SoilClassifier(Protocol):
-    @abstractmethod
-    def classify(self) -> SoilClf: ...
-
-
 @enum_repr
 class ClfType(enum.StrEnum):
     """Enumeration of soil classification types."""
@@ -703,7 +661,7 @@ def create_soil_classifier(liquid_limit: float,
                            add_group_idx: bool = True,
                            organic: bool = False,
                            clf_type: Optional[ClfType | str] = None
-                           ) -> SoilClassifier:
+                           ) -> AASHTO | USCS:
     """ A factory function that encapsulates the creation of a soil classifier.
 
     :param liquid_limit: Water content beyond which soils flows under their own
@@ -752,8 +710,9 @@ def create_soil_classifier(liquid_limit: float,
     :raises ValueError: Raises ValueError if ``sand`` is not provided for
                         :class:`USCS` classification.
     """
-    msg = (f"{clf_type=} is not supported, Supported "
-           f"types are: {list(ClfType)}")
+    msg = ErrorMsg(param_name="clf_type",
+                   param_value=clf_type,
+                   param_type=ClfType)
 
     if clf_type is None:
         raise ValueError(msg)
@@ -774,7 +733,8 @@ def create_soil_classifier(liquid_limit: float,
 
     # USCS classification
     if sand is None:
-        raise ValueError("sand must be specified for USCS classification")
+        msg = ErrorMsg(msg=f"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)
     clf = USCS(atterberg_limits=atterberg_lmts, psd=psd, organic=organic)

geolysis/spt.py

@@ -1,44 +1,13 @@
-""" Standard penetration test module.
-
-Enums
-=====
-
-.. autosummary::
-    :toctree: _autosummary
-    :nosignatures:
-
-    HammerType
-    SamplerType
-    OPCType
-
-Classes
-=======
-
-.. autosummary::
-    :toctree: _autosummary
-
-    SPTNDesign
-    EnergyCorrection
-    GibbsHoltzOPC
-    BazaraaPeckOPC
-    PeckOPC
-    LiaoWhitmanOPC
-    SkemptonOPC
-    DilatancyCorrection
-
-Functions
-=========
-
-.. autosummary::
-    :toctree: _autosummary
-
-    create_spt_correction
+"""This module provides classes for performing Standard Penetration Test (SPT) 
+corrections, including energy, overburden pressure, and dilatancy corrections, 
+as well as calculating design N-values.
 """
 import enum
 from abc import abstractmethod
 from typing import Final, Sequence
 
-from .utils import enum_repr, isclose, log10, mean, round_, sqrt, validators
+from .utils import enum_repr, isclose, log10, mean, round_, sqrt, validators, \
+    ErrorMsg
 
 __all__ = ["SPTNDesign",
            "HammerType",
@@ -49,11 +18,13 @@ __all__ = ["SPTNDesign",
            "PeckOPC",
            "LiaoWhitmanOPC",
            "SkemptonOPC",
-           "DilatancyCorrection"]
+           "DilatancyCorrection",
+           "OPCType",
+           "create_overburden_pressure_correction"]
 
 
 class SPTNDesign:
-    """ SPT Design Calculations.
+    """SPT Design Calculations.
 
     Due to uncertainty in field procedure in standard penetration test and also
     to consider all the N-value in the influence zone of a foundation, a method
@@ -147,14 +118,6 @@ class EnergyCorrection:
     in testing procedures may be at least partially compensated by converting
     the measured N-value to :math:`N_{60}` assuming 60% hammer energy being
     transferred to the tip of the standard split spoon.
-
-    :Equation:
-
-    .. math::
-
-        N_{ENERGY} = \dfrac{E_H \cdot C_B \cdot C_S \cdot C_R \cdot N}{ENERGY}
-
-    ``ENERGY``: 0.6, 0.55, etc
     """
 
     _HAMMER_EFFICIENCY_FACTORS = {HammerType.AUTOMATIC: 0.70,
@@ -187,13 +150,13 @@ class EnergyCorrection:
         :param rod_length: Length of SPT rod, defaults to 3.0. (m)
         :type rod_length: float, optional
 
-        :param hammer_type: Hammer type, defaults to :attr:`HammerType.DONUT_1`
+        :param hammer_type: Hammer type, defaults to :py:enum:mem:`~HammerType.DONUT_1`
         :type hammer_type: HammerType, optional
 
-        :param sampler_type: Sampler type, defaults to :attr:`SamplerType.STANDARD`
+        :param sampler_type: Sampler type, defaults to :py:enum:mem:`~SamplerType.STANDARD`
         :type sampler_type: SamplerType, optional
         """
-        self.recorded_spt_n_value = recorded_spt_n_value
+        self.recorded_spt_n_value = int(recorded_spt_n_value)
         self.energy_percentage = energy_percentage
         self.borehole_diameter = borehole_diameter
         self.rod_length = rod_length
@@ -278,7 +241,16 @@ class EnergyCorrection:
         return corr
 
     def correction(self) -> float:
-        """Energy correction factor."""
+        r"""Energy correction factor.
+
+        :Equation:
+
+        .. math::
+
+            N_{ENERGY} = \dfrac{E_H \cdot C_B \cdot C_S \cdot C_R \cdot N}{ENERGY}
+
+        ``ENERGY``: 0.6, 0.55, etc
+        """
         numerator = (self.hammer_efficiency
                      * self.borehole_diameter_correction
                      * self.sampler_correction
@@ -502,12 +474,12 @@ class DilatancyCorrection:
         """SPT N-value standardized for field procedures and/or corrected for
         overburden pressure.
         """
-        return self._std_spt_n_value
+        return self._corr_spt_n_value
 
     @corr_spt_n_value.setter
     @validators.gt(0.0)
     def corr_spt_n_value(self, val: float) -> None:
-        self._std_spt_n_value = val
+        self._corr_spt_n_value = val
 
     @round_(ndigits=1)
     def corrected_spt_n_value(self) -> float:
@@ -537,66 +509,30 @@ class OPCType(enum.StrEnum):
     SKEMPTON = enum.auto()
 
 
-def create_spt_correction(recorded_spt_n_value: int,
-                          eop: float,
-                          energy_percentage=0.6,
-                          borehole_diameter=65.0,
-                          rod_length=3.0,
-                          hammer_type=HammerType.DONUT_1,
-                          sampler_type=SamplerType.STANDARD,
-                          opc_type: OPCType | str = OPCType.GIBBS,
-                          apply_dilatancy_correction: bool = False
-                          ) -> OPC | DilatancyCorrection:
-    """A factory function that encapsulates the creation of spt correction.
+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
+    pressure correction.
 
-    :param recorded_spt_n_value: Recorded SPT N-value from field.
-    :type recorded_spt_n_value: int
+    :param std_spt_n_value: SPT N-value standardized for field procedures.
+    :type std_spt_n_value: float
 
     :param eop: Effective overburden pressure (:math:`kPa`).
     :type eop: float
 
-    :param energy_percentage: Energy percentage reaching the tip of the
-                              sampler, defaults to 0.6
-    :type energy_percentage: float, optional
-
-    :param borehole_diameter: Borehole diameter, defaults to 65.0 (mm).
-    :type borehole_diameter: float, optional
-
-    :param rod_length: Rod length, defaults to 3.0 (m).
-    :type rod_length: float, optional
-
-    :param hammer_type: Hammer type, defaults to :attr:`HammerType.DONUT_1`
-    :type hammer_type: HammerType, optional
-
-    :param sampler_type: Sampler type, defaults to :attr:`SamplerType.STANDARD`
-    :type sampler_type: SamplerType, optional
-
     :param opc_type: Overburden Pressure Correction type to apply,
-                    defaults to :attr:`OPCType.GIBBS`
+                    defaults to :py:enum:mem:`~OPCType.GIBBS`
     :type opc_type: OPCType, optional
-
-    :param apply_dilatancy_correction: Indicates whether to apply dilatancy
-                                       correction, defaults to False.
-    :type apply_dilatancy_correction: bool, optional
     """
 
     try:
         opc_type = OPCType(str(opc_type).casefold())
     except ValueError as e:
-        msg = (f"{opc_type=} is not supported, Supported "
-               f"types are: {list(OPCType)}")
+        msg = ErrorMsg(param_name="opc_type",
+                       param_value=opc_type,
+                       param_type=OPCType)
         raise ValueError(msg) from e
 
-    energy_correction = EnergyCorrection(
-        recorded_spt_n_value=recorded_spt_n_value,
-        energy_percentage=energy_percentage,
-        borehole_diameter=borehole_diameter,
-        rod_length=rod_length,
-        hammer_type=hammer_type,
-        sampler_type=sampler_type)
-
-    std_spt_n_value = energy_correction.standardized_spt_n_value()
-
     opc_types = {OPCType.GIBBS: GibbsHoltzOPC,
                  OPCType.BAZARAA: BazaraaPeckOPC,
                  OPCType.PECK: PeckOPC,
@@ -606,8 +542,4 @@ def create_spt_correction(recorded_spt_n_value: int,
     opc_class = opc_types[opc_type]
     opc_corr = opc_class(std_spt_n_value=std_spt_n_value, eop=eop)
 
-    if apply_dilatancy_correction:
-        corr_spt_n_value = opc_corr.corrected_spt_n_value()
-        return DilatancyCorrection(corr_spt_n_value=corr_spt_n_value)
-
     return opc_corr

geolysis/utils/__init__.py

@@ -2,11 +2,13 @@ import functools
 import math
 from math import exp, inf, isclose, log10, pi, sqrt
 from statistics import fmean as mean
-from typing import Callable, SupportsRound
+from typing import Callable, SupportsRound, Iterable, Any, Optional, \
+    NotRequired, TypedDict, Unpack
 
 from . import validators
 
-__all__ = ["enum_repr",
+__all__ = ["ErrorMsg",
+           "enum_repr",
            "inf",
            "pi",
            "deg2rad",
@@ -77,24 +79,34 @@ def round_(ndigits: int | Callable[..., SupportsRound]) -> Callable:
     TypeError is raised when ``ndigits`` is neither an int nor a callable.
     """
 
-    default_dp = 2
-
     def dec(fn) -> Callable[..., float]:
         @functools.wraps(fn)
         def wrapper(*args, **kwargs) -> float:
-            dp = ndigits if not callable(ndigits) else default_dp
             res = fn(*args, **kwargs)
-            return round(res, ndigits=dp)
+            return round(res, ndigits=ndigits)
 
         return wrapper
 
-    # See if we're being called as @round_ or @round_().
-    # We're called with parens.
-    if isinstance(ndigits, int):
-        return dec
+    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)
 
-    # We're called as @round_ without parens.
-    if callable(ndigits):
-        return dec(ndigits)
+        # Assume kwargs contains values for param_name, param_value,
+        # param_type, if not, KeyError exception is raised
 
-    raise TypeError("ndigits must be an int or a callable")
+        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/validators.py

@@ -8,8 +8,7 @@ Number: TypeAlias = int | float
 def _num_validator(bound: float, /, *,
                    compare_symbol: str,
                    compare_fn: Callable,
-                   err_msg: str,
-                   exc_type: Callable):
+                   exc_type: Callable, err_msg: str):
     def dec(fn):
         def wrapper(obj, val):
             if not compare_fn(val, bound):
@@ -25,15 +24,14 @@ def _num_validator(bound: float, /, *,
 def _len_validator(bound: float, /, *,
                    compare_symbol: str,
                    compare_fn: Callable,
-                   err_msg: str,
-                   exc_type: Callable):
+                   exc_type: Callable, err_msg: str):
     def dec(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)
-            return fn(obj, val)
+            fn(obj, val)
 
         return wrapper
 
@@ -43,38 +41,40 @@ def _len_validator(bound: float, /, *,
 def min_len(m_len: int, /, *, exc_type=ValueError, err_msg=None):
     return _len_validator(m_len, compare_symbol=">=",
                           compare_fn=operator.ge,
-                          err_msg=err_msg,
-                          exc_type=exc_type)
+                          exc_type=exc_type, err_msg=err_msg)
 
 
-# def lt(val: Number, /, *, exc_type=ValueError, err_msg=None):
-#     return _NumberValidator(val, "<", operator.lt, exc_type, err_msg)
+def lt(val: Number, /, *, exc_type=ValueError, err_msg=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=ValueError, err_msg=None):
     return _num_validator(val, compare_symbol="<=",
                           compare_fn=operator.le,
-                          err_msg=err_msg,
-                          exc_type=exc_type)
+                          exc_type=exc_type, err_msg=err_msg)
 
 
-# def eq(val: Number, /, *, exc_type=ValueError, err_msg=None):
-#     return _NumberValidator(val, "==", operator.eq, exc_type, err_msg)
+def eq(val: Number, /, *, exc_type=ValueError, err_msg=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=ValueError, err_msg=None):
-#     return _NumberValidator(val, "!=", operator.ne, exc_type, err_msg)
+def ne(val: Number, /, *, exc_type=ValueError, err_msg=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=ValueError, err_msg=None):
     return _num_validator(val, compare_symbol=">=",
                           compare_fn=operator.ge,
-                          err_msg=err_msg,
-                          exc_type=exc_type)
+                          exc_type=exc_type, err_msg=err_msg)
 
 
 def gt(val: Number, /, *, exc_type=ValueError, err_msg=None):
     return _num_validator(val, compare_symbol=">",
                           compare_fn=operator.gt,
-                          err_msg=err_msg,
-                          exc_type=exc_type)
+                          exc_type=exc_type, err_msg=err_msg)

{geolysis-0.4.5.dist-info → geolysis-0.6.0.dist-info}/METADATA

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

geolysis-0.6.0.dist-info/RECORD

@@ -0,0 +1,23 @@
+geolysis/__init__.py,sha256=N6jRDNL2L9U1UQjnCq3QP90Dd7HSn8dKdlS8mVtGWNs,122
+geolysis/foundation.py,sha256=wO_4TNetFOiW1ekFNyIQSYu-sIBuOfUWs6pazBwmmqU,11528
+geolysis/soil_classifier.py,sha256=kcBirodL4JiCRTGk1ODjfnu_3UkOOUiBI1Z-rrdFi3E,26786
+geolysis/spt.py,sha256=EncVQgocKcC4FVgDircbddVKhm_qX0AKZeE17DLuJBQ,16869
+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=OWpsgmVCZEkhN-TQDYNjtoCdBU8BMsIP7zLq2Cx79aI,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=5Dk-1vE37Gijr_fNO61-RX7AFjYKNUGOxxU59a0TIJg,5970
+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=kRUcJ7BqEtmWHDEvDImIidQqILtg8n8omsPCH-P_zas,2983
+geolysis/utils/validators.py,sha256=nMZi044cbAcsgiH4yxKDELhIFuUMy7Rn8kgGzXWjEcA,2674
+geolysis-0.6.0.dist-info/licenses/LICENSE.txt,sha256=ap6sMs3lT7ICbEXBhgihwH1BTCVcjmCQkIkwVnil1Ak,1065
+geolysis-0.6.0.dist-info/METADATA,sha256=gzxdbg5V_atQSIKnaWub5TBmptHZH6j0ggIo6zOgSzg,7368
+geolysis-0.6.0.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+geolysis-0.6.0.dist-info/top_level.txt,sha256=9mnQgOaCRr11dtXff8X-q3FfXjRONd6kHseSy5q2y8g,9
+geolysis-0.6.0.dist-info/RECORD,,

{geolysis-0.4.5.dist-info → geolysis-0.6.0.dist-info}/WHEEL

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

geolysis-0.4.5.dist-info/RECORD

@@ -1,23 +0,0 @@
-geolysis/__init__.py,sha256=2ZuIpW-WsfnnAV4bWZmR7F2TRFLqHgS5ZjhgU0qDY_c,122
-geolysis/foundation.py,sha256=_oOv-JLl8WTT81WXNaIDZzXiVTL8EwGjXi9-kmbuNSA,11722
-geolysis/soil_classifier.py,sha256=AaTgcFOqpqnYvoIzXlyPBjzYhSCtgsbRae_VzD_3C4Y,27056
-geolysis/spt.py,sha256=Fe5tlqvTquyfw8lFEnNQtZrRXrG1lWnflX-w-Cx5Epo,18659
-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=r-NG8fTPpNgqBriejIEkNNE3cX4X2rRqyCFYMK3RS3Y,5312
-geolysis/bearing_capacity/abc/cohl/_core.py,sha256=t8nAr8ITAILQmbK5Rzie9ZCn6ODW87XLsiwULvyOMns,1741
-geolysis/bearing_capacity/abc/cohl/bowles_abc.py,sha256=beYKA2yEEQ8mVKgEK6ZBlHuiWvDXE-jm5A6RhXXkPaI,4236
-geolysis/bearing_capacity/abc/cohl/meyerhof_abc.py,sha256=deoFp8Tdy-eCA4-hOY6lPpvCp71rcqD9v3qhsM-H9vA,4202
-geolysis/bearing_capacity/abc/cohl/terzaghi_abc.py,sha256=xYQ4moHm_2UDnUhyP1Uq54i7Yzo5l6GKjj380_prtRM,5453
-geolysis/bearing_capacity/ubc/__init__.py,sha256=dwpPLRtFJ0ck0bOimGZA8zqqS8fp71_Qi0Av_A-iBkM,5956
-geolysis/bearing_capacity/ubc/_core.py,sha256=Zq6DGAyrjw1OR2QZwShkdc_8BzEaKaqNNo70bhiWEu4,5858
-geolysis/bearing_capacity/ubc/hansen_ubc.py,sha256=J3H8yZmrEC413pquMGbZ8Z7L47u9AXvtJbQOORvhsAU,7184
-geolysis/bearing_capacity/ubc/terzaghi_ubc.py,sha256=k5P_TrEa7Uc17MbWmLrZDWlZJQLqOs01glQpfeJRxbc,6688
-geolysis/bearing_capacity/ubc/vesic_ubc.py,sha256=_N4bkqYWVer7yxuFAbnEYay9BsPewbtfXgK6DJyy8hw,7416
-geolysis/utils/__init__.py,sha256=Q3eBBOi_JKnydu6su-TswdI2bIT4PZ7V43NIIGaTj2w,2616
-geolysis/utils/validators.py,sha256=ETvqwXtBFE17keDE5plYcSOztFNbSuJVqB6M6SmxBaQ,2556
-geolysis-0.4.5.dist-info/licenses/LICENSE.txt,sha256=ap6sMs3lT7ICbEXBhgihwH1BTCVcjmCQkIkwVnil1Ak,1065
-geolysis-0.4.5.dist-info/METADATA,sha256=HWPSRtbg7g6bd4fo_IdAe89ligFQLX1B6lppjBvOK0w,7368
-geolysis-0.4.5.dist-info/WHEEL,sha256=tTnHoFhvKQHCh4jz3yCn0WPTYIy7wXx3CJtJ7SJGV7c,91
-geolysis-0.4.5.dist-info/top_level.txt,sha256=9mnQgOaCRr11dtXff8X-q3FfXjRONd6kHseSy5q2y8g,9
-geolysis-0.4.5.dist-info/RECORD,,