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

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.10'
 
 _COMMANL_           = _COMMA_ + _NL_
 _COMMASPACEDOT_     = _COMMASPACE_ + _DOT_
@@ -248,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)
@@ -309,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}).
@@ -422,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
 
@@ -716,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
 
@@ -843,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
 
@@ -870,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)
 
 
@@ -923,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):
@@ -932,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:
@@ -943,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.
@@ -965,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
@@ -976,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.
 
@@ -986,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}).
@@ -1006,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).
@@ -1043,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
 
@@ -1083,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):
@@ -1231,8 +1257,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 +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
 
 

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

@@ -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
@@ -34,12 +33,12 @@ from pygeodesy.props import deprecated_method, Property_RO, property_doc_, \
 from pygeodesy.streprs import Fmt, hstr, unstr, _xattrs
 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.06'
 
 
 class NvectorBase(Vector3d):  # XXX kept private
@@ -49,32 +48,30 @@ 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}), 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}}.
            @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 +323,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
@@ -378,8 +375,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):

pygeodesy/points.py

@@ -62,7 +62,7 @@ from pygeodesy.utily import atan2b, degrees90, degrees180, degrees2m, \
 from math import cos, fabs, fmod as _fmod, radians, sin
 
 __all__ = _ALL_LAZY.points
-__version__ = '24.05.25'
+__version__ = '24.06.06'
 
 _ilat_  = 'ilat'
 _ilon_  = 'ilon'
@@ -1479,7 +1479,7 @@ def nearestOn5(point, points, closed=False, wrap=False, adjust=True,
                      spherical earth radius L{R_KM}).
        @kwarg LatLon_and_kwds: Optional, C{B{LatLon}=None} class to use for
                      the closest point and additional B{C{LatLon}} keyword
-                     arguments, ignored if C{B{LatLon}=None} or not given.
+                     arguments, ignored if C{B{LatLon} is None} or not given.
 
        @return: A L{NearestOn3Tuple}C{(closest, distance, angle)} with the
                 {closest} point (B{C{LatLon}}) or if C{B{LatLon} is None},

pygeodesy/rhumb/solve.py

@@ -21,7 +21,7 @@ from pygeodesy.solveBase import _SolveBase, _SolveLineBase
 from pygeodesy.utily import _unrollon, _Wrap, wrap360
 
 __all__ = _ALL_LAZY.rhumb_solve
-__version__ = '24.05.31'
+__version__ = '24.06.04'
 
 
 class _RhumbSolveBase(_SolveBase):
@@ -37,9 +37,9 @@ class _RhumbSolveBase(_SolveBase):
     def _cmdBasic(self):
         '''(INTERNAL) Get the basic C{RhumbSolve} cmd (C{tuple}).
         '''
-        return (self.RhumbSolve,) + self._e_option \
-                                  + self._p_option \
-                                  + self._s_option
+        return (self.RhumbSolve,) + (self._e_option +
+                                     self._p_option +
+                                     self._s_option)
 
     @Property
     def RhumbSolve(self):
@@ -423,59 +423,6 @@ if __name__ == '__main__':
 #   p = rlS.ArcPosition(49.475527)
 #   printf('ArcPosition: %s %r', p == r, p)
 
