pygeodesy 24.6.24__py2.py3-none-any.whl → 24.7.24__py2.py3-none-any.whl

pygeodesy/solveBase.py

@@ -4,14 +4,16 @@
 u'''(INTERNAL) Private base classes for L{pygeodesy.geodsolve} and L{pygeodesy.rhumb.solve}.
 '''
 
-from pygeodesy.basics import map2, ub2str, _zip
+from pygeodesy.basics import clips, 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_get1, _xkwds_item2
+from pygeodesy.errors import _AssertionError, _xkwds_get, _xkwds_get1, \
+                             _xkwds_item2
 from pygeodesy.internals import _enquote, printf
-from pygeodesy.interns import NN, _0_, _BACKSLASH_, _COMMASPACE_, \
-                             _EQUAL_, _Error_, _SPACE_, _UNUSED_
+from pygeodesy.interns import NN, _0_, _AT_,_BACKSLASH_, _COLONSPACE_, \
+                             _COMMASPACE_, _EQUAL_, _Error_, _SPACE_, \
+                             _UNUSED_
 from pygeodesy.karney import Caps, _CapsBase, GDict
 from pygeodesy.lazily import _ALL_DOCS, _ALL_LAZY, _sys_version_info2
 from pygeodesy.named import callername, _name2__, notOverloaded
@@ -23,7 +25,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.06.05'
+__version__ = '24.07.11'
 
 _ERROR_     = 'ERROR'
 _Popen_kwds =  dict(creationflags=0,
@@ -43,36 +45,96 @@ def _cmd_stdin_(cmd, stdin):  # PYCHOK no cover
     return _SPACE_.join(cmd)
 
 
+# def _float_int(r):
+#     '''(INTERNAL) Convert result into C{float} or C{int}.
+#     '''
+#     f = float(r)
+#     i = int(f)
+#     return i if float(i) == f else f  # PYCHOK inconsistent
+
+
 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}.
+       and all output from C{stdout/-err}, I{stripped}.
     '''
     p = _Popen(cmd, **_Popen_kwds)  # PYCHOK kwArgs
-    r =  p.communicate(stdin)[0]
+    r =  p.communicate(stdin)[0]  # stdout + NL + stderr
     return p.returncode, ub2str(r).strip()
 
 
 class _SolveCapsBase(_CapsBase):
     '''(NTERNAL) Base class for C{_SolveBase} and C{_LineSolveBase}.
     '''
-    _Error         =  None
-    _Exact         =  True
-    _invokation    =  0
-    _Names_Direct  = \
-    _Names_Inverse = ()
-    _prec          =  Precision_(prec=DIG)
-    _reverse2      =  False
-    _Solve_name    =  NN  # executable basename
-    _Solve_path    =  NN  # executable path
-    _status        =  None
-    _unroll        =  False
-    _verbose       =  False
+    _datum      = _WGS84
+    _Error      =  None
+    _Exact      =  True
+    _invokat    = _AT_
+    _invokation =  0
+    _linelimit  =  0
+    _prec       =  Precision_(prec=DIG)
+    _prec2stdin =  DIG
+    _Xable_name =  NN  # executable basename
+    _Xable_path =  NN  # executable path
+    _status     =  None
+    _verbose    =  False
+
+    @Property_RO
+    def a(self):
+        '''Get the I{equatorial} radius, semi-axis (C{meter}).
+        '''
+        return self.ellipsoid.a
 
     @property_RO
     def _cmdBasic(self):  # PYCHOK no cover
         '''(INTERNAL) I{Must be overloaded}.'''
         notOverloaded(self, underOK=True)
 
+    @property_RO
+    def datum(self):
+        '''Get the datum (C{Datum}).
+        '''
+        return self._datum
+
+    def _Dict(self, Dict, n, v, floats=True, **unused):
+        if self.verbose:  # PYCHOK no cover
+            self._print(_COMMASPACE_.join(map(Fmt.EQUAL, n, map(fstrzs, v))))
+        if floats:
+            v = map(float, v)  # _float_int, see Intersectool._XDistInvoke
+        return Dict(_zip(n, v))  # strict=True
+
+    def _DictInvoke2(self, cmd, args, Names, Dict, **floats_R):
+        '''(INTERNAL) Invoke C{Solve}, return results as C{Dict}.
+        '''
+        N = len(Names)
+        if N < 1:
+            raise _AssertionError(cmd=cmd, Names=Names)
+        i = fstr(args, prec=self._prec2stdin, fmt=Fmt.F, sep=_SPACE_) if args else None  # NOT Fmt.G!
+        t = self._invoke(cmd, stdin=i, **floats_R).lstrip().split()  # 12-/++ tuple
+        if _xkwds_get(floats_R, _R=None):  # == '-R' in cmd
+            return self._Dicts(Dict, Names, t, **floats_R), True
+        elif len(t) > N:  # PYCHOK no cover
+            # unzip instrumented name=value pairs to names and values
+            n, v = _zip(*(p.split(_EQUAL_) for p in t[:-N]))  # strict=True
+            v += tuple(t[-N:])
+            n += Names
+        else:
+            n, v = Names, t
+        r = self._Dict(Dict, n, t, **floats_R)
+        return self._iter2tion(r, **r), None
+
+    def _Dicts(self, Dict, Names, t, **floats_R):
+        i, N = 0, len(Names)
+        for x in range(0, len(t), N):
+            if t[x] == 'nan':
+                break
+            X = self._Dict(Dict, Names, t[x:x + N], **floats_R)
+            yield X.set_(iteration=i)
+            i += 1
+
+    @Property_RO
+    def _E_option(self):
+        return ('-E',) if self.Exact else ()
+
     @property
     def Exact(self):
         '''Get the Solve's C{exact} setting (C{bool}).
