pygeodesy 25.4.8__py2.py3-none-any.whl → 25.5.5__py2.py3-none-any.whl

pygeodesy/elliptic.py

@@ -75,7 +75,7 @@ U{22<https://DLMF.NIST.gov/22>}.
 # make sure int/int division yields float quotient, see .basics
 from __future__ import division as _; del _  # PYCHOK semicolon
 
-from pygeodesy.basics import copysign0, map2, neg, neg_
+from pygeodesy.basics import copysign0, map2, neg, neg_,  typename
 from pygeodesy.constants import EPS, INF, NAN, PI, PI_2, PI_4, _0_0, \
                                _0_25, _0_5, _1_0, _2_0, _N_2_0, _3_0, \
                                _4_0, _6_0, _8_0, _64_0, _180_0, _360_0, \
@@ -84,9 +84,9 @@ from pygeodesy.constants import EPS, INF, NAN, PI, PI_2, PI_4, _0_0, \
 # from pygeodesy.errors import _ValueError  # from .fmath
 from pygeodesy.fmath import favg, hypot1, zqrt,  _ValueError
 from pygeodesy.fsums import Fsum, _sum
-from pygeodesy.internals import _DUNDER_nameof
-from pygeodesy.interns import NN, _delta_, _DOT_, _f_, _invalid_, \
-                             _invokation_, _negative_, _SPACE_
+# from pygeodesy.internals import typename  # from .basics
+from pygeodesy.interns import NN, _delta_, _DOT_, _f_, _invalid_, _invokation_, \
+                             _negative_, _SPACE_
 from pygeodesy.karney import _K_2_0, _norm180, _signBit, _sincos2
 # from pygeodesy.lazily import _ALL_LAZY  # from .named
 from pygeodesy.named import _Named, _NamedTuple,  _ALL_LAZY, Fmt, unstr
@@ -99,7 +99,7 @@ from math import asin, asinh, atan, ceil, cosh, fabs, floor, radians, \
                  sin, sinh, sqrt, tan, tanh  # tan as _tan
 
 __all__ = _ALL_LAZY.elliptic
-__version__ = '24.11.26'
+__version__ = '25.04.14'
 
 _TolRD  =  zqrt(EPS * 0.002)
 _TolRF  =  zqrt(EPS * 0.030)
@@ -678,7 +678,7 @@ class Elliptic(_Named):
                 return (deltaX(sn, cn, dn) + phi) * cX / PI_2
             # fall through
         elif cn is None or dn is None:
-            n = NN(_f_, deltaX.__name__[5:])
+            n = NN(_f_, typename(deltaX)[5:])
             raise _ellipticError(n, sn, cn, dn)
 
         if _signBit(cn):  # enforce usual trig-like symmetries
@@ -1063,7 +1063,7 @@ def _deltaX(sn, cn, dn, cX, fX):
         return r - atan2(sn, cn)
 
     except Exception as e:
-        n = NN(_delta_, fX.__name__[1:])
+        n = NN(_delta_, typename(fX)[1:])
         raise _ellipticError(n, sn, cn, dn, cause=e)
 
 
@@ -1075,8 +1075,8 @@ def _ellipticError(where, *args, **kwds_cause_txt):
 
     x, t, kwds = _x_t_kwds(**kwds_cause_txt)
 
-    n = _DUNDER_nameof(where, where)
-    n = _DOT_(Elliptic.__name__, n)
+    n =  typename(where, where)
+    n = _DOT_(typename(Elliptic), n)
     n = _SPACE_(_invokation_, n)
     u =  unstr(n, *args, **kwds)
     return EllipticError(u, cause=x, txt=t)

pygeodesy/errors.py

@@ -11,25 +11,26 @@ chaining}, use command line option C{python -X dev} I{OR} set env variable
 C{PYTHONDEVMODE=1} or to any non-empty string I{OR} set env variable
 C{PYGEODESY_EXCEPTION_CHAINING=std} or to any non-empty string.
 '''
-# from pygeodesy.basics import isint, isodd, issubclassof, itemsorted, _xinstanceof, _zip  # _MODS
+# from pygeodesy import basics as _basics  # _MODS.into
 # from pygeodesy.ellipsoidalBase import CartesianEllipsoidalBase, LatLonEllipsoidalBase  # _MODS
 # from pygeodesy import errors  # _MODS, _MODS.getattr
-from pygeodesy.internals import _DUNDER_nameof_, _getPYGEODESY, _plural, _tailof
+from pygeodesy.internals import _envPYGEODESY, _plural, _tailof, typename
 from pygeodesy.interns import MISSING, NN, _a_, _an_, _and_, _clip_, _COLON_, _COLONSPACE_, \
                              _COMMASPACE_, _datum_, _ELLIPSIS_, _ellipsoidal_, _incompatible_, \
                              _invalid_, _keyword_, _LatLon_, _len_, _not_, _or_, _SPACE_, \
                              _specified_, _UNDER_, _vs_, _with_
 from pygeodesy.lazily import _ALL_LAZY, _ALL_MODS as _MODS, _PYTHON_X_DEV
-# from pygeodesy import streprs as _streprs  # _MODS
+# from pygeodesy import streprs as _streprs  # _MODS.into
 # from pygeodesy.unitsBase import Str  # _MODS
 # from pygeodesy.vector3dBase import Vector3dBase  # _MODS
 
 from copy import copy as _copy
 
 __all__ = _ALL_LAZY.errors  # _ALL_DOCS('_InvalidError', '_IsnotError')  _under
-__version__ = '24.11.02'
+__version__ = '25.04.21'
 
 _argument_   = 'argument'
+_basics      = _MODS.into(basics=__name__)
 _box_        = 'box'
 _expected_   = 'expected'
 _limiterrors =  True  # in .formy
@@ -43,7 +44,7 @@ try:
     _exception_chaining = None  # not available
     _ = Exception().__cause__   # Python 3.9+ exception chaining
 
-    if _PYTHON_X_DEV or _getPYGEODESY('EXCEPTION_CHAINING'):  # == _std_
+    if _PYTHON_X_DEV or _envPYGEODESY('EXCEPTION_CHAINING'):  # == _std_
         _exception_chaining = True  # turned on, std
         raise AttributeError()  # allow exception chaining
 
@@ -143,8 +144,8 @@ def _TypesError(name, value, *Types, **kwds):
     '''
     # no longer C{class _TypesError} to avoid missing value
     # argument errors in _XError line ...E = Error(str(e))
