pygeodesy 25.8.25__py2.py3-none-any.whl → 25.10.10__py2.py3-none-any.whl

pygeodesy/internals.py

@@ -4,10 +4,10 @@
 u'''Mostly INTERNAL functions, except L{machine}, L{print_} and L{printf}.
 '''
 # from pygeodesy.basics import isiterablen, ubstr  # _MODS
-# from pygeodesy.errors import _AttributeError, _error_init, _UnexpectedError, _xError2  # _MODS
-from pygeodesy.interns import _BAR_, _COLON_, _DASH_, _DMAIN_, _DOT_, _ELLIPSIS_, _EQUALSPACED_, \
-                              _immutable_, _NL_, NN, _pygeodesy_, _PyPy__, _python_, _QUOTE1_, \
-                              _QUOTE2_, _s_, _SPACE_, _sys, _UNDER_
+# from pygeodesy.errors import _AttributeError, _error_init, _ImmutableError, _UnexpectedError, _xError2  # _MODS
+from pygeodesy.interns import _BAR_, _COLON_, _DASH_, _DMAIN_, _DOT_, _ELLIPSIS_, _NL_, NN, \
+                              _pygeodesy_, _PyPy__, _python_, _QUOTE1_, _QUOTE2_, _s_, _sys, \
+                              _SPACE_, _UNDER_
 from pygeodesy.interns import _COMMA_, _Python_  # PYCHOK used!
 # from pygeodesy.streprs import anstr, pairs, unstr  # _MODS
 
@@ -56,6 +56,27 @@ def _Property_RO(method):
     return property(_get, _set, _del)
 
 
+class _Enum(object):  # in .elliptic, .utily
+    '''(INTERNAL) Enum-like, immutable items.
+    '''
+    # _ImmutableError = None
+
+    def __init__(self, **enums):
+        self.__dict__.update(enums)
+        # for item in enums.items():
+        #     setattr(self, *item)  # object.__setattr__
+
+    def __str__(self):
+        _unstr = _MODS.streprs.unstr
+        return _unstr(_Enum, **self.__dict__)
+
+    # def __delattr__(self, attr):  # PYCHOK no cover
+        # raise _ImmutableError(self, attr)  # _del_
+
+    # def __setattr__(self, attr, value):  # PYCHOK no cover
+        # raise _ImmutableError(self, attr, value)
+
+
 class _MODS_Base(object):
     '''(INTERNAL) Base-class for C{lazily._ALL_MODS}.
     '''
@@ -63,10 +84,7 @@ class _MODS_Base(object):
         self.__dict__.pop(attr, None)
 
     def __setattr__(self, attr, value):  # PYCHOK no cover
-        e = _MODS.errors
-        n = _DOT_(self.name, attr)
-        t = _EQUALSPACED_(n, repr(value))
-        raise e._AttributeError(_immutable_, txt=t)
+        raise _ImmutableError(self, attr, value)
 
     @_Property_RO
     def basics(self):
@@ -184,7 +202,7 @@ class _MODS_Base(object):
                      (_macOS_,   p.mac_ver),
                      (_Windows_, p.win32_ver),
                      (_Nix,  _MODS.nix_ver),
-                     ('Java',    p.java_ver),
+# removed Py 3.15    ('Java',    p.java_ver),
                      ('uname',   p.uname)):
             v = v()[0]
             if v and n:
@@ -302,6 +320,12 @@ def _headof(name):
     return name if i < 0 else name[:i]
 
 
+def _ImmutableError(*inst_attr_value):
+    '''(INTERNAL) Format an C{_ImmutableError}.
+    '''
+    return _MODS.errors._ImmutableError(*inst_attr_value)
+
+
 # def _is(a, b):  # PYCHOK no cover
 #     '''(INTERNAL) C{a is b}? in C{PyPy}
 #     '''
@@ -473,10 +497,10 @@ def printf(fmt, *args, **nl_nt_prec_prefix__end_file_flush_sep__kwds):
         else:
             t =  fmt
     except Exception as x:
-        _E, s = _MODS.errors._xError2(x)
-        unstr = _MODS.streprs.unstr
-        t = unstr(printf, fmt, *args, **nl_nt_prec_prefix__end_file_flush_sep__kwds)
-        raise _E(s, txt=t, cause=x)
+        _Error, s = _MODS.errors._xError2(x)
+        _unstr    = _MODS.strepr.unstr
+        t = _unstr(printf, fmt, *args, **nl_nt_prec_prefix__end_file_flush_sep__kwds)
+        raise _Error(s, txt=t, cause=x)
     try:
         n = f.write(NN(b, t, e))
     except UnicodeEncodeError:  # XXX only Windows
