pygeodesy 24.6.1__py2.py3-none-any.whl → 24.6.24__py2.py3-none-any.whl

pygeodesy/geohash.py

@@ -20,7 +20,7 @@ from pygeodesy.basics import isodd, isstr, map2
 from pygeodesy.constants import EPS, R_M, _floatuple, _0_0, _0_5, _180_0, \
                                _360_0,  _90_0, _N_90_0, _N_180_0  # PYCHOK used!
 from pygeodesy.dms import parse3llh  # parseDMS2
-from pygeodesy.errors import _ValueError, _xkwds
+from pygeodesy.errors import _ValueError, _xkwds, _xStrError
 from pygeodesy.fmath import favg
 # from pygeodesy import formy as _formy  # _MODS
 from pygeodesy.interns import NN, _COMMA_, _DOT_, _E_, _N_, _NE_, _NW_, \
@@ -30,15 +30,16 @@ from pygeodesy.named import _name__, _NamedDict, _NamedTuple, nameof, _xnamed
 from pygeodesy.namedTuples import Bounds2Tuple, Bounds4Tuple, LatLon2Tuple, \
                                   PhiLam2Tuple
 from pygeodesy.props import deprecated_function, deprecated_method, \
-                            deprecated_property_RO, Property_RO, property_RO
+                            deprecated_property_RO, Property_RO
 from pygeodesy.streprs import fstr
-from pygeodesy.units import Degrees_, Int, Lat, Lon, Precision_, Str, \
-                           _xStrError
+from pygeodesy.units import Degrees_, Int, Lat, Lon, Precision_, Str
 
 from math import fabs, ldexp, log10, radians
 
 __all__ = _ALL_LAZY.geohash
-__version__ = '24.05.23'
+__version__ = '24.06.15'
+
+_formy = _MODS.into(formy=__name__)
 
 
 class _GH(object):
@@ -235,7 +236,7 @@ class Geohash(Str):
            @kwarg LatLon: Optional class to return I{bounds} (C{LatLon})
                           or C{None}.
            @kwarg LatLon_kwds: Optional, additional B{C{LatLon}} keyword
-                               arguments, ignored if B{C{LatLon}} is C{None}.
+                               arguments, ignored if C{B{LatLon} is None}.
 
            @return: A L{Bounds2Tuple}C{(latlonSW, latlonNE)} of B{C{LatLon}}s
                     or a L{Bounds4Tuple}C{(latS, lonW, latN, lonE)} if
@@ -298,16 +299,15 @@ class Geohash(Str):
 
            @arg other: The other geohash (L{Geohash}, C{LatLon} or C{str}).
            @kwarg radius: Mean earth radius, ellipsoid or datum (C{meter},
-                          L{Ellipsoid}, L{Ellipsoid2}, L{Datum} or
-                          L{a_f2Tuple}) or C{None}, see function
-                          L{pygeodesy.equirectangular}.
+                          L{Ellipsoid}, L{Ellipsoid2}, L{Datum} or L{a_f2Tuple})
+                          or C{None}, see function L{pygeodesy.equirectangular}.
            @kwarg adjust_limit_wrap: Optional keyword arguments for function
                          L{pygeodesy.equirectangular4}, overriding defaults
                          C{B{adjust}=False, B{limit}=None} and C{B{wrap}=False}.
 
-           @return: Distance (C{meter}, same units as B{C{radius}} or the
-                    ellipsoid or datum axes or C{radians I{squared}} if
-                    B{C{radius}} is C{None} or C{0}).
+           @return: Distance (C{meter}, same units as B{C{radius}} or the ellipsoid
+                    or datum axes or C{radians I{squared}} if B{C{radius} is None}
+                    or C{0}).
 
            @raise TypeError: The B{C{other}} is not a L{Geohash}, C{LatLon} or
                              C{str} or invalid B{C{radius}}.
