pygeodesy 24.9.29__py2.py3-none-any.whl → 24.10.24__py2.py3-none-any.whl

pygeodesy/mgrs.py

@@ -55,7 +55,7 @@ from pygeodesy.utm import toUtm8, _to3zBlat, Utm, _UTM_ZONE_MAX, _UTM_ZONE_MIN
 # from pygeodesy.utmupsBase import _UTM_ZONE_MAX, _UTM_ZONE_MIN  # from .utm
 
 __all__ = _ALL_LAZY.mgrs
-__version__ = '24.09.04'
+__version__ = '24.10.13'
 
 _AN_    = 'AN'  # default south pole grid tile and band B
 _AtoPx_ = _AtoZnoIO_.tillP
@@ -654,32 +654,32 @@ if __name__ == '__main__':
 
     def _main():
 
-        from pygeodesy.ellipsoidalVincenty import fabs, LatLon
+        from pygeodesy.ellipsoidalVincenty import LatLon,  fabs
         from pygeodesy.internals import _fper, printf
-        from pygeodesy.lazily import _getenv, _PYGEODESY_GEOCONVERT_
+        from pygeodesy.karney import _Xables
 
 #       from math import fabs  # from .ellipsoidalVincenty
-        from os import access as _access, linesep as _NL, X_OK as _X_OK
 
         # <https://GeographicLib.sourceforge.io/C++/doc/GeoConvert.1.html>
-        _GeoConvert = _getenv(_PYGEODESY_GEOCONVERT_, '/opt/local/bin/GeoConvert')
-        if _access(_GeoConvert, _X_OK):
-            GC_m = _GeoConvert, '-m'  # -m converts latlon to MGRS
-            printf(' using: %s ...', _SPACE_.join(GC_m))
-            from pygeodesy.solveBase import _popen2
+        G = _Xables.GeoConvert(_Xables.bin_)
+        if _Xables.X_OK(G):
+            from pygeodesy.internals import _popen2
+            printf(' using: %s', _Xables.name_version(G, base=False))
+            cmd = G, '-m'  # -m converts latlon to MGRS
         else:
-            GC_m = _popen2 = None
+            printf(' sorry: %s', _Xables.X_not(G))
+            cmd = _popen2 = None
 
         e = n = 0
         try:
             for lat in range(-90, 91, 1):
                 printf('%6s: lat %s ...', n, lat, end=NN, flush=True)
-                nl = _NL
+                nl = _MODS.os.linesep
                 for lon in range(-180, 181, 1):
                     m = LatLon(lat, lon).toMgrs()
-                    if _popen2:
+                    if _popen2:  # and cmd
                         t = '%s %s' % (lat, lon)
-                        g = _popen2(GC_m, stdin=t)[1]
+                        g = _popen2(cmd, stdin=t)[0]
                         t =  m.toStr()  # sep=NN
                         if t != g:
                             e += 1

pygeodesy/named.py

@@ -20,13 +20,14 @@ from pygeodesy.errors import _AssertionError, _AttributeError, _incompatible, \
                              _NotImplementedError, _TypeError, _TypesError, \
                              _UnexpectedError, UnitError, _ValueError, \
                              _xattr, _xkwds, _xkwds_item2, _xkwds_pop2
-from pygeodesy.internals import _caller3, _dunder_nameof, _isPyPy, _sizeof, _under
+from pygeodesy.internals import _caller3, _DUNDER_nameof, _getPYGEODESY, _isPyPy, \
+                                _sizeof, _under
 from pygeodesy.interns import MISSING, NN, _AT_, _COLON_, _COLONSPACE_, _COMMA_, \
                              _COMMASPACE_, _doesn_t_exist_, _DOT_, _DUNDER_, \
-                             _dunder_name_, _EQUAL_, _exists_, _immutable_, _name_, \
+                             _DUNDER_name_, _EQUAL_, _exists_, _immutable_, _name_, \
                              _NL_, _NN_, _no_, _other_, _s_, _SPACE_, _std_, \
                              _UNDER_, _vs_
-from pygeodesy.lazily import _ALL_DOCS, _ALL_LAZY, _ALL_MODS as _MODS, _getenv
+from pygeodesy.lazily import _ALL_DOCS, _ALL_LAZY, _ALL_MODS as _MODS
 from pygeodesy.props import _allPropertiesOf_n, deprecated_method, _hasProperty, \
                             _update_all, property_doc_, Property_RO, property_RO, \
                             _update_attrs
@@ -34,7 +35,7 @@ from pygeodesy.streprs import attrs, Fmt, lrstrip, pairs, reprs, unstr
 # from pygeodesy.units import _toUnit  # _MODS
 
 __all__ = _ALL_LAZY.named
