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

pygeodesy/solveBase.py

@@ -13,7 +13,7 @@ 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.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
@@ -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.31'
+__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,7 +134,7 @@ class _SolveLineSolveBase(_CapsBase):
 
            @note: The C{Solve} return code is in property L{status}.
         '''
-        c = (self._Solve_path,) + map2(str, options)
+        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
@@ -270,7 +273,7 @@ class _SolveLineSolveBase(_CapsBase):
         return self.invoke('--version')
 
 
-class _SolveBase(_SolveLineSolveBase):
+class _SolveBase(_SolveCapsBase):
     '''(NTERNAL) Base class for C{_GeodesicSolveBase} and C{_RhumbSolveBase}.
     '''
     _datum = _WGS84
@@ -387,7 +390,7 @@ 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
@@ -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
 #

pygeodesy/sphericalBase.py

@@ -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__ = '24.05.31'
+__version__ = '24.06.06'
 
 
 class CartesianSphericalBase(CartesianBase):
@@ -380,7 +380,8 @@ class LatLonSphericalBase(LatLonBase):
         '''DEPRECATED, use method C{.rhumbAzimuthTo}.'''
         return self.rhumbAzimuthTo(other, b360=True)  # [0..360)
 
-    def rhumbDestination(self, distance, azimuth, radius=R_M, height=None, exact=False):
+    def rhumbDestination(self, distance, azimuth, radius=R_M, height=None,
+                                                   exact=False, **name):
         '''Return the destination point having travelled the given distance from
            this point along a rhumb line (loxodrome) of the given azimuth.
 
@@ -393,6 +394,7 @@ class LatLonSphericalBase(LatLonBase):
            @kwarg height: Optional height, overriding the default height (C{meter}.
            @kwarg exact: If C{True}, use I{Elliptic, Krüger} L{Rhumb} (C{bool}),
                          default C{False} for backward compatibility.
+           @kwarg name: Optional C{B{name}=NN} (C{str}).
 
            @return: The destination point (spherical C{LatLon}).
 
@@ -401,7 +403,7 @@ class LatLonSphericalBase(LatLonBase):
         '''
         if exact:  # use series, always
             r = LatLonBase.rhumbDestination(self, distance, azimuth, exact=False,  # Krüger
-                                                  radius=radius, height=height)
+                                                  radius=radius, height=height, **name)
         else:  # radius=None from .rhumbMidpointTo
             if radius in (None, self._radius):
                 d, r = self.datum, radius
@@ -425,7 +427,7 @@ class LatLonSphericalBase(LatLonBase):
             b2 = b1 if isnear0(q) else (b1 + r * sb / q)
 
             h = self._heigHt(height)
-            r = self.classof(degrees90(a2), degrees180(b2), datum=d, height=h)
+            r = self.classof(degrees90(a2), degrees180(b2), datum=d, height=h, **name)
         return r
 
     def rhumbDistanceTo(self, other, radius=R_M, exact=False, wrap=False):
@@ -499,7 +501,7 @@ class LatLonSphericalBase(LatLonBase):
                                              height=height, wrap=wrap)
 
     def rhumbMidpointTo(self, other, height=None, radius=R_M, exact=False,
-                                                fraction=_0_5, wrap=False):
+                                                fraction=_0_5, **wrap_name):
         '''Return the (loxodromic) midpoint on the rhumb line between
            this and an other point.
 
@@ -511,8 +513,9 @@ class LatLonSphericalBase(LatLonBase):
                          default C{False} for backward compatibility.
            @kwarg fraction: Midpoint location from this point (C{scalar}), may
                             be negative if C{B{exact}=True}.
-           @kwarg wrap: If C{True}, wrap or I{normalize} and unroll the B{C{other}}
-                        point (C{bool}).
+           @kwarg wrap_name: Optional C{B{name}=NN} (C{str}) and optional keyword
+                       argument C{B{wrap}=False}, if C{True}, wrap or I{normalize}
+                       and unroll the B{C{other}} point (C{bool}).
 
            @return: The (mid)point at the given B{C{fraction}} along the rhumb
                     line (spherical C{LatLon}).
@@ -524,18 +527,21 @@ class LatLonSphericalBase(LatLonBase):
         if exact:  # use series, always
             r = LatLonBase.rhumbMidpointTo(self, other, exact=False,  # Krüger
                                                  radius=radius, height=height,
-                                                 fraction=fraction, wrap=wrap)
+                                                 fraction=fraction, **wrap_name)
         elif fraction is not _0_5:
             f = Scalar_(fraction=fraction)  # low=_0_0