@@ -317,9 +317,8 @@ class Geohash(Str):
         '''
         lls  =  self.latlon + _2Geohash(other).latlon
         kwds = _xkwds(adjust_limit_wrap, adjust=False, limit=None, wrap=False)
-        m    =  self._formy
-        return m.equirectangular( *lls, radius=radius, **kwds) if radius else \
-               m.equirectangular4(*lls, **kwds).distance2
+        return _formy.equirectangular( *lls, radius=radius, **kwds) if radius else \
+               _formy.equirectangular4(*lls, **kwds).distance2
 
     def euclideanTo(self, other, **radius_adjust_wrap):
         '''Approximate the distance between this and an other geohash using
@@ -335,14 +334,7 @@ class Geohash(Str):
            @raise TypeError: The B{C{other}} is not a L{Geohash}, C{LatLon}
                              or C{str} or invalid B{C{radius}}.
         '''
-        return self._distanceTo(self._formy.euclidean, other, **radius_adjust_wrap)
-
-    @property_RO
-    def _formy(self):
-        '''(INTERNAL) Get the C{.formy} module, I{once}.
-        '''
-        Geohash._formy = f = _MODS.formy  # overwrite property_RO
-        return f
+        return self._distanceTo(_formy.euclidean, other, **radius_adjust_wrap)
 
     def haversineTo(self, other, **radius_wrap):
         '''Compute the distance between this and an other geohash using
@@ -358,7 +350,7 @@ class Geohash(Str):
            @raise TypeError: The B{C{other}} is not a L{Geohash}, C{LatLon}
                              or C{str} or invalid B{C{radius}}.
         '''
-        return self._distanceTo(self._formy.haversine, other, **radius_wrap)
+        return self._distanceTo(_formy.haversine, other, **radius_wrap)
 
     @Property_RO
     def latlon(self):
@@ -404,13 +396,11 @@ class Geohash(Str):
            as an instance of the supplied C{LatLon} class.
 
            @arg LatLon: Class to use (C{LatLon}) or C{None}.
-           @kwarg LatLon_kwds: Optional, additional B{C{LatLon}}
-                               keyword arguments, ignored if
-                               C{B{LatLon} is None}.
+           @kwarg LatLon_kwds: Optional, additional B{C{LatLon}} keyword
+                               arguments, ignored if C{B{LatLon} is None}.
 
-           @return: This geohash location (B{C{LatLon}}) or a
-                    L{LatLon2Tuple}C{(lat, lon)} if B{C{LatLon}}
-                    is C{None}.
+           @return: This geohash location (B{C{LatLon}}) or if C{B{LatLon}
+                    is None}, a L{LatLon2Tuple}C{(lat, lon)}.
 
            @raise TypeError: Invalid B{C{LatLon}} or B{C{LatLon_kwds}}.
         '''
@@ -431,7 +421,7 @@ class Geohash(Str):
            @raise TypeError: The B{C{other}} is not a L{Geohash}, C{LatLon}
                              or C{str} or invalid B{C{radius}}.
         '''
-        return self._distanceTo(self._formy.vincentys, other, **radius_wrap)
+        return self._distanceTo(_formy.vincentys, other, **radius_wrap)
 
     @Property_RO
     def N(self):
@@ -506,19 +496,17 @@ _Neighbors8Defaults = dict(zip(Neighbors8Dict._Keys_, (None,) *
 def bounds(geohash, LatLon=None, **LatLon_kwds):
     '''Returns the lower-left SW and upper-right NE corners of a geohash.
 
-       @arg geohash: To be bound (L{Geohash}).
-       @kwarg LatLon: Optional class to return the bounds (C{LatLon})
-                      or C{None}.
-       @kwarg LatLon_kwds: Optional, additional B{C{LatLon}} keyword
-                           arguments, ignored if C{B{LatLon} is None}.
+       @arg geohash: To be "bound" (L{Geohash}).
+       @kwarg LatLon: Optional class to return the bounds (C{LatLon}) or C{None}.
+       @kwarg LatLon_kwds: Optional, additional B{C{LatLon}} keyword arguments,
+                           ignored if C{B{LatLon} is None}.
 
