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

pygeodesy/rhumb/aux_.py

@@ -32,22 +32,22 @@ from pygeodesy.auxilats.auxAngle import AuxMu, AuxPhi,  hypot
 from pygeodesy.auxilats.auxDLat import AuxDLat, _DClenshaw
 # from pygeodesy.auxilats.auxDST import AuxDST  # _MODS
 from pygeodesy.auxilats.auxily import _Dlam, _Dp0Dpsi, _Ufloats
-from pygeodesy.basics import copysign0, _reverange,  _xkwds_get
+from pygeodesy.basics import copysign0, _reverange,  _xkwds_get1
 from pygeodesy.constants import EPS_2, MANT_DIG, PI4, isinf, \
                                _0_0, _4_0, _720_0, _log2, _over
-from pygeodesy.datums import _WGS84,  NN
-# from pygeodesy.errors import _xkwds_get  # from .basics
+# from pygeodesy.datums import _WGS84  # from .rhumb.bases
+# from pygeodesy.errors import _xkwds_get1  # from .basics
 from pygeodesy.karney import Caps, _polynomial
 # from pygeodesy.fmath import hypot  # from .auxilats.auxAngle
-# from pygeodesy.interns import NN  # from .datums
 from pygeodesy.lazily import _ALL_DOCS, _ALL_LAZY, _ALL_MODS as _MODS
-# from pygeodesy.props import Property_RO  # from .rhumbBase
-from pygeodesy.rhumb.bases import RhumbBase, RhumbLineBase,  Property_RO
+# from pygeodesy.props import Property_RO  # from .rhumb.bases
+from pygeodesy.rhumb.bases import RhumbBase, RhumbLineBase, \
+                                  Property_RO, _WGS84
 
 from math import ceil as _ceil, fabs, radians
 
 __all__ = _ALL_LAZY.rhumb_aux_
-__version__ = '23.12.09'
+__version__ = '24.05.29'
 
 # DIGITS = (sizeof(real) * 8) bits
 #        = (ctypes.sizeof(ctypes.c_double(1.0)) * 8) bits
@@ -68,7 +68,7 @@ class RhumbAux(RhumbBase):
               installed, version 1.16 or later.
     '''
 
-    def __init__(self, a_earth=_WGS84, f=None, exact=True, name=NN, **TMorder):  # PYCHOK signature
+    def __init__(self, a_earth=_WGS84, f=None, exact=True, **TMorder_name):  # PYCHOK signature
         '''New C{RhumbAux}.
 
            @kwarg a_earth: This rhumb's earth model (L{Datum}, L{Ellipsoid},
@@ -79,18 +79,16 @@ class RhumbAux(RhumbBase):
            @kwarg exact: If C{True}, use the exact expressions for the I{Auxiliary
                          Latitudes}, otherwise use the I{Fourier} series expansion
                          (C{bool}), see also property C{exact}.
-           @kwarg name: Optional name (C{str}).
-           @kwarg TMorder: Optional keyword argument B{C{TMorder}}, see property
-                           C{TMorder}.
+           @kwarg TMorder_name: Optional C{B{name}=NN} (C{str}) and optional
+                          keyword argument C{B{TMorder}=6} for the order of
+                          the L{KTransverseMercator}, see property C{TMorder}.
 
            @raise ImportError: Package C{numpy} not found or not installed, only
                                required for area C{S12} when C{B{exact} is True}.
 
            @raise RhumbError: Invalid B{C{a_earth}}, B{C{f}} or B{C{TMorder}}.
         '''
-        RhumbBase.__init__(self, a_earth, f, exact, name)
-        if TMorder:
-            self.Tmorder = _xkwds_get(TMorder, TMorder=RhumbBase._mTM)
+        RhumbBase.__init__(self, a_earth, f, exact, TMorder_name)
 
     def areaux(self, **exact):
         '''Get this ellipsoid's B{C{exact}} surface area (C{meter} I{squared}).