@@ -635,11 +659,10 @@ def _usage_argv(argv0, *args):
     '''(INTERNAL) Return 3-tuple C{(python, '-m', module, *args)}.
     '''
     o = _MODS.os
-    m =  o.path.dirname(argv0)
-    m =  m.replace(o.getcwd(), _ELLIPSIS_) \
-          .replace(o.sep,      _DOT_).strip()
-    b =  o.path.basename(argv0)
-    b, x = o.path.splitext(b)
+    p =  o.path
+    m =  p.dirname(argv0).replace(o.getcwd(), _ELLIPSIS_) \
+                         .replace(o.sep,      _DOT_).strip()
+    b, x = p.splitext(p.basename(argv0))
     if x == '.py' and b != _DMAIN_:
         m = _DOT_(m or _pygeodesy_, b)
     p = NN(_python_, _MODS.sys_version_info2[0])
@@ -686,7 +709,7 @@ def _versions(sep=_SPACE_):
 
 
 __all__ = tuple(map(typename, (machine, print_, printf, typename)))
-__version__ = '25.08.18'
+__version__ = '25.10.06'
 
 if __name__ == _DMAIN_:
 

pygeodesy/karney.py

@@ -145,8 +145,8 @@ from __future__ import division as _; del _  # noqa: E702 ;
 
 from pygeodesy.basics import _copysign, _isin, isint, neg, unsigned0, \
                              _xgeographiclib, _zip
-from pygeodesy.constants import NAN, _isfinite as _math_isfinite, _0_0, \
-                               _1_16th, _1_0, _2_0, _180_0, _N_180_0, _360_0
+from pygeodesy.constants import NAN, _isfinite as _math_isfinite, \
+                               _0_0, _1_0, _2_0, _180_0, _N_180_0, _360_0
 from pygeodesy.errors import GeodesicError, _ValueError, _xkwds
 from pygeodesy.fmath import cbrt, fremainder, norm2  # Fhorner, Fsum
 from pygeodesy.internals import _getenv, _popen2, _PYGEODESY_ENV, typename, \
@@ -157,8 +157,7 @@ from pygeodesy.interns import NN, _a12_, _area_, _azi1_, _azi2_, _azi12_, \
                              _SPACE_, _UNDER_, _X_, _1_, _2_,  _BAR_  # PYCHOK used!
 from pygeodesy.lazily import _ALL_DOCS, _ALL_LAZY, _ALL_MODS as _MODS, _FOR_DOCS
 from pygeodesy.named import ADict, _NamedBase, _NamedTuple, notImplemented, _Pass
-from pygeodesy.props import deprecated_method, Property_RO, property_RO, \
-                                               property_ROnce
+from pygeodesy.props import deprecated_method, property_RO, property_ROnce
 from pygeodesy.units import Azimuth as _Azi, Degrees as _Deg, Lat, Lon, \
                             Meter as _M, Meter2 as _M2, Number_
 from pygeodesy.utily import atan2d, sincos2d, tand, _unrollon,  fabs
@@ -166,8 +165,9 @@ from pygeodesy.utily import atan2d, sincos2d, tand, _unrollon,  fabs
 # from math import fabs  # from .utily
 
 __all__ = _ALL_LAZY.karney
-__version__ = '25.05.28'
+__version__ = '25.09.13'
 
+_1_16th     = _1_0 / 16
 _2_4_       = '2.4'
 _K_2_0      = _getenv(_PYGEODESY_ENV(typename(_xgeographiclib)[2:]), _2_)
 _K_2_4      = _K_2_0 ==  _2_4_
@@ -270,16 +270,16 @@ class Caps(object):
     REDUCEDLENGTH =  1 << 12 | _CAP_1 | _CAP_2  # compute reduced length C{m12}
     GEODESICSCALE =  1 << 13 | _CAP_1 | _CAP_2  # compute geodesic scales C{M12} and C{M21}
     AREA          =  1 << 14 | _CAP_4  # compute area C{S12}
+    ALL           =  0x7F80  | _CAP_ALL  # without LONG_UNROLL, LINE_OFF, NONFINITONAN, REVERSE2 and _DEBUG_*
 
     STANDARD      =  AZIMUTH  | DISTANCE | LATITUDE | LONGITUDE
     STANDARD_LINE =  STANDARD | DISTANCE_IN  # for goedesici/-w
 
     LINE_CAPS     =  STANDARD_LINE | REDUCEDLENGTH | GEODESICSCALE  # .geodesici only
     LONG_UNROLL   =  1 << 15  # unroll C{lon2} in .Direct and .Position
-    NONFINITONAN  =  1 << 16  # see method GDict._toNAN
-    LINE_OFF      =  1 << 17  # Line without updates from parent geodesic or rhumb
+    LINE_OFF      =  1 << 16  # Line without updates from parent geodesic or rhumb
+    NONFINITONAN  =  1 << 17  # see method GDict._toNAN
     REVERSE2      =  1 << 18  # reverse C{azi2}
