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

pygeodesy/rhumb/bases.py

@@ -33,9 +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.internals import typename, _under
 from pygeodesy.interns import NN, _coincident_, _COMMASPACE_, _Dash, \
-                             _parallel_, _too_
+                             _DMAIN_, _parallel_, _too_
 from pygeodesy.karney import _atan2d, Caps, _CapsBase, _diff182, _fix90, \
                              _norm180, GDict
 # from pygeodesy.ktm import KTransverseMercator, _AlpCoeffs  # _MODS
@@ -52,7 +52,7 @@ from pygeodesy.vector3d import _intersect3d3, Vector3d  # in .Intersection below
 from math import cos, fabs
 
 __all__ = ()
-__version__ = '24.10.14'
+__version__ = '25.04.14'
 
 _anti_ = _Dash('anti')
 _rls   = []  # instances of C{RbumbLine...} to be updated
@@ -231,9 +231,10 @@ class RhumbBase(_CapsBase):
            @arg azi12: Azimuth of the rhumb line (compass C{degrees}).
            @kwarg caps_name: Optional keyword arguments C{B{name}=NN} and
                        C{B{caps}=Caps.STANDARD}, a bit-or'ed combination of
-                       L{Caps} values specifying the required capabilities.
-                       Include C{Caps.LINE_OFF} if updates to the B{C{rhumb}}
-                       should I{not} be reflected in this rhumb line.
+                       L{Caps<pygeodesy.karney.Caps>} values specifying the
+                       required capabilities.  Include C{Caps.LINE_OFF} if
+                       updates to the B{C{rhumb}} should I{not be reflected}
+                       in this rhumb line.
 
            @return: A C{RhumbLine...} instance and invoke its method
                     C{.Position} to compute each point.
@@ -397,9 +398,10 @@ class RhumbBase(_CapsBase):
            @arg lon2: Longitude of the second point (C{degrees180}).
            @kwarg caps_name: Optional keyword arguments C{B{name}=NN} and
                        C{B{caps}=Caps.STANDARD}, a bit-or'ed combination of
-                       L{Caps} values specifying the required capabilities.
-                       Include C{Caps.LINE_OFF} if updates to the B{C{rhumb}}
-                       should I{not} be reflected in this rhumb line.
+                       L{Caps<pygeodesy.karney.Caps>} values specifying the
+                       required capabilities.  Include C{Caps.LINE_OFF} if
+                       updates to the B{C{rhumb}} should I{not be reflected}
+                       in this rhumb line.
 
            @return: A C{RhumbLine...} instance and invoke its method
                     C{ArcPosition} or C{Position} to compute points.
@@ -517,8 +519,8 @@ class RhumbLineBase(_CapsBase):
 
            @arg a12: The angle along this rhumb line from its origin to the
                      point (C{degrees}), can be negative.
-           @kwarg outmask: Bit-or'ed combination of L{Caps} values specifying
-                           the quantities to be returned.
+           @kwarg outmask: Bit-or'ed combination of L{Caps<pygeodesy.karney.Caps>}
+                           values specifying the quantities to be returned.
 
            @return: L{GDict} with 4 to 8 items C{azi12, a12, s12, S12, lat2,
                     lon2, lat1, lon1} with latitude C{lat2} and longitude
@@ -634,7 +636,7 @@ class RhumbLineBase(_CapsBase):
         t = dict(lat3=q.lat2, lon3=q.lon2, azi03=q.azi02, a03=q.a02, s03=a)
         if a < r:
             t.update(iteration=q.iteration, lat0=q.lat1, lon0=q.lon1,  # or lat0, lon0
-                     name=_DUNDER_nameof(self.Intersecant2, self.name))
+                     name=typename(self.Intersecant2, self.name))
             if fabs(a) < EPS0:  # coincident centers
                 d, h = _0_0, r
             else:
@@ -660,7 +662,7 @@ class RhumbLineBase(_CapsBase):
     def intersection2(self, other, **tol_eps):  # PYCHOK no cover
         '''DEPRECATED on 23.10.10, use method L{Intersection}.'''
         p = self.Intersection(other, **tol_eps)