-__version__ = '24.09.02'
+__version__ = '24.10.14'
 
 _COMMANL_           = _COMMA_ + _NL_
 _COMMASPACEDOT_     = _COMMASPACE_ + _DOT_
@@ -45,7 +46,7 @@ _MRO_               = 'MRO'
 _name               = _under(_name_)
 _Names_             = '_Names_'
 _registered_        = 'registered'  # PYCHOK used!
-_std_NotImplemented = _getenv('PYGEODESY_NOTIMPLEMENTED', NN).lower() == _std_
+_std_NotImplemented = _getPYGEODESY('NOTIMPLEMENTED', NN).lower() == _std_
 _such_              = 'such'
 _Units_             = '_Units_'
 _UP                 =  2
@@ -614,7 +615,7 @@ class _NamedEnum(_NamedDict):
            @arg Classes: Additional, acceptable classes or C{type}s.
         '''
         self._item_Classes = (Class,) + Classes
-        n = _name__(**name) or NN(Class.__name__, _s_)  # _dunder_nameof
+        n = _name__(**name) or NN(Class.__name__, _s_)  # _DUNDER_nameof
         if n and _xvalid(n, underOK=True):
             _Named.name.fset(self, n)  # see _Named.name
 
@@ -1237,7 +1238,7 @@ def modulename(clas, prefixed=None):  # in .basics._xversion
     try:
         n = clas.__name__
     except AttributeError:
-        n = clas if isstr(clas) else _dunder_name_
+        n = clas if isstr(clas) else _DUNDER_name_
     if prefixed or (classnaming() if prefixed is None else False):
         try:
             m =  clas.__module__.rsplit(_DOT_, 1)
@@ -1256,7 +1257,7 @@ def modulename(clas, prefixed=None):  # in .basics._xversion
 #     if name:  # is given
 #         n = _name__(**name) if isinstance(name, dict) else str(name)
 #     elif name__ is not None:
-#         n = getattr(name__, _dunder_name_, NN)  # _xattr(name__, __name__=NN)
+#         n = getattr(name__, _DUNDER_name_, NN)  # _xattr(name__, __name__=NN)
 #     else:
 #         n = name  # NN or None or {} or any False type
 #     if _or_nameof is not None and not n:
@@ -1293,7 +1294,7 @@ def _name2__(name=NN, name__=None, _or_nameof=None, **kwds):
         else:
             n = str(name)
     elif name__ is not None:
-        n = _dunder_nameof(name__, NN)
+        n = _DUNDER_nameof(name__, NN)
     else:
         n = name if name is None else NN
     if _or_nameof is not None and not n:
@@ -1328,7 +1329,7 @@ def _notDecap(where):
 def _notError(inst, name, args, kwds):  # PYCHOK no cover
     '''(INTERNAL) Format an error message.
     '''
-    n = _DOT_(classname(inst, prefixed=True), _dunder_nameof(name, name))
+    n = _DOT_(classname(inst, prefixed=True), _DUNDER_nameof(name, name))
     m = _COMMASPACE_.join(modulename(c, prefixed=True) for c in inst.__class__.__mro__[1:-1])
     return _COMMASPACE_(unstr(n, *args, **kwds), Fmt.PAREN(_MRO_, m))
 

pygeodesy/nvectorBase.py

@@ -38,7 +38,7 @@ from pygeodesy.vector3d import Vector3d, _xyzhdlln4
 from math import fabs, sqrt
 
 __all__ = _ALL_LAZY.nvectorBase
-__version__ = '24.07.12'
+__version__ = '24.10.12'
 
 
 class NvectorBase(Vector3d):  # XXX kept private

pygeodesy/points.py

@@ -62,7 +62,7 @@ from pygeodesy.utily import atan2b, degrees90, degrees180, degrees2m, \
 from math import cos, fabs, fmod as _fmod, radians, sin
 
 __all__ = _ALL_LAZY.points
-__version__ = '24.09.23'
+__version__ = '24.10.24'
 
 _ilat_  = 'ilat'
 _ilon_  = 'ilon'
@@ -147,7 +147,7 @@ class LatLon_(LatLonBase):  # XXX in heights._HeightBase.height
            @kwarg wrap: If C{True}, wrap or I{normalize} and unroll
                         the B{C{other}} point (C{bool}).
 
-           @return: Intermediate point (this C{LatLon}).
+           @return: Intermediate point (same C{LatLon} class).
 
            @raise TypeError: Incompatible B{C{other}} C{type}.
         '''

pygeodesy/props.py

@@ -12,22 +12,24 @@ choices, see callable L{DeprecationWarnings} below.
 
 from pygeodesy.basics import isclass as _isclass
 from pygeodesy.errors import _AssertionError, _AttributeError, \