-# % python3 -m pygeodesy.rhumb.solve
-
-# version: /opt/local/bin/RhumbSolve: GeographicLib version 1.51
-#
-# Direct: GDict(S12=44095641862956.148438, azi12=51, lat1=40.6, lat2=71.6889, lon1=-73.8, lon2=0.25552, s12=5500000.0)
-# Direct3: Destination3Tuple(lat=71.6889, lon=0.25552, final=51.0)
-#
-# Inverse: GDict(S12=37395209100030.367188, a12=51.929543, azi12=77.76839, lat1=40.6, lat2=51.6, lon1=-73.8, lon2=-0.5, s12=5771083.383328)
-# Inverse1: 51.92954250756195
-# Inverse3: Distance3Tuple(distance=5771083.383328, initial=77.76839, final=77.76839)
-#
-# Inverse: GDict(S12=-63760642939072.492188, a12=115.02062, azi12=-92.388888, lat1=40.6, lat2=35.8, lon1=-73.8, lon2=140.3, s12=12782581.067684)
-# Inverse1: 115.02061966879258
-# Inverse3: Distance3Tuple(distance=12782581.067684, initial=267.611112, final=267.611112)
-#
-# Position:    True  GDict(S12=44095641862956.148438, azi12=51, lat1=40.6, lat2=71.6889, lon1=-73.8, lon2=0.25552, s12=5500000.0)
-
-
-# % python3 -m pygeodesy.rhumb.solve --verbose
-
-# RhumbSolve 'Test' 1: /opt/local/bin/RhumbSolve --version (invoke)
-# RhumbSolve 'Test' 1: /opt/local/bin/RhumbSolve: GeographicLib version 1.51 (0)
-# version: /opt/local/bin/RhumbSolve: GeographicLib version 1.51
-# RhumbSolve 'Test' 2: /opt/local/bin/RhumbSolve -p 10 \ 40.600000000000001 -73.799999999999997 51.0 5500000.0 (Direct)
-# RhumbSolve 'Test' 2: lat2=71.688899882813047, lon2=0.255519824423445, S12=44095641862956.148 (0)
-
-# Direct: GDict(S12=44095641862956.148438, azi12=51, lat1=40.6, lat2=71.6889, lon1=-73.8, lon2=0.25552, s12=5500000.0)
-# RhumbSolve 'Test' 3: /opt/local/bin/RhumbSolve -p 10 \ 40.600000000000001 -73.799999999999997 51.0 5500000.0 (Direct3)
-# RhumbSolve 'Test' 3: lat2=71.688899882813047, lon2=0.255519824423445, S12=44095641862956.148 (0)
-# Direct3: Destination3Tuple(lat=71.6889, lon=0.25552, final=51.0)
-# RhumbSolve 'Test' 4: /opt/local/bin/RhumbSolve -p 10 -i \ 40.600000000000001 -73.799999999999997 51.600000000000001 -0.5 (Inverse)
-# RhumbSolve 'Test' 4: azi12=77.768389710255661, s12=5771083.3833280317, S12=37395209100030.367 (0)
-
-# Inverse: GDict(S12=37395209100030.367188, a12=51.929543, azi12=77.76839, lat1=40.6, lat2=51.6, lon1=-73.8, lon2=-0.5, s12=5771083.383328)
-# RhumbSolve 'Test' 5: /opt/local/bin/RhumbSolve -p 10 -i \ 40.600000000000001 -73.799999999999997 51.600000000000001 -0.5 (Inverse1)
-# RhumbSolve 'Test' 5: azi12=77.768389710255661, s12=5771083.3833280317, S12=37395209100030.367 (0)
-# Inverse1: 51.92954250756195
-# RhumbSolve 'Test' 6: /opt/local/bin/RhumbSolve -p 10 -i \ 40.600000000000001 -73.799999999999997 51.600000000000001 -0.5 (Inverse3)
-# RhumbSolve 'Test' 6: azi12=77.768389710255661, s12=5771083.3833280317, S12=37395209100030.367 (0)
-# Inverse3: Distance3Tuple(distance=5771083.383328, initial=77.76839, final=77.76839)
-# RhumbSolve 'Test' 7: /opt/local/bin/RhumbSolve -p 10 -i \ 40.600000000000001 -73.799999999999997 35.799999999999997 140.300000000000011 (Inverse)
-# RhumbSolve 'Test' 7: azi12=-92.388887981699639, s12=12782581.0676841792, S12=-63760642939072.492 (0)
-
-# Inverse: GDict(S12=-63760642939072.492188, a12=115.02062, azi12=-92.388888, lat1=40.6, lat2=35.8, lon1=-73.8, lon2=140.3, s12=12782581.067684)
-# RhumbSolve 'Test' 8: /opt/local/bin/RhumbSolve -p 10 -i \ 40.600000000000001 -73.799999999999997 35.799999999999997 140.300000000000011 (Inverse1)
-# RhumbSolve 'Test' 8: azi12=-92.388887981699639, s12=12782581.0676841792, S12=-63760642939072.492 (0)
-# Inverse1: 115.02061966879258
-# RhumbSolve 'Test' 9: /opt/local/bin/RhumbSolve -p 10 -i \ 40.600000000000001 -73.799999999999997 35.799999999999997 140.300000000000011 (Inverse3)
-# RhumbSolve 'Test' 9: azi12=-92.388887981699639, s12=12782581.0676841792, S12=-63760642939072.492 (0)
-# Inverse3: Distance3Tuple(distance=12782581.067684, initial=267.611112, final=267.611112)
-
-# Position:    True  GDict(S12=44095641862956.148438, azi12=51, lat1=40.6, lat2=71.6889, lon1=-73.8, lon2=0.25552, s12=5500000.0)
-
 
 # % python3 -m pygeodesy.rhumb.solve
 
