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

pygeodesy/ellipsoidalExact.py

@@ -24,7 +24,7 @@ from pygeodesy.points import _areaError, ispolar  # PYCHOK exported
 # from math import fabs  # from .karney
 
 __all__ = _ALL_LAZY.ellipsoidalExact
-__version__ = '24.08.13'
+__version__ = '24.11.06'
 
 
 class Cartesian(CartesianEllipsoidalBase):
@@ -119,30 +119,28 @@ def areaOf(points, datum=_WGS84, wrap=True):
 
 
 def intersection3(start1, end1, start2, end2, height=None, wrap=False,  # was=True
-                  equidistant=None, tol=_TOL_M, LatLon=LatLon, **LatLon_kwds):
-    '''I{Iteratively} compute the intersection point of two lines, each defined
-       by two (ellipsoidal) points or by an (ellipsoidal) start point and an
-       initial bearing from North.
+                                equidistant=None, tol=_TOL_M, **LatLon_and_kwds):
+    '''I{Iteratively} compute the intersection point of two geodesic lines, each
+       given as two points or as an start point and a bearing from North.
 
        @arg start1: Start point of the first line (L{LatLon}).
        @arg end1: End point of the first line (L{LatLon}) or the initial bearing
-                  at the first point (compass C{degrees360}).
+                  at B{C{start1}} (compass C{degrees360}).
        @arg start2: Start point of the second line (L{LatLon}).
        @arg end2: End point of the second line (L{LatLon}) or the initial bearing
-                  at the second point (compass C{degrees360}).
+                  at B{C{start2}} (compass C{degrees360}).
        @kwarg height: Optional height at the intersection (C{meter}, conventionally)
                       or C{None} for the mean height.
-       @kwarg wrap: If C{True}, wrap or I{normalize} and unroll the B{C{start2}}
-                    and B{C{end*}} points (C{bool}).
+       @kwarg wrap: If C{True}, wrap or I{normalize} and unroll B{C{start2}} and
+                    both B{C{end*}} points (C{bool}).
        @kwarg equidistant: An azimuthal equidistant projection (I{class} or function
                            L{pygeodesy.equidistant}) or C{None} for the preferred
                            C{B{start1}.Equidistant}.
        @kwarg tol: Tolerance for convergence and for skew line distance and length
                    (C{meter}, conventionally).
