pygeodesy 24.5.8__py2.py3-none-any.whl → 24.5.24__py2.py3-none-any.whl

pygeodesy/datums.py

@@ -67,23 +67,24 @@ datum, q.v. U{"A Guide to Coordinate Systems in Great Britain", Section 6
 # make sure int/int division yields float quotient, see .basics
 from __future__ import division as _; del _  # PYCHOK semicolon
 
-from pygeodesy.basics import islistuple, map2, neg, _passarg, _xinstanceof, _zip
+from pygeodesy.basics import islistuple, map2, neg, _xinstanceof, _zip
 from pygeodesy.constants import R_M, _float as _F, _0_0, _1_0, _2_0, _8_0, _3600_0
 # from pygeodesy.ellipsoidalBase import CartesianEllipsoidalBase as _CEB, \
 #                                          LatLonEllipsoidalBase as _LLEB  # MODS
 from pygeodesy.ellipsoids import a_f2Tuple, Ellipsoid, Ellipsoid2, Ellipsoids, _EWGS84, \
                                  Vector3Tuple
-from pygeodesy.errors import _IsnotError, _TypeError, _xattr, _xellipsoidall, _xkwds, \
-                             _xkwds_pop2
+from pygeodesy.errors import _IsnotError, _TypeError, _xellipsoidall, _xkwds, _xkwds_pop2
 from pygeodesy.fmath import fdot, fmean,  Fmt, _operator
+from pygeodesy.internals import _passarg, _under
 from pygeodesy.interns import NN, _a_, _Airy1830_, _AiryModified_, _BAR_, _Bessel1841_, \
-                             _Clarke1866_, _Clarke1880IGN_, _COMMASPACE_, _DOT_, \
-                             _earth_, _ellipsoid_, _ellipsoidal_, _GRS80_, _Intl1924_, \
-                             _MINUS_, _Krassovski1940_, _Krassowsky1940_, _NAD27_, \
-                             _NAD83_, _PLUS_, _s_, _Sphere_, _spherical_, _transform_, \
-                             _UNDER_, _WGS72_, _WGS84_, _under
+                             _Clarke1866_, _Clarke1880IGN_, _COMMASPACE_, _DOT_, _earth_, \
+                             _ellipsoid_, _ellipsoidal_, _GRS80_, _Intl1924_, _MINUS_, \
+                             _Krassovski1940_, _Krassowsky1940_, _NAD27_, _NAD83_, _s_, \
+                             _PLUS_, _Sphere_, _spherical_, _transform_, _UNDER_, \
+                             _WGS72_, _WGS84_
 from pygeodesy.lazily import _ALL_LAZY, _ALL_MODS as _MODS
-from pygeodesy.named import _NamedEnum, _NamedEnumItem, _lazyNamedEnumItem as _lazy
+from pygeodesy.named import _lazyNamedEnumItem as _lazy, _name__, _name2__, _NamedEnum, \
+                                _NamedEnumItem
 # from pygeodesy.namedTuples import Vector3Tuple  # from .ellipsoids
 from pygeodesy.props import Property_RO, property_RO
 # from pygeodesy.streprs import Fmt  # from .fmath
@@ -93,7 +94,7 @@ from pygeodesy.units import _isRadius, Radius_,  radians
 # import operator as _operator  # from .fmath
 
 __all__ = _ALL_LAZY.datums
-__version__ = '24.03.07'
+__version__ = '24.05.21'
 
 _a_ellipsoid_ = _UNDER_(_a_, _ellipsoid_)
 _BD72_        = 'BD72'
@@ -203,15 +204,15 @@ class Transform(_NamedEnumItem):
     def __neg__(self):
         return self.inverse()
 
-    def inverse(self, name=NN):
+    def inverse(self, **name):
         '''Return the inverse of this transform.
 
            @kwarg name: Optional, unique name (C{str}).
 
            @return: Inverse (L{Transform}), unregistered.
         '''
-        r = type(self)(**dict(self.items(inverse=True)))
-        n = name or _negastr(self.name)
+        r =  type(self)(**dict(self.items(inverse=True)))
+        n = _name__(**name) or _negastr(self.name)
         if n:
             r.name = n  # unregistered
         return r
@@ -247,16 +248,17 @@ class Transform(_NamedEnumItem):
         self.s  = s = (s1 - _1_0) / _S1_S
         return s
 
-    def toStr(self, prec=5, fmt=Fmt.g, name=NN, **unused):  # PYCHOK expected
+    def toStr(self, prec=5, fmt=Fmt.g, **name):  # PYCHOK expected
         '''Return this transform as a string.
 
            @kwarg prec: Number of (decimal) digits, unstripped (C{int}).
            @kwarg fmt: Optional C{float} format (C{letter}).
-           @kwarg name: Override name (C{str}) or C{None} to exclude
-                        this transform's name.
+           @kwarg name: Optional, override C{B{name}=NN} (C{str}) or
+                        C{None} to exclude this transform's name.
 
            @return: Transform attributes (C{str}).
         '''
+        name, _ = _name2__(**name)  # name=None
         return self._instr(name, prec, *_Names11, fmt=fmt)
 
     def transform(self, x, y, z, inverse=False, **Vector_and_kwds):
@@ -377,12 +379,12 @@ class Datum(_NamedEnumItem):
     _ellipsoid = Ellipsoids.WGS84  # default ellipsoid (L{Ellipsoid}, L{Ellipsoid2})
     _transform = Transforms.WGS84  # default transform (L{Transform})
 
-    def __init__(self, ellipsoid, transform=None, name=NN):
+    def __init__(self, ellipsoid, transform=None, **name):
         '''New L{Datum}.
 
            @arg ellipsoid: The ellipsoid (L{Ellipsoid} or L{Ellipsoid2}).
            @kwarg transform: Optional transform (L{Transform}).
-           @kwarg name: Optional, unique name (C{str}).
+           @kwarg name: Optional, unique C{B{name}=NN} (C{str}).
 
            @raise NameError: Datum with that B{C{name}} already exists.
 
@@ -396,7 +398,8 @@ class Datum(_NamedEnumItem):
         self._transform = transform or Datum._transform
         _xinstanceof(Transform, transform=self.transform)
 
-        self._register(Datums, name or self.transform.name or self.ellipsoid.name)
+        self._register(Datums, _name__(name) or self.transform.name
+                                             or self.ellipsoid.name)
 
     def __eq__(self, other):
         '''Compare this and an other datum.
@@ -473,15 +476,16 @@ class Datum(_NamedEnumItem):
         '''
         return self.ellipsoid.isSpherical
 
-    def toStr(self, sep=_COMMASPACE_, name=NN, **unused):  # PYCHOK expected
+    def toStr(self, sep=_COMMASPACE_, **name):  # PYCHOK expected
         '''Return this datum as a string.
 
            @kwarg sep: Separator to join (C{str}).
-           @kwarg name: Override name (C{str}) or C{None} to exclude
-                        this datum's name.
+           @kwarg name: Optional, override C{B{name}=NN} (C{str}) or
+                        C{None} to exclude this datum's name.
 
            @return: Datum attributes (C{str}).
         '''
+        name, _ = _name2__(**name)  # name=None
         t = [] if name is None else \
             [Fmt.EQUAL(name=repr(name or self.named))]
         for a in (_ellipsoid_, _transform_):
@@ -496,7 +500,7 @@ class Datum(_NamedEnumItem):
         return self._transform
 
 
-def _earth_datum(inst, a_earth, f=None, name=NN, raiser=_a_ellipsoid_):  # in .karney, .trf, ...
+def _earth_datum(inst, a_earth, f=None, raiser=_a_ellipsoid_, **name):  # in .karney, .trf, ...
     '''(INTERNAL) Set C{inst._datum} from C{(B{a_..}, B{f})} or C{B{.._ellipsoid}}
        (L{Ellipsoid}, L{Ellipsoid2}, L{Datum}, C{a_f2Tuple} or C{scalar} earth radius).
 
@@ -519,12 +523,12 @@ def _earth_datum(inst, a_earth, f=None, name=NN, raiser=_a_ellipsoid_):  # in .k
     inst._datum = D
 
 
-def _earth_ellipsoid(earth, *name_raiser):
+def _earth_ellipsoid(earth, **name_raiser):
     '''(INTERAL) Return the ellipsoid for the given C{earth} model.
     '''
     return Ellipsoids.Sphere if earth is  R_M else (
           _EWGS84            if earth is _EWGS84 or earth is _WGS84 else
-          _spherical_datum(earth, *name_raiser).ellipsoid)
+          _spherical_datum(earth, **name_raiser).ellipsoid)
 
 
 def _ED2(radius, name):