-    ALL           =  0x7F80 | _CAP_ALL  # without LONG_UNROLL, LINE_OFF, REVERSE2 and _DEBUG_*
 
     AZIMUTH_DISTANCE        = AZIMUTH | DISTANCE
     AZIMUTH_DISTANCE_AREA   = AZIMUTH | DISTANCE | AREA
@@ -300,7 +300,7 @@ class Caps(object):
     _INVERSE3      =  AZIMUTH  | DISTANCE  # for goedesicw only
 
     _OUT_ALL       =  ALL  # see geographiclib.geodesiccapabilities.py
-    _OUT_MASK      =  ALL | LONG_UNROLL | REVERSE2 | _DEBUG_ALL
+    _OUT_MASK      =  ALL | LONG_UNROLL | NONFINITONAN | REVERSE2 | _DEBUG_ALL
 
     _AZIMUTH_LATITUDE_LONGITUDE           =  AZIMUTH | LATITUDE | LONGITUDE
     _AZIMUTH_LATITUDE_LONG_UNROLL         =  AZIMUTH | LATITUDE | LONG_UNROLL
@@ -366,7 +366,7 @@ class _CapsBase(_NamedBase):  # in .auxilats, .geodesicx.gxbases
     _caps         = 0  # None
     _debug        = 0  # or Caps._DEBUG_...
 
-    @Property_RO
+    @property_RO
     def caps(self):
         '''Get the capabilities (bit-or'ed C{Caps}).
         '''