-        r = LatLon2Tuple(p.lat2, p.lon2, name=self.intersection2.__name__)
+        r = LatLon2Tuple(p.lat2, p.lon2, name=typename(self.intersection2))
         r._iteration = p.iteration
         return r
 
@@ -701,7 +703,7 @@ class RhumbLineBase(_CapsBase):
             _s_3d, s_az =  self._xTM3d,  self.azi12
             _o_3d, o_az = other._xTM3d, other.azi12
             p = _MODS.formy.opposing(s_az, o_az, margin=tol)
-            if p is not None:  # == p in (True, False)
+            if p is not None:  # == isbool(p)
                 raise ValueError(_anti_(_parallel_) if p else _parallel_)
             _diff =  euclid  # approximate length
             _i3d3 = _intersect3d3  # NOT .vector3d.intersection3d3
@@ -723,7 +725,7 @@ class RhumbLineBase(_CapsBase):
 
             P = GDict(lat1=self.lat1, lat2=p.lat, lat0=other.lat1,
                       lon1=self.lon1, lon2=p.lon, lon0=other.lon1,
-                      name=_DUNDER_nameof(self.Intersection, self.name))
+                      name=typename(self.Intersection, self.name))
             r =  self.Inverse(p.lat, p.lon, outmask=Caps.DISTANCE)
             t = other.Inverse(p.lat, p.lon, outmask=Caps.DISTANCE)
             P.set_(azi12= self.azi12, a12=r.a12, s12=r.s12,
@@ -805,7 +807,7 @@ class RhumbLineBase(_CapsBase):
         '''DEPRECATED on 23.10.10, use method L{PlumbTo}.'''
         P =  self.PlumbTo(lat0, lon0, **exact_eps_est_tol)
         r = _MODS.deprecated.classes.NearestOn4Tuple(P.lat2, P.lon2, P.s12, P.azi02,
-                                                     name=self.nearestOn4.__name__)
+                                                     name=typename(self.nearestOn4))
         r._iteration = P.iteration
         return r
 
@@ -897,7 +899,7 @@ class RhumbLineBase(_CapsBase):
                         break
                 P.set_(azi0=r.azi1, a02=r.a12, s02=r.s12,  # azi2=r.azi2,
                        lat0=lat0, lon0=lon0, iteration=i, at=r.azi2 - self.azi12,
-                       name=_DUNDER_nameof(self.PlumbTo, self.name))
+                       name=typename(self.PlumbTo, self.name))
             except Exception as x:  # Fsum(NAN) Value-, ZeroDivisionError
                 raise IntersectionError(lat0=lat0, lon0=lon0, tol=tol, exact=exact,
                                         eps=eps, est=est, iteration=i, cause=x)
@@ -909,8 +911,8 @@ class RhumbLineBase(_CapsBase):
 
            @arg s12: The distance along this rhumb line from its origin to the point
                      (C{meters}), can be negative.
-           @kwarg outmask: Bit-or'ed combination of L{Caps} values specifying the
-                           quantities to be returned.
+           @kwarg outmask: Bit-or'ed combination of L{Caps<pygeodesy.karney.Caps>}
+                           values specifying the quantities to be returned.
 
            @return: L{GDict} with 4 to 8 items C{azi12, a12, s12, S12, lat2, lat1,
                     lon2, lon1} with latitude C{lat2} and longitude C{lon2} of the
@@ -1046,7 +1048,7 @@ class _PseudoRhumbLine(RhumbLineBase):
 
 __all__ += _ALL_DOCS(RhumbBase, RhumbLineBase)
 
-if __name__ == '__main__':
+if __name__ == _DMAIN_:
 
     from pygeodesy import printf, Rhumb as Rh, RhumbAux as Ah
     from pygeodesy.basics import _zip

pygeodesy/rhumb/ekx.py

@@ -43,7 +43,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__ = '24.11.26'
+__version__ = '25.04.12'
 
 
 class Rhumb(RhumbBase):
@@ -263,11 +263,11 @@ class RhumbLine(RhumbLineBase):
            @kwarg lat1: Latitude of the start point (C{degrees90}).
            @kwarg lon1: Longitude of the start point (C{degrees180}).
            @kwarg azi12: Azimuth of this rhumb line (compass C{degrees}).