-    t = _not_(_an(_or(*(t.__name__ for t in Types))))
-    return _TypeError(name, value, txt=t, **kwds)
+    t = _an(_or(*map(typename, Types, Types)))
+    return _TypeError(name, value, txt=_not_(t), **kwds)
 
 
 class _UnexpectedError(TypeError):  # note, a TypeError!
@@ -240,12 +241,12 @@ class LenError(_ValueError):  # in .ecef, .fmath, .heights, .iters, .named
                             (C{keyword arguments}).
         '''
         def _ns_vs_txt_x(cause=None, txt=_invalid_, **kwds):
-            ns, vs = zip(*_MODS.basics.itemsorted(kwds))  # unzip
+            ns, vs = zip(*_basics.itemsorted(kwds))  # unzip
             return ns, vs, txt, cause
 
         ns, vs, txt, x = _ns_vs_txt_x(**lens_txt)
         ns = _COMMASPACE_.join(ns)
-        t  = _streprs.Fmt.PAREN(where.__name__, ns)
+        t  = _streprs.Fmt.PAREN(typename(where), ns)
         vs = _vs__.join(map(str, vs))
         t  = _SPACE_(t, _len_, vs)
         _ValueError.__init__(self, t, txt=txt, cause=x)
@@ -379,8 +380,8 @@ def _and_or(last, *words):
 def crosserrors(raiser=None):
     '''Report or ignore vectorial cross product errors.
 
-       @kwarg raiser: Use C{True} to throw or C{False} to ignore
-                      L{CrossError} exceptions.  Use C{None} to
+       @kwarg raiser: Use C{True} to throw, C{False} to ignore
+                      L{CrossError} exceptions or C{None} to
                       leave the setting unchanged.
 
        @return: Previous setting (C{bool}).