@@ -455,13 +455,16 @@ class GDict(ADict):  # XXX _NamedDict
         '''
         return self._toTuple(Inverse10Tuple, dflt)
 
-    def _toNAN(self, outmask):  # .GeodesicExact._GDistInverse, .GeodesicLineExact._GenPosition
+    def _toNAN(self, outmask, **specs):  # .GeodesicExact._GDistInverse, .GeodesicLineExact._GenPosition
         '''(INTERNAL) Convert this C{GDict} to all C{NAN}s.
         '''
         if (outmask & Caps.NONFINITONAN):
-            d = dict((k, NAN) for k, C in _key2Caps.items()
-                                       if (outmask & C) == C)
-            self.set_(**d)
+            def _t2(k):
+                return k, specs.get(k, NAN)
+
+            d = dict(_t2(k) for k, C in _key2Caps.items()
+                                     if (outmask & C) == C)
+            self.set_(**d)  # self.update(d)
         return self
 
     @deprecated_method
@@ -721,12 +724,10 @@ def _around(x):  # in .utily.sincos2d
     try:
         return _wrapped.Math.AngRound(x)
     except AttributeError:
-        if x:
-            y = _1_16th - fabs(x)
-            if y > 0:  # fabs(x) < _1_16th
-                x = _copysign(_1_16th - y, x)
-        else:
-            x = _0_0  # -0 to 0
+        z = _1_16th
+        w =  z - fabs(x)
+        if w > 0:  # don't "simplify" z - (z - x) to x
+            x = _copysign(z - w, x)
         return x
 
 
@@ -771,13 +772,13 @@ def _diff182(deg0, deg, K_2_0=False):
     try:
         return _wrapped.Math.AngDiff(deg0, deg)
     except AttributeError:
-        if K_2_0 or _K_2_0:  # geographiclib 2.0
-            _r, _360 = fremainder, _360_0
-            d, t = _sum2(_r(-deg0, _360),
-                         _r( deg,  _360))
-            d, t = _sum2(_r( d,    _360), t)
+        if K_2_0 or _K_2_0:  # geographiclib 2.0+
+            _r = fremainder
+            d, t = _sum2(_r(-deg0, _360_0),
+                         _r( deg,  _360_0))
+            d, t = _sum2(_r( d,    _360_0), t)
             if _isin(d, _0_0, _180_0, _N_180_0):
-                d = _copysign(d, -t if t else (deg - deg0))
+                d = _copysign(d, (-t) if t else (deg - deg0))
         else:
             _n = _norm180
             d, t = _sum2(_n(-deg0), _n(deg))

pygeodesy/ktm.py

@@ -66,7 +66,7 @@ from cmath import polar as _polar
 from math import asinh, cos, cosh, degrees, fabs, sin, sinh, sqrt, tanh
 
 __all__ = _ALL_LAZY.ktm
-__version__ = '25.08.18'
+__version__ = '25.08.31'
 
 
 class KTMError(_ValueError):

pygeodesy/lazily.py

@@ -29,15 +29,15 @@ and line number.
 
 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.errors import _error_init, _ImmutableError, _xkwds_item2  # _ALL_MODS
 from pygeodesy.internals import _caller3, _envPYGEODESY, _headof, printf, _tailof, \
                                  typename, _versions  # _getenv, _PYGEODESY_ENV, \
 #                               _MODS_Base, _MODS.sys_version_info2
 from pygeodesy.interns import _attribute_, _by_, _COLONSPACE_, _COMMASPACE_, _DALL_, \
                               _DMAIN_, _doesn_t_exist_, _DOT_, _EQUALSPACED_, _from_, \
-                              _HASH_, _immutable_, _line_, _module_, NN, _no_, _not_, \
-                              _pygeodesy_, _pygeodesy_abspath_, _SPACE_, _SUB_PACKAGES, \
-                              _or_, _UNDER_, _version_,  _sys, _intern  # function, _1_
+                              _HASH_, _line_, _module_, NN, _no_, _not_, _pygeodesy_, \
+                              _pygeodesy_abspath_, _SPACE_, _SUB_PACKAGES, _or_, \
+                              _UNDER_, _version_,  _sys, _intern  # function, _1_
 try:
     from importlib import import_module
 except ImportError as x:  # Python 2.6-
@@ -125,8 +125,9 @@ class _NamedEnum_RO(dict):
             raise LazyAttributeError(t, txt=_doesn_t_exist_)
 
     def __setattr__(self, attr, value):  # PYCHOK no cover
-        t = _EQUALSPACED_(self._DOT_(attr), repr(value))
-        raise LazyAttributeError(_immutable_, txt=t)
+        e = _ALL_MODS.errors
+        raise e._ImmutableError(self, attr, value,
+                          Error=LazyAttributeError)
 
     def enums(self):
         # Yield all C{(mod_, tuple)} pairs
@@ -200,10 +201,10 @@ _ALL_LAZY = _NamedEnum_RO(_name='_ALL_LAZY',
                                    'EasNorAziRk4Tuple', 'EasNorAziRkEqu6Tuple', 'LatLonAziRk4Tuple'),
                       constants=_a('DIG', 'EPS', 'EPS0', 'EPS02', 'EPS1', 'EPS2', 'EPS4', 'EPS_2',
                                    'INF', 'INT0', 'MANT_DIG', 'MAX', 'MAX_EXP', 'MIN', 'MIN_EXP', 'NAN', 'NEG0', 'NINF',
-                                   'PI', 'PI2', 'PI_2', 'PI3', 'PI_3', 'PI3_2', 'PI4', 'PI_4',
+                                   'PI', 'PI2', 'PI_2', 'PI3', 'PI_3', 'PI3_2', 'PI4', 'PI_4', 'PI_6',
                                    'R_FM', 'R_GM', 'R_KM', 'R_M', 'R_MA', 'R_MB', 'R_NM', 'R_QM', 'R_SM', 'R_VM',
                                    'float_', 'float0_', 'isclose', 'isfinite', 'isinf', 'isint0',
-                                   'isnan', 'isnear0', 'isnear1', 'isnear90', 'isneg0', 'isninf', 'isnon0',
+                                   'isnan', 'isnear0', 'isnear1', 'isnear90', 'isneg', 'isneg0', 'isninf', 'isnon0',
                                    'remainder'),
                          datums=_a('Datum', 'Datums', 'Transform', 'Transforms'),
 #                    deprecated=_a(),  # module only
@@ -357,11 +358,11 @@ _ALL_LAZY = _NamedEnum_RO(_name='_ALL_LAZY',
                                    'Radius_', 'Scalar', 'Scalar_', 'Zone'),
                       unitsBase=_a('Float', 'Int', 'Radius', 'Str'),
                             ups=_a('Ups', 'UPSError', 'parseUPS5', 'toUps8', 'upsZoneBand5'),
-                          utily=_a('acos1', 'acre2ha', 'acre2m2', 'asin1', 'atan1', 'atan1d', 'atan2', 'atan2b', 'atan2d',
+                          utily=_a('acos1', 'acre2ha', 'acre2m2', 'agdf', 'asin1', 'atan1', 'atan1d', 'atan2', 'atan2b', 'atan2d',
                                    'chain2m', 'circle4', 'cot', 'cot_', 'cotd', 'cotd_',
                                    'degrees', 'degrees90', 'degrees180', 'degrees360', 'degrees2grades', 'degrees2m',
                                    'fathom2m', 'ft2m', 'furlong2m',                  # 'degrees2grades as degrees2gons',
-                                   'grades', 'grades400', 'grades2degrees', 'grades2radians',
+                                   'gdf', 'grades', 'grades400', 'grades2degrees', 'grades2radians',
 #                                  'grades as gons', 'grades400 as gons400', 'grades2degrees as gons2degrees', 'grades2radians as gons2radians',
                                    'ha2acre', 'ha2m2', 'hav', 'km2m',
                                    'm2acre', 'm2chain', 'm2degrees', 'm2fathom', 'm2ft', 'm2furlong',
@@ -510,7 +511,7 @@ class _ALL_MODS(_internals._MODS_Base):
 _internals._MODS = _ALL_MODS = _ALL_MODS()  # PYCHOK singleton
 
 __all__ = _ALL_LAZY.lazily
-__version__ = '25.08.22'
+__version__ = '25.09.09'
 
 
 def _ALL_OTHER(*objs):

pygeodesy/lcc.py

@@ -24,10 +24,10 @@ and John P. Snyder U{'Map Projections - A Working Manual'<https://Pubs.USGS.gov/
 # make sure int/int division yields float quotient, see .basics
 from __future__ import division as _; del _  # noqa: E702 ;
 
-from pygeodesy.basics import copysign0, _isin, _xinstanceof, _xsubclassof, \
-                             typename
-from pygeodesy.constants import EPS, EPS02, PI_2, _float as _F, _0_0, _0_5, \
-                               _1_0, _2_0, _90_0
+from pygeodesy.basics import copysign0, _isin, typename, \
+                            _xinstanceof, _xsubclassof
+from pygeodesy.constants import EPS, EPS02, PI_2, _float as _F, \
+                               _0_0, _0_5, _1_0, _2_0, _90_0
 from pygeodesy.ellipsoidalBase import LatLonEllipsoidalBase as _LLEB
 from pygeodesy.datums import Datums, _ellipsoidal_datum
 from pygeodesy.errors import _IsnotError, _ValueError
@@ -50,7 +50,7 @@ from pygeodesy.utily import atan1, degrees90, degrees180, sincos2, tanPI_2_2
 from math import atan, fabs, log, radians, sin, sqrt
 
 __all__ = _ALL_LAZY.lcc
-__version__ = '25.05.26'
+__version__ = '25.08.31'
 
 _E0_   = 'E0'
 _N0_   = 'N0'

pygeodesy/named.py

@@ -16,17 +16,17 @@ standard Python C{namedtuple}s.
 from pygeodesy.basics import isbool, isidentifier, iskeyword, isstr, itemsorted, \
                              len2, _xcopy, _xdup, _xinstanceof, _xsubclassof, _zip
 # from pygeodesy.ecef import EcefKarney  # _MODS
-from pygeodesy.errors import _AssertionError, _AttributeError, _incompatible, \
-                             _IndexError, _KeyError, LenError, _NameError, \
-                             _NotImplementedError, _TypeError, _TypesError, \
-                             _UnexpectedError, UnitError, _ValueError, \
+from pygeodesy.errors import _AssertionError, _AttributeError, _ImmutableError, \
+                             _incompatible, _IndexError, _KeyError, LenError, \
+                             _NameError, _NotImplementedError, _TypeError, \
+                             _TypesError, _UnexpectedError, UnitError, _ValueError, \
                              _xattr, _xkwds, _xkwds_item2, _xkwds_pop2
 from pygeodesy.internals import _caller3, _envPYGEODESY, _isPyPy, _sizeof, \
                                  typename, _under
 from pygeodesy.interns import MISSING, NN, _AT_, _COLON_, _COLONSPACE_, _COMMA_, \
                              _COMMASPACE_, _DNAME_, _doesn_t_exist_, _DOT_, _DUNDER_, \
-                             _EQUAL_, _exists_, _immutable_, _name_, _NL_, _NN_, \
-                             _no_, _other_, _s_, _SPACE_, _std_, _UNDER_, _vs_
+                             _EQUAL_, _exists_, _name_, _NL_, _NN_, _no_, _other_, \
+                             _s_, _SPACE_, _std_, _UNDER_, _vs_
 from pygeodesy.lazily import _ALL_DOCS, _ALL_LAZY, _ALL_MODS as _MODS
 from pygeodesy.props import _allPropertiesOf_n, deprecated_method, _hasProperty, \
                             _update_all, property_doc_, Property_RO, property_RO, \
@@ -35,11 +35,10 @@ from pygeodesy.streprs import attrs, Fmt, lrstrip, pairs, reprs, unstr
 # from pygeodesy.units import _toUnit  # _MODS
 
 __all__ = _ALL_LAZY.named
-__version__ = '25.04.28'
+__version__ = '25.09.04'
 
 _COMMANL_           = _COMMA_ + _NL_
 _COMMASPACEDOT_     = _COMMASPACE_ + _DOT_
-_del_               = 'del'
 _item_              = 'item'
 _MRO_               = 'MRO'
 # __DUNDER gets mangled in class
@@ -111,7 +110,7 @@ class ADict(dict):
             self._iteration = iteration
         if items:
             dict.update(self, items)
-        return self  # in RhumbLineBase.Intersecant2, _PseudoRhumbLine.Position
+        return self  # in RhumbLineBase.Intersecant2, _PseudoRhumbLine.Position, ...
 
     def _toL(self):
         '''(INTERNAL) Get items as list.