-           @kwarg caps_name: Optional keyword arguments C{B{name}=NN} and
-                       C{B{caps}=0}, a bit-or'ed combination of L{Caps}
-                       values specifying the required capabilities.  Include
-                       C{Caps.LINE_OFF} if updates to the B{C{rhumb}} should
-                       I{not} be reflected in this rhumb line.
+           @kwarg caps_name: Optional keyword arguments C{B{name}=NN} and C{B{caps}=0},
+                       a bit-or'ed combination of L{Caps<pygeodesy.karney.Caps>} values
+                       specifying the required capabilities.  Include C{Caps.LINE_OFF}
+                       if updates to the B{C{rhumb}} should I{not be reflected} in this
+                       rhumb line.
         '''
         RhumbLineBase.__init__(self, rhumb, lat1, lon1, azi12, **caps_name)
 

pygeodesy/rhumb/solve.py

@@ -11,7 +11,8 @@ as an (exact) rhumb or rhumb line from I{either GeographicLib 2.0 or 2.2+}.
 from pygeodesy.basics import _xinstanceof
 from pygeodesy.constants import _0_0, _180_0, _N_180_0, _over,  _90_0  # PYCHOK used!
 from pygeodesy.errors import RhumbError   # PYCHOK used!
-from pygeodesy.interns import NN, _a12_, _azi12_, _lat2_, _lon2_, _s12_, _S12_, _UNDER_
+from pygeodesy.interns import NN, _a12_, _azi12_, _DMAIN_, _lat2_, _lon2_, _s12_, \
+                             _S12_, _UNDER_
 from pygeodesy.karney import Caps, GDict, _norm180, Rhumb8Tuple, _sincos2d, _Xables
 from pygeodesy.lazily import _ALL_DOCS, _ALL_LAZY, _ALL_MODS as _MODS
 from pygeodesy.namedTuples import Destination3Tuple, Distance3Tuple
@@ -20,7 +21,7 @@ from pygeodesy.solveBase import _SolveGDictBase, _SolveGDictLineBase
 from pygeodesy.utily import _unrollon, _Wrap, wrap360
 
 __all__ = _ALL_LAZY.rhumb_solve
-__version__ = '24.11.07'
+__version__ = '25.04.12'
 
 
 class _RhumbSolveBase(_SolveGDictBase):
@@ -29,7 +30,7 @@ class _RhumbSolveBase(_SolveGDictBase):
     _Error         =  RhumbError
     _Names_Direct  = _lat2_, _lon2_, _S12_
     _Names_Inverse = _azi12_, _s12_, _S12_
-    _Xable_name    = _Xables.RhumbSolve.__name__
+    _Xable_name    = _Xables.RhumbSolve.__name__  # typename
     _Xable_path    = _Xables.RhumbSolve()
 
     @Property_RO
@@ -146,9 +147,9 @@ class RhumbSolve(_RhumbSolveBase):
            @arg lat1: Latitude of the first point (C{degrees}).
            @arg lon1: Longitude of the first point (C{degrees}).
            @arg azi1: Azimuth at the first point (compass C{degrees}).
-           @kwarg caps: Bit-or'ed combination of L{Caps} values specifying
-                        the capabilities the L{RhumbLineSolve} instance
-                        should possess, always C{Caps.ALL}.
+           @kwarg caps: Bit-or'ed combination of L{Caps<pygeodesy.karney.Caps>}
+                        values specifying the capabilities the L{RhumbLineSolve}
+                        instance should possess, always C{Caps.ALL}.
            @kwarg name: Optional C{B{name}=NN} (C{str}).
 
            @return: A L{RhumbLineSolve} instance.
@@ -247,18 +248,17 @@ class RhumbLineSolve(_RhumbSolveBase, _SolveGDictLineBase):
            @arg lat1: Latitude of the first point (C{degrees90}).
            @arg lon1: Longitude of the first point (C{degrees180}).
            @arg azi12: Azimuth of the rhumb line (compass C{degrees180}).
-           @kwarg caps: Bit-or'ed combination of L{Caps} values specifying
-                        the capabilities the L{RhumbLineSolve} instance should
-                        possess, always C{Caps.ALL}.  Use C{Caps.LINE_OFF}
-                        if updates to the B{C{rhumb}} should I{not} be
-                        reflected in this L{RhumbLineSolve} instance.
+           @kwarg caps: Bit-or'ed combination of L{Caps<pygeodesy.karney.Caps>}
+                        values specifying the capabilities the L{RhumbLineSolve}
+                        instance should possess, always C{Caps.ALL}.  Include
+                        C{Caps.LINE_OFF} if updates to the B{C{rhumb}} should
+                        I{not be reflected} in this L{RhumbLineSolve} instance.
            @kwarg name: Optional C{B{name}=NN} (C{str}).
 
            @kwarg name: Optional name (C{str}).
 
-           @raise RhumbError: Invalid path for C{RhumbSolve} executable or
-                              isn't the C{RhumbSolve} executable, see
-                              property C{B{rhumb}.RhumbSolve}.
+           @raise RhumbError: Invalid path for C{RhumbSolve} executable or isn't the
+                              C{RhumbSolve} executable, see property C{B{rhumb}.RhumbSolve}.
 
            @raise TypeError: Invalid B{C{rhumb}}.
         '''