-                             _xcallable, _xkwds, _xkwds_get
+                             _xcallable, _xkwds_get
+# from pygeodesy.internals import _tailof  # from .lazily
 from pygeodesy.interns import MISSING, NN, _an_, _COMMASPACE_, \
                              _DEPRECATED_, _DOT_, _EQUALSPACED_, \
-                             _immutable_, _invalid_, _module_, _N_A_, \
-                             _not_, _SPACE_, _UNDER_,  _DNL_  # PYCHOK used!
+                             _immutable_, _invalid_, _module_, \
+                             _N_A_, _NL_, _not_, _SPACE_, _UNDER_
 # from pygeodesy.named import callname  # _MODS, avoid circular
 from pygeodesy.lazily import _ALL_LAZY, _ALL_MODS as _MODS, \
-                             _FOR_DOCS, _WARNINGS_X_DEV
+                             _FOR_DOCS, _WARNINGS_X_DEV,  _tailof
 # from pygeodesy.streprs import Fmt  # _MODS
 
 from functools import wraps as _wraps
 
 __all__ = _ALL_LAZY.props
-__version__ = '24.09.02'
+__version__ = '24.10.19'
 
 _class_       = 'class'
+_DNL_         = _NL_ * 2  # PYCHOK used!
 _dont_use_    = _DEPRECATED_ + ", don't use."
 _function_    = 'function'
 _has_been_    = 'has been'  # PYCHOK used!
@@ -650,23 +652,42 @@ class DeprecationWarnings(object):
         '''
         return self.Warnings
 
+    @property_ROver
+    def _Fmt(self):
+        '''Get C{streprs.Fmt}, I{once}.
+        '''
+        return _MODS.streprs.Fmt
+
+    @property_ROver
+    def _stacklevel3(self):
+        '''Get C{dict(stacklevel=3)}, I{once}.
+        '''
+        return dict(stacklevel=3)
+
     def throw(self, kind, name, doc, **stacklevel):  # stacklevel=3
         '''Report or raise a C{DeprecationWarning}.
+
+           @arg kind: Warning kind (C{str}), C{"method"}, C{"funtion"}, ...
+           @arg name: Qualified name (C{str}) of B{C{kind}}.
+           @arg doc: The __doc__ (C{str}) of B{C{kind}}, C{"DEPRECATED ...}.
         '''
-        line =  doc.split(_DNL_, 1)[0].strip()
-        name = _MODS.streprs.Fmt.CURLY(L=name)
-        text = _SPACE_(kind, name, _has_been_, *line.split())
-        kwds = _xkwds(stacklevel, stacklevel=3)
+        link = _tailof(name) or name
+        if link is not name:  # make "link<name>"
+            link = self._Fmt.ANGLE(link, name)
+        link =  self._Fmt.CURLY(L=link)  # "L{link}"
+        text =  doc.split(_DNL_, 1)[0].strip()
+        text = _SPACE_(kind, link, _has_been_, *text.split())
+        kwds =  stacklevel if stacklevel else self._stacklevel3
         # XXX invoke warn or raise DeprecationWarning(text)
         self._warn(text, category=DeprecationWarning, **kwds)
         self._Warnings += 1
 
-    @Property_RO
+    @property_ROver
     def _warn(self):
-        '''Get Python's C{warnings.warn}.
+        '''Get Python's C{warnings.warn} function, I{once}.
         '''
-        from warnings import warn
-        return warn
+        from warnings import warn as w
+        return w
 
     @property_RO
     def Warnings(self):

pygeodesy/rhumb/bases.py

@@ -33,7 +33,7 @@ from pygeodesy.errors import IntersectionError, RhumbError, _xdatum, \
 from pygeodesy.fmath import euclid, favg, sqrt_a,  Fsum
 # from pygeodesy.formy import opposing  # _MODS
 # from pygeodesy.fsums import Fsum  # from .fmath
-from pygeodesy.internals import _dunder_nameof, _under
+from pygeodesy.internals import _DUNDER_nameof, _under
 from pygeodesy.interns import NN, _coincident_, _COMMASPACE_, _Dash, \
                              _parallel_, _too_
 from pygeodesy.karney import _atan2d, Caps, _CapsBase, _diff182, _fix90, \
@@ -52,7 +52,7 @@ from pygeodesy.vector3d import _intersect3d3, Vector3d  # in .Intersection below
 from math import cos, fabs
 
 __all__ = ()
-__version__ = '24.06.18'
+__version__ = '24.10.14'
 
 _anti_ = _Dash('anti')
 _rls   = []  # instances of C{RbumbLine...} to be updated
@@ -634,7 +634,7 @@ class RhumbLineBase(_CapsBase):
         t = dict(lat3=q.lat2, lon3=q.lon2, azi03=q.azi02, a03=q.a02, s03=a)
         if a < r:
             t.update(iteration=q.iteration, lat0=q.lat1, lon0=q.lon1,  # or lat0, lon0
-                     name=_dunder_nameof(self.Intersecant2, self.name))
+                     name=_DUNDER_nameof(self.Intersecant2, self.name))
             if fabs(a) < EPS0:  # coincident centers
                 d, h = _0_0, r
             else:
