pygeodesy 24.10.10__py2.py3-none-any.whl → 24.11.11__py2.py3-none-any.whl

pygeodesy/geodsolve.py

@@ -14,9 +14,8 @@ from pygeodesy.basics import _xinstanceof
 # from pygeodesy.geodesicx import GeodesicAreaExact  # _MODS
 from pygeodesy.interns import NN, _UNDER_
 from pygeodesy.karney import Caps, GeodesicError, GeodSolve12Tuple, \
-                            _sincos2d,  _0_0, NAN
-from pygeodesy.lazily import _ALL_DOCS, _ALL_LAZY, _ALL_MODS as _MODS, \
-                             _getenv, _PYGEODESY_GEODSOLVE_
+                            _sincos2d, _Xables,  _0_0, NAN
+from pygeodesy.lazily import _ALL_DOCS, _ALL_LAZY, _ALL_MODS as _MODS
 from pygeodesy.named import _name1__
 from pygeodesy.namedTuples import Destination3Tuple, Distance3Tuple
 from pygeodesy.props import Property, Property_RO, property_RO
@@ -24,7 +23,7 @@ from pygeodesy.solveBase import _SolveGDictBase, _SolveGDictLineBase
 from pygeodesy.utily import _unrollon, _Wrap, wrap360
 
 __all__ = _ALL_LAZY.geodsolve
-__version__ = '24.08.13'
+__version__ = '24.11.02'
 
 
 class _GeodesicSolveBase(_SolveGDictBase):
@@ -33,8 +32,8 @@ class _GeodesicSolveBase(_SolveGDictBase):
     _Error         =  GeodesicError
     _Names_Direct  = \
     _Names_Inverse =  GeodSolve12Tuple._Names_
-    _Xable_name    = 'GeodSolve'
-    _Xable_path    = _getenv(_PYGEODESY_GEODSOLVE_, _PYGEODESY_GEODSOLVE_)
+    _Xable_name    = _Xables.GeodSolve.__name__
+    _Xable_path    = _Xables.GeodSolve()
 
     @Property_RO
     def _b_option(self):
@@ -182,15 +181,6 @@ class GeodesicSolve(_GeodesicSolveBase):
             ll2 = _unrollon(ll1, _Wrap.point(ll2))
         return self.InverseLine(ll1.lat, ll1.lon, ll2.lat, ll2.lon, **caps_name)
 
-#   def _InverseLine2(self, lat1, lon1, lat2, lon2, **caps_name):  # in .geodesici
-#       '''(INTERNAL) Helper for L{InverseLine} and L{_InverseLine}.
-#       '''
-#       r  = self.Inverse(lat1, lon1, lat2, lon2)
-#       gl = GeodesicLineSolve(self, lat1, lon1, r.azi1, **_name1__(caps_name, _or_nameof=self))
-#       gl._a13 = r.a12  # gl.SetArc(r.a12)
-#       gl._s13 = r.s12  # gl.SetDistance(r.s12)
-#       return gl, r
-
     def InverseLine(self, lat1, lon1, lat2, lon2, **caps_name):  # PYCHOK no cover
         '''Set up a L{GeodesicLineSolve} to compute several points
            on a single geodesic.
@@ -271,14 +261,14 @@ class GeodesicLineSolve(_GeodesicSolveBase, _SolveGDictLineBase):
         '''
         return self._a13
 
-    def Arc(self):
+    def Arc(self):  # PYCHOK no cover
         '''Return the arc length to reference point 3 (C{degrees} or C{NAN}).
 
            @see: Method L{SetArc} and property L{a13}.
         '''
         return self.a13
 
-    def ArcPosition(self, a12, outmask=Caps.STANDARD):  # PYCHOK unused
+    def ArcPosition(self, a12, outmask=Caps.STANDARD):  # PYCHOK no cover
         '''Find the position on the line given B{C{a12}}.
 
            @arg a12: Spherical arc length from the first point to the
@@ -348,7 +338,7 @@ class GeodesicLineSolve(_GeodesicSolveBase, _SolveGDictLineBase):
         '''
         return self._s13
 