@@ -355,7 +355,7 @@ class RhumbSolve7Tuple(Rhumb8Tuple):
 
 __all__ += _ALL_DOCS(_RhumbSolveBase)
 
-if __name__ == '__main__':
+if __name__ == _DMAIN_:
 
     from pygeodesy import printf
     from sys import argv

pygeodesy/solveBase.py

@@ -4,7 +4,7 @@
 u'''(INTERNAL) Private base classes for L{pygeodesy.geodsolve} and L{pygeodesy.rhumb.solve}.
 '''
 
-from pygeodesy.basics import clips, map2, _zip
+from pygeodesy.basics import clips, _isin, map2, _zip
 from pygeodesy.constants import DIG
 from pygeodesy.datums import _earth_datum, _WGS84,  _EWGS84
 # from pygeodesy.ellipsoids import _EWGS84  # from .datums
@@ -23,7 +23,7 @@ from pygeodesy.units import Precision_
 from pygeodesy.utily import unroll180,  wrap360  # PYCHOK shared
 
 __all__ = _ALL_LAZY.solveBase
-__version__ = '24.10.13'
+__version__ = '25.04.14'
 
 _ERROR_ = 'ERROR'
 
@@ -211,7 +211,7 @@ class _SolveCapsBase(_CapsBase):
             self._print(t)
         try:  # invoke and write to stdin
             r, s = _popen2(cmd, stdin)
-            if len(r) < 6 or r[:5] in (_Error_, _ERROR_):
+            if len(r) < 6 or _isin(r[:5], _Error_, _ERROR_):
                 raise ValueError(r)
         except (IOError, OSError, TypeError, ValueError) as x:
             raise self._Error(cmd=t or _cmd_stdin_(cmd, stdin), cause=x)

pygeodesy/sphericalBase.py

