pygeodesy 25.1.9__py2.py3-none-any.whl → 25.4.25__py2.py3-none-any.whl

pygeodesy/clipy.py

@@ -12,11 +12,12 @@ I{Greiner-Hormann} and L{clipSH} and L{clipSH3} I{Sutherland-Hodgeman}.
 # make sure int/int division yields float quotient, see .basics
 from __future__ import division as _; del _  # PYCHOK semicolon
 
-# from pygeodesy.basics import len2  # from .fmath
+from pygeodesy.basics import len2,  typename
 from pygeodesy.constants import EPS, _0_0, _1_0
 from pygeodesy.errors import _AssertionError, ClipError, PointsError
-from pygeodesy.fmath import fabs, len2,  Fsum
+from pygeodesy.fmath import fabs,  Fsum
 # from pygeodesy.fsums import Fsum  # from .fmath
+# from pygeodesy.internals import typename  # from .basics
 from pygeodesy.interns import NN, _clipid_, _convex_, _DOT_, _end_, _few_, \
                              _fi_, _height_, _i_, _invalid_, _j_, _lat_, \
                              _lon_, _near_, _not_, _points_, _start_, _too_
@@ -30,7 +31,7 @@ from pygeodesy.units import Bool, FIx, HeightX, Lat, Lon, Number_
 # from math import fabs  # from .fmath
 
 __all__ = _ALL_LAZY.clipy
-__version__ = '23.09.20'
+__version__ = '25.04.14'
 
 _fj_       = 'fj'
 _original_ = 'original'
@@ -126,7 +127,7 @@ class _CS(_Named):
 #       elif c & _CS._XR:
 #           return self.lat4(p, self._xr)
 #       # should never get here
-#       raise _AssertionError(self._DOT_(self.clip4.__name__))
+#       raise _AssertionError(self._DOT_(typename(self.clip4)))
 
     def code4(self, p):  # compute code for point p
         if p.lat < self._yb:
@@ -168,7 +169,7 @@ class _CS(_Named):
 
     def nop4(self, b, p):  # PYCHOK no cover
         if p:  # should never get here
-            raise _AssertionError(self._DOT_(self.nop4.__name__))
+            raise _AssertionError(self._DOT_(typename(self.nop4)))
         return _CS._IN, self.nop4, b, p
 
 
@@ -202,7 +203,7 @@ def clipCS4(points, lowerleft, upperight, closed=False, inull=False):
        @raise PointsError: Insufficient number of B{C{points}}.
     '''
     T4 =  ClipCS4Tuple
-    cs = _CS(lowerleft, upperight, name=clipCS4.__name__)
+    cs = _CS(lowerleft, upperight, name=typename(clipCS4))
     n, pts = _pts2(points, closed, inull)
 
     i, m = _imdex2(closed, n)
@@ -398,7 +399,7 @@ def clipLB6(points, lowerleft, upperight, closed=False, inull=False):
              U{Liang-Barsky algorithm<https://WikiPedia.org/wiki/Liang-Barsky_algorithm>}.
     '''
     xl, yb, \
-    xr, yt = _box4(lowerleft, upperight, clipLB6.__name__)
+    xr, yt = _box4(lowerleft, upperight, typename(clipLB6))
     n, pts = _pts2(points, closed, inull)
 
     T6  =  ClipLB6Tuple
@@ -578,7 +579,7 @@ class _SH(_Named):
         fx = float(p2.lon - x)
         d  = fy * dx - fx * dy  # fdot((fx, fy), dx, -dy)
         if fabs(d) < EPS:  # PYCHOK no cover
-            raise _AssertionError(self._DOT_(self.intersect.__name__))
+            raise _AssertionError(self._DOT_(typename(self.intersect)))
         d  = Fsum(self._xy, -y * dx, x * dy).fover(d)
         y += d * fy
         x += d * fx
@@ -644,7 +645,7 @@ def clipSH(points, corners, closed=False, inull=False):
 
        @raise PointsError: Insufficient number of B{C{points}}.
     '''
-    sh = _SH(corners, name=clipSH.__name__)
+    sh = _SH(corners, name=typename(clipSH))
     n, pts = sh.clip2(points, closed, inull)
     for i in range(n):
         p, _ = sh.clipped2(pts[i])
@@ -671,7 +672,7 @@ def clipSH3(points, corners, closed=False, inull=False):
 
        @raise PointsError: Insufficient number of B{C{points}} or B{C{corners}}.
     '''
-    sh = _SH(corners, name=clipSH3.__name__)
+    sh = _SH(corners, name=typename(clipSH3))
     n, pts = sh.clip2(points, closed, inull)
     if n > 1:
         T3 = ClipSH3Tuple

pygeodesy/constants.py