-    def SetArc(self, a13):
+    def SetArc(self, a13):  # PYCHOK no cover
         '''Set reference point 3 in terms relative to the first point.
 
            @arg a13: Spherical arc length from the first to the reference
@@ -363,13 +353,13 @@ class GeodesicLineSolve(_GeodesicSolveBase, _SolveGDictLineBase):
 #           _update_all(self)
         return self._s13
 
-    def SetDistance(self, s13):
+    def SetDistance(self, s13):  # PYCHOK no cover
         '''Set reference point 3 in terms relative to the first point.
 
            @arg s13: Distance from the first to the reference point (C{meter}).
 
-           @return: The arc length C{a13} (C{degrees}) between the first
-                    and the reference point or C{NAN}.
+           @return: The arc length C{a13} (C{degrees}) between the first and
+                    the reference point or C{NAN}.
         '''
         if self._s13 != s13:
             self._s13 = s13
@@ -396,30 +386,32 @@ __all__ += _ALL_DOCS(_GeodesicSolveBase)
 
 if __name__ == '__main__':
 
-    from pygeodesy import printf
-    from sys import argv
+    def _main():
+        from pygeodesy import printf
+        from sys import argv
 
-    gS = GeodesicSolve(name='Test')
-    gS.verbose = '--verbose' in argv  # or '-v' in argv
+        gS = GeodesicSolve(name='Test')
+        gS.verbose = '--verbose' in argv  # or '-v' in argv
 
-    if gS.GeodSolve in (_PYGEODESY_GEODSOLVE_, None):  # not set
-        gS.GeodSolve = '/opt/local/bin/GeodSolve'  # '/opt/local/Cellar/geographiclib/2.3/bin/GeodSolve'  # HomeBrew
-    printf('version: %s', gS.version)
+        if not _Xables.X_OK(gS.GeodSolve):  # not set
+            gS.GeodSolve = _Xables.GeodSolve(_Xables.bin_)
+        printf('version: %s', gS.version)
 
-    r = gS.Direct(40.6, -73.8, 51, 5.5e6)
-    printf('Direct: %r', r, nl=1)
-    printf('Direct3: %r', gS.Direct3(40.6, -73.8, 51, 5.5e6))
+        r = gS.Direct(40.6, -73.8, 51, 5.5e6)
+        printf('Direct: %r', r, nl=1)
+        printf('Direct3: %r', gS.Direct3(40.6, -73.8, 51, 5.5e6))
 
-    printf('Inverse: %r',  gS.Inverse( 40.6, -73.8, 51.6, -0.5), nl=1)
-    printf('Inverse1: %r', gS.Inverse1(40.6, -73.8, 51.6, -0.5))
-    printf('Inverse3: %r', gS.Inverse3(40.6, -73.8, 51.6, -0.5))
+        printf('Inverse: %r',  gS.Inverse( 40.6, -73.8, 51.6, -0.5), nl=1)
+        printf('Inverse1: %r', gS.Inverse1(40.6, -73.8, 51.6, -0.5))
+        printf('Inverse3: %r', gS.Inverse3(40.6, -73.8, 51.6, -0.5))
 
-    glS = GeodesicLineSolve(gS, 40.6, -73.8, 51, name='LineTest')
-    p = glS.Position(5.5e6)
-    printf('Position:    %s  %r', p == r, p, nl=1)
-    p = glS.ArcPosition(49.475527)
-    printf('ArcPosition: %s %r', p == r, p)
+        glS = GeodesicLineSolve(gS, 40.6, -73.8, 51, name='LineTest')
+        p = glS.Position(5.5e6)
+        printf('Position:    %5s %r', p == r, p, nl=1)
+        p = glS.ArcPosition(49.475527)
+        printf('ArcPosition: %5s %r', p == r, p)
 
+    _main()
 
 # % python3 -m pygeodesy.geodsolve
 
@@ -436,6 +428,21 @@ if __name__ == '__main__':
 # ArcPosition: False GDict(a12=49.475527, azi1=51.0, azi2=107.189397, lat1=40.6, lat2=51.884565, lon1=-73.8, lon2=-1.141174, m12=4844148.669561, M12=0.650911, M21=0.651229, s12=5499999.948497, S12=39735074737272.734375)
 
 
+# % python3 -m pygeodesy.geodsolve
+
+# version: /opt/local/bin/GeodSolve: GeographicLib version 2.3
+
+# Direct: GDict(a12=49.475527, azi1=51.0, azi2=107.189397, lat1=40.6, lat2=51.884565, lon1=-73.8, lon2=-1.141173, m12=4844148.703101, M12=0.650911, M21=0.651229, s12=5500000.0, S12=39735075134877.078125)
+# Direct3: Destination3Tuple(lat=51.884565, lon=-1.141173, final=107.189397)
+
+# Inverse: GDict(a12=49.94131, azi1=51.198883, azi2=107.821777, lat1=40.6, lat2=51.6, lon1=-73.8, lon2=-0.5, m12=4877684.602706, M12=0.64473, M21=0.645046, s12=5551759.400319, S12=40041368848742.53125)
+# Inverse1: 49.94131021789904
+# Inverse3: Distance3Tuple(distance=5551759.400319, initial=51.198883, final=107.821777)
+
+# Position:    False GDict(a12=49.475527, azi1=51.0, azi2=107.189397, lat1=40.6, lat2=51.884565, lon1=-73.8, lon2=-1.141173, s12=5500000.0)
+# ArcPosition: False GDict(a12=49.475527, azi1=51.0, azi2=107.189397, lat1=40.6, lat2=51.884565, lon1=-73.8, lon2=-1.141174, s12=5499999.948497)
+
+
 # % python3 -m pygeodesy.geodsolve --verbose
 
 # GeodesicSolve 'Test' 1: /opt/local/bin/GeodSolve --version (invoke)
@@ -462,6 +469,39 @@ if __name__ == '__main__':
 # Position:    True  GDict(a12=49.475527, azi1=51.0, azi2=107.189397, lat1=40.6, lat2=51.884565, lon1=-73.8, lon2=-1.141173, m12=4844148.703101, M12=0.650911, M21=0.651229, s12=5500000.0, S12=39735075134877.09375)
 # ArcPosition: False GDict(a12=49.475527, azi1=51.0, azi2=107.189397, lat1=40.6, lat2=51.884565, lon1=-73.8, lon2=-1.141174, m12=4844148.669561, M12=0.650911, M21=0.651229, s12=5499999.948497, S12=39735074737272.734375)
 
+
+# % python3 -m pygeodesy.geodsolve --verbose
+
+# GeodesicSolve 'Test'@1: /opt/local/bin/GeodSolve --version (invoke)
+# GeodesicSolve 'Test'@1: '/opt/local/bin/GeodSolve: GeographicLib version 2.3' (0, stdout/-err)
+# GeodesicSolve 'Test'@1: /opt/local/bin/GeodSolve: GeographicLib version 2.3 (0)
+# version: /opt/local/bin/GeodSolve: GeographicLib version 2.3
+# GeodesicSolve 'Test'@2: /opt/local/bin/GeodSolve -f -E -p 10 \ 40.600000000000001 -73.799999999999997 51.0 5500000.0 (Direct)
+# GeodesicSolve 'Test'@2: '40.600000000000001 -73.799999999999997 51.000000000000000 51.884564505606761 -1.141172861200843 107.189397162605871 5500000.0000000000 49.475527463251460 4844148.7031014860 0.65091056699808614 0.65122865892196569 39735075134877.078' (0, stdout/-err)
+# GeodesicSolve 'Test'@2: lat1=40.600000000000001, lon1=-73.799999999999997, azi1=51.0, lat2=51.884564505606761, lon2=-1.141172861200843, azi2=107.189397162605871, s12=5500000.0, a12=49.47552746325146, m12=4844148.703101486, M12=0.65091056699808614, M21=0.65122865892196569, S12=39735075134877.078 (0)
+
+# Direct: GDict(a12=49.475527, azi1=51.0, azi2=107.189397, lat1=40.6, lat2=51.884565, lon1=-73.8, lon2=-1.141173, m12=4844148.703101, M12=0.650911, M21=0.651229, s12=5500000.0, S12=39735075134877.078125)
+# GeodesicSolve 'Test'@3: /opt/local/bin/GeodSolve -f -E -p 10 \ 40.600000000000001 -73.799999999999997 51.0 5500000.0 (Direct3)
+# GeodesicSolve 'Test'@3: '40.600000000000001 -73.799999999999997 51.000000000000000 51.884564505606761 -1.141172861200843 107.189397162605871 5500000.0000000000 49.475527463251460 4844148.7031014860 0.65091056699808614 0.65122865892196569 39735075134877.078' (0, stdout/-err)
+# GeodesicSolve 'Test'@3: lat1=40.600000000000001, lon1=-73.799999999999997, azi1=51.0, lat2=51.884564505606761, lon2=-1.141172861200843, azi2=107.189397162605871, s12=5500000.0, a12=49.47552746325146, m12=4844148.703101486, M12=0.65091056699808614, M21=0.65122865892196569, S12=39735075134877.078 (0)
+# Direct3: Destination3Tuple(lat=51.884565, lon=-1.141173, final=107.189397)
+# GeodesicSolve 'Test'@4: /opt/local/bin/GeodSolve -f -E -p 10 -i \ 40.600000000000001 -73.799999999999997 51.600000000000001 -0.5 (Inverse)
+# GeodesicSolve 'Test'@4: '40.600000000000001 -73.799999999999997 51.198882845579824 51.600000000000001 -0.500000000000000 107.821776735514248 5551759.4003186813 49.941310217899037 4877684.6027061967 0.64472969205948238 0.64504567852134398 40041368848742.531' (0, stdout/-err)
+# GeodesicSolve 'Test'@4: lat1=40.600000000000001, lon1=-73.799999999999997, azi1=51.198882845579824, lat2=51.600000000000001, lon2=-0.5, azi2=107.821776735514248, s12=5551759.4003186813, a12=49.941310217899037, m12=4877684.6027061967, M12=0.64472969205948238, M21=0.64504567852134398, S12=40041368848742.531 (0)
+
+# Inverse: GDict(a12=49.94131, azi1=51.198883, azi2=107.821777, lat1=40.6, lat2=51.6, lon1=-73.8, lon2=-0.5, m12=4877684.602706, M12=0.64473, M21=0.645046, s12=5551759.400319, S12=40041368848742.53125)
+# GeodesicSolve 'Test'@5: /opt/local/bin/GeodSolve -f -E -p 10 -i \ 40.600000000000001 -73.799999999999997 51.600000000000001 -0.5 (Inverse1)
+# GeodesicSolve 'Test'@5: '40.600000000000001 -73.799999999999997 51.198882845579824 51.600000000000001 -0.500000000000000 107.821776735514248 5551759.4003186813 49.941310217899037 4877684.6027061967 0.64472969205948238 0.64504567852134398 40041368848742.531' (0, stdout/-err)
+# GeodesicSolve 'Test'@5: lat1=40.600000000000001, lon1=-73.799999999999997, azi1=51.198882845579824, lat2=51.600000000000001, lon2=-0.5, azi2=107.821776735514248, s12=5551759.4003186813, a12=49.941310217899037, m12=4877684.6027061967, M12=0.64472969205948238, M21=0.64504567852134398, S12=40041368848742.531 (0)
+# Inverse1: 49.94131021789904
+# GeodesicSolve 'Test'@6: /opt/local/bin/GeodSolve -f -E -p 10 -i \ 40.600000000000001 -73.799999999999997 51.600000000000001 -0.5 (Inverse3)
+# GeodesicSolve 'Test'@6: '40.600000000000001 -73.799999999999997 51.198882845579824 51.600000000000001 -0.500000000000000 107.821776735514248 5551759.4003186813 49.941310217899037 4877684.6027061967 0.64472969205948238 0.64504567852134398 40041368848742.531' (0, stdout/-err)
+# GeodesicSolve 'Test'@6: lat1=40.600000000000001, lon1=-73.799999999999997, azi1=51.198882845579824, lat2=51.600000000000001, lon2=-0.5, azi2=107.821776735514248, s12=5551759.4003186813, a12=49.941310217899037, m12=4877684.6027061967, M12=0.64472969205948238, M21=0.64504567852134398, S12=40041368848742.531 (0)
+# Inverse3: Distance3Tuple(distance=5551759.400319, initial=51.198883, final=107.821777)
+
+# Position:    False GDict(a12=49.475527, azi1=51.0, azi2=107.189397, lat1=40.6, lat2=51.884565, lon1=-73.8, lon2=-1.141173, s12=5500000.0)
+# ArcPosition: False GDict(a12=49.475527, azi1=51.0, azi2=107.189397, lat1=40.6, lat2=51.884565, lon1=-73.8, lon2=-1.141174, s12=5499999.948497)
+
 # **) MIT License
 #
 # Copyright (C) 2016-2024 -- mrJean1 at Gmail -- All Rights Reserved.

pygeodesy/geohash.py

@@ -7,7 +7,7 @@ Class L{Geohash} and several functions to encode, decode and inspect
 C{geohashes} and optional L{Geohashed} caches.
 
 Originally transcoded from JavaScript originals by I{(C) Chris Veness
-2011-2015} and published under the same MIT Licence**, see
+2011-2024} and published under the same MIT Licence**, see
 U{Geohashes<https://www.Movable-Type.co.UK/scripts/geohash.html>}.
 
 @see: U{Geohash<https://WikiPedia.org/wiki/Geohash>}, I{Karney}'s C++
@@ -38,7 +38,7 @@ from pygeodesy.units import Degrees_, Int, Lat_, Lon_, Meter, Precision_, Str
 from math import fabs, ldexp, log10, radians
 
 __all__ = _ALL_LAZY.geohash
-__version__ = '24.08.05'
+__version__ = '24.10.12'
 
 _formy   = _MODS.into(formy=__name__)
 _MASK5   =  16, 8, 4, 2, 1  # PYCHOK used!

pygeodesy/geoids.py

@@ -15,7 +15,7 @@ The L{GeoidG2012B} and L{GeoidPGM} interpolators both depend on U{scipy
 require those packages to be installed.
 
 In addition, each geoid interpolator needs C{grid knots} (down)loaded from
-a C{geoid} model file, I{specific to the interpolator}, more details below
+a C{geoid} model file, I{specific to the interpolator}.  More details below
 and in the documentation of the interpolator class.  For each interpolator,
 there are several interpolation choices, like I{linear}, I{cubic}, etc.
 
@@ -42,7 +42,7 @@ C{>>> h = ginterpolator(ll)}
 
 or
 
-C{>>> h0, h1, h2, ... = ginterpolator(ll0, ll1, ll2, ...)}
+C{>>> h1, h2, h3, ... = ginterpolator(ll1, ll2, ll3, ...)}
 
 or a list, tuple, generator, etc. of C{LatLon}s
 
@@ -106,9 +106,9 @@ from pygeodesy.streprs import attrs, Fmt, fstr, pairs
 from pygeodesy.units import Height, Int_, Lat, Lon
 # from pygeodesy.utily import _Wrap  # from .heights
 
-from math import floor
-import os.path as _os_path
-from os import SEEK_CUR as _SEEK_CUR, SEEK_SET as _SEEK_SET
+from math import floor as _floor
+# from os import SEEK_CUR, SEEK_SET  # _MODS
+# import os.path  # _MODS
 from struct import calcsize as _calcsize, unpack as _unpack
 try:
     from StringIO import StringIO as _BytesIO  # reads bytes
@@ -118,7 +118,7 @@ except ImportError:  # Python 3+
     from io import BytesIO as _BytesIO  # PYCHOK expected
 
 __all__ = _ALL_LAZY.geoids
-__version__ = '24.08.24'
+__version__ = '24.11.05'
 
 _assert_         = 'assert'
 _bHASH_          = b'#'
@@ -159,7 +159,7 @@ class _GeoidBase(_HeightBase):
     _smooth   =  0      # used only for RectBivariateSpline
     _stdev    =  None   # fixed in GeoidKarney
     _u2B      =  0      # np.itemsize or undefined
-    _yx_hits  =  None   # cache hits, ala Karney
+    _yx_hits  =  None   # cache hits, ala Karney's
 
 #   _lat_d  = _0_0  # increment, +tive
 #   _lat_lo = _0_0  # lower lat, south
@@ -463,7 +463,7 @@ class _GeoidBase(_HeightBase):
 
     def _load(self, g, dtype, n, offset=0):
         # numpy.fromfile, like .frombuffer
-        g.seek(offset, _SEEK_SET)
+        g.seek(offset, _MODS.os.SEEK_SET)
         return self.numpy.fromfile(g, dtype, n)
 
     @Property_RO
@@ -545,8 +545,8 @@ class _GeoidBase(_HeightBase):
     def _open(self, geoid, datum, kind, name, smooth):
         # open the geoid file
         try:
-            self._geoid = _os_path.basename(geoid)
-            self._sizeB = _os_path.getsize(geoid)
+            self._geoid = _MODS.os.path.basename(geoid)
+            self._sizeB = _MODS.os.path.getsize(geoid)
             g = open(geoid, _rb_)
         except (IOError, OSError) as x:
             raise GeoidError(geoid=geoid, cause=x)
@@ -988,21 +988,21 @@ class GeoidKarney(_GeoidBase):
         p = self._pgm
         if 0 < x < (p.nlon - 2) and 0 < y < (p.nlat - 2):
             # read 4x4 ushorts, drop the 4 corners
-            g = self._egm
-            e = self._4endian
-            n = self._4u2B
-            R = self._Ru2B
-
-            b = self._seek(y - 1, x - 1)
+            S = _MODS.os.SEEK_SET
+            e =  self._4endian
+            g =  self._egm
+            n =  self._4u2B
+            R =  self._Ru2B
+            b =  self._seek(y - 1, x - 1)
             v = _unpack(e, g.read(n))[1:3]
             b += R
-            g.seek(b, _SEEK_SET)
+            g.seek(b, S)
             v += _unpack(e, g.read(n))
             b += R
-            g.seek(b, _SEEK_SET)
+            g.seek(b, S)
             v += _unpack(e, g.read(n))
             b += R
-            g.seek(b, _SEEK_SET)
+            g.seek(b, S)
             v += _unpack(e, g.read(n))[1:3]
             j = 1
 
@@ -1021,7 +1021,7 @@ class GeoidKarney(_GeoidBase):
     def _ev(self, lat, lon):  # PYCHOK expected
         # interpolate the geoid height at grid (lat, lon)
         fy, fx = self._g2yx2(lat, lon)
-        y, x = int(floor(fy)), int(floor(fx))
+        y, x = int(_floor(fy)), int(_floor(fx))
         fy -= y
         fx -= x
         H  = self._ev2d(fy, fx, y, x)  # PYCHOK ._ev2k or ._ev3k
@@ -1223,7 +1223,7 @@ class GeoidKarney(_GeoidBase):
         p, g = self._pgm, self._egm
         if g:
             b = p.skip + (y * p.nlon + x) * self._u2B
-            g.seek(b, _SEEK_SET)
+            g.seek(b, _MODS.os.SEEK_SET)
             return b  # position
         raise GeoidError('closed file', txt=repr(p.egm))  # IOError
 
@@ -1551,11 +1551,11 @@ class _PGM(_Gpars):
         t, c = 0, self._tmpfile()
         # reading (s - n) rows, forward
         for y in range(n, s):  # PYCHOK y unused
-            g.seek(z, _SEEK_SET)
+            g.seek(z, _MODS.os.SEEK_SET)
             # Python 2 tmpfile.write returns None
             t += c.write(g.read(r)) or r
             if p:  # wrap around to start of row
-                g.seek(-q, _SEEK_CUR)
+                g.seek(-q, _MODS.os.SEEK_CUR)
                 # assert(g.tell() == (z - w * self.u2B))
                 # Python 2 tmpfile.write returns None
                 t += c.write(g.read(p)) or p
@@ -1582,7 +1582,7 @@ class _PGM(_Gpars):
         self.knots = k
         self.skip  = 0  # no header lines in c
 
-        c.seek(0, _SEEK_SET)
+        c.seek(0, _MODS.os.SEEK_SET)
         # c = open(c.name, _rb_)  # reopen for numpy 1.8.0-
         return c
 
@@ -1606,10 +1606,11 @@ class _PGM(_Gpars):
         try:
             from tempfile import NamedTemporaryFile as tmpfile
         except ImportError:  # Python 2.7.16-
-            from os import tmpfile
-        t = _os_path.splitext(_os_path.basename(self.pgm))[0]
-        f = tmpfile(mode='w+b', prefix=t or 'egm')
-        f.seek(0, _SEEK_SET)  # force overwrite
+            from _MODS.os import tmpfile
+        t = _MODS.os.path.basename(self.pgm)
+        t = _MODS.os.path.splitext(t)[0]
+        f =  tmpfile(mode='w+b', prefix=t or 'egm')
+        f.seek(0, _MODS.os.SEEK_SET)  # force overwrite
         return f
 
     @Property_RO
@@ -1620,7 +1621,7 @@ class _PGM(_Gpars):
 
 
 class PGMError(GeoidError):
-    '''Issue parsing or cropping an C{egm*.pgm} geoid dataset.
+    '''An issue while parsing or cropping an C{egm*.pgm} geoid dataset.
     '''
     pass
 