-       @return: A L{Bounds2Tuple}C{(latlonSW, latlonNE)} of B{C{LatLon}}s
-                or if B{C{LatLon}} is C{None}, a L{Bounds4Tuple}C{(latS,
-                lonW, latN, lonE)}.
+       @return: A L{Bounds2Tuple}C{(latlonSW, latlonNE)}, each a B{C{LatLon}}
+                or if C{B{LatLon} is None}, a L{Bounds4Tuple}C{(latS, lonW,
+                latN, lonE)}.
 
-       @raise TypeError: The B{C{geohash}} is not a L{Geohash}, C{LatLon}
-                         or C{str} or invalid B{C{LatLon}} or invalid
-                         B{C{LatLon_kwds}}.
+       @raise TypeError: The B{C{geohash}} is not a L{Geohash}, C{LatLon} or
+                         C{str} or invalid B{C{LatLon}} or invalid B{C{LatLon_kwds}}.
 
        @raise GeohashError: Invalid or C{null} B{C{geohash}}.
     '''
@@ -803,18 +791,11 @@ def precision(res1, res2=None):
              <https://GeographicLib.SourceForge.io/C++/doc/classGeographicLib_1_1Geohash.html>}.
     '''
     r = Degrees_(res1=res1, low=_0_0, Error=GeohashError)
-    if res2 is None:
-        t = r, r
-        for p in range(1, _MaxPrec):
-            if resolution2(p, None) <= t:
-                return p
-
-    else:
-        t = r, Degrees_(res2=res2, low=_0_0, Error=GeohashError)
-        for p in range(1, _MaxPrec):
-            if resolution2(p, p) <= t:
-                return p
-
+    N = res2 is None
+    t = r, (r if N else Degrees_(res2=res2, low=_0_0, Error=GeohashError))
+    for p in range(1, _MaxPrec):
+        if resolution2(p, (None if N else p)) <= t:
+            return p
     return _MaxPrec
 
 
@@ -860,14 +841,12 @@ def resolution2(prec1, prec2=None):
 def sizes(geohash):
     '''Return the lat- and longitudinal size of this L{Geohash} cell.
 
-       @arg geohash: Cell for which size are required (L{Geohash} or
-                     C{str}).
+       @arg geohash: Cell for which size are required (L{Geohash} or C{str}).
 
-       @return: A L{LatLon2Tuple}C{(lat, lon)} with the latitudinal
-                height and longitudinal width in (C{meter}).
+       @return: A L{LatLon2Tuple}C{(lat, lon)} with the latitudinal height and
+                longitudinal width in (C{meter}).
 
-       @raise TypeError: The B{C{geohash}} is not a L{Geohash},
-                         C{LatLon} or C{str}.
+       @raise TypeError: The B{C{geohash}} is not a L{Geohash}, C{LatLon} or C{str}.
     '''
     return _2Geohash(geohash).sizes
 

pygeodesy/geoids.py

@@ -118,7 +118,7 @@ except ImportError:  # Python 3+
     from io import BytesIO as _BytesIO  # PYCHOK expected
 
 __all__ = _ALL_LAZY.geoids
-__version__ = '24.05.23'
+__version__ = '24.06.11'
 
 _assert_ = 'assert'
 _bHASH_  =  b'#'
@@ -323,10 +323,9 @@ class _GeoidBase(_HeightsBase):
            @kwarg LatLon: Optional class to return the location and height
                           (C{LatLon}) or C{None}.
 
-           @return: If B{C{LatLon}} is C{None}, a L{LatLon3Tuple}C{(lat,
-                    lon, height)} otherwise a B{C{LatLon}} instance
-                    with the lat-, longitude and geoid height of the
-                    center grid location.
+           @return: If C{B{LatLon} is None}, a L{LatLon3Tuple}C{(lat, lon,
+                    height)} otherwise a B{C{LatLon}} instance with the lat-,
+                    longitude and geoid height of the center grid location.
         '''
         return self._llh3LL(self._center, LatLon)
 
@@ -437,10 +436,9 @@ class _GeoidBase(_HeightsBase):
            @kwarg LatLon: Optional class to return the location and height
                           (C{LatLon}) or C{None}.
 
-           @return: If B{C{LatLon}} is C{None}, a L{LatLon3Tuple}C{(lat,
-                    lon, height)} otherwise a B{C{LatLon}} instance
-                    with the lat-, longitude and geoid height of the
-                    highest grid location.
+           @return: If C{B{LatLon} is None}, a L{LatLon3Tuple}C{(lat, lon,
+                    height)} otherwise a B{C{LatLon}} instance with the lat-,
+                    longitude and geoid height of the highest grid location.
         '''
         return self._llh3LL(self._highest, LatLon)
 