@@ -723,7 +723,7 @@ class RhumbLineBase(_CapsBase):
 
             P = GDict(lat1=self.lat1, lat2=p.lat, lat0=other.lat1,
                       lon1=self.lon1, lon2=p.lon, lon0=other.lon1,
-                      name=_dunder_nameof(self.Intersection, self.name))
+                      name=_DUNDER_nameof(self.Intersection, self.name))
             r =  self.Inverse(p.lat, p.lon, outmask=Caps.DISTANCE)
             t = other.Inverse(p.lat, p.lon, outmask=Caps.DISTANCE)
             P.set_(azi12= self.azi12, a12=r.a12, s12=r.s12,
@@ -897,7 +897,7 @@ class RhumbLineBase(_CapsBase):
                         break
                 P.set_(azi0=r.azi1, a02=r.a12, s02=r.s12,  # azi2=r.azi2,
                        lat0=lat0, lon0=lon0, iteration=i, at=r.azi2 - self.azi12,
-                       name=_dunder_nameof(self.PlumbTo, self.name))
+                       name=_DUNDER_nameof(self.PlumbTo, self.name))
             except Exception as x:  # Fsum(NAN) Value-, ZeroDivisionError
                 raise IntersectionError(lat0=lat0, lon0=lon0, tol=tol, exact=exact,
                                         eps=eps, est=est, iteration=i, cause=x)

pygeodesy/rhumb/solve.py

@@ -12,16 +12,15 @@ from pygeodesy.basics import _xinstanceof
 from pygeodesy.constants import _0_0, _180_0, _N_180_0, _over,  _90_0  # PYCHOK used!
 from pygeodesy.errors import RhumbError   # PYCHOK used!
 from pygeodesy.interns import NN, _a12_, _azi12_, _lat2_, _lon2_, _s12_, _S12_, _UNDER_
-from pygeodesy.karney import Caps, GDict, _norm180, Rhumb8Tuple, _sincos2d
-from pygeodesy.lazily import _ALL_DOCS, _ALL_LAZY, _ALL_MODS as _MODS, _getenv, \
-                             _PYGEODESY_RHUMBSOLVE_
+from pygeodesy.karney import Caps, GDict, _norm180, Rhumb8Tuple, _sincos2d, _Xables
+from pygeodesy.lazily import _ALL_DOCS, _ALL_LAZY, _ALL_MODS as _MODS
 from pygeodesy.namedTuples import Destination3Tuple, Distance3Tuple
 from pygeodesy.props import deprecated_method, Property, Property_RO
 from pygeodesy.solveBase import _SolveGDictBase, _SolveGDictLineBase
 from pygeodesy.utily import _unrollon, _Wrap, wrap360
 
 __all__ = _ALL_LAZY.rhumb_solve
-__version__ = '24.08.13'
+__version__ = '24.10.12'
 
 
 class _RhumbSolveBase(_SolveGDictBase):
@@ -30,8 +29,8 @@ class _RhumbSolveBase(_SolveGDictBase):
     _Error         =  RhumbError
     _Names_Direct  = _lat2_, _lon2_, _S12_
     _Names_Inverse = _azi12_, _s12_, _S12_
-    _Xable_name    = 'RhumbSolve'
-    _Xable_path    = _getenv(_PYGEODESY_RHUMBSOLVE_, _PYGEODESY_RHUMBSOLVE_)
+    _Xable_name    = _Xables.RhumbSolve.__name__
+    _Xable_path    = _Xables.RhumbSolve()
 
     @Property_RO
     def _cmdBasic(self):
@@ -394,8 +393,8 @@ if __name__ == '__main__':
     rS = RhumbSolve(name='Test')
     rS.verbose = '--verbose' in argv  # or '-v' in argv
 
-    if rS.RhumbSolve in (_PYGEODESY_RHUMBSOLVE_, None):  # not set
-        rS.RhumbSolve = '/opt/local/bin/RhumbSolve'  # '/opt/local/Cellar/geographiclib/2.3/bin/RhumbSolve'  # HomeBrew
+    if not _Xables.X_OK(rS.RhumbSolve):  # not set
+        rS.RhumbSolve = _Xables.RhumbSolve(_Xables.bin_)
     printf('version: %s', rS.version)
 
     if len(argv) > 6:  # 60 0 30 0 45 1e6

