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

pygeodesy/azimuthal.py

@@ -49,7 +49,7 @@ from pygeodesy.ellipsoidalBase import LatLonEllipsoidalBase as _LLEB, \
                               _xinstanceof
 from pygeodesy.datums import _spherical_datum, _WGS84
 from pygeodesy.errors import _ValueError, _xdatum, _xkwds
-from pygeodesy.fmath import euclid, hypot as _hypot,  Fsum
+from pygeodesy.fmath import euclid, fdot_, hypot as _hypot,  Fsum
 # from pygeodesy.fsums import Fsum  # from .fmath
 # from pygeodesy.formy import antipode  # _MODS
 from pygeodesy.interns import _azimuth_, _datum_, _lat_, _lon_, _scale_, \
@@ -70,7 +70,7 @@ from pygeodesy.utily import asin1, atan1, atan2b, atan2d, sincos2, \
 from math import acos, atan2, degrees, fabs, sin, sqrt
 
 __all__ = _ALL_LAZY.azimuthal
-__version__ = '24.07.25'
+__version__ = '24.11.07'
 
 _EPS_K         = _EPStol * _0_1  # Karney's eps_ or _EPSmin * _0_1?
 _over_horizon_ = 'over horizon'
@@ -154,10 +154,10 @@ class _AzimuthalBase(_NamedBase):
         s0, c0 = self._sc0
 
         cb  *= ca
-        k, t = _k_t_2(s0 * sa + c0 * cb)
+        k, t = _k_t_2(fdot_(s0, sa, c0, cb))
         if t:
             r = k * self.radius
-            y = r * (c0 * sa - s0 * cb)
+            y = r * fdot_(c0, sa, -s0, cb)
             e, n, z, _ = _enzh4(r * sb * ca, y, None)
         else:  # 0 or 180
             e = n = z = _0_0
@@ -233,11 +233,11 @@ class _AzimuthalBase(_NamedBase):
                                      Lon_(lon0=lon0, Error=AzimuthalError))
         self._sc0     = sincos2d(self.lat0)
 
-    def reverse(self, x, y, LatLon=None, **name_LatLon_kwds):  # PYCHOK no cover
+    def reverse(self, x, y, **name_LatLon_and_kwds):
         '''I{Must be overloaded}.'''
-        self._notOverloaded(x, y, LatLon=LatLon, **name_LatLon_kwds)
+        self._notOverloaded(x, y, **name_LatLon_and_kwds)  # PYCHOK no cover
 
-    def _reverse(self, x, y, _c, lea, LatLon, **name_LatLon_kwds):
+    def _reverse(self, x, y, _c, lea, LatLon=None, **name_LatLon_kwds):
         '''(INTERNAL) Azimuthal (spherical) reverse C{x, y} to C{lat, lon}.
         '''
         e, n, z, r = _enzh4(x, y)
@@ -379,15 +379,14 @@ class Equidistant(_AzimuthalBase):
 
         return self._forward(lat, lon, name, _k_t)
 
-    def reverse(self, x, y, LatLon=None, **name_LatLon_kwds):
+    def reverse(self, x, y, **name_LatLon_and_kwds):
         '''Convert an azimuthal equidistant location to geodetic lat- and longitude.
 
            @arg x: Easting of the location (C{meter}).
            @arg y: Northing of the location (C{meter}).
-           @kwarg LatLon: Class to use (C{LatLon}) or C{None}.
-           @kwarg name_LatLon_kwds: Optional C{B{name}=NN} forthe location and
-                              optional, additional B{C{LatLon}} keyword arguments,
-                              ignored if C{B{LatLon} is None}.
+           @kwarg name_LatLon_and_kwds: Optional C{B{name}=NN} and class C{B{LatLon}=None}
+                       to use and optionally, additional B{C{LatLon}} keyword arguments,
+                       ignored if C{B{LatLon} is None}.
 
            @return: The geodetic (C{LatLon}) or if C{B{LatLon} is None} an
                     L{Azimuthal7Tuple}C{(x, y, lat, lon, azimuth, scale, datum)}.
@@ -401,7 +400,7 @@ class Equidistant(_AzimuthalBase):
         def _c(c):
             return c if c > EPS else None
 
-        return self._reverse(x, y, _c, False, LatLon, **name_LatLon_kwds)
+        return self._reverse(x, y, _c, False, **name_LatLon_and_kwds)
 
 
 def equidistant(lat0, lon0, datum=_WGS84, exact=False, geodsolve=False, **name):
@@ -505,9 +504,8 @@ class _EquidistantBase(_AzimuthalGeodesic):
            @arg x: Easting of the location (C{meter}).
            @arg y: Northing of the location (C{meter}).
            @kwarg LatLon: Class to use (C{LatLon}) or C{None}.
-           @kwarg name_LatLon_kwds: Optional C{B{name}=NN} for the location and
-                              optional, additional B{C{LatLon}} keyword arguments,
-                              ignored if C{B{LatLon} is None}.
+           @kwarg name_LatLon_kwds: Optional C{B{name}=NN} and optionally, additional
+                       B{C{LatLon}} keyword arguments, ignored if C{B{LatLon} is None}.
 
            @return: The geodetic (C{LatLon}) or if C{B{LatLon} is None} an
                     L{Azimuthal7Tuple}C{(x, y, lat, lon, azimuth, scale, datum)}.
@@ -670,15 +668,14 @@ class Gnomonic(_AzimuthalBase):
 
         return self._forward(lat, lon, name, _k_t)
 
-    def reverse(self, x, y, LatLon=None, **name_LatLon_kwds):
+    def reverse(self, x, y, **name_LatLon_and_kwds):
         '''Convert an azimuthal equidistant location to geodetic lat- and longitude.
 
            @arg x: Easting of the location (C{meter}).
            @arg y: Northing of the location (C{meter}).