@@ -389,8 +390,8 @@ def crosserrors(raiser=None):
     '''
     V = _MODS.vector3dBase.Vector3dBase
     t =  V._crosserrors  # XXX class attr!
-    if raiser in (True, False):
-        V._crosserrors = raiser
+    if raiser is not None:
+        V._crosserrors = bool(raiser)
     return t
 
 
@@ -419,7 +420,7 @@ def _error_init(Error, inst, args, fmt_name_value='%s (%r)', txt_not_=NN,
     t, n = (), len(args)
     if n > 2:
         t = _fmtuple(zip(args[0::2], args[1::2]))
-        s = _MODS.basics.isodd(n)
+        s = _basics.isodd(n)
         if s:  # XXX _xzip(..., strict=s)
             t += args[-1:]
     elif n == 2:
@@ -427,11 +428,11 @@ def _error_init(Error, inst, args, fmt_name_value='%s (%r)', txt_not_=NN,
     elif n:  # == 1
         t =  str(args[0]),
     if kwds:
-        t += _fmtuple(_MODS.basics.itemsorted(kwds))
+        t += _fmtuple(_basics.itemsorted(kwds))
     t = _or(*t) if t else _SPACE_(_name_value_, MISSING)
 
     x = _not_(txt_not_) if txt_not_ else (txt if txt__ is None
-                                    else  txt__.__name__)
+                                    else typename(txt__))
     if x is not None:
         x =  str(x) or (str(cause) if cause else _invalid_)
         C = _COMMASPACE_ if _COLON_ in t else _COLONSPACE_
@@ -447,9 +448,10 @@ def _error_init(Error, inst, args, fmt_name_value='%s (%r)', txt_not_=NN,
 def _error_under(inst):
     '''(INTERNAL) Remove leading underscore from instance' class name.
     '''
-    n = inst.__class__.__name__  # _tailof?
+    t = type(inst)
+    n = typename(t)  # _tailof?
     if n.startswith(_UNDER_):
-        inst.__class__.__name__ = n.lstrip(_UNDER_)
+        t.__name__ = n.lstrip(_UNDER_)
     return inst
 
 
@@ -469,7 +471,7 @@ def exception_chaining(exc=None):
               non-empty value prior to C{import pygeodesy}.
     '''
     return _exception_chaining if exc is None else \
-            getattr(exc, '__cause__', None)
+            getattr(exc, '__cause__', None)  # _DCAUSE_
 
 
 def _incompatible(this):
@@ -504,9 +506,9 @@ def isError(exc):
     def _X(exc):
         X = type(exc)
         m = X.__module__
-        return _MODS.basics.issubclassof(X, *_XErrors) or \
+        return _basics.issubclassof(X, *_XErrors) or \
                ((m is __name__ or m == __name__) and
-               _tailof(X.__name__).startswith(_UNDER_))
+               _tailof(typename(X)).startswith(_UNDER_))
 
     return True   if isinstance(exc, _XErrors)   else (
           _X(exc) if isinstance(exc,  Exception) else None)
@@ -527,23 +529,23 @@ def _IsnotError(*types__, **name_value_Error_cause):  # name=value [, Error=Type
     n, v    = _xkwds_item2(kwds)
 
     n = _streprs.Fmt.PARENSPACED(n, repr(v))
-    t = _not_(_an(_or(*_DUNDER_nameof_(*types__))) if types__ else _specified_)
-    return _XError(E, n, txt=t, cause=x)
+    t = _an(_or(*map(typename, types__, types__))) if types__ else _specified_
+    return _XError(E, n, txt=_not_(t), cause=x)
 
 
 def limiterrors(raiser=None):
     '''Get/set the throwing of L{LimitError}s.
 
-       @kwarg raiser: Choose C{True} to raise or C{False} to
-                      ignore L{LimitError} exceptions.  Use
+       @kwarg raiser: Use C{True} to raise, C{False} to
+                      ignore L{LimitError} exceptions or
                       C{None} to leave the setting unchanged.
 
        @return: Previous setting (C{bool}).
     '''
     global _limiterrors
     t = _limiterrors
-    if raiser in (True, False):
-        _limiterrors = raiser
+    if raiser is not None:
+        _limiterrors = bool(raiser)
     return t
 
 
@@ -576,16 +578,16 @@ def _parseX(parser, *args, **Error_name_values):  # name=value[, ..., Error=Pars
 def rangerrors(raiser=None):
     '''Get/set the throwing of L{RangeError}s.
 
-       @kwarg raiser: Choose C{True} to raise or C{False} to ignore
-                      L{RangeError} exceptions.  Use C{None} to leave
+       @kwarg raiser: Use C{True} to raise or C{False} to ignore
+                      L{RangeError} exceptions or C{None} to leave
                       the setting unchanged.
 
        @return: Previous setting (C{bool}).
     '''
     global _rangerrors
     t = _rangerrors