@@ -513,10 +511,9 @@ class _GeoidBase(_HeightsBase):
            @kwarg LatLon: Optional class to return the location
                           (C{LatLon}) and height or C{None}.
 
-           @return: If B{C{LatLon}} is C{None}, a L{LatLon3Tuple}C{(lat,
-                    lon, height)} otherwise a B{C{LatLon}} instance
-                    with the lat-, longitude and geoid height of the
-                    lower-left, SW grid corner.
+           @return: If C{B{LatLon} is None}, a L{LatLon3Tuple}C{(lat, lon, height)}
+                    otherwise a B{C{LatLon}} instance with the lat-, longitude and
+                    geoid height of the lower-left, SW grid corner.
         '''
         return self._llh3LL(self._lowerleft, LatLon)
 
@@ -532,10 +529,9 @@ class _GeoidBase(_HeightsBase):
            @kwarg LatLon: Optional class to return the location and height
                           (C{LatLon}) or C{None}.
 
-           @return: If B{C{LatLon}} is C{None}, a L{LatLon3Tuple}C{(lat,
-                    lon, height)} otherwise a B{C{LatLon}} instance
-                    with the lat-, longitude and geoid height of the
-                    lower-right, SE grid corner.
+           @return: If C{B{LatLon} is None}, a L{LatLon3Tuple}C{(lat, lon, height)}
+                    otherwise a B{C{LatLon}} instance with the lat-, longitude and
+                    geoid height of the lower-right, SE grid corner.
         '''
 
         return self._llh3LL(self._loweright, LatLon)
@@ -554,10 +550,9 @@ class _GeoidBase(_HeightsBase):
            @kwarg LatLon: Optional class to return the location and height
                           (C{LatLon}) or C{None}.
 
-           @return: If B{C{LatLon}} is C{None}, a L{LatLon3Tuple}C{(lat,
-                    lon, height)} otherwise a B{C{LatLon}} instance
-                    with the lat-, longitude and geoid height of the
-                    lowest grid location.
+           @return: If C{B{LatLon} is None}, a L{LatLon3Tuple}C{(lat, lon,
+                    height)} otherwise a B{C{LatLon}} instance with the lat-,
+                    longitude and geoid height of the lowest grid location.
         '''
         return self._llh3LL(self._lowest, LatLon)
 
@@ -701,10 +696,9 @@ class _GeoidBase(_HeightsBase):
            @kwarg LatLon: Optional class to return the location and height
                           (C{LatLon}) or C{None}.
 
-           @return: If B{C{LatLon}} is C{None}, a L{LatLon3Tuple}C{(lat,
-                    lon, height)} otherwise a B{C{LatLon}} instance
-                    with the lat-, longitude and geoid height of the
-                    upper-left, NW grid corner.
+           @return: If C{B{LatLon} is None}, a L{LatLon3Tuple}C{(lat, lon, height)}
+                    otherwise a B{C{LatLon}} instance with the lat-, longitude and
+                    geoid height of the upper-left, NW grid corner.
         '''
         return self._llh3LL(self._upperleft, LatLon)
 
@@ -720,10 +714,9 @@ class _GeoidBase(_HeightsBase):
            @kwarg LatLon: Optional class to return the location and height
                           (C{LatLon}) or C{None}.
 
