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

pygeodesy/named.py

@@ -14,25 +14,26 @@ standard Python C{namedtuple}s.
 '''
 
 from pygeodesy.basics import isclass, isidentifier, iskeyword, isstr, issubclassof, \
-                             itemsorted, len2, _sizeof, _xcopy, _xdup, _zip
+                             itemsorted, len2, _xcopy, _xdup, _zip
 from pygeodesy.errors import _AssertionError, _AttributeError, _incompatible, \
                              _IndexError, _IsnotError, _KeyError, LenError, \
                              _NameError, _NotImplementedError, _TypeError, \
                              _TypesError, UnitError, _ValueError, _xattr, _xkwds, \
-                             _xkwds_get, _xkwds_item2, _xkwds_pop2
+                             _xkwds_item2, _xkwds_pop2
+from pygeodesy.internals import _caller3, _dunder_nameof, _isPyPy, _sizeof, _under
 from pygeodesy.interns import MISSING, NN, _AT_, _COLON_, _COLONSPACE_, _COMMA_, \
-                             _COMMASPACE_, _doesn_t_exist_, _DOT_, _DUNDER_, _EQUAL_, \
-                             _exists_, _immutable_, _name_, _NL_, _NN_, _no_, _other_, \
-                             _s_, _SPACE_, _std_, _UNDER_, _valid_, _vs_, \
-                             _dunder_nameof, _isPyPy, _under
-from pygeodesy.lazily import _ALL_DOCS, _ALL_LAZY, _ALL_MODS as _MODS, _caller3, _getenv
+                             _COMMASPACE_, _doesn_t_exist_, _DOT_, _DUNDER_, \
+                             _dunder_name_, _EQUAL_, _exists_, _immutable_, _name_, \
+                             _NL_, _NN_, _no_, _other_, _s_, _SPACE_, _std_, \
+                             _UNDER_, _valid_, _vs_
+from pygeodesy.lazily import _ALL_DOCS, _ALL_LAZY, _ALL_MODS as _MODS, _getenv
 from pygeodesy.props import _allPropertiesOf_n, deprecated_method, _hasProperty, \
                             _update_all, property_doc_, Property_RO, property_RO, \
                             _update_attrs
 from pygeodesy.streprs import attrs, Fmt, lrstrip, pairs, reprs, unstr
 
 __all__ = _ALL_LAZY.named
-__version__ = '24.05.04'
+__version__ = '24.05.21'
 
 _COMMANL_           = _COMMA_ + _NL_
 _COMMASPACEDOT_     = _COMMASPACE_ + _DOT_
@@ -44,32 +45,37 @@ _name               = _under(_name_)
 _Names_             = '_Names_'
 _registered_        = 'registered'  # PYCHOK used!
 _std_NotImplemented = _getenv('PYGEODESY_NOTIMPLEMENTED', NN).lower() == _std_
+_such_              = 'such'
 _Units_             = '_Units_'
 _UP                 =  2
 
 
-def _xjoined_(prefix, name, enquote=True):
-    '''(INTERNAL) Join C{pref} and non-empty C{name}.
+def _xjoined_(prefix, name=NN, enquote=True, **name__of_name):
+    '''(INTERNAL) Join C{prefix} and non-empty C{name}.
     '''
+    if name__of_name:
+        name = _name__(name, **name__of_name)
     if name and prefix:
         if enquote:
             name = repr(name)
-        n = _SPACE_(prefix, name)
+        t = _SPACE_(prefix, name)
     else:
-        n =  prefix or name
-    return n
+        t =  prefix or name
+    return t
 
 
-def _xnamed(inst, name, force=False):
+def _xnamed(inst, name=NN, force=False, **name__of_name):
     '''(INTERNAL) Set the instance' C{.name = B{name}}.
 
        @arg inst: The instance (C{_Named}).
-       @arg name: The name (C{str}).
-       @kwarg force: Force name change (C{bool}).
+       @kwarg name: The name (C{str}).
+       @kwarg force: If C{True}, force rename (C{bool}).
 
-       @return: The B{C{inst}}, named if B{C{force}}d or
-                not named before.
+       @return: The B{C{inst}}, renamed if B{C{force}}d
+                or if not named before.
     '''