-            r, db, dp = self._rhumbs3(other, wrap, r=True)  # radians
+            w, n      = self._wrap_name2(**wrap_name)
+            r, db, dp = self._rhumbs3(other, w, r=True)  # radians
             z = atan2b(db, dp)
             h = self._havg(other, f=f, h=height)
-            r = self.rhumbDestination(r * f, z, radius=None, height=h)
+            r = self.rhumbDestination(r * f, z, radius=None, height=h, name=n)
 
         else:  # for backward compatibility, unwrapped
+            _,  n  = self._wrap_name2(**wrap_name)
             # see <https://MathForum.org/library/drmath/view/51822.html>
             a1, b1 = self.philam
             a2, b2 = self.others(other).philam
+            _,  n  = self._wrap_name2(**wrap_name)
 
             if fabs(b2 - b1) > PI:
                 b1 += PI2  # crossing anti-meridian
@@ -557,7 +563,7 @@ class LatLonSphericalBase(LatLonBase):
             d = self.datum if radius in (None, self._radius) else \
                _spherical_datum(radius, name=self.name, raiser=_radius_)
             h = self._havg(other, h=height)
-            r = self.classof(degrees90(a3), degrees180(b3), datum=d, height=h)
+            r = self.classof(degrees90(a3), degrees180(b3), datum=d, height=h, name=n)
         return r
 
     @property_RO

pygeodesy/streprs.py

@@ -8,7 +8,7 @@ from pygeodesy.basics import isint, islistuple, isscalar, isstr, itemsorted, \
                             _zip, _0_0
 # from pygeodesy.constants import _0_0
 from pygeodesy.errors import _or, _AttributeError, _IsnotError, _TypeError, \
-                             _ValueError, _xkwds_get, _xkwds_item2, _xkwds_pop2
+                             _ValueError, _xkwds_get, _xkwds_item2
 # from pygeodesy.internals import _dunder_nameof  # from .lazily
 from pygeodesy.interns import NN, _0_, _0to9_, MISSING, _BAR_, _COMMASPACE_, \
                              _DOT_, _E_, _ELLIPSIS_, _EQUAL_, _H_, _LR_PAIRS, \
@@ -22,7 +22,7 @@ from pygeodesy.lazily import _ALL_LAZY, _ALL_MODS as _MODS,  _dunder_nameof
 from math import fabs, log10 as _log10
 
 __all__ = _ALL_LAZY.streprs
-__version__ = '24.05.19'
+__version__ = '24.06.04'
 
 _at_        = 'at'         # PYCHOK used!
 _EN_PREC    =  6           # max MGRS/OSGR precision, 1 micrometer
@@ -546,8 +546,10 @@ def unstr(where, *args, **kwds):
 
        @return: Representation (C{str}).
     '''
-    e, kwds = _xkwds_pop2(kwds, _ELLIPSIS=False)
-    g, kwds = _xkwds_pop2(kwds, _fmt=Fmt.g)
+    def _e_g_kwds3(_ELLIPSIS=False, _fmt=Fmt.g, **kwds):
+        return _ELLIPSIS, _fmt, kwds
+
+    e, g, kwds = _e_g_kwds3(**kwds)
     t = reprs(args, fmt=g) if args else ()
     if e:
         t += _ELLIPSIS_,

pygeodesy/trf.py

@@ -91,7 +91,7 @@ from math import ceil as _ceil, fabs
 # import operator as _operator  # from .datums
 
 __all__ = _ALL_LAZY.trf
-__version__ = '24.05.31'
+__version__ = '24.06.09'
 
 _EP0CH    =  Epoch(0, low=0)
 _Es       = {_EP0CH: _EP0CH}  # L{Epoch}s, deleted below
@@ -253,7 +253,7 @@ class RefFrame(_NamedEnumItem):
         '''
         D = self.datum
         e = self.epoch if epoch is None else _Epoch(epoch)
