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

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.21'
 
 _COMMANL_           = _COMMA_ + _NL_
 _COMMASPACEDOT_     = _COMMASPACE_ + _DOT_
@@ -49,28 +50,32 @@ _Units_             = '_Units_'
 _UP                 =  2
 
 
-def _xjoined_(prefix, name, enquote=True):
-    '''(INTERNAL) Join C{pref} and non-empty C{name}.
+def _xjoined_(prefix, name=NN, enquote=True, **name__of_name):
+    '''(INTERNAL) Join C{prefix} and non-empty C{name}.
     '''
+    if name__of_name:
+        name = _name__(name, **name__of_name)
     if name and prefix:
         if enquote:
             name = repr(name)
-        n = _SPACE_(prefix, name)
+        t = _SPACE_(prefix, name)
     else:
-        n =  prefix or name
-    return n
+        t =  prefix or name
+    return t
 
 
-def _xnamed(inst, name, force=False):
+def _xnamed(inst, name=NN, force=False, **name__of_name):
     '''(INTERNAL) Set the instance' C{.name = B{name}}.
 
        @arg inst: The instance (C{_Named}).
-       @arg name: The name (C{str}).
-       @kwarg force: Force name change (C{bool}).
+       @kwarg name: The name (C{str}).
+       @kwarg force: If C{True}, force rename (C{bool}).
 
-       @return: The B{C{inst}}, named if B{C{force}}d or
-                not named before.
+       @return: The B{C{inst}}, renamed if B{C{force}}d
+                or if not named before.
     '''
+    if name__of_name:
+        name = _name__(name, **name__of_name)
     if name and isinstance(inst, _Named):
         if not inst.name:
             inst.name = name
@@ -85,7 +90,7 @@ def _xother3(inst, other, name=_other_, up=1, **name_other):
     if name_other:  # and other is None
         name, other = _xkwds_item2(name_other)
     elif other and len(other) == 1:
-        other = other[0]
+        name, other = _name__(name), other[0]
     else:
         raise _AssertionError(name, other, txt=classname(inst, prefixed=True))
     return other, name, up
@@ -165,6 +170,7 @@ class ADict(dict):
            C{floats} formatted by function L{pygeodesy.fstr}.
         '''
         n = _xattr(self, name=NN) or self.__class__.__name__
+        print(1, n)
         return Fmt.PAREN(n, self._toT(_EQUAL_, **prec_fmt))
 
     def toStr(self, **prec_fmt):
@@ -259,18 +265,18 @@ class _Named(object):
         '''
         return _xnamed(self.__class__(*args, **kwds), self.name)
 
-    def copy(self, deep=False, name=NN):
+    def copy(self, deep=False, **name):
         '''Make a shallow or deep copy of this instance.
 
            @kwarg deep: If C{True} make a deep, otherwise
                         a shallow copy (C{bool}).
-           @kwarg name: Optional, non-empty name (C{str}).
+           @kwarg name: Optional, non-empty C{B{name}=NN} (C{str}).
 
            @return: The copy (C{This class}).
         '''
         c = _xcopy(self, deep=deep)
         if name:
-            c.rename(name)
+            _ = c.rename(name)
         return c
 
     def _DOT_(self, *names):
@@ -282,7 +288,8 @@ class _Named(object):
         '''Duplicate this instance, replacing some attributes.
 
            @kwarg deep: If C{True} duplicate deep, otherwise shallow.
-           @kwarg items: Attributes to be changed (C{any}).
+           @kwarg items: Attributes to be changed (C{any}), including
+                         optional C{B{name}} (C{str}).
 
            @return: The duplicate (C{This class}).
 
@@ -292,7 +299,7 @@ class _Named(object):
         m, items = _xkwds_pop2(items, name=n)
         d = _xdup(self, deep=deep, **items)
         if m != n:
-            d.rename(m)
+            d.rename(m)  # zap _Named_Property_ROs
 #       if items:
 #           _update_all(d)
         return d
@@ -341,11 +348,11 @@ class _Named(object):
 
     @name.setter  # PYCHOK setter!
     def name(self, name):