+    if name__of_name:
+        name = _name__(name, **name__of_name)
     if name and isinstance(inst, _Named):
         if not inst.name:
             inst.name = name
@@ -84,7 +90,7 @@ def _xother3(inst, other, name=_other_, up=1, **name_other):
     if name_other:  # and other is None
         name, other = _xkwds_item2(name_other)
     elif other and len(other) == 1:
-        other = other[0]
+        name, other = _name__(name), other[0]
     else:
         raise _AssertionError(name, other, txt=classname(inst, prefixed=True))
     return other, name, up
@@ -164,6 +170,7 @@ class ADict(dict):
            C{floats} formatted by function L{pygeodesy.fstr}.
         '''
         n = _xattr(self, name=NN) or self.__class__.__name__
+        print(1, n)
         return Fmt.PAREN(n, self._toT(_EQUAL_, **prec_fmt))
 
     def toStr(self, **prec_fmt):
@@ -258,18 +265,18 @@ class _Named(object):
         '''
         return _xnamed(self.__class__(*args, **kwds), self.name)
 
-    def copy(self, deep=False, name=NN):
+    def copy(self, deep=False, **name):
         '''Make a shallow or deep copy of this instance.
 
            @kwarg deep: If C{True} make a deep, otherwise
                         a shallow copy (C{bool}).
-           @kwarg name: Optional, non-empty name (C{str}).
+           @kwarg name: Optional, non-empty C{B{name}=NN} (C{str}).
 
            @return: The copy (C{This class}).
         '''
         c = _xcopy(self, deep=deep)
         if name:
-            c.rename(name)
+            _ = c.rename(name)
         return c
 
     def _DOT_(self, *names):
@@ -281,7 +288,8 @@ class _Named(object):
         '''Duplicate this instance, replacing some attributes.
 
            @kwarg deep: If C{True} duplicate deep, otherwise shallow.
-           @kwarg items: Attributes to be changed (C{any}).
+           @kwarg items: Attributes to be changed (C{any}), including
+                         optional C{B{name}} (C{str}).
 
            @return: The duplicate (C{This class}).
 
@@ -291,7 +299,7 @@ class _Named(object):
         m, items = _xkwds_pop2(items, name=n)
         d = _xdup(self, deep=deep, **items)
         if m != n:
-            d.rename(m)
+            d.rename(m)  # zap _Named_Property_ROs
 #       if items:
 #           _update_all(d)
         return d
@@ -340,11 +348,11 @@ class _Named(object):
 
     @name.setter  # PYCHOK setter!
     def name(self, name):
-        '''Set the name (C{str}).
+        '''Set the C{B{name}=NN} (C{str}).
 
            @raise NameError: Can't rename, use method L{rename}.
         '''
-        m, n = self._name, str(name)
+        m, n = self._name, _name__(name)
         if not m:
             self._name = n
         elif n != m:
@@ -360,6 +368,11 @@ class _Named(object):
         #  _Named.name.fset(self, name), but NOT
         #  _Named(self).name = name
 
+    def _name__(self, name):  # usually **name
+        '''(INTERNAL) Get the C{name} or this C{name}.
+        '''
+        return _name__(name, _or_nameof=self)  # nameof(self)
+
     @Property_RO
     def named(self):
         '''Get the name I{or} class name or C{""} (C{str}).
@@ -407,12 +420,22 @@ class _Named(object):
 
            @return: The previous name (C{str}).
         '''
-        m, n = self._name, str(name)
+        m, n = self._name, _name__(name)
         if n != m:
             self._name = n
             _update_attrs(self, *_Named_Property_ROs)
         return m
 