@@ -13,8 +13,8 @@ from __future__ import division as _; del _  # PYCHOK semicolon
 from pygeodesy.basics import _copysign, isbool, iscomplex, isint
 from pygeodesy.errors import _xError, _xError2, _xkwds_get1, _xkwds_item2
 # from pygeodesy.fsums import _isFsum_2Tuple  # _MODS
-from pygeodesy.internals import _0_0, _100_0
-from pygeodesy.interns import _INF_, _NAN_, _UNDER_
+from pygeodesy.internals import _0_0, _100_0, typename
+from pygeodesy.interns import _DMAIN_, _INF_, _NAN_
 from pygeodesy.lazily import _ALL_MODS as _MODS, _ALL_LAZY
 # from pygeodesy.streprs import Fmt  # from .unitsBase
 from pygeodesy.unitsBase import Float, Int, Radius,  Fmt
@@ -26,7 +26,7 @@ except ImportError:  # Python 2-
     _inf, _nan = float(_INF_), float(_NAN_)
 
 __all__ = _ALL_LAZY.constants
-__version__ = '24.12.22'
+__version__ = '25.04.14'
 
 
 def _copysign_0_0(y):
@@ -360,7 +360,7 @@ def isfinite(obj):
             return _iscfinite(obj)
         if _MODS.fsums._isFsum_2Tuple(obj):  # OverflowError
             return obj.is_finite()
-        raise _xError(x, Fmt.PAREN(isfinite.__name__, obj))
+        raise _xError(x, Fmt.PAREN(typename(isfinite), obj))
 
 
 def isint0(obj, both=False):
@@ -493,13 +493,14 @@ def _umod_PI2(rad):
     return (rad % PI2) or _0_0
 
 
-if __name__ == '__main__':
+if __name__ == _DMAIN_:
 
-    def _main():
+    def _main(locals):
         from pygeodesy import itemsorted, printf
+        from pygeodesy.interns import _DALL_, _UNDER_
 
         t = n = v = []
-        for n, v in itemsorted(locals()):
+        for n, v in itemsorted(locals):
             if isinstance(v, (Float, Int, Radius)):
                 printf('%9s: %r', n, v.toRepr(std=False))
                 if v.name != n:
@@ -508,10 +509,10 @@ if __name__ == '__main__':
                     raise AssertionError('%r is not %r' % (n, v))
                 if not n.startswith(_UNDER_):
                     t.append(n)
-        t.append(float_.__name__)
-        printf('__all__ = %r', tuple(t))
+        t.append(typename(float_))
+        printf('%s = %r', _DALL_, tuple(t))
 
-    _main()
+    _main(locals())
 
 # **) MIT License
 #

pygeodesy/css.py

@@ -3,12 +3,13 @@
 
 u'''Cassini-Soldner (CSS) projection.
 
-Classes L{CassiniSoldner}, L{Css} and L{CSSError} requiring I{Charles Karney}'s
-U{geographiclib <https://PyPI.org/project/geographiclib>} Python package to be
-installed.
+Classes L{CassiniSoldner}, L{Css} and L{CSSError} use I{Charles Karney}'s
+U{geographiclib <https://PyPI.org/project/geographiclib>} Python package
+if installed, see property L{CassiniSoldner.geodesic}.
 '''
 
-from pygeodesy.basics import islistuple, neg, _xinstanceof, _xsubclassof
+from pygeodesy.basics import _isin, islistuple, neg, _xinstanceof, \
+                             _xsubclassof
 from pygeodesy.constants import _umod_360, _0_0, _0_5, _90_0
 from pygeodesy.datums import _ellipsoidal_datum, _WGS84
 from pygeodesy.ellipsoidalBase import LatLonEllipsoidalBase as _LLEB
@@ -33,7 +34,7 @@ from pygeodesy.units import Azimuth, Degrees, Easting, Height, _heigHt, \
 # from math import fabs  # from .karney
 
 __all__ = _ALL_LAZY.css
-__version__ = '24.11.06'
+__version__ = '25.04.14'
 
 
 def _CS0(cs0):
@@ -76,7 +77,7 @@ class CassiniSoldner(_NamedBase):
 
            @raise CSSError: Invalid B{C{lat}} or B{C{lon}}.
         '''
-        if datum not in (None, self._datum):
+        if not _isin(datum, None, self._datum):
             self._datum = _xellipsoidal(datum=_ellipsoidal_datum(datum, **name))
         if name:
             self.name = name
@@ -217,9 +218,10 @@ class CassiniSoldner(_NamedBase):
     @Property
     def geodesic(self):
         '''Get this projection's I{wrapped} U{geodesic.Geodesic