-    if raiser in (True, False):
-        _rangerrors = raiser
+    if raiser is not None:
+        _rangerrors = bool(raiser)
     return t
 
 
@@ -648,7 +650,7 @@ def _xcallable(**names_callables):
     '''
     for n, c in names_callables.items():
         if not callable(c):
-            raise _TypeError(n, c, txt_not_=callable.__name__)  # txt__
+            raise _TypeError(n, c, txt_not_=typename(callable))  # txt__
 
 
 def _xdatum(datum1, datum2, Error=None):
@@ -685,9 +687,8 @@ def _xellipsoidall(point):  # ... elel, see _xellipsoidal
     m = _MODS.ellipsoidalBase
     ll = isinstance(point, m.LatLonEllipsoidalBase)
     if not ll:
-        b = _MODS.basics
-        b._xinstanceof(m.CartesianEllipsoidalBase,
-                       m.LatLonEllipsoidalBase, point=point)
+        _basics._xinstanceof(m.CartesianEllipsoidalBase,
+                             m.LatLonEllipsoidalBase, point=point)
     return ll
 
 
@@ -734,7 +735,7 @@ def _xError2(exc):  # in .constants, .fsums, .lazily, .vector2d
     elif x is None:
         E = _AssertionError
     else:  # get _Error from Error
-        n =  NN(_UNDER_, _tailof(type(exc).__name__))
+        n =  NN(_UNDER_, _tailof(typename(type(exc))))
         E = _MODS.getattr(__name__, n, _NotImplementedError)
         x =  E is not _NotImplementedError
     return E, (str(exc) if x else repr(exc))
@@ -783,9 +784,9 @@ except AttributeError:
 #     for n, v in kwds.items():
 #         b = getattr(inst, n, None)
 #         if b is None:  # invalid bool attr
-#             t = _SPACE_(_EQUAL_(n, repr(v)), 'for', inst.__class__.__name__)  # XXX .classname
+#             t = _SPACE_(_EQUAL_(n, repr(v)), 'for', typename(type(inst))  # XXX .classname
 #             raise _AttributeError(t, txt_not_='applicable')
-#         if v in (False, True) and v != b:
+#         if _basics.isbool(v) and v != b:
 #             setattr(inst, NN(_UNDER_, n), v)
 
 
@@ -819,7 +820,7 @@ def _xkwds_get(kwds, **name_default):
 #     '''
 #     if not isinstance(kwds, dict):
 #         raise _xAssertionError(_xkwds_get_, kwds)
-#     for n, v in _MODS.basics.itemsorted(names_defaults):
+#     for n, v in _basics.itemsorted(names_defaults):
 #         yield kwds.get(n, v)
 
 
@@ -886,7 +887,7 @@ def _Xorder(_Coeffs, Error, **Xorder):  # in .auxLat, .ktm, .rhumb.bases, .rhumb
     '''(INTERNAL) Validate C{RAorder} or C{TMorder}.
     '''
     X, m = _xkwds_item2(Xorder)
-    if m in _Coeffs and _MODS.basics.isint(m):
+    if m in _Coeffs and _basics.isint(m):
         return m
     t = sorted(map(str, _Coeffs.keys()))
     raise Error(X, m, txt_not_=_or(*t))
@@ -908,9 +909,9 @@ def _xsError(X, xs, i, x, *n, **kwds):  # in .fmath, ._fstats, .fsums
 def _xStrError(*Refs, **name_value_Error):  # in .gars, .geohash, .wgrs
     '''(INTERNAL) Create a C{TypeError} for C{Garef}, C{Geohash}, C{Wgrs}.
     '''
-    S = _MODS.unitsBase.Str
-    r =  tuple(r.__name__ for r in Refs) + (S.__name__, _LatLon_, 'LatLon*Tuple')
-    return _IsnotError(*r, **name_value_Error)
+    s = typename(_MODS.unitsBase.Str)
+    t = tuple(map(typename, Refs)) + (s, _LatLon_, 'LatLon*Tuple')
+    return _IsnotError(*t, **name_value_Error)
 
 # **) MIT License
 #

pygeodesy/etm.py