@@ -533,13 +537,13 @@ def _ED2(radius, name):
     D = Datums.Sphere
     E = D.ellipsoid
     if name or radius != E.a:  # != E.b
-        n = _under(name)
+        n = _under(_name__(name, _or_nameof=D))
         E =  Ellipsoid(radius, radius, name=n)
         D =  Datum(E, transform=Transforms.Identity, name=n)
     return E, D
 
 
-def _ellipsoidal_datum(earth, Error=TypeError, name=NN, raiser=NN):
+def _ellipsoidal_datum(earth, Error=TypeError, raiser=NN, **name):
     '''(INTERNAL) Create a L{Datum} from an L{Ellipsoid} or L{Ellipsoid2},
        C{a_f2Tuple}, 2-tuple or 2-list B{C{earth}} model.
 
@@ -562,29 +566,25 @@ def _ellipsoidal_datum(earth, Error=TypeError, name=NN, raiser=NN):
 def _EnD3(earth, name):
     '''(INTERNAL) Helper for C{_earth_datum} and C{_ellipsoidal_datum}.
     '''
-    D = None
+    D, n = None, _under(_name__(name, _or_nameof=earth))
     if isinstance(earth, (Ellipsoid, Ellipsoid2)):
-        E =  earth
-        n = _under(name or E.name)
+        E = earth
     elif isinstance(earth, Datum):
-        E =  earth.ellipsoid
-        n = _under(name or earth.name)
-        D =  earth
+        E = earth.ellipsoid
+        D = earth
     elif _isRadius(earth):
-        E, D = _ED2(Radius_(earth), name)
-        n =  E.name
+        E, D = _ED2(Radius_(earth), n)
+        n = E.name
     elif isinstance(earth, a_f2Tuple):
-        n = _under(name or earth.name)
-        E =  earth.ellipsoid(name=n)
+        E = earth.ellipsoid(name=n)
     elif islistuple(earth, minum=2):
-        E =  Ellipsoids.Sphere
+        E = Ellipsoids.Sphere
         a, f = earth[:2]
         if f or a != E.a:  # != E.b
-            n = _under(name or _xattr(earth, name=NN))
-            E =  Ellipsoid(a, f=f, name=n)
+            E = Ellipsoid(a, f=f, name=n)
         else:
-            n =  E.name
-            D =  Datums.Sphere
+            n = E.name
+            D = Datums.Sphere
     else:
         E, n = None, NN
     return E, n, D
@@ -623,16 +623,18 @@ def _negastr(name):  # in .trf
     return n.lstrip(p) if n.startswith(p) else NN(m, n)
 
 
-def _spherical_datum(earth, Error=TypeError, name=NN, raiser=NN):
+def _spherical_datum(earth, Error=TypeError, raiser=NN, **name):
     '''(INTERNAL) Create a L{Datum} from an L{Ellipsoid}, L{Ellipsoid2},
        C{a_f2Tuple}, 2-tuple, 2-list B{C{earth}} model or C{scalar} radius.
 
        @kwarg raiser: If not C{NN}, raise an B{C{Error}} if not spherical.
     '''
-    if _isRadius(earth):
+    if isinstance(earth, Datum):
+        D = earth
+    elif _isRadius(earth):
         _, D = _ED2(Radius_(earth, Error=Error), name)
     else:
-        D = _ellipsoidal_datum(earth, Error=Error, name=name)
+        D = _ellipsoidal_datum(earth, Error=Error, **name)
     if raiser and not D.isSpherical:
         raise _IsnotError(_spherical_, Error=Error, **{raiser: earth})
     return D
@@ -642,11 +644,11 @@ class Datums(_NamedEnum):
     '''(INTERNAL) L{Datum} registry, I{must} be a sub-class
        to accommodate the L{_LazyNamedEnumItem} properties.
     '''
-    def _Lazy(self, ellipsoid_name, transform_name, name=NN):
+    def _Lazy(self, ellipsoid_name, transform_name, **name):
         '''(INTERNAL) Instantiate the L{Datum}.
         '''
         return Datum(Ellipsoids.get(ellipsoid_name),
-                     Transforms.get(transform_name), name=name)
+                     Transforms.get(transform_name), **name)
 
 Datums = Datums(Datum)  # PYCHOK singleton
 '''Some pre-defined L{Datum}s, all I{lazily} instantiated.'''
@@ -722,7 +724,7 @@ assert _WGS84.ellipsoid is _EWGS84
 if __name__ == '__main__':
 
     from pygeodesy.interns import _COMMA_, _NL_, _NLATvar_
-    from pygeodesy.lazily import printf
+    from pygeodesy import printf
 
     # __doc__ of this file, force all into registery
     for r in (Datums, Transforms):

pygeodesy/dms.py

@@ -66,10 +66,11 @@ from pygeodesy.basics import copysign0, isLatLon, isodd, issequence, isstr, map2
 from pygeodesy.constants import _umod_360, _0_0, _0_5, _60_0, _360_0, _3600_0
 from pygeodesy.errors import ParseError, RangeError, _TypeError, _ValueError,\
                             _parseX, rangerrors, _xkwds, _xkwds_get
-from pygeodesy.interns import NN, _arg_, _COMMA_, _d_, _DASH_, _deg_, _degrees_, _DOT_, \
-                             _0_, _e_, _E_, _EW_, _f_, _F_, _g_, _MINUS_, _N_, _NE_, _NS_, \
-                             _NSEW_, _NW_, _of_, _PERCENTDOTSTAR_, _PLUS_, _PLUSMINUS_, \
-                             _QUOTE1_, _QUOTE2_, _radians_, _S_, _SE_, _SPACE_, _SW_, _W_
+from pygeodesy.interns import NN, _arg_, _COMMA_, _d_, _DASH_, _deg_, _degrees_, \
+                             _DOT_, _0_, _e_, _E_, _EW_, _f_, _F_, _g_, _keyword_, \
+                             _MINUS_, _N_, _NE_, _NS_, _NSEW_, _NW_, _of_, \
+                             _PERCENTDOTSTAR_, _PLUS_, _PLUSMINUS_, _QUOTE1_, \
+                             _QUOTE2_, _radians_, _S_, _SE_, _SPACE_, _SW_, _W_
 from pygeodesy.lazily import _ALL_LAZY, _ALL_MODS as _MODS, _getenv
 # from pygeodesy.namedTuples import LatLon2Tuple  # _MODS
 # from pygeodesy.props import _throwarning  # _MODS
@@ -84,12 +85,11 @@ except ImportError:  # Python 3+
     from string import ascii_letters as _LETTERS
 
 __all__ = _ALL_LAZY.dms
-__version__ = '24.03.21'
+__version__ = '24.05.18'
 
 _beyond_      = 'beyond'
 _DDDMMSS_     = 'DDDMMSS'
 _deg_min_     = 'deg+min'
-_keyword_     = 'keyword'
 _SDIGITS_     = '-0123456789+'
 _sexagecimal_ = 'sexagecimal'
 _SEXAGECIMUL  =  1.e4  # sexagecimal C{D.MMSSss} into decimal C{DMMSS.ss}

pygeodesy/ecef.py

@@ -73,7 +73,7 @@ from pygeodesy.interns import NN, _a_, _C_, _datum_, _ellipsoid_, _f_, _height_,
                              _lat_, _lon_, _M_, _name_, _singular_, _SPACE_, \
                              _x_, _xyz_, _y_, _z_
 from pygeodesy.lazily import _ALL_DOCS, _ALL_LAZY, _ALL_MODS as _MODS
-from pygeodesy.named import _NamedBase, _NamedTuple, _Pass, _xnamed
+from pygeodesy.named import _name__, _NamedBase, _NamedTuple, _Pass, _xnamed
 from pygeodesy.namedTuples import LatLon2Tuple, LatLon3Tuple, \
                                   PhiLam2Tuple, Vector3Tuple, Vector4Tuple
 from pygeodesy.props import deprecated_method, Property_RO, property_RO, property_doc_
@@ -86,7 +86,7 @@ from pygeodesy.utily import atan1, atan1d, atan2d, degrees90, degrees180, \
 from math import atan2, cos, degrees, fabs, radians, sqrt
 
 __all__ = _ALL_LAZY.ecef
-__version__ = '24.05.04'
+__version__ = '24.05.21'
 
 _Ecef_    = 'Ecef'
 _prolate_ = 'prolate'
@@ -108,7 +108,7 @@ class _EcefBase(_NamedBase):
     _E     = _EWGS84
     _lon00 =  INT0  # arbitrary, "polar" lon for LocalCartesian, Ltp
 
-    def __init__(self, a_ellipsoid=_EWGS84, f=None, name=NN, lon00=INT0):
+    def __init__(self, a_ellipsoid=_EWGS84, f=None, lon00=INT0, **name):
         '''New C{Ecef*} converter.
 
            @arg a_ellipsoid: A (non-prolate) ellipsoid (L{Ellipsoid}, L{Ellipsoid2},
@@ -117,9 +117,9 @@ class _EcefBase(_NamedBase):
            @kwarg f: C{None} or the ellipsoid flattening (C{scalar}), required
                      for C{scalar} B{C{a_ellipsoid}}, C{B{f}=0} represents a
                      sphere, negative B{C{f}} a prolate ellipsoid.
-           @kwarg name: Optional name (C{str}).
            @kwarg lon00: An arbitrary, I{"polar"} longitude (C{degrees}), see the
-                         methods C{reverse}.
+                         C{reverse} method.
+           @kwarg name: Optional C{B{name}=NN} (C{str}).
 
            @raise EcefError: If B{C{a_ellipsoid}} not L{Ellipsoid}, L{Ellipsoid2},
                              L{Datum} or L{a_f2Tuple} or C{scalar} or B{C{f}} not
@@ -136,7 +136,7 @@ class _EcefBase(_NamedBase):
                 raise ValueError  # _invalid_
 
             if E not in (_EWGS84, _WGS84):
-                d = _ellipsoidal_datum(E, name=name)
+                d = _ellipsoidal_datum(E, **name)
                 E =  d.ellipsoid
                 if E.a < EPS or E.f > EPS1:
                     raise ValueError  # _invalid_
@@ -211,7 +211,7 @@ class _EcefBase(_NamedBase):
                                              0, m, self.datum,
                                              name=name or self.name)
 