@@ -89,27 +151,38 @@ class _SolveCapsBase(_CapsBase):
             _update_all(self)
             self._Exact = Exact
 
-    def _GDictInvoke(self, cmd, floats, Names, *args):
-        '''(INTERNAL) Invoke C{Solve}, return results as C{GDict}.
+    @Property_RO
+    def ellipsoid(self):
+        '''Get the ellipsoid (C{Ellipsoid}).
         '''
-        N = len(Names)
-        if N < 1:
-            raise _AssertionError(cmd=cmd, Names=Names)
-        i = fstr(args, prec=DIG, fmt=Fmt.F, sep=_SPACE_) if args else None  # not Fmt.G!
-        t = self._invoke(cmd, stdin=i).lstrip().split()  # 12-/+ tuple
-        if len(t) > N:  # PYCHOK no cover
-            # unzip instrumented name=value pairs to names and values
-            n, v = _zip(*(p.split(_EQUAL_) for p in t[:-N]))  # strict=True
-            v += tuple(t[-N:])
-            n += Names
-        else:
-            n, v = Names, t
-        if self.verbose:  # PYCHOK no cover
-            self._print(_COMMASPACE_.join(map(Fmt.EQUAL, n, map(fstrzs, v))))
-        if floats:
-            v = map(float, v)
-        r = GDict(_zip(n, v))  # strict=True
-        return self._iter2tion(r, **r)
+        return self.datum.ellipsoid
+
+    @Property_RO
+    def _e_option(self):
+        E = self.ellipsoid
+        if E is _EWGS84:
+            return ()  # default
+        a, f = strs(E.a_f, fmt=Fmt.F, prec=DIG + 3)  # not .G!
+        return ('-e', a, f)
+
+    @Property_RO
+    def flattening(self):
+        '''Get the C{ellipsoid}'s I{flattening} (C{scalar}), M{(a - b) / a},
+           C{0} for spherical, negative for prolate.
+        '''
+        return self.ellipsoid.f
+
+    f = flattening
+
+    def invokat(self, *prefix):
+        '''Get and set the invokation number C{"@"} prefix (C{str}).
+
+           @return: Previous prefix (C{str}).
+        '''
+        p = self._invokat
+        if prefix:
+            set._invokat = str(prefix[0])
+        return p
 
     @property_RO
     def invokation(self):
@@ -134,7 +207,7 @@ class _SolveCapsBase(_CapsBase):
 
            @note: The C{Solve} return code is in property L{status}.
         '''
-        c = (self._Solve_path,) + map2(str, options)  # map2(_enquote, options)
+        c = (self._Xable_path,) + map2(str, options)  # map2(_enquote, options)
         i = _xkwds_get1(stdin, stdin=None)
         r =  self._invoke(c, stdin=i)
         s =  self.status
@@ -145,7 +218,7 @@ class _SolveCapsBase(_CapsBase):
             self._print(r)
         return r
 
-    def _invoke(self, cmd, stdin=None):
+    def _invoke(self, cmd, stdin=None, **unused):  # _R=None
         '''(INTERNAL) Invoke the C{Solve} executable, with the
            given B{C{cmd}} line and optional input to B{C{stdin}}.
         '''