-           @return: If B{C{LatLon}} is C{None}, a L{LatLon3Tuple}C{(lat,
-                    lon, height)} otherwise a B{C{LatLon}} instance
-                    with the lat-, longitude and geoid height of the
-                    upper-right, NE grid corner.
+           @return: If C{B{LatLon} is None}, a L{LatLon3Tuple}C{(lat, lon, height)}
+                    otherwise a B{C{LatLon}} instance with the lat-, longitude and
+                    geoid height of the upper-right, NE grid corner.
         '''
         return self._llh3LL(self._upperright, LatLon)
 
@@ -1169,10 +1162,9 @@ class GeoidKarney(_GeoidBase):
                           (C{LatLon}) or C{None}.
            @kwarg full: Search the full or limited latitude range (C{bool}).
 
-           @return: If B{C{LatLon}} is C{None}, a L{LatLon3Tuple}C{(lat,
-                    lon, height)} otherwise a B{C{LatLon}} instance
-                    with the lat-, longitude and geoid height at the
-                    highest grid location.
+           @return: If C{B{LatLon} is None}, a L{LatLon3Tuple}C{(lat, lon,
+                    height)} otherwise a B{C{LatLon}} instance with the lat-,
+                    longitude and geoid height of the highest grid location.
         '''
         llh = self._highest if full or self.cropped else self._highest_ltd
         return self._llh3LL(llh, LatLon)
@@ -1223,10 +1215,9 @@ class GeoidKarney(_GeoidBase):
                           (C{LatLon}) or C{None}.
            @kwarg full: Search the full or limited latitude range (C{bool}).
 
-           @return: If B{C{LatLon}} is C{None}, a L{LatLon3Tuple}C{(lat,
-                    lon, height)} otherwise a B{C{LatLon}} instance
-                    with the lat-, longitude and geoid height of the
-                    lowest grid location.
+           @return: If C{B{LatLon} is None}, a L{LatLon3Tuple}C{(lat, lon,
+                    height)} otherwise a B{C{LatLon}} instance with the lat-,
+                    longitude and geoid height of the lowest grid location.
         '''
         llh = self._lowest if full or self.cropped else self._lowest_ltd
         return self._llh3LL(llh, LatLon)

pygeodesy/hausdorff.py

@@ -72,21 +72,20 @@ from pygeodesy.datums import _ellipsoidal_datum, _WGS84
 from pygeodesy.errors import PointsError, _xattr, _xcallable, _xkwds, _xkwds_get
 import pygeodesy.formy as _formy
 from pygeodesy.interns import NN, _i_, _j_, _units_
-# from pygeodesy.iters import points2  # from .points
+# from pygeodesy.iters import points2 as _points  # from .points
 from pygeodesy.lazily import _ALL_LAZY, _FOR_DOCS
 from pygeodesy.named import _name2__, _Named, _NamedTuple, _Pass
 # from pygeodesy.namedTuples import PhiLam2Tuple  # from .points
-from pygeodesy.points import _distanceTo, points2 as _points2,  PhiLam2Tuple, radians
+from pygeodesy.points import _distanceTo,  PhiLam2Tuple, points2 as _points2, radians
 from pygeodesy.props import Property, Property_RO, property_doc_, property_RO
-from pygeodesy.units import Float, Number_, _xUnit, _xUnits
-from pygeodesy.unitsBase import _Str_degrees, _Str_degrees2, _Str_meter, _Str_NN, \
-                                _Str_radians, _Str_radians2
+from pygeodesy.units import Float, Number_
+from pygeodesy import unitsBase as _unitsBase  # _Str_..., _xUnit, _xUnits
 
 # from math import radians  # from .points
 from random import Random
 
 __all__ = _ALL_LAZY.hausdorff
-__version__ = '24.05.26'
+__version__ = '24.06.15'
 
 
 class HausdorffError(PointsError):
@@ -104,7 +103,7 @@ class Hausdorff(_Named):
     _kwds  = {}     # func_ options
     _model = ()
     _seed  =  None
-    _units = _Str_NN  # XXX Str to _Pass and for backward compatibility
+    _units = _unitsBase._Str_NN  # XXX Str to _Pass and for backward compatibility
 
     def __init__(self, point1s, seed=None, units=NN, **name__kwds):
         '''New C{Hausdorff...} calculator.
