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

pygeodesy/mgrs.py

@@ -44,7 +44,7 @@ from pygeodesy.interns import NN, _0_, _A_, _AtoZnoIO_, _band_, _B_, \
                              _COMMASPACE_, _datum_, _easting_, _invalid_, \
                              _northing_, _SPACE_, _W_, _Y_, _Z_, _zone_
 from pygeodesy.lazily import _ALL_LAZY, _ALL_MODS as _MODS, _PYGEODESY_GEOCONVERT_
-from pygeodesy.named import _NamedBase, _NamedTuple, _Pass, _xnamed
+from pygeodesy.named import _name2__, _NamedBase, _NamedTuple, _Pass
 from pygeodesy.namedTuples import EasNor2Tuple, UtmUps5Tuple
 from pygeodesy.props import deprecated_property_RO, property_RO, Property_RO
 from pygeodesy.streprs import enstr2, _enstr2m3, Fmt, _resolution10, _xzipairs
@@ -55,7 +55,7 @@ from pygeodesy.utm import toUtm8, _to3zBlat, Utm, _UTM_ZONE_MAX, _UTM_ZONE_MIN
 # from pygeodesy.utmupsBase import _UTM_ZONE_MAX, _UTM_ZONE_MIN  # from .utm
 
 __all__ = _ALL_LAZY.mgrs
-__version__ = '24.05.24'
+__version__ = '24.06.04'
 
 _AN_    = 'AN'  # default south pole grid tile and band B
 _AtoPx_ = _AtoZnoIO_.tillP
@@ -87,7 +87,7 @@ class Mgrs(_NamedBase):
     _zone       =  0      # longitudinal or polar zone (C{int}), 0..60
 
     def __init__(self, zone=0, EN=NN, easting=0, northing=0, band=NN,
-                               datum=_WGS84, resolution=0, name=NN):
+                               datum=_WGS84, resolution=0, **name):
         '''New L{Mgrs} Military grid reference.
 
            @arg zone: The 6° I{longitudinal} zone (C{int}), 1..60 covering
@@ -104,7 +104,7 @@ class Mgrs(_NamedBase):
            @kwarg datum: This reference's datum (L{Datum}, L{Ellipsoid},
                          L{Ellipsoid2} or L{a_f2Tuple}).
            @kwarg resolution: Optional resolution (C{meter}), C{0} for default.
-           @kwarg name: Optional name (C{str}).
+           @kwarg name: Optional C{B{name}=NN} (C{str}).
 
            @raise MGRSError: Invalid B{C{zone}}, B{C{EN}}, B{C{easting}},
                              B{C{northing}}, B{C{band}} or B{C{resolution}}.
@@ -235,20 +235,18 @@ class Mgrs(_NamedBase):
             toUps8(a, 0, datum=self.datum, Ups=None)
         return int(u.northing / _100km) * _100km
 
-    def parse(self, strMGRS, name=NN):
+    def parse(self, strMGRS, **name):
         '''Parse a string to a similar L{Mgrs} instance.
 
-           @arg strMGRS: The MGRS reference (C{str}),
-                         see function L{parseMGRS}.
-           @kwarg name: Optional instance name (C{str}),
-                        overriding this name.
+           @arg strMGRS: The MGRS reference (C{str}), see function L{parseMGRS}.
+           @kwarg name: Optional C{B{name}=NN} (C{str}), overriding this name.
 
            @return: The similar instance (L{Mgrs}).
 
            @raise MGRSError: Invalid B{C{strMGRS}}.
         '''
         return parseMGRS(strMGRS, datum=self.datum, Mgrs=self.classof,
-                                  name=name or self.name)
+                                                    name=self._name__(name))
 
     @property
     def resolution(self):
@@ -536,7 +534,7 @@ class _RE(object):
 _RE = _RE()  # PYCHOK singleton
 
 
-def parseMGRS(strMGRS, datum=_WGS84, Mgrs=Mgrs, name=NN):
+def parseMGRS(strMGRS, datum=_WGS84, Mgrs=Mgrs, **name):
     '''Parse a string representing a MGRS grid reference,
        consisting of C{"[zone]Band, EN, easting, northing"}.
 
@@ -544,7 +542,7 @@ def parseMGRS(strMGRS, datum=_WGS84, Mgrs=Mgrs, name=NN):
        @kwarg datum: Optional datum to use (L{Datum}).
        @kwarg Mgrs: Optional class to return the MGRS grid
                     reference (L{Mgrs}) or C{None}.
-       @kwarg name: Optional B{C{Mgrs}} name (C{str}).
+       @kwarg name: Optional B{C{Mgrs}} C{B{name}=NN} (C{str}).
 
        @return: The MGRS grid reference as B{C{Mgrs}} or if
                 C{B{Mgrs} is None} as an L{Mgrs4Tuple}C{(zone,
@@ -582,29 +580,29 @@ def parseMGRS(strMGRS, datum=_WGS84, Mgrs=Mgrs, name=NN):
         e, n, m = _enstr2m3(*m[2:])
 
         if Mgrs is None:
-            r = Mgrs4Tuple(zB, EN, e, n, name=name)
+            r = Mgrs4Tuple(zB, EN, e, n, **name)
             _ = r.toMgrs(resolution=m)  # validate
         else:
-            r = Mgrs(zB, EN, e, n, datum=datum, resolution=m, name=name)
+            r = Mgrs(zB, EN, e, n, datum=datum, resolution=m, **name)
         return r
 
     return _parseX(_MGRS, strMGRS, datum, Mgrs, name,
                           strMGRS=strMGRS, Error=MGRSError)
 
 
-def toMgrs(utmups, Mgrs=Mgrs, name=NN, **Mgrs_kwds):
+def toMgrs(utmups, Mgrs=Mgrs, **name_Mgrs_kwds):
     '''Convert a UTM or UPS coordinate to an MGRS grid reference.
 
        @arg utmups: A UTM or UPS coordinate (L{Utm}, L{Etm} or L{Ups}).
        @kwarg Mgrs: Optional class to return the MGRS grid reference
                     (L{Mgrs}) or C{None}.
-       @kwarg name: Optional B{C{Mgrs}} name (C{str}).
-       @kwarg Mgrs_kwds: Optional, additional B{C{Mgrs}} keyword
-                         arguments, ignored if C{B{Mgrs} is None}.
+       @kwarg name_Mgrs_kwds: Optional C{B{name}=NN} (C{str}) and
+                   optional, additional B{C{Mgrs}} keyword arguments,
+                   ignored if C{B{Mgrs} is None}.
 
-       @return: The MGRS grid reference as B{C{Mgrs}} or if
-                C{B{Mgrs} is None} as an L{Mgrs6Tuple}C{(zone,
-                EN, easting, northing, band, datum)}.
+       @return: The MGRS grid reference as B{C{Mgrs}} or if C{B{Mgrs}
+                is None} as an L{Mgrs6Tuple}C{(zone, EN, easting,
+                northing, band, datum)}.
 
        @raise MGRSError: Invalid B{C{utmups}}.
 
@@ -634,12 +632,14 @@ def toMgrs(utmups, Mgrs=Mgrs, name=NN, **Mgrs_kwds):
     except (IndexError, TypeError, ValueError) as x:
         raise MGRSError(B=B, E=E, N=N, utmups=utmups, cause=x)
 
+    t, kwds = _name2__(name_Mgrs_kwds, _or_nameof=utmups)
     if Mgrs is None:
-        r = Mgrs4Tuple(Fmt.zone(z), EN, e, n).to6Tuple(B, utmups.datum)
+        r = Mgrs4Tuple(Fmt.zone(z), EN, e, n, name=t) \
+             .to6Tuple(B, utmups.datum)
     else:
-        kwds = _xkwds(Mgrs_kwds, band=B, datum=utmups.datum)
+        kwds = _xkwds(kwds, band=B, datum=utmups.datum, name=t)
         r = Mgrs(z, EN, e, n, **kwds)
-    return _xnamed(r, name or utmups.name)
+    return r
 
 
 def _um100km2(m):
@@ -699,6 +699,33 @@ if __name__ == '__main__':
     p = e * 100.0 / n
     printf('%6s: %s errors (%.2f%%)', n, (e if e else 'no'), p)
 
+# % python3 -m pygeodesy.mgrs
+#  using: /opt/local/bin/GeoConvert -m ...
+#      0: lat -90 ... OK
+#    361: lat -89 ... OK
+#    722: lat -88 ... OK
+#   1083: lat -87 ... OK
+#   1444: lat -86 ... OK
+#   1805: lat -85 ... OK
+#   2166: lat -84 ... OK
+#   2527: lat -83 ... OK
+#   2888: lat -82 ... OK
+#   3249: lat -81 ... OK
+#   3610: lat -80 ... OK
+#  ...
+#  61370: lat 80 ... OK
+#  61731: lat 81 ... OK
+#  62092: lat 82 ... OK
+#  62453: lat 83 ... OK
+#  62814: lat 84 ... OK
+#  63175: lat 85 ... OK
+#  63536: lat 86 ... OK
+#  63897: lat 87 ... OK
+#  64258: lat 88 ... OK
+#  64619: lat 89 ... OK
+#  64980: lat 90 ... OK
+#  65341: no errors (0.00%)
+
 # **) MIT License
 #
 # Copyright (C) 2016-2024 -- mrJean1 at Gmail -- All Rights Reserved.

pygeodesy/named.py

@@ -13,27 +13,28 @@ standard Python C{namedtuple}s.
 @see: Module L{pygeodesy.namedTuples} for (most of) the C{Named-Tuples}.
 '''
 
-from pygeodesy.basics import isclass, isidentifier, iskeyword, isstr, issubclassof, \
-                             itemsorted, len2, _xcopy, _xdup, _zip
+from pygeodesy.basics import isidentifier, iskeyword, isstr, itemsorted, len2, \
+                            _xcopy, _xdup, _xinstanceof, _xsubclassof, _zip
 from pygeodesy.errors import _AssertionError, _AttributeError, _incompatible, \
-                             _IndexError, _IsnotError, _KeyError, LenError, \
-                             _NameError, _NotImplementedError, _TypeError, \
-                             _TypesError, UnitError, _ValueError, _xattr, _xkwds, \
-                             _xkwds_item2, _xkwds_pop2
+                             _IndexError, _KeyError, LenError, _NameError, \
+                             _NotImplementedError, _TypeError, _TypesError, \
+                             _UnexpectedError, UnitError, _ValueError, \
+                             _xattr, _xkwds, _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_, \
                              _dunder_name_, _EQUAL_, _exists_, _immutable_, _name_, \
                              _NL_, _NN_, _no_, _other_, _s_, _SPACE_, _std_, \
-                             _UNDER_, _valid_, _vs_
+                             _UNDER_, _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
+# from pygeodesy.units import _toUnit  # _MODS
 
 __all__ = _ALL_LAZY.named
-__version__ = '24.05.21'
+__version__ = '24.06.10'
 
 _COMMANL_           = _COMMA_ + _NL_
 _COMMASPACEDOT_     = _COMMASPACE_ + _DOT_
@@ -50,69 +51,6 @@ _Units_             = '_Units_'
 _UP                 =  2
 
 
-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)
-        t = _SPACE_(prefix, name)
-    else:
-        t =  prefix or name
-    return t
-
-
-def _xnamed(inst, name=NN, force=False, **name__of_name):
-    '''(INTERNAL) Set the instance' C{.name = B{name}}.
-
-       @arg inst: The instance (C{_Named}).
-       @kwarg name: The name (C{str}).
-       @kwarg force: If C{True}, force rename (C{bool}).
-
-       @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
-        elif force:
-            inst.rename(name)
-    return inst
-
-
-def _xother3(inst, other, name=_other_, up=1, **name_other):
-    '''(INTERNAL) Get C{name} and C{up} for a named C{other}.
-    '''
-    if name_other:  # and other is None
-        name, other = _xkwds_item2(name_other)
-    elif other and len(other) == 1:
-        name, other = _name__(name), other[0]
-    else:
-        raise _AssertionError(name, other, txt=classname(inst, prefixed=True))
-    return other, name, up
-
-
-def _xotherError(inst, other, name=_other_, up=1):
-    '''(INTERNAL) Return a C{_TypeError} for an incompatible, named C{other}.
-    '''
-    n = _callname(name, classname(inst, prefixed=True), inst.name, up=up + 1)
-    return _TypeError(name, other, txt=_incompatible(n))
-
-
-def _xvalid(name, underOK=False):
-    '''(INTERNAL) Check valid attribute name C{name}.
-    '''
-    return bool(name and isstr(name)
-                     and name != _name_
-                     and (underOK or not name.startswith(_UNDER_))
-                     and (not iskeyword(name))
-                     and isidentifier(name))
-
-
 class ADict(dict):
     '''A C{dict} with both key I{and} attribute access to
        the C{dict} items.
@@ -170,7 +108,6 @@ 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):
@@ -312,7 +249,7 @@ class _Named(object):
 
         fmt, props, kwds = _fmt_props_kwds(**fmt_props_kwds)
 
-        t = () if name is None else (Fmt.EQUAL(name=repr(name or self.name)),)
+        t = () if name is None else (Fmt.EQUAL(name=repr(self._name__(name))),)
         if attrs:
             t += pairs(((a, getattr(self, a)) for a in attrs),
                        prec=prec, ints=True, fmt=fmt)
@@ -373,6 +310,11 @@ class _Named(object):
         '''
         return _name__(name, _or_nameof=self)  # nameof(self)
 
+    def _name1__(self, kwds):
+        '''(INTERNAL) Resolve and set the C{B{name}=NN}.
+        '''
+        return _name1__(kwds, _or_nameof=self.name) if self.name else kwds
+
     @Property_RO
     def named(self):
         '''Get the name I{or} class name or C{""} (C{str}).
@@ -486,11 +428,8 @@ class _Named(object):
 
            @raise TypeError: Not C{isinstance(B{inst}, _Named)}.
         '''
-        if not isinstance(inst, _Named):
-            raise _IsnotError(_valid_, inst=inst)
-
-        _ = inst.rename(self.name)
-        return inst
+        _xinstanceof(_Named, inst=inst)  # assert
+        return inst.renamed(self.name)
 
 _Named_Property_ROs = _allPropertiesOf_n(5, _Named, Property_RO)  # PYCHOK once
 
@@ -780,12 +719,14 @@ class _NamedEnum(_NamedDict):
                 if not (n and isstr(n) and isidentifier(n)):
                     raise ValueError()
             except (AttributeError, ValueError, TypeError) as x:
-                raise _NameError(_DOT_(_item_, _name_), item, cause=x)
+                n = _DOT_(_item_, _name_)
+                raise _NameError(n, item, cause=x)
             if n in self:
                 t = _SPACE_(_item_, self._DOT_(n), _exists_)
                 raise _NameError(t, txt=repr(item))
-            if not isinstance(item, self._item_Classes):
-                raise _TypesError(self._DOT_(n), item, *self._item_Classes)
+            if not isinstance(item, self._item_Classes):  # _xinstanceof
+                n = self._DOT_(n)
+                raise _TypesError(n, item, *self._item_Classes)
             self[n] = item
         return n
 
@@ -907,7 +848,7 @@ class _NamedEnumItem(_NamedBase):
         '''
         name = _name__(name) or _NN_
         if self._enum:
-            raise _NameError(name, self, txt=_registered_)  # XXX _TypeError
+            raise _NameError(name, self, txt=_registered_)  # _TypeError
         if name:
             self._name = name
 
@@ -934,8 +875,8 @@ class _NamedEnumItem(_NamedBase):
         enum = self._enum
         if enum and self.name and self.name in enum:
             item = enum.unregister(self.name)
-            if item is not self:
-                t = _SPACE_(repr(item), _vs_, repr(self))  # PYCHOK no cover
+            if item is not self:  # PYCHOK no cover
+                t = _SPACE_(repr(item), _vs_, repr(self))
                 raise _AssertionError(t)
 
 
@@ -987,7 +928,11 @@ class _NamedTuple(tuple, _Named):
             raise LenError(self.__class__, args=n, _Names_=N)
 
         if iteration_name:
-            self._kwdself(**iteration_name)
+            i, name = _xkwds_pop2(iteration_name, iteration=None)
+            if i is not None:
+                self._iteration = i
+            if name:
+                self.name = name
         return self
 
     def __delattr__(self, name):
@@ -996,7 +941,8 @@ class _NamedTuple(tuple, _Named):
            @note: Items can not be deleted.
         '''
         if name in self._Names_:
-            raise _TypeError(_del_, _DOT_(self.classname, name), txt=_immutable_)
+            t = _SPACE_(_del_, self._DOT_(name))
+            raise _TypeError(t, txt=_immutable_)
         elif name in (_name_, _name):
             _Named.__setattr__(self, name, NN)  # XXX _Named.name.fset(self, NN)
         else:
@@ -1007,10 +953,10 @@ class _NamedTuple(tuple, _Named):
         '''
         try:
             return tuple.__getitem__(self, self._Names_.index(name))
-        except IndexError:
-            raise _IndexError(_DOT_(self.classname, Fmt.ANGLE(_name_)), name)
+        except IndexError as x:
+            raise _IndexError(self._DOT_(name), cause=x)
         except ValueError:  # e.g. _iteration
-            return tuple.__getattribute__(self, name)
+            return tuple.__getattr__(self, name)  # __getattribute__
 
 #   def __getitem__(self, index):  # index, slice, etc.
 #       '''Get the item(s) at an B{C{index}} or slice.
@@ -1029,7 +975,8 @@ class _NamedTuple(tuple, _Named):
         '''Set attribute or item B{C{name}} to B{C{value}}.
         '''
         if name in self._Names_:
-            raise _TypeError(_DOT_(self.classname, name), value, txt=_immutable_)
+            t = Fmt.EQUALSPACED(self._DOT_(name), repr(value))
+            raise _TypeError(t, txt=_immutable_)
         elif name in (_name_, _name):
             _Named.__setattr__(self, name, value)  # XXX _Named.name.fset(self, value)
         else:  # e.g. _iteration
@@ -1040,6 +987,11 @@ class _NamedTuple(tuple, _Named):
         '''
         return self.toStr()
 
+    def _DOT_(self, *names):
+        '''(INTERNAL) Period-join C{self.classname} and C{names}.
+        '''
+        return _DOT_(self.classname, *names)
+
     def dup(self, name=NN, **items):
         '''Duplicate this tuple replacing one or more items.
 
@@ -1050,15 +1002,18 @@ class _NamedTuple(tuple, _Named):
 
            @raise NameError: Some B{C{items}} invalid.
         '''
-        tl = list(self)
+        t = list(self)
+        U = self._Units_
         if items:
-            _ix = self._Names_.index
+            _ix =  self._Names_.index
+            _2U = _MODS.units._toUnit
             try:
                 for n, v in items.items():
-                    tl[_ix(n)] = v
+                    i = _ix(n)
+                    t[i] = _2U(U[i], v, name=n)
             except ValueError:  # bad item name
-                raise _NameError(_DOT_(self.classname, n), v, this=self)
-        return self.classof(*tl, name=name or self.name)
+                raise _NameError(self._DOT_(n), v, this=self)
+        return self.classof(*t).reUnit(*U, name=name)
 
     def items(self):
         '''Yield the items, each as a C{(name, value)} pair (C{2-tuple}).
@@ -1070,13 +1025,23 @@ class _NamedTuple(tuple, _Named):
 
     iteritems = items
 
-    def _kwdself(self, iteration=None, **name):
-        '''(INTERNAL) Set C{__new__} keyword arguments.
+    def reUnit(self, *Units, **name):
+        '''Replace some of this C{Named-Tuple}'s C{Units}.
+
+           @arg Units: One or more C{Unit} classes, all positional.
+           @kwarg name: Optional C{B{name}=NN} (C{str}).
+
+           @return: This instance with updated C{Units}.
+
+           @note: This C{Named-Tuple}'s values are I{not updated}.
         '''
-        if iteration is not None:
-            self._iteration = iteration
-        if name:
-            self.name = name
+        U = self._Units_
+        n = min(len(U), len(Units))
+        if n:
+            R = Units + U[n:]
+            if R != U:
+                self._Units_ = R
+        return self.renamed(name) if name else self
 
     def toRepr(self, prec=6, sep=_COMMASPACE_, fmt=Fmt.F, **unused):  # PYCHOK signature
         '''Return this C{Named-Tuple} items as C{name=value} string(s).
@@ -1107,37 +1072,34 @@ class _NamedTuple(tuple, _Named):
         '''
         return Fmt.PAREN(sep.join(reprs(self, prec=prec, fmt=fmt)))
 
-    def toUnits(self, Error=UnitError):  # overloaded in .frechet, .hausdorff
+    def toUnits(self, Error=UnitError, **name):  # overloaded in .frechet, .hausdorff
         '''Return a copy of this C{Named-Tuple} with each item value wrapped
            as an instance of its L{units} class.
 
            @kwarg Error: Error to raise for L{units} issues (C{UnitError}).
+           @kwarg name: Optional C{B{name}=NN} (C{str}).
 
            @return: A duplicate of this C{Named-Tuple} (C{C{Named-Tuple}}).
 
            @raise Error: Invalid C{Named-Tuple} item or L{units} class.
         '''
-        t = (v for _, v in self.units(Error=Error))
-        return self.classof(*tuple(t))
+        t = tuple(v for _, v in self.units(Error=Error))
+        return self.classof(*t).reUnit(*self._Units_, **name)
 
-    def units(self, Error=UnitError):
-        '''Yield the items, each as a C{(name, value}) pair (C{2-tuple}) with
-           the value wrapped as an instance of its L{units} class.
+    def units(self, **Error):
+        '''Yield the items, each as a C{2-tuple (name, value}) with the
+           value wrapped as an instance of its L{units} class.
 
-           @kwarg Error: Error to raise for L{units} issues (C{UnitError}).
+           @kwarg Error: Optional C{B{Error}=UnitError} to raise for
+                         L{units} issues.
 
            @raise Error: Invalid C{Named-Tuple} item or L{units} class.
 
            @see: Method C{.items}.
         '''
+        _2U = _MODS.units._toUnit
         for n, v, U in _zip(self._Names_, self, self._Units_):  # strict=True
-            if not (v is None or U is None
-                              or (isclass(U) and
-                                  isinstance(v, U) and
-                                  hasattr(v, _name_) and
-                                  v.name == n)):  # PYCHOK indent
-                v = U(v, name=n, Error=Error)
-            yield n, v
+            yield n, _2U(U, v, name=n, **Error)
 
     iterunits = units
 
@@ -1147,35 +1109,35 @@ class _NamedTuple(tuple, _Named):
         '''
         ns = self._Names_
         if not (isinstance(ns, tuple) and len(ns) > 1):  # XXX > 0
-            raise _TypeError(_DOT_(self.classname, _Names_), ns)
+            raise _TypeError(self._DOT_(_Names_), ns)
         for i, n in enumerate(ns):
             if not _xvalid(n, underOK=underOK):
                 t = Fmt.SQUARE(_Names_=i)  # PYCHOK no cover
-                raise _ValueError(_DOT_(self.classname, t), n)
+                raise _ValueError(self._DOT_(t), n)
 
         us = self._Units_
         if not isinstance(us, tuple):
-            raise _TypeError(_DOT_(self.classname, _Units_), us)
+            raise _TypeError(self._DOT_(_Units_), us)
         if len(us) != len(ns):
             raise LenError(self.__class__, _Units_=len(us), _Names_=len(ns))
         for i, u in enumerate(us):
             if not (u is None or callable(u)):
                 t = Fmt.SQUARE(_Units_=i)  # PYCHOK no cover
-                raise _TypeError(_DOT_(self.classname, t), u)
+                raise _TypeError(self._DOT_(t), u)
 
         self.__class__._validated = True
 
     def _xtend(self, xTuple, *items, **name):
         '''(INTERNAL) Extend this C{Named-Tuple} with C{items} to an other B{C{xTuple}}.
         '''
-        if (issubclassof(xTuple, _NamedTuple) and
-            (len(self._Names_) + len(items)) == len(xTuple._Names_) and
-                 self._Names_ == xTuple._Names_[:len(self)]):
-            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))
+        _xsubclassof(_NamedTuple, xTuple=xTuple)
+        if len(xTuple._Names_)       != (len(self._Names_) + len(items)) or \
+               xTuple._Names_[:len(self)] != self._Names_:  # PYCHOK no cover
+            c = NN(self.classname,  repr(self._Names_))
+            x = NN(xTuple.__name__, repr(xTuple._Names_))
+            raise TypeError(_SPACE_(c, _vs_, x))
+        t = self + items
+        return xTuple(t, name=self._name__(name))  # .reUnit(*self._Units_)
 
 
 def callername(up=1, dflt=NN, source=False, underOK=False):
@@ -1295,18 +1257,16 @@ def _name__(name=NN, **kwds):
     if name or kwds:
         name, kwds = _name2__(name, **kwds)
         if kwds:  # "unexpected keyword arguments ..."
-            m = _MODS.errors
-            raise m._UnexpectedError(**kwds)
+            raise _UnexpectedError(**kwds)
     return name if name or name is None else NN
 
 
-def _name1__(kwds_name, _or_nameof=None):
+def _name1__(kwds_name, **name__or_nameof):
     '''(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)
+    if kwds_name or name__or_nameof:
+        n, kwds_name = _name2__(kwds_name, **name__or_nameof)
+        kwds_name.update(name=n)
     return kwds_name
 
 
@@ -1320,11 +1280,11 @@ def _name2__(name=NN, name__=None, _or_nameof=None, **kwds):
         else:
             n = str(name)
     elif name__ is not None:
-        n = getattr(name__, _dunder_name_, NN)  # _xattr(name__, __name__=NN)
+        n = _dunder_nameof(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)
+        n = _xattr(_or_nameof, name=NN)  # nameof
     return n, kwds  # (str or None or {}), dict
 
 
@@ -1406,6 +1366,69 @@ def _Pass(arg, **unused):  # PYCHOK no cover
     return arg
 
 
+def _xjoined_(prefix, name=NN, enquote=True, **name__or_nameof):
+    '''(INTERNAL) Join C{prefix} and non-empty C{name}.
+    '''
+    if name__or_nameof:
+        name = _name__(name, **name__or_nameof)
+    if name and prefix:
+        if enquote:
+            name = repr(name)
+        t = _SPACE_(prefix, name)
+    else:
+        t =  prefix or name
+    return t
+
+
+def _xnamed(inst, name=NN, force=False, **name__or_nameof):
+    '''(INTERNAL) Set the instance' C{.name = B{name}}.
+
+       @arg inst: The instance (C{_Named}).
+       @kwarg name: The name (C{str}).
+       @kwarg force: If C{True}, force rename (C{bool}).
+
+       @return: The B{C{inst}}, renamed if B{C{force}}d
+                or if not named before.
+    '''
+    if name__or_nameof:
+        name = _name__(name, **name__or_nameof)
+    if name and isinstance(inst, _Named):
+        if not inst.name:
+            inst.name = name
+        elif force:
+            inst.rename(name)
+    return inst
+
+
+def _xother3(inst, other, name=_other_, up=1, **name_other):
+    '''(INTERNAL) Get C{name} and C{up} for a named C{other}.
+    '''
+    if name_other:  # and other is None
+        name, other = _xkwds_item2(name_other)
+    elif other and len(other) == 1:
+        name, other = _name__(name), other[0]
+    else:
+        raise _AssertionError(name, other, txt=classname(inst, prefixed=True))
+    return other, name, up
+
+
+def _xotherError(inst, other, name=_other_, up=1):
+    '''(INTERNAL) Return a C{_TypeError} for an incompatible, named C{other}.
+    '''
+    n = _callname(name, classname(inst, prefixed=True), inst.name, up=up + 1)
+    return _TypeError(name, other, txt=_incompatible(n))
+
+
+def _xvalid(name, underOK=False):
+    '''(INTERNAL) Check valid attribute name C{name}.
+    '''
+    return bool(name and isstr(name)
+                     and name != _name_
+                     and (underOK or not name.startswith(_UNDER_))
+                     and (not iskeyword(name))
+                     and isidentifier(name))
+
+
 __all__ += _ALL_DOCS(_Named,
                      _NamedBase,  # _NamedDict,
                      _NamedEnum, _NamedEnumItem,