@@ -977,8 +976,7 @@ class _NamedTuple(tuple, _Named):
            @note: Items can not be deleted.
         '''
         if name in self._Names_:
-            t = _SPACE_(_del_, self._DOT_(name))
-            raise _TypeError(t, txt=_immutable_)
+            raise _ImmutableError(self, name)  # _del_
         elif name in (_name_, _name):
             _Named.__setattr__(self, name, NN)  # XXX _Named.name.fset(self, NN)
         else:
@@ -1011,8 +1009,7 @@ class _NamedTuple(tuple, _Named):
         '''Set attribute or item B{C{name}} to B{C{value}}.
         '''
         if name in self._Names_:
-            t = Fmt.EQUALSPACED(self._DOT_(name), repr(value))
-            raise _TypeError(t, txt=_immutable_)
+            raise _ImmutableError(self, name, value)
         elif name in (_name_, _name):
             _Named.__setattr__(self, name, value)  # XXX _Named.name.fset(self, value)
         else:  # e.g. _iteration
@@ -1250,7 +1247,7 @@ def modulename(clas, prefixed=None):  # in .basics._xversion
     '''Return the class name optionally prefixed with the
        module name.
 
-       @arg clas: The class (any C{class}).
+       @arg clas: The class (any C{class} or C{str}).
        @kwarg prefixed: Include the module name (C{bool}), see
                         function C{classnaming}.
 

