pygeodesy 24.7.7__py2.py3-none-any.whl → 24.8.4__py2.py3-none-any.whl

pygeodesy/lazily.py

@@ -31,8 +31,7 @@ from pygeodesy import internals as _internals, interns as _interns, \
                      _isfrozen  # DON'T _lazy_import2
 # from pygeodesy.errors import _error_init, _xkwds_item2  # _ALL_MODS
 from pygeodesy.internals import _caller3, _dunder_nameof, _dunder_ismain, \
-                                _headof, _osversion2, printf, _Pythonarchine, \
-                                _tailof  # _Property_RO
+                                _headof, printf, _Pythonarchine, _tailof  # _Property_RO
 from pygeodesy.interns import NN, _attribute_, _by_, _COLONSPACE_, _COMMASPACE_, \
                              _doesn_t_exist_, _DOT_, _EQUALSPACED_, _from_, \
                              _HASH_, _immutable_, _line_, _module_, _no_, _not_, \
@@ -284,13 +283,13 @@ _ALL_LAZY = _NamedEnum_RO(_name='_ALL_LAZY',
                           fsums=_i('Fsum', 'DivMod2Tuple', 'Fsum2Tuple', 'ResidualError',
                                    'fsum', 'fsum_', 'fsumf_', 'fsum1', 'fsum1_', 'fsum1f_'),
                            gars=_i('Garef', 'GARSError'),
-                      geodesici=_i('Intersectool', 'Intersectool5Tuple', 'Middle5Tuple',
-                                   'Intersector',  'Intersector5Tuple',  'XDict'),
+                      geodesici=_i('Intersectool', 'Intersectool5Tuple', 'Intersect7Tuple',
+                                   'Intersector',  'Intersector5Tuple',  'Middle5Tuple', 'XDict'),
                       geodesicw=_i('Geodesic', 'GeodesicLine', 'Geodesic_WGS84'),
                       geodesicx=_i('gx', 'gxarea', 'gxbases', 'gxline',  # modules
                                    'GeodesicAreaExact', 'GeodesicExact', 'GeodesicLineExact', 'PolygonArea'),
                       geodsolve=_i('GeodesicSolve', 'GeodesicLineSolve', 'GeodSolve12Tuple'),
-                        geohash=_i('Geohash', 'GeohashError', 'Neighbors8Dict', 'Resolutions2Tuple'),
+                        geohash=_i('Geohash', 'Geohashed', 'GeohashError', 'Neighbors8Dict', 'Resolutions2Tuple', 'Sizes3Tuple'),
                          geoids=_i('GeoidError', 'GeoidG2012B', 'GeoidKarney', 'GeoidPGM', 'egmGeoidHeights',
                                    'PGMError', 'GeoidHeight5Tuple'),
                       hausdorff=_i('Hausdorff', 'HausdorffDegrees', 'HausdorffError', 'HausdorffRadians',
@@ -343,7 +342,8 @@ _ALL_LAZY = _NamedEnum_RO(_name='_ALL_LAZY',
                                    'areaOf', 'boundsOf', 'centroidOf', 'fractional',
                                    'isclockwise', 'isconvex', 'isconvex_', 'isenclosedBy', 'ispolar',
                                    'luneOf', 'nearestOn5', 'perimeterOf', 'quadOf'),
-                          props=_i('Property', 'Property_RO', 'property_RO', 'property_doc_',
+                          props=_i('Property', 'Property_RO', 'property_doc_',
+                                   'property_RO', 'property_ROnce', 'property_ROver',
                                    'deprecated_class', 'deprecated_function', 'deprecated_method',
                                    'deprecated_Property_RO', 'deprecated_property_RO', 'DeprecationWarnings'),
                      resections=_i('Collins5Tuple', 'ResectionError', 'Survey3Tuple', 'Tienstra7Tuple',
@@ -367,7 +367,7 @@ _ALL_LAZY = _NamedEnum_RO(_name='_ALL_LAZY',
                       triaxials=_i('BetaOmega2Tuple', 'BetaOmega3Tuple', 'Jacobi2Tuple',
                                    'JacobiConformal', 'JacobiConformalSpherical',
                                    'Triaxial', 'Triaxial_', 'TriaxialError', 'Triaxials', 'hartzell4'),
-                          units=_i('Band', 'Bearing', 'Bearing_', 'Bool',
+                          units=_i('Azimuth', 'Band', 'Bearing', 'Bearing_', 'Bool',
                                    'Degrees', 'Degrees_', 'Degrees2', 'Distance', 'Distance_', 'Easting', 'Epoch',
                                    'Feet', 'FIx', 'Float_', 'Height', 'Height_', 'HeightX', 'Int_',
                                    'Lam', 'Lamd', 'Lat', 'Lat_', 'Lon', 'Lon_',
@@ -521,7 +521,7 @@ class _ALL_MODS(_internals._MODS_Base):
 _internals._MODS = _ALL_MODS = _ALL_MODS()  # PYCHOK singleton
 
 __all__ = _ALL_LAZY.lazily
-__version__ = '24.07.09'
+__version__ = '24.08.01'
 
 
 def _ALL_OTHER(*objs):
@@ -861,13 +861,13 @@ def _lazy_module(name):  # overwritten by _lazy_import2
 #
 #     return _ALL_OTHER(*sm.values())
 
-
 # del _i, _i0
 
 # _ = _ALL_MODS.errors  # force import pygeodesy.errors
 
 if _dunder_ismain(__name__):  # PYCHOK no cover
 
+    from pygeodesy.internals import _versions
     from timeit import timeit
 
     def t1():
@@ -881,22 +881,24 @@ if _dunder_ismain(__name__):  # PYCHOK no cover
 
     t1 = timeit(t1, number=1000000)
     t2 = timeit(t2, number=1000000)
-    v = _SPACE_.join(_Pythonarchine() + _osversion2())
-    printf('%.6f import vs %.6f _ALL_MODS: %.2fX, %s', t1, t2, t1 / t2, v)
+    printf('%.6f import vs %.6f _ALL_MODS: %.2fX, %s', t1, t2, t1 / t2, _versions())
 
 #   del t1, t2, timeit, v
 
-# python3.12 -W ignore -m pygeodesy.lazily
-# 0.145177 import vs 0.075402 _ALL_MODS: 1.93X, Python 3.12.3 64bit arm64 macOS 14.4.1
+# % python3.13 -W ignore -m pygeodesy.lazily
+# 0.102670 import vs 0.076113 _ALL_MODS: 1.35X, pygeodesy 24.8.4 Python 3.13.0b4 64bit arm64 macOS 14.5
+
+# % python3.12 -W ignore -m pygeodesy.lazily
+# 0.132801 import vs 0.079125 _ALL_MODS: 1.68X, pygeodesy 24.8.4 Python 3.12.4 64bit arm64 macOS 14.5
 
-# python3.11 -W ignore -m pygeodesy.lazily
-# 0.381723 import vs 0.251589 _ALL_MODS: 1.52X, Python 3.11.5 64bit arm64 macOS 14.4.1
+# % python3.11 -W ignore -m pygeodesy.lazily
+# 0.381723 import vs 0.251589 _ALL_MODS: 1.52X, pygeodesy 24.8.4 Python 3.11.5 64bit arm64 macOS 14.4.1
 
-# python3.10 -W ignore -m pygeodesy.lazily
-# 0.378293 import vs 0.266507 _ALL_MODS: 1.42X, Python 3.10.8 64bit arm64 macOS 14.4.1
+# % python3.8 -W ignore -m pygeodesy.lazily
+# 0.570353 import vs 0.382842 _ALL_MODS: 1.49X, pygeodesy 24.8.4 Python 3.8.10 64bit arm64_x86_64 macOS 10.16
 
-# python2 -m pygeodesy.lazily
-# 1.213805 import vs 0.474075 _ALL_MODS: 2.56X, Python 2.7.18 64bit arm64_x86_64 macOS 10.16
+# % python2 -m pygeodesy.lazily
+# 1.213805 import vs 0.474075 _ALL_MODS: 2.56X, pygeodesy 24.8.4 Python 2.7.18 64bit arm64_x86_64 macOS 10.16
 
 # **) MIT License
 #

pygeodesy/ltp.py

@@ -33,8 +33,8 @@ from pygeodesy.ltpTuples import Attitude4Tuple, ChLVEN2Tuple, ChLV9Tuple, \
                                 ChLVyx2Tuple, _XyzLocals4, _XyzLocals5, Xyz4Tuple
 from pygeodesy.named import _name__, _name2__, _NamedBase, notOverloaded
 from pygeodesy.namedTuples import LatLon3Tuple, LatLon4Tuple, Vector3Tuple
-from pygeodesy.props import Property, Property_RO, property_doc_, property_RO, \
-                           _update_all
+from pygeodesy.props import Property, Property_RO, property_doc_, \
+                            property_ROver, _update_all
 from pygeodesy.streprs import Fmt, strs, unstr
 from pygeodesy.units import Bearing, Degrees, _isHeight, Meter
 from pygeodesy.utily import cotd, _loneg, sincos2d, sincos2d_, tand, tand_, \
@@ -44,7 +44,7 @@ from pygeodesy.vector3d import _ALL_LAZY, Vector3d
 # from math import fabs, floor as _floor  # from .fmath, .fsums
 
 __all__ = _ALL_LAZY.ltp
-__version__ = '24.06.11'
+__version__ = '24.07.25'
 
 _height0_ = _height_ + _0_
 _narrow_  = 'narrow'
@@ -722,15 +722,15 @@ class _ChLV(object):
         t = Y_X_h_lat_lon_h + (self, self._t0, None)  # PYCHOK _t0
         return ChLV9Tuple(t, name=name)
 
-    @property_RO
+    @property_ROver
     def _enh_n_h(self):
         '''(INTERNAL) Get C{ChLV*.reverse} args[1:4] names, I{once}.
         '''
-        _ChLV._enh_n_h = t = _args_kwds_names(_ChLV.reverse)[1:4]  # overwrite property_RO
+        t = _args_kwds_names(_ChLV.reverse)[1:4]
         # assert _args_kwds_names( ChLV.reverse)[1:4] == t
         # assert _args_kwds_names(ChLVa.reverse)[1:4] == t
         # assert _args_kwds_names(ChLVe.reverse)[1:4] == t
-        return t
+        return t  # overwrite property_ROver
 
     def forward(self, latlonh, lon=None, height=0, M=None, **name):  # PYCHOK no cover
         '''Convert WGS84 geodetic to I{Swiss} projection coordinates.  I{Must be overloaded}.

pygeodesy/ltpTuples.py

@@ -28,15 +28,15 @@ from pygeodesy.namedTuples import LatLon2Tuple, PhiLam2Tuple, Vector3Tuple
 from pygeodesy.props import deprecated_method, deprecated_Property_RO, \
                             Property_RO, property_RO
 from pygeodesy.streprs import Fmt, fstr, strs, _xzipairs
-from pygeodesy.units import Bearing, Degrees, Degrees_, Height, _isDegrees, \
-                           _isMeter, Lat, Lon, Meter, Meter_
+from pygeodesy.units import Azimuth, Bearing, Degrees, Degrees_, Height, \
+                           _isDegrees, _isMeter, Lat, Lon, Meter, Meter_
 from pygeodesy.utily import atan2d, atan2b, sincos2_, sincos2d_,  cos, radians
 from pygeodesy.vector3d import Vector3d
 
 # from math import cos, radians  # from .utily
 
 __all__ = _ALL_LAZY.ltpTuples
-__version__ = '24.06.28'
+__version__ = '24.07.25'
 
 _aer_        = 'aer'
 _alt_        = 'alt'
@@ -93,7 +93,7 @@ def _xyz2aer4(inst):
     '''(INTERNAL) Convert C{(x, y, z}) to C{(A, E, R)}.
     '''
     x, y, z, _ = inst.xyz4
-    A = Bearing(azimuth=atan2b(x, y))
+    A = Azimuth(atan2b(x, y))
     E = Degrees(elevation=atan2d(z, hypot(x, y)))
     R = Meter(slantrange=hypot_(x, y, z))
     return Aer4Tuple(A, E, R, inst.ltp, name=inst.name)
@@ -268,7 +268,7 @@ class Aer(_AbcBase):
         '''
         if _isDegrees(azimuth_aer):
             aer =  None
-            t   = (Bearing(azimuth=azimuth_aer),
+            t   = (Azimuth(azimuth_aer),
                    Degrees_(elevation=elevation, low=_N_90_0, high=_90_0),
                    Meter_(slantrange=slantrange), ltp)
         else:  # PYCHOK no cover
@@ -421,7 +421,7 @@ class Attitude4Tuple(_NamedTuple):
        the attitude of a plane or camera.
     '''
     _Names_ = (_alt_, _tilt_,  _yaw_,   _roll_)
-    _Units_ = ( Meter, Bearing, Degrees, Degrees)
+    _Units_ = ( Meter, Degrees, Bearing, Degrees)
 
     @Property_RO
     def atyr(self):

pygeodesy/named.py

@@ -34,7 +34,7 @@ from pygeodesy.streprs import attrs, Fmt, lrstrip, pairs, reprs, unstr
 # from pygeodesy.units import _toUnit  # _MODS
 
 __all__ = _ALL_LAZY.named
-__version__ = '24.06.24'
+__version__ = '24.07.12'
 
 _COMMANL_           = _COMMA_ + _NL_
 _COMMASPACEDOT_     = _COMMASPACE_ + _DOT_
@@ -1231,9 +1231,9 @@ def modulename(clas, prefixed=None):  # in .basics._xversion
        @return: The B{C{class}}'s C{[module.]class} name (C{str}).
     '''
     try:
-        n =  clas.__name__
+        n = clas.__name__
     except AttributeError:
-        n = _dunder_name_
+        n = clas if isstr(clas) else _dunder_name_
     if prefixed or (classnaming() if prefixed is None else False):
         try:
             m =  clas.__module__.rsplit(_DOT_, 1)

pygeodesy/nvectorBase.py

@@ -29,7 +29,7 @@ from pygeodesy.named import _xother3,  _under
 from pygeodesy.namedTuples import Trilaterate5Tuple, Vector3Tuple, \
                                   Vector4Tuple,  map1
 from pygeodesy.props import deprecated_method, Property_RO, property_doc_, \
-                            property_RO, _update_all
+                            property_RO, property_ROnce, _update_all
 from pygeodesy.streprs import Fmt, hstr, unstr
 from pygeodesy.units import Bearing, Height, Radius_, Scalar
 from pygeodesy.utily import sincos2d, _unrollon, _unrollon3
@@ -38,7 +38,7 @@ from pygeodesy.vector3d import Vector3d, _xyzhdlln4
 from math import fabs, sqrt
 
 __all__ = _ALL_LAZY.nvectorBase
-__version__ = '24.06.12'
+__version__ = '24.07.12'
 
 
 class NvectorBase(Vector3d):  # XXX kept private
@@ -78,12 +78,11 @@ class NvectorBase(Vector3d):  # XXX kept private
         '''
         return self._datum
 
-    @property_RO
+    @property_ROnce
     def Ecef(self):
         '''Get the ECEF I{class} (L{EcefKarney}), I{once}.
         '''
-        NvectorBase.Ecef = E = _MODS.ecef.EcefKarney  # overwrite property_RO
-        return E
+        return _MODS.ecef.EcefKarney
 
     @property_RO
     def ellipsoidalNvector(self):

pygeodesy/props.py

@@ -25,7 +25,7 @@ from pygeodesy.lazily import _ALL_LAZY, _ALL_MODS as _MODS, \
 from functools import wraps as _wraps
 
 __all__ = _ALL_LAZY.props
-__version__ = '24.05.26'
+__version__ = '24.07.23'
 
 _class_       = 'class'
 _dont_use_    = _DEPRECATED_ + ", don't use."
@@ -48,11 +48,12 @@ def _allPropertiesOf(Clas_or_inst, *Bases, **excls):
         except AttributeError:
             raise
             S = ()  # not an inst
-    B    = Bases or _PropertyBase
-    _isa = isinstance
+    B =  Bases or _PropertyBase
+    P = _property_RO___
     for C in S:
         for n, p in C.__dict__.items():
-            if _isa(p, B) and p.name == n and n not in excls:
+            if isinstance(p, B) and p.name == n and not (
+               isinstance(p, P) or n in excls):
                 yield p
 
 
@@ -251,9 +252,9 @@ class Property_RO(_PropertyBase):
                  <https://Docs.Python.org/3/library/functools.html#functools.cache>}
                  to I{cache} or I{memoize} the property value.
 
-           @see: Luciano Ramalho, "Fluent Python", O'Reilly, Example 19-24, 2016
-                 p. 636 or Example 22-28, 2022 p. 870 and U{class Property
-                 <https://docs.Python.org/3/howto/descriptor.html>}.
+           @see: Luciano Ramalho, "Fluent Python", O'Reilly, 2016 p. 636
+                 Example 19-24 or 2022 p. 870 Example 22-28 and U{class
+                 Property<https://docs.Python.org/3/howto/descriptor.html>}.
         '''
         _fget = method if _FOR_DOCS else self._fget  # XXX force method.__doc__ to epydoc
         _PropertyBase.__init__(self, method, _fget, self._fset_error)
@@ -355,6 +356,61 @@ class property_RO(_PropertyBase):
                 inst.__dict__.pop(uname)
 
 
+class _property_RO___(_PropertyBase):
+    # No __doc__ on purpose
+
+    def __init__(self, method, doc=NN):  # PYCHOK expected
+        '''New C{property_ROnce} or C{property_ROver}, holding a singleton value as
+           class attribute for all instances of that class and overwriting C{self},
+           the C{property_ROver} instance in the 1st invokation.
+
+           @see: L{property_RO} for further details.
+        '''
+        _PropertyBase.__init__(self, method, self._fget, self._fset_error, doc=doc)
+
+    def _fdel(self, unused):  # PYCHOK no cover
+        '''Silently ignored, always.
+        '''
+        pass
+
+    def _update(self, *unused):  # PYCHOK signature
+        '''(INTERNAL) No-op, ignore updates.
+        '''
+        pass
+
+
+class property_ROnce(_property_RO___):
+    # No __doc__ on purpose
+
+    def _fget(self, inst):
+        '''Get the C{property} value, only I{once} and memoize/cache it.
+        '''
+        try:
+            v = self._val
+        except AttributeError:
+            v = self._val = self.method(inst)
+        return v
+
+
+class property_ROver(_property_RO___):
+    # No __doc__ on purpose
+
+    def _fget(self, inst):
+        '''Get the C{property} value I{once} and overwrite C{self}, this C{property} instance.
+        '''
+        v = self.method(inst)
+        n = self.name
+        C = inst.__class__
+        for c in C.__mro__:  # [:-1]
+            if getattr(c, n, None) is self:
+                setattr(c, n, v)  # overwrite property_ROver
+                break
+        else:
+            n = _DOT_(C.__name__, n)
+            raise _AssertionError(_EQUALSPACED_(n, v))
+        return v
+
+
 class _NamedProperty(property):
     '''Class C{property} with retrievable name.
     '''
@@ -372,16 +428,18 @@ def property_doc_(doc):
 
        @example:
 
-        >>> @property_doc_("documentation text.")
-        >>> def name(self):
-        >>>     ...
+        >>>class Clas(object):
+        >>>
+        >>>     @property_doc_("documentation text.")
+        >>>     def name(self):
+        >>>         ...
         >>>
-        >>> @name.setter
-        >>> def name(self, value):
-        >>>     ...
+        >>>     @name.setter
+        >>>     def name(self, value):
+        >>>         ...
     '''
-    # See Luciano Ramalho, "Fluent Python", O'Reilly, Example 7-23,
-    # 2016 p. 212+, 2022 p. 331+, Example 9-22 and <https://
+    # See Luciano Ramalho, "Fluent Python", O'Reilly, 2016 p. 212+
+    # Example 7-23 or 2022 p. 331+ Example 9-22 and <https://
     # Python-3-Patterns-Idioms-Test.ReadTheDocs.io/en/latest/PythonDecorators.html>
 
     def _documented_property(method):
@@ -396,8 +454,8 @@ def property_doc_(doc):
 def _deprecated(call, kind, qual_d):
     '''(INTERNAL) Decorator for DEPRECATED functions, methods, etc.
 
-       @see: Brett Slatkin, "Effective Python", page 105, 2nd ed,
-             Addison-Wesley, 2019.
+       @see: Brett Slatkin, "Effective Python", 2019 page 105, 2nd
+             ed, Addison-Wesley.
     '''
     doc = _docof(call)
 

pygeodesy/rhumb/solve.py

@@ -21,7 +21,7 @@ from pygeodesy.solveBase import _SolveGDictBase, _SolveGDictLineBase
 from pygeodesy.utily import _unrollon, _Wrap, wrap360
 
 __all__ = _ALL_LAZY.rhumb_solve
-__version__ = '24.06.28'
+__version__ = '24.07.11'
 
 
 class _RhumbSolveBase(_SolveGDictBase):
@@ -173,7 +173,7 @@ class RhumbSolve(_RhumbSolveBase):
         return r
 
     def _GDictInverse(self, lat1, lon1, lat2, lon2, *unused, **floats):  # PYCHOK signature
-        '''(INTERNAL) Get C{_GenInverse}-like result as an 8-item C{GDict}, but I{without} C{_S_CALPs_}.
+        '''(INTERNAL) Get C{_GenInverse}-like result as an 8-item C{GDict}, but I{without} C{_SALP_CALPs_}.
         '''
         i = _RhumbSolveBase._GDictInverse(self, lat1, lon1, lat2, lon2, **floats)
         a = _over(float(i.s12), self._mpd)  # for .Inverse1

pygeodesy/solveBase.py

@@ -11,8 +11,9 @@ from pygeodesy.datums import _earth_datum, _WGS84,  _EWGS84
 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
@@ -24,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.07.08'
+__version__ = '24.07.11'
 
 _ERROR_     = 'ERROR'
 _Popen_kwds =  dict(creationflags=0,
@@ -54,7 +55,7 @@ def _cmd_stdin_(cmd, stdin):  # PYCHOK no cover
 
 def _popen2(cmd, stdin=None):  # in .mgrs, test.bases, .testMgrs
     '''(INTERNAL) Invoke C{B{cmd} tuple} and return C{exitcode}
-       and all output from C{stdout/-err}.
+       and all output from C{stdout/-err}, I{stripped}.
     '''
     p = _Popen(cmd, **_Popen_kwds)  # PYCHOK kwArgs
     r =  p.communicate(stdin)[0]  # stdout + NL + stderr
@@ -67,6 +68,7 @@ class _SolveCapsBase(_CapsBase):
     _datum      = _WGS84
     _Error      =  None
     _Exact      =  True
+    _invokat    = _AT_
     _invokation =  0
     _linelimit  =  0
     _prec       =  Precision_(prec=DIG)
@@ -100,7 +102,7 @@ class _SolveCapsBase(_CapsBase):
             v = map(float, v)  # _float_int, see Intersectool._XDistInvoke
         return Dict(_zip(n, v))  # strict=True
 
-    def _DictInvoke2(self, cmd, Names, Dict, args, **floats_R):
+    def _DictInvoke2(self, cmd, args, Names, Dict, **floats_R):
         '''(INTERNAL) Invoke C{Solve}, return results as C{Dict}.
         '''
         N = len(Names)
@@ -172,6 +174,16 @@ class _SolveCapsBase(_CapsBase):
 
     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):
         '''Get the most recent C{Solve} invokation number (C{int}).
@@ -223,7 +235,7 @@ class _SolveCapsBase(_CapsBase):
             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))
+            self._print(repr(r), 'stdout/-err')
         return r
 
     def linelimit(self, *limit):
@@ -268,14 +280,16 @@ 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)
+            s    = _COMMASPACE_(self.status, *suffix)
+            line = _SPACE_(line, Fmt.PAREN(s))
+        p = NN(self.named2, self._invokat, self.invokation)
+        printf(_COLONSPACE_(p, line))
 
     def _setXable(self, path, **Xable_path):
         '''(INTERNAL) Set the executable C{path}.
@@ -411,7 +425,7 @@ class _SolveGDictBase(_SolveBase):
                                                   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{_S_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)
@@ -419,7 +433,7 @@ class _SolveGDictBase(_SolveBase):
     def _GDictInvoke(self, cmd,  Names, *args, **floats):
         '''(INTERNAL) Invoke C{Solve}, return results as C{Dict}.
         '''
-        return self._DictInvoke2(cmd, Names, GDict, args, **floats)[0]  # _R
+        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.
@@ -456,7 +470,7 @@ class _SolveGDictLineBase(_SolveGDictBase):
         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

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.29'
 
 _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 property_ROver
 
     def hartzell4(self, pov, los=False, **name):
         '''Compute the intersection of this triaxial's surface with a Line-Of-Sight
@@ -754,7 +753,7 @@ class Triaxial(Triaxial_):
         return self.height4(x_xyz, y, z, **normal_eps_name)
 
     def forwardLatLon(self, lat, lon, height=0, **name):
-        '''Convert I{geodetic} lat-, longitude and heigth to cartesian.
+        '''Convert I{geodetic} lat-, longitude and height to cartesian.
 
            @arg lat: Geodetic latitude (C{degrees}).
            @arg lon: Geodetic longitude (C{degrees}).
@@ -770,7 +769,7 @@ class Triaxial(Triaxial_):
         return self._forwardLatLon3(height, name, *sincos2d_(lat, lon))
 
     def forwardLatLon_(self, slat, clat, slon, clon, height=0, **name):
-        '''Convert I{geodetic} lat-, longitude and heigth to cartesian.
+        '''Convert I{geodetic} lat-, longitude and height to cartesian.
 
            @arg slat: Geodetic latitude C{sin(lat)} (C{scalar}).
            @arg clat: Geodetic latitude C{cos(lat)} (C{scalar}).