@@ -261,7 +260,7 @@ class Hausdorff(_Named):
 
            @raise TypeError: Invalid B{C{units}}.
         '''
-        self._units = _xUnits(units, Base=Float)
+        self._units = _unitsBase._xUnits(units, Base=Float)
 
     @Property_RO
     def wrap(self):
@@ -274,7 +273,7 @@ class HausdorffDegrees(Hausdorff):
     '''L{Hausdorff} base class for distances from C{LatLon}
        points in C{degrees}.
     '''
-    _units = _Str_degrees
+    _units = _unitsBase._Str_degrees
 
     if _FOR_DOCS:
         __init__  = Hausdorff.__init__
@@ -290,7 +289,7 @@ class HausdorffRadians(Hausdorff):
     '''L{Hausdorff} base class for distances from C{LatLon}
        points converted from C{degrees} to C{radians}.
     '''
-    _units = _Str_radians
+    _units = _unitsBase._Str_radians
 
     if _FOR_DOCS:
         __init__  = Hausdorff.__init__
@@ -318,8 +317,8 @@ class _HausdorffMeterRadians(Hausdorff):
        the optional keyword arguments supplied at instantiation
        of the C{Hausdorff*} sub-class.
     '''
-    _units  = _Str_meter
-    _units_ = _Str_radians
+    _units  = _unitsBase._Str_meter
+    _units_ = _unitsBase._Str_radians
 
     def directed(self, point2s, early=True):
         '''Overloaded method L{Hausdorff.directed} to determine
@@ -426,7 +425,7 @@ class HausdorffDistanceTo(Hausdorff):
     '''Compute the C{Hausdorff} distance based on the distance from the
        points' C{LatLon.distanceTo} method, conventionally in C{meter}.
     '''
-    _units = _Str_meter
+    _units = _unitsBase._Str_meter
 
     def __init__(self, point1s, **seed_name__distanceTo_kwds):
         '''New L{HausdorffDistanceTo} calculator.
@@ -464,7 +463,7 @@ class HausdorffEquirectangular(Hausdorff):
     '''Compute the C{Hausdorff} distance based on the C{equirectangular} distance
        in C{radians squared} like function L{pygeodesy.equirectangular}.
     '''
-    _units = _Str_degrees2
+    _units = _unitsBase._Str_degrees2
 
     def __init__(self, point1s, **seed_name__adjust_limit_wrap):
         '''New L{HausdorffEquirectangular} calculator.
@@ -513,7 +512,7 @@ class HausdorffExact(Hausdorff):
     '''Compute the C{Hausdorff} distance based on the I{angular}
        distance in C{degrees} from method L{GeodesicExact}C{.Inverse}.
     '''
-    _units = _Str_degrees
+    _units = _unitsBase._Str_degrees
 
     def __init__(self, point1s, datum=None, **seed_name__wrap):
         '''New L{HausdorffKarney} calculator.
@@ -543,7 +542,7 @@ class HausdorffFlatLocal(_HausdorffMeterRadians):
     '''Compute the C{Hausdorff} distance based on the I{angular} distance in
        C{radians squared} like function L{pygeodesy.flatLocal_}/L{pygeodesy.hubeny_}.
     '''
-    _units = _Str_radians2
+    _units = _unitsBase._Str_radians2
 
     def __init__(self, point1s, **seed_name__datum_scaled_wrap):
         '''New L{HausdorffFlatLocal}/L{HausdorffHubeny} calculator.
@@ -634,7 +633,7 @@ class HausdorffKarney(Hausdorff):
        <https://GeographicLib.SourceForge.io/Python/doc/code.html>}
        Inverse method.
     '''