+    def renamed(self, name):
+        '''Change the name.
+
+           @arg name: The new name (C{str}).
+
+           @return: This instance (C{str}).
+        '''
+        _ = self.rename(name)
+        return self
+
     @property_RO
     def sizeof(self):
         '''Get the current size in C{bytes} of this instance (C{int}).
@@ -442,16 +465,17 @@ class _Named(object):
 #       '''
 #       return _DOT_(self, unstr(which, *args, **kwds))
 
-    def _xnamed(self, inst, name=NN, force=False):
+    def _xnamed(self, inst, name=NN, **force):
         '''(INTERNAL) Set the instance' C{.name = self.name}.
 
            @arg inst: The instance (C{_Named}).
-           @kwarg name: Optional name, overriding C{self.name} (C{str}).
-           @kwarg force: Force name change (C{bool}).
+           @kwarg name: The name (C{str}).
+           @kwarg force: If C{True}, force rename (C{bool}).
 
-           @return: The B{C{inst}}, named if not named before.
+           @return: The B{C{inst}}, renamed if B{C{force}}d
+                    or if not named before.
         '''
-        return _xnamed(inst, name or self.name, force=force)
+        return _xnamed(inst, name, **force)
 
     def _xrenamed(self, inst):
         '''(INTERNAL) Rename the instance' C{.name = self.name}.
@@ -465,7 +489,7 @@ class _Named(object):
         if not isinstance(inst, _Named):
             raise _IsnotError(_valid_, inst=inst)
 
-        inst.rename(self.name)
+        _ = inst.rename(self.name)
         return inst
 
 _Named_Property_ROs = _allPropertiesOf_n(5, _Named, Property_RO)  # PYCHOK once
@@ -558,16 +582,17 @@ class _NamedBase(_Named):
 
 
 class _NamedDict(ADict, _Named):
-    '''(INTERNAL) Named C{dict} with key I{and} attribute
-       access to the items.
+    '''(INTERNAL) Named C{dict} with key I{and} attribute access
+       to the items.
     '''
     def __init__(self, *args, **kwds):
-        if args:  # args override kwds
+        if args:  # is args[0] a dict?
             if len(args) != 1:  # or not isinstance(args[0], dict)
+                kwds = _name1__(kwds)
                 t = unstr(self.classname, *args, **kwds)  # PYCHOK no cover
                 raise _ValueError(args=len(args), txt=t)
-            kwds = _xkwds(dict(args[0]), **kwds)
-        n, kwds = _xkwds_pop2(kwds, name=NN)
+            kwds = _xkwds(dict(args[0]), **kwds)  # args[0] overrides kwds
+        n, kwds = _name2__(**kwds)
         if n:
             _Named.name.fset(self, n)  # see _Named.name
         ADict.__init__(self, kwds)
@@ -639,7 +664,7 @@ class _NamedEnum(_NamedDict):
            @arg Classes: Additional, acceptable classes or C{type}s.
         '''
         self._item_Classes = (Class,) + Classes
-        n = _xkwds_get(name, name=NN) or NN(Class.__name__, _s_)
+        n = _name__(**name) or NN(Class.__name__, _s_)  # _dunder_nameof
         if n and _xvalid(n, underOK=True):
             _Named.name.fset(self, n)  # see _Named.name
 
@@ -662,12 +687,13 @@ class _NamedEnum(_NamedDict):
         '''(INTERNAL) Check attribute name against given, registered name.
         '''
         pypy = _isPyPy()
+        _isa =  isinstance
         for n, v in kwds.items():
-            if isinstance(v, _LazyNamedEnumItem):  # property
+            if _isa(v, _LazyNamedEnumItem):  # property
                 assert (n == v.name) if pypy else (n is v.name)
                 # assert not hasattr(self.__class__, n)
                 setattr(self.__class__, n, v)
-            elif isinstance(v, self._item_Classes):  # PYCHOK no cover
+            elif _isa(v, self._item_Classes):  # PYCHOK no cover
                 assert self[n] is v and getattr(self, n) \
                                     and self.find(v) == n
             else:
@@ -710,8 +736,9 @@ class _NamedEnum(_NamedDict):
                            case-insensitive} order (C{bool}).
         '''
         if all:  # instantiate any remaining L{_LazyNamedEnumItem}