-    def forward(self, latlonh, lon=None, height=0, M=False, name=NN):
+    def forward(self, latlonh, lon=None, height=0, M=False, **name):
         '''Convert from geodetic C{(lat, lon, height)} to geocentric C{(x, y, z)}.
 
            @arg latlonh: Either a C{LatLon}, an L{Ecef9Tuple} or C{scalar}
@@ -221,7 +221,7 @@ class _EcefBase(_NamedBase):
            @kwarg height: Optional height (C{meter}), vertically above (or below)
                           the surface of the ellipsoid.
            @kwarg M: Optionally, return the rotation L{EcefMatrix} (C{bool}).
-           @kwarg name: Optional name (C{str}).
+           @kwarg name: Optional C{B{name}=NN} (C{str}).
 
            @return: An L{Ecef9Tuple}C{(x, y, z, lat, lon, height, C, M, datum)} with
                     geocentric C{(x, y, z)} coordinates for the given geodetic ones
@@ -235,10 +235,10 @@ class _EcefBase(_NamedBase):
            @note: Use method C{.forward_} to specify C{lat} and C{lon} in C{radians}
                   and avoid double angle conversions.
         '''
-        llhn = _llhn4(latlonh, lon, height, name=name)
+        llhn = _llhn4(latlonh, lon, height, **name)
         return self._forward(*llhn, M=M)
 