@@ -485,11 +432,11 @@ if __name__ == '__main__':
 # Direct3: Destination3Tuple(lat=71.6889, lon=0.25552, final=51.0)
 
 # Inverse: GDict(a12=51.929543, azi12=77.76839, lat1=40.6, lat2=51.6, lon1=-73.8, lon2=-0.5, s12=5771083.383328, S12=37395209100030.390625)
-# Inverse1: 51.92954250756191
+# Inverse1: 51.929542507561905
 # Inverse3: Distance3Tuple(distance=5771083.383328, initial=77.76839, final=77.76839)
 
 # Inverse: GDict(a12=115.02062, azi12=-92.388888, lat1=40.6, lat2=35.8, lon1=-73.8, lon2=140.3, s12=12782581.067684, S12=-63760642939072.5)
-# Inverse1: 115.02061966879249
+# Inverse1: 115.02061966879248
 # Inverse3: Distance3Tuple(distance=12782581.067684, initial=267.611112, final=267.611112)
 
 # Position:    True  GDict(azi12=51, lat1=40.6, lat2=71.6889, lon1=-73.8, lon2=0.25552, s12=5500000.0, S12=44095641862956.109375)
@@ -513,7 +460,7 @@ if __name__ == '__main__':
 # Inverse: GDict(a12=51.929543, azi12=77.76839, lat1=40.6, lat2=51.6, lon1=-73.8, lon2=-0.5, s12=5771083.383328, S12=37395209100030.390625)
 # RhumbSolve 'Test' 5: /opt/local/bin/RhumbSolve -p 10 -i \ 40.600000000000001 -73.799999999999997 51.600000000000001 -0.5 (Inverse1)
 # RhumbSolve 'Test' 5: azi12=77.768389710255661, s12=5771083.383328028, S12=37395209100030.391 (0)
-# Inverse1: 51.92954250756191
+# Inverse1: 51.929542507561905
 # RhumbSolve 'Test' 6: /opt/local/bin/RhumbSolve -p 10 -i \ 40.600000000000001 -73.799999999999997 51.600000000000001 -0.5 (Inverse3)
 # RhumbSolve 'Test' 6: azi12=77.768389710255661, s12=5771083.383328028, S12=37395209100030.391 (0)
 # Inverse3: Distance3Tuple(distance=5771083.383328, initial=77.76839, final=77.76839)
@@ -523,7 +470,7 @@ if __name__ == '__main__':
 # Inverse: GDict(a12=115.02062, azi12=-92.388888, lat1=40.6, lat2=35.8, lon1=-73.8, lon2=140.3, s12=12782581.067684, S12=-63760642939072.5)
 # RhumbSolve 'Test' 8: /opt/local/bin/RhumbSolve -p 10 -i \ 40.600000000000001 -73.799999999999997 35.799999999999997 140.300000000000011 (Inverse1)
 # RhumbSolve 'Test' 8: azi12=-92.388887981699654, s12=12782581.0676841699, S12=-63760642939072.5 (0)
-# Inverse1: 115.02061966879249
+# Inverse1: 115.02061966879248
 # RhumbSolve 'Test' 9: /opt/local/bin/RhumbSolve -p 10 -i \ 40.600000000000001 -73.799999999999997 35.799999999999997 140.300000000000011 (Inverse3)
 # RhumbSolve 'Test' 9: azi12=-92.388887981699654, s12=12782581.0676841699, S12=-63760642939072.5 (0)
 # Inverse3: Distance3Tuple(distance=12782581.067684, initial=267.611112, final=267.611112)