+            _isa = isinstance
             for n, p in tuple(self.__class__.__dict__.items()):
-                if isinstance(p, _LazyNamedEnumItem):
+                if _isa(p, _LazyNamedEnumItem):
                     _ = getattr(self, n)
         return itemsorted(self) if asorted else ADict.items(self)
 
@@ -778,7 +805,7 @@ class _NamedEnum(_NamedDict):
         else:
             name = self.find(name_or_item, dflt=MISSING)  # all=True?
             if name is MISSING:
-                t = _SPACE_(_no_, 'such', self.classname, _item_)
+                t = _SPACE_(_no_, _such_, self.classname, _item_)
                 raise _AttributeError(t, txt=repr(name_or_item))
         try:
             item = ADict.pop(self, name)
@@ -878,9 +905,11 @@ class _NamedEnumItem(_NamedBase):
     def name(self, name):
         '''Set the name, unless already registered (C{str}).
         '''
+        name = _name__(name) or _NN_
         if self._enum:
-            raise _NameError(str(name), self, txt=_registered_)  # XXX _TypeError
-        self._name = str(name)
+            raise _NameError(name, self, txt=_registered_)  # XXX _TypeError
+        if name:
+            self._name = name
 
     def _register(self, enum, name):
         '''(INTERNAL) Add this item as B{C{enum.name}}.
@@ -888,6 +917,7 @@ class _NamedEnumItem(_NamedBase):
            @note: Don't register if name is empty or doesn't
                   start with a letter.
         '''
+        name = _name__(name)
         if name and _xvalid(name, underOK=True):
             self.name = name
             if name[:1].isalpha():  # '_...' not registered
@@ -1040,7 +1070,7 @@ class _NamedTuple(tuple, _Named):
 
     iteritems = items
 
-    def _kwdself(self, iteration=None, name=NN, **unused):
+    def _kwdself(self, iteration=None, **name):
         '''(INTERNAL) Set C{__new__} keyword arguments.
         '''
         if iteration is not None:
@@ -1141,7 +1171,8 @@ class _NamedTuple(tuple, _Named):
         if (issubclassof(xTuple, _NamedTuple) and
             (len(self._Names_) + len(items)) == len(xTuple._Names_) and
                  self._Names_ == xTuple._Names_[:len(self)]):
-            return xTuple(self + items, **_xkwds(name, name=self.name))  # *(self + items)
+            n = _name__(**name) or self.name
+            return xTuple(self + items, name=n)  # *(self + items)
         c = NN(self.classname,  repr(self._Names_))  # PYCHOK no cover
         x = NN(xTuple.__name__, repr(xTuple._Names_))  # PYCHOK no cover
         raise TypeError(_SPACE_(c, _vs_, x))