pygeodesy/solveBase.py

@@ -4,36 +4,28 @@
 u'''(INTERNAL) Private base classes for L{pygeodesy.geodsolve} and L{pygeodesy.rhumb.solve}.
 '''
 
-from pygeodesy.basics import clips, map2, ub2str, _zip
+from pygeodesy.basics import clips, map2, _zip
 from pygeodesy.constants import DIG
 from pygeodesy.datums import _earth_datum, _WGS84,  _EWGS84
 # from pygeodesy.ellipsoids import _EWGS84  # from .datums
 from pygeodesy.errors import _AssertionError, _xkwds_get, _xkwds_get1, \
                              _xkwds_item2
-from pygeodesy.internals import _enquote, printf
+from pygeodesy.internals import _enquote, _popen2, printf
 from pygeodesy.interns import NN, _0_, _AT_,_BACKSLASH_, _COLONSPACE_, \
                              _COMMASPACE_, _EQUAL_, _Error_, _SPACE_, \
                              _UNUSED_
 from pygeodesy.karney import Caps, _CapsBase, GDict
-from pygeodesy.lazily import _ALL_DOCS, _ALL_LAZY, _sys_version_info2
+from pygeodesy.lazily import _ALL_DOCS, _ALL_LAZY
 from pygeodesy.named import callername, _name2__, notOverloaded
 from pygeodesy.props import Property, Property_RO, property_RO, _update_all
 from pygeodesy.streprs import Fmt, fstr, fstrzs, pairs, strs
 from pygeodesy.units import Precision_
 from pygeodesy.utily import unroll180,  wrap360  # PYCHOK shared
 
-from subprocess import PIPE as _PIPE, Popen as _Popen, STDOUT as _STDOUT
-
 __all__ = _ALL_LAZY.solveBase
-__version__ = '24.07.11'
+__version__ = '24.10.13'
 
-_ERROR_     = 'ERROR'
-_Popen_kwds =  dict(creationflags=0,
-                  # executable=sys.executable, shell=True,
-                    stdin=_PIPE, stdout=_PIPE, stderr=_STDOUT)
-if _sys_version_info2 > (3, 6):
-    _Popen_kwds.update(text=True)
-del _PIPE, _STDOUT, _sys_version_info2  # _ALL_LAZY
+_ERROR_ = 'ERROR'
 
 
 def _cmd_stdin_(cmd, stdin):  # PYCHOK no cover
@@ -53,15 +45,6 @@ def _cmd_stdin_(cmd, stdin):  # PYCHOK no cover
 #     return i if float(i) == f else f  # PYCHOK inconsistent
 
 
-def _popen2(cmd, stdin=None):  # in .mgrs, test.bases, .testMgrs
-    '''(INTERNAL) Invoke C{B{cmd} tuple} and return C{exitcode}
-       and all output from C{stdout/-err}, I{stripped}.
-    '''
-    p = _Popen(cmd, **_Popen_kwds)  # PYCHOK kwArgs
-    r =  p.communicate(stdin)[0]  # stdout + NL + stderr
-    return p.returncode, ub2str(r).strip()
-
-
 class _SolveCapsBase(_CapsBase):
     '''(NTERNAL) Base class for C{_SolveBase} and C{_LineSolveBase}.
     '''
@@ -85,8 +68,7 @@ class _SolveCapsBase(_CapsBase):
         return self.ellipsoid.a
 
     @property_RO
-    def _cmdBasic(self):  # PYCHOK no cover
-        '''(INTERNAL) I{Must be overloaded}.'''
+    def _cmdBasic(self):  # PYCHOK no covers        '''(INTERNAL) I{Must be overloaded}.'''
         notOverloaded(self, underOK=True)
 
     @property_RO
@@ -228,7 +210,7 @@ class _SolveCapsBase(_CapsBase):
             t = _cmd_stdin_(cmd, stdin)
             self._print(t)
         try:  # invoke and write to stdin
-            s, r = _popen2(cmd, stdin)
+            r, s = _popen2(cmd, stdin)
             if len(r) < 6 or r[:5] in (_Error_, _ERROR_):
                 raise ValueError(r)
         except (IOError, OSError, TypeError, ValueError) as x:

pygeodesy/sphericalBase.py

@@ -5,7 +5,7 @@ u'''(INTERNAL) Private spherical base classes C{CartesianSphericalBase} and
 C{LatLonSphericalBase} for L{sphericalNvector} and L{sphericalTrigonometry}.
 
 A pure Python implementation of geodetic (lat-/longitude) functions,
-transcoded in part from JavaScript originals by I{(C) Chris Veness 2011-2016}
+transcoded in part from JavaScript originals by I{(C) Chris Veness 2011-2024}
 and published under the same MIT Licence**, see
 U{Latitude/Longitude<https://www.Movable-Type.co.UK/scripts/latlong.html>}.
 '''