@@ -63,7 +63,7 @@ which maintains accuracy near C{phi = pi/2}.  Such changes are noted in the code
 # make sure int/int division yields float quotient, see .basics
 from __future__ import division as _; del _  # PYCHOK semicolon
 
-from pygeodesy.basics import map1, neg, neg_, _xinstanceof
+from pygeodesy.basics import _isin, map1, neg, neg_, _xinstanceof
 from pygeodesy.constants import EPS, EPS02, PI_2, PI_4, _K0_UTM, \
                              _1_EPS, _0_0, _0_1, _0_5, _1_0, _2_0, \
                              _3_0, _90_0, isnear0, isnear90
@@ -74,9 +74,9 @@ from pygeodesy.datums import _ellipsoidal_datum, _WGS84,  _EWGS84
 # from pygeodesy.errors import _incompatible  # from .named
 # from pygeodesy.fsums import Fsum  # from .fmath
 from pygeodesy.fmath import cbrt, hypot, hypot1, hypot2,  Fsum
-from pygeodesy.interns import _COMMASPACE_, _near_, _SPACE_, _spherical_
-from pygeodesy.karney import _K_2_4, _copyBit, _diff182, _fix90, \
-                             _norm2, _norm180, _tand, _unsigned2
+from pygeodesy.interns import _COMMASPACE_, _DMAIN_, _near_, _SPACE_, _spherical_
+from pygeodesy.karney import _K_2_4, _copyBit, _diff182, _fix90, _norm2, \
+                            _norm180, _tand, _unsigned2
 # from pygeodesy.lazily import _ALL_LAZY, _ALL_MODS as _MODS  # from .named
 from pygeodesy.named import callername, _incompatible, _NamedBase, \
                            _ALL_LAZY, _MODS
@@ -93,7 +93,7 @@ from pygeodesy.utm import _cmlon, _LLEB, _parseUTM5, _toBand, _toXtm8, \
 from math import asinh, degrees, radians, sinh, sqrt
 
 __all__ = _ALL_LAZY.etm
-__version__ = '25.01.12'
+__version__ = '25.04.14'
 
 _OVERFLOW = _1_EPS**2  # ~2e+31
 _TAYTOL   =  pow(EPS,  0.6)
@@ -268,7 +268,7 @@ class ExactTransverseMercator(_NamedBase):
             self.raiser = True
 
         TM = ExactTransverseMercator
-        if datum not in (TM._datum, TM._E, None):
+        if not _isin(datum, None, TM._datum, TM._E):
             self.datum = datum  # invokes ._resets
         if lon0 or lon0 != TM._lon0:
             self.lon0 = lon0
@@ -1101,7 +1101,7 @@ def toEtm8(latlon, lon=None, datum=None, Etm=Etm, falsed=True,
                         n, latlon, d.exactTM, Error=ETMError)
 
 
-if __name__ == '__main__':  # MCCABE 16
+if __name__ == _DMAIN_:  # MCCABE 16
 
     def _main():
 

pygeodesy/fmath.py

@@ -1,19 +1,21 @@
 
 # -*- coding: utf-8 -*-
 