-           @kwarg LatLon: Class to use (C{LatLon}) or C{None}.
-           @kwarg name_LatLon_kwds: Optional C{B{name}=NN} for the location and
-                              optional, additional B{C{LatLon}} keyword arguments,
-                              ignored if C{B{LatLon} is None}.
+           @kwarg name_LatLon_and_kwds: Optional C{B{name}=NN} and class C{B{LatLon}=None}
+                       for the location and optionally, additional B{C{LatLon}} keyword
+                       arguments, ignored if C{B{LatLon} is None}.
 
            @return: The geodetic (C{LatLon}) or if C{B{LatLon} is None} an
                     L{Azimuthal7Tuple}C{(x, y, lat, lon, azimuth, scale, datum)}.
@@ -692,7 +689,7 @@ class Gnomonic(_AzimuthalBase):
         def _c(c):
             return atan1(c) if c > EPS else None
 
-        return self._reverse(x, y, _c, False, LatLon, **name_LatLon_kwds)
+        return self._reverse(x, y, _c, False, **name_LatLon_and_kwds)
 
 
 def gnomonic(lat0, lon0, datum=_WGS84, exact=False, geodsolve=False, **name):
@@ -787,20 +784,18 @@ class _GnomonicBase(_AzimuthalGeodesic):
            @arg x: Easting of the location (C{meter}).
            @arg y: Northing of the location (C{meter}).
            @kwarg LatLon: Class to use (C{LatLon}) or C{None}.
-           @kwarg name_LatLon_kwds: Optional C{B{name}=NN} for the location and
-                              optional, additional B{C{LatLon}} keyword arguments,
-                              ignored if C{B{LatLon} is None}.
+           @kwarg name_LatLon_kwds: Optional C{B{name}=NN} for the location and optionally,
+                       additional B{C{LatLon}} keyword arguments, ignored if C{B{LatLon} is None}.
 
            @return: The geodetic (C{LatLon}) or if C{B{LatLon} is None} an
                     L{Azimuthal7Tuple}C{(x, y, lat, lon, azimuth, scale, datum)}.
 
            @raise AzimuthalError: No convergence.
 
-           @note: The C{lat} will be in the range C{[-90..90] degrees} and C{lon}
-                  in the range C{[-180..180] degrees}.  The C{azimuth} is clockwise
-                  from true North.  The scale is C{1 / reciprocal**2} in C{radial}
-                  direction and C{1 / reciprocal} in the direction perpendicular
-                  to this.
+           @note: The C{lat} will be in the range C{[-90..90] degrees} and C{lon} in the range
+                  C{[-180..180] degrees}.  The C{azimuth} is clockwise from true North.  The
+                  scale is C{1 / reciprocal**2} in C{radial} direction and C{1 / reciprocal}
+                  in the direction perpendicular to this.
         '''
         e, n, z, q = _enzh4(x, y)
 
@@ -974,30 +969,28 @@ class LambertEqualArea(_AzimuthalBase):
 
         return self._forward(lat, lon, name, _k_t)
 
-    def reverse(self, x, y, LatLon=None, **name_LatLon_kwds):
+    def reverse(self, x, y, **name_LatLon_and_kwds):
         '''Convert an azimuthal Lambert-equal-area location to geodetic lat- and longitude.
 
            @arg x: Easting of the location (C{meter}).
            @arg y: Northing of the location (C{meter}).