@@ -12,7 +12,7 @@ U{Latitude/Longitude<https://www.Movable-Type.co.UK/scripts/latlong.html>}.
 # make sure int/int division yields float quotient, see .basics
 from __future__ import division as _; del _  # PYCHOK semicolon
 
-from pygeodesy.basics import _copysign, isbool, isinstanceof, map1
+from pygeodesy.basics import _copysign, isbool, _isin, isinstanceof, map1
 from pygeodesy.cartesianBase import CartesianBase,  Bearing2Tuple
 from pygeodesy.constants import EPS, EPS0, PI, PI2, PI_2, R_M, \
                                _0_0, _0_5, _1_0, _180_0, _360_0, \
@@ -40,7 +40,7 @@ from pygeodesy.utily import acos1, asin1, atan2b, atan2d, degrees90, \
 from math import cos, fabs, log, sin, sqrt
 
 __all__ = _ALL_LAZY.sphericalBase
-__version__ = '24.10.19'
+__version__ = '25.04.14'
 
 
 class CartesianSphericalBase(CartesianBase):
@@ -137,7 +137,7 @@ class LatLonSphericalBase(LatLonBase):
            @raise TypeError: Invalid B{C{latlonh}} or B{C{datum}} not spherical.
         '''
         LatLonBase.__init__(self, latlonh, lon=lon, height=height, wrap=wrap, **name)
-        if datum not in (None, self.datum):
+        if not _isin(datum, None, self.datum):
             self.datum = datum
 
     def bearingTo2(self, other, wrap=False, raiser=False):
@@ -403,7 +403,7 @@ class LatLonSphericalBase(LatLonBase):
             r = LatLonBase.rhumbDestination(self, distance, azimuth, exact=False,  # Krüger
                                                   radius=radius, height=height, **name)
         else:  # radius=None from .rhumbMidpointTo
-            if radius in (None, self._radius):
+            if _isin(radius, None, self._radius):
                 d, r = self.datum, radius
             else:
                 d = _spherical_datum(radius, raiser=_radius_)  # spherical only
@@ -557,7 +557,7 @@ class LatLonSphericalBase(LatLonBase):
                         b3 = fdot(map1(log, f1, f2, f3),
                                            -b2, b1, b2 - b1) / f
 
-            d = self.datum if radius in (None, self._radius) else \
+            d = self.datum if _isin(radius, None, self._radius) else \
                _spherical_datum(radius, name=self.name, raiser=_radius_)
             h = self._havg(other, h=height)
             r = self.classof(degrees90(a3), degrees180(b3), datum=d, height=h, name=n)
@@ -674,7 +674,7 @@ def _m2radians(distance, radius, low=EPS):  # PYCHOK in .spherical*
 def _radians2m(rad, radius):
     '''(INTERNAL) Angular distance in C{radians} to distance in C{meter}.
     '''
-    if radius is not None:  # not in (None, _0_0)
+    if radius is not None:  # not _isin(radius, None, _0_0)
         rad *= R_M if radius is R_M else Radius(radius)
     return rad
 

pygeodesy/sphericalNvector.py

@@ -33,13 +33,14 @@ to a normalised version of an (ECEF) cartesian coordinate.
 # make sure int/int division yields float quosient, see .basics
 from __future__ import division as _; del _  # PYCHOK semicolon
 
-# from pygeodesy.basics import _xinstanceof  # _MODS
+from pygeodesy.basics import _isin, _xinstanceof,  typename
 from pygeodesy.constants import EPS, EPS0, PI, PI2, PI_2, R_M, \
                                _0_0, _0_5, _1_0
 # from pygeodesy.datums import Datums  # from .sphericalBase
 from pygeodesy.errors import PointsError, VectorError, _xError, _xkwds
 from pygeodesy.fmath import fdot_, fmean, fsum
 # from pygeodesy.fsums import fsum  # from .fmath
+# from pygeodesy.internals import typename  # from .basics
 from pygeodesy.interns import _composite_, _end_, _Nv00_, _other_, \
                               _point_, _pole_
 from pygeodesy.lazily import _ALL_LAZY, _ALL_MODS as _MODS, _ALL_OTHER
@@ -61,7 +62,7 @@ from pygeodesy.utily import atan2, degrees360, sincos2, sincos2_, sincos2d, \
 # from math import fabs  # from utily
 
 __all__ = _ALL_LAZY.sphericalNvector
-__version__ = '24.11.24'
+__version__ = '25.04.14'
 
 _lines_ = 'lines'
 
@@ -605,7 +606,7 @@ class LatLon(LatLonNvectorBase, LatLonSphericalBase):
                 return p2  # is point2 if not wrap
 
         p = n.toLatLon(height=height or 0, LatLon=self.classof)
-        if height in (None, False):  # interpolate height within extent
+        if _isin(height, None, False):  # interpolate height within extent
             d =  p1.distanceTo(p2)
             f = (p1.distanceTo(p) / d) if d > EPS0 else _0_5
             p.height = p1._havg(p2, f=max(_0_0, min(f, _1_0)))
@@ -1006,7 +1007,7 @@ def meanOf(points, height=None, wrap=False, **LatLon_and_kwds):
     except (TypeError, ValueError) as x:
         raise PointsError(points=points, wrap=wrap, cause=x, **LatLon_and_kwds)
     return n.toLatLon(**_xkwds(LatLon_and_kwds, LatLon=LatLon, height=n.h,
-                                                name=meanOf.__name__))
+                                                name=typename(meanOf)))
 
 
 @deprecated_function
@@ -1050,7 +1051,7 @@ def nearestOn3(point, points, closed=False, radius=R_M, height=None, wrap=False)
 
        @raise TypeError: Some B{C{points}} or B{C{point}} not C{LatLon}.
     '''
-    _MODS.basics._xinstanceof(LatLon, point=point)
+    _xinstanceof(LatLon, point=point)
 
     return point.nearestOn3(points, closed=closed, radius=radius,
                                     height=height, wrap=wrap)

pygeodesy/sphericalTrigonometry.py

@@ -16,7 +16,7 @@ U{Latitude/Longitude<https://www.Movable-Type.co.UK/scripts/latlong.html>}.
 # make sure int/int division yields float quotient, see .basics
 from __future__ import division as _; del _  # PYCHOK semicolon
 
-from pygeodesy.basics import copysign0, map1, signOf
+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
@@ -29,6 +29,7 @@ from pygeodesy.fsums import Fsum, fsum, fsumf_
 from pygeodesy.formy import antipode_, bearing_, _bearingTo2, excessAbc_, \
                             excessGirard_, excessLHuilier_, opposing_, _radical2, \
                             vincentys_
+# from pygeodesy.internals import typename  # from .basics
 from pygeodesy.interns import _1_, _2_, _coincident_, _composite_, _colinear_, \
                               _concentric_, _convex_, _end_, _infinite_, \
                               _invalid_, _line_, _near_, _null_, _parallel_, \
@@ -55,7 +56,7 @@ from pygeodesy.vector3d import sumOf, Vector3d
 from math import asin, cos, degrees, fabs, radians, sin
 
 __all__ = _ALL_LAZY.sphericalTrigonometry
-__version__ = '24.11.24'
+__version__ = '25.04.14'
 
 _PI_EPS4 = PI - EPS4
 if _PI_EPS4 >= PI:
@@ -1147,7 +1148,7 @@ def isPoleEnclosedBy(points, wrap=False):  # PYCHOK no cover
 def _LL3Tuple(lat, lon, height, where, LatLon, LatLon_kwds):
     '''(INTERNAL) Helper for L{intersection}, L{intersections2} and L{meanOf}.
     '''
-    n = where.__name__
+    n = typename(where)
     if LatLon is None:
         r = LatLon3Tuple(lat, lon, height, name=n)
     else:
@@ -1250,7 +1251,7 @@ def nearestOn3(point, points, closed=False, radius=R_M, wrap=False, adjust=True,
                                    adjust=adjust, limit=limit)
     d = degrees2m(t.distance, radius=radius)
     h = t.height
-    n = nearestOn3.__name__
+    n = typename(nearestOn3)
 
     LL, kwds = _xkwds_pop2(LatLon_and_kwds, LatLon=LatLon)
     r = LatLon3Tuple(t.lat, t.lon, h, name=n) if LL is None else \
@@ -1378,8 +1379,8 @@ def triangle8_(phiA, lamA, phiB, lamB, phiC, lamC, excess=excessAbc_,
     C, _ = _A_r(c, *r)
 
     D = fsumf_(PI2, -a, -b, -c)  # deficit aka defect
-    E = excessGirard_(A, B, C)   if excess in (excessGirard_,   True)  else (
-        excessLHuilier_(a, b, c) if excess in (excessLHuilier_, False) else
+    E = excessGirard_(A, B, C)   if _isin(excess, excessGirard_,   True)  else (
+        excessLHuilier_(a, b, c) if _isin(excess, excessLHuilier_, False) else
         excessAbc_(*max((A, b, c), (B, c, a), (C, a, b))))
 
     return Triangle8Tuple(A, a, B, b, C, c, D, E)
@@ -1388,7 +1389,7 @@ def triangle8_(phiA, lamA, phiB, lamB, phiC, lamC, excess=excessAbc_,
 def _t7Tuple(t, radius):
     '''(INTERNAL) Convert a L{Triangle8Tuple} to L{Triangle7Tuple}.
     '''
-    if radius:  # not in (None, _0_0)
+    if radius:  # not _isin(radius, None, _0_0)
         r = radius if _isRadius(radius) else \
             _ellipsoidal_datum(radius).ellipsoid.Rmean
         A, B, C = map1(degrees, t.A, t.B, t.C)

pygeodesy/streprs.py

@@ -5,11 +5,11 @@ u'''Floating point and other formatting utilities.
 '''
 
 from pygeodesy.basics import isint, islistuple, isscalar, isstr, itemsorted, \
-                            _zip, _0_0
+                            _zip, _0_0,  typename
 # from pygeodesy.constants import _0_0
 from pygeodesy.errors import _or, _IsnotError, _TypeError, _ValueError, \
                              _xkwds_get, _xkwds_item2
-from pygeodesy.internals import _DUNDER_nameof
+# from pygeodesy.internals import typename  # from .basics
 from pygeodesy.interns import NN, _0_, _0to9_, MISSING, _BAR_, _COMMASPACE_, \
                              _DOT_, _E_, _ELLIPSIS_, _EQUAL_, _H_, _LR_PAIRS, \
                              _N_, _name_, _not_scalar_, _PERCENT_, _SPACE_, \
@@ -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__ = '24.11.26'
+__version__ = '25.04.14'
 
 _at_        = 'at'         # PYCHOK used!
 _EN_PREC    =  6           # max MGRS/OSGR precision, 1 micrometer
@@ -82,7 +82,7 @@ class Fstr(str):
            @raise ValueError: Invalid B{C{arg}}.
         '''
         def _error(arg):
-            n = _DOT_(Fstr.__name__, self.name or self)
+            n = _DOT_(typename(Fstr), self.name or self)
             return _SPACE_(n, _PERCENT_, repr(arg))
 
         prec = 6  # default std %f and %F
@@ -105,7 +105,7 @@ class _Sub(str):
     '''
     # see .ellipsoidalNvector.LatLon.deltaTo
     def __call__(self, *Classes):
-        t = _or(*(C.__name__ for C in Classes))
+        t = _or(*map(typename, Classes))
         return  str.__mod__(self, t or MISSING)
 
 
@@ -148,9 +148,10 @@ class Fmt(object):
     zone          = _Fmt('%02d')  # .epsg, .mgrs, .utmupsBase
 
     def __init__(self):
-        for n, a in self.__class__.__dict__.items():
+        for n, a in type(self).__dict__.items():
             if isinstance(a, (Fstr, _Fmt)):
                 setattr(a, _name_, n)
+        self.__name__ = typename(type(self))
 
     def __call__(self, obj, prec=9):
         '''Return C{str(B{obj})} or C{repr(B{obj})}.
@@ -182,15 +183,14 @@ class Fmt(object):
         '''
         return self.ANGLE(_SPACE_((text or inst), _at_, hex(id(inst))))
 
-Fmt          = Fmt()  # PYCHOK singleton
-Fmt.__name__ = Fmt.__class__.__name__
+Fmt = Fmt()  # PYCHOK singleton
 
-_DOTSTAR_ = Fmt.DOT(_STAR_)
+_DOTSTAR_ = Fmt.DOT(_STAR_)  # in _streprs above
 # formats %G and %g drop all trailing zeros and the
 # decimal point, making the float appear as an int
-_Gg     = (Fmt.G, Fmt.g)
-_FfEeGg = (Fmt.F, Fmt.f, Fmt.E, Fmt.e) + _Gg  # float formats
-_Fspec_ = NN('[%[<flags>][<width>]', _DOTSTAR_, ']', _BAR_.join(_FfEeGg))  # in testStreprs
+_Gg       = (Fmt.G, Fmt.g)
+_FfEeGg   = (Fmt.F, Fmt.f, Fmt.E, Fmt.e) + _Gg  # float formats
+_Fspec_   = NN('[%[<flags>][<width>]', _DOTSTAR_, ']', _BAR_.join(_FfEeGg))  # in testStreprs
 
 del _convergence_, _distant_, _e_, _eps_, _exceeds_, _EQUALSPACED_,\
     _f_, _F_, _g_, _limit_, _PAREN_g, _RESIDUAL_
@@ -561,14 +561,14 @@ def unstr(where, *args, **kwds_):
         t  =  reprs(args, fmt=g) if args else ()
     if kwds:
         t += pairs(itemsorted(kwds), fmt=g)
-    n = where if isstr(where) else _DUNDER_nameof(where)  # _NN_
+    n = where if isstr(where) else typename(where)  # _NN_
     if C and hasattr(C, n):
         try:  # bound method of class C?
             where = where.__func__
         except AttributeError:
             pass  # method of C?
         if getattr(C, n, None) is where:
-            n = _DOT_(_DUNDER_nameof(C), n)
+            n = _DOT_(typename(C), n)
     return Fmt.PAREN(n, _COMMASPACE_.join(t))
 
 

pygeodesy/trf.py

@@ -69,16 +69,18 @@ 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, _xscalar
+from pygeodesy.basics import _isin, map1, neg, isidentifier, isstr, _xinstanceof, \
+                             _xscalar,  typename
 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
 # from pygeodesy.ellipsoids import _EWGS84  # from .datums
 from pygeodesy.errors import TRFError, _xattr, _xellipsoidall, _xkwds, _xkwds_item2
+# from pygeodesy.internals import typename  # from .basics
 from pygeodesy.interns import MISSING, NN, _AT_, _COMMASPACE_, _conversion_, \
-                             _datum_, _DOT_, _exists_, _invalid_, _MINUS_, \
-                             _NAD83_, _no_, _PLUS_, _reframe_, _s_, _SPACE_, \
-                             _STAR_, _to_, _vs_, _WGS84_, _x_, _intern as _i
+                             _datum_, _DMAIN_, _DOT_, _exists_, _invalid_, _MINUS_, \
+                             _NAD83_, _no_, _PLUS_, _reframe_, _s_, _SPACE_, _to_, \
+                             _STAR_, _vs_, _WGS84_, _x_, _intern as _i
 # from pygeodesy.lazily import _ALL_LAZY  # from .units
 from pygeodesy.named import ADict, classname, _lazyNamedEnumItem as _lazy, _name2__, \
                            _Named, _NamedEnum, _NamedEnumItem, _NamedTuple,  Fmt, unstr
@@ -91,7 +93,7 @@ from math import ceil as _ceil, fabs
 # import operator as _operator  # from .datums
 
 __all__ = _ALL_LAZY.trf
-__version__ = '24.10.14'
+__version__ = '25.04.14'
 
 _EP0CH    =  Epoch(0, low=0)
 _Es       = {_EP0CH: _EP0CH}  # L{Epoch}s, deleted below
@@ -176,9 +178,9 @@ class RefFrame(_NamedEnumItem):
 
            @raise TypeError: Invalid B{C{datum}}.
         '''
-        if datum in (_GRS80, None):
+        if _isin(datum, None, _GRS80):
             pass
-        elif datum in (_WGS84, _EWGS84):
+        elif _isin(datum, _WGS84, _EWGS84):
             self._datum = _WGS84
         else:
             _earth_datum(self, datum, raiser=_datum_)
@@ -1062,8 +1064,8 @@ def _toRefFrame(point, reframe2, reframe=None, epoch=None,
     e2 =  e1 if epoch2 is None else Epoch(epoch2=epoch2)
     t0 = _toTransform0(r1.name, e1, reframe2.name, e2)
     if t0 is None:
-        t = _SPACE_(RefFrame.__name__, _AT_(r1.name, e1),
-                           _to_, _AT_(reframe2.name, e2))
+        t = _SPACE_(typename(RefFrame), _AT_(r1.name, e1),
+                            _to_, _AT_(reframe2.name, e2))
         raise TRFError(_no_(_conversion_), txt=t)
 
     name, LatLon_kwds = _name2__(name_LatLon_kwds)
@@ -1732,7 +1734,7 @@ trfXform(_WGS84g1150_,  _ITRF2000_, epoch=_E(2004), xform=_P_0_0s, rates=_P_0_0s
 
 del _E, _Es, _i, _P, _P_0_0s, _R, _Rs, _X, _Xs
 
-if __name__ == '__main__':
+if __name__ == _DMAIN_:
 
     def _main():
         from pygeodesy.basics import _args_kwds_names
@@ -1740,8 +1742,8 @@ if __name__ == '__main__':
         from pygeodesy import printf
         from time import localtime
 
-        D = date2epoch.__name__
-        E = epoch2date.__name__
+        D = typename(date2epoch)
+        E = typename(epoch2date)
         y = localtime()[0]
         for m in range(1, 13):
             for d in (1, 15, _mDays[m] - 1, _mDays[m]):