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

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

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_, _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.lazily import _ALL_DOCS, _ALL_LAZY, _sys_version_info2
+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,34 +23,37 @@ 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.05.20'
+__version__ = '24.06.05'
 
-_ERROR_    = 'ERROR'
-_text_True =  dict() if _unlazy else dict(text=True)
+_ERROR_     = 'ERROR'
+_Popen_kwds =  dict(creationflags=0,
+                  # executable=sys.executable, shell=True,
+                    stdin=_PIPE, stdout=_PIPE, stderr=_STDOUT)
+if _sys_version_info2 > (3, 6):
+    _Popen_kwds.update(text=True)
+del _PIPE, _STDOUT, _sys_version_info2  # _ALL_LAZY
 
 
 def _cmd_stdin_(cmd, stdin):  # PYCHOK no cover
     '''(INTERNAL) Cmd line, stdin and caller as sC{str}.
     '''
-    c = Fmt.PAREN(callername(up=3))
-    t = (c,) if stdin is None else (_BACKSLASH_, str(stdin), c)
-    return _SPACE_.join(cmd + t)
+    if stdin is not None:
+        cmd += _BACKSLASH_, str(stdin)
+    cmd += Fmt.PAREN(callername(up=3)),
+    return _SPACE_.join(cmd)
 
 
-def _popen2(cmd, stdin=None):  # in .mgrs, .test.base, .test.testMgrs
+def _popen2(cmd, stdin=None):  # in .mgrs, test.bases, .testMgrs
     '''(INTERNAL) Invoke C{B{cmd} tuple} and return C{exitcode}
        and all output to C{stdout/-err}.
     '''
-    p = _Popen(cmd, creationflags=0,
-                  # executable=sys.executable, shell=True,
-                    stdin=_PIPE, stdout=_PIPE, stderr=_STDOUT,
-                 **_text_True)  # PYCHOK kwArgs
-    r = p.communicate(stdin)[0]
+    p = _Popen(cmd, **_Popen_kwds)  # PYCHOK kwArgs
+    r =  p.communicate(stdin)[0]
     return p.returncode, ub2str(r).strip()
 
 
-class _SolveLineSolveBase(_CapsBase):
-    '''(NTERNAL) Base class for C{_Solve} and C{_LineSolve}.
+class _SolveCapsBase(_CapsBase):
+    '''(NTERNAL) Base class for C{_SolveBase} and C{_LineSolveBase}.
     '''
     _Error         =  None
     _Exact         =  True
@@ -131,8 +134,8 @@ 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)
+        c = (self._Solve_path,) + map2(str, options)  # map2(_enquote, options)
+        i = _xkwds_get1(stdin, stdin=None)
         r =  self._invoke(c, stdin=i)
         s =  self.status
         if s:
@@ -270,12 +273,12 @@ class _SolveLineSolveBase(_CapsBase):
         return self.invoke('--version')
 
 
-class _SolveBase(_SolveLineSolveBase):
+class _SolveBase(_SolveCapsBase):
     '''(NTERNAL) Base class for C{_GeodesicSolveBase} and C{_RhumbSolveBase}.
     '''
     _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 +288,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 +355,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 +363,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)
 
@@ -387,23 +390,23 @@ class _SolveBase(_SolveLineSolveBase):
         return sep.join(pairs(d, prec=prec))
 
 
-class _SolveLineBase(_SolveLineSolveBase):
+class _SolveLineBase(_SolveCapsBase):
     '''(NTERNAL) Base class for C{GeodesicLineSolve} and C{RhumbLineSolve}.
     '''
 #   _caps  =  0
 #   _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}).
@@ -448,7 +451,7 @@ class _SolveLineBase(_SolveLineSolveBase):
         return sep.join(pairs(d, prec=prec))
 
 
-__all__ += _ALL_DOCS(_SolveBase, _SolveLineBase, _SolveLineSolveBase)
+__all__ += _ALL_DOCS(_SolveBase, _SolveLineBase, _SolveCapsBase)
 
 # **) MIT License
 #