@@ -40,7 +40,7 @@ from pygeodesy.utily import acos1, asin1, atan2b, atan2d, degrees90, \
 from math import cos, fabs, log, sin, sqrt
 
 __all__ = _ALL_LAZY.sphericalBase
-__version__ = '24.08,13'
+__version__ = '24.10.19'
 
 
 class CartesianSphericalBase(CartesianBase):
@@ -126,24 +126,23 @@ class LatLonSphericalBase(LatLonBase):
            @kwarg lon: Longitude (C{degrees} or DMS C{str} with E or W suffix) or
                        C(None), indicating B{C{latlonh}} is a C{LatLon}.
            @kwarg height: Optional height above (or below) the earth surface (C{meter},
-                          same units as the datum's ellipsoid axes or radius).
+                          same units as the datum's radius or axes).
            @kwarg datum: Optional, spherical datum to use (L{Datum}, L{Ellipsoid},
-                         L{Ellipsoid2}, L{a_f2Tuple}) or earth radius in C{meter},
-                         conventionally).
+                         L{Ellipsoid2}, L{a_f2Tuple}) or the mean earth radius
+                         (C{meter}, conventionally).
            @kwarg wrap: If C{True}, wrap or I{normalize} B{C{lat}} and B{C{lon}}
                         (C{bool}).
            @kwarg name: Optional C{B{name}=NN} (C{str}).
 