-    def forward_(self, phi, lam, height=0, M=False, name=NN):
+    def forward_(self, phi, lam, height=0, M=False, **name):
         '''Like method C{.forward} except with geodetic lat- and longitude given
            in I{radians}.
 
@@ -247,7 +247,7 @@ class _EcefBase(_NamedBase):
            @kwarg height: Optional height (C{meter}), vertically above (or below)
                           the surface of the ellipsoid.
            @kwarg M: Optionally, return the rotation L{EcefMatrix} (C{bool}).
-           @kwarg name: Optional name (C{str}).
+           @kwarg name: Optional C{B{name}=NN} (C{str}).
 
            @return: An L{Ecef9Tuple}C{(x, y, z, lat, lon, height, C, M, datum)}
                     with C{lat} set to C{degrees90(B{phi})} and C{lon} to
@@ -255,8 +255,8 @@ class _EcefBase(_NamedBase):
 
            @raise EcefError: If B{C{phi}} or B{C{lam}} invalid or not C{scalar}.
         '''
-        try:  # like function C{_llhn4} above
-            plhn = Phi(phi), Lam(lam), Height(height), name
+        try:  # like function C{_llhn4} below
+            plhn = Phi(phi), Lam(lam), Height(height), _name__(name)
         except (TypeError, ValueError) as x:
             raise EcefError(phi=phi, lam=lam, height=height, cause=x)
         return self._forward(*plhn, M=M, _philam=True)