-           <https://GeographicLib.SourceForge.io/Python/doc/code.html>}, provided
+           <https://GeographicLib.SourceForge.io/Python/doc/code.html>} from
            I{Karney}'s U{geographiclib<https://PyPI.org/project/geographiclib>}
-           package is installed, otherwise an I{exact} L{GeodesicExact} instance.
+           package if installed, otherwise an I{exact} L{GeodesicExact
+           <pygeodesy.geodesicx.GeodesicExact>} instance.
         '''
         g = self._geodesic
         if g is None:
@@ -247,7 +249,8 @@ class CassiniSoldner(_NamedBase):
 
     @Property_RO
     def isExact(self):
-        '''Return C{True} if this projection's geodesic is L{GeodesicExact}.
+        '''Return C{True} if this projection's geodesic is L{GeodesicExact
+           <pygeodesy.geodesicx.GeodesicExact>}.
         '''
         return isinstance(self.geodesic, _MODS.geodesicx.GeodesicExact)
 
@@ -306,8 +309,8 @@ class CassiniSoldner(_NamedBase):
 
         g = self.geodesic
         self._meridian = m = g.Line(Lat_(lat0=lat0, Error=CSSError),
-                                    Lon_(lon0=lon0, Error=CSSError), _0_0,
-                                    g.STANDARD | g.DISTANCE_IN | g.LINE_OFF)
+                                    Lon_(lon0=lon0, Error=CSSError),
+                                   _0_0, caps=g.STANDARD_LINE | g.LINE_OFF)
         self._latlon0 = LatLon2Tuple(m.lat1, m.lon1)
         s, c = _sincos2d(m.lat1)  # == self.lat0 == self.LatitudeOrigin()
         self._sb0, self._cb0 = _norm2(s * g.f1, c)

pygeodesy/datums.py