-    _units = _Str_degrees
+    _units = _unitsBase._Str_degrees
 
     def __init__(self, point1s, datum=None, **seed_name__wrap):
         '''New L{HausdorffKarney} calculator.
@@ -819,14 +818,13 @@ class Hausdorff6Tuple(_NamedTuple):
     _Names_ = ('hd', _i_,     _j_,     'mn',     'md',  _units_)
     _Units_ = (_Pass, Number_, Number_, Number_, _Pass, _Pass)
 
-    def toUnits(self, **Error):  # PYCHOK expected
+    def toUnits(self, **Error_name):  # PYCHOK expected
         '''Overloaded C{_NamedTuple.toUnits} for C{hd} and C{md} units.
         '''
-        U = _xUnit(self.units, Float)  # PYCHOK expected
-        M = _Pass if self.md is None else U  # PYCHOK expected
-        self._Units_ = (U,) + Hausdorff6Tuple._Units_[1:4] \
-                     + (M,) + Hausdorff6Tuple._Units_[5:]
-        return _NamedTuple.toUnits(self, **Error)
+        u    = list(Hausdorff6Tuple._Units_)
+        u[0] = U = _unitsBase._xUnit(self.units, Float)  # PYCHOK expected
+        u[4] =     _Pass if self.md is None else U  # PYCHOK expected
+        return _NamedTuple.toUnits(self.reUnit(*u), **Error_name)  # PYCHOK self
 
 
 def randomrangenerator(seed):

pygeodesy/heights.py

@@ -1,7 +1,7 @@
 
 # -*- coding: utf-8 -*-
 
-u'''Height interpolations at C{LatLon} points from C{knots}.
+u'''Height interpolations at C{LatLon} points from known C{knots}.
 
 Classes L{HeightCubic}, L{HeightIDWcosineAndoyerLambert},
 L{HeightIDWcosineForsytheAndoyerLambert}, L{HeightIDWcosineLaw},
@@ -76,7 +76,7 @@ from pygeodesy.errors import _AssertionError, LenError, PointsError, \
 # from pygeodesy.fmath import fidw  # _MODS
 # from pygeodesy.formy import cosineAndoyerLambert, cosineForsytheAndoyerLambert, \
 #                             cosineLaw, equirectangular4, euclidean, flatLocal, \
-#                             flatPolar, haversine, thomas, vincentys  # _MODS
+#                             flatPolar, haversine, thomas, vincentys  # _MODS.into
 # from pygeodesy.internals import _version2  # _MODS
 from pygeodesy.interns import NN, _COMMASPACE_, _cubic_, _insufficient_, _linear_, \
                              _NOTEQUAL_, _PLUS_, _scipy_, _SPACE_, _STAR_
@@ -91,9 +91,10 @@ from pygeodesy.units import _isDegrees, Float_, Int_
 # from math import radians  # from .points
 
 __all__ = _ALL_LAZY.heights
-__version__ = '24.05.25'
+__version__ = '24.06.22'
 
 _error_     = 'error'
+_formy      = _MODS.into(formy=__name__)
 _llis_      = 'llis'
 _smoothing_ = 'smoothing'
 
@@ -693,20 +694,6 @@ class _HeightIDW(_HeightBase):
             i = Fmt.INDEX(knots=i)
             raise HeightError(i, k, cause=e)
 
-    @property_RO
-    def _fmath(self):
-        '''(INTERNAL) Get module C{fmath}, I{once}.
-        '''
-        _HeightIDW._fmath = f = _MODS.fmath  # overwrite property_RO
-        return f
-
-    @property_RO
-    def _formy(self):
-        '''(INTERNAL) Get module C{formy}, I{once}.
-        '''
-        _HeightIDW._formy = f = _MODS.formy  # overwrite property_RO
-        return f
-
     def height(self, lats, lons, **wrap):
         '''Interpolate the height for one or several lat-/longitudes.
 
@@ -735,7 +722,7 @@ class _HeightIDW(_HeightBase):
         '''
         ds, hs = self._distances(x, y), self._heights
         try:
-            return self._fmath.fidw(hs, ds, beta=self.beta)
+            return _MODS.fmath.fidw(hs, ds, beta=self.beta)
         except (TypeError, ValueError) as e:
             raise HeightError(x=x, y=y, cause=e)
 
@@ -798,7 +785,7 @@ class HeightIDWcosineAndoyerLambert(_HeightIDW):
            @see: L{Here<_HeightIDW.__init__>} for further details.
         '''
         _HeightIDW.__init__(self, knots, beta=beta, **name__datum_wrap)