pygeodesy/rhumb/__init__.py

@@ -9,7 +9,7 @@ u'''Package of lazily imported C{rhumb} modules L{rhumb.aux_}, L{rhumb.ekx} and
 from pygeodesy.lazily import _ALL_LAZY, _ALL_OTHER, _lazy_import_as, _unLazy0
 
 __all__ = _ALL_LAZY.rhumb
-__version__ = '25.04.14'
+__version__ = '25.08.28'
 
 if _unLazy0:  # or _isfrozen
     from pygeodesy.rhumb.aux_ import RhumbAux, RhumbLineAux

pygeodesy/rhumb/aux_.py

@@ -48,7 +48,7 @@ from pygeodesy.rhumb.bases import RhumbBase, RhumbLineBase, \
 from math import ceil as _ceil, fabs, radians
 
 __all__ = _ALL_LAZY.rhumb_aux_
-__version__ = '25.05.12'
+__version__ = '25.08.31'
 
 # DIGITS = (sizeof(real) * 8) bits
 #        = (ctypes.sizeof(ctypes.c_double(1.0)) * 8) bits

pygeodesy/rhumb/bases.py

@@ -732,8 +732,7 @@ class RhumbLineBase(_CapsBase):
                    azi02=other.azi12, a02=t.a12, s02=t.s12,
                    at=other.azi12 - self.azi12, iteration=i)
         except Exception as x:
-            raise IntersectionError(self, other, tol=tol,
-                                          eps=eps, cause=x)
+            raise IntersectionError(self, other, tol=tol, cause=x, **eps)
         return P
 
     def Inverse(self, lat2, lon2, wrap=False, **outmask):
@@ -870,19 +869,19 @@ class RhumbLineBase(_CapsBase):
             P  =  self.Intersection(rl, tol=tol, eps=eps)
 
         else:  # C{rhumb-intercept}
-            E   = self.ellipsoid
-            _gI = E.geodesic_(exact=exact).Inverse
-            gm  = Cs.STANDARD | Cs._REDUCEDLENGTH_GEODESICSCALE  # ^ Cs.DISTANCE_IN
+            E   =  self.ellipsoid
+            _gI =  E.geodesic_(exact=exact).Inverse
+            gm  =  Cs.STANDARD | Cs._REDUCEDLENGTH_GEODESICSCALE  # ^ Cs.DISTANCE_IN
+            _d2 = _diff182
             if est is None:  # get an estimate from the "perpendicular" geodesic
                 r = _gI(self.lat1, self.lon1, lat0, lon0, outmask=Cs.AZIMUTH_DISTANCE)
-                d, _ = _diff182(r.azi2, self.azi12, K_2_0=True)
+                d, _ = _d2(r.azi2, self.azi12, K_2_0=True)
                 _, s12 = sincos2d(d)
                 s12 *=  r.s12  # signed
             else:
                 s12  =  Meter(est=est)
             try:
                 _abs =  fabs
-                _d2  = _diff182
                 _ErT =  E.rocPrimeVertical  # aka rocTransverse
                 _ovr = _over
                 _S12 =  Fsum(s12).fsum2f_
@@ -894,7 +893,7 @@ class RhumbLineBase(_CapsBase):
                     s, c, s2, c2 = _scd(d, r.lat2)
                     c2 *= _ErT(r.lat2)
                     s  *= _ovr(s2 * self._salp, c2) - _ovr(s * r.M21, r.m12)
-                    s12, t = _S12(c / s)  # XXX _ovr?
+                    s12, t = _S12(c / s) if s else (s12, s)  # XXX _ovr?
                     if _abs(t) < tol:  # or _abs(c) < EPS
                         break
                 P.set_(azi0=r.azi1, a02=r.a12, s02=r.s12,  # azi2=r.azi2,

pygeodesy/rhumb/ekx.py

@@ -22,9 +22,9 @@ License.  For more information, see the U{GeographicLib<https://GeographicLib.So
 # make sure int/int division yields float quotient
 from __future__ import division as _; del _  # noqa: E702 ;
 
-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.basics import copysign0, neg  # _MODS
+from pygeodesy.constants import PI_2, _over, _1_over, _0_0s, \
+                               _0_0, _0_5, _1_0, _2_0, _4_0, _720_0
 # from pygeodesy.datums import _WGS84  # from .rhumb.bases
 # from pygeodesy.deprecated import RhumbOrder2Tuple  # _MODS
 from pygeodesy.errors import RhumbError, _xkwds_pop2, _Xorder
@@ -42,7 +42,7 @@ from pygeodesy.utily import atan1, sincos2_
 from math import asinh, atan, cos, cosh, radians, sin, sinh, sqrt, tan  # as _tan
 
 __all__ = _ALL_LAZY.rhumb_ekx
-__version__ = '25.05.12'
+__version__ = '25.08.31'
 
 
 class Rhumb(RhumbBase):
@@ -159,9 +159,9 @@ class Rhumb(RhumbBase):
         if (outmask & Cs.DISTANCE):
             a = s = hypot(lon12, psi12)
             if a:
-                a *= self._DIsometric2Rectifyingd(psi2, psi1)
-                s  = self._mpd * a  # == E._Lpd
-                a  = copysign0(a, s)
+                a *=  self._DIsometric2Rectifyingd(psi2, psi1)
+                s  =  self._mpd * a  # == E._Lpd
+                a  = _MODS.basics.copysign0(a, s)
             r.set_(a12=a, s12=s)
 
         if ((outmask | self._debug) & Cs._DEBUG_INVERSE):  # PYCHOK no cover
@@ -306,7 +306,7 @@ class RhumbLine(RhumbLineBase):
 
     @Property_RO
     def _psi1(self):
-        '''(INTERNAL) Get the I{isometric auxiliary} latitude C{psi} (C{degrees}).
+        '''(INTERNAL) Get the I{isometric auxiliary} latitude (C{degrees}).
         '''
         return self.ellipsoid.auxIsometric(self.lat1)
 