-        '''Set the name (C{str}).
+        '''Set the C{B{name}=NN} (C{str}).
 
            @raise NameError: Can't rename, use method L{rename}.
         '''
-        m, n = self._name, str(name)
+        m, n = self._name, _name__(name)
         if not m:
             self._name = n
         elif n != m:
@@ -361,6 +368,11 @@ class _Named(object):
         #  _Named.name.fset(self, name), but NOT
         #  _Named(self).name = name
 
+    def _name__(self, name):  # usually **name
+        '''(INTERNAL) Get the C{name} or this C{name}.
+        '''
+        return _name__(name, _or_nameof=self)  # nameof(self)
+
     @Property_RO
     def named(self):
         '''Get the name I{or} class name or C{""} (C{str}).
@@ -408,12 +420,22 @@ class _Named(object):
 
            @return: The previous name (C{str}).
         '''
-        m, n = self._name, str(name)
+        m, n = self._name, _name__(name)
         if n != m:
             self._name = n
             _update_attrs(self, *_Named_Property_ROs)
         return m
 
+    def renamed(self, name):
+        '''Change the name.
+
+           @arg name: The new name (C{str}).
+
+           @return: This instance (C{str}).
+        '''
+        _ = self.rename(name)
+        return self
+
     @property_RO
     def sizeof(self):
         '''Get the current size in C{bytes} of this instance (C{int}).
@@ -443,16 +465,17 @@ class _Named(object):
 #       '''
 #       return _DOT_(self, unstr(which, *args, **kwds))
 
-    def _xnamed(self, inst, name=NN, force=False):
+    def _xnamed(self, inst, name=NN, **force):
         '''(INTERNAL) Set the instance' C{.name = self.name}.
 
            @arg inst: The instance (C{_Named}).
-           @kwarg name: Optional name, overriding C{self.name} (C{str}).
-           @kwarg force: Force name change (C{bool}).
+           @kwarg name: The name (C{str}).
+           @kwarg force: If C{True}, force rename (C{bool}).
 
-           @return: The B{C{inst}}, named if not named before.
+           @return: The B{C{inst}}, renamed if B{C{force}}d
+                    or if not named before.
         '''
-        return _xnamed(inst, name or self.name, force=force)
+        return _xnamed(inst, name, **force)
 
     def _xrenamed(self, inst):
         '''(INTERNAL) Rename the instance' C{.name = self.name}.
@@ -466,7 +489,7 @@ class _Named(object):
         if not isinstance(inst, _Named):
             raise _IsnotError(_valid_, inst=inst)
 
-        inst.rename(self.name)
+        _ = inst.rename(self.name)
         return inst
 
 _Named_Property_ROs = _allPropertiesOf_n(5, _Named, Property_RO)  # PYCHOK once
@@ -559,16 +582,17 @@ class _NamedBase(_Named):
 
 
 class _NamedDict(ADict, _Named):
-    '''(INTERNAL) Named C{dict} with key I{and} attribute
-       access to the items.
+    '''(INTERNAL) Named C{dict} with key I{and} attribute access
+       to the items.
     '''
     def __init__(self, *args, **kwds):
-        if args:  # args override kwds
+        if args:  # is args[0] a dict?
             if len(args) != 1:  # or not isinstance(args[0], dict)
+                kwds = _name1__(kwds)
                 t = unstr(self.classname, *args, **kwds)  # PYCHOK no cover
                 raise _ValueError(args=len(args), txt=t)
-            kwds = _xkwds(dict(args[0]), **kwds)
-        n, kwds = _xkwds_pop2(kwds, name=NN)
+            kwds = _xkwds(dict(args[0]), **kwds)  # args[0] overrides kwds
+        n, kwds = _name2__(**kwds)
         if n:
             _Named.name.fset(self, n)  # see _Named.name
         ADict.__init__(self, kwds)