-           @raise TypeError: If B{C{latlonh}} is not a C{LatLon} or B{C{datum}} not
-                             spherical.
+           @raise TypeError: Invalid B{C{latlonh}} or B{C{datum}} not spherical.
         '''
         LatLonBase.__init__(self, latlonh, lon=lon, height=height, wrap=wrap, **name)
         if datum not in (None, self.datum):
             self.datum = datum
 
     def bearingTo2(self, other, wrap=False, raiser=False):
-        '''Return the initial and final bearing (forward and reverse
-           azimuth) from this to an other point.
+        '''Return the initial and final bearing (forward and reverse azimuth)
+           from this to an other point.
 
            @arg other: The other point (C{LatLon}).
            @kwarg wrap: If C{True}, wrap or I{normalize} and unroll the
@@ -204,10 +203,10 @@ class LatLonSphericalBase(LatLonBase):
 
            @arg circle: Radius of the circle centered at this location (C{meter},
                         same units as B{C{radius}}) or a point on the circle
-                        (this C{LatLon}).
-           @arg point: A point on the (great circle) line (this C{LatLon}).
-           @arg other: An other point I{on} (this {LatLon}) or the bearing at
-                       B{C{point}} I{of} the (great circle) line (compass
+                        (same C{LatLon} class).
+           @arg point: A point on the (great circle) line (same C{LatLon} class).
+           @arg other: An other point I{on} (same C{LatLon} class) or the bearing
+                       at B{C{point}} I{of} the (great circle) line (compass
                        C{degrees}).
            @kwarg radius: Mean earth radius (C{meter}, conventionally).
            @kwarg exact: If C{True}, use the I{exact} rhumb methods for azimuth,
@@ -216,8 +215,8 @@ class LatLonSphericalBase(LatLonBase):
                          circle} methods.
            @kwarg height: Optional height for the intersection points (C{meter},
                           conventionally) or C{None} for interpolated heights.
-           @kwarg wrap: If C{True}, wrap or I{normalize} and unroll the points
-                        B{C{circle}}, B{C{point}} and/or B{C{other}} (C{bool}).
+           @kwarg wrap: If C{True}, wrap or I{normalize} and unroll B{C{circle}},
+                         B{C{point}} and B{C{other}} iff points (C{bool}).
 
            @return: 2-Tuple of the intersection points (representing a chord), each
                     an instance of the B{C{point}} class.  Both points are the same
@@ -225,8 +224,7 @@ class LatLonSphericalBase(LatLonBase):
 
            @raise IntersectionError: The circle and line do not intersect.
 
-           @raise TypeError: If B{C{point}} is not this C{LatLon} or B{C{circle}}
-                             or B{C{other}} invalid.
+           @raise TypeError: Invalid B{C{point}}, B{C{circle}} or B{C{other}}.
 
            @raise UnitError: Invalid B{C{circle}}, B{C{other}}, B{C{radius}},
                              B{C{exact}}, B{C{height}} or B{C{napieradius}}.
@@ -469,8 +467,8 @@ class LatLonSphericalBase(LatLonBase):
 
            @arg circle: Radius of the circle centered at this location (C{meter},
                         same units as B{C{radius}}) or a point on the circle
-                        (this C{LatLon}).
-           @arg point: The rhumb line's start point (this C{LatLon}).
+                        (same C{LatLon} class).
+           @arg point: The rhumb line's start point (same C{LatLon} class).
            @arg other: An other point (this I{on} C{LatLon}) or the azimuth I{of}
                        (compass C{degrees}) the rhumb line.
            @kwarg radius: Mean earth radius (C{meter}, conventionally).
@@ -489,8 +487,7 @@ class LatLonSphericalBase(LatLonBase):
 
            @raise IntersectionError: The circle and line do not intersect.
 
-           @raise TypeError: If B{C{point}} is not this C{LatLon} or B{C{circle}}
-                             or B{C{other}} invalid.
+           @raise TypeError: Invalid B{C{point}}, B{C{circle}} or B{C{other}}.
 
            @raise UnitError: Invalid B{C{circle}}, B{C{other}}, B{C{radius}},
                              B{C{exact}} or B{C{height}}.
@@ -502,8 +499,8 @@ class LatLonSphericalBase(LatLonBase):
 
     def rhumbMidpointTo(self, other, height=None, radius=R_M, exact=False,
                                                 fraction=_0_5, **wrap_name):
-        '''Return the (loxodromic) midpoint on the rhumb line between
-           this and an other point.
+        '''Return the (loxodromic) midpoint on the rhumb line between this
+           and an other point.
 
            @arg other: The other point (spherical LatLon).
            @kwarg height: Optional height, overriding the mean height (C{meter}).

pygeodesy/sphericalNvector.py

@@ -9,7 +9,7 @@ L{meanOf}, L{nearestOn3}, L{perimeterOf}, L{sumOf}, L{triangulate} and
 L{trilaterate}, I{all spherical}.
 
 Pure Python implementation of n-vector-based spherical geodetic (lat-/longitude)
-methods, transcoded from JavaScript originals by I{(C) Chris Veness 2011-2016},
+methods, transcoded from JavaScript originals by I{(C) Chris Veness 2011-2024},
 published under the same MIT Licence**.  See U{Vector-based geodesy
 <https://www.Movable-Type.co.UK/scripts/latlong-vectors.html>} and
 U{Module latlon-nvector-spherical
@@ -61,7 +61,7 @@ from pygeodesy.utily import atan2, degrees360, fabs, sincos2, sincos2_, \
 # from math import atan2, fabs  # from utily
 
 __all__ = _ALL_LAZY.sphericalNvector
-__version__ = '24.09.23'
+__version__ = '24.10.19'
 
 _lines_ = 'lines'
 
@@ -797,7 +797,7 @@ class Nvector(NvectorBase):
         return n.minus(e)
 
 
-_Nvll = LatLon(_0_0, _0_0, name=_Nv00_)  # reference instance (L{LatLon})
+_Nv00 = LatLon(_0_0, _0_0, name=_Nv00_)  # reference instance (L{LatLon})
 
 
 def areaOf(points, radius=R_M, wrap=False):
@@ -821,7 +821,7 @@ def areaOf(points, radius=R_M, wrap=False):
              and L{ellipsoidalKarney.areaOf}.
     '''
     def _interangles(ps, w):  # like .karney._polygon
-        Ps = _Nvll.PointsIter(ps, loop=2, wrap=w)
+        Ps = _Nv00.PointsIter(ps, loop=2, wrap=w)
         # use vector to 1st point as plane normal for sign of α
         n0 =  Ps[0].toNvector()
 
@@ -858,13 +858,14 @@ def intersecant2(center, circle, point, other, **radius_exact_height_wrap):
        two points or as a point and bearing.
 
        @arg center: Center of the circle (L{LatLon}).
-       @arg circle: Radius of the circle (C{meter}, same units as B{C{radius}})
-                    or a point on the circle (L{LatLon}).
+       @arg circle: Radius of the circle (C{meter}, same units as the earth
+                    B{C{radius}}) or a point on the circle (L{LatLon}).
        @arg point: A point on the (great circle) line (L{LatLon}).
        @arg other: An other point on the (great circle) line (L{LatLon}) or
                    the bearing at the B{C{point}} (compass C{degrees360}).
-       @kwarg radius_exact_height_wrap: Optional keyword arguments, see
-                     method L{LatLon.intersecant2} for further details.
+       @kwarg radius_exact_height_wrap: Optional keyword arguments, see method
+                     L{intersecant2<pygeodesy.sphericalBase.LatLonSphericalBase.
+                     intersecant2>} for further details.
 
        @return: 2-Tuple of the intersection points (representing a chord), each
                 an instance of the B{C{point}} class.  Both points are the same