@@ -161,8 +234,24 @@ class _SolveCapsBase(_CapsBase):
         except (IOError, OSError, TypeError, ValueError) as x:
             raise self._Error(cmd=t or _cmd_stdin_(cmd, stdin), cause=x)
         self._status = s
+        if self.verbose:  # and _R is None:  # PYCHOK no cover
+            self._print(repr(r), 'stdout/-err')
         return r
 
+    def linelimit(self, *limit):
+        '''Set and get the print line length limit.
+
+           @arg limit: New line limit (C{int}) or C{0}
+                       or C{None} for unlimited.
+
+           @return: Teh previous limit (C{int}).
+        '''
+        n = self._linelimit
+        if limit:
+            m = int(limit[0] or 0)
+            self._linelimit = max(80, m) if m > 0 else (n if m < 0 else 0)
+        return n
+
     @Property_RO
     def _mpd(self):  # meter per degree
         return self.ellipsoid._Lpd
@@ -191,45 +280,34 @@ class _SolveCapsBase(_CapsBase):
             _update_all(self)
             self._prec = prec
 
-    def _print(self, line):  # PYCHOK no cover
+    def _print(self, line, *suffix):  # PYCHOK no cover
         '''(INTERNAL) Print a status line.
         '''
+        if self._linelimit:
+            line =  clips(line, limit=self._linelimit, length=True)
         if self.status is not None:
-            line = _SPACE_(line, Fmt.PAREN(self.status))
-        printf('%s %d: %s', self.named2, self.invokation, line)
-
-    @Property
-    def reverse2(self):
-        '''Get the C{azi2} direction (C{bool}).
-        '''
-        return self._reverse2
-
-    @reverse2.setter  # PYCHOK setter!
-    def reverse2(self, reverse2):
-        '''Set the direction for C{azi2} (C{bool}), if C{True} reverse C{azi2}.
-        '''
-        reverse2 = bool(reverse2)
-        if self._reverse2 != reverse2:
-            _update_all(self)
-            self._reverse2 = reverse2
+            s    = _COMMASPACE_(self.status, *suffix)
+            line = _SPACE_(line, Fmt.PAREN(s))
+        p = NN(self.named2, self._invokat, self.invokation)
+        printf(_COLONSPACE_(p, line))
 
-    def _setSolve(self, path, **Solve_path):
+    def _setXable(self, path, **Xable_path):
         '''(INTERNAL) Set the executable C{path}.
         '''
-        hold = self._Solve_path
+        hold = self._Xable_path
         if hold != path:
             _update_all(self)
-            self._Solve_path = path
+            self._Xable_path = path
         try:
             _ = self.version  # test path and ...
             if self.status:  # ... return code
-                S_p = Solve_path or {self._Solve_name: _enquote(path)}
+                S_p = Xable_path or {self._Xable_name: _enquote(path)}
                 raise self._Error(status=self.status, txt_not_=_0_, **S_p)
             hold = path
         finally:  # restore in case of error
-            if self._Solve_path != hold:
+            if self._Xable_path != hold:
                 _update_all(self)
-                self._Solve_path = hold
+                self._Xable_path = hold
 
     @property_RO
     def status(self):
@@ -238,21 +316,6 @@ class _SolveCapsBase(_CapsBase):
         '''
         return self._status
 
-    @Property
-    def unroll(self):
-        '''Get the C{lon2} unroll'ing (C{bool}).
-        '''
-        return self._unroll
-
-    @unroll.setter  # PYCHOK setter!
-    def unroll(self, unroll):
-        '''Set unroll'ing for C{lon2} (C{bool}), if C{True} unroll C{lon2}, otherwise don't.
-        '''
-        unroll = bool(unroll)
-        if self._unroll != unroll:
-            _update_all(self)
-            self._unroll = unroll
-
     @property
     def verbose(self):
         '''Get the C{verbose} option (C{bool}).
@@ -274,9 +337,47 @@ class _SolveCapsBase(_CapsBase):
 
 
 class _SolveBase(_SolveCapsBase):