@@ -67,7 +67,7 @@ datum, q.v. U{"A Guide to Coordinate Systems in Great Britain", Section 6
 # make sure int/int division yields float quotient, see .basics
 from __future__ import division as _; del _  # PYCHOK semicolon
 
-from pygeodesy.basics import islistuple, map2, neg, _xinstanceof, _zip
+from pygeodesy.basics import _isin, islistuple, map2, neg, _xinstanceof, _zip
 from pygeodesy.constants import R_M, _float as _F, _0_0, _1_0, _2_0, _8_0, _3600_0
 # from pygeodesy.ellipsoidalBase import CartesianEllipsoidalBase as _CEB, \
 #                                          LatLonEllipsoidalBase as _LLEB  # MODS
@@ -77,10 +77,10 @@ from pygeodesy.errors import _IsnotError, _TypeError, _xellipsoidall, _xkwds, _x
 from pygeodesy.fmath import fdot, fmean,  Fmt, _operator
 from pygeodesy.internals import _passarg, _under
 from pygeodesy.interns import NN, _a_, _Airy1830_, _AiryModified_, _BAR_, _Bessel1841_, \
-                             _Clarke1866_, _Clarke1880IGN_, _COMMASPACE_, _DOT_, _earth_, \
-                             _ellipsoid_, _ellipsoidal_, _GRS80_, _Intl1924_, _MINUS_, \
-                             _Krassovski1940_, _Krassowsky1940_, _NAD27_, _NAD83_, _s_, \
-                             _PLUS_, _Sphere_, _spherical_, _transform_, _UNDER_, \
+                             _Clarke1866_, _Clarke1880IGN_, _COMMASPACE_, _DMAIN_,_DOT_, \
+                             _earth_, _ellipsoid_, _ellipsoidal_, _GRS80_, _Intl1924_, \
+                             _MINUS_, _Krassovski1940_, _Krassowsky1940_, _NAD27_, _NAD83_, \
+                             _s_, _PLUS_, _Sphere_, _spherical_, _transform_, _UNDER_, \
                              _WGS72_, _WGS84_
 from pygeodesy.lazily import _ALL_LAZY, _ALL_MODS as _MODS
 from pygeodesy.named import _lazyNamedEnumItem as _lazy, _name__, _name2__, _NamedEnum, \
@@ -94,7 +94,7 @@ from pygeodesy.units import _isRadius, Radius_,  radians
 # import operator as _operator  # from .fmath
 
 __all__ = _ALL_LAZY.datums
-__version__ = '24.10.12'
+__version__ = '25.04.14'
 
 _a_ellipsoid_ = _UNDER_(_a_, _ellipsoid_)
 _BD72_        = 'BD72'
@@ -510,7 +510,7 @@ def _earth_datum(inst, a_earth, f=None, raiser=_a_ellipsoid_, **name):  # in .ka
         E, n, D = _EnD3((a_earth, f), name)
         if raiser and not E:
             raise _TypeError(f=f, **{raiser: a_earth})
-    elif a_earth in (_EWGS84, _WGS84, None) and inst._datum is _WGS84:
+    elif _isin(a_earth, None, _EWGS84, _WGS84) and inst._datum is _WGS84:
         return
     elif isinstance(a_earth, Datum):
         E, n, D =  None, NN, a_earth
@@ -721,7 +721,7 @@ _WGS84 = Datums.WGS84
 assert _WGS84.ellipsoid is _EWGS84
 # assert _WGS84.transform.isunity
 
-if __name__ == '__main__':
+if __name__ == _DMAIN_:
 
     from pygeodesy.interns import _COMMA_, _NL_, _NLATvar_
     from pygeodesy import printf

pygeodesy/deprecated/bases.py

@@ -9,11 +9,11 @@ from pygeodesy.latlonBase import LatLonBase as _LatLonBase
 from pygeodesy.lazily import _ALL_DEPRECATED
 
 __all__ = _ALL_DEPRECATED.deprecated_bases
-__version__ = '23.11.25'
+__version__ = '25.04.09'
 
 
 class LatLonHeightBase(_LatLonBase):  # PYCHOK no cover
-    ''''DEPRECATED on 2021.02.10, use (INTERNAL) class L{pygeodesy.latlonBase.LatLonBase}.'''
+    '''DEPRECATED on 2021.02.10, use (INTERNAL) class L{pygeodesy.latlonBase.LatLonBase}.'''
     pass
 
 

pygeodesy/deprecated/classes.py

@@ -22,7 +22,7 @@ from pygeodesy.trf import TRFXform7Tuple as _TRFXform7Tuple
 from pygeodesy.units import Bearing, Int, Lamd, Lat, Lon, Meter, Phid
 
 __all__ = _ALL_DEPRECATED.deprecated_classes
-__version__ = '24.12.31'
+__version__ = '25.04.11'
 
 
 class _Deprecated_NamedTuple(_NamedTuple):
@@ -349,7 +349,7 @@ class UtmUps4Tuple(_Deprecated_NamedTuple):  # PYCHOK no cover
 
 
 class XDist(ADict):
-    '''DEPRECATED on 2024.07.02, use class L{XDict}.'''
+    '''DEPRECATED on 2024.07.02, use class L{ADict}.'''
     def __init__(self, *args, **kwds):  # PYCHOK no cover
         deprecated_class(self.__class__)
         ADict.__init__(self, *args, **kwds)

pygeodesy/deprecated/consterns.py

@@ -9,21 +9,21 @@ from pygeodesy.lazily import _ALL_DEPRECATED
 from pygeodesy.units import Float, Int, Str
 
 __all__ = _ALL_DEPRECATED.deprecated_consterns
-__version__ = '23.11.24'
+__version__ = '25.04.09'
 
 
 class _Deprecated_Float(Float):
-    '''DEPRECATED on 2023.09.12, don't use.'''
+    '''DEPRECATED on 2023.09.12, I{don't use}.'''
     pass
 
 
 class _Deprecated_Int(Int):
-    '''DEPRECATED on 2023.09.12, don't use.'''
+    '''DEPRECATED on 2023.09.12, I{don't use}.'''
     pass
 
 
 class _Deprecated_Str(Str):
-    '''DEPRECATED on 2023.09.12, don't use.'''
+    '''DEPRECATED on 2023.09.12, I{don't use}.'''
     pass
 
 

pygeodesy/dms.py

@@ -62,11 +62,11 @@ U{Vector-based geodesy<https://www.Movable-Type.co.UK/scripts/latlong-vectors.ht
 '''
 
 from pygeodesy.basics import copysign0, isLatLon, isodd, issequence, isstr, \
-                             neg as _neg  # in .ups
+                             neg as _neg,  typename  # in .ups
 from pygeodesy.constants import _umod_360, _0_0, _0_5, _60_0, _360_0, _3600_0
 from pygeodesy.errors import ParseError, RangeError, _TypeError, _ValueError, \
-                            _parseX, rangerrors, _xError, _xkwds,  _getPYGEODESY
-# from pygeodesy.internals import _getPYGEODESY  # from .errors
+                            _parseX, rangerrors, _xError, _xkwds,  _envPYGEODESY
+# from pygeodesy.internals import _envPYGEODESY, typename  # from .errors
 from pygeodesy.interns import NN, _COMMA_, _d_, _DASH_, _deg_, _degrees_, _DOT_, \
                              _0_, _e_, _E_, _EW_, _f_, _F_, _g_, _MINUS_, _N_, \
                              _NE_, _NS_, _NSEW_, _NW_, _PERCENTDOTSTAR_, _PLUS_, \
@@ -86,7 +86,7 @@ except ImportError:  # Python 3+
     from string import ascii_letters as _LETTERS
 
 __all__ = _ALL_LAZY.dms
-__version__ = '24.10.18'
+__version__ = '25.04.14'
 
 _beyond_      = 'beyond'
 _deg_min_     = 'deg+min'
@@ -100,7 +100,7 @@ F_D_,  F_DM_,  F_DMS_,  F_DEG_,  F_MIN_,  F_SEC_,  F_D60_,  F__E_,  F__F_,  F__G
 F_D__, F_DM__, F_DMS__, F_DEG__, F_MIN__, F_SEC__, F_D60__, F__E__, F__F__, F__G__, F_RAD__ = (NN(
  _PLUS_, _)  for _ in _F_s)
 del _F_s
-_F_DMS  = _getPYGEODESY('FMT_FORM') or F_DMS
+_F_DMS  = _envPYGEODESY('FMT_FORM') or F_DMS
 
 _F_case = {F_D:   F_D,   F_DEG: F_D,   _degrees_: F_D,  # unsigned _F_s
            F_DM:  F_DM,  F_MIN: F_DM,  _deg_min_: F_DM,
@@ -348,7 +348,7 @@ def compassPoint(bearing, prec=3):
         p = _MODS.units.Precision_(prec, low=1, high=4) \
              if prec != 3 else int(prec)
         m =  2 << p
-        w = 32 // m  # if m in (4, 8, 16, 32)
+        w = 32 // m  # if _isin(m, 4, 8, 16, 32)
         # not round(b), half-even rounding in Python 3+, but
         # round-away-from-zero as int(b + copysign0(_0_5, b))
         w *= int(b * m / _360_0 + _0_5) % m
@@ -483,7 +483,7 @@ def _latlonDMS_sep2(where, sep=None, **kwds):
         i = _MODS.inters
         k =  Fmt.EQUAL(sep=repr(sep))
         k = _SPACE_(i._keyword_, i._arg_, k, i._of_)
-        n =  where.__name__
+        n =  typename(where)
         t = _latlonDMS_sep2.__doc__ % (sep, n)
         _MODS.props._throwarning(k, n, t)
     return sep, kwds
@@ -670,7 +670,7 @@ def _DDDMMSS6(t, S):
         # check [D]DDMMSS form and compass point
         X = _EW_ if isodd(n) else _NS_
         if not (P in X or (S in X and (P.isdigit() or P == _DOT_))):
-            t =  parseDDDMMSS.__name__[5 if isodd(n) else 6:]
+            t =  typename(parseDDDMMSS)[(5 if isodd(n) else 6):]
             t = _SPACE_('form', t, 'applies', _DASH_.join(X))
             raise ParseError(t)
     else:

pygeodesy/ecef.py

@@ -57,8 +57,8 @@ for conversion between geodetic and I{local cartesian} coordinates in a I{local
 plane} as opposed to I{geocentric} (ECEF) ones.
 '''
 
-from pygeodesy.basics import copysign0, isscalar, issubclassof, neg, map1, \
-                            _xinstanceof, _xsubclassof  # _args_kwds_names
+from pygeodesy.basics import copysign0, _isin, isscalar, issubclassof, neg, map1, \
+                            _xinstanceof, _xsubclassof,  typename  # _args_kwds_names
 from pygeodesy.constants import EPS, EPS0, EPS02, EPS1, EPS2, EPS_2, INT0, PI, PI_2, \
                                _0_0, _0_0001, _0_01, _0_5, _1_0, _1_0_1T, _N_1_0, \
                                _2_0, _N_2_0, _3_0, _4_0, _6_0, _60_0, _90_0, _N_90_0, \
@@ -69,6 +69,7 @@ from pygeodesy.errors import _IndexError, LenError, _ValueError, _TypesError, \
                              _xattr, _xdatum, _xkwds, _xkwds_get
 from pygeodesy.fmath import cbrt, fdot, Fpowers, hypot, hypot1, hypot2_, sqrt0
 from pygeodesy.fsums import Fsum, fsumf_,  Fmt, unstr
+# from pygeodesy.internals import typename  # from .basics
 from pygeodesy.interns import NN, _a_, _C_, _datum_, _ellipsoid_, _f_, _height_, \
                              _lat_, _lon_, _M_, _name_, _singular_, _SPACE_, \
                              _x_, _xyz_, _y_, _z_
@@ -89,7 +90,7 @@ from pygeodesy.utily import atan1, atan1d, atan2, atan2d, degrees90, degrees180,
 from math import cos, degrees, fabs, radians, sqrt
 
 __all__ = _ALL_LAZY.ecef
-__version__ = '24.12.06'
+__version__ = '25.04.24'
 
 _Ecef_    = 'Ecef'
 _prolate_ = 'prolate'
@@ -138,7 +139,7 @@ class _EcefBase(_NamedBase):
             else:
                 raise ValueError()  # _invalid_
 
-            if E not in (_EWGS84, _WGS84):
+            if not _isin(E, _EWGS84, _WGS84):
                 d = _ellipsoidal_datum(E, **name)
                 E =  d.ellipsoid
                 if E.a < EPS or E.f > EPS1:
@@ -956,7 +957,7 @@ class EcefMatrix(_NamedTuple):
         # <https://GeographicLib.SourceForge.io/C++/doc/LocalCartesian_8cpp_source.html>
         # X = (fdot(self.column(r), *other.column(c)) for r in (0,1,2) for c in (0,1,2))
         X = (fdot(self[r::3], *other[c::3]) for r in range(3) for c in range(3))
-        return _xnamed(EcefMatrix(*X), EcefMatrix.multiply.__name__)
+        return _xnamed(EcefMatrix(*X), typename(EcefMatrix.multiply))
 
     def rotate(self, xyz, *xyz0):
         '''Forward rotation M{M0' ⋅ ([x, y, z] - [x0, y0, z0])'}.
@@ -1141,6 +1142,8 @@ class Ecef9Tuple(_NamedTuple, _NamedLocal):
         '''
         return PhiLam2Tuple(radians(self.lat), self.lamVermeille, name=self.name)
 
+    phiVermeille = phi
+
     def toCartesian(self, Cartesian=None, **Cartesian_kwds):
         '''Return the geocentric C{(x, y, z)} coordinates as an ellipsoidal or spherical
            C{Cartesian}.
@@ -1157,7 +1160,7 @@ class Ecef9Tuple(_NamedTuple, _NamedLocal):
 
            @raise TypeError: Invalid B{C{Cartesian}} or B{C{Cartesian_kwds}} item.
         '''
-        if Cartesian in (None, Vector4Tuple):
+        if _isin(Cartesian, None, Vector4Tuple):
             r = self.xyzh
         elif Cartesian is Vector3Tuple:
             r = self.xyz
@@ -1177,7 +1180,7 @@ class Ecef9Tuple(_NamedTuple, _NamedLocal):
            @raise TypeError: The B{C{datum2}} is not a L{Datum}.
         '''
         n = _name__(name, _or_nameof=self)
-        if self.datum in (None, datum2):  # PYCHOK _Names_
+        if _isin(self.datum, None, datum2):  # PYCHOK _Names_
             r = self.copy(name=n)
         else:
             c = self._CartesianBase(self, datum=self.datum, name=n)  # PYCHOK _Names_

pygeodesy/elevations.py

@@ -21,11 +21,12 @@ U{USGS10mElev.py<https://Gist.GitHub.com/pyRobShrk>}.
        C{"/Applications/Python\\ X.Y/Install\\ Certificates.command"}
 '''
 
-from pygeodesy.basics import clips, ub2str
+from pygeodesy.basics import clips, ub2str,  typename
 from pygeodesy.errors import ParseError, _xkwds_get
-from pygeodesy.interns import NN, _AMPERSAND_, _COLONSPACE_, \
-                             _elevation_, _height_, _LCURLY_, \
-                             _n_a_, _no_, _RCURLY_, _SPACE_
+# from pygeodesy.internals import typename  # from .basics
+from pygeodesy.interns import NN, _AMPERSAND_, _COLONSPACE_, _DMAIN_, \
+                             _elevation_, _height_, _LCURLY_, _n_a_, \
+                             _no_, _RCURLY_, _SPACE_
 from pygeodesy.lazily import _ALL_LAZY
 from pygeodesy.named import _NamedTuple
 from pygeodesy.streprs import fabs, Fmt, fstr, lrstrip
@@ -34,7 +35,7 @@ from pygeodesy.units import Lat, Lon, Meter, Scalar, Str
 # from math import fabs  # from .karney
 
 __all__ = _ALL_LAZY.elevations
-__version__ = '24.06.11'
+__version__ = '25.04.14'
 
 try:
     from urllib2 import urlopen  # quote, urlcleanup
@@ -91,7 +92,7 @@ except ImportError:
 def _error(fun, lat, lon, e):
     '''(INTERNAL) Format an error
     '''
-    return _COLONSPACE_(Fmt.PAREN(fun.__name__, fstr((lat, lon))), e)
+    return _COLONSPACE_(Fmt.PAREN(typename(fun), fstr((lat, lon))), e)
 
 
 def _qURL(url, timeout=2, **params):
@@ -243,14 +244,14 @@ def geoidHeight2(lat, lon, model=0, timeout=2.0):
     return GeoidHeight2Tuple(None, e)
 
 
-if __name__ == '__main__':
+if __name__ == _DMAIN_:
 
     from pygeodesy import printf
     # <https://WikiPedia.org/wiki/Mount_Diablo>
     for f in (elevation2,     # (1173.79, '3DEP 1/3 arc-second')
               geoidHeight2):  # (-31.699, u'GEOID12B')
         t = f(37.8816, -121.9142)
-        printf(_COLONSPACE_(f.__name__, t))
+        printf(_COLONSPACE_(typename(f), t))
 
 # **) MIT License
 #

pygeodesy/ellipsoidalBase.py

@@ -12,30 +12,41 @@ and published under the same MIT Licence**, see for example U{latlon-ellipsoidal
 # make sure int/int division yields float quotient, see .basics
 from __future__ import division as _; del _  # PYCHOK semicolon
 
-# from pygeodesy.basics import _xinstanceof  # from .datums
+# from pygeodesy.azimuthal import EquidistantExact, EquidistantKarney  # _MODS
+from pygeodesy.basics import _isin, _xinstanceof
 from pygeodesy.constants import EPS, EPS0, EPS1, _0_0, _0_5
 from pygeodesy.cartesianBase import CartesianBase  # PYCHOK used!
+# from pygeodesy.css import toCss  # _MODS
 from pygeodesy.datums import Datum, Datums, _earth_ellipsoid, _ellipsoidal_datum, \
-                             Transform, _WGS84,  _EWGS84, _xinstanceof  # _spherical_datum
+                             Transform, _WGS84,  _EWGS84  # _spherical_datum
+# from pygeodesy.dms import parse3llh  # _MODS
+# from pygeodesy.elevations import elevation2, geoidHeight2  # _MODS
+# from pygeodesy.ellipsoidalBaseDI import _intersect3, _intersections2, _nearestOn2  # _MODS
 # from pygeodesy.ellipsoids import _EWGS84  # from .datums
 from pygeodesy.errors import _IsnotError, RangeError, _TypeError, _xattr, _xellipsoidal, \
                              _xellipsoids, _xError, _xkwds, _xkwds_not
+# from pygeodesy.etm import etm, toEtm8  # _MODS
 # from pygeodesy.fmath import favg  # _MODS
 from pygeodesy.interns import NN, _COMMA_, _ellipsoidal_
 from pygeodesy.latlonBase import LatLonBase, _trilaterate5,  fabs, _Wrap
 from pygeodesy.lazily import _ALL_DOCS, _ALL_LAZY, _ALL_MODS as _MODS
 # from pygeodesy.lcc import toLcc  # _MODS
 # from pygeodesy.namedTuples import Vector3Tuple  # _MODS
+# from pygeodesy.osgr import toOsgr  # _MODS
+# from pygeodesy.points import isenclosedBy  # _MODS
 from pygeodesy.props import deprecated_method, deprecated_property_RO, \
                             Property_RO, property_doc_, property_RO, _update_all
-# from pygeodesy.trf import _eT0Ds4  # _MODS
+# from pygeodesy.trf import RefFrame, _toRefFrame  # _MODS
 from pygeodesy.units import Epoch, _isDegrees, Radius_, _1mm as _TOL_M
+# from pygeodesy import ups, utm, utmups  # MODS
+# from pygeodesy.utmupsBase import _lowerleft  # MODS
 # from pygeodesy.utily import _Wrap  # from .latlonBase
+# from pygeodesy.vector3d import _intersects2  # _MODS
 
 # from math import fabs  # from .latlonBase
 
 __all__ = _ALL_LAZY.ellipsoidalBase
-__version__ = '24.12.04'
+__version__ = '25.04.14'
 
 
 class CartesianEllipsoidalBase(CartesianBase):
@@ -246,7 +257,7 @@ class LatLonEllipsoidalBase(LatLonBase):
            @raise UnitError: Invalid B{C{lat}}, B{C{lon}} or B{C{height}}.
         '''
         LatLonBase.__init__(self, latlonh, lon=lon, height=height, wrap=wrap, **name)
-        if datum not in (None, self._datum, _EWGS84):
+        if not _isin(datum, None, self._datum, _EWGS84):
             self.datum = _ellipsoidal_datum(datum, name=self.name)
         if reframe:
             self.reframe = reframe
@@ -738,7 +749,7 @@ class LatLonEllipsoidalBase(LatLonBase):
                 n = Datums.NAD83.ellipsoid.rocGauss(self.lat)
                 if n > EPS0:
                     # use ratio, datum and NAD83 units may differ
-                    E = self.ellipsoid() if datum in (None, self.datum) else \
+                    E = self.ellipsoid() if _isin(datum, None, self.datum) else \
                       _earth_ellipsoid(datum)
                     r = E.rocGauss(self.lat)
                     if r > EPS0 and fabs(r - n) > EPS:  # EPS1
@@ -1109,9 +1120,9 @@ class LatLonEllipsoidalBase(LatLonBase):
 def _lowerleft(utmups, center):
     '''(INTERNAL) Optionally I{un}-center C{utmups}.
     '''
-    if center in (False, 0, _0_0):
+    if _isin(center, False, 0, _0_0):
         u = utmups
-    elif center in (True,):
+    elif _isin(center, True):
         u = utmups._lowerleft
     else:
         u = _MODS.utmupsBase._lowerleft(utmups, center)

pygeodesy/ellipsoidalBaseDI.py

@@ -7,34 +7,36 @@ class C{LatLonEllipsoidalBaseDI} and functions.
 # make sure int/int division yields float quotient, see .basics
 from __future__ import division as _; del _  # PYCHOK semicolon
 
-from pygeodesy.basics import isLatLon, _xsubclassof
+# from pygeodesy.azimuthal import _Equidistants  # _MODS
+from pygeodesy.basics import isLatLon, _xsubclassof,  typename
 from pygeodesy.constants import EPS, MAX, PI, PI2, PI_4, isnear0, isnear1, \
                                _EPSqrt as _TOL, _0_0, _0_01, _1_0, _1_5, _3_0
 # from pygeodesy.dms import F_DMS  # _MODS
 from pygeodesy.ellipsoidalBase import LatLonEllipsoidalBase, _TOL_M,  property_RO
-from pygeodesy.errors import _AssertionError, IntersectionError, _IsnotError, \
-                             _or, _ValueError, _xellipsoidal, _xError, _xkwds_not
+from pygeodesy.errors import _AssertionError, IntersectionError, _IsnotError, _or, \
+                             _ValueError, _xellipsoidal, _xError, _xkwds_not
 from pygeodesy.fmath import favg, fmean_
 from pygeodesy.fsums import Fmt, fsumf_
 from pygeodesy.formy import _isequalTo, opposing, _radical2
-from pygeodesy.interns import _antipodal_, _concentric_, _ellipsoidal_, \
-                              _exceed_PI_radians_, _low_, _near_, \
-                              _SPACE_, _too_
+# from pygeodesy.geodesicw import _Intersecant2, _PlumbTo  # _MODS
+# from pygeodesy.internals import typename  # from .basics
+from pygeodesy.interns import _antipodal_, _concentric_, _ellipsoidal_, _low_, \
+                              _exceed_PI_radians_, _near_, _SPACE_, _too_
 from pygeodesy.lazily import _ALL_DOCS, _ALL_LAZY, _ALL_MODS as _MODS
-from pygeodesy.namedTuples import Bearing2Tuple, Destination2Tuple, \
-                                  Intersection3Tuple, NearestOn2Tuple, \
-                                  NearestOn8Tuple, _LL4Tuple
+from pygeodesy.namedTuples import Bearing2Tuple, Destination2Tuple, Intersection3Tuple, \
+                                  NearestOn2Tuple, NearestOn8Tuple, _LL4Tuple
 # from pygeodesy.props import property_RO  # from .ellipsoidalBase
+# from pygeodesy.sphericalNvector import _intersects2  # _MODS
+# from pygeodesy.sphericalTrigonometry import _intersect, LatLon  # _MODS
 # from pygeodesy.streprs import Fmt  # from .fsums
-from pygeodesy.units import _fi_j2, _isDegrees, _isHeight, _isRadius, \
-                             Radius_, Scalar
-from pygeodesy.utily import m2km, unroll180, _unrollon, _unrollon3, \
-                           _Wrap, wrap360
+from pygeodesy.units import _fi_j2, _isDegrees, _isHeight, _isRadius, Radius_, Scalar
+from pygeodesy.utily import m2km, unroll180, _unrollon, _unrollon3, _Wrap, wrap360
+# from pygeodesy.vector3d import _intersects2, _intersect3d3, _nearestOn2, Vector3d  # _MODS
 
 from math import degrees, radians
 
 __all__ = _ALL_LAZY.ellipsoidalBaseDI
-__version__ = '24.11.04'
+__version__ = '25.04.21'
 
 _polar__ = 'polar?'
 _TRIPS   =  33   # _intersect3, _intersects2, _nearestOn interations, 6..9 sufficient?
@@ -390,7 +392,7 @@ class LatLonEllipsoidalBaseDI(LatLonEllipsoidalBase):
 
         f, j = _fi_j2(f, len(Ps))  # like .vector3d.nearestOn6
 
-        n = self.nearestOn8.__name__  # _DUNDER_nameof
+        n = typename(self)
         c.rename(n)
         if s is not c:
             s = s.copy(name=n)