@@ -872,14 +873,14 @@ def intersecant2(center, circle, point, other, **radius_exact_height_wrap):
 
        @raise IntersectionError: The circle and line do not intersect.
 
-       @raise TypeError: If B{C{center}} or B{C{point}} not L{LatLon} or
-                         B{C{circle}} or B{C{other}} invalid.
+       @raise TypeError: If B{C{center}}, B{C{point}}, B{C{circle}} or B{C{other}}
+                         not L{LatLon}.
 
        @raise UnitError: Invalid B{C{circle}}, B{C{other}}, B{C{radius}},
                          B{C{exact}}, B{C{height}} or B{C{napieradius}}.
     '''
-    c = _Nvll.others(center=center)
-    p = _Nvll.others(point=point)
+    c = _Nv00.others(center=center)
+    p = _Nv00.others(point=point)
     try:
         return _intersecant2(c, circle, p, other, **radius_exact_height_wrap)
     except (TypeError, ValueError) as x:
@@ -966,8 +967,8 @@ def _intersect3(start1, end1, start2, end2, height, wrap):
     '''(INTERNAL) Return the intersection and antipodal points for
        functions C{intersection} and C{intersection2}.
     '''
-    p1 = _Nvll.others(start1=start1)
-    p2 = _Nvll.others(start2=start2)
+    p1 = _Nv00.others(start1=start1)
+    p2 = _Nv00.others(start2=start2)
     if wrap:
         p2 = _unrollon(p1, p2, wrap=wrap)
     # If gc1 and gc2 are great circles through start and end points
@@ -976,8 +977,8 @@ def _intersect3(start1, end1, start2, end2, height, wrap):
     # work is deciding the correct intersection point to select!  If
     # bearing is given, that determines the intersection, but if both
     # lines are defined by start/end points, take closer intersection.
-    gc1, s1, e1 = _Nvll._gc3(p1, end1, 'end1', wrap=wrap)
-    gc2, s2, e2 = _Nvll._gc3(p2, end2, 'end2', wrap=wrap)
+    gc1, s1, e1 = _Nv00._gc3(p1, end1, 'end1', wrap=wrap)
+    gc2, s2, e2 = _Nv00._gc3(p2, end2, 'end2', wrap=wrap)
 
     hs = start1.height, start2.height
     # there are two (antipodal) candidate intersection
@@ -1038,7 +1039,7 @@ def meanOf(points, height=None, wrap=False, LatLon=LatLon, **LatLon_kwds):
                            some B{C{points}} are not C{LatLon}.
     '''
     def _N_vs(ps, w):
-        Ps = _Nvll.PointsIter(ps, wrap=w)
+        Ps = _Nv00.PointsIter(ps, wrap=w)
         for p in Ps.iterate(closed=False):
             yield p._N_vector
 
@@ -1122,7 +1123,7 @@ def perimeterOf(points, closed=False, radius=R_M, wrap=False):
              and L{sphericalTrigonometry.perimeterOf}.
     '''
     def _rads(ps, c, w):  # angular edge lengths in radians
-        Ps = _Nvll.PointsIter(ps, loop=1, wrap=w)
+        Ps = _Nv00.PointsIter(ps, loop=1, wrap=w)
         p1 =  Ps[0]
         v1 =  p1._N_vector
         for p2 in Ps.iterate(closed=c):
@@ -1184,8 +1185,8 @@ def triangulate(point1, bearing1, point2, bearing2,
 
        @raise Valuerror: Points coincide.
     '''
-    return _triangulate(_Nvll.others(point1=point1), bearing1,
-                        _Nvll.others(point2=point2), bearing2,
+    return _triangulate(_Nv00.others(point1=point1), bearing1,
+                        _Nv00.others(point2=point2), bearing2,
                          height=height, wrap=wrap,
                          LatLon=LatLon, **LatLon_kwds)
 
@@ -1225,9 +1226,9 @@ def trilaterate(point1, distance1, point2, distance2, point3, distance3,  # PYCH
 
        @see: U{Trilateration<https://WikiPedia.org/wiki/Trilateration>}.
     '''
-    return _trilaterate(_Nvll.others(point1=point1), distance1,
-                        _Nvll.others(point2=point2), distance2,
-                        _Nvll.others(point3=point3), distance3,
+    return _trilaterate(_Nv00.others(point1=point1), distance1,
+                        _Nv00.others(point2=point2), distance2,
+                        _Nv00.others(point3=point3), distance3,
                          radius=radius, height=height, useZ=useZ,
                          wrap=wrap, LatLon=LatLon, **LatLon_kwds)