+    '''(INTERNAL) Base class for C{_SolveBase} and C{_SolveLineBase}.
+    '''
+    _Names_Direct  = \
+    _Names_Inverse = ()
+    _reverse2      =  False
+    _unroll        =  False
+
+    @Property
+    def reverse2(self):
+        '''Get the C{azi2} direction (C{bool}).
+        '''
+        return self._reverse2
+
+    @reverse2.setter  # PYCHOK setter!
+    def reverse2(self, reverse2):
+        '''Set the direction for C{azi2} (C{bool}), if C{True} reverse C{azi2}.
+        '''
+        reverse2 = bool(reverse2)
+        if self._reverse2 != reverse2:
+            _update_all(self)
+            self._reverse2 = reverse2
+
+    @Property
+    def unroll(self):
+        '''Get the C{lon2} unroll'ing (C{bool}).
+        '''
+        return self._unroll
+
+    @unroll.setter  # PYCHOK setter!
+    def unroll(self, unroll):
+        '''Set unroll'ing for C{lon2} (C{bool}), if C{True} unroll C{lon2}, otherwise don't.
+        '''
+        unroll = bool(unroll)
+        if self._unroll != unroll:
+            _update_all(self)
+            self._unroll = unroll
+
+
+class _SolveGDictBase(_SolveBase):
     '''(NTERNAL) Base class for C{_GeodesicSolveBase} and C{_RhumbSolveBase}.
     '''
-    _datum = _WGS84
 
     def __init__(self, a_ellipsoid=_EWGS84, f=None, path=NN, **name):
         '''New C{Solve} instance.
@@ -296,13 +397,7 @@ class _SolveBase(_SolveCapsBase):
         if name:
             self.name = name
         if path:
-            self._setSolve(path)
-
-    @Property_RO
-    def a(self):
-        '''Get the I{equatorial} radius, semi-axis (C{meter}).
-        '''
-        return self.ellipsoid.a
+            self._setXable(path)
 
     @Property_RO
     def _cmdDirect(self):
@@ -316,56 +411,29 @@ class _SolveBase(_SolveCapsBase):
         '''
         return self._cmdBasic + ('-i',)
 
-    @property_RO
-    def datum(self):
-        '''Get the datum (C{Datum}).
-        '''
-        return self._datum
-
     def Direct(self, lat1, lon1, azi1, s12, outmask=_UNUSED_):  # PYCHOK unused
         '''Return the C{Direct} result.
         '''
         return self._GDictDirect(lat1, lon1, azi1, False, s12)
 
-    @Property_RO
-    def ellipsoid(self):
-        '''Get the ellipsoid (C{Ellipsoid}).
-        '''
-        return self.datum.ellipsoid
-
-    @Property_RO
-    def _e_option(self):
-        E = self.ellipsoid
-        if E is _EWGS84:
-            return ()  # default
-        a, f = strs(E.a_f, fmt=Fmt.F, prec=DIG + 3)  # not .G!
-        return ('-e', a, f)
-
-    @Property_RO
-    def flattening(self):
-        '''Get the C{ellipsoid}'s I{flattening} (C{scalar}), M{(a - b) / a},
-           C{0} for spherical, negative for prolate.
-        '''
-        return self.ellipsoid.f
-
-    f = flattening
-
     def _GDictDirect(self, lat, lon, azi, arcmode, s12_a12, outmask=_UNUSED_, **floats):  # PYCHOK for .geodesicx.gxarea
         '''(INTERNAL) Get C{_GenDirect}-like result as C{GDict}.
         '''
         if arcmode:
             raise self._Error(arcmode=arcmode, txt=str(NotImplemented))
-        floats = _xkwds_get1(floats, floats=True)
-        return self._GDictInvoke(self._cmdDirect, floats, self._Names_Direct,
-                                                  lat, lon, azi, s12_a12)
+        return self._GDictInvoke(self._cmdDirect, self._Names_Direct,
+                                                  lat, lon, azi, s12_a12, **floats)
 
     def _GDictInverse(self, lat1, lon1, lat2, lon2, outmask=_UNUSED_, **floats):  # PYCHOK for .geodesicx.gxarea
-        '''(INTERNAL) Get C{_GenInverse}-like result as C{GDict}, but
-           I{without} C{_SALPs_CALPs_}.
+        '''(INTERNAL) Get C{_GenInverse}-like result as C{GDict}, but I{without} C{_SALP_CALPs_}.
+        '''
+        return self._GDictInvoke(self._cmdInverse, self._Names_Inverse,
+                                                   lat1, lon1, lat2, lon2, **floats)
+
+    def _GDictInvoke(self, cmd,  Names, *args, **floats):
+        '''(INTERNAL) Invoke C{Solve}, return results as C{Dict}.
         '''
-        floats = _xkwds_get1(floats, floats=True)
-        return self._GDictInvoke(self._cmdInverse, floats, self._Names_Inverse,
-                                                   lat1, lon1, lat2, lon2)
+        return self._DictInvoke2(cmd, args, Names, GDict, **floats)[0]  # _R
 
     def Inverse(self, lat1, lon1, lat2, lon2, outmask=_UNUSED_):  # PYCHOK unused
         '''Return the C{Inverse} result.