@@ -110,7 +108,7 @@ class RhumbAux(RhumbBase):
            @see: U{The area of rhumb polygons<https://ArXiv.org/pdf/2303.03219.pdf>}
                  and method L{auxilats.AuxLat.AuthalicRadius2}.
         '''
-        x = _xkwds_get(exact, exact=self.exact)
+        x = _xkwds_get1(exact, exact=self.exact)
         a = (self._c2 * _720_0) if bool(x) is self.exact else (
              self._auxD.AuthalicRadius2(exact=x, f_max=self.f_max) * PI4)
         return a

pygeodesy/rhumb/bases.py

@@ -52,7 +52,7 @@ from pygeodesy.vector3d import _intersect3d3, Vector3d  # in .Intersection below
 from math import cos, fabs
 
 __all__ = ()
-__version__ = '24.05.13'
+__version__ = '24.05.29'
 
 _anti_ = _Dash('anti')
 _rls   = []  # instances of C{RbumbLine...} to be updated
@@ -95,10 +95,17 @@ class RhumbBase(_CapsBase):
     _f_max = _0_01
     _mTM   =  6  # see .TMorder
 
-    def __init__(self, a_earth, f, exact, name):
+    def __init__(self, a_earth, f, exact, TMorder_name):
         '''New C{RhumbAux} or C{Rhumb}.
         '''
-        _earth_datum(self, a_earth, f=f, name=name)
+        if TMorder_name:
+            M = self._mTM
+            m, name = _xkwds_pop2(TMorder_name, TMorder=M)
+            if m != M:
+                self.TMorder = m
+        else:
+            name = {}
+        _earth_datum(self, a_earth, f=f, **name)
         if not exact:
             self.exact = False
         if name:
@@ -425,13 +432,13 @@ class RhumbBase(_CapsBase):
 
     @Property
     def TMorder(self):
-        '''Get the I{Transverse Mercator} order (C{int}, 4, 5, 6, 7 or 8).
+        '''Get the L{KTransverseMercator} order (C{int}, 4, 5, 6, 7 or 8).
         '''
         return self._mTM
 
     @TMorder.setter  # PYCHOK setter!
     def TMorder(self, order):
-        '''Set the I{Transverse Mercator} order (C{int}, 4, 5, 6, 7 or 8).
+        '''Set the L{KTransverseMercator} order (C{int}, 4, 5, 6, 7 or 8).
 
            @note: Setting C{TMorder} turns property C{exact} off, but only
                   for L{Rhumb} instances.

pygeodesy/rhumb/ekx.py

@@ -25,24 +25,25 @@ from __future__ import division as _; del _  # PYCHOK semicolon
 from pygeodesy.basics import copysign0, neg
 from pygeodesy.constants import PI_2, _0_0s, _0_0, _0_5, _1_0, \
                                _2_0, _4_0, _720_0, _over, _1_over
-from pygeodesy.datums import _WGS84
+# from pygeodesy.datums import _WGS84  # from .rhumb.bases
 # from pygeodesy.deprecated import RhumbOrder2Tuple  # _MODS
-from pygeodesy.errors import RhumbError, _Xorder
+from pygeodesy.errors import RhumbError, _xkwds_pop2, _Xorder
 from pygeodesy.fmath import hypot, hypot1
 # from pygeodesy.fsums import fsum1f_  # _MODS
-# from pygeodesy.interns import NN  # from .farney
-from pygeodesy.karney import Caps,  NN
+# from pygeodesy.karney import Caps  # from .rhumb.bases
 from pygeodesy.ktm import KTransverseMercator, _Xs, \
                          _AlpCoeffs, _BetCoeffs  # PYCHOK used!
 from pygeodesy.lazily import _ALL_DOCS, _ALL_LAZY, _ALL_MODS as _MODS
-from pygeodesy.props import deprecated_method, Property, Property_RO, property_RO
-from pygeodesy.rhumb.bases import RhumbBase, RhumbLineBase,  _update_all_rls
+from pygeodesy.props import deprecated_method, Property, Property_RO, \
+                            property_RO
+from pygeodesy.rhumb.bases import RhumbBase, RhumbLineBase, \
+                                  Caps, _update_all_rls, _WGS84
 from pygeodesy.utily import atan1, sincos2_
 
 from math import asinh, atan, cos, cosh, radians, sin, sinh, sqrt, tan
 
 __all__ = _ALL_LAZY.rhumb_ekx
-__version__ = '23.12.03'
+__version__ = '24.05.30'
 
 
 class Rhumb(RhumbBase):
@@ -54,7 +55,7 @@ class Rhumb(RhumbBase):
     '''
     _mRA = 6  # see .RAorder
 
-    def __init__(self, a_earth=_WGS84, f=None, exact=True, name=NN, **RA_TMorder):
+    def __init__(self, a_earth=_WGS84, f=None, exact=True, **RA_TMorder_name):
         '''New C{Rhumb}.
 
            @kwarg a_earth: This rhumb's earth model (L{Datum}, L{Ellipsoid},
@@ -67,15 +68,20 @@ class Rhumb(RhumbBase):
                          series expansion (C{bool} or C{None}), see also properties
                          C{exact} and C{TMorder}.
            @kwarg name: Optional name (C{str}).
-           @kwarg RA_TMorder: Optional keyword arguments B{C{RAorder}} and B{C{TMorder}}
-                              to set the respective C{order}, see properties C{RAorder}
-                              and C{TMorder} and method C{orders}.
+           @kwarg RA_TMorder_name: Optional C{B{name}=NN} (C{str}) and optional keyword
+                     arguments B{C{RAorder}=6} and B{C{TMorder}=6} to set the respective
+                     C{order}, see properties C{RAorder} and C{TMorder}.
 
-           @raise RhumbError: Invalid B{C{a_earth}}, B{C{f}} or B{C{RA_TMorder}}.
+           @raise RhumbError: Invalid B{C{a_earth}}, B{C{f}}, B{C{RAorder}} or B{C{TMorder}}.
         '''
-        RhumbBase.__init__(self, a_earth, f, exact, name)
-        if RA_TMorder:
-            self.orders(**RA_TMorder)
+        if RA_TMorder_name:
+            M = self._mRA
+            m, kwds = _xkwds_pop2(RA_TMorder_name, RAorder=M)
+            if m != M:
+                self.RAorder = m
+        else:
+            kwds = {}
+        RhumbBase.__init__(self, a_earth, f, exact, kwds)
 
     @Property_RO
     def _A2(self):  # Conformal2RectifyingCoeffs
@@ -184,7 +190,7 @@ class Rhumb(RhumbBase):
         return self.ellipsoid._Lpr  # degrees(._Lpd)
 
     @deprecated_method
-    def orders(self, RAorder=None, TMorder=None):  # PYCHOK no cover
+    def orders(self, RAorder=6, TMorder=6):  # PYCHOK no cover
         '''DEPRECATED, use properties C{RAorder} and/or C{TMorder}.
 
            Get and set the I{RAorder} and/or I{TMorder}.
@@ -198,9 +204,9 @@ class Rhumb(RhumbBase):
                     with the previous C{RAorder} and C{TMorder} setting.
         '''
         t = _MODS.deprecated.classes.RhumbOrder2Tuple(self.RAorder, self.TMorder)
-        if RAorder not in (None, t.RAorder):  # PYCHOK attr
+        if RAorder != t.RAorder:  # PYCHOK attr
             self.RAorder = RAorder
-        if TMorder not in (None, t.TMorder):  # PYCHOK attr
+        if TMorder != t.TMorder:  # PYCHOK attr
             self.TMorder = TMorder
         return t
 

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.04.13'
+__version__ = '24.05.31'
 
 
 class _RhumbSolveBase(_SolveBase):
@@ -90,13 +90,13 @@ class RhumbSolve(_RhumbSolveBase):
        @note: This C{rhumb} is intended I{for testing purposes only}, it invokes the C{RhumbSolve}
               executable for I{every} method call.
     '''
-#   def Area(self, polyline=False, name=NN):
+#   def Area(self, polyline=False, **name):
 #       '''Set up a L{RhumbArea} to compute area and
 #          perimeter of a polygon.
 #
 #          @kwarg polyline: If C{True} perimeter only, otherwise
 #                           area and perimeter (C{bool}).
-#          @kwarg name: Optional name (C{str}).
+#          @kwarg name: Optional C{B{name}=NN} (C{str}).
 #
 #          @return: A L{RhumbArea} instance.
 #
@@ -104,7 +104,7 @@ class RhumbSolve(_RhumbSolveBase):
 #                 to the returned L{RhumbAreaExact} instance.
 #       '''
 #       rA = _MODS.rhumbs.rhumb*.RhumbArea(self, polyline=polyline,
-#                                                name=name or self.name)
+#                                          name=self._name__(name))
 #       if self.verbose or self.debug:  # PYCHOK no cover
 #           rA.verbose = True
 #       return rA
@@ -140,7 +140,7 @@ class RhumbSolve(_RhumbSolveBase):
         '''
         return self.DirectLine(ll1.lat, ll1.lon, azi12, **name_caps)
 
-    def DirectLine(self, lat1, lon1, azi1, caps=Caps.STANDARD, name=NN):
+    def DirectLine(self, lat1, lon1, azi1, caps=Caps.STANDARD, **name):
         '''Set up a L{RhumbLineSolve} in terms of the I{direct} rhumb
            problem to compute several points on a single rhumb line.
 
@@ -150,6 +150,7 @@ class RhumbSolve(_RhumbSolveBase):
            @kwarg caps: Bit-or'ed combination of L{Caps} values specifying
                         the capabilities the L{RhumbLineSolve} instance
                         should possess, always C{Caps.ALL}.
+           @kwarg name: Optional C{B{name}=NN} (C{str}).
 
            @return: A L{RhumbLineSolve} instance.
 
@@ -161,7 +162,7 @@ class RhumbSolve(_RhumbSolveBase):
                  <https://GeographicLib.SourceForge.io/C++/doc/classGeographicLib_1_1RhumbExact.html>}
                  and Python U{Rhumb.Line<https://GeographicLib.SourceForge.io/Python/doc/code.html>}.
         '''
-        return RhumbLineSolve(self, lat1, lon1, azi1, caps=caps, name=name or self.name)
+        return RhumbLineSolve(self, lat1, lon1, azi1, caps=caps, name=self._name__(name))
 
     def _GDictDirect(self, lat, lon, azi1, arcmode, s12_a12, *unused, **floats):  # PYCHOK signature
         '''(INTERNAL) Get C{_GenDirect}-like result as an 8-item C{GDict}.
@@ -206,7 +207,7 @@ class RhumbSolve(_RhumbSolveBase):
             ll2 = _unrollon(ll1, _Wrap.point(ll2))
         return self.InverseLine(ll1.lat, ll1.lon, ll2.lat, ll2.lon, **name_caps)
 
-    def InverseLine(self, lat1, lon1, lat2, lon2, caps=Caps.STANDARD, name=NN):
+    def InverseLine(self, lat1, lon1, lat2, lon2, caps=Caps.STANDARD, **name):
         '''Define a L{RhumbLineSolve} in terms of the I{inverse}
            rhumb problem.
 
@@ -215,6 +216,7 @@ class RhumbSolve(_RhumbSolveBase):
            @arg lat2: Latitude of the second point (C{degrees90}).
            @arg lon2: Longitude of the second point (C{degrees180}).
            @kwarg caps: Optional C{caps}, see L{RhumbLine} C{B{caps}}.
+           @kwarg name: Optional C{B{name}=NN} (C{str}).
 
            @return: A L{RhumbLineSolve} instance and invoke its method
                     L{RhumbLine.Position} to compute each point.
@@ -224,7 +226,7 @@ class RhumbSolve(_RhumbSolveBase):
         '''
         r = self.Inverse(lat1, lon1, lat2, lon2)  # outmask=Caps.AZIMUTH
         return RhumbLineSolve(self, lat1, lon1, r.azi12, caps=caps,
-                                    name=name or self.name)
+                                                name=self._name__(name))
 
     Line = DirectLine
 
@@ -239,7 +241,7 @@ class RhumbLineSolve(_RhumbSolveBase, _SolveLineBase):
        @note: This C{rhumb line} is intended I{for testing purposes only}, it invokes the C{RhumbSolve}
               executable for I{every} method call.
     '''
-    def __init__(self, rhumb, lat1, lon1, azi12, caps=Caps.STANDARD, name=NN):
+    def __init__(self, rhumb, lat1, lon1, azi12, caps=Caps.STANDARD, **name):
         '''New L{RhumbLineSolve} instance, allowing points to be found along
            a rhumb starting at C{(B{lat1}, B{lon1})} with azimuth B{C{azi12}}.
 
@@ -252,6 +254,7 @@ class RhumbLineSolve(_RhumbSolveBase, _SolveLineBase):
                         possess, always C{Caps.ALL}.  Use C{Caps.LINE_OFF}
                         if updates to the B{C{rhumb}} should I{not} be
                         reflected in this L{RhumbLineSolve} instance.
+           @kwarg name: Optional C{B{name}=NN} (C{str}).
 
            @kwarg name: Optional name (C{str}).
 
@@ -264,7 +267,7 @@ class RhumbLineSolve(_RhumbSolveBase, _SolveLineBase):
         _xinstanceof(RhumbSolve, rhumb=rhumb)
         if (caps & Caps.LINE_OFF):  # copy to avoid updates
             rhumb = rhumb.copy(deep=False, name=NN(_UNDER_, rhumb.name))
-        _SolveLineBase.__init__(self, rhumb, lat1, lon1, caps, name, azi12=azi12)
+        _SolveLineBase.__init__(self, rhumb, lat1, lon1, caps, azi12=azi12, **name)
         try:
             self.RhumbSolve = rhumb.RhumbSolve  # rhumb or copy of rhumb
         except RhumbError:

pygeodesy/simplify.py

@@ -43,7 +43,7 @@ list of simplified point I{indices} instead of the simplified points.
 The first and last index are always the first and last original index.
 
 Finally, any additional keyword arguments B{C{options}} to all functions
-are passed thru to function L{pygeodesy.equirectangular_} to specify the
+are passed thru to function L{pygeodesy.equirectangular4} to specify the
 distance approximation.
 
 To process C{NumPy} arrays containing rows of lat-, longitude and
@@ -77,7 +77,7 @@ from __future__ import division as _; del _  # PYCHOK semicolon
 from pygeodesy.constants import EPS, R_M, _1_0
 from pygeodesy.errors import _AttributeError, _ValueError
 from pygeodesy.fmath import len2, sqrt0
-from pygeodesy.formy import equirectangular_
+from pygeodesy.formy import equirectangular4
 from pygeodesy.interns import _small_, _too_
 from pygeodesy.iters import isNumpy2, isTuple2
 # from pygeodesy.lazily import _ALL_LAZY  # from .units
@@ -86,7 +86,7 @@ from pygeodesy.units import _ALL_LAZY, _1mm, Radius_
 from math import degrees, fabs, radians
 
 __all__ = _ALL_LAZY.simplify
-__version__ = '23.03.22'
+__version__ = '24.05.25'
 
 
 # try:
@@ -240,7 +240,7 @@ class _Sy(object):
            and the (longitudinal) unrollment.
         '''
         p1, p2= self.pts[i], self.pts[j]
-        return equirectangular_(p1.lat, p1.lon,
+        return equirectangular4(p1.lat, p1.lon,
                                 p2.lat, p2.lon, **self.options)
 
     def h2t(self, i1, i0, i2):
@@ -386,12 +386,12 @@ def simplify1(points, distance=_1mm, radius=R_M, indices=False, **options):
        @kwarg indices: If C{True} return the simplified point indices
                        instead of the simplified points (C{bool}).
        @kwarg options: Optional keyword arguments passed thru to
-                       function L{pygeodesy.equirectangular_}.
+                       function L{pygeodesy.equirectangular4}.
 
        @return: Simplified points (C{LatLon}[]).
 
        @raise LimitError: Lat- and/or longitudinal delta exceeds the B{C{limit}},
-                          see function L{pygeodesy.equirectangular_}.
+                          see function L{pygeodesy.equirectangular4}.
 
        @raise ValueError: Tolerance B{C{distance}} or B{C{radius}} too small.
     '''
@@ -431,12 +431,12 @@ def simplifyRDP(points, distance=_1mm, radius=R_M, shortest=False,
        @kwarg indices: If C{True} return the simplified point indices
                        instead of the simplified points (C{bool}).
        @kwarg options: Optional keyword arguments passed thru to
-                       function L{pygeodesy.equirectangular_}.
+                       function L{pygeodesy.equirectangular4}.
 
        @return: Simplified points (C{LatLon}[]).
 
        @raise LimitError: Lat- and/or longitudinal delta exceeds the B{C{limit}},
-                          see function L{pygeodesy.equirectangular_}.
+                          see function L{pygeodesy.equirectangular4}.
 
        @raise ValueError: Tolerance B{C{distance}} or B{C{radius}} too small.
     '''
@@ -465,12 +465,12 @@ def simplifyRDPm(points, distance=_1mm, radius=R_M, shortest=False,
        @kwarg indices: If C{True} return the simplified point indices
                        instead of the simplified points (C{bool}).
        @kwarg options: Optional keyword arguments passed thru to
-                       function L{pygeodesy.equirectangular_}.
+                       function L{pygeodesy.equirectangular4}.
 
        @return: Simplified points (C{LatLon}[]).
 
        @raise LimitError: Lat- and/or longitudinal delta exceeds the B{C{limit}},
-                          see function L{pygeodesy.equirectangular_}.
+                          see function L{pygeodesy.equirectangular4}.
 
        @raise ValueError: Tolerance B{C{distance}} or B{C{radius}} too small.
     '''
@@ -496,12 +496,12 @@ def simplifyRW(points, pipe=_1mm, radius=R_M, shortest=False,
        @kwarg indices: If C{True} return the simplified point indices
                        instead of the simplified points (C{bool}).
        @kwarg options: Optional keyword arguments passed thru to
-                       function L{pygeodesy.equirectangular_}.
+                       function L{pygeodesy.equirectangular4}.
 
        @return: Simplified points (C{LatLon}[]).
 
        @raise LimitError: Lat- and/or longitudinal delta exceeds the B{C{limit}},
-                          see function L{pygeodesy.equirectangular_}.
+                          see function L{pygeodesy.equirectangular4}.
 
        @raise ValueError: Tolerance B{C{pipe}} or B{C{radius}} too small.
     '''
@@ -547,7 +547,7 @@ def simplifyVW(points, area=_1mm, radius=R_M, attr=None,
        @kwarg indices: If C{True} return the simplified point indices
                        instead of the simplified points (C{bool}).
        @kwarg options: Optional keyword arguments passed thru to
-                       function L{pygeodesy.equirectangular_}.
+                       function L{pygeodesy.equirectangular4}.
 
        @return: Simplified points (C{LatLon}[]).
 
@@ -555,7 +555,7 @@ def simplifyVW(points, area=_1mm, radius=R_M, attr=None,
                               B{C{points}}.
 
        @raise LimitError: Lat- and/or longitudinal delta exceeds the B{C{limit}},
-                          see function L{pygeodesy.equirectangular_}.
+                          see function L{pygeodesy.equirectangular4}.
 
        @raise ValueError: Tolerance B{C{area}} or B{C{radius}} too small.
     '''
@@ -603,7 +603,7 @@ def simplifyVWm(points, area=_1mm, radius=R_M, attr=None,
        @kwarg indices: If C{True} return the simplified point indices
                        instead of the simplified points (C{bool}).
        @kwarg options: Optional keyword arguments passed thru to
-                       function L{pygeodesy.equirectangular_}.
+                       function L{pygeodesy.equirectangular4}.
 
        @return: Simplified points (C{LatLon}[]).
 
@@ -611,7 +611,7 @@ def simplifyVWm(points, area=_1mm, radius=R_M, attr=None,
                               B{C{points}}.
 
        @raise LimitError: Lat- and/or longitudinal delta exceeds the B{C{limit}},
-                          see function L{pygeodesy.equirectangular_}.
+                          see function L{pygeodesy.equirectangular4}.
 
        @raise ValueError: Tolerance B{C{area}} or B{C{radius}} too small.
     '''

pygeodesy/solveBase.py

@@ -8,13 +8,13 @@ from pygeodesy.basics import map2, ub2str, _zip
 from pygeodesy.constants import DIG
 from pygeodesy.datums import _earth_datum, _WGS84,  _EWGS84
 # from pygeodesy.ellipsoids import _EWGS84  # from .datums
-from pygeodesy.errors import _AssertionError, _xkwds_get, _xkwds_item2
+from pygeodesy.errors import _AssertionError, _xkwds_get1, _xkwds_item2
 from pygeodesy.internals import _enquote, printf
 from pygeodesy.interns import NN, _0_, _BACKSLASH_, _COMMASPACE_, \
-                             _EQUAL_, _Error_, _not_, _SPACE_, _UNUSED_
+                             _EQUAL_, _Error_, _SPACE_, _UNUSED_
 from pygeodesy.karney import Caps, _CapsBase, GDict
 from pygeodesy.lazily import _ALL_DOCS, _ALL_LAZY, _unlazy
-from pygeodesy.named import callername, notOverloaded
+from pygeodesy.named import callername, _name2__, notOverloaded
 from pygeodesy.props import Property, Property_RO, property_RO, _update_all
 from pygeodesy.streprs import Fmt, fstr, fstrzs, pairs, strs
 from pygeodesy.units import Precision_
@@ -23,7 +23,7 @@ from pygeodesy.utily import unroll180,  wrap360  # PYCHOK shared
 from subprocess import PIPE as _PIPE, Popen as _Popen, STDOUT as _STDOUT
 
 __all__ = _ALL_LAZY.solveBase
-__version__ = '24.03.15'
+__version__ = '24.05.31'
 
 _ERROR_    = 'ERROR'
 _text_True =  dict() if _unlazy else dict(text=True)
@@ -106,7 +106,7 @@ class _SolveLineSolveBase(_CapsBase):
         if floats:
             v = map(float, v)
         r = GDict(_zip(n, v))  # strict=True
-        return self._iter2tion(r, r)
+        return self._iter2tion(r, **r)
 
     @property_RO
     def invokation(self):
@@ -132,12 +132,12 @@ class _SolveLineSolveBase(_CapsBase):
            @note: The C{Solve} return code is in property L{status}.
         '''
         c = (self._Solve_path,) + map2(str, options)
-        i = _xkwds_get(stdin, stdin=None)
+        i = _xkwds_get1(stdin, stdin=None)
         r =  self._invoke(c, stdin=i)
         s =  self.status
         if s:
             raise self._Error(cmd=_cmd_stdin_(c, i), status=s,
-                              txt=_not_(_0_))
+                              txt_not_=_0_)
         if self.verbose:  # PYCHOK no cover
             self._print(r)
         return r
@@ -221,7 +221,7 @@ class _SolveLineSolveBase(_CapsBase):
             _ = self.version  # test path and ...
             if self.status:  # ... return code
                 S_p = Solve_path or {self._Solve_name: _enquote(path)}
-                raise self._Error(status=self.status, txt=_not_(_0_), **S_p)
+                raise self._Error(status=self.status, txt_not_=_0_, **S_p)
             hold = path
         finally:  # restore in case of error
             if self._Solve_path != hold:
@@ -275,7 +275,7 @@ class _SolveBase(_SolveLineSolveBase):
     '''
     _datum = _WGS84
 
-    def __init__(self, a_ellipsoid=_EWGS84, f=None, path=NN, name=NN):
+    def __init__(self, a_ellipsoid=_EWGS84, f=None, path=NN, **name):
         '''New C{Solve} instance.
 
            @arg a_ellipsoid: An ellipsoid (L{Ellipsoid}) or datum (L{Datum}) or
@@ -285,11 +285,11 @@ class _SolveBase(_SolveLineSolveBase):
                    is specified as C{scalar}.
            @kwarg path: Optionally, the (fully qualified) path to the C{GeodSolve}
                         or C{RhumbSolve} executable (C{filename}).
-           @kwarg name: Optional name (C{str}).
+           @kwarg name: Optional C{B{name}=NN} (C{str}).
 
            @raise TypeError: Invalid B{C{a_ellipsoid}} or B{C{f}}.
         '''
-        _earth_datum(self, a_ellipsoid, f=f, name=name)
+        _earth_datum(self, a_ellipsoid, f=f, **name)
         if name:
             self.name = name
         if path:
@@ -352,7 +352,7 @@ class _SolveBase(_SolveLineSolveBase):
         '''
         if arcmode:
             raise self._Error(arcmode=arcmode, txt=str(NotImplemented))
-        floats = _xkwds_get(floats, floats=True)
+        floats = _xkwds_get1(floats, floats=True)
         return self._GDictInvoke(self._cmdDirect, floats, self._Names_Direct,
                                                   lat, lon, azi, s12_a12)
 
@@ -360,7 +360,7 @@ class _SolveBase(_SolveLineSolveBase):
         '''(INTERNAL) Get C{_GenInverse}-like result as C{GDict}, but
            I{without} C{_SALPs_CALPs_}.
         '''
-        floats = _xkwds_get(floats, floats=True)
+        floats = _xkwds_get1(floats, floats=True)
         return self._GDictInvoke(self._cmdInverse, floats, self._Names_Inverse,
                                                    lat1, lon1, lat2, lon2)
 
@@ -394,16 +394,16 @@ class _SolveLineBase(_SolveLineSolveBase):
 #   _lla1  = {}
     _solve =  None  # L{GeodesicSolve} or L{RhumbSolve} instance
 
-    def __init__(self, solve, lat1, lon1, caps, name, **azi):
+    def __init__(self, solve, lat1, lon1, caps, **azi_name):
+        name, azi = _name2__(azi_name, _or_nameof=solve)
+        if name:
+            self.name = name
+
         self._caps  = caps | Caps._LINE
         self._debug = solve._debug & Caps._DEBUG_ALL
         self._lla1  = GDict(lat1=lat1, lon1=lon1, **azi)
         self._solve = solve
 
-        n = name or solve.name
-        if n:
-            self.name = n
-
     @Property_RO
     def _cmdDistance(self):
         '''(INTERNAL) Get the C{GeodSolve} I{-L} cmd (C{tuple}).

pygeodesy/sphericalBase.py

@@ -21,18 +21,18 @@ from pygeodesy.datums import Datums, _earth_ellipsoid, _spherical_datum
 from pygeodesy.errors import IntersectionError, _ValueError, \
                             _xattr, _xError
 from pygeodesy.fmath import favg, fdot, hypot, sqrt_a
-from pygeodesy.interns import NN, _COMMA_, _concentric_, _datum_, \
-                             _distant_, _exceed_PI_radians_, _name_, \
-                             _near_, _radius_, _too_
+from pygeodesy.interns import _COMMA_, _concentric_, _datum_, _distant_, \
+                              _exceed_PI_radians_, _name_, _near_, \
+                              _radius_, _too_
 from pygeodesy.latlonBase import LatLonBase,  _trilaterate5  # PYCHOK passed
 from pygeodesy.lazily import _ALL_DOCS, _ALL_LAZY, _ALL_MODS as _MODS
 # from pygeodesy.namedTuples import Bearing2Tuple  # from .cartesianBase
 from pygeodesy.nvectorBase import NvectorBase,  Fmt, _xattrs
-from pygeodesy.props import deprecated_method, property_doc_, \
-                            property_RO, _update_all
+from pygeodesy.props import deprecated_method, property_doc_, property_RO, \
+                           _update_all
 # from pygeodesy.streprs import Fmt, _xattrs  # from .nvectorBase
-from pygeodesy.units import _isRadius, Bearing, Bearing_, Radians_, \
-                             Radius, Radius_, Scalar_, _100km
+from pygeodesy.units import Bearing, Bearing_, _isRadius, Radians_, Radius, \
+                            Radius_, Scalar_, _100km
 from pygeodesy.utily import acos1, asin1, atan2b, atan2d, degrees90, \
                             degrees180, sincos2, sincos2d, _unrollon, \
                             tanPI_2_2, wrapPI
@@ -40,7 +40,7 @@ from pygeodesy.utily import acos1, asin1, atan2b, atan2d, degrees90, \
 from math import cos, fabs, log, sin, sqrt
 
 __all__ = _ALL_LAZY.sphericalBase
-__version__ = '23.12.18'
+__version__ = '24.05.31'
 
 
 class CartesianSphericalBase(CartesianBase):
@@ -117,7 +117,7 @@ class LatLonSphericalBase(LatLonBase):
     _datum       =  Datums.Sphere  # spherical L{Datum}
     _napieradius = _100km
 
-    def __init__(self, latlonh, lon=None, height=0, datum=None, wrap=False, name=NN):
+    def __init__(self, latlonh, lon=None, height=0, datum=None, wrap=False, **name):
         '''Create a spherical C{LatLon} point frome the given lat-, longitude and
            height on the given datum.
 
@@ -132,12 +132,12 @@ class LatLonSphericalBase(LatLonBase):
                          conventionally).
            @kwarg wrap: If C{True}, wrap or I{normalize} B{C{lat}} and B{C{lon}}
                         (C{bool}).
-           @kwarg name: Optional name (C{str}).
+           @kwarg name: Optional C{B{name}=NN} (C{str}).
 
            @raise TypeError: If B{C{latlonh}} is not a C{LatLon} or B{C{datum}} not
                              spherical.
         '''
-        LatLonBase.__init__(self, latlonh, lon=lon, height=height, wrap=wrap, name=name)
+        LatLonBase.__init__(self, latlonh, lon=lon, height=height, wrap=wrap, **name)
         if datum not in (None, self.datum):
             self.datum = datum
 
@@ -302,26 +302,22 @@ class LatLonSphericalBase(LatLonBase):
 #           raise _xError(x, this=self, point=point, other=other, **radius_exact_height_wrap)
 #       return p.midpointTo(q)
 
-    def parse(self, strllh, height=0, sep=_COMMA_, name=NN):
+    def parse(self, strllh, height=0, sep=_COMMA_, **name):
         '''Parse a string representing a similar, spherical C{LatLon}
            point, consisting of C{"lat, lon[, height]"}.
 
-           @arg strllh: Lat, lon and optional height (C{str}),
-                        see function L{pygeodesy.parse3llh}.
+           @arg strllh: Lat, lon and optional height (C{str}), see function
+                        L{pygeodesy.parse3llh}.
            @kwarg height: Optional, default height (C{meter}).
            @kwarg sep: Optional separator (C{str}).
-           @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 point (spherical C{LatLon}).
 
            @raise ParseError: Invalid B{C{strllh}}.
         '''
-        t = _MODS.dms.parse3llh(strllh, height=height, sep=sep)
-        r =  self.classof(*t)
-        if name:
-            r.rename(name)
-        return r
+        llh = _MODS.dms.parse3llh(strllh, height=height, sep=sep)
+        return self.classof(*llh, **name)
 
     @property_RO
     def _radius(self):