pygeodesy 24.5.8__py2.py3-none-any.whl → 24.5.24__py2.py3-none-any.whl

pygeodesy/osgr.py

@@ -53,7 +53,7 @@ from pygeodesy.utily import degrees90, degrees180, sincostan3, truncate
 from math import cos, fabs, radians, sin, sqrt
 
 __all__ = _ALL_LAZY.osgr
-__version__ = '23.12.03'
+__version__ = '24.05.13'
 
 _equivalent_ = 'equivalent'
 _OSGR_       = 'OSGR'
@@ -324,17 +324,19 @@ class Osgr(_NamedBase):
             r = NG.reverse(self)
 
         elif self._latlon is None:
+            _F = _Fsumf_
             e0 =     self.easting  - NG.eas0
             n0 = m = self.northing - NG.nor0
 
-            _M =  NG.Mabcd0
             a0 =  NG.a0
+            _M =  NG.Mabcd0
             a  =  NG.phi0
-            _A = _Fsumf_(a).fsum_
+            _a =  fabs
+            _A = _F(a).fsum_
             for self._iteration in range(1, _TRIPS):
                 a = _A(m / a0)
                 m = n0 - _M(a)  # meridional arc
-                if fabs(m) < eps:
+                if _a(m) < eps:
                     break
             else:  # PYCHOK no cover
                 t =  str(self)
@@ -354,14 +356,14 @@ class Osgr(_NamedBase):
             d2  = d**2
 
             a = (d2 * ta * (-1 +  # Horner-like
-                 d2 / 12 * (_Fsumf_( 5,  3 * ta2, -9 * ta2 * n2, n2) -
-                 d2 / 30 *  _Fsumf_(61, 90 * ta2, 45 * ta4)))).fsum_(a)
+                 d2 / 12 * (_F( 5,  3 * ta2, -9 * ta2 * n2, n2) -
+                 d2 / 30 *  _F(61, 90 * ta2, 45 * ta4)))).fsum_(a)
 
             b = (d  / ca * ( 1 -  # Horner-like
-                 d2 /  6 * (_Fsumf_(v_r,  2 * ta2) -
-                 d2 / 20 * (_Fsumf_( 5,  28 * ta2,   24 * ta4) +
-                 d2 / 42 *  _Fsumf_(61, 662 * ta2, 1320 * ta4,
-                                        720 * ta2 * ta4))))).fsum_(NG.lam0)
+                 d2 /  6 * (_F(v_r,  2 * ta2) -
+                 d2 / 20 * (_F( 5,  28 * ta2,   24 * ta4) +
+                 d2 / 42 *  _F(61, 662 * ta2, 1320 * ta4,
+                                   720 * ta2 * ta4))))).fsum_(NG.lam0)
 
             r = _LLEB(degrees90(a), degrees180(b), datum=self.datum, name=self.name)
             r._iteration = self._iteration  # only ellipsoidal LatLon
@@ -541,7 +543,7 @@ def parseOSGR(strOSGR, Osgr=Osgr, name=NN, **Osgr_kwds):
         if not p:
             raise ValueError
         g = s[0]
-        if p == 2 and isfloat(g):  # "easting,northing"
+        if p == 2 and isfloat(g, both=True):  # "easting,northing"
             e, n, m = _enstr2m3(*s, wide=_EN_WIDE + 1)
 
         else:
@@ -681,7 +683,7 @@ def toOsgr(latlon, lon=None, kTM=False, datum=_WGS84, Osgr=Osgr, name=NN,  # MCC
 
 if __name__ == '__main__':
 
-    from pygeodesy.lazily import printf
+    from pygeodesy import printf
     from random import random, seed
     from time import localtime
 

pygeodesy/points.py

@@ -26,8 +26,8 @@ C{ilon} longitude index in each 2+tuple.
 '''
 
 from pygeodesy.basics import isclass, isint, isscalar, issequence, \
-                             issubclassof, _Sequence, _xcopy, _xdup, \
-                             _xinstanceof
+                            _xdup, issubclassof, _Sequence, _xcopy, \
+                            _xinstanceof
 from pygeodesy.constants import EPS, EPS1, PI_2, R_M, isnear0, isnear1, \
                                _umod_360, _0_0, _0_5, _1_0, _2_0, _6_0, \
                                _90_0, _N_90_0, _180_0, _360_0
@@ -41,8 +41,8 @@ from pygeodesy.fmath import favg, fdot, hypot,  Fsum, fsum
 from pygeodesy.formy import _bearingTo2, equirectangular_,  _spherical_datum
 from pygeodesy.interns import NN, _colinear_, _COMMASPACE_, _composite_, \
                              _DEQUALSPACED_, _ELLIPSIS_, _EW_, _immutable_, \
-                             _near_, _no_, _not_, _NS_, _point_, _SPACE_, \
-                             _UNDER_, _valid_  # _lat_, _lon_
+                             _near_, _no_, _NS_, _point_, _SPACE_, _UNDER_, \
+                             _valid_  # _lat_, _lon_
 from pygeodesy.iters import LatLon2PsxyIter, PointsIter, points2
 from pygeodesy.latlonBase import LatLonBase, _latlonheight3, \
                                 _ALL_DOCS, _ALL_LAZY, _MODS
@@ -59,10 +59,10 @@ from pygeodesy.units import Number_, Radius, Scalar, Scalar_
 from pygeodesy.utily import atan2b, degrees90, degrees180, degrees2m, \
                             unroll180, _unrollon, unrollPI, _Wrap, wrap180
 
-from math import cos, fabs, fmod, radians, sin
+from math import cos, fabs, fmod as _fmod, radians, sin
 
 __all__ = _ALL_LAZY.points
-__version__ = '24.04.07'
+__version__ = '24.05.19'
 
 _ilat_  = 'ilat'
 _ilon_  = 'ilon'
@@ -92,7 +92,7 @@ class LatLon_(LatLonBase):  # XXX in heights._HeightBase.height
     # python3 -m timeit -s "from pygeodesy... import LatLonBase as LL" "LL(0, 0)" 2.14 usec
     # python3 -m timeit -s "from pygeodesy import LatLon_" "LatLon_(0, 0)" 216 nsec
 
-    def __init__(self, latlonh, lon=None, height=0, wrap=False, name=NN, datum=None):
+    def __init__(self, latlonh, lon=None, height=0, wrap=False, datum=None, **name):
         '''New L{LatLon_}.
 
            @note: The lat- and longitude values are taken I{as-given,
@@ -283,7 +283,7 @@ class _Basequence(_Sequence):  # immutable, on purpose
         '''
         for i in self._findall(point, start_end):
             return i
-        raise _IndexError(self._itemname, point, txt=_not_('found'))
+        raise _IndexError(self._itemname, point, txt_not_='found')
 
     @property_RO
     def isNumpy2(self):  # PYCHOK no cover
@@ -1156,7 +1156,7 @@ def fractional(points, fi, j=None, wrap=None, LatLon=None, Vector=None, **kwds):
     '''
     if LatLon and Vector:  # PYCHOK no cover
         kwds = _xkwds(kwds, fi=fi, LatLon=LatLon, Vector=Vector)
-        raise _TypeError(txt=fractional.__name__, **kwds)
+        raise _TypeError(txt__=fractional, **kwds)
     w = wrap if LatLon else False  # intermediateTo
     try:
         if not isscalar(fi) or fi < 0:
@@ -1168,7 +1168,7 @@ def fractional(points, fi, j=None, wrap=None, LatLon=None, Vector=None, **kwds):
         elif Vector:
             p = Vector(p.x, p.y, p.z, **kwds)
     except (IndexError, TypeError):
-        raise _IndexError(fi=fi, points=points, wrap=w, txt=fractional.__name__)
+        raise _IndexError(fi=fi, points=points, wrap=w, txt__=fractional)
     return p
 
 
@@ -1191,12 +1191,12 @@ def _fractional(points, fi, j, fin=None, wrap=None):  # in .frechet.py
         elif _isLatLon(p):  # backward compatible default
             p = LatLon2Tuple(favg(p.lat, q.lat, f=r),
                              favg(p.lon, q.lon, f=r),
-                             name=fractional.__name__)
+                             name__=fractional)
         else:  # assume p and q are cartesian or vectorial
             z = p.z if p.z is q.z else favg(p.z, q.z, f=r)
             p = Vector3Tuple(favg(p.x, q.x, f=r),
                              favg(p.y, q.y, f=r), z,
-                             name=fractional.__name__)
+                             name__=fractional)
     return p
 
 
@@ -1353,7 +1353,7 @@ def isenclosedBy(point, points, wrap=False):  # MCCABE 15
             return dx, x2, y2
 
     else:
-        x0 = fmod(x0, _360_0)  # not x0 % 360!
+        x0 = _fmod(x0, _360_0)  # not x0 % 360!
         x0_180_ = x0 - _180_0
         x0_180  = x0 + _180_0
 

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.03'
+__version__ = '24.05.12'
 
 _class_       = 'class'
 _dont_use_    = _DEPRECATED_ + ", don't use."
@@ -48,11 +48,11 @@ def _allPropertiesOf(Clas_or_inst, *Bases, **excls):
         except AttributeError:
             raise
             S = ()  # not an inst
-    B   = Bases or _PropertyBase
-    _is = isinstance
+    B    = Bases or _PropertyBase
+    _isa = isinstance
     for C in S:
         for n, p in C.__dict__.items():
-            if _is(p, B) and p.name == n and n not in excls:
+            if _isa(p, B) and p.name == n and n not in excls:
                 yield p
 
 
@@ -252,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", page 636, O'Reilly, Example
-                 19-24, 2016 p. 636 or Example 22-28, 2022 p. 869+ and U{class
-                 Property<https://docs.Python.org/3/howto/descriptor.html>}.
+           @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>}.
         '''
         _fget = method if _FOR_DOCS else self._fget  # XXX force method.__doc__ to epydoc
         _PropertyBase.__init__(self, method, _fget, self._fset_error)

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__ = '23.12.29'
+__version__ = '24.05.24'
 
 if _unLazy0:  # or _isfrozen
     from pygeodesy.rhumb.aux_ import RhumbAux, RhumbLineAux

pygeodesy/rhumb/bases.py

@@ -33,8 +33,9 @@ from pygeodesy.errors import IntersectionError, RhumbError, _xdatum, \
 from pygeodesy.fmath import euclid, favg, sqrt_a,  Fsum
 # from pygeodesy.formy import opposing  # _MODS
 # from pygeodesy.fsums import Fsum  # from .fmath
+from pygeodesy.internals import _dunder_nameof, _under
 from pygeodesy.interns import NN, _coincident_, _COMMASPACE_, _Dash, \
-                             _dunder_nameof, _parallel_, _too_, _under
+                             _parallel_, _too_
 from pygeodesy.karney import _atan2d, Caps, _CapsBase, _diff182, _fix90, \
                              _norm180, GDict
 # from pygeodesy.ktm import KTransverseMercator, _AlpCoeffs  # _MODS
@@ -51,7 +52,7 @@ from pygeodesy.vector3d import _intersect3d3, Vector3d  # in .Intersection below
 from math import cos, fabs
 
 __all__ = ()
-__version__ = '24.04.07'
+__version__ = '24.05.13'
 
 _anti_ = _Dash('anti')
 _rls   = []  # instances of C{RbumbLine...} to be updated

pygeodesy/rhumb/solve.py

@@ -21,7 +21,7 @@ from pygeodesy.solveBase import _SolveBase, _SolveLineBase
 from pygeodesy.utily import _unrollon, _Wrap, wrap360
 
 __all__ = _ALL_LAZY.rhumb_solve
-__version__ = '24.02.21'
+__version__ = '24.04.13'
 
 
 class _RhumbSolveBase(_SolveBase):
@@ -356,7 +356,7 @@ __all__ += _ALL_DOCS(_RhumbSolveBase)
 
 if __name__ == '__main__':
 
-    from pygeodesy.lazily import printf
+    from pygeodesy import printf
     from sys import argv
 
     def rhumb_intercept(rS, lat1, lon1, lat2, lon2, azi2, s23):

pygeodesy/solveBase.py

@@ -9,10 +9,11 @@ from pygeodesy.constants import DIG
 from pygeodesy.datums import _earth_datum, _WGS84,  _EWGS84
 # from pygeodesy.ellipsoids import _EWGS84  # from .datums
 from pygeodesy.errors import _AssertionError, _xkwds_get, _xkwds_item2
-from pygeodesy.interns import NN, _0_, _BACKSLASH_, _COMMASPACE_, _enquote, \
-                             _EQUAL_, _Error_, _not_, _SPACE_, _UNUSED_
+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, printf, _unlazy
+from pygeodesy.lazily import _ALL_DOCS, _ALL_LAZY, _unlazy
 from pygeodesy.named import callername, notOverloaded
 from pygeodesy.props import Property, Property_RO, property_RO, _update_all
 from pygeodesy.streprs import Fmt, fstr, fstrzs, pairs, strs
@@ -22,7 +23,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.03.15'
+__version__ = '24.05.20'
 
 _ERROR_    = 'ERROR'
 _text_True =  dict() if _unlazy else dict(text=True)
@@ -105,7 +106,7 @@ class _SolveLineSolveBase(_CapsBase):
         if floats:
             v = map(float, v)
         r = GDict(_zip(n, v))  # strict=True
-        return self._iter2tion(r, r)
+        return self._iter2tion(r, **r)
 
     @property_RO
     def invokation(self):
@@ -136,7 +137,7 @@ class _SolveLineSolveBase(_CapsBase):
         s =  self.status
         if s:
             raise self._Error(cmd=_cmd_stdin_(c, i), status=s,
-                              txt=_not_(_0_))
+                              txt_not_=_0_)
         if self.verbose:  # PYCHOK no cover
             self._print(r)
         return r
@@ -220,7 +221,7 @@ class _SolveLineSolveBase(_CapsBase):
             _ = self.version  # test path and ...
             if self.status:  # ... return code
                 S_p = Solve_path or {self._Solve_name: _enquote(path)}
-                raise self._Error(status=self.status, txt=_not_(_0_), **S_p)
+                raise self._Error(status=self.status, txt_not_=_0_, **S_p)
             hold = path
         finally:  # restore in case of error
             if self._Solve_path != hold:

pygeodesy/sphericalTrigonometry.py

@@ -30,9 +30,9 @@ from pygeodesy.formy import antipode_, bearing_, _bearingTo2, excessAbc_, \
                             excessGirard_, excessLHuilier_, opposing_, _radical2, \
                             vincentys_
 from pygeodesy.interns import _1_, _2_, _coincident_, _composite_, _colinear_, \
-                              _concentric_, _convex_, _end_, _infinite_, _invalid_,\
-                              _line_, _near_, _not_, _null_, _parallel_, _point_, \
-                              _SPACE_, _too_
+                              _concentric_, _convex_, _end_, _infinite_, \
+                              _invalid_, _line_, _near_, _null_, _parallel_, \
+                              _point_, _SPACE_, _too_
 from pygeodesy.lazily import _ALL_LAZY, _ALL_MODS as _MODS, _ALL_OTHER
 # from pygeodesy.nvectorBase import NvectorBase, sumOf  # _MODE
 from pygeodesy.namedTuples import LatLon2Tuple, LatLon3Tuple, NearestOn3Tuple, \
@@ -54,7 +54,7 @@ from pygeodesy.vector3d import sumOf, Vector3d
 from math import asin, atan2, cos, degrees, fabs, radians, sin
 
 __all__ = _ALL_LAZY.sphericalTrigonometry
-__version__ = '24.04.07'
+__version__ = '24.045.19'
 
 _PI_EPS4 = PI - EPS4
 if _PI_EPS4 >= PI:
@@ -494,7 +494,7 @@ class LatLon(LatLonSphericalBase):
                     s0 = s
                 else:
                     t = _Fmt.SQUARE(points=i)
-                    raise _ValueError(t, p2, wrap=wrap, txt=_not_(_convex_))
+                    raise _ValueError(t, p2, wrap=wrap, txt_not_=_convex_)
             gc1, v1 = gc, v2
 
         return True  # inside

pygeodesy/streprs.py

@@ -5,23 +5,24 @@ u'''Floating point and other formatting utilities.
 '''
 
 from pygeodesy.basics import isint, islistuple, isscalar, isstr, itemsorted, \
-                            _zip,  _0_0
+                            _zip, _0_0
 # from pygeodesy.constants import _0_0
 from pygeodesy.errors import _or, _AttributeError, _IsnotError, _TypeError, \
                              _ValueError, _xkwds_get, _xkwds_item2, _xkwds_pop2
+# 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, \
-                             _N_, _name_, _not_, _not_scalar_, _PERCENT_, \
-                             _SPACE_, _STAR_, _UNDER_,  _dunder_nameof
+                             _N_, _name_, _not_scalar_, _PERCENT_, _SPACE_, \
+                             _STAR_, _UNDER_
 from pygeodesy.interns import _convergence_, _distant_, _e_, _eps_, _exceeds_, \
                               _EQUALSPACED_, _f_, _F_, _g_, _limit_, _no_, \
                               _tolerance_  # PYCHOK used!
-from pygeodesy.lazily import _ALL_LAZY, _ALL_MODS as _MODS
+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.04'
+__version__ = '24.05.19'
 
 _at_        = 'at'         # PYCHOK used!
 _EN_PREC    =  6           # max MGRS/OSGR precision, 1 micrometer
@@ -498,11 +499,11 @@ def _streprs(prec, objs, fmt, ints, force, strepr):
             f = fmt.replace(_DOTSTAR_, Fmt.DOT(abs(prec)))
             _ = f % (_0_0,)
         except (TypeError, ValueError):
-            raise _ValueError(fmt=fmt, txt=_not_(repr(_DOTSTAR_)))
+            raise _ValueError(fmt=fmt, txt_not_=repr(_DOTSTAR_))
         fmt = f
 
     else:
-        raise _ValueError(fmt=fmt, txt=_not_(repr(_Fspec_)))
+        raise _ValueError(fmt=fmt, txt_not_=repr(_Fspec_))
 
     for i, o in enumerate(objs):
         if force or isinstance(o, float):

pygeodesy/trf.py

@@ -69,7 +69,7 @@ en/how-to-deal-with-etrs89-datum-and-time-dependent-transformation-parameters-45
 @var RefFrames.WGS84g1762: RefFrame(name='WGS84g1762', epoch=2005, datum=Datums.GRS80) .Xforms=(0, 0)
 '''
 