@@ -1229,9 +1260,9 @@ def modulename(clas, prefixed=None):  # in .basics._xversion
        @return: The B{C{class}}'s C{[module.]class} name (C{str}).
     '''
     try:
-        n = clas.__name__
+        n =  clas.__name__
     except AttributeError:
-        n = '__name__'  # _DUNDER_(NN, _name_, NN)
+        n = _dunder_name_
     if prefixed or (classnaming() if prefixed is None else False):
         try:
             m =  clas.__module__.rsplit(_DOT_, 1)
@@ -1241,6 +1272,62 @@ def modulename(clas, prefixed=None):  # in .basics._xversion
     return n
 
 
+# def _name__(name=NN, name__=None, _or_nameof=None, **kwds):
+#     '''(INTERNAL) Get single keyword argument C{B{name}=NN|None}.
+#     '''
+#     if kwds:  # "unexpected keyword arguments ..."
+#         m = _MODS.errors
+#         raise m._UnexpectedError(**kwds)
+#     if name:  # is given
+#         n = _name__(**name) if isinstance(name, dict) else str(name)
+#     elif name__ is not None:
+#         n = getattr(name__, _dunder_name_, NN)  # _xattr(name__, __name__=NN)
+#     else:
+#         n = name  # NN or None or {} or any False type
+#     if _or_nameof is not None and not n:
+#         n = getattr(_or_nameof, _name_, NN) # _xattr(_or_nameof, name=NN)
+#     return n  # str or None or {}
+
+
+def _name__(name=NN, **kwds):
+    '''(INTERNAL) Get single keyword argument C{B{name}=NN|None}.
+    '''
+    if name or kwds:
+        name, kwds = _name2__(name, **kwds)
+        if kwds:  # "unexpected keyword arguments ..."
+            m = _MODS.errors
+            raise m._UnexpectedError(**kwds)
+    return name if name or name is None else NN
+
+
+def _name1__(kwds_name, _or_nameof=None):
+    '''(INTERNAL) Resolve and set the C{B{name}=NN}.
+    '''
+    if kwds_name:
+        n, kwds_name = _name2__(kwds_name, _or_nameof=_or_nameof)
+        if n:
+            kwds_name.update(name=n)
+    return kwds_name
+
+
+def _name2__(name=NN, name__=None, _or_nameof=None, **kwds):
+    '''(INTERNAL) Get the C{B{name}=NN|None} and other C{kwds}.
+    '''
+    if name:  # is given
+        if isinstance(name, dict):
+            kwds.update(name)  # kwds = _xkwds(kwds, **name)?
+            n, kwds = _name2__(**kwds)
+        else:
+            n = str(name)
+    elif name__ is not None:
+        n = getattr(name__, _dunder_name_, NN)  # _xattr(name__, __name__=NN)
+    else:
+        n = name if name is None else NN
+    if _or_nameof is not None and not n:
+        n = getattr(_or_nameof, _name_, NN)  # _xattr(_or_nameof, name=NN)
+    return n, kwds  # (str or None or {}), dict
+
+
 def nameof(inst):
     '''Get the name of an instance.
 

pygeodesy/namedTuples.py

@@ -11,13 +11,13 @@ of C{_NamedTuple} defined in C{pygeodesy.named}.
 from pygeodesy.basics import map1, _xinstanceof
 # from pygeodesy.constants import INT0  # from .units
 from pygeodesy.errors import _ALL_LAZY, _MODS, _xattr, _xkwds_not  # _xkwds
-from pygeodesy.interns import NN, _1_, _2_, _a_, _A_, _area_, _angle_, _b_, \
-                             _B_, _band_, _c_, _C_, _datum_, _D_, _distance_, \
-                             _E_, _easting_, _end_, _fi_, _gamma_, _height_, \
-                             _h_, _j_, _hemipole_, _initial_, _lam_, _lat_, \
-                             _lon_, _n_, _northing_, _number_, _outside_, \
-                             _phi_, _point_, _precision_, _points_, _radius_, \
-                             _scale_, _start_, _x_, _y_, _z_, _zone_
+from pygeodesy.interns import _1_, _2_, _a_, _A_, _area_, _angle_, _b_, _B_, \
+                              _band_, _c_, _C_, _datum_, _D_, _distance_, \
+                              _E_, _easting_, _end_, _fi_, _gamma_, _height_, \
+                              _h_, _j_, _hemipole_, _initial_, _lam_, _lat_, \
+                              _lon_, _n_, _northing_, _number_, _outside_, \
+                              _phi_, _point_, _precision_, _points_, _radius_, \
+                              _scale_, _start_, _x_, _y_, _z_, _zone_
 # from pygeodesy.lazily import _ALL_LAZY, _ALL_MODS as _MODS  # from .errors
 from pygeodesy.named import _NamedTuple, _Pass
 from pygeodesy.props import deprecated_property_RO, property_RO
@@ -27,7 +27,7 @@ from pygeodesy.units import Band, Bearing, Degrees, Degrees2, Easting, \
                             Radians, Radius, Scalar, Str
 
 __all__ = _ALL_LAZY.namedTuples
-__version__ = '23.12.07'
+__version__ = '24.05.18'
 
 # __DUNDER gets mangled in class
 _closest_     = 'closest'
@@ -202,7 +202,8 @@ class LatLon2Tuple(_NamedTuple):
         '''Extend this L{LatLon2Tuple} to a L{LatLon3Tuple}.
 
            @arg height: The height to add (C{scalar}).
