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

pygeodesy/mgrs.py

@@ -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.31'
+__version__ = '24.06.11'
 
 _AN_    = 'AN'  # default south pole grid tile and band B
 _AtoPx_ = _AtoZnoIO_.tillP
@@ -596,18 +596,17 @@ def toMgrs(utmups, Mgrs=Mgrs, **name_Mgrs_kwds):
        @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_Mgrs_kwds: Optional C{B{name}=NN} (C{str}) and
-                   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}}.
 
-       @raise TypeError: If B{C{utmups}} is not L{Utm} nor L{Etm}
-                         nor L{Ups}.
+       @raise TypeError: If B{C{utmups}} is not L{Utm}, L{Etm} nor L{Ups}.
     '''
 #   _MODS.utmups.utmupsValidate(utmups, MGRS=True, Error-MGRSError)
     _xinstanceof(Utm, Ups, utmups=utmups)  # Utm, Etm, Ups
@@ -699,6 +698,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.31'
+__version__ = '24.06.24'
 
 _COMMANL_           = _COMMA_ + _NL_
 _COMMASPACEDOT_     = _COMMASPACE_ + _DOT_
@@ -71,6 +72,15 @@ class ADict(dict):
         '''
         return self.toRepr()
 
+    def __setattr__(self, name, value):
+        '''Set the value of a I{known} item by B{C{name}}.
+        '''
+        try:
+            if self[name] != value:
+                self[name] = value
+        except KeyError:
+            dict.__setattr__(self, name, value)
+
     def __str__(self):
         '''Default C{str(self)}.
         '''
@@ -240,13 +250,14 @@ class _Named(object):
 #           _update_all(d)
         return d
 
-    def _instr(self, name, prec, *attrs, **fmt_props_kwds):
-        '''(INTERNAL) Format, used by C{Conic}, C{Ellipsoid}, C{Transform}, C{Triaxial}.
+    def _instr(self, *attrs, **fmt_prec_props_sep_name__kwds):
+        '''(INTERNAL) Format, used by C{Conic}, C{Ellipsoid}, C{Geodesic...}, C{Transform}, C{Triaxial}.
         '''
-        def _fmt_props_kwds(fmt=Fmt.F, props=(), **kwds):
-            return fmt, props, kwds
+        def _fmt_prec_props_kwds(fmt=Fmt.F, prec=6, props=(), sep=_COMMASPACE_, **kwds):
+            return fmt, prec, props, sep, kwds
 
-        fmt, props, kwds = _fmt_props_kwds(**fmt_props_kwds)
+        name, kwds = _name2__(**fmt_prec_props_sep_name__kwds)
+        fmt, prec, props, sep, kwds = _fmt_prec_props_kwds(**kwds)
 
         t = () if name is None else (Fmt.EQUAL(name=repr(name or self.name)),)
         if attrs:
@@ -257,7 +268,7 @@ class _Named(object):
                        prec=prec, ints=True)
         if kwds:
             t += pairs(kwds, prec=prec)
-        return _COMMASPACE_.join(t)
+        return sep.join(t) if sep else t
 
     @property_RO
     def iteration(self):  # see .karney.GDict
@@ -309,6 +320,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}).
@@ -422,11 +438,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
 
@@ -716,12 +729,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
 
@@ -843,7 +858,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
 
@@ -870,8 +885,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)
 
 
@@ -923,7 +938,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):
@@ -932,7 +951,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:
@@ -943,10 +963,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.
@@ -965,7 +985,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
@@ -976,6 +997,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.
 
@@ -986,15 +1012,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}).
@@ -1006,13 +1035,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).
@@ -1043,37 +1082,33 @@ 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.
 
            @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
 
@@ -1083,35 +1118,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):
@@ -1231,8 +1266,7 @@ 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
 
 
@@ -1255,11 +1289,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
 
 

pygeodesy/namedTuples.py

@@ -8,26 +8,27 @@ are all instances of some C{Named...Tuple} class, all sub-classes
 of C{_NamedTuple} defined in C{pygeodesy.named}.
 '''
 
-from pygeodesy.basics import map1, _xinstanceof
+from pygeodesy.basics import isinstanceof, map1, _xinstanceof
 # from pygeodesy.constants import INT0  # from .units