-from pygeodesy.basics import map1, neg, isidentifier, isstr, _xinstanceof, _xisscalar
+from pygeodesy.basics import map1, neg, isidentifier, isstr, _xinstanceof, _xscalar
 from pygeodesy.constants import _float as _F, _0_0s, _0_0, _0_001, _0_5, _1_0
 from pygeodesy.datums import Datums, _earth_datum, _equall, _GDA2020_, _Names7, \
                             _negastr, Transform, _WGS84,  _EWGS84, _operator
@@ -91,7 +91,7 @@ from math import ceil as _ceil, fabs
 # import operator as _operator  # from .datums
 
 __all__ = _ALL_LAZY.trf
-__version__ = '24.03.12'
+__version__ = '24.05.21'
 
 _EP0CH    =  Epoch(0, low=0)
 _Es       = {_EP0CH: _EP0CH}  # L{Epoch}s, deleted below
@@ -242,7 +242,7 @@ class RefFrame(_NamedEnumItem):
         return _toRefFrame(point, reframe2, reframe=self, **_xkwds(epoch_epoch2_name,
                                                name=_xattr(reframe2, name=self.name)))
 
-    def toStr(self, epoch=None, name=NN, **unused):  # PYCHOK expected
+    def toStr(self, epoch=None, name=NN, **unused):  # PYCHOK signature
         '''Return this reference frame as a string.
 
            @kwarg epoch: Override this reframe's epoch (C{scalar} or C{str}).
@@ -383,14 +383,14 @@ class TransformXform(Transform):
     def __hash__(self):
         return Transform.__hash__(self)
 
-    def inverse(self, name=NN):
+    def inverse(self, **name):
         '''Return the inverse of this transform.
 
-           @kwarg name: Optional, unique name (C{str}).
+           @kwarg name: Optional, unique C{B{name}=NN} (C{str}).
 
            @return: Inverse (L{TransformXform}), unregistered.
         '''
-        r = Transform.inverse(name=name)
+        r = Transform.inverse(self, **name)
         r._Xform = r.Xform.inverse()
         return r
 
@@ -568,7 +568,7 @@ class TRFXform7Tuple(_NamedTuple):
         return _NamedTuple.__hash__(self)
 
     def __mul__(self, factor):
-        _xisscalar(factor=factor)
+        _xscalar(factor=factor)
         return type(self)((x * factor for x in self), name=_STAR_)  # .fsums._mul_op
 
     def __neg__(self):
@@ -1733,7 +1733,7 @@ if __name__ == '__main__':
     def _main():
         from pygeodesy.basics import _args_kwds_names
         from pygeodesy.interns import _COLONSPACE_,_COMMA_, _NL_, _NLATvar_, _vs_
-        from pygeodesy.lazily import printf
+        from pygeodesy import printf
         from time import localtime
 
         D = date2epoch.__name__