-           @kwarg LatLon: Class to use (C{LatLon}) or C{None}.
-           @kwarg name_LatLon_kwds: Optional C{B{name}=NN} for the location
-                              and optional, additional B{C{LatLon}} keyword
-                              arguments, ignored if C{B{LatLon} is None}.
+           @kwarg name_LatLon_and_kwds: Optional C{B{name}=NN} and class C{B{LatLon}=None}
+                       to use and optionally, additional B{C{LatLon}} keyword arguments,
+                       ignored if C{B{LatLon} is None}.
 
            @return: The geodetic (C{LatLon}) or if C{B{LatLon} is None} an
                     L{Azimuthal7Tuple}C{(x, y, lat, lon, azimuth, scale, datum)}.
 
-           @note: The C{lat} will be in the range C{[-90..90] degrees} and C{lon}
-                  in the range C{[-180..180] degrees}.  The C{scale} of the
-                  projection is C{1} in I{radial} direction, C{azimuth} clockwise
-                  from true North and is C{1 / reciprocal} in the direction
-                  perpendicular to this.
+           @note: The C{lat} will be in the range C{[-90..90] degrees} and C{lon} in the
+                  range C{[-180..180] degrees}.  The C{scale} of the projection is C{1}
+                  in I{radial} direction, C{azimuth} clockwise from true North and is C{1
+                  / reciprocal} in the direction perpendicular to this.
         '''
         def _c(c):
             c *= _0_5
             return (asin1(c) * _2_0) if c > EPS else None
 
-        return self._reverse(x, y, _c, True, LatLon, **name_LatLon_kwds)
+        return self._reverse(x, y, _c, True, **name_LatLon_and_kwds)
 
 
 class Orthographic(_AzimuthalBase):
@@ -1028,29 +1021,27 @@ class Orthographic(_AzimuthalBase):
 
         return self._forward(lat, lon, name, _k_t)
 
-    def reverse(self, x, y, LatLon=None, **name_LatLon_kwds):
+    def reverse(self, x, y, **name_LatLon_and_kwds):
         '''Convert an azimuthal orthographic location to geodetic lat- and longitude.
 
            @arg x: Easting of the location (C{meter}).
            @arg y: Northing of the location (C{meter}).
-           @kwarg LatLon: Class to use (C{LatLon}) or C{None}.
-           @kwarg name_LatLon_kwds: Optional C{B{name}=NN} for the location and
-                              optional, additional B{C{LatLon}} keyword arguments,
-                              ignored if C{B{LatLon} is None}.
+           @kwarg name_LatLon_and_kwds: Optional C{B{name}=NN} and class C{B{LatLon}=None}
+                       to use and optionally, additional B{C{LatLon}} keyword arguments,
+                       ignored if C{B{LatLon} is None}.
 
            @return: The geodetic (C{LatLon}) or if C{B{LatLon} is None} an
                     L{Azimuthal7Tuple}C{(x, y, lat, lon, azimuth, scale, datum)}.
 
-           @note: The C{lat} will be in the range C{[-90..90] degrees} and C{lon}
-                  in the range C{[-180..180] degrees}.  The C{scale} of the
-                  projection is C{1} in I{radial} direction, C{azimuth} clockwise
-                  from true North and is C{1 / reciprocal} in the direction
-                  perpendicular to this.
+           @note: The C{lat} will be in the range C{[-90..90] degrees} and C{lon} in the
+                  range C{[-180..180] degrees}.  The C{scale} of the projection is C{1}
+                  in I{radial} direction, C{azimuth} clockwise from true North and is C{1
+                  / reciprocal} in the direction perpendicular to this.
         '''
         def _c(c):
             return asin1(c) if c > EPS else None
 
-        return self._reverse(x, y, _c, False, LatLon, **name_LatLon_kwds)
+        return self._reverse(x, y, _c, False, **name_LatLon_and_kwds)
 
 
 class Stereographic(_AzimuthalBase):
@@ -1101,28 +1092,27 @@ class Stereographic(_AzimuthalBase):
         self._k0  = Scalar_(factor, name=n, low=EPS, high=2)  # XXX high=1, 2, other?
         self._k02 = self._k0 * _2_0
 
-    def reverse(self, x, y, LatLon=None, **name_LatLon_kwds):
+    def reverse(self, x, y, **name_LatLon_and_kwds):
         '''Convert an azimuthal stereographic location to geodetic lat- and longitude.
 
            @arg x: Easting of the location (C{meter}).
            @arg y: Northing of the location (C{meter}).