@@ -640,7 +664,7 @@ class _NamedEnum(_NamedDict):
            @arg Classes: Additional, acceptable classes or C{type}s.
         '''
         self._item_Classes = (Class,) + Classes
-        n = _xkwds_get(name, name=NN) or NN(Class.__name__, _s_)
+        n = _name__(**name) or NN(Class.__name__, _s_)  # _dunder_nameof
         if n and _xvalid(n, underOK=True):
             _Named.name.fset(self, n)  # see _Named.name
 
@@ -881,9 +905,11 @@ class _NamedEnumItem(_NamedBase):
     def name(self, name):
         '''Set the name, unless already registered (C{str}).
         '''
+        name = _name__(name) or _NN_
         if self._enum:
-            raise _NameError(str(name), self, txt=_registered_)  # XXX _TypeError
-        self._name = str(name)
+            raise _NameError(name, self, txt=_registered_)  # XXX _TypeError
+        if name:
+            self._name = name
 
     def _register(self, enum, name):
         '''(INTERNAL) Add this item as B{C{enum.name}}.
@@ -891,6 +917,7 @@ class _NamedEnumItem(_NamedBase):
            @note: Don't register if name is empty or doesn't
                   start with a letter.
         '''
+        name = _name__(name)
         if name and _xvalid(name, underOK=True):
             self.name = name
             if name[:1].isalpha():  # '_...' not registered
@@ -1043,7 +1070,7 @@ class _NamedTuple(tuple, _Named):
 
     iteritems = items
 
-    def _kwdself(self, iteration=None, name=NN, **unused):
+    def _kwdself(self, iteration=None, **name):
         '''(INTERNAL) Set C{__new__} keyword arguments.
         '''
         if iteration is not None:
@@ -1144,7 +1171,8 @@ class _NamedTuple(tuple, _Named):
         if (issubclassof(xTuple, _NamedTuple) and
             (len(self._Names_) + len(items)) == len(xTuple._Names_) and
                  self._Names_ == xTuple._Names_[:len(self)]):
-            return xTuple(self + items, **_xkwds(name, name=self.name))  # *(self + items)
+            n = _name__(**name) or self.name
+            return xTuple(self + items, name=n)  # *(self + items)
         c = NN(self.classname,  repr(self._Names_))  # PYCHOK no cover
         x = NN(xTuple.__name__, repr(xTuple._Names_))  # PYCHOK no cover
         raise TypeError(_SPACE_(c, _vs_, x))
@@ -1232,9 +1260,9 @@ def modulename(clas, prefixed=None):  # in .basics._xversion
        @return: The B{C{class}}'s C{[module.]class} name (C{str}).
     '''
     try:
-        n = clas.__name__
+        n =  clas.__name__
     except AttributeError:
-        n = '__name__'  # _DUNDER_(NN, _name_, NN)
+        n = _dunder_name_
     if prefixed or (classnaming() if prefixed is None else False):
         try:
             m =  clas.__module__.rsplit(_DOT_, 1)
@@ -1244,6 +1272,62 @@ def modulename(clas, prefixed=None):  # in .basics._xversion
     return n
 
 
