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

pygeodesy/datums.py

@@ -73,8 +73,7 @@ from pygeodesy.constants import R_M, _float as _F, _0_0, _1_0, _2_0, _8_0, _3600
 #                                          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_, \
@@ -84,7 +83,8 @@ from pygeodesy.interns import NN, _a_, _Airy1830_, _AiryModified_, _BAR_, _Besse
                              _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
@@ -94,7 +94,7 @@ from pygeodesy.units import _isRadius, Radius_,  radians
 # import operator as _operator  # from .fmath
 
 __all__ = _ALL_LAZY.datums
-__version__ = '24.05.14'
+__version__ = '24.05.21'
 
 _a_ellipsoid_ = _UNDER_(_a_, _ellipsoid_)
 _BD72_        = 'BD72'
@@ -204,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
@@ -248,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):
@@ -378,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.
 
@@ -397,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.
@@ -474,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_):
@@ -497,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).
 
@@ -520,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):
@@ -534,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.
 
@@ -563,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
@@ -624,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
@@ -643,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.'''

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.10'
+__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)
@@ -1272,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
@@ -1302,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/ellipsoidalBase.py

@@ -24,8 +24,9 @@ from pygeodesy.errors import _incompatible, _IsnotError, RangeError, _TypeError,
 # from pygeodesy.fmath import favg  # _MODS
 from pygeodesy.interns import NN, _COMMA_, _ellipsoidal_
 from pygeodesy.latlonBase import LatLonBase, _trilaterate5,  fabs, _Wrap
-from pygeodesy.lazily import _ALL_DOCS, _ALL_LAZY, _ALL_MODS as _MODS
+# from pygeodesy.lazily import _ALL_DOCS, _ALL_LAZY, _ALL_MODS as _MODS  # from .named
 # from pygeodesy.lcc import toLcc  # _MODS
+from pygeodesy.named import _name1__,  _ALL_DOCS, _ALL_LAZY, _MODS
 # from pygeodesy.namedTuples import Vector3Tuple  # _MODS
 from pygeodesy.props import deprecated_method, deprecated_property_RO, \
                             Property_RO, property_doc_, property_RO, _update_all
@@ -36,7 +37,7 @@ from pygeodesy.units import Epoch, _isDegrees, Radius_, _1mm as _TOL_M
 # from math import fabs  # from .latlonBase
 
 __all__ = _ALL_LAZY.ellipsoidalBase
-__version__ = '24.04.07'
+__version__ = '24.05.21'
 
 
 class CartesianEllipsoidalBase(CartesianBase):
@@ -46,8 +47,8 @@ class CartesianEllipsoidalBase(CartesianBase):
     _epoch   =  None   # overriding .reframe.epoch (C{float})
     _reframe =  None   # reference frame (L{RefFrame})
 
-    def __init__(self, x_xyz, y=None, z=None, datum=None, reframe=None,
-                                              epoch=None, ll=None, name=NN):
+    def __init__(self, x_xyz, y=None, z=None, reframe=None, epoch=None,
+                                                       **datum_ll_name):
         '''New ellispoidal C{Cartesian...}.
 
            @kwarg reframe: Optional reference frame (L{RefFrame}).
@@ -61,9 +62,9 @@ class CartesianEllipsoidalBase(CartesianBase):
                              not a L{Datum}, B{C{reframe}} is not a L{RefFrame} or
                              B{C{epoch}} is not C{scalar} non-zero.
 
-           @see: Super-class L{CartesianBase<CartesianBase.__init__>} for more details.
+           @see: Class L{CartesianBase<CartesianBase.__init__>} for more details.
         '''
-        CartesianBase.__init__(self, x_xyz, y=y, z=z, datum=datum, ll=ll, name=name)
+        CartesianBase.__init__(self, x_xyz, y=y, z=z, **datum_ll_name)
         if reframe:
             self.reframe = reframe
             self.epoch = epoch
@@ -171,7 +172,7 @@ class CartesianEllipsoidalBase(CartesianBase):
             kwds = _xkwds(kwds, reframe=self.reframe, epoch=self.epoch)
         return CartesianBase.toLatLon(self, datum=datum, height=height, **kwds)
 
-    def toRefFrame(self, reframe2, reframe=None, epoch=None, epoch2=None, name=NN):
+    def toRefFrame(self, reframe2, reframe=None, epoch=None, epoch2=None, **name):
         '''Convert this point to an other reference frame and epoch.
 
            @arg reframe2: Reference frame to convert I{to} (L{RefFrame}).
@@ -181,7 +182,7 @@ class CartesianEllipsoidalBase(CartesianBase):
                          this point's C{epoch or B{reframe}.epoch}.
            @kwarg epoch2: Optional epoch to observe for the converted point (L{Epoch},
                           C{scalar} or C{str}), otherwise B{C{epoch}}.
-           @kwarg name: Optional name (C{str}), C{B{reframe2}.name} iff converted.
+           @kwarg name: Optional C{B{name}=NN} (C{str}), overriding C{B{reframe2}.name}.
 
            @return: The converted point (ellipsoidal C{Cartesian}) or if conversion
                     C{isunity}, this point or a copy of this point if the B{C{name}}