@@ -390,7 +458,7 @@ class _SolveBase(_SolveCapsBase):
         return sep.join(pairs(d, prec=prec))
 
 
-class _SolveLineBase(_SolveCapsBase):
+class _SolveGDictLineBase(_SolveGDictBase):
     '''(NTERNAL) Base class for C{GeodesicLineSolve} and C{RhumbLineSolve}.
     '''
 #   _caps  =  0
@@ -402,7 +470,7 @@ class _SolveLineBase(_SolveCapsBase):
         if name:
             self.name = name
 
-        self._caps  = caps | Caps._LINE
+        self._caps  = caps | Caps._AZIMUTH_LATITUDE_LONG_UNROLL
         self._debug = solve._debug & Caps._DEBUG_ALL
         self._lla1  = GDict(lat1=lat1, lon1=lon1, **azi)
         self._solve = solve
@@ -451,7 +519,7 @@ class _SolveLineBase(_SolveCapsBase):
         return sep.join(pairs(d, prec=prec))
 
 
-__all__ += _ALL_DOCS(_SolveBase, _SolveLineBase, _SolveCapsBase)
+__all__ += _ALL_DOCS(_SolveBase, _SolveCapsBase, _SolveGDictBase, _SolveGDictLineBase)
 
 # **) MIT License
 #

pygeodesy/triaxials.py

@@ -49,7 +49,7 @@ from pygeodesy.named import _lazyNamedEnumItem as _lazy, _name__, _NamedEnum, \
                                 _NamedEnumItem, _Pass
 from pygeodesy.namedTuples import LatLon3Tuple, _NamedTupleTo, Vector3Tuple, \
                                   Vector4Tuple
-from pygeodesy.props import Property_RO, property_RO
+from pygeodesy.props import Property_RO, property_ROver
 # from pygeodesy.streprs import Fmt  # from .datums
 from pygeodesy.units import Degrees, Float, Height_, Meter, Meter2, Meter3, \
                             Radians, Radius, Scalar_
@@ -59,7 +59,7 @@ from pygeodesy.vector3d import _otherV3d, Vector3d,  _ALL_LAZY, _MODS
 from math import atan2, fabs, sqrt
 
 __all__ = _ALL_LAZY.triaxials
-__version__ = '24.06.24'
+__version__ = '24.07.12'
 
 _not_ordered_ = _not_('ordered')
 _omega_       = 'omega'
@@ -360,12 +360,11 @@ class Triaxial_(_NamedEnumItem):
 
     _1e2bc = _c2_b2  # C{1 - e2bc} == C{(c/b)**2}
 
-    @property_RO
+    @property_ROver
     def _Elliptic(self):
         '''(INTERNAL) Get class L{Elliptic}, I{once}.
         '''
-        Triaxial_._Elliptic = E = _MODS.elliptic.Elliptic  # overwrite property_RO
-        return E
+        return _MODS.elliptic.Elliptic  # overwrite propertyROver
 
     def hartzell4(self, pov, los=False, **name):
         '''Compute the intersection of this triaxial's surface with a Line-Of-Sight

pygeodesy/units.py

@@ -27,7 +27,7 @@ from pygeodesy.unitsBase import Float, Int, _NamedUnit, Radius, Str,  Fmt, fstr
 from math import degrees, radians
 
 __all__ = _ALL_LAZY.units
-__version__ = '24.06.15'
+__version__ = '24.06.29'
 
 
 class Float_(Float):
@@ -781,10 +781,10 @@ class Zone(Int):
         return Int_.__new__(cls, arg=arg, name=name, **Error_name_arg)
 
 
-_Scalars =  Float, Float_, Scalar, Scalar_
-_Degrees = (Bearing, Bearing_, Degrees, Degrees_) + _Scalars
-_Meters  = (Distance, Distance_, Meter, Meter_) + _Scalars
-_Radians = (Radians, Radians_) + _Scalars  # PYCHOK unused
+_ScalarU =  Float, Float_, Scalar, Scalar_
+_Degrees = (Bearing, Bearing_, Degrees, Degrees_) + _ScalarU
+_Meters  = (Distance, Distance_, Meter, Meter_) + _ScalarU
+_Radians = (Radians, Radians_) + _ScalarU  # PYCHOK unused
 _Radii   = _Meters + (Radius, Radius_)