@@ -465,7 +465,7 @@ def _sincosSeries(sinp, x, y, C, n):
     #   SC = sinp ? sin : cos
     #   CS = sinp ? cos : sin
     # ...
-    d, _neg = (x - y), neg
+    d, _neg = (x - y), _MODS.basics.neg
     sp, cp, sd, cd = sincos2_(x + y, d)
     sd = (sd / d) if d else _1_0
     s  = _neg(sp * sd)  # negative

pygeodesy/solveBase.py

@@ -23,7 +23,7 @@ from pygeodesy.units import Precision_
 from pygeodesy.utily import unroll180
 
 __all__ = _ALL_LAZY.solveBase
-__version__ = '25.05.12'
+__version__ = '25.09.02'
 
 _ERROR_ = 'ERROR'
 
@@ -63,10 +63,16 @@ class _SolveCapsBase(_CapsBase):
 
     @Property_RO
     def a(self):
-        '''Get the I{equatorial} radius, semi-axis (C{meter}).
+        '''Get the ellipsoid's I{equatorial} radius, semi-axis (C{meter}).
         '''
         return self.ellipsoid.a
 
+    @Property_RO
+    def b(self):
+        '''Get the ellipsoid's I{polar} radius, semi-axis (C{meter}).
+        '''
+        return self.ellipsoid.b
+
     @property_RO
     def _cmdBasic(self):  # PYCHOK no covers        '''(INTERNAL) I{Must be overloaded}.'''
         notOverloaded(self, underOK=True)
@@ -381,6 +387,11 @@ class _SolveGDictBase(_SolveBase):
         if path:
             self._setXable(path)
 
+    def ArcDirect(self, lat1, lon1, azi1, a12, outmask=_UNUSED_):  # PYCHOK unused
+        '''Return the C{Direct} result at C{a12} degrees.
+        '''
+        return self._GDictDirect(lat1, lon1, azi1, True, a12)
+
     @Property_RO
     def _cmdDirect(self):
         '''(INTERNAL) Get the C{Solve} I{Direct} cmd (C{tuple}).