@@ -646,7 +646,7 @@ class EcefSudano(_EcefBase):
 
         _a  = fabs
         lat = atan1d(z, R * E.e21)
-        sa, ca = sincos2d(fabs(lat))
+        sa, ca = sincos2d(_a(lat))
         # Sudano's Eq (A-6) and (A-7) refactored/reduced,
         # replacing Rn from Eq (A-4) with n = E.a / ca:
         # N = ca**2 * ((z + E.e2 * n * sa) * ca - R * sa)
@@ -656,17 +656,18 @@ class EcefSudano(_EcefBase):
         #   = ca**2 * (E.e2 * E.a / E.e2s2(sa) - R / ca**2)
         # N / D = (z * ca + (E.e2 * E.a - R) * sa) /
         #         (E.e2 * E.a / E.e2s2(sa) - R / ca**2)
+        _E  = EPS_2
         tol = self.tolerance
         _S2 = Fsum(sa).fsum2f_
         _rt = sqrt
         for i in range(1, _TRIPS):
             ca2 = _1_0 - sa**2
-            if ca2 < EPS_2:  # PYCHOK no cover
+            if ca2 < _E:  # PYCHOK no cover
                 ca = _0_0
                 break
             ca = _rt(ca2)
             r = e / E.e2s2(sa) - R / ca2