-       @kwarg LatLon: Optional class to return the intersection points (L{LatLon})
-                      or C{None}.
-       @kwarg LatLon_kwds: Optional, additional B{C{LatLon}} keyword arguments,
-                           ignored if C{B{LatLon} is None}.
+       @kwarg LatLon_and_kwds: Optional class C{B{LatLon}=}L{LatLon} to return the
+                     intersection points and optionally, additional B{C{LatLon}}
+                     keyword arguments, ignored if C{B{LatLon}=None}.
 
        @return: An L{Intersection3Tuple}C{(point, outside1, outside2)} with C{point}
                 a B{C{LatLon}} or if C{B{LatLon} is None}, a L{LatLon4Tuple}C{(lat,
@@ -154,23 +152,23 @@ def intersection3(start1, end1, start2, end2, height=None, wrap=False,  # was=Tr
        @raise TypeError: Invalid or non-ellipsoidal B{C{start1}}, B{C{end1}},
                          B{C{start2}} or B{C{end2}} or invalid B{C{equidistant}}.
 
-       @note: For each line specified with an initial bearing, a pseudo-end point
-              is computed as the C{destination} along that bearing at about 1.5
-              times the distance from the start point to an initial gu-/estimate
-              of the intersection point (and between 1/8 and 3/8 of the authalic
-              earth perimeter).
+       @note: For each line specified with an initial bearing, a pseudo-end point is
+              computed as the C{destination} along that bearing at about 1.5 times the
+              distance from the start point to an initial gu-/estimate of the intersection
+              point (and between 1/8 and 3/8 of the authalic earth perimeter).
 
        @see: U{The B{ellipsoidal} case<https://GIS.StackExchange.com/questions/48937/
              calculating-intersection-of-two-circles>} and U{Karney's paper
              <https://ArXiv.org/pdf/1102.1215.pdf>}, pp 20-21, section B{14. MARITIME
              BOUNDARIES} for more details about the iteration algorithm.
     '''
+    kwds = _xkwds(LatLon_and_kwds, LatLon=LatLon)
     return _intersection3(start1, end1, start2, end2, height=height, wrap=wrap,
-                          equidistant=equidistant, tol=tol, LatLon=LatLon, **LatLon_kwds)
+                                        equidistant=equidistant, tol=tol, **kwds)
 
 
 def intersections2(center1, radius1, center2, radius2, height=None, wrap=False,  # was=True
-                   equidistant=None, tol=_TOL_M, LatLon=LatLon, **LatLon_kwds):
+                                     equidistant=None, tol=_TOL_M, **LatLon_and_kwds):
     '''I{Iteratively} compute the intersection points of two circles, each defined
        by an (ellipsoidal) center point and a radius.
 
@@ -189,10 +187,9 @@ def intersections2(center1, radius1, center2, radius2, height=None, wrap=False,
                            the preferred C{B{center1}.Equidistant}.
        @kwarg tol: Convergence tolerance (C{meter}, same units as B{C{radius1}}
                    and B{C{radius2}}).
-       @kwarg LatLon: Optional class to return the intersection points (L{LatLon})
-                      or C{None}.
-       @kwarg LatLon_kwds: Optional, additional B{C{LatLon}} keyword arguments,
-                           ignored if C{B{LatLon} is None}.
+       @kwarg LatLon_and_kwds: Optional class C{B{LatLon}=}L{LatLon} to return the
+                     intersection points and optionally, additional B{C{LatLon}}
+                     keyword arguments, ignored if C{B{LatLon}=None}.
 
        @return: 2-Tuple of the intersection points, each a B{C{LatLon}} instance
                 or L{LatLon4Tuple}C{(lat, lon, height, datum)} if C{B{LatLon} is
@@ -214,8 +211,9 @@ def intersections2(center1, radius1, center2, radius2, height=None, wrap=False,
              U{sphere-sphere<https://MathWorld.Wolfram.com/Sphere-SphereIntersection.html>}
              intersections.
     '''
+    kwds = _xkwds(LatLon_and_kwds, LatLon=LatLon)
     return _intersections2(center1, radius1, center2, radius2, height=height, wrap=wrap,
-                           equidistant=equidistant, tol=tol, LatLon=LatLon, **LatLon_kwds)
+                                             equidistant=equidistant, tol=tol, **kwds)
 
 
 def isclockwise(points, datum=_WGS84, wrap=True):
@@ -245,9 +243,9 @@ def isclockwise(points, datum=_WGS84, wrap=True):
 
 
 def nearestOn(point, point1, point2, within=True, height=None, wrap=False,
-              equidistant=None, tol=_TOL_M, LatLon=LatLon, **LatLon_kwds):
-    '''I{Iteratively} locate the closest point on the geodesic between
-       two other (ellispoidal) points.
+                     equidistant=None, tol=_TOL_M, **LatLon_and_kwds):
+    '''I{Iteratively} locate the closest point on the geodesic (line)
+       between two other (ellipsoidal) points.
 
        @arg point: Reference point (C{LatLon}).
        @arg point1: Start point of the geodesic (C{LatLon}).
@@ -265,16 +263,15 @@ def nearestOn(point, point1, point2, within=True, height=None, wrap=False,
                            or function L{pygeodesy.equidistant}) or C{None}
                            for the preferred C{B{point}.Equidistant}.
        @kwarg tol: Convergence tolerance (C{meter}).
-       @kwarg LatLon: Optional class to return the closest point
-                      (L{LatLon}) or C{None}.
-       @kwarg LatLon_kwds: Optional, additional B{C{LatLon}} keyword
-                           arguments, ignored if C{B{LatLon} is None}.
+       @kwarg LatLon_and_kwds: Optional class C{B{LatLon}=}L{LatLon} to return the
+                     closest point and optionally, additional B{C{LatLon}} keyword
+                     arguments, ignored if C{B{LatLon}=None}.
 
-       @return: Closest point, a B{C{LatLon}} instance or if C{B{LatLon}
-                is None}, a L{LatLon4Tuple}C{(lat, lon, height, datum)}.
+       @return: Closest point, a B{C{LatLon}} instance or if C{B{LatLon} is None},
+                a L{LatLon4Tuple}C{(lat, lon, height, datum)}.
 
-       @raise TypeError: Invalid or non-ellipsoidal B{C{point}}, B{C{point1}}
-                         or B{C{point2}} or invalid B{C{equidistant}}.
+       @raise TypeError: Invalid or non-ellipsoidal B{C{point}}, B{C{point1}} or
+                         B{C{point2}} or invalid B{C{equidistant}}.
 
        @raise ValueError: No convergence for the B{C{tol}}.
 
@@ -283,8 +280,9 @@ def nearestOn(point, point1, point2, within=True, height=None, wrap=False,
              <https://ArXiv.org/pdf/1102.1215.pdf>}, pp 20-21, section B{14. MARITIME
              BOUNDARIES} for more details about the iteration algorithm.
     '''
+    kwds = _xkwds(LatLon_and_kwds, LatLon=LatLon)
     return _nearestOn(point, point1, point2, within=within, height=height, wrap=wrap,
-                      equidistant=equidistant, tol=tol, LatLon=LatLon, **LatLon_kwds)
+                                             equidistant=equidistant, tol=tol, **kwds)
 
 
 def perimeterOf(points, closed=False, datum=_WGS84, wrap=True):

pygeodesy/ellipsoidalNvector.py

@@ -8,7 +8,7 @@ and C{Nvector} and DEPRECATED L{Ned} and functions L{meanOf}, L{sumOf}
 and DEPRECATED L{toNed}.
 
 Pure Python implementation of n-vector-based geodetic (lat-/longitude)
-methods by I{(C) Chris Veness 2011-2016} published under the same MIT
+methods 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>}.
 
@@ -48,7 +48,7 @@ from pygeodesy.units import Bearing, Distance, Height, Scalar
 # from math import fabs  # from .nvectorBase
 
 __all__ = _ALL_LAZY.ellipsoidalNvector
-__version__ = '24.08.13'
+__version__ = '24.10.19'
 
 
 class Ned(_Ned):
@@ -417,7 +417,7 @@ class LatLon(LatLonNvectorBase, LatLonEllipsoidalBase):
         return LatLonNvectorBase.toNvector(self, **kwds)
 
 
-_Nvll = LatLon(0, 0, name=_Nv00_)  # reference instance (L{LatLon})
+_Nv00 = LatLon(0, 0, name=_Nv00_)  # reference instance (L{LatLon})
 
 
 class Nvector(NvectorBase):
@@ -541,7 +541,7 @@ def meanOf(points, datum=_WGS84, height=None, wrap=False,
 
        @raise ValueError: Insufficient number of B{C{points}}.
     '''
-    Ps = _Nvll.PointsIter(points, wrap=wrap)
+    Ps = _Nv00.PointsIter(points, wrap=wrap)
     n  =  sumOf(p._N_vector for p in Ps.iterate(closed=False))
     return n.toLatLon(**_xkwds(LatLon_and_kwds, height=height, datum=datum,
                                                 LatLon=LatLon, name__=meanOf))

pygeodesy/ellipsoidalVincenty.py

@@ -8,7 +8,7 @@ I{Thaddeus Vincenty}'s geodetic (lat-/longitude) L{LatLon}, geocentric
 L{intersections2}, L{nearestOn} and L{perimeterOf}.
 
 Pure Python implementation of geodesy tools for ellipsoidal earth models,
-transcoded from JavaScript originals by I{(C) Chris Veness 2005-2016}
+transcoded from JavaScript originals by I{(C) Chris Veness 2005-2024}
 and published under the same MIT Licence**, see U{Vincenty geodesics
 <https://www.Movable-Type.co.UK/scripts/LatLongVincenty.html>}.  More
 at U{geographiclib<https://PyPI.org/project/geographiclib>} and
@@ -72,7 +72,7 @@ from pygeodesy.utily import atan2b, atan2d, sincos2, sincos2d, unroll180, wrap18
 from math import atan2, cos, degrees, fabs, radians, tan
 
 __all__ = _ALL_LAZY.ellipsoidalVincenty
-__version__ = '24.08.13'
+__version__ = '24.10.12'
 
 _antipodal_to_ = _SPACE_(_antipodal_, _to_)
 

pygeodesy/ellipsoids.py

@@ -66,7 +66,7 @@ from __future__ import division as _; del _  # PYCHOK semicolon
 
 from pygeodesy.basics import copysign0, isbool, isint
 from pygeodesy.constants import EPS, EPS0, EPS02, EPS1, INF, NINF, PI4, PI_2, PI_3, R_M, R_MA, R_FM, \
-                               _EPSqrt, _EPStol as _TOL, _floatuple as _T, _isfinite, _SQRT2_2, \
+                               _EPSqrt, _EPStol as _TOL, _floatuple as _T, _isfinite, \
                                _0_0s, _0_0, _0_5, _1_0, _1_EPS, _2_0, _4_0, _90_0, \
                                _0_25, _3_0  # PYCHOK used!
 from pygeodesy.errors import _AssertionError, IntersectionError, _ValueError, _xattr, _xkwds_not
@@ -93,7 +93,7 @@ from pygeodesy.utily import atan1, atan1d, atan2b, degrees90, m2radians, radians
 from math import asinh, atan, atanh, cos, degrees, exp, fabs, radians, sin, sinh, sqrt, tan
 
 __all__ = _ALL_LAZY.ellipsoids
-__version__ = '24.07.25'
+__version__ = '24.10.15'
 
 _f_0_0    = Float(f =_0_0)  # zero flattening
 _f__0_0   = Float(f_=_0_0)  # zero inverse flattening
@@ -281,7 +281,7 @@ class Ellipsoid(_NamedEnumItem):
 
         self._register(Ellipsoids, n)
 
-        if f and f_:  # see .test/testEllipsoidal.py
+        if f and f_:  # see test/testEllipsoidal
             d = dict(eps=_TOL)
             if None in ff_:  # both f_ and f given
                 d.update(Error=_ValueError, txt=_incompatible_)
@@ -811,9 +811,9 @@ class Ellipsoid(_NamedEnumItem):
 
     eccentricity     = e    # eccentricity
 #   eccentricity2    = e2   # eccentricity squared
-    eccentricity1st2 = e2   # first eccentricity squared
-    eccentricity2nd2 = e22  # second eccentricity squared
-    eccentricity3rd2 = e32  # third eccentricity squared
+    eccentricity1st2 = e2   # first eccentricity squared, signed
+    eccentricity2nd2 = e22  # second eccentricity squared, signed
+    eccentricity3rd2 = e32  # third eccentricity squared, signed
 
     def ecef(self, Ecef=None):
         '''Return U{ECEF<https://WikiPedia.org/wiki/ECEF>} converter.
@@ -1160,7 +1160,7 @@ class Ellipsoid(_NamedEnumItem):
                 v = v.times_(t, t, 0)  # force z=0.0
                 h = x - a  # equatorial
             else:  # normal in 1st quadrant
-                x, y, i = _plumbTo3(x, y, self)
+                x, y, i = _MODS.triaxials._plumbTo3(x, y, self)
                 t, v = v, v.times_(x, x, y)
                 h = t.minus(v).length
 
@@ -1522,9 +1522,9 @@ class Ellipsoid(_NamedEnumItem):
     def _Rhumbs(self):
         '''(INTERNAL) Get all C{Rhumb...} classes, I{once}.
         '''
-        p = _MODS.rhumb
-        return (p.aux_.RhumbAux,  # overwrite property_ROver
-                p.ekx.Rhumb, p.solve.RhumbSolve)
+        r = _MODS.rhumb
+        return (r.aux_.RhumbAux,  # overwrite property_ROver
+                r.ekx.Rhumb, r.solve.RhumbSolve)
 
     @property
     def rhumbsolve(self):
@@ -2276,47 +2276,6 @@ def n2f_(n):
     return f2f_(n2f(n))
 
 
-def _plumbTo3(px, py, E, eps=EPS):  # in .height4 above
-    '''(INTERNAL) Nearest point on a 2-D ellipse in 1st quadrant.
-
-       @see: Functions C{pygeodesy.triaxial._plumbTo4} and C{-._plumbTo5}.
-    '''
-    a, b, e0 = E.a, E.b, EPS0
-    if min(px, py, a, b) < e0:
-        raise _AssertionError(px=px, py=py, a=a, b=b, E=E)
-
-    a2 = a - b * E.b_a
-    b2 = b - a * E.a_b
-    tx = ty = _SQRT2_2
-    _a,  _h =  fabs, hypot
-    for i in range(16):  # max 5
-        ex = a2 * tx**3
-        ey = b2 * ty**3
-
-        qx =  px - ex
-        qy =  py - ey
-        q  = _h(qx, qy)
-        if q < e0:  # PYCHOK no cover
-            break
-        r = _h(ex - tx * a,
-               ey - ty * b) / q
-
-        sx, tx = tx, min(_1_0, max(0, (ex + qx * r) / a))
-        sy, ty = ty, min(_1_0, max(0, (ey + qy * r) / b))
-        t = _h(ty, tx)
-        if t < e0:  # PYCHOK no cover
-            break
-        tx = tx / t  # /= chokes PyChecker
-        ty = ty / t
-        if _a(sx - tx) < eps and \
-           _a(sy - ty) < eps:
-            break
-
-    tx *= a / px
-    ty *= b / py
-    return tx, ty, i  # x and y as fractions
-
-
 class Ellipsoids(_NamedEnum):
     '''(INTERNAL) L{Ellipsoid} registry, I{must} be a sub-class
        to accommodate the L{_LazyNamedEnumItem} properties.

pygeodesy/elliptic.py

@@ -84,12 +84,12 @@ from pygeodesy.constants import EPS, INF, NAN, PI, PI_2, PI_4, _0_0, \
 # from pygeodesy.errors import _ValueError  # from .fmath
 from pygeodesy.fmath import favg, hypot1, zqrt,  _ValueError
 from pygeodesy.fsums import Fsum, _sum
-# from pygeodesy.internals import _dunder_nameof  # from .lazily
+from pygeodesy.internals import _DUNDER_nameof
 from pygeodesy.interns import NN, _delta_, _DOT_, _f_, _invalid_, \
                              _invokation_, _negative_, _SPACE_
 from pygeodesy.karney import _K_2_0, _norm180, _signBit, _sincos2
-from pygeodesy.lazily import _ALL_LAZY,  _dunder_nameof
-from pygeodesy.named import _Named, _NamedTuple,  Fmt, unstr
+# from pygeodesy.lazily import _ALL_LAZY  # from .named
+from pygeodesy.named import _Named, _NamedTuple,  _ALL_LAZY, Fmt, unstr
 from pygeodesy.props import _allPropertiesOf_n, Property_RO, _update_all
 # from pygeodesy.streprs import Fmt, unstr  # from .named
 from pygeodesy.units import Scalar, Scalar_
@@ -99,7 +99,7 @@ from math import asin, asinh, atan, atan2, ceil, cosh, fabs, floor, \
                  radians, sin, sinh, sqrt, tan, tanh
 
 __all__ = _ALL_LAZY.elliptic
-__version__ = '24.09.06'
+__version__ = '24.10.14'
 
 _TolRD  =  zqrt(EPS * 0.002)
 _TolRF  =  zqrt(EPS * 0.030)
@@ -408,9 +408,9 @@ class Elliptic(_Named):
     def _Einv(self, x):
         '''(INTERNAL) Helper for C{.deltaEinv} and C{.fEinv}.
         '''
-        E2 = self.cE * _2_0
-        n  = floor(x / E2 + _0_5)
-        r  = x - E2 * n  # r in [-cE, cE)
+        E2  = self.cE * _2_0
+        n   = floor(x / E2 + _0_5)
+        r   = x - E2 * n  # r in [-cE, cE)
         # linear approximation
         phi = PI * r / E2  # phi in [-PI_2, PI_2)
         Phi = Fsum(phi)
@@ -427,7 +427,7 @@ class Elliptic(_Named):
                 sn = self.fE(sn, cn, dn)
                 phi, d = _Phi2((r - sn) / dn)
             else:  # PYCHOK no cover
-                d = _0_0  # XXX continue?
+                d = _0_0  # XXX or continue?
             if fabs(d) < _TolJAC:  # 3-4 trips
                 _iterations(self, i)
                 break
@@ -497,20 +497,20 @@ class Elliptic(_Named):
             '''(INTERNAL) Core of C{.fE}.
             '''
             if sn:
-                sn2, cn2, dn2 = sn**2, cn**2, dn**2
-                kp2, k2 = self.kp2, self.k2
+                cn2, dn2 = cn**2, dn**2
+                kp2, k2  = self.kp2, self.k2
                 if k2 <= 0:  # Carlson, eq. 4.6, <https://DLMF.NIST.gov/19.25.E9>
                     Ei = _RF3(self, cn2, dn2, _1_0)
                     if k2:
-                        Ei -= _RD(self, cn2, dn2, _1_0, _3over(k2, sn2))
+                        Ei -= _RD(self, cn2, dn2, _1_0, _3over(k2, sn**2))
                 elif kp2 >= 0:  # k2 > 0, <https://DLMF.NIST.gov/19.25.E10>
                     Ei = _over(k2 * fabs(cn), dn)  # float
                     if kp2:
-                        Ei += (_RD( self, cn2, _1_0,  dn2, _3over(k2, sn2)) +
+                        Ei += (_RD( self, cn2, _1_0,  dn2, _3over(k2, sn**2)) +
                                _RF3(self, cn2,  dn2, _1_0)) * kp2
                 else:  # kp2 < 0, <https://DLMF.NIST.gov/19.25.E11>
                     Ei  = _over(dn, fabs(cn))
-                    Ei -= _RD(self, dn2, _1_0, cn2, _3over(kp2, sn2))
+                    Ei -= _RD(self, dn2, _1_0, cn2, _3over(kp2, sn**2))
                 Ei *= fabs(sn)
                 ei  = float(Ei)
             else:  # PYCHOK no cover
@@ -1075,7 +1075,7 @@ def _ellipticError(where, *args, **kwds_cause_txt):
 
     x, t, kwds = _x_t_kwds(**kwds_cause_txt)
 
-    n = _dunder_nameof(where, where)
+    n = _DUNDER_nameof(where, where)
     n = _DOT_(Elliptic.__name__, n)
     n = _SPACE_(_invokation_, n)
     u =  unstr(n, *args, **kwds)

pygeodesy/errors.py

@@ -14,12 +14,12 @@ C{PYGEODESY_EXCEPTION_CHAINING=std} or to any non-empty string.
 # from pygeodesy.basics import isint, isodd, issubclassof, itemsorted, _xinstanceof, _zip  # _MODS
 # from pygeodesy.ellipsoidalBase import CartesianEllipsoidalBase, LatLonEllipsoidalBase  # _MODS
 # from pygeodesy import errors  # _MODS, _MODS.getattr
-from pygeodesy.internals import _dunder_nameof_, _plural, _tailof
+from pygeodesy.internals import _DUNDER_nameof_, _getPYGEODESY, _plural, _tailof
 from pygeodesy.interns import MISSING, NN, _a_, _an_, _and_, _clip_, _COLON_, _COLONSPACE_, \
                              _COMMASPACE_, _datum_, _ELLIPSIS_, _ellipsoidal_, _incompatible_, \
                              _invalid_, _keyword_, _LatLon_, _len_, _not_, _or_, _SPACE_, \
                              _specified_, _UNDER_, _vs_, _with_
-from pygeodesy.lazily import _ALL_LAZY, _ALL_MODS as _MODS, _getenv, _PYTHON_X_DEV
+from pygeodesy.lazily import _ALL_LAZY, _ALL_MODS as _MODS, _PYTHON_X_DEV
 # from pygeodesy import streprs as _streprs  # _MODS
 # from pygeodesy.unitsBase import Str  # _MODS
 # from pygeodesy.vector3dBase import Vector3dBase  # _MODS
@@ -27,7 +27,7 @@ from pygeodesy.lazily import _ALL_LAZY, _ALL_MODS as _MODS, _getenv, _PYTHON_X_D
 from copy import copy as _copy
 
 __all__ = _ALL_LAZY.errors  # _ALL_DOCS('_InvalidError', '_IsnotError')  _under
-__version__ = '24.10.01'
+__version__ = '24.11.02'
 
 _argument_   = 'argument'
 _box_        = 'box'
@@ -43,7 +43,7 @@ try:
     _exception_chaining = None  # not available
     _ = Exception().__cause__   # Python 3.9+ exception chaining
 
-    if _PYTHON_X_DEV or _getenv('PYGEODESY_EXCEPTION_CHAINING', NN):  # == _std_
+    if _PYTHON_X_DEV or _getPYGEODESY('EXCEPTION_CHAINING'):  # == _std_
         _exception_chaining = True  # turned on, std
         raise AttributeError()  # allow exception chaining
 
@@ -527,7 +527,7 @@ def _IsnotError(*types__, **name_value_Error_cause):  # name=value [, Error=Type
     n, v    = _xkwds_item2(kwds)
 
     n = _streprs.Fmt.PARENSPACED(n, repr(v))
-    t = _not_(_an(_or(*_dunder_nameof_(*types__))) if types__ else _specified_)
+    t = _not_(_an(_or(*_DUNDER_nameof_(*types__))) if types__ else _specified_)
     return _XError(E, n, txt=t, cause=x)
 
 
@@ -777,7 +777,7 @@ except AttributeError:
         return d
 
 
-# def _xkwds_bool(inst, **kwds):  # no longer in .frechet, .hausdorff, .heights
+# def _xkwds_bool(inst, **kwds):  # unused
 #     '''(INTERNAL) Set applicable C{bool} properties/attributes.
 #     '''
 #     for n, v in kwds.items():
@@ -789,18 +789,18 @@ except AttributeError:
 #             setattr(inst, NN(_UNDER_, n), v)
 
 
-def _xkwds_from(orig, *args, **kwds):
-    '''(INTERNAL) Return the items from C{orig} with the keys
-       from C{kwds} and a value not in C{args} and C{kwds}.
-    '''
-    def _items(orig, args, items):
-        for n, m in items:
-            if n in orig:  # n in (orig.keys() & kwds.keys())
-                t = orig[n]
-                if t is not m and t not in args:
-                    yield n, t
-
-    return _items(orig, args, kwds.items())
+# def _xkwds_from(orig, *args, **kwds):  # unused
+#     '''(INTERNAL) Return the items from C{orig} with the keys
+#        from C{kwds} and a value not in C{args} and C{kwds}.
+#     '''
+#     def _items(orig, args, items):
+#         for n, m in items:
+#             if n in orig:  # n in (orig.keys() & kwds.keys())
+#                 t = orig[n]
+#                 if t is not m and t not in args:
+#                     yield n, t
+#
+#     return _items(orig, args, kwds.items())
 
 
 def _xkwds_get(kwds, **name_default):
@@ -813,14 +813,14 @@ def _xkwds_get(kwds, **name_default):
     raise _xAssertionError(_xkwds_get, kwds, **name_default)
 
 
-def _xkwds_get_(kwds, **names_defaults):
-    '''(INTERNAL) Yield each C{kwds} value or its C{default}
-       in I{case-insensitive, alphabetical} C{name} order.
-    '''
-    if not isinstance(kwds, dict):
-        raise _xAssertionError(_xkwds_get_, kwds)
-    for n, v in _MODS.basics.itemsorted(names_defaults):
-        yield kwds.get(n, v)
+# def _xkwds_get_(kwds, **names_defaults):  # unused
+#     '''(INTERNAL) Yield each C{kwds} value or its C{default}
+#        in I{case-insensitive, alphabetical} C{name} order.
+#     '''
+#     if not isinstance(kwds, dict):
+#         raise _xAssertionError(_xkwds_get_, kwds)
+#     for n, v in _MODS.basics.itemsorted(names_defaults):
+#         yield kwds.get(n, v)
 
 
 def _xkwds_get1(kwds, **name_default):
@@ -844,11 +844,11 @@ def _xkwds_item2(kwds):
     raise _xAssertionError(_xkwds_item2, kwds)
 
 
-def _xkwds_kwds(kwds, **names_defaults):
+def _xkwds_kwds(kwds, **names_defaults):  # in .geodesici  # PYCHOK no cover
     '''(INTERNAL) Return a C{dict} of C{named_defaults} items replaced with C{kwds}.
     '''
     if not isinstance(kwds, dict):
-        raise _xAssertionError(_xkwds_get_, kwds)
+        raise _xAssertionError(_xkwds_kwds, kwds)
     _g = kwds.get
     return dict((n, _g(n, v)) for n, v in names_defaults.items())