@@ -194,7 +195,7 @@ class CartesianEllipsoidalBase(CartesianBase):
            @raise TypeError: B{C{reframe2}} or B{C{reframe}} not a L{RefFrame}.
         '''
         return _MODS.trf._toRefFrame(self, reframe2, reframe=reframe, epoch=epoch,
-                                                      epoch2=epoch2, name=name)
+                                                     epoch2=epoch2, **name)
 
     @deprecated_method
     def toTransforms_(self, *transforms, **datum):  # PYCHOK no cover
@@ -217,8 +218,8 @@ class LatLonEllipsoidalBase(LatLonBase):
     _scale          =  None   # UTM/UPS scale factor (C{float})
     _toLLEB_args    = ()      # Etm/Utm/Ups._toLLEB arguments
 
-    def __init__(self, latlonh, lon=None, height=0, datum=None, reframe=None,
-                                          epoch=None, wrap=False, name=NN):
+    def __init__(self, latlonh, lon=None, height=0, datum=_WGS84, reframe=None,
+                                          epoch=None, wrap=False, **name):
         '''Create an ellipsoidal C{LatLon} point from the given lat-, longitude
            and height on the given datum, reference frame and epoch.
 
@@ -236,7 +237,7 @@ class LatLonEllipsoidalBase(LatLonBase):
                          if C{B{reframe}=None}.
            @kwarg wrap: If C{True}, wrap or I{normalize} B{C{lat}} and B{C{lon}}
                         (C{bool}).
-           @kwarg name: Optional name (C{str}).
+           @kwarg name: Optional C{B{name}=NN} (C{str}).
 
            @raise RangeError: Value of C{lat} or B{C{lon}} outside the valid
                               range and L{rangerrors} set to C{True}.
@@ -247,9 +248,9 @@ class LatLonEllipsoidalBase(LatLonBase):
 
            @raise UnitError: Invalid B{C{lat}}, B{C{lon}} or B{C{height}}.
         '''
-        LatLonBase.__init__(self, latlonh, lon=lon, height=height, wrap=wrap, name=name)
+        LatLonBase.__init__(self, latlonh, lon=lon, height=height, wrap=wrap, **name)
         if datum not in (None, self._datum, _EWGS84):
-            self.datum = _ellipsoidal_datum(datum, name=name)
+            self.datum = _ellipsoidal_datum(datum, name=self.name)
         if reframe:
             self.reframe = reframe
             self.epoch = epoch
@@ -736,7 +737,7 @@ class LatLonEllipsoidalBase(LatLonBase):
         return _MODS.osgr.toOsgr(self, kTM=True, name=self.name)  # datum=self.datum
 
     def parse(self, strllh, height=0, datum=None, epoch=None, reframe=None,
-                                        sep=_COMMA_, wrap=False, name=NN):
+                                        sep=_COMMA_, wrap=False, **name):
         '''Parse a string consisting of C{"lat, lon[, height]"},
            representing a similar, ellipsoidal C{LatLon} point.
 
@@ -753,7 +754,7 @@ class LatLonEllipsoidalBase(LatLonBase):
            @kwarg sep: Optional separator (C{str}).
            @kwarg wrap: If C{True}, wrap or I{normalize} the lat-
                         and longitude (C{bool}).
-           @kwarg name: Optional instance name (C{str}), overriding
+           @kwarg name: Optional C{B{name}=NN} (C{str}), overriding
                         this name.
 
            @return: The similar point (ellipsoidal C{LatLon}).
@@ -768,7 +769,7 @@ class LatLonEllipsoidalBase(LatLonBase):
             r.epoch = epoch
         if reframe not in (None, self.reframe):
             r.reframe = reframe
-        return self._xnamed(r, name=name, force=True) if name else r
+        return self._xnamed(r, force=True, **name) if name else r
 
     def _Radjust2(self, adjust, datum, meter_text2):
         '''(INTERNAL) Adjust an C{elevation} or C{geoidHeight} with
@@ -834,15 +835,15 @@ class LatLonEllipsoidalBase(LatLonBase):
            @see: Function L{pygeodesy.toCss}.
         '''
         return self._css if not toCss_kwds else _MODS.css.toCss(
-               self, **_xkwds(toCss_kwds, name=self.name))
+               self, **_name1__(toCss_kwds, _or_nameof=self))
 
-    def toDatum(self, datum2, height=None, name=NN):
+    def toDatum(self, datum2, height=None, **name):
         '''Convert this point to an other datum.
 
            @arg datum2: Datum to convert I{to} (L{Datum}).
            @kwarg height: Optional height, overriding the
                           converted height (C{meter}).
-           @kwarg name: Optional name (C{str}), iff converted.
+           @kwarg name: Optional C{B{name}=NN} (C{str}).
 
            @return: The converted point (ellipsoidal C{LatLon})
                     or a copy of this point if B{C{datum2}}
@@ -850,10 +851,10 @@ class LatLonEllipsoidalBase(LatLonBase):
 
            @raise TypeError: Invalid B{C{datum2}}.
         '''