-        t = (Fmt.EQUAL(name=repr(name or self.name)),
+        t = (Fmt.EQUAL(name=repr(self._name__(name))),
              Fmt.EQUAL(epoch=e),
              Fmt.EQUAL(datum=_DOT_(classname(D) + _s_, D.name)))
         return _COMMASPACE_.join(t[int(name is None):])
@@ -903,7 +903,7 @@ def date2epoch(year, month, day):
             e = y + float(sum(_mDays[:m]) + d) / _366_0
             return Epoch(e, low=0)
 
-        raise ValueError  # _invalid_
+        raise ValueError()  # _invalid_
     except (TRFError, TypeError, ValueError) as x:
         raise TRFError(year=year, month=month, day=day, cause=x)
 

pygeodesy/triaxials.py

@@ -35,7 +35,6 @@ from pygeodesy.constants import EPS, EPS0, EPS02, EPS4, INT0, PI2, PI_3, PI4, \
                                _EPS2e4, float0_, isfinite, isnear1, _0_0, _0_5, \
                                _1_0, _N_1_0, _N_2_0,  _4_0  # PYCHOK used!
 from pygeodesy.datums import Datum, _spherical_datum, _WGS84,  Ellipsoid, _EWGS84, Fmt
-# from pygeodesy.dms import toDMS  # _MODS
 # from pygeodesy.ellipsoids import Ellipsoid, _EWGS84  # from .datums
 # from pygeodesy.elliptic import Elliptic  # _MODS
 # from pygeodesy.errors import _ValueError  # from .basics
@@ -47,38 +46,49 @@ from pygeodesy.interns import NN, _a_, _b_, _beta_, _c_, _distant_, _finite_, \
                              _spherical_, _too_, _x_, _y_
 # from pygeodesy.lazily import _ALL_LAZY, _ALL_MODS as _MODS  # from .vector3d
 from pygeodesy.named import _lazyNamedEnumItem as _lazy, _name__, _NamedEnum, \
-                                _NamedEnumItem, _NamedTuple, _Pass
-from pygeodesy.namedTuples import LatLon3Tuple, Vector3Tuple, Vector4Tuple
+                                _NamedEnumItem, _Pass
+from pygeodesy.namedTuples import LatLon3Tuple, _NamedTupleTo, Vector3Tuple, \
+                                  Vector4Tuple
 from pygeodesy.props import Property_RO, property_RO
 # from pygeodesy.streprs import Fmt  # from .datums
-from pygeodesy.units import Float, Height_, Meter, Meter2, Meter3, Radians, \
-                            Radius, Scalar_, _toDegrees, _toRadians
+from pygeodesy.units import Degrees, Float, Height_, Meter, Meter2, Meter3, \
+                            Radians, Radius, Scalar_
 from pygeodesy.utily import asin1, atan2d, km2m, m2km, SinCos2, sincos2d_
 from pygeodesy.vector3d import _otherV3d, Vector3d,  _ALL_LAZY, _MODS
 
 from math import atan2, fabs, sqrt
 
 __all__ = _ALL_LAZY.triaxials
-__version__ = '24.05.28'
+__version__ = '24.06.09'
 
 _not_ordered_ = _not_('ordered')
 _omega_       = 'omega'
 _TRIPS        =  269  # 48-55, Eberly 1074?
 
 
-class _NamedTupleTo(_NamedTuple):  # in .testNamedTuples, like .cartesianBase.RadiusThetaPhi3Tuple
-    '''(INTERNAL) Base for C{-.toDegrees}, C{-.toRadians}.
+class _NamedTupleToX(_NamedTupleTo):  # in .testNamedTuples
+    '''(INTERNAL) Base class for L{BetaOmega2Tuple},
+       L{BetaOmega3Tuple} and L{Jacobi2Tuple}.
     '''
-    def _toDegrees(self, a, b, *c, **toDMS_kwds):
-        a, b, _ = _toDegrees(self, a, b, **toDMS_kwds)
-        return _ or self.classof(a, b, *c, name=self.name)
+    def _toDegrees(self, name, **toDMS_kwds):
+        '''(INTERNAL) Convert C{self[0:2]} to L{Degrees} or C{toDMS}.
+        '''
+        return self._toX3U(_NamedTupleTo._Degrees3, Degrees, name, *self, **toDMS_kwds)
+
+    def _toRadians(self, name):
+        '''(INTERNAL) Convert C{self[0:2]} to L{Radians}.
+        '''
+        return self._toX3U(_NamedTupleTo._Radians3, Radians, name, *self)
 
-    def _toRadians(self, a, b, *c):
-        a, b, _ = _toRadians(self, a, b)
-        return _ or self.classof(a, b, *c, name=self.name)
+    def _toX3U(self, _X3, U, name, a, b, *c, **kwds):
+        a, b, s = _X3(self, a, b, **kwds)
+        if s is None or name:
+            n = self._name__(name)
+            s = self.classof(a, b, *c, name=n).reUnit(U, U).toUnits()
+        return s
 
 
-class BetaOmega2Tuple(_NamedTupleTo):
+class BetaOmega2Tuple(_NamedTupleToX):
     '''2-Tuple C{(beta, omega)} with I{ellipsoidal} lat- and
        longitude C{beta} and C{omega} both in L{Radians} (or
        L{Degrees}).
@@ -86,27 +96,30 @@ class BetaOmega2Tuple(_NamedTupleTo):
     _Names_ = (_beta_, _omega_)
     _Units_ = (_Pass,  _Pass)
 
-    def toDegrees(self, **toDMS_kwds):
+    def toDegrees(self, name=NN, **toDMS_kwds):
         '''Convert this L{BetaOmega2Tuple} to L{Degrees} or C{toDMS}.
 
-           @return: L{BetaOmega2Tuple}C{(beta, omega)} with
-                    C{beta} and C{omega} both in L{Degrees}
-                    or as a L{toDMS} string provided some
-                    B{C{toDMS_kwds}} keyword arguments are
+           @kwarg name: Optional name (C{str}), overriding this name.
+
+           @return: L{BetaOmega2Tuple}C{(beta, omega)} with C{beta} and
+                    C{omega} both in L{Degrees} or as L{toDMS} strings
+                    provided some B{C{toDMS_kwds}} keyword arguments are
                     specified.
         '''
-        return _NamedTupleTo._toDegrees(self, *self, **toDMS_kwds)
+        return self._toDegrees(name, **toDMS_kwds)
 
-    def toRadians(self):
+    def toRadians(self, **name):
         '''Convert this L{BetaOmega2Tuple} to L{Radians}.
 
-           @return: L{BetaOmega2Tuple}C{(beta, omega)} with
-                    C{beta} and C{omega} both in L{Radians}.
+           @kwarg name: Optional C{B{name}=NN} (C{str}), overriding this name.
+
+           @return: L{BetaOmega2Tuple}C{(beta, omega)} with C{beta} and C{omega}
+                    both in L{Radians}.
         '''
-        return _NamedTupleTo._toRadians(self, *self)
+        return self._toRadians(name)
 
 
-class BetaOmega3Tuple(_NamedTupleTo):
+class BetaOmega3Tuple(_NamedTupleToX):
     '''3-Tuple C{(beta, omega, height)} with I{ellipsoidal} lat- and
        longitude C{beta} and C{omega} both in L{Radians} (or L{Degrees})
        and the C{height}, rather the (signed) I{distance} to the triaxial's
@@ -116,54 +129,62 @@ class BetaOmega3Tuple(_NamedTupleTo):
     _Names_ = BetaOmega2Tuple._Names_ + (_height_,)
     _Units_ = BetaOmega2Tuple._Units_ + ( Meter,)
 
-    def toDegrees(self, **toDMS_kwds):
+    def toDegrees(self, name=NN, **toDMS_kwds):
         '''Convert this L{BetaOmega3Tuple} to L{Degrees} or C{toDMS}.
 
+           @kwarg name: Optional name (C{str}), overriding this name.
+
            @return: L{BetaOmega3Tuple}C{(beta, omega, height)} with
-                    C{beta} and C{omega} both in L{Degrees} or as a
-                    L{toDMS} string provided some B{C{toDMS_kwds}}
+                    C{beta} and C{omega} both in L{Degrees} or as
+                    L{toDMS} strings provided some B{C{toDMS_kwds}}
                     keyword arguments are specified.
         '''
-        return _NamedTupleTo._toDegrees(self, *self, **toDMS_kwds)
+        return self._toDegrees(name, **toDMS_kwds)
 
-    def toRadians(self):
+    def toRadians(self, **name):
         '''Convert this L{BetaOmega3Tuple} to L{Radians}.
 
-           @return: L{BetaOmega3Tuple}C{(beta, omega, height)} with
-                    C{beta} and C{omega} both in L{Radians}.
+           @kwarg name: Optional C{B{name}=NN} (C{str}), overriding this name.
+
+           @return: L{BetaOmega3Tuple}C{(beta, omega, height)} with C{beta}
+                    and C{omega} both in L{Radians}.
         '''
-        return _NamedTupleTo._toRadians(self, *self)
+        return self._toRadians(name)
 
-    def to2Tuple(self):
+    def to2Tuple(self, **name):
         '''Reduce this L{BetaOmega3Tuple} to a L{BetaOmega2Tuple}.
+
+           @kwarg name: Optional C{B{name}=NN} (C{str}), overriding this name.
         '''
-        return BetaOmega2Tuple(*self[:2])
+        return BetaOmega2Tuple(*self[:2], name=self._name__(name))
 
 
-class Jacobi2Tuple(_NamedTupleTo):
+class Jacobi2Tuple(_NamedTupleToX):
     '''2-Tuple C{(x, y)} with a Jacobi Conformal C{x} and C{y}
        projection, both in L{Radians} (or L{Degrees}).
     '''
     _Names_ = (_x_,   _y_)
     _Units_ = (_Pass, _Pass)
 
-    def toDegrees(self, **toDMS_kwds):
+    def toDegrees(self, name=NN, **toDMS_kwds):
         '''Convert this L{Jacobi2Tuple} to L{Degrees} or C{toDMS}.
 
-           @return: L{Jacobi2Tuple}C{(x, y)} with C{x} and C{y}
-                    both in L{Degrees} or as a L{toDMS} string
-                    provided some B{C{toDMS_kwds}} keyword
-                    arguments are specified.
+           @kwarg name: Optional name (C{str}), overriding this name.
+
+           @return: L{Jacobi2Tuple}C{(x, y)} with C{x} and C{y} both
+                    in L{Degrees} or as L{toDMS} strings provided some
+                    B{C{toDMS_kwds}} keyword arguments are specified.
         '''
-        return _NamedTupleTo._toDegrees(self, *self, **toDMS_kwds)
+        return self._toDegrees(name, **toDMS_kwds)
 
-    def toRadians(self):
+    def toRadians(self, **name):
         '''Convert this L{Jacobi2Tuple} to L{Radians}.
 
-           @return: L{Jacobi2Tuple}C{(x, y)} with C{x}
-                    and C{y} both in L{Radians}.
+           @kwarg name: Optional C{B{name}=NN} (C{str}), overriding this name.
+
+           @return: L{Jacobi2Tuple}C{(x, y)} with C{x} and C{y} both in L{Radians}.
         '''
-        return _NamedTupleTo._toRadians(self, *self)
+        return self._toRadians(name)
 
 
 class Triaxial_(_NamedEnumItem):
@@ -894,8 +915,8 @@ class Triaxial(Triaxial_):
         s =  v.times_(self._1e2ac,  # == 1 - e_sub_x**2
                       self._1e2bc,  # == 1 - e_sub_y**2
                      _1_0)
-        t = self._reverseLatLon3(s, atan2d, v, self.forwardLatLon_)
-        return LatLon3Tuple(*t, **name)
+        a, b, h = self._reverseLatLon3(s, atan2d, v, self.forwardLatLon_)
+        return LatLon3Tuple(Degrees(lat=a), Degrees(lon=b), h, **name)
 
     def _reverseLatLon3(self, s, atan2_, v, forward_):
         '''(INTERNAL) Helper for C{.reverseBetOmg} and C{.reverseLatLon}.