-            if _a(r) < EPS_2:
+            if _a(r) < _E:
                 break
             lat = None
             sa, r = _S2(-z * ca / r, -d * sa / r)
@@ -1271,25 +1272,24 @@ def _4Ecef(this, Ecef):  # in .datums.Datum.ecef, .ellipsoids.Ellipsoid.ecef
     return Ecef(this, name=this.name)
 
 
-def _llhn4(latlonh, lon, height, suffix=NN, Error=EcefError, name=NN):  # in .ltp
+def _llhn4(latlonh, lon, height, suffix=NN, Error=EcefError, **name):  # in .ltp
     '''(INTERNAL) Get a C{(lat, lon, h, name)} 4-tuple.
     '''
     try:
         lat, lon = latlonh.lat, latlonh.lon
         h = _xattr(latlonh, height=_xattr(latlonh, h=height))
-        n = _xattr(latlonh, name=NN)
+        n = _name__(name, _or_nameof=latlonh)  # == latlonh._name__(name)
     except AttributeError:
-        lat, h, n = latlonh, height, NN
+        lat, h, n = latlonh, height, _name__(**name)
 
     try:
-        llhn = Lat(lat), Lon(lon), Height(h), (name or n)
+        return Lat(lat), Lon(lon), Height(h), n
     except (TypeError, ValueError) as x:
         t = _lat_, _lon_, _height_
         if suffix:
             t = (_ + suffix for _ in t)
         d = dict(zip(t, (lat, lon, h)))
         raise Error(cause=x, **d)