+# def _name__(name=NN, name__=None, _or_nameof=None, **kwds):
+#     '''(INTERNAL) Get single keyword argument C{B{name}=NN|None}.
+#     '''
+#     if kwds:  # "unexpected keyword arguments ..."
+#         m = _MODS.errors
+#         raise m._UnexpectedError(**kwds)
+#     if name:  # is given
+#         n = _name__(**name) if isinstance(name, dict) else str(name)
+#     elif name__ is not None:
+#         n = getattr(name__, _dunder_name_, NN)  # _xattr(name__, __name__=NN)
+#     else:
+#         n = name  # NN or None or {} or any False type
+#     if _or_nameof is not None and not n:
+#         n = getattr(_or_nameof, _name_, NN) # _xattr(_or_nameof, name=NN)
+#     return n  # str or None or {}
+
+
+def _name__(name=NN, **kwds):
+    '''(INTERNAL) Get single keyword argument C{B{name}=NN|None}.
+    '''
+    if name or kwds:
+        name, kwds = _name2__(name, **kwds)
+        if kwds:  # "unexpected keyword arguments ..."
+            m = _MODS.errors
+            raise m._UnexpectedError(**kwds)
+    return name if name or name is None else NN
+
+
+def _name1__(kwds_name, _or_nameof=None):
+    '''(INTERNAL) Resolve and set the C{B{name}=NN}.
+    '''
+    if kwds_name:
+        n, kwds_name = _name2__(kwds_name, _or_nameof=_or_nameof)
+        if n:
+            kwds_name.update(name=n)
+    return kwds_name
+
+
+def _name2__(name=NN, name__=None, _or_nameof=None, **kwds):
+    '''(INTERNAL) Get the C{B{name}=NN|None} and other C{kwds}.
+    '''
+    if name:  # is given
+        if isinstance(name, dict):
+            kwds.update(name)  # kwds = _xkwds(kwds, **name)?
+            n, kwds = _name2__(**kwds)
+        else:
+            n = str(name)
+    elif name__ is not None:
+        n = getattr(name__, _dunder_name_, NN)  # _xattr(name__, __name__=NN)
+    else:
+        n = name if name is None else NN
+    if _or_nameof is not None and not n:
+        n = getattr(_or_nameof, _name_, NN)  # _xattr(_or_nameof, name=NN)
+    return n, kwds  # (str or None or {}), dict
+
+
 def nameof(inst):
     '''Get the name of an instance.
 

pygeodesy/namedTuples.py

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

pygeodesy/nvectorBase.py

@@ -39,7 +39,7 @@ from pygeodesy.vector3d import Vector3d, _xyzhdn3
 from math import fabs, sqrt
 
 __all__ = _ALL_LAZY.nvectorBase
-__version__ = '24.05.13'
+__version__ = '24.05.18'
 
 
 class NvectorBase(Vector3d):  # XXX kept private
@@ -49,7 +49,7 @@ class NvectorBase(Vector3d):  # XXX kept private
     _h     = Height(h=0)  # height (C{meter})
     _H     = NN           # height prefix (C{str}), '↑' in JS version
 
-    def __init__(self, x_xyz, y=None, z=None, h=0, ll=None, datum=None, name=NN):
+    def __init__(self, x_xyz, y=None, z=None, h=0, ll=None, datum=None, **name):
         '''New n-vector normal to the earth's surface.
 
            @arg x_xyz: X component of vector (C{scalar}) or (3-D) vector
@@ -62,15 +62,15 @@ class NvectorBase(Vector3d):  # XXX kept private
            @kwarg h: Optional height above surface (C{meter}).
            @kwarg ll: Optional, original latlon (C{LatLon}).
            @kwarg datum: Optional, I{pass-thru} datum (L{Datum}).