-           @kwarg name: Optional name (C{str}), overriding this name.
+           @kwarg name: Optional C{B{name}=NN} (C{str}), overriding
+                        this name.
 
            @return: A L{LatLon3Tuple}C{(lat, lon, height)}.
 
@@ -215,7 +216,8 @@ class LatLon2Tuple(_NamedTuple):
 
            @arg height: The height to add (C{scalar}).
            @arg datum: The datum to add (C{Datum}).
-           @kwarg name: Optional name (C{str}), overriding this name.
+           @kwarg name: Optional C{B{name}=NN} (C{str}), overriding
+                        this name.
 
            @return: A L{LatLon4Tuple}C{(lat, lon, height, datum)}.
 
@@ -237,7 +239,8 @@ class LatLon3Tuple(_NamedTuple):
         '''Extend this L{LatLon3Tuple} to a L{LatLon4Tuple}.
 
            @arg datum: The datum to add (C{Datum}).
-           @kwarg name: Optional name (C{str}), overriding this name.
+           @kwarg name: Optional C{B{name}=NN} (C{str}), overriding
+                        this name.
 
            @return: A L{LatLon4Tuple}C{(lat, lon, height, datum)}.
 
@@ -256,17 +259,17 @@ class LatLon4Tuple(LatLon3Tuple):  # .cartesianBase, .css, .ecef, .lcc
 
 
 def _LL4Tuple(lat, lon, height, datum, LatLon, LatLon_kwds, inst=None,
-                                       iteration=None, name=NN):
+                                       iteration=None, **name):
     '''(INTERNAL) Return a L{LatLon4Tuple} or a B{C{LatLon}} instance.
     '''
     if LatLon is None:  # ignore LatLon_kwds
-        r = LatLon4Tuple(lat, lon, height, datum, name=name)
+        r = LatLon4Tuple(lat, lon, height, datum, **name)
     else:
         kwds = {} if inst is None else _xkwds_not(None,
 #                    datum=_xattr(inst, datum=None),
                      epoch=_xattr(inst, epoch=None),
                    reframe=_xattr(inst, reframe=None))  # PYCHOK indent
-        kwds.update(datum=datum, height=height, name=name)
+        kwds.update(datum=datum, height=height, **name)
         if LatLon_kwds:
             kwds.update(LatLon_kwds)
         r = LatLon(lat, lon, **kwds)
@@ -303,7 +306,8 @@ class LatLonPrec3Tuple(_NamedTuple):  # .gars.py, .wgrs.py
 
            @arg height: The height to add (C{float} or C{None}).
            @arg radius: The radius to add (C{float} or C{None}).
-           @kwarg name: Optional name (C{str}), overriding this name.
+           @kwarg name: Optional C{B{name}=NN} (C{str}), overriding
+                        this name.
 
            @return: A L{LatLonPrec5Tuple}C{(lat, lon, precision,
                     height, radius)}.
@@ -401,7 +405,8 @@ class PhiLam2Tuple(_NamedTuple):  # .frechet, .hausdorff, .latlonBase, .points,
         '''Extend this L{PhiLam2Tuple} to a L{PhiLam3Tuple}.
 
            @arg height: The height to add (C{scalar}).
-           @kwarg name: Optional name (C{str}), overriding this name.
+           @kwarg name: Optional C{B{name}=NN} (C{str}),
+                        overriding this name.
 
            @return: A L{PhiLam3Tuple}C{(phi, lam, height)}.
 
@@ -440,7 +445,8 @@ class PhiLam3Tuple(_NamedTuple):  # .nvector.py, extends -2Tuple
         '''Extend this L{PhiLam3Tuple} to a L{PhiLam4Tuple}.
 
            @arg datum: The datum to add (C{Datum}).
-           @kwarg name: Optional name (C{str}), overriding this name.
+           @kwarg name: Optional C{B{name}=NN} (C{str}),
+                        overriding this name.
 
            @return: A L{PhiLam4Tuple}C{(phi, lam, height, datum)}.
 
@@ -546,11 +552,11 @@ class UtmUps5Tuple(_NamedTuple):  # .mgrs.py, .ups.py, .utm.py, .utmups.py
     _Names_ = (_zone_,  _hemipole_, _easting_, _northing_, _band_)
     _Units_ = ( Number_, Str,        Easting,   Northing,   Band)
 
-    def __new__(cls, z, h, e, n, B, Error=None, name=NN):
+    def __new__(cls, z, h, e, n, B, Error=None, **name):
         if Error is not None:
             e = Easting( e, Error=Error)
             n = Northing(n, Error=Error)
-        return _NamedTuple.__new__(cls, z, h, e, n, B, name=name)
+        return _NamedTuple.__new__(cls, z, h, e, n, B, **name)
 
 
 class UtmUps8Tuple(_NamedTuple, _Convergence):  # .ups, .utm, .utmups
@@ -567,13 +573,13 @@ class UtmUps8Tuple(_NamedTuple, _Convergence):  # .ups, .utm, .utmups
     _Units_ = ( Number_, Str,        Easting,   Northing,
                 Band,   _Pass,    Degrees, Scalar)
 
-    def __new__(cls, z, h, e, n, B, d, g, s, Error=None, name=NN):  # PYCHOK 11 args
+    def __new__(cls, z, h, e, n, B, d, g, s, Error=None, **name):  # PYCHOK 11 args
         if Error is not None:
             e = Easting( e, Error=Error)
             n = Northing(n, Error=Error)
             g = Degrees(gamma=g, Error=Error)
             s = Scalar(scale=s, Error=Error)
-        return _NamedTuple.__new__(cls, z, h, e, n, B, d, g, s, name=name)
+        return _NamedTuple.__new__(cls, z, h, e, n, B, d, g, s, **name)
 
 
 class UtmUpsLatLon5Tuple(_NamedTuple):  # .ups.py, .utm.py, .utmups.py
@@ -587,11 +593,11 @@ class UtmUpsLatLon5Tuple(_NamedTuple):  # .ups.py, .utm.py, .utmups.py
     _Names_ = (_zone_,  _band_, _hemipole_, _lat_, _lon_)
     _Units_ = ( Number_, Band,   Str,        Lat,   Lon)
 
-    def __new__(cls, z, B, h, lat, lon, Error=None, name=NN):
+    def __new__(cls, z, B, h, lat, lon, Error=None, **name):
         if Error is not None:
             lat = Lat(lat, Error=Error)
             lon = Lon(lon, Error=Error)
-        return _NamedTuple.__new__(cls, z, B, h, lat, lon, name=name)
+        return _NamedTuple.__new__(cls, z, B, h, lat, lon, **name)
 
 
 class Vector2Tuple(_NamedTuple):
@@ -605,7 +611,8 @@ class Vector2Tuple(_NamedTuple):
         '''Extend this L{Vector2Tuple} to a L{Vector3Tuple}.
 
            @kwarg z: The Z component add (C{scalar}).
-           @kwarg name: Optional name (C{str}), overriding this name.
+           @kwarg name: Optional C{B{name}=NN} (C{str}),
+                        overriding this name.
 
            @return: A L{Vector3Tuple}C{(x, y, z)}.
 
@@ -625,7 +632,8 @@ class Vector3Tuple(_NamedTuple):
         '''Extend this L{Vector3Tuple} to a L{Vector4Tuple}.
 
            @arg h: The height to add (C{scalar}).
-           @kwarg name: Optional name (C{str}), overriding this name.
+           @kwarg name: Optional C{B{name}=NN} (C{str}),
+                        overriding this name.
 
            @return: A L{Vector4Tuple}C{(x, y, z, h)}.
 

pygeodesy/nvectorBase.py

@@ -19,13 +19,14 @@ from pygeodesy.fmath import fdot, fidw, hypot_  # PYCHOK fdot shared
 from pygeodesy.fsums import Fsum, fsumf_
 from pygeodesy.formy import _isequalTo, n_xyz2latlon, n_xyz2philam, \
                             _spherical_datum
+# from pygeodesy.internals import _under  # from .named
 from pygeodesy.interns import NN, _1_, _2_, _3_, _bearing_, _coincident_, \
                              _COMMASPACE_, _distance_, _h_, _insufficient_, \
                              _intersection_, _no_, _NorthPole_, _point_, \
-                             _pole_, _SPACE_, _SouthPole_, _under
+                             _pole_, _SPACE_, _SouthPole_
 from pygeodesy.latlonBase import LatLonBase,  _ALL_DOCS, _ALL_LAZY, _MODS
 # from pygeodesy.lazily import _ALL_DOCS, _ALL_LAZY, _ALL_MODS as _MODS  # from .latlonBase
-from pygeodesy.named import _xother3
+from pygeodesy.named import _xother3,  _under
 from pygeodesy.namedTuples import Trilaterate5Tuple, Vector3Tuple, \
                                   Vector4Tuple,  map1
 from pygeodesy.props import deprecated_method, Property_RO, property_doc_, \
@@ -38,7 +39,7 @@ from pygeodesy.vector3d import Vector3d, _xyzhdn3
 from math import fabs, sqrt
 
 __all__ = _ALL_LAZY.nvectorBase
-__version__ = '24.04.07'
+__version__ = '24.05.18'
 
 
 class NvectorBase(Vector3d):  # XXX kept private
@@ -48,7 +49,7 @@ class NvectorBase(Vector3d):  # XXX kept private
     _h     = Height(h=0)  # height (C{meter})
     _H     = NN           # height prefix (C{str}), '↑' in JS version
 
-    def __init__(self, x_xyz, y=None, z=None, h=0, ll=None, datum=None, name=NN):
+    def __init__(self, x_xyz, y=None, z=None, h=0, ll=None, datum=None, **name):
         '''New n-vector normal to the earth's surface.
 
            @arg x_xyz: X component of vector (C{scalar}) or (3-D) vector
@@ -61,15 +62,15 @@ class NvectorBase(Vector3d):  # XXX kept private
            @kwarg h: Optional height above surface (C{meter}).
            @kwarg ll: Optional, original latlon (C{LatLon}).
            @kwarg datum: Optional, I{pass-thru} datum (L{Datum}).
-           @kwarg name: Optional name (C{str}).
+           @kwarg name: Optional C{B{name}=NN} (C{str}).
 
            @raise TypeError: Non-scalar B{C{x}}, B{C{y}} or B{C{z}}
                              coordinate or B{C{x}} not an C{Nvector},
                              L{Vector3Tuple} or L{Vector4Tuple} or
                              invalid B{C{datum}}.
         '''
-        h, d, n = _xyzhdn3(x_xyz, h, datum, ll)
-        Vector3d.__init__(self, x_xyz, y=y, z=z, ll=ll, name=name or n)
+        h, d, n = _xyzhdn3(x_xyz, h, datum, ll, **name)
+        Vector3d.__init__(self, x_xyz, y=y, z=z, ll=ll, name=n)
         if h:
             self.h = h
         if d is not None:
@@ -460,8 +461,8 @@ class LatLonNvectorBase(LatLonBase):
            @arg bearing1: Bearing at this point (compass C{degrees360}).
            @arg other: The other point (C{LatLon}).
            @arg bearing2: Bearing at the other point (compass C{degrees360}).
-           @kwarg height: Optional height at the triangulated point,
-                          overriding the mean height (C{meter}).
+           @kwarg height: Optional height at the triangulated point, overriding
+                          the mean height (C{meter}).
            @kwarg wrap: If C{True}, use this and the B{C{other}} point
                         I{normalized} (C{bool}).