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

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.31'
 
 
 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:
@@ -385,7 +385,7 @@ SouthPole = NvectorBase(0, 0, -1, name=_SouthPole_)  # South pole (C{Nvector})
 class _N_vector_(NvectorBase):
     '''(INTERNAL) Minimal, low-overhead C{n-vector}.
     '''
-    def __init__(self, x, y, z, h=0, name=NN):
+    def __init__(self, x, y, z, h=0, **name):
         self._x, self._y, self._z = x, y, z
         if h:
             self._h = h
@@ -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/osgr.py

@@ -33,14 +33,14 @@ from pygeodesy.datums import Datums, _ellipsoidal_datum, _WGS84
 # from pygeodesy.dms import parseDMS2   # _MODS
 from pygeodesy.ellipsoidalBase import LatLonEllipsoidalBase as _LLEB
 from pygeodesy.errors import _parseX, _TypeError, _ValueError, \
-                             _xkwds, _xkwds_get
+                             _xkwds, _xkwds_get, _xkwds_pop2
 from pygeodesy.fmath import Fdot, fpowers
 from pygeodesy.fsums import _Fsumf_
 from pygeodesy.interns import MISSING, NN, _A_, _COLON_, _COMMA_, \
                              _COMMASPACE_, _DOT_, _ellipsoidal_, \
                              _latlon_, _not_, _SPACE_
 from pygeodesy.lazily import _ALL_LAZY, _ALL_MODS as _MODS
-from pygeodesy.named import _NamedBase, nameof, _xnamed
+from pygeodesy.named import _name2__, _NamedBase, nameof
 from pygeodesy.namedTuples import EasNor2Tuple, LatLon2Tuple, \
                                   LatLonDatum3Tuple
 from pygeodesy.props import Property_RO, property_RO
@@ -53,7 +53,7 @@ from pygeodesy.utily import degrees90, degrees180, sincostan3, truncate
 from math import cos, fabs, radians, sin, sqrt
 
 __all__ = _ALL_LAZY.osgr
-__version__ = '24.05.13'
+__version__ = '24.05.31'
 
 _equivalent_ = 'equivalent'
 _OSGR_       = 'OSGR'
@@ -194,22 +194,17 @@ class Osgr(_NamedBase):
     _northing   =  0         # Nothing (C{meter})
     _resolution =  0         # from L{parseOSGR} (C{meter})
 
-    def __init__(self, easting, northing, datum=None, name=NN,
-                                          resolution=0):
+    def __init__(self, easting, northing, datum=None, resolution=0, **name):
         '''New L{Osgr} coordinate.
 
-           @arg easting: Easting from the OS C{National Grid}
-                         origin (C{meter}).
-           @arg northing: Northing from the OS C{National Grid}
-                          origin (C{meter}).
+           @arg easting: Easting from the OS C{National Grid} origin (C{meter}).
+           @arg northing: Northing from the OS C{National Grid} origin (C{meter}).
            @kwarg datum: Override default datum (C{Datums.OSGB36}).
-           @kwarg name: Optional name (C{str}).
-           @kwarg resolution: Optional resolution (C{meter}),
-                              C{0} for default.
+           @kwarg resolution: Optional resolution (C{meter}), C{0} for default.
+           @kwarg name: Optional C{B{name}=NN} (C{str}).
 
-           @raise OSGRError: Invalid or negative B{C{easting}} or
-                             B{C{northing}} or B{C{datum}} not an
-                             C{Datums.OSGB36} equivalent.
+           @raise OSGRError: Invalid or negative B{C{easting}} or B{C{northing}}
+                             or B{C{datum}} not an C{Datums.OSGB36} equivalent.
         '''
         if datum:  # PYCHOK no cover
             try:
@@ -267,17 +262,17 @@ class Osgr(_NamedBase):
         '''
         return self._northing
 
-    def parse(self, strOSGR, name=NN):
+    def parse(self, strOSGR, **name):
         '''Parse an OSGR reference to a similar L{Osgr} instance.
 
            @arg strOSGR: The OSGR reference (C{str}), see function L{parseOSGR}.