-    return llhn
 
 
 def _xEcef(Ecef):  # PYCHOK .latlonBase
@@ -1301,22 +1301,22 @@ def _xEcef(Ecef):  # PYCHOK .latlonBase
 
 
 # kwd lon00 unused but will throw a TypeError if misspelled, etc.
-def _xyzn4(xyz, y, z, Types, Error=EcefError, name=NN,   # PYCHOK unused
-                     _xyz_y_z_names=_xyz_y_z, lon00=0):  # in .ltp
+def _xyzn4(xyz, y, z, Types, Error=EcefError, lon00=0,  # PYCHOK unused
+                     _xyz_y_z_names=_xyz_y_z, **name):  # in .ltp
     '''(INTERNAL) Get an C{(x, y, z, name)} 4-tuple.
     '''
     try:
+        n = _name__(name, _or_nameof=xyz)  # == xyz._name__(name)
         try:
-            t = xyz.x, xyz.y, xyz.z, _xattr(xyz, name=name)
+            t = xyz.x, xyz.y, xyz.z, n
             if not isinstance(xyz, Types):
                 raise _TypesError(_xyz_y_z_names[0], xyz, *Types)
         except AttributeError:
-            t = map1(float, xyz, y, z) + (name,)
-
+            t = map1(float, xyz, y, z) + (n,)
+        return t
     except (TypeError, ValueError) as x:
         d = dict(zip(_xyz_y_z_names, (xyz, y, z)))
         raise Error(cause=x, **d)
-    return t
 # assert _xyz_y_z == _MODS.basics._args_kwds_names(_xyzn4)[:3]
 
 

pygeodesy/elevations.py

@@ -34,7 +34,7 @@ from pygeodesy.units import Lat, Lon, Meter, Scalar, Str
 # from math import fabs  # from .karney
 
 __all__ = _ALL_LAZY.elevations
-__version__ = '23.05.26'
+__version__ = '24.05.13'
 
 try:
     from urllib2 import urlopen  # quote, urlcleanup
@@ -245,7 +245,7 @@ def geoidHeight2(lat, lon, model=0, timeout=2.0):
 
 if __name__ == '__main__':
 
-    from pygeodesy.lazily import printf
+    from pygeodesy import printf
     # <https://WikiPedia.org/wiki/Mount_Diablo>
     for f in (elevation2,     # (1173.79, '3DEP 1/3 arc-second')
               geoidHeight2):  # (-31.699, u'GEOID12B')