-           @kwarg name: Optional name (C{str}).
+           @kwarg name: Optional C{B{name}=NN} (C{str}).
 
            @raise TypeError: Non-scalar B{C{x}}, B{C{y}} or B{C{z}}
                              coordinate or B{C{x}} not an C{Nvector},
                              L{Vector3Tuple} or L{Vector4Tuple} or
                              invalid B{C{datum}}.
         '''
-        h, d, n = _xyzhdn3(x_xyz, h, datum, ll)
-        Vector3d.__init__(self, x_xyz, y=y, z=z, ll=ll, name=name or n)
+        h, d, n = _xyzhdn3(x_xyz, h, datum, ll, **name)
+        Vector3d.__init__(self, x_xyz, y=y, z=z, ll=ll, name=n)
         if h:
             self.h = h
         if d is not None:
@@ -461,8 +461,8 @@ class LatLonNvectorBase(LatLonBase):
            @arg bearing1: Bearing at this point (compass C{degrees360}).
            @arg other: The other point (C{LatLon}).
            @arg bearing2: Bearing at the other point (compass C{degrees360}).
-           @kwarg height: Optional height at the triangulated point,
-                          overriding the mean height (C{meter}).
+           @kwarg height: Optional height at the triangulated point, overriding
+                          the mean height (C{meter}).
            @kwarg wrap: If C{True}, use this and the B{C{other}} point
                         I{normalized} (C{bool}).
 

pygeodesy/points.py

@@ -41,8 +41,8 @@ from pygeodesy.fmath import favg, fdot, hypot,  Fsum, fsum
 from pygeodesy.formy import _bearingTo2, equirectangular_,  _spherical_datum
 from pygeodesy.interns import NN, _colinear_, _COMMASPACE_, _composite_, \
                              _DEQUALSPACED_, _ELLIPSIS_, _EW_, _immutable_, \
-                             _near_, _no_, _not_, _NS_, _point_, _SPACE_, \
-                             _UNDER_, _valid_  # _lat_, _lon_
+                             _near_, _no_, _NS_, _point_, _SPACE_, _UNDER_, \
+                             _valid_  # _lat_, _lon_
 from pygeodesy.iters import LatLon2PsxyIter, PointsIter, points2
 from pygeodesy.latlonBase import LatLonBase, _latlonheight3, \
                                 _ALL_DOCS, _ALL_LAZY, _MODS
@@ -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.10'
+__version__ = '24.05.19'
 
 _ilat_  = 'ilat'
 _ilon_  = 'ilon'
@@ -92,7 +92,7 @@ class LatLon_(LatLonBase):  # XXX in heights._HeightBase.height
     # python3 -m timeit -s "from pygeodesy... import LatLonBase as LL" "LL(0, 0)" 2.14 usec
     # python3 -m timeit -s "from pygeodesy import LatLon_" "LatLon_(0, 0)" 216 nsec
 
-    def __init__(self, latlonh, lon=None, height=0, wrap=False, name=NN, datum=None):
+    def __init__(self, latlonh, lon=None, height=0, wrap=False, datum=None, **name):
         '''New L{LatLon_}.
 
            @note: The lat- and longitude values are taken I{as-given,
@@ -283,7 +283,7 @@ class _Basequence(_Sequence):  # immutable, on purpose
         '''
         for i in self._findall(point, start_end):
             return i
-        raise _IndexError(self._itemname, point, txt=_not_('found'))
+        raise _IndexError(self._itemname, point, txt_not_='found')
 
     @property_RO
     def isNumpy2(self):  # PYCHOK no cover
@@ -1156,7 +1156,7 @@ def fractional(points, fi, j=None, wrap=None, LatLon=None, Vector=None, **kwds):
     '''
     if LatLon and Vector:  # PYCHOK no cover
         kwds = _xkwds(kwds, fi=fi, LatLon=LatLon, Vector=Vector)
-        raise _TypeError(txt=fractional.__name__, **kwds)
+        raise _TypeError(txt__=fractional, **kwds)
     w = wrap if LatLon else False  # intermediateTo
     try:
         if not isscalar(fi) or fi < 0:
@@ -1168,7 +1168,7 @@ def fractional(points, fi, j=None, wrap=None, LatLon=None, Vector=None, **kwds):
         elif Vector:
             p = Vector(p.x, p.y, p.z, **kwds)
     except (IndexError, TypeError):
-        raise _IndexError(fi=fi, points=points, wrap=w, txt=fractional.__name__)
+        raise _IndexError(fi=fi, points=points, wrap=w, txt__=fractional)
     return p
 
 
@@ -1191,12 +1191,12 @@ def _fractional(points, fi, j, fin=None, wrap=None):  # in .frechet.py
         elif _isLatLon(p):  # backward compatible default
             p = LatLon2Tuple(favg(p.lat, q.lat, f=r),
                              favg(p.lon, q.lon, f=r),
-                             name=fractional.__name__)
+                             name__=fractional)
         else:  # assume p and q are cartesian or vectorial
             z = p.z if p.z is q.z else favg(p.z, q.z, f=r)
             p = Vector3Tuple(favg(p.x, q.x, f=r),
                              favg(p.y, q.y, f=r), z,
-                             name=fractional.__name__)
+                             name__=fractional)
     return p
 
 

pygeodesy/rhumb/__init__.py

@@ -9,7 +9,7 @@ u'''Package of lazily imported C{rhumb} modules L{rhumb.aux_}, L{rhumb.ekx} and
 from pygeodesy.lazily import _ALL_LAZY, _ALL_OTHER, _lazy_import_as, _unLazy0
 
 __all__ = _ALL_LAZY.rhumb
-__version__ = '23.12.29'
+__version__ = '24.05.24'
 
 if _unLazy0:  # or _isfrozen
     from pygeodesy.rhumb.aux_ import RhumbAux, RhumbLineAux