-           @kwarg name: Optional instance name (C{str}), overriding this name.
+           @kwarg name: Optional C{B{name}=NN} (C{str}), overriding this name.
 
            @return: The similar instance (L{Osgr})
 
            @raise OSGRError: Invalid B{C{strOSGR}}.
         '''
-        return parseOSGR(strOSGR, Osgr=self.classof, name=name or self.name)
+        return parseOSGR(strOSGR, Osgr=self.classof, name=self._name__(name))
 
     @property_RO
     def resolution(self):
@@ -496,19 +491,20 @@ def _ll2datum(ll, datum, name):
 def _ll2LatLon3(ll, LatLon, datum, LatLon_kwds):
     '''(INTERNAL) Convert C{ll} to C{LatLon}
     '''
+    n = nameof(ll)
     if LatLon is None:
         r = _ll2datum(ll, datum, LatLonDatum3Tuple.__name__)
-        r =  LatLonDatum3Tuple(r.lat, r.lon, r.datum)
+        r =  LatLonDatum3Tuple(r.lat, r.lon, r.datum, name=n)
     else:  # must be ellipsoidal
         _xsubclassof(_LLEB, LatLon=LatLon)
         r = _ll2datum(ll, datum, LatLon.__name__)
-        r =  LatLon(r.lat, r.lon, datum=r.datum, **LatLon_kwds)
+        r =  LatLon(r.lat, r.lon, datum=r.datum, **_xkwds(LatLon_kwds, name=n))
     if r._iteration != ll._iteration:
         r._iteration = ll._iteration
-    return _xnamed(r, nameof(ll))
+    return r
 
 
-def parseOSGR(strOSGR, Osgr=Osgr, name=NN, **Osgr_kwds):
+def parseOSGR(strOSGR, Osgr=Osgr, **name_Osgr_kwds):
     '''Parse a string representing an OS Grid Reference, consisting
        of C{"[GD] easting northing"}.
 
@@ -520,9 +516,9 @@ def parseOSGR(strOSGR, Osgr=Osgr, name=NN, **Osgr_kwds):
        @arg strOSGR: An OSGR coordinate (C{str}).
        @kwarg Osgr: Optional class to return the OSGR coordinate
                     (L{Osgr}) or C{None}.
-       @kwarg name: Optional B{C{Osgr}} name (C{str}).
-       @kwarg Osgr_kwds: Optional, additional B{C{Osgr}} keyword
-                         arguments, ignored if C{B{Osgr} is None}.
+       @kwarg name_Osgr_kwds: Optional C{B{name}=NN} (C{str}) and
+                   optional, additional B{C{Osgr}} keyword arguments,
+                   ignored if C{B{Osgr} is None}.
 
        @return: An (B{C{Osgr}}) instance or if B{C{Osgr}} is
                 C{None} an L{EasNor2Tuple}C{(easting, northing)}.
@@ -537,7 +533,7 @@ def parseOSGR(strOSGR, Osgr=Osgr, name=NN, **Osgr_kwds):
             raise ValueError
         return g
 
-    def _OSGR(strOSGR, Osgr, name):
+    def _OSGR(strOSGR, Osgr, kwds):
         s = _splituple(strOSGR.strip())
         p =  len(s)
         if not p:
@@ -570,20 +566,20 @@ def parseOSGR(strOSGR, Osgr=Osgr, name=NN, **Osgr_kwds):
             e +=  E * _100km
             n +=  N * _100km
 
+        name, kwds = _name2__(**kwds)
         if Osgr is None:
             _ = _MODS.osgr.Osgr(e, n, resolution=m)  # validate
             r =  EasNor2Tuple(e, n, name=name)
         else:
-            r =  Osgr(e, n, name=name,
-                         **_xkwds(Osgr_kwds, resolution=m))
+            r =  Osgr(e, n, name=name, **_xkwds(kwds, resolution=m))
         return r
 
