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

pygeodesy/geodsolve.py

@@ -10,48 +10,31 @@ of the C{GeodSolve} executable.
 '''
 
 from pygeodesy.basics import _xinstanceof
-# from pygeodesy.constants import NAN, _0_0 # from .karney
+# from pygeodesy.constants import NAN, _0_0  # from .karney
 # from pygeodesy.geodesicx import GeodesicAreaExact  # _MODS
-from pygeodesy.interns import NN, _a12_, _azi1_, _azi2_, \
-                             _lat1_, _lat2_, _lon1_, _lon2_, _m12_, \
-                             _M12_, _M21_, _s12_, _S12_, _UNDER_
-from pygeodesy.interns import _UNUSED_, _not_  # PYCHOK used!
-from pygeodesy.karney import _Azi, Caps, _Deg, GeodesicError, _GTuple, \
-                             _Pass, _Lat, _Lon, _M, _M2, _sincos2d, \
-                             _0_0, NAN
+from pygeodesy.interns import NN, _UNDER_
+from pygeodesy.karney import Caps, GeodesicError, GeodSolve12Tuple, \
+                            _sincos2d,  _0_0, NAN
 from pygeodesy.lazily import _ALL_DOCS, _ALL_LAZY, _ALL_MODS as _MODS, \
                              _getenv, _PYGEODESY_GEODSOLVE_
 from pygeodesy.named import _name1__
 from pygeodesy.namedTuples import Destination3Tuple, Distance3Tuple
 from pygeodesy.props import Property, Property_RO, property_RO
-from pygeodesy.solveBase import _SolveBase, _SolveLineBase
+from pygeodesy.solveBase import _SolveGDictBase, _SolveGDictLineBase
 from pygeodesy.utily import _unrollon, _Wrap, wrap360
 
 __all__ = _ALL_LAZY.geodsolve
-__version__ = '24.06.26'
+__version__ = '24.07.11'
 
 
-class GeodSolve12Tuple(_GTuple):
-    '''12-Tuple C{(lat1, lon1, azi1, lat2, lon2, azi2, s12, a12, m12, M12, M21, S12)} with
-       angles C{lat1}, C{lon1}, C{azi1}, C{lat2}, C{lon2} and C{azi2} and arc C{a12} all in
-       C{degrees}, initial C{azi1} and final C{azi2} forward azimuths, distance C{s12} and
-       reduced length C{m12} in C{meter}, area C{S12} in C{meter} I{squared} and geodesic
-       scale factors C{M12} and C{M21}, both C{scalar}, see U{GeodSolve
-       <https://GeographicLib.SourceForge.io/C++/doc/GeodSolve.1.html>}.
-    '''
-    # from GeodSolve --help option -f ... lat1 lon1 azi1 lat2 lon2 azi2 s12 a12 m12 M12 M21 S12
-    _Names_ = (_lat1_, _lon1_, _azi1_, _lat2_, _lon2_, _azi2_, _s12_, _a12_, _m12_, _M12_, _M21_, _S12_)
-    _Units_ = (_Lat,   _Lon,   _Azi,   _Lat,   _Lon,   _Azi,   _M,    _Deg,  _Pass, _Pass, _Pass, _M2)
-
-
-class _GeodesicSolveBase(_SolveBase):
+class _GeodesicSolveBase(_SolveGDictBase):
     '''(INTERNAL) Base class for L{GeodesicSolve} and L{GeodesicLineSolve}.
     '''
     _Error         =  GeodesicError
     _Names_Direct  = \
     _Names_Inverse =  GeodSolve12Tuple._Names_
-    _Solve_name    = 'GeodSolve'
-    _Solve_path    = _getenv(_PYGEODESY_GEODSOLVE_, _PYGEODESY_GEODSOLVE_)
+    _Xable_name    = 'GeodSolve'
+    _Xable_path    = _getenv(_PYGEODESY_GEODSOLVE_, _PYGEODESY_GEODSOLVE_)
 
     @Property_RO
     def _b_option(self):
@@ -67,16 +50,12 @@ class _GeodesicSolveBase(_SolveBase):
                                          self._p_option +
                                          self._u_option)
 
-    @Property_RO
-    def _E_option(self):
-        return ('-E',) if self.Exact else ()
-
     @Property
     def GeodSolve(self):
         '''Get the U{GeodSolve<https://GeographicLib.SourceForge.io/C++/doc/GeodSolve.1.html>}
            executable (C{filename}).
         '''
-        return self._Solve_path
+        return self._Xable_path
 
     @GeodSolve.setter  # PYCHOK setter!
     def GeodSolve(self, path):
@@ -86,20 +65,20 @@ class _GeodesicSolveBase(_SolveBase):
            @raise GeodesicError: Invalid B{C{path}}, B{C{path}} doesn't exist or
                                  isn't the C{GeodSolve} executable.
         '''
-        self._setSolve(path)
+        self._setXable(path)
 
     def toStr(self, **prec_sep):  # PYCHOK signature
         '''Return this C{GeodesicSolve} as string.
 
-           @kwarg prec_sep: Keyword argumens C{B{prec}=6} and C{B{sep}=', '}
-                      for the C{float} C{prec}ision, number of decimal digits
-                      (0..9) and the C{sep}arator string to join.  Trailing
-                      zero decimals are stripped for B{C{prec}} values of
-                      1 and above, but kept for negative B{C{prec}} values.
+           @kwarg prec_sep: Keyword argumens C{B{prec}=6} and C{B{sep}=", "}
+                       for the C{float} C{prec}ision, number of decimal digits
+                       (0..9) and the C{sep}arator string to join.  Trailing
+                       zero decimals are stripped for B{C{prec}} values of 1
+                       and above, but kept for negative B{C{prec}} values.
 
            @return: GeodesicSolve items (C{str}).
         '''
-        return _SolveBase._toStr(self, GeodSolve=self.GeodSolve, **prec_sep)
+        return _SolveGDictBase._toStr(self, GeodSolve=self.GeodSolve, **prec_sep)
 
     @Property_RO
     def _u_option(self):
@@ -119,11 +98,11 @@ class GeodesicSolve(_GeodesicSolveBase):
     '''
 
     def Area(self, polyline=False, **name):
-        '''Set up a L{GeodesicAreaExact} to compute area and
-           perimeter of a polygon.
+        '''Set up a L{GeodesicAreaExact} to compute area and perimeter
+           of a polygon.
 
-           @kwarg polyline: If C{True} perimeter only, otherwise
-                            area and perimeter (C{bool}).
+           @kwarg polyline: If C{True} perimeter only, otherwise area
+                            and perimeter (C{bool}).
            @kwarg name: Optional C{B{name}=NN} (C{str}).
 
            @return: A L{GeodesicAreaExact} instance.
@@ -139,8 +118,8 @@ class GeodesicSolve(_GeodesicSolveBase):
     Polygon = Area  # for C{geographiclib} compatibility
 
     def Direct3(self, lat1, lon1, azi1, s12):  # PYCHOK outmask
-        '''Return the destination lat, lon and reverse azimuth
-           (final bearing) in C{degrees}.
+        '''Return the destination lat, lon and reverse azimuth (final bearing)
+           in C{degrees}.
 
            @return: L{Destination3Tuple}C{(lat, lon, final)}.
         '''
@@ -203,6 +182,15 @@ class GeodesicSolve(_GeodesicSolveBase):
             ll2 = _unrollon(ll1, _Wrap.point(ll2))
         return self.InverseLine(ll1.lat, ll1.lon, ll2.lat, ll2.lon, **caps_name)
 
+#   def _InverseLine2(self, lat1, lon1, lat2, lon2, **caps_name):  # in .geodesici
+#       '''(INTERNAL) Helper for L{InverseLine} and L{_InverseLine}.
+#       '''
+#       r  = self.Inverse(lat1, lon1, lat2, lon2)
+#       gl = GeodesicLineSolve(self, lat1, lon1, r.azi1, **_name1__(caps_name, _or_nameof=self))
+#       gl._a13 = r.a12  # gl.SetArc(r.a12)
+#       gl._s13 = r.s12  # gl.SetDistance(r.s12)
+#       return gl, r
+
     def InverseLine(self, lat1, lon1, lat2, lon2, **caps_name):  # PYCHOK no cover
         '''Set up a L{GeodesicLineSolve} to compute several points
            on a single geodesic.
@@ -231,7 +219,7 @@ class GeodesicSolve(_GeodesicSolveBase):
         return gl
 
 
-class GeodesicLineSolve(_GeodesicSolveBase, _SolveLineBase):
+class GeodesicLineSolve(_GeodesicSolveBase, _SolveGDictLineBase):
     '''Wrapper to invoke I{Karney}'s U{GeodSolve<https://GeographicLib.SourceForge.io/C++/doc/GeodSolve.1.html>}
        as an C{Exact} version of I{Karney}'s Python class U{GeodesicLine<https://GeographicLib.SourceForge.io/C++/doc/
        python/code.html#geographiclib.geodesicline.GeodesicLine>}.
@@ -269,7 +257,7 @@ class GeodesicLineSolve(_GeodesicSolveBase, _SolveLineBase):
         _xinstanceof(GeodesicSolve, geodesic=geodesic)
         if (caps & Caps.LINE_OFF):  # copy to avoid updates
             geodesic = geodesic.copy(deep=False, name=_UNDER_(NN, geodesic.name))  # NOT _under!
-        _SolveLineBase.__init__(self, geodesic, lat1, lon1, caps, azi1=azi1, **name)
+        _SolveGDictLineBase.__init__(self, geodesic, lat1, lon1, caps, azi1=azi1, **name)
         try:
             self.GeodSolve = geodesic.GeodSolve  # geodesic or copy of geodesic
         except GeodesicError:
@@ -299,7 +287,7 @@ class GeodesicLineSolve(_GeodesicSolveBase, _SolveLineBase):
            @return: A C{GDict} with 12 items C{lat1, lon1, azi1, lat2, lon2,
                     azi2, m12, a12, s12, M12, M21, S12}.
         '''
-        return self._GDictInvoke(self._cmdArc, True, self._Names_Direct, a12)._unCaps(outmask)
+        return self._GDictInvoke(self._cmdArc, self._Names_Direct, a12)._unCaps(outmask)
 
     @Property_RO
     def azi1(self):
@@ -350,7 +338,7 @@ class GeodesicLineSolve(_GeodesicSolveBase, _SolveLineBase):
            @return: A C{GDict} with 12 items C{lat1, lon1, azi1, lat2, lon2,
                     azi2, m12, a12, s12, M12, M21, S12}, possibly C{a12=NAN}.
         '''
-        return self._GDictInvoke(self._cmdDistance, True, self._Names_Direct, s12)._unCaps(outmask)
+        return self._GDictInvoke(self._cmdDistance, self._Names_Direct, s12)._unCaps(outmask)
 
     @Property_RO
     def s13(self):
@@ -392,16 +380,16 @@ class GeodesicLineSolve(_GeodesicSolveBase, _SolveLineBase):
     def toStr(self, **prec_sep):  # PYCHOK signature
         '''Return this C{GeodesicLineSolve} as string.
 
-           @kwarg prec_sep: Keyword argumens C{B{prec}=6} and C{B{sep}=', '}
-                      for the C{float} C{prec}ision, number of decimal digits
-                      (0..9) and the C{sep}arator string to join.  Trailing
-                      zero decimals are stripped for B{C{prec}} values of
-                      1 and above, but kept for negative B{C{prec}} values.
+           @kwarg prec_sep: Keyword argumens C{B{prec}=6} and C{B{sep}=", "}
+                       for the C{float} C{prec}ision, number of decimal digits
+                       (0..9) and the C{sep}arator string to join.  Trailing
+                       zero decimals are stripped for B{C{prec}} values of 1
+                       and above, but kept for negative B{C{prec}} values.
 
            @return: GeodesicLineSolve items (C{str}).
         '''
-        return _SolveLineBase._toStr(self, azi1=self.azi1, geodesic=self._solve,
-                                           GeodSolve=self.GeodSolve, **prec_sep)
+        return _SolveGDictLineBase._toStr(self, azi1=self.azi1, geodesic=self._solve,
+                                                GeodSolve=self.GeodSolve, **prec_sep)
 
 
 __all__ += _ALL_DOCS(_GeodesicSolveBase)
@@ -415,7 +403,7 @@ if __name__ == '__main__':
     gS.verbose = '--verbose' in argv  # or '-v' in argv
 
     if gS.GeodSolve in (_PYGEODESY_GEODSOLVE_, None):  # not set
-        gS.GeodSolve = '/opt/local/bin/GeodSolve'  # '/opt/local/Cellar/geographiclib/1.51/bin/GeodSolve'  # HomeBrew
+        gS.GeodSolve = '/opt/local/bin/GeodSolve'  # '/opt/local/Cellar/geographiclib/2.3/bin/GeodSolve'  # HomeBrew
     printf('version: %s', gS.version)
 
     r = gS.Direct(40.6, -73.8, 51, 5.5e6)

pygeodesy/geoids.py

@@ -93,15 +93,14 @@ from pygeodesy.fmath import favg, Fdot, fdot, Fhorner, frange
 from pygeodesy.heights import _as_llis2, _ascalar, _height_called, HeightError, \
                               _HeightsBase,  _ellipsoidal_datum, _Wrap
 # from pygeodesy.internals import _version2  # _MODS
-from pygeodesy.interns import MISSING, NN, _4_, _COLONSPACE_, _COMMASPACE_, \
-                             _cubic_, _E_, _height_, _in_, _kind_, _lat_, \
-                             _linear_, _lon_, _mean_, _N_, _n_a_, _numpy_, \
-                             _on_, _outside_, _S_, _s_, _scipy_, _SPACE_, \
-                             _stdev_, _tbd_, _W_, _width_
+from pygeodesy.interns import MISSING, NN, _4_, _COLONSPACE_, _COMMASPACE_, _cubic_, \
+                             _E_, _height_, _in_, _kind_, _lat_, _linear_, _lon_, \
+                             _mean_, _N_, _n_a_, _numpy_, _on_, _outside_, _S_, _s_, \
+                             _scipy_, _SPACE_, _stdev_, _tbd_, _W_, _width_
 from pygeodesy.lazily import _ALL_DOCS, _ALL_LAZY, _ALL_MODS as _MODS, _FOR_DOCS
 from pygeodesy.named import _name__, _Named, _NamedTuple
 # from pygeodesy.namedTuples import LatLon3Tuple  # _MODS
-from pygeodesy.props import deprecated_method, Property_RO, property_RO
+from pygeodesy.props import deprecated_method, Property_RO, property_RO, property_ROver
 from pygeodesy.streprs import attrs, Fmt, fstr, pairs
 from pygeodesy.units import Height, Int_, Lat, Lon
 # from pygeodesy.utily import _Wrap  # from .heights
@@ -118,7 +117,7 @@ except ImportError:  # Python 3+
     from io import BytesIO as _BytesIO  # PYCHOK expected
 
 __all__ = _ALL_LAZY.geoids
-__version__ = '24.06.11'
+__version__ = '24.07.12'
 
 _assert_ = 'assert'
 _bHASH_  =  b'#'
@@ -473,12 +472,11 @@ class _GeoidBase(_HeightsBase):
         '''(INTERNAL) I{Must be overloaded}.'''
         self._notOverloaded(lat, lon)
 
-    @property_RO
+    @property_ROver
     def _LL3T(self):
         '''(INTERNAL) Get L{LatLon3Tuple}, I{once}.
         '''
-        _GeoidBase._LL3T = T = _MODS.namedTuples.LatLon3Tuple  # overwrite poperty_RO
-        return T
+        return _MODS.namedTuples.LatLon3Tuple  # overwrite property_ROver
 
     def _llh3(self, lat, lon):
         return self._LL3T(lat, lon, self._hGeoid(lat, lon), name=self.name)

pygeodesy/internals.py

@@ -4,9 +4,9 @@ u'''Mostly INTERNAL functions, except L{machine}, L{print_} and L{printf}.
 '''
 # from pygeodesy.basics import isiterablen  # _MODS
 # from pygeodesy.errors import _AttributeError, _error_init, _UnexpectedError, _xError2  # _MODS
-from pygeodesy.interns import NN, _COLON_, _DOT_, _ELLIPSIS_, _EQUALSPACED_, \
-                             _immutable_, _NL_, _pygeodesy_, _PyPy__, _python_, \
-                             _QUOTE1_, _QUOTE2_, _s_, _SPACE_, _sys, _UNDER_, _utf_8_
+from pygeodesy.interns import NN, _BAR_, _COLON_, _DASH_, _DOT_, _ELLIPSIS_, _EQUALSPACED_, \
+                             _immutable_, _NL_, _pygeodesy_, _PyPy__, _python_, _QUOTE1_, \
+                             _QUOTE2_, _s_, _SPACE_, _sys, _UNDER_, _utf_8_
 from pygeodesy.interns import _COMMA_, _Python_  # PYCHOK used!
 # from pygeodesy.streprs import anstr, pairs, unstr  # _MODS
 
@@ -360,10 +360,10 @@ def _passargs(*args):
     return args
 
 
-def _plural(noun, n):
+def _plural(noun, n, nn=NN):
     '''(INTERNAL) Return C{noun}['s'] or C{NN}.
     '''
-    return NN(noun, _s_) if n > 1 else (noun if n else NN)
+    return NN(noun, _s_) if n > 1 else (noun if n else nn)
 
 
 def print_(*args, **nl_nt_prec_prefix__end_file_flush_sep__kwds):  # PYCHOK no cover
@@ -504,17 +504,44 @@ def _under(name):  # PYCHOK in .datums, .auxilats, .ups, .utm, .utmupsBase, ...
     return name if name.startswith(_UNDER_) else NN(_UNDER_, name)
 
 
-def _usage(file_py, *args):  # in .etm
+def _usage(file_py, *args, **opts_help):  # in .etm, .geodesici
     '''(INTERNAL) Build "usage: python -m ..." cmd line for module B{C{file_py}}.
     '''
-    m = _os_path.dirname(file_py).replace(_os.getcwd(), _ELLIPSIS_) \
-                                 .replace(_os.sep, _DOT_).strip()
-    b, x = _os_path.splitext(_os_path.basename(file_py))
+    if opts_help:
+
+        def _help(alts=(), help=NN, **unused):
+            if alts and help:
+                h = NN(help, _SPACE_).lstrip(_DASH_)
+                for a in alts:
+                    if a.startswith(h):
+                        return NN(_DASH_, a),
+
+        def _opts(opts=NN, alts=(), **unused):
+            # opts='T--v-C-R meter-c|i|n|o'
+            d, fmt = NN, _MODS.streprs.Fmt.SQUARE
+            for o in (opts + _BAR_(*alts)).split(_DASH_):
+                if o:
+                    yield fmt(NN(d, _DASH_, o.replace(_BAR_, ' | -')))
+                    d =  NN
+                else:
+                    d = _DASH_
+
+        args = _help(**opts_help) or (tuple(_opts(**opts_help)) + args)
+
+    u = _COLON_(_dunder_nameof(_usage)[1:], NN)
+    return _SPACE_(u, *_usage_argv(file_py, *args))
+
+
+def _usage_argv(argv0, *args):
+    '''(INTERNAL) Return 3-tuple C{(python, '-m', module, *args)}.
+    '''
+    m = _os_path.dirname(argv0).replace(_os.getcwd(), _ELLIPSIS_) \
+                               .replace(_os.sep, _DOT_).strip()
+    b, x = _os_path.splitext(_os_path.basename(argv0))
     if x == '.py' and not _dunder_ismain(b):
         m = _DOT_(m or _pygeodesy_, b)
-    p =  NN(_python_, _sys.version_info[0])
-    u = _COLON_(_dunder_nameof(_usage)[1:], NN)
-    return _SPACE_(u, p, '-m', _enquote(m), *args)
+    p = NN(_python_, _sys.version_info[0])
+    return (p, '-m', _enquote(m)) + args
 
 
 def _version2(version, n=2):
@@ -550,7 +577,7 @@ def _version_ints(vs):
 
 
 __all__ = tuple(map(_dunder_nameof, (machine, print_, printf)))
-__version__ = '24.06.05'
+__version__ = '24.07.04'
 
 if _dunder_ismain(__name__):  # PYCHOK no cover