@@ -394,7 +405,7 @@ class _SolveGDictBase(_SolveBase):
         return self._cmdBasic + ('-i',)
 
     def Direct(self, lat1, lon1, azi1, s12, outmask=_UNUSED_):  # PYCHOK unused
-        '''Return the C{Direct} result.
+        '''Return the C{Direct} result at distance C{s12}.
         '''
         return self._GDictDirect(lat1, lon1, azi1, False, s12)
 

pygeodesy/sphericalTrigonometry.py

@@ -17,9 +17,9 @@ U{Latitude/Longitude<https://www.Movable-Type.co.UK/scripts/latlong.html>}.
 from __future__ import division as _; del _  # noqa: E702 ;
 
 from pygeodesy.basics import copysign0, _isin, map1, signOf,  typename
-from pygeodesy.constants import EPS, EPS1, EPS4, PI, PI2, PI_2, PI_4, R_M, \
-                                isnear0, isnear1, isnon0, _0_0, _0_5, \
-                                _1_0, _2_0, _90_0
+from pygeodesy.constants import EPS, EPS1, EPS4, PI, PI2, PI_2, PI_4, \
+                                R_M, _0_0, _0_5, _1_0, _2_0, _90_0, \
+                                isnear0, isnear1, isnon0
 from pygeodesy.datums import _ellipsoidal_datum, _mean_radius
 from pygeodesy.errors import _AssertionError, CrossError, crosserrors, \
                              _TypeError, _ValueError, IntersectionError, \
@@ -57,7 +57,7 @@ from pygeodesy.vector3d import sumOf, Vector3d
 from math import asin, cos, degrees, fabs, radians, sin
 
 __all__ = _ALL_LAZY.sphericalTrigonometry
-__version__ = '25.08.18'
+__version__ = '25.08.31'
 
 _PI_EPS4 = PI - EPS4
 if _PI_EPS4 >= PI:

pygeodesy/streprs.py

@@ -22,7 +22,7 @@ from pygeodesy.lazily import _ALL_LAZY, _ALL_MODS as _MODS
 from math import fabs, log10 as _log10
 
 __all__ = _ALL_LAZY.streprs
-__version__ = '25.04.14'
+__version__ = '25.10.10'
 
 _at_        = 'at'         # PYCHOK used!
 _EN_PREC    =  6           # max MGRS/OSGR precision, 1 micrometer
@@ -545,22 +545,22 @@ def unstr(where, *args, **kwds_):
        @arg where: Class, function, method (C{type}) or name (C{str}).
        @arg args: Optional positional arguments.
        @kwarg kwds_: Optional keyword arguments, except C{B{_Cdot}=None},
-                     C{B{_ELLIPSIS}=False} and C{B{_fmt}=Fmt.g}.
+                     C{B{_ELLIPSIS}=False}, C{B{_fmt}=Fmt.g} and C{B{_prec}=6}.
 
        @return: Representation (C{str}).
     '''
-    def _C_e_g_kwds3(_Cdot=None, _ELLIPSIS=0, _fmt=Fmt.g, **kwds):
-        return _Cdot, _ELLIPSIS, _fmt, kwds
+    def _C_e_fmt_prec_kwds(_Cdot=None, _ELLIPSIS=0, _fmt=Fmt.g, _prec=6, **kwds):
+        return _Cdot, _ELLIPSIS, dict(fmt=_fmt, prec=_prec), kwds
 
-    C, e, g, kwds = _C_e_g_kwds3(**kwds_)
+    C, e, fmt_prec, kwds = _C_e_fmt_prec_kwds(**kwds_)
     if e and len(args) > (e + 1):
-        t  =  reprs(args[:e], fmt=g)
+        t  =  reprs(args[:e], **fmt_prec)
         t += _ELLIPSIS_,
-        t +=  reprs(args[-1:], fmt=g)
+        t +=  reprs(args[-1:], **fmt_prec)
     else:
-        t  =  reprs(args, fmt=g) if args else ()
+        t  =  reprs(args, **fmt_prec) if args else ()
     if kwds:
-        t += pairs(itemsorted(kwds), fmt=g)
+        t += pairs(itemsorted(kwds), **fmt_prec)
     n = where if isstr(where) else typename(where)  # _NN_
     if C and hasattr(C, n):
         try:  # bound method of class C?