-    return _parseX(_OSGR, strOSGR, Osgr, name,
+    return _parseX(_OSGR, strOSGR, Osgr, name_Osgr_kwds,
                           strOSGR=strOSGR, Error=OSGRError)
 
 
-def toOsgr(latlon, lon=None, kTM=False, datum=_WGS84, Osgr=Osgr, name=NN,  # MCCABE 14
-                                               **prec_Osgr_kwds):
+def toOsgr(latlon, lon=None, kTM=False, datum=_WGS84, Osgr=Osgr,  # MCCABE 14
+                                          **prec_name_Osgr_kwds):
     '''Convert a lat-/longitude point to an OSGR coordinate.
 
        @arg latlon: Latitude (C{degrees}) or an (ellipsoidal) geodetic
@@ -597,11 +593,10 @@ def toOsgr(latlon, lon=None, kTM=False, datum=_WGS84, Osgr=Osgr, name=NN,  # MCC
                      L{a_f2Tuple}).
        @kwarg Osgr: Optional class to return the OSGR coordinate
                     (L{Osgr}) or C{None}.
-       @kwarg name: Optional B{C{Osgr}} name (C{str}).
-       @kwarg prec_Osgr_kwds: Optional L{truncate} precision
-                              C{B{prec}=ndigits} and/or additional
-                              B{C{Osgr}} keyword arguments, ignored
-                              if C{B{Osgr} is None}.
+       @kwarg prec_name_Osgr_kwds: Optional C{B{name}=NN} (C{str}),
+                   optional L{truncate} precision C{B{prec}=ndigits}
+                   and additional B{C{Osgr}} keyword arguments,
+                   ignored if C{B{Osgr} is None}.
 
        @return: An (B{C{Osgr}}) instance or if B{C{Osgr}} is C{None}
                 an L{EasNor2Tuple}C{(easting, northing)}.
@@ -615,9 +610,6 @@ def toOsgr(latlon, lon=None, kTM=False, datum=_WGS84, Osgr=Osgr, name=NN,  # MCC
                          B{C{datum}}, B{C{Osgr}}, B{C{Osgr_kwds}}
                          or conversion to C{Datums.OSGB36} failed.
     '''
-    def _prec_kwds2(prec=MISSING, **kwds):
-        return prec, kwds
-
     if lon is not None:
         try:
             lat, lon = _MODS.dms.parseDMS2(latlon, lon)
@@ -626,8 +618,6 @@ def toOsgr(latlon, lon=None, kTM=False, datum=_WGS84, Osgr=Osgr, name=NN,  # MCC
             raise OSGRError(latlon=latlon, lon=lon, datum=datum, cause=x)
     elif not isinstance(latlon, _LLEB):
         raise _TypeError(latlon=latlon, txt=_not_(_ellipsoidal_))
-    elif not name:  # use latlon.name
-        name = nameof(latlon)
 
     NG = _NG
     # convert latlon to OSGB36 first
@@ -663,22 +653,24 @@ def toOsgr(latlon, lon=None, kTM=False, datum=_WGS84, Osgr=Osgr, name=NN,  # MCC
              d2 / 12 * (_Fsumf_( 5, ta2,  9 * n2) +
              d2 / 30 *  _Fsumf_(61, ta4, 58 * ta2)))).fsum_(m0, NG.nor0)
 
-    p, kwds = _prec_kwds2(**prec_Osgr_kwds)
-    if p is not MISSING:
-        e = truncate(e, p)
-        n = truncate(n, p)
+    t, kwds = _name2__(prec_name_Osgr_kwds, _or_nameof=latlon)
+    if kwds:
+        p, kwds = _xkwds_pop2(kwds, prec=MISSING)
+        if p is not MISSING:
+            e = truncate(e, p)
+            n = truncate(n, p)
 
     if Osgr is None:
         _ = _MODS.osgr.Osgr(e, n)  # validate
-        r =  EasNor2Tuple(e, n)
+        r =  EasNor2Tuple(e, n, name=t)
     else:
-        r = Osgr(e, n, **kwds)  # datum=NG.datum
+        r =  Osgr(e, n, name=t, **kwds)  # datum=NG.datum
         if lon is None and isinstance(latlon, _LLEB):
             if kTM:
                 r._latlonTM = latlon  # XXX weakref(latlon)?
             else:
                 r._latlon = latlon  # XXX weakref(latlon)?
-    return _xnamed(r, name or nameof(latlon))
+    return r
 
 
 if __name__ == '__main__':

pygeodesy/points.py

@@ -38,11 +38,11 @@ from pygeodesy.errors import CrossError, crosserrors, _IndexError, \
                             _xattr, _xkwds, _xkwds_item2, _xkwds_pop2
 from pygeodesy.fmath import favg, fdot, hypot,  Fsum, fsum
 # from pygeodesy.fsums import Fsum, fsum  # from .fmath
-from pygeodesy.formy import _bearingTo2, equirectangular_,  _spherical_datum
+from pygeodesy.formy import _bearingTo2, equirectangular4,  _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.25'
 
 _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
 
 
@@ -1473,8 +1473,8 @@ def nearestOn5(point, points, closed=False, wrap=False, adjust=True,
        @kwarg closed: Optionally, close the path or polygon (C{bool}).
        @kwarg wrap: If C{True}, wrap or I{normalize} and unroll the
                     B{C{points}} (C{bool}).
-       @kwarg adjust: See function L{pygeodesy.equirectangular_} (C{bool}).
-       @kwarg limit: See function L{pygeodesy.equirectangular_} (C{degrees}),
+       @kwarg adjust: See function L{pygeodesy.equirectangular4} (C{bool}).
+       @kwarg limit: See function L{pygeodesy.equirectangular4} (C{degrees}),
                      default C{9 degrees} is about C{1,000 Kmeter} (for mean
                      spherical earth radius L{R_KM}).
        @kwarg LatLon_and_kwds: Optional, C{B{LatLon}=None} class to use for
@@ -1490,24 +1490,24 @@ def nearestOn5(point, points, closed=False, wrap=False, adjust=True,
                 compass C{degrees}, like function L{pygeodesy.compassAngle}.
 
        @raise LimitError: Lat- and/or longitudinal delta exceeds the B{C{limit}},
-                          see function L{pygeodesy.equirectangular_}.
+                          see function L{pygeodesy.equirectangular4}.
 
        @raise PointsError: Insufficient number of B{C{points}}
 
        @raise TypeError: Some B{C{points}} are not C{LatLon}.
 
-       @note: Distances are I{approximated} by function L{pygeodesy.equirectangular_}.
+       @note: Distances are I{approximated} by function L{pygeodesy.equirectangular4}.
               For more accuracy use one of the C{LatLon.nearestOn6} methods.
 
        @see: Function L{pygeodesy.degrees2m}.
     '''
     def _d2yx4(p2, p1, u, alw):
         # w = wrap if (i < (n - 1) or not closed) else False
-        # equirectangular_ returns a Distance4Tuple(distance
+        # equirectangular4 returns a Distance4Tuple(distance
         # in degrees squared, delta lat, delta lon, p2.lon
         # unroll/wrap'd); the previous p2.lon unroll/wrap'd
         # is also applied to the next edge's p1.lon
-        return equirectangular_(p1.lat, p1.lon + u,
+        return equirectangular4(p1.lat, p1.lon + u,
                                 p2.lat, p2.lon, **alw)
 
     def _h(p):  # get height or default 0
@@ -1604,7 +1604,7 @@ def perimeterOf(points, closed=False, adjust=True, radius=R_M, wrap=True):
        @raise ValueError: Invalid B{C{radius}} or C{B{closed}=False} with
                           C{B{points}} a composite.
 
-       @note: This perimeter is based on the L{pygeodesy.equirectangular_}
+       @note: This perimeter is based on the L{pygeodesy.equirectangular4}
               distance approximation and is ill-suited for regions exceeding
               several hundred Km or Miles or with near-polar latitudes.
 
@@ -1618,7 +1618,7 @@ def perimeterOf(points, closed=False, adjust=True, radius=R_M, wrap=True):
             if w and c:
                 w = not Ps.looped
             # apply previous x2's unroll/wrap'd to new x1
-            _, dy, dx, u = equirectangular_(p1.y, p1.x + u,
+            _, dy, dx, u = equirectangular4(p1.y, p1.x + u,
                                             p2.y, p2.x,
                                             adjust=a, limit=None,
                                             wrap=w)  # PYCHOK non-seq

pygeodesy/props.py

@@ -10,9 +10,9 @@ with command line option C{-X dev} or with one of the C{-W}
 choices, see callable L{DeprecationWarnings} below.
 '''
 
-from pygeodesy.basics import isclass as _isclass  # _MODS
+from pygeodesy.basics import isclass as _isclass
 from pygeodesy.errors import _AssertionError, _AttributeError, \
-                             _xkwds, _xkwds_get
+                             _xcallable, _xkwds, _xkwds_get
 from pygeodesy.interns import MISSING, NN, _an_, _COMMASPACE_, \
                              _DEPRECATED_, _DOT_, _EQUALSPACED_, \
                              _immutable_, _invalid_, _module_, _N_A_, \
@@ -25,7 +25,7 @@ from pygeodesy.lazily import _ALL_LAZY, _ALL_MODS as _MODS, \
 from functools import wraps as _wraps
 
 __all__ = _ALL_LAZY.props
-__version__ = '24.05.12'
+__version__ = '24.05.26'
 
 _class_       = 'class'
 _dont_use_    = _DEPRECATED_ + ", don't use."
@@ -157,8 +157,7 @@ class _PropertyBase(property):
     '''
     def __init__(self, method, fget, fset, doc=NN):
 
-        if not callable(method):
-            self.getter(method)  # PYCHOK no cover
+        _xcallable(getter=method, fget=fget)
 
         self.method = method
         self.name   = method.__name__
@@ -288,20 +287,34 @@ class Property(Property_RO):
            @note: Setting a new property value always clears the previously I{cached}
                   or I{memoized} value I{after} invoking the B{C{method}}.
         '''
-        if not callable(method):
-            _PropertyBase.setter(self, method)  # PYCHOK no cover
+        def _fset(inst, val):
+            '''Set and I{cache}, I{memoize} the C{property} value.
+            '''
+            _ = method(inst, val)
+            self._update(inst)  # un-cache this item
 
-        if _FOR_DOCS:  # XXX force method.__doc__ into epydoc
-            _PropertyBase.__init__(self, self.method, self.method, method)
-        else:
+        return self._setters(method, _fset)
 
-            def _fset(inst, val):
-                '''Set and I{cache}, I{memoize} the C{property} value.
-                '''
-                method(inst, val)
-                self._update(inst)  # un-cache this item
+    def setter_(self, method):
+        '''Make this C{Property} I{mutable}.
 
-            # class Property <https://docs.Python.org/3/howto/descriptor.html>
+           @arg method: The callable being decorated as this C{Property}'s C{setter}
+                        and returning the new property value to be I{cached} or
+                        I{memoized}.
+        '''
+        def _fset(inst, val):
+            '''Set and I{cache}, I{memoize} the C{property} value.
+            '''
+            val = method(inst, val)
+            inst.__dict__[self.name] = val
+
+        return self._setters(method, _fset)
+
+    def _setters(self, method, _fset):
+        _xcallable(setter=method, fset=_fset)
+        if _FOR_DOCS:  # XXX force method.__doc__ into epydoc
+            _PropertyBase.__init__(self, self.method, self.method, method)
+        else:  # class Property <https://docs.Python.org/3/howto/descriptor.html>
             _PropertyBase.__init__(self, self.method, self._fget, _fset)
         return self
 

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