-u'''Utilities using precision floating point summation.
+u'''Utilities for precision floating point summation, multiplication,
+C{fused-multiply-add}, polynomials, roots, etc.
 '''
 # make sure int/int division yields float quotient, see .basics
 from __future__ import division as _; del _  # PYCHOK semicolon
 
 from pygeodesy.basics import _copysign, copysign0, isbool, isint, isscalar, \
-                              len2, map1, _xiterable
+                              len2, map1, _xiterable,  typename
 from pygeodesy.constants import EPS0, EPS02, EPS1, NAN, PI, PI_2, PI_4, \
                                _0_0, _0_125, _1_6th, _0_25, _1_3rd, _0_5, _1_0, \
                                _1_5, _copysign_0_0, isfinite, remainder
 from pygeodesy.errors import _IsnotError, LenError, _TypeError, _ValueError, \
                              _xError, _xkwds, _xkwds_pop2, _xsError
 from pygeodesy.fsums import _2float, Fsum, fsum, _isFsum_2Tuple,  Fmt, unstr
+# from pygeodesy.internals import typename  # from .basics
 from pygeodesy.interns import MISSING, _negative_, _not_scalar_
 from pygeodesy.lazily import _ALL_LAZY, _ALL_MODS as _MODS
 # from pygeodesy.streprs import Fmt, unstr  # from .fsums
@@ -23,10 +25,10 @@ from math import fabs, sqrt  # pow
 import operator as _operator  # in .datums, .trf, .utm
 
 __all__ = _ALL_LAZY.fmath
-__version__ = '25.01.09'
+__version__ = '25.04.30'
 
 # sqrt(2) - 1 <https://WikiPedia.org/wiki/Square_root_of_2>
-_0_4142  =  0.41421356237309504880  # ... ~ 3730904090310553 / 9007199254740992
+_0_4142  =  0.41421356237309504880  # ~ 3_730_904_090_310_553 / 9_007_199_254_740_992
 _2_3rd   = _1_3rd * 2
 _h_lt_b_ = 'abs(h) < abs(b)'
 
@@ -64,13 +66,27 @@ class Fdot(Fsum):
         self._facc_dot(n, a, b, **kwds)
 
 
+class Fdot_(Fdot):
+    '''Precision dot product.
+    '''
+    def __init__(self, *xys, **start_name_f2product_nonfinites_RESIDUAL):
+        '''New L{Fdot_} precision dot product M{sum(xys[i] * xys[i+1] for i in
+           range(0, len(xys), B{2}))}.
+
+           @arg xys: Pairwise values (each C{scalar}, an L{Fsum} or L{Fsum2Tuple}),
+                     all positional.
+
+           @see: Class L{Fdot<Fdot.__init__>} for further details.
+        '''
+        Fdot.__init__(self, xys[0::2], *xys[1::2], **start_name_f2product_nonfinites_RESIDUAL)
+
+
 class Fhorner(Fsum):
     '''Precision polynomial evaluation using the Horner form.
     '''
     def __init__(self, x, *cs, **incx_name_f2product_nonfinites_RESIDUAL):
-        '''New L{Fhorner} form evaluation of polynomial M{sum(cs[i] * x**i for
-           i=0..n)} with in- or decreasing exponent M{sum(... i=n..0)}, where C{n
-           = len(cs) - 1}.
+        '''New L{Fhorner} form evaluation of polynomial M{sum(cs[i] * x**i for i=0..n)}
+           with in- or decreasing exponent M{sum(... i=n..0)}, where C{n = len(cs) - 1}.
 
            @arg x: Polynomial argument (C{scalar}, an L{Fsum} or L{Fsum2Tuple}).
            @arg cs: Polynomial coeffients (each C{scalar}, an L{Fsum} or L{Fsum2Tuple}),
@@ -294,9 +310,8 @@ def euclid(x, y):
        @see: Function L{euclid_}.
     '''
     x, y = abs(x), abs(y)  # NOT fabs!
-    if y > x:
-        x, y = y, x
-    return x + y * _0_4142  # * _0_5 before 20.10.02
+    return (x + y * _0_4142) if x > y else \
+           (y + x * _0_4142)  # * _0_5 before 20.10.02
 
 
 def euclid_(*xs):
@@ -453,7 +468,8 @@ def fdot_(*xys, **start_f2product_nonfinites):
 
        @return: Dot product (C{float}).
     '''
-    return fdot(xys[0::2], *xys[1::2], **start_f2product_nonfinites)
+    D = Fdot_(*xys, **_xkwds(start_f2product_nonfinites, nonfinites=True))
+    return float(D)
 
 
 def fdot3(xs, ys, zs, **start_f2product_nonfinites):
@@ -554,7 +570,7 @@ def fidw(xs, ds, beta=2):
 
 
 try:
-    from math import fma as _fma
+    from math import fma as _fma  # in .resections
 except  ImportError:  # PYCHOK DSPACE!
 
     def _fma(x, y, z):  # no need for accuracy
@@ -656,7 +672,7 @@ def fpowers(x, n, alts=0):
        @raise ValueError: Non-finite B{C{x}} or invalid B{C{n}}.
     '''
     if not isint(n):
-        raise _IsnotError(int.__name__, n=n)
+        raise _IsnotError(typename(int), n=n)
     elif n < 1:
         raise _ValueError(n=n)
 
@@ -736,7 +752,7 @@ def frange(start, number, step=1):
              numpy/reference/generated/numpy.arange.html>}.
     '''
     if not isint(number):
-        raise _IsnotError(int.__name__, number=number)
+        raise _IsnotError(typename(int), number=number)
     for i in range(number):
         yield start + (step * i)
 

pygeodesy/formy.py

@@ -6,25 +6,24 @@ u'''Formulary of basic geodesy functions and approximations.
 # make sure int/int division yields float quotient, see .basics
 from __future__ import division as _; del _  # PYCHOK semicolon
 
-# from pygeodesy.basics import _args_kwds_count2, _copysign  # from .constants
+from pygeodesy.basics import _copysign, _isin  # _args_kwds_count2
 # from pygeodesy.cartesianBase import CartesianBase  # _MODS
 from pygeodesy.constants import EPS, EPS0, EPS1, PI, PI2, PI3, PI_2, R_M, \
                                _0_0s, float0_, isnon0, remainder, _umod_PI2, \
                                _0_0, _0_125, _0_25, _0_5, _1_0, _2_0, _4_0, \
-                               _90_0, _180_0, _360_0,  _copysign
+                               _90_0, _180_0, _360_0
 from pygeodesy.datums import Datum, Ellipsoid, _ellipsoidal_datum, \
                             _mean_radius, _spherical_datum, _WGS84,  _EWGS84
 # from pygeodesy.ellipsoids import Ellipsoid, _EWGS84  # from .datums
 from pygeodesy.errors import IntersectionError, LimitError, limiterrors, \
                             _TypeError, _ValueError, _xattr, _xError, \
-                            _xcallable,_xkwds, _xkwds_pop2
+                            _xcallable, _xkwds, _xkwds_pop2
 from pygeodesy.fmath import euclid, fdot_, fprod, hypot, hypot2, sqrt0
 from pygeodesy.fsums import fsumf_,  Fmt, unstr
-# from pygeodesy.internals import _DUNDER_nameof  # from .named
+# from pygeodesy.internals import typename  # from .named
 from pygeodesy.interns import _delta_, _distant_, _inside_, _SPACE_, _too_
 from pygeodesy.lazily import _ALL_LAZY, _ALL_MODS as _MODS
-from pygeodesy.named import _name__, _name2__, _NamedTuple, _xnamed, \
-                            _DUNDER_nameof
+from pygeodesy.named import _name__, _name2__, _NamedTuple, _xnamed,  typename
 from pygeodesy.namedTuples import Bearing2Tuple, Distance4Tuple, LatLon2Tuple, \
                                   Intersection3Tuple, PhiLam2Tuple
 # from pygeodesy.streprs import Fmt, unstr  # from .fsums
@@ -43,7 +42,7 @@ from contextlib import contextmanager
 from math import atan, cos, degrees, fabs, radians, sin, sqrt  # pow
 
 __all__ = _ALL_LAZY.formy
-__version__ = '25.01.05'
+__version__ = '25.04.14'
 
 _RADIANS2 =  radians(_1_0)**2  # degree to radians-squared
 _ratio_   = 'ratio'
@@ -371,9 +370,9 @@ def _dS(fun_, radius, wrap, *lls, **adjust):
 def _ellipsoidal(earth, where):
     '''(INTERNAL) Helper for distances.
     '''
-    return _EWGS84 if earth in (_WGS84, _EWGS84)   else (
-             earth if isinstance(earth, Ellipsoid) else
-            (earth if isinstance(earth, Datum)     else  # PYCHOK indent
+    return _EWGS84 if _isin(earth, _EWGS84, _WGS84) else (
+             earth if  isinstance(earth, Ellipsoid) else
+            (earth if  isinstance(earth, Datum)     else  # PYCHOK indent
             _ellipsoidal_datum(earth, name__=where)).ellipsoid)
 
 
@@ -1077,8 +1076,8 @@ class _idllmn6(object):  # see also .geodesicw._wargs, .latlonBase._toCartesian3
             if wrap:
                 _, lat2, lon2 = _Wrap.latlon3(lon1, lat2, lon2, wrap)
                 kwds = _xkwds(kwds, wrap=wrap)  # for _xError
-            m =  small if small is _100km else Meter_(small=small)
-            n = _DUNDER_nameof(intersections2 if s else intersection2)
+            m = small if small is _100km else Meter_(small=small)
+            n = typename(intersections2 if s else intersection2)
             if datum is None or euclidean(lat1, lon1, lat2, lon2) < m:
                 d, m = None, _MODS.vector3d
                 _i   = m._intersects2 if s else m._intersect3d3