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

pygeodesy/mgrs.py

@@ -42,9 +42,9 @@ from pygeodesy.errors import _AssertionError, MGRSError, _parseX, \
                              _ValueError, _xkwds
 from pygeodesy.interns import NN, _0_, _A_, _AtoZnoIO_, _band_, _B_, \
                              _COMMASPACE_, _datum_, _easting_, _invalid_, \
-                             _northing_, _not_, _SPACE_, _W_, _Y_, _Z_, _zone_
+                             _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.13'
+__version__ = '24.05.31'
 
 _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):
@@ -357,7 +355,7 @@ class Mgrs(_NamedBase):
            @raise MGRSError: This MGRS is a I{non-polar} UTM reference.
         '''
         if self.isUTM:
-            raise MGRSError(zoneB=self.zoneB, txt=_not_(_polar_))
+            raise MGRSError(zoneB=self.zoneB, txt_not_=_polar_)
         return self._toUtmUps(Ups, center)
 
     def toUtm(self, Utm=Utm, center=False):
@@ -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):

pygeodesy/named.py

@@ -19,12 +19,13 @@ 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_
+                             _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, \
@@ -32,7 +33,7 @@ from pygeodesy.props import _allPropertiesOf_n, deprecated_method, _hasProperty,
 from pygeodesy.streprs import attrs, Fmt, lrstrip, pairs, reprs, unstr
 
 __all__ = _ALL_LAZY.named
-__version__ = '24.05.13'
+__version__ = '24.05.31'
 
 _COMMANL_           = _COMMA_ + _NL_
 _COMMASPACEDOT_     = _COMMASPACE_ + _DOT_
@@ -49,65 +50,6 @@ _Units_             = '_Units_'
 _UP                 =  2
 
 
-def _xjoined_(prefix, name, enquote=True):
-    '''(INTERNAL) Join C{pref} and non-empty C{name}.
-    '''
-    if name and prefix:
-        if enquote:
-            name = repr(name)
-        n = _SPACE_(prefix, name)
-    else:
-        n =  prefix or name
-    return n
-
-
-def _xnamed(inst, name, force=False):
-    '''(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}).
-
-       @return: The B{C{inst}}, named if B{C{force}}d or
-                not named before.
-    '''
-    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:
-        other = 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.
@@ -259,18 +201,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):
@@ -282,7 +224,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}).
 
@@ -292,7 +235,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
@@ -341,11 +284,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:
@@ -361,6 +304,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}).
@@ -408,12 +356,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}).
@@ -443,16 +401,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}.
@@ -466,7 +425,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
@@ -559,16 +518,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)
@@ -640,7 +600,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
 
@@ -881,9 +841,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}}.
@@ -891,6 +853,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
@@ -1043,7 +1006,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:
@@ -1144,7 +1107,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))
@@ -1232,9 +1196,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)
@@ -1244,6 +1208,61 @@ 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, **name__or_nameof):
+    '''(INTERNAL) Resolve and set the C{B{name}=NN}.
+    '''
+    if kwds_name or name__or_nameof:
+        n, kwds_name = _name2__(kwds_name, **name__or_nameof)
+        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.
 
@@ -1322,6 +1341,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,