@@ -1649,7 +1650,7 @@ def egmGeoidHeights(GeoidHeights_dat):
         dat = _BytesIO(dat)
 
     try:
-        dat.seek(0, _SEEK_SET)  # reset
+        dat.seek(0, _MODS.os.SEEK_SET)  # reset
     except AttributeError as x:
         raise GeoidError(GeoidHeights_dat=type(dat), cause=x)
 
@@ -1666,7 +1667,7 @@ __all__ += _ALL_DOCS(_GeoidBase)
 
 if __name__ == '__main__':  # MCCABE 14
 
-    from pygeodesy.internals import printf, _secs2str, _sys, _versions
+    from pygeodesy.internals import printf, _secs2str, _versions,  _sys
     from time import time
 
     _crop     = ()

pygeodesy/heights.py

@@ -91,7 +91,7 @@ from pygeodesy.units import _isDegrees, Float_, Int_
 # from math import radians  # from .points
 
 __all__ = _ALL_LAZY.heights
-__version__ = '24.08.24'
+__version__ = '24.11.02'
 
 _error_  = 'error'
 _formy   = _MODS.into(formy=__name__)
@@ -1031,7 +1031,7 @@ class HeightIDWkarney(_HeightIDW):
        <https://WikiPedia.org/wiki/Inverse_distance_weighting>} (IDW) and the
        I{angular} distance in C{degrees} from I{Karney}'s U{geographiclib
        <https://PyPI.org/project/geographiclib>} method U{Geodesic.Inverse
-       <https://geographiclib.sourceforge.io/Python/doc/code.html#
+       <https://GeographicLib.SourceForge.io/Python/doc/code.html#
        geographiclib.geodesic.Geodesic.Inverse>}.
     '''
     def __init__(self, knots, beta=2, datum=None, **name__wrap):