-        n  =  name or self.name
+        n  =  self._name__(name)
         d2 = _ellipsoidal_datum(datum2, name=n)
         if self.datum == d2:
-            r = self.copy(name=name)
+            r = self.copy(name=n)
         else:
             kwds = _xkwds_not(None, LatLon=self.classof, name=n,
                                     epoch=self.epoch, reframe=self.reframe)
@@ -871,7 +872,7 @@ class LatLonEllipsoidalBase(LatLonBase):
            @see: Function L{pygeodesy.toEtm8}.
         '''
         return self._etm if not toEtm8_kwds else _MODS.etm.toEtm8(
-               self, **_xkwds(toEtm8_kwds, name=self.name))
+               self, **_name1__(toEtm8_kwds, _or_nameof=self))
 
     def toLcc(self, **toLcc_kwds):
         '''Convert this C{LatLon} point to a Lambert location.
@@ -883,7 +884,7 @@ class LatLonEllipsoidalBase(LatLonBase):
            @see: Function L{pygeodesy.toLcc}.
         '''
         return self._lcc if not toLcc_kwds else _MODS.lcc.toLcc(
-               self, **_xkwds(toLcc_kwds, name=self.name))
+               self, **_name1__(toLcc_kwds, _or_nameof=self))
 
     def toMgrs(self, center=False, pole=NN):
         '''Convert this C{LatLon} point to an MGRS coordinate.
@@ -918,7 +919,7 @@ class LatLonEllipsoidalBase(LatLonBase):
             r =  self._osgrTM if kTM else self._osgr
         return r
 
-    def toRefFrame(self, reframe2, reframe=None, epoch=None, epoch2=None, height=None, name=NN):
+    def toRefFrame(self, reframe2, reframe=None, epoch=None, epoch2=None, height=None, **name):
         '''Convert this point to an other reference frame and epoch.
 
            @arg reframe2: Reference frame to convert I{to} (L{RefFrame}).
@@ -929,7 +930,7 @@ class LatLonEllipsoidalBase(LatLonBase):
            @kwarg epoch2: Optional epoch to observe for the converted point (L{Epoch},
                           C{scalar} or C{str}), otherwise B{C{epoch}}.
            @kwarg height: Optional height, overriding the converted height (C{meter}).
-           @kwarg name: Optional name (C{str}), C{B{reframe2}.name} iff converted.
+           @kwarg name: Optional C{B{name}=NN} (C{str}), overriding C{B{reframe2}.name}.
 
            @return: The converted point (ellipsoidal C{LatLon}) or if conversion
                     C{isunity}, this point or a copy of this point if the B{C{name}}
@@ -942,7 +943,7 @@ class LatLonEllipsoidalBase(LatLonBase):
            @raise TypeError: B{C{reframe2}} or B{C{reframe}} not a L{RefFrame}.
         '''
         return _MODS.trf._toRefFrame(self, reframe2, reframe=reframe, epoch=epoch,
-                                           epoch2=epoch2, name=name, height=height)
+                                           epoch2=epoch2, height=height, **name)
 
     def toTransform(self, transform, inverse=False, datum=None, **LatLon_kwds):
         '''Apply a Helmert transform to this geodetic point.

pygeodesy/ellipsoidalBaseDI.py

@@ -17,7 +17,6 @@ from pygeodesy.errors import _AssertionError, IntersectionError, _IsnotError, \
 from pygeodesy.fmath import favg, fmean_
 from pygeodesy.fsums import Fmt, fsumf_
 from pygeodesy.formy import _isequalTo, opposing, _radical2
-# from pygeodesy.internals import _dunder_nameof  # from .lazily
 from pygeodesy.interns import _antipodal_, _concentric_, _ellipsoidal_, \
                               _exceed_PI_radians_, _low_, _near_, \
                               _SPACE_, _too_
@@ -36,7 +35,7 @@ from pygeodesy.utily import m2km, unroll180, _unrollon, _unrollon3, \
 from math import degrees, radians
 
 __all__ = _ALL_LAZY.ellipsoidalBaseDI
-__version__ = '24.05.13'
+__version__ = '24.05.19'
 
 _polar__  = 'polar?'
 _B2END    = _1_5  # _intersect3 bearing to pseudo-end point factor
@@ -400,12 +399,12 @@ class LatLonEllipsoidalBaseDI(LatLonEllipsoidalBase):
 
         f, j = _fi_j2(f, len(Ps))  # like .vector3d.nearestOn6
 
-        n = self.nearestOn8.__name__
+        n = self.nearestOn8.__name__  # _dunder_nameof
         c.rename(n)
         if s is not c:
             s = s.copy(name=n)
         if e is not c:
-            e = e.copy(name=n)
+            e = e.copy(name=n)  # name__=self.nearestOn8
         return NearestOn8Tuple(c, c3.distance, f, j, s, e, c3.initial, c3.final,
                                iteration=m)  # ._iteration for tests