-        self._func = self._formy.cosineAndoyerLambert
+        self._func = _formy.cosineAndoyerLambert
 
     if _FOR_DOCS:
         __call__ = _HeightIDW.__call__
@@ -821,7 +808,7 @@ class HeightIDWcosineForsytheAndoyerLambert(_HeightIDW):
            @see: L{Here<_HeightIDW.__init__>} for further details.
         '''
         _HeightIDW.__init__(self, knots, beta=beta, **name__datum_wrap)
-        self._func = self._formy.cosineForsytheAndoyerLambert
+        self._func = _formy.cosineForsytheAndoyerLambert
 
     if _FOR_DOCS:
         __call__ = _HeightIDW.__call__
@@ -845,7 +832,7 @@ class HeightIDWcosineLaw(_HeightIDW):
            @see: L{Here<_HeightIDW.__init__>} for further details.
         '''
         _HeightIDW.__init__(self, knots, beta=beta, **name__radius_wrap)
-        self._func = self._formy.cosineLaw
+        self._func = _formy.cosineLaw
 
     if _FOR_DOCS:
         __call__ = _HeightIDW.__call__
@@ -914,7 +901,7 @@ class HeightIDWequirectangular(_HeightIDW):
     def _distances(self, x, y):
         '''(INTERNAL) Yield distances to C{(x, y)}.
         '''
-        _f, kwds = self._formy.equirectangular4, self._kwds
+        _f, kwds = _formy.equirectangular4, self._kwds
         try:
             for i, k in enumerate(self._knots):
                 yield _f(y, x, k.lat, k.lon, **kwds).distance2
@@ -942,7 +929,7 @@ class HeightIDWeuclidean(_HeightIDW):
            @see: L{Here<_HeightIDW.__init__>} for further details.
         '''
         _HeightIDW.__init__(self, knots, beta=beta, **name__adjust_radius_wrap)
-        self._func = self._formy.euclidean
+        self._func = _formy.euclidean
 
     if _FOR_DOCS:
         __call__ = _HeightIDW.__call__
@@ -995,7 +982,7 @@ class HeightIDWflatLocal(_HeightIDW):
         '''
         _HeightIDW.__init__(self, knots, beta=beta,
                                        **name__datum_hypot_scaled_wrap)
-        self._func = self._formy.flatLocal
+        self._func = _formy.flatLocal
 
     if _FOR_DOCS:
         __call__ = _HeightIDW.__call__
@@ -1018,7 +1005,7 @@ class HeightIDWflatPolar(_HeightIDW):
            @see: L{Here<_HeightIDW.__init__>} for further details.
         '''
         _HeightIDW.__init__(self, knots, beta=beta, **name__radius_wrap)
-        self._func = self._formy.flatPolar
+        self._func = _formy.flatPolar
 
     if _FOR_DOCS:
         __call__ = _HeightIDW.__call__
@@ -1042,7 +1029,7 @@ class HeightIDWhaversine(_HeightIDW):
            @see: L{Here<_HeightIDW.__init__>} for further details.
         '''
         _HeightIDW.__init__(self, knots, beta=beta, **name__radius_wrap)
-        self._func = self._formy.haversine
+        self._func = _formy.haversine
 
     if _FOR_DOCS:
         __call__ = _HeightIDW.__call__
@@ -1106,7 +1093,7 @@ class HeightIDWthomas(_HeightIDW):
            @see: L{Here<_HeightIDW.__init__>} for further details.
         '''
         _HeightIDW.__init__(self, knots, beta=beta, **name__datum_wrap)
-        self._func = self._formy.thomas
+        self._func = _formy.thomas
 
     if _FOR_DOCS:
         __call__ = _HeightIDW.__call__
@@ -1130,7 +1117,7 @@ class HeightIDWvincentys(_HeightIDW):
            @see: L{Here<_HeightIDW.__init__>} for further details.
         '''
         _HeightIDW.__init__(self, knots, beta=beta, **name__radius_wrap)
-        self._func = self._formy.vincentys
+        self._func = _formy.vincentys
 
     if _FOR_DOCS:
         __call__ = _HeightIDW.__call__