-           @kwarg LatLon: Class to use (C{LatLon}) or C{None}.
-           @kwarg name_LatLon_kwds: Optional C{B{name}=NN} for the location and
-                              optional, additional B{C{LatLon}} keyword arguments,
-                              ignored if C{B{LatLon} is None}.
+           @kwarg name_LatLon_and_kwds: Optional C{B{name}=NN} and class C{B{LatLon}=None}
+                       to use and optionally, additional B{C{LatLon}} keyword arguments,
+                       ignored if C{B{LatLon} is None}.
 
            @return: The geodetic (C{LatLon}) or if C{B{LatLon} is None} an
                     L{Azimuthal7Tuple}C{(x, y, lat, lon, azimuth, scale, datum)}.
 
            @note: The C{lat} will be in range C{[-90..90] degrees}, C{lon} in range
-                  C{[-180..180] degrees} and C{azimuth} clockwise from true North.
-                  The C{scale} of the projection is C{1} in I{radial} direction and
-                  is C{1 / reciprocal} in the direction perpendicular to this.
+                  C{[-180..180] degrees} and C{azimuth} clockwise from true North.  The
+                  C{scale} of the projection is C{1} in I{radial} direction and is C{1
+                  / reciprocal} in the direction perpendicular to this.
         '''
         def _c(c):
             return (atan2(c, self._k02) * _2_0) if c > EPS else None
 
-        return self._reverse(x, y, _c, False, LatLon, **name_LatLon_kwds)
+        return self._reverse(x, y, _c, False, **name_LatLon_and_kwds)
 
 
 __all__ += _ALL_DOCS(_AzimuthalBase, _AzimuthalGeodesic, _EquidistantBase, _GnomonicBase)

pygeodesy/basics.py

@@ -20,30 +20,28 @@ from pygeodesy.errors import _AttributeError, _ImportError, _NotImplementedError
                              _TypeError, _TypesError, _ValueError, _xAssertionError, \
                              _xkwds_get1
 # from pygeodesy.fsums import _isFsum_2Tuple  # _MODS
-from pygeodesy.internals import _0_0, _enquote, _passarg, _version_info
+from pygeodesy.internals import _0_0, _enquote, _getenv, _passarg, _PYGEODESY, \
+                                _version_info
 from pygeodesy.interns import MISSING, NN, _1_, _by_, _COMMA_, _DOT_, _DEPRECATED_, \
                              _ELLIPSIS4_, _EQUAL_, _in_, _invalid_, _N_A_, _not_, \
                              _not_scalar_, _odd_, _SPACE_, _UNDER_, _version_
 # from pygeodesy.latlonBase import LatLonBase  # _MODS
-from pygeodesy.lazily import _ALL_LAZY, _ALL_MODS as _MODS, _FOR_DOCS, _getenv, \
-                             LazyImportError, _sys_version_info2
+from pygeodesy.lazily import _ALL_LAZY, _ALL_MODS as _MODS, LazyImportError
 # from pygeodesy.named import classname, modulename, _name__  # _MODS
 # from pygeodesy.nvectorBase import NvectorBase  # _MODS
 # from pygeodesy.props import _update_all  # _MODS
 # from pygeodesy.streprs import Fmt  # _MODS
-# from pygeodesy.unitsBase import _NamedUnit, Str  # _MODS
 
 from copy import copy as _copy, deepcopy as _deepcopy
 from math import copysign as _copysign
-import inspect as _inspect
+# import inspect as _inspect  # _MODS
 
 __all__ = _ALL_LAZY.basics
-__version__ = '24.09.28'
+__version__ = '24.11.02'
 
-_below_               = 'below'
-_list_tuple_types     = (list, tuple)
-_PYGEODESY_XPACKAGES_ = 'PYGEODESY_XPACKAGES'
-_required_            = 'required'
+_below_           = 'below'
+_list_tuple_types = (list, tuple)
+_required_        = 'required'
 
 try:  # Luciano Ramalho, "Fluent Python", O'Reilly, 2016 p. 395, 2022 p. 577+
     from numbers import Integral as _Ints, Real as _Scalars  # .units
@@ -113,28 +111,29 @@ except NameError:  # Python 3+
         return ub
 
 
-def _args_kwds_count2(func, exelf=True):
-    '''(INTERNAL) Get a C{func}'s args and kwds count as 2-tuple
-       C{(nargs, nkwds)}, including arg C{self} for methods.
-
-       @kwarg exelf: If C{True}, exclude C{self} in the C{args}
-                     of a method (C{bool}).
-    '''
-    try:  # PYCHOK no cover
-        a = k = 0
-        for _, p in _inspect.signature(func).parameters.items():
-            if p.kind is p.POSITIONAL_OR_KEYWORD:
-                if p.default is p.empty:
-                    a += 1
-                else:
-                    k += 1
-    except AttributeError:  # .signature new Python 3+
-        s = _inspect.getargspec(func)
-        k = len(s.defaults or ())
-        a = len(s.args) - k
-    if exelf and a > 0 and _inspect.ismethod(func):
-        a -= 1
-    return a, k
+# def _args_kwds_count2(func, exelf=True):  # in .formy
+#     '''(INTERNAL) Get a C{func}'s args and kwds count as 2-tuple
+#        C{(nargs, nkwds)}, including arg C{self} for methods.
+#
+#        @kwarg exelf: If C{True}, exclude C{self} in the C{args}
+#                      of a method (C{bool}).
+#     '''
+#     i = _MODS.inspect
+#     try:
+#         a = k = 0
+#         for _, p in i.signature(func).parameters.items():
+#             if p.kind is p.POSITIONAL_OR_KEYWORD:
+#                 if p.default is p.empty:
+#                     a += 1
+#                 else:
+#                     k += 1
+#     except AttributeError:  # Python 2-
+#         s = i.getargspec(func)
+#         k = len(s.defaults or ())
+#         a = len(s.args) - k
+#     if exelf and a > 0 and i.ismethod(func):
+#         a -= 1
+#     return a, k
 
 
 def _args_kwds_names(func, splast=False):
@@ -147,10 +146,11 @@ def _args_kwds_names(func, splast=False):
        @note: Python 2 may I{not} include the C{*args} nor the
               C{**kwds} names.
     '''
+    i = _MODS.inspect
     try:
-        args_kwds = _inspect.signature(func).parameters.keys()
-    except AttributeError:  # .signature new Python 3+
-        args_kwds = _inspect.getargspec(func).args
+        args_kwds = i.signature(func).parameters.keys()
+    except AttributeError:  # Python 2-
+        args_kwds = i.getargspec(func).args
     if splast and args_kwds:  # PYCHOK no cover
         args_kwds = list(args_kwds)
         t = args_kwds[-1:]
@@ -222,7 +222,7 @@ def halfs2(str2):
     return str2[:h], str2[h:]
 
 
-def int1s(x):
+def int1s(x):  # PYCHOK no cover
     '''Count the number of 1-bits in an C{int}, I{unsigned}.
 
        @note: C{int1s(-B{x}) == int1s(abs(B{x}))}.
@@ -266,14 +266,10 @@ def isCartesian(obj, ellipsoidal=None):
     return isinstanceof(obj, _MODS.cartesianBase.CartesianBase)
 
 
-if _FOR_DOCS:  # XXX avoid epydoc Python 2.7 error
-
-    def isclass(obj):
-        '''Is B{C{obj}}ect a C{Class} or C{type}?
-        '''
-        return _inspect.isclass(obj)
-else:
-    isclass = _inspect.isclass
+def isclass(obj):  # XXX avoid epydoc Python 2.7 error
+    '''Is B{C{obj}}ect a C{Class} or C{type}?
+    '''
+    return _MODS.inspect.isclass(obj)
 
 
 def iscomplex(obj, both=False):
@@ -511,7 +507,7 @@ def issubclassof(Sub, *Supers):
     if isclass(Sub):
         t = tuple(S for S in Supers if isclass(S))
         if t:
-            return bool(issubclass(Sub, t))
+            return bool(issubclass(Sub, t))  # built-in
     return None
 
 
@@ -711,9 +707,9 @@ def splice(iterable, n=2, **fill):
         yield t  # 1 slice, all
 
 
-def _splituple(strs, *sep_splits):  # in .mgrs, .osgr, .webmercator
+def _splituple(strs, *sep_splits):  # in .mgrs, ...
     '''(INTERNAL) Split a C{comma}- or C{whitespace}-separated
-       string into a C{tuple} of stripped strings.
+       string into a C{tuple} of stripped C{str}ings.
     '''
     t = (strs.split(*sep_splits) if sep_splits else
          strs.replace(_COMMA_, _SPACE_).split()) if strs else ()
@@ -740,11 +736,11 @@ def _xcopy(obj, deep=False):
     return _deepcopy(obj) if deep else _copy(obj)
 
 
-def _xcoverage(where, *required):
+def _xcoverage(where, *required):  # in .__main__  # PYCHOK no cover
     '''(INTERNAL) Import C{coverage} and check required version.
     '''
     try:
-        _xpackage(_xcoverage)
+        _xpackages(_xcoverage)
         import coverage
     except ImportError as x:
         raise _xImportError(x, where)
@@ -780,7 +776,7 @@ def _xgeographiclib(where, *required):
     '''(INTERNAL) Import C{geographiclib} and check required version.
     '''
     try:
-        _xpackage(_xgeographiclib)
+        _xpackages(_xgeographiclib)
         import geographiclib
     except ImportError as x:
         raise _xImportError(x, where, Error=LazyImportError)
@@ -828,7 +824,7 @@ def _xiterablen(obj):
 def _xiterror(obj, _xwhich):
     '''(INTERNAL) Helper for C{_xinterable} and C{_xiterablen}.
     '''
-    t = _not_(_xwhich.__name__[2:])  # _dunder_nameof
+    t = _not_(_xwhich.__name__[2:])  # _DUNDER_nameof
     raise _TypeError(repr(obj), txt=t)
 
 
@@ -836,7 +832,7 @@ def _xnumpy(where, *required):
     '''(INTERNAL) Import C{numpy} and check required version.
     '''
     try:
-        _xpackage(_xnumpy)
+        _xpackages(_xnumpy)
         import numpy
     except ImportError as x:
         raise _xImportError(x, where)
@@ -851,14 +847,16 @@ def _xor(x, *xs):
     return x
 
 
-def _xpackage(_xpkg):
+def _xpackages(_xpkgf):
     '''(INTERNAL) Check dependency to be excluded.
     '''
-    n = _xpkg.__name__[2:]  # _dunder_nameof
-    if n in _XPACKAGES:
-        x = _SPACE_(n, _in_, _PYGEODESY_XPACKAGES_)
-        e = _enquote(_getenv(_PYGEODESY_XPACKAGES_, NN))
-        raise ImportError(_EQUAL_(x, e))
+    if _XPACKAGES:  # PYCHOK no cover
+        n = _xpkgf.__name__[2:]  # _DUNDER_nameof, less '_x'
+        if n.lower() in _XPACKAGES:
+            E = _PYGEODESY(_xpackages)
+            x = _SPACE_(n, _in_, E)
+            e = _enquote(_getenv(E, NN))
+            raise ImportError(_EQUAL_(x, e))
 
 
 def _xscalar(**names_values):
@@ -873,7 +871,7 @@ def _xscipy(where, *required):
     '''(INTERNAL) Import C{scipy} and check required version.
     '''
     try:
-        _xpackage(_xscipy)
+        _xpackages(_xscipy)
         import scipy
     except ImportError as x:
         raise _xImportError(x, where)
@@ -905,7 +903,7 @@ def _xversion(package, where, *required, **name):
     if required:
         t = _version_info(package)
         if t[:len(required)] < required:
-            t = _SPACE_(package.__name__,  # _dunder_nameof
+            t = _SPACE_(package.__name__,  # _DUNDER_nameof
                        _version_, _DOT_(*t),
                        _below_, _DOT_(*required),
                        _req_d_by(where, **name))
@@ -925,14 +923,14 @@ def _xzip(*args, **strict):  # PYCHOK no cover
     return zip(*args)
 
 
-if _sys_version_info2 < (3, 10):  # see .errors
+if _MODS.sys_version_info2 < (3, 10):  # see .errors
     _zip = zip  # PYCHOK exported
 else:  # Python 3.10+
 
     def _zip(*args):
         return zip(*args, strict=True)
 
-_XPACKAGES = _splituple(_getenv(_PYGEODESY_XPACKAGES_, NN).lower())
+_XPACKAGES = _splituple(_getenv(_PYGEODESY(_xpackages), NN).lower())  # test/bases._X_OK
 
 # **) MIT License
 #