-from pygeodesy.errors import _ALL_LAZY, _MODS, _xattr, _xkwds_not  # _xkwds
-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.dms import toDMS  # _MODS
+from pygeodesy.errors import _xattr, _xkwds, _xkwds_not,  _ALL_LAZY, _MODS
+from pygeodesy.interns import NN, _1_, _2_, _a_, _A_, _area_, _angle_, _b_, _B_, \
+                             _band_, _c_, _C_, _D_, _datum_, _distance_, _E_, \
+                             _easting_, _end_, _fi_, _gamma_, _h_, _height_, \
+                             _hemipole_, _initial_, _j_, _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
-from pygeodesy.units import Band, Bearing, Degrees, Degrees2, Easting, \
-                            FIx, Height, Int, INT0, Lam, Lat, Lon, Meter, \
-                            Meter2, Northing, Number_, Phi, Precision_, \
-                            Radians, Radius, Scalar, Str
+from pygeodesy.units import Band, Bearing, Degrees, Degrees2, Easting, FIx, \
+                            Height, Int, Lam, Lat, Lon, Meter, Meter2, \
+                            Northing, Number_, Phi, Precision_, Radians, \
+                            Radius, Scalar, Str,  INT0
 
 __all__ = _ALL_LAZY.namedTuples
-__version__ = '24.05.18'
+__version__ = '24.06.08'
 
 # __DUNDER gets mangled in class
 _closest_     = 'closest'
@@ -324,6 +325,34 @@ class LatLonPrec5Tuple(LatLonPrec3Tuple):  # .wgrs.py
     _Units_ = LatLonPrec3Tuple._Units_ + ( Height,   Radius)
 
 
+class _NamedTupleTo(_NamedTuple):  # in .testNamedTuples
+    '''(INTERNAL) Base for C{-.toDegrees}, C{-.toRadians}.
+    '''
+    def _Degrees3(self, *xs, **toDMS_kwds):
+        '''(INTERNAL) Convert C{xs} from C{Radians} to C{Degrees} or C{toDMS}.
+        '''
+        if toDMS_kwds:
+            toDMS_kwds = _xkwds(toDMS_kwds, ddd=1, pos=NN)
+            toDMS, s   = _MODS.dms.toDMS, None
+        else:
+            toDMS, s   =  None, self
+        for x in xs:
+            if not isinstanceof(x, Degrees):
+                x, s = x.toDegrees(), None
+            yield toDMS(x, **toDMS_kwds) if toDMS else x
+        yield s
+
+    def _Radians3(self, *xs, **unused):
+        '''(INTERNAL) Convert C{xs} from C{Degrees} to C{Radians}.
+        '''
+        s = self
+        for x in xs:
+            if not isinstanceof(x, Radians):
+                x, s = x.toRadians(), None
+            yield x
+        yield s
+
+
 class NearestOn2Tuple(_NamedTuple):  # .ellipsoidalBaseDI
     '''2-Tuple C{(closest, fraction)} of the C{closest} point
        on and C{fraction} along a line (segment) between two

pygeodesy/nvectorBase.py

@@ -14,7 +14,7 @@ and published under the same MIT Licence**, see U{Vector-based geodesy
 from pygeodesy.constants import EPS, EPS1, EPS_2, R_M, _2_0, _N_2_0
 # from pygeodesy.datums import _spherical_datum  # from .formy
 from pygeodesy.errors import IntersectionError, _ValueError, VectorError, \
-                            _xkwds, _xkwds_pop2
+                            _xattrs, _xkwds, _xkwds_pop2
 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, \
@@ -22,8 +22,7 @@ from pygeodesy.formy import _isequalTo, n_xyz2latlon, n_xyz2philam, \
 # 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_
+                             _intersection_, _no_, _point_, _pole_, _SPACE_
 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,  _under
@@ -31,15 +30,15 @@ from pygeodesy.namedTuples import Trilaterate5Tuple, Vector3Tuple, \
                                   Vector4Tuple,  map1
 from pygeodesy.props import deprecated_method, Property_RO, property_doc_, \
                             property_RO, _update_all
-from pygeodesy.streprs import Fmt, hstr, unstr, _xattrs
+from pygeodesy.streprs import Fmt, hstr, unstr
 from pygeodesy.units import Bearing, Height, Radius_, Scalar
 from pygeodesy.utily import sincos2d, _unrollon, _unrollon3
-from pygeodesy.vector3d import Vector3d, _xyzhdn3
+from pygeodesy.vector3d import Vector3d, _xyzhdlln4
 
 from math import fabs, sqrt
 
 __all__ = _ALL_LAZY.nvectorBase
-__version__ = '24.05.31'
+__version__ = '24.06.12'
 
 
 class NvectorBase(Vector3d):  # XXX kept private
@@ -49,32 +48,29 @@ 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):
+    def __init__(self, x_xyz, y=None, z=None, h=0, datum=None, **ll_name):
         '''New n-vector normal to the earth's surface.
 
            @arg x_xyz: X component of vector (C{scalar}) or (3-D) vector
-                       (C{Nvector}, L{Vector3d}, L{Vector3Tuple} or
-                       L{Vector4Tuple}).
-           @kwarg y: Y component of vector (C{scalar}), ignored if B{C{x_xyz}}
-                     is not C{scalar}, otherwise same units as B{C{x_xyz}}.
-           @kwarg z: Z component of vector (C{scalar}), ignored if B{C{x_xyz}}
-                     is not C{scalar}, otherwise same units as B{C{x_xyz}}.
+                       (C{Nvector}, L{Vector3d}, L{Vector3Tuple} or L{Vector4Tuple}).
+           @kwarg y: Y component of vector (C{scalar}), required if B{C{x_xyz}} is
+                     C{scalar} and same units as B{C{x_xyz}}, ignored otherwise.
+           @kwarg z: Z component of vector (C{scalar}), like B{C{y}}.
            @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 C{B{name}=NN} (C{str}).
+           @kwarg ll_name: Optional C{B{name}=NN} (C{str}) and optional, original
+                           latlon C{B{ll}=None} (C{LatLon}).
 
-           @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}}.
+           @raise TypeError: Non-scalar B{C{x}}, B{C{y}} or B{C{z}} coordinate or
+                             B{C{x_xyz}} not an C{Nvector}, L{Vector3Tuple} or
+                             L{Vector4Tuple} or invalid B{C{datum}}.
         '''
-        h, d, n = _xyzhdn3(x_xyz, h, datum, ll, **name)
+        h, d, ll, n = _xyzhdlln4(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:
-            self._datum = _spherical_datum(d, name=self.name)  # pass-thru
+            self._datum = _spherical_datum(d, name=n)  # pass-thru
 
     @Property_RO
     def datum(self):
@@ -326,7 +322,7 @@ class NvectorBase(Vector3d):  # XXX kept private
             r = self.toCartesian(h=h, Cartesian=None, datum=d)
         else:
             kwds = _xkwds(LatLon_kwds, height=h, datum=d)
-            r = self._xnamed(LatLon(self.lat, self.lon, **kwds))
+            r = LatLon(self.lat, self.lon, **self._name1__(kwds))
         return r
 
     def toStr(self, prec=5, fmt=Fmt.PAREN, sep=_COMMASPACE_):  # PYCHOK expected
@@ -349,7 +345,7 @@ class NvectorBase(Vector3d):  # XXX kept private
     def toVector3d(self, norm=True):
         '''Convert this n-vector to a 3-D vector, I{ignoring height}.
 
-           @kwarg norm: Normalize the 3-D vector (C{bool}).
+           @kwarg norm: If C{True}, normalize the 3-D vector (C{bool}).
 
            @return: The (normalized) vector (L{Vector3d}).
         '''
@@ -369,7 +365,7 @@ class NvectorBase(Vector3d):  # XXX kept private
 
            @return: Normalized vector (C{Nvector}).
         '''
-        return _xattrs(Vector3d.unit(self, ll=ll), _under(_h_))
+        return _xattrs(Vector3d.unit(self, ll=ll), self, _under(_h_))
 
     @Property_RO
     def xyzh(self):
@@ -378,8 +374,8 @@ class NvectorBase(Vector3d):  # XXX kept private
         return self.xyz.to4Tuple(self.h)
 
 
-NorthPole = NvectorBase(0, 0, +1, name=_NorthPole_)  # North pole (C{Nvector})
-SouthPole = NvectorBase(0, 0, -1, name=_SouthPole_)  # South pole (C{Nvector})
+NorthPole = NvectorBase(0, 0, +1, name='NorthPole')  # North pole (C{Nvector})
+SouthPole = NvectorBase(0, 0, -1, name='SouthPole')  # South pole (C{Nvector})
 
 
 class _N_vector_(NvectorBase):
@@ -575,7 +571,7 @@ def sumOf(nvectors, Vector=None, h=None, **Vector_kwds):
                            arguments, ignored if C{B{Vector} is None}.
 
        @return: Vectorial sum (B{C{Vector}}) or a L{Vector4Tuple}C{(x, y,
-                z, h)} if B{C{Vector}} is C{None}.
+                z, h)} if C{B{Vector} is None}.
 
        @raise VectorError: No B{C{nvectors}}.
     '''