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

pygeodesy/named.py

@@ -13,21 +13,20 @@ standard Python C{namedtuple}s.
 @see: Module L{pygeodesy.namedTuples} for (most of) the C{Named-Tuples}.
 '''
 
-from pygeodesy.basics import isidentifier, iskeyword, isstr, itemsorted, len2, \
-                            _xcopy, _xdup, _xinstanceof, _xsubclassof, _zip
+from pygeodesy.basics import isbool, isidentifier, iskeyword, isstr, itemsorted, \
+                             len2, _xcopy, _xdup, _xinstanceof, _xsubclassof, _zip
 # from pygeodesy.ecef import EcefKarney  # _MODS
 from pygeodesy.errors import _AssertionError, _AttributeError, _incompatible, \
                              _IndexError, _KeyError, LenError, _NameError, \
                              _NotImplementedError, _TypeError, _TypesError, \
                              _UnexpectedError, UnitError, _ValueError, \
                              _xattr, _xkwds, _xkwds_item2, _xkwds_pop2
-from pygeodesy.internals import _caller3, _DUNDER_nameof, _getPYGEODESY, _isPyPy, \
-                                _sizeof, _under
+from pygeodesy.internals import _caller3, _envPYGEODESY, _isPyPy, _sizeof, \
+                                 typename, _under
 from pygeodesy.interns import MISSING, NN, _AT_, _COLON_, _COLONSPACE_, _COMMA_, \
-                             _COMMASPACE_, _doesn_t_exist_, _DOT_, _DUNDER_, \
-                             _DUNDER_name_, _EQUAL_, _exists_, _immutable_, _name_, \
-                             _NL_, _NN_, _no_, _other_, _s_, _SPACE_, _std_, \
-                             _UNDER_, _vs_
+                             _COMMASPACE_, _DNAME_, _doesn_t_exist_, _DOT_, _DUNDER_, \
+                             _EQUAL_, _exists_, _immutable_, _name_, _NL_, _NN_, \
+                             _no_, _other_, _s_, _SPACE_, _std_, _UNDER_, _vs_
 from pygeodesy.lazily import _ALL_DOCS, _ALL_LAZY, _ALL_MODS as _MODS
 # from pygeodesy.ltp import Ltp, _toLocal, _toLtp  # _MODS
 # from pygeodesy.ltpTuples import Aer, Enu, Ned  # _MODS
@@ -38,7 +37,7 @@ from pygeodesy.streprs import attrs, Fmt, lrstrip, pairs, reprs, unstr
 # from pygeodesy.units import _toUnit  # _MODS
 
 __all__ = _ALL_LAZY.named
-__version__ = '24.12.05'
+__version__ = '25.04.14'
 
 _COMMANL_           = _COMMA_ + _NL_
 _COMMASPACEDOT_     = _COMMASPACE_ + _DOT_
@@ -49,7 +48,7 @@ _MRO_               = 'MRO'
 _name               = _under(_name_)
 _Names_             = '_Names_'
 _registered_        = 'registered'  # PYCHOK used!
-_std_NotImplemented = _getPYGEODESY('NOTIMPLEMENTED', NN).lower() == _std_
+_std_NotImplemented = _envPYGEODESY('NOTIMPLEMENTED', NN).lower() == _std_
 _such_              = 'such'
 _Units_             = '_Units_'
 _UP                 =  2
@@ -94,7 +93,7 @@ class ADict(dict):
         '''(INTERNAL) Create an C{AttributeError}.
         '''
         if _DOT_ not in name:  # NOT classname(self)!
-            name = _DOT_(self.__class__.__name__, name)
+            name = _DOT_(self.typename, name)
         return _AttributeError(item=name, txt=_doesn_t_exist_)
 
     @property_RO
@@ -116,11 +115,16 @@ class ADict(dict):
             dict.update(self, items)
         return self  # in RhumbLineBase.Intersecant2, _PseudoRhumbLine.Position
 
+    def _toL(self):
+        '''(INTERNAL) Get items as list.
+        '''
+        return list(_EQUAL_(*t) for t in self.items())  # _kwdstr
+
     def toRepr(self, **prec_fmt):
         '''Like C{repr(dict)} but with C{name} prefix and with
            C{floats} formatted by function L{pygeodesy.fstr}.
         '''
-        n = _xattr(self, name=NN) or self.__class__.__name__
+        n = _xattr(self, name=NN) or self.typename
         return Fmt.PAREN(n, self._toT(_EQUAL_, **prec_fmt))
 
     def toStr(self, **prec_fmt):
@@ -135,6 +139,12 @@ class ADict(dict):
         kwds = _xkwds(kwds, prec=6, fmt=Fmt.F, sep=sep)
         return _COMMASPACE_.join(pairs(itemsorted(self), **kwds))
 
+    @property_RO
+    def typename(self):
+        '''Get this C{ADict}'s type name (C{str}).
+        '''
+        return type(self).__name__  # typename(type(self))
+
 
 class _Named(object):
     '''(INTERNAL) Root class for named objects.
@@ -294,7 +304,7 @@ class _Named(object):
 
            @arg which: The method (C{callable}).
         '''
-        return _DOT_(self.classname, which.__name__ if callable(which) else _NN_)
+        return _DOT_(self.classname, typename(which) if callable(which) else _NN_)
 
     @property_doc_(''' the name (C{str}).''')
     def name(self):
@@ -314,7 +324,7 @@ class _Named(object):
         elif n != m:
             n =  repr(n)
             c =  self.classname
-            t = _DOT_(c, Fmt.PAREN(self.rename.__name__, n))
+            t = _DOT_(c, Fmt.PAREN(typename(self.rename), n))
             n = _DOT_(c, Fmt.EQUALSPACED(name=n))
             m =  Fmt.PAREN(_SPACE_('was', repr(m)))
             n = _SPACE_(n, m)
@@ -362,7 +372,7 @@ class _Named(object):
     def named4(self):
         '''Get the C{package.module.class} name I{and/or} the name or C{""} (C{str}).
         '''
-        return _xjoined_(_DOT_(self.__module__, self.__class__.__name__),  self.name)
+        return _xjoined_(_DOT_(self.__module__, self.typename),  self.name)
 
     def _notImplemented(self, *args, **kwds):
         '''(INTERNAL) See function L{notImplemented}.
@@ -426,6 +436,12 @@ class _Named(object):
 #       '''
 #       return _DOT_(self, unstr(which, *args, **kwds))
 
+    @property_RO
+    def typename(self):
+        '''Get this object's type name (C{str}).
+        '''
+        return type(self).__name__  # typename(type(self))
+
     def _xnamed(self, inst, name=NN, **force):
         '''(INTERNAL) Set the instance' C{.name = self.name}.
 
@@ -586,7 +602,7 @@ class _NamedDict(ADict, _Named):
     def _KeyError(self, key, *value):  # PYCHOK no cover
         '''(INTERNAL) Create a C{KeyError}.
         '''
-        n = self.name or self.__class__.__name__
+        n = self.name or self.typename
         t = Fmt.SQUARE(n, key)
         if value:
             t = Fmt.EQUALSPACED(t, *value)
@@ -622,7 +638,7 @@ class _NamedEnum(_NamedDict):
            @arg Classes: Additional, acceptable classes or C{type}s.
         '''
         self._item_Classes = (Class,) + Classes
-        n = _name__(**name) or NN(Class.__name__, _s_)  # _DUNDER_nameof
+        n = _name__(**name) or NN(typename(Class), _s_)
         if n and _xvalid(n, underOK=True):
             _Named.name.fset(self, n)  # see _Named.name
 
@@ -695,7 +711,7 @@ class _NamedEnum(_NamedDict):
         '''
         if all:  # instantiate any remaining L{_LazyNamedEnumItem}
             _isa = isinstance
-            for n, p in tuple(self.__class__.__dict__.items()):
+            for n, p in tuple(type(self).__dict__.items()):
                 if _isa(p, _LazyNamedEnumItem):
                     _ = getattr(self, n)
         return itemsorted(self) if asorted else ADict.items(self)
@@ -731,7 +747,7 @@ class _NamedEnum(_NamedDict):
         '''
         if item is all or item is any:
             _ = self.items(all=True)
-            n = item.__name__
+            n = typename(item)
         else:
             try:
                 n = item.name
@@ -1288,7 +1304,7 @@ class _NamedTuple(tuple, _Named):
                 t = Fmt.SQUARE(_Units_=i)  # PYCHOK no cover
                 raise _TypeError(self._DOT_(t), u)
 
-        self.__class__._validated = True
+        type(self)._validated = True
 
     def _xtend(self, xTuple, *items, **name):
         '''(INTERNAL) Extend this C{Named-Tuple} with C{items} to an other B{C{xTuple}}.
@@ -1297,7 +1313,7 @@ class _NamedTuple(tuple, _Named):
         if len(xTuple._Names_)       != (len(self._Names_) + len(items)) or \
                xTuple._Names_[:len(self)] != self._Names_:  # PYCHOK no cover
             c = NN(self.classname,  repr(self._Names_))
-            x = NN(xTuple.__name__, repr(xTuple._Names_))
+            x = NN(typename(xTuple), repr(xTuple._Names_))
             raise TypeError(_SPACE_(c, _vs_, x))
         t = self + items
         return xTuple(t, name=self._name__(name))  # .reUnit(*self._Units_)
@@ -1357,7 +1373,7 @@ def classname(inst, prefixed=None):
        @return: The B{C{inst}}'s C{[module.]class} name (C{str}).
     '''
     if prefixed is None:
-        prefixed = getattr(inst, classnaming.__name__, prefixed)
+        prefixed = getattr(inst, typename(classnaming), prefixed)
     return modulename(inst.__class__, prefixed=prefixed)
 
 
@@ -1369,7 +1385,7 @@ def classnaming(prefixed=None):
        @return: Previous class naming setting (C{bool}).
     '''
     t = _Named._classnaming
-    if prefixed in (True, False):
+    if isbool(prefixed):
         _Named._classnaming = prefixed
     return t
 
@@ -1385,9 +1401,9 @@ def modulename(clas, prefixed=None):  # in .basics._xversion
        @return: The B{C{class}}'s C{[module.]class} name (C{str}).
     '''
     try:
-        n = clas.__name__
+        n = typename(clas)
     except AttributeError:
-        n = clas if isstr(clas) else _DUNDER_name_
+        n = clas if isstr(clas) else _DNAME_
     if prefixed or (classnaming() if prefixed is None else False):
         try:
             m =  clas.__module__.rsplit(_DOT_, 1)
@@ -1406,7 +1422,7 @@ def modulename(clas, prefixed=None):  # in .basics._xversion
 #     if name:  # is given
 #         n = _name__(**name) if isinstance(name, dict) else str(name)
 #     elif name__ is not None:
-#         n = getattr(name__, _DUNDER_name_, NN)  # _xattr(name__, __name__=NN)
+#         n = getattr(name__, _DNAME_, NN)  # _xattr(name__, __name__=NN)
 #     else:
 #         n = name  # NN or None or {} or any False type
 #     if _or_nameof is not None and not n:
@@ -1443,7 +1459,7 @@ def _name2__(name=NN, name__=None, _or_nameof=None, **kwds):
         else:
             n = str(name)
     elif name__ is not None:
-        n = _DUNDER_nameof(name__, NN)
+        n = typename(name__, NN)
     else:
         n = name if name is None else NN
     if _or_nameof is not None and not n:
@@ -1461,7 +1477,7 @@ def nameof(inst):
     n = _xattr(inst, name=NN)
     if not n:  # and isinstance(inst, property):
         try:
-            n = inst.fget.__name__
+            n = typename(inst.fget)
         except AttributeError:
             n = NN
     return n
@@ -1470,7 +1486,7 @@ def nameof(inst):
 def _notDecap(where):
     '''De-Capitalize C{where.__name__}.
     '''
-    n = where.__name__
+    n = typename(where)
     c = n[3].lower()  # len(_not_)
     return NN(n[:3], _SPACE_, c, n[4:])
 
@@ -1478,8 +1494,8 @@ def _notDecap(where):
 def _notError(inst, name, args, kwds):  # PYCHOK no cover
     '''(INTERNAL) Format an error message.
     '''
-    n = _DOT_(classname(inst, prefixed=True), _DUNDER_nameof(name, name))
-    m = _COMMASPACE_.join(modulename(c, prefixed=True) for c in inst.__class__.__mro__[1:-1])
+    n = _DOT_(classname(inst, prefixed=True), typename(name, name))
+    m = _COMMASPACE_.join(modulename(c, prefixed=True) for c in type(inst).__mro__[1:-1])
     return _COMMASPACE_(unstr(n, *args, **kwds), Fmt.PAREN(_MRO_, m))
 
 

pygeodesy/nvectorBase.py

@@ -10,7 +10,7 @@ and published under the same MIT Licence**, see U{Vector-based geodesy
 <https://www.Movable-Type.co.UK/scripts/latlong-vectors.html>}.
 '''
 
-# from pygeodesy.basics import map1  # from .namedTuples
+from pygeodesy.basics import _isin, map1
 from pygeodesy.constants import EPS, EPS0, EPS1, EPS_2, R_M, \
                                _0_0, _1_0, _2_0, _N_2_0
 # from pygeodesy.datums import _spherical_datum  # from .formy
@@ -27,7 +27,7 @@ from pygeodesy.latlonBase import LatLonBase,  _ALL_DOCS, _ALL_LAZY, _MODS
 # from pygeodesy.lazily import _ALL_DOCS, _ALL_LAZY, _ALL_MODS as _MODS  # from .latlonBase
 from pygeodesy.named import _xother3,  _under
 from pygeodesy.namedTuples import LatLon2Tuple, PhiLam2Tuple, Trilaterate5Tuple, \
-                                  Vector3Tuple, Vector4Tuple,  map1
+                                  Vector3Tuple, Vector4Tuple
 from pygeodesy.props import deprecated_method, Property_RO, property_doc_, \
                             property_RO, property_ROnce, _update_all
 from pygeodesy.streprs import Fmt, hstr, unstr
@@ -38,7 +38,7 @@ from pygeodesy.vector3d import Vector3d, _xyzhdlln4
 from math import degrees, fabs, sqrt
 
 __all__ = _ALL_LAZY.nvectorBase
-__version__ = '24.11.24'
+__version__ = '25.04.14'
 
 
 class NvectorBase(Vector3d):  # XXX kept private
@@ -217,7 +217,7 @@ class NvectorBase(Vector3d):  # XXX kept private
     @deprecated_method
     def to3abh(self, height=None):  # PYCHOK no cover
         '''DEPRECATED, use property L{philamheight} or C{philam.to3Tuple(B{height})}.'''
-        return self.philamheight if height in (None, self.h) else \
+        return self.philamheight if _isin(height, None, self.h) else \
                self.philam.to3Tuple(height)
 
     def toCartesian(self, h=None, Cartesian=None, datum=None, **name_Cartesian_kwds):  # PYCHOK signature
@@ -249,7 +249,7 @@ class NvectorBase(Vector3d):  # XXX kept private
     def _toEcefDrv3(self, CC, LL, datum, h, name=NN, **unused):
         '''(INTERNAL) Helper for methods C{toCartesian} and C{toLatLon}.
         '''
-        D = self.datum if datum in (None, self.datum) else \
+        D = self.datum if _isin(datum, None, self.datum) else \
            _spherical_datum(datum, name=self.name)
         if LL is None:
             v = Vector3d(self, name=name or self.name)  # .toVector3d(norm=False)
@@ -272,7 +272,7 @@ class NvectorBase(Vector3d):  # XXX kept private
     @deprecated_method
     def to3llh(self, height=None):  # PYCHOK no cover
         '''DEPRECATED, use property C{latlonheight} or C{latlon.to3Tuple(B{height})}.'''
-        return self.latlonheight if height in (None, self.h) else \
+        return self.latlonheight if _isin(height, None, self.h) else \
                self.latlon.to3Tuple(height)
 
     def toLatLon(self, height=None, LatLon=None, datum=None, **name_LatLon_kwds):
@@ -336,7 +336,7 @@ class NvectorBase(Vector3d):  # XXX kept private
     @deprecated_method
     def to4xyzh(self, h=None):  # PYCHOK no cover
         '''DEPRECATED, use property L{xyzh} or C{xyz.to4Tuple(B{h})}.'''
-        return self.xyzh if h in (None, self.h) else Vector4Tuple(
+        return self.xyzh if _isin(h, None, self.h) else Vector4Tuple(
                self.x, self.y, self.z, h, name=self.name)
 
     def unit(self, ll=None):

pygeodesy/osgr.py

@@ -27,7 +27,7 @@ and U{Ordnance Survey National Grid<https://WikiPedia.org/wiki/Ordnance_Survey_N
 from __future__ import division as _; del _  # PYCHOK semicolon
 
 from pygeodesy.basics import halfs2, isbool, isfloat, map1, \
-                            _splituple, _xsubclassof
+                            _splituple, _xsubclassof,  typename
 from pygeodesy.constants import _1_0, _10_0,  _N_2_0  # PYCHOK used!
 from pygeodesy.datums import Datums, _ellipsoidal_datum, _WGS84
 # from pygeodesy.dms import parseDMS2   # _MODS
@@ -36,9 +36,10 @@ from pygeodesy.errors import _parseX, _TypeError, _ValueError, \
                              _xkwds, _xkwds_get, _xkwds_pop2
 from pygeodesy.fmath import Fdot, fpowers
 from pygeodesy.fsums import _Fsumf_
+# from pygeodesy.internals import typename  # from .basics
 from pygeodesy.interns import MISSING, NN, _A_, _COLON_, _COMMA_, \
-                             _COMMASPACE_, _DOT_, _ellipsoidal_, \
-                             _latlon_, _not_, _SPACE_
+                             _COMMASPACE_, _DMAIN_, _DOT_, _not_, \
+                             _ellipsoidal_, _latlon_, _SPACE_
 from pygeodesy.lazily import _ALL_LAZY, _ALL_MODS as _MODS
 from pygeodesy.named import _name2__, _NamedBase, nameof
 from pygeodesy.namedTuples import EasNor2Tuple, LatLon2Tuple, \
@@ -53,7 +54,7 @@ from pygeodesy.utily import degrees90, degrees180, sincostan3, truncate
 from math import cos, fabs, radians, sin, sqrt
 
 __all__ = _ALL_LAZY.osgr
-__version__ = '24.11.06'
+__version__ = '25.04.12'
 
 _equivalent_ = 'equivalent'
 _OSGR_       = 'OSGR'
@@ -336,7 +337,7 @@ class Osgr(_NamedBase):
             else:  # PYCHOK no cover
                 t =  str(self)
                 t =  Fmt.PAREN(self.classname, repr(t))
-                t = _DOT_(t, self.toLatLon.__name__)
+                t = _DOT_(t, typename(self.toLatLon))
                 t =  unstr(t, eps=eps, kTM=kTM)
                 raise OSGRError(Fmt.no_convergence(m), txt=t)
 
@@ -493,11 +494,11 @@ def _ll2LatLon3(ll, LatLon, datum, LatLon_kwds):
     '''
     n = nameof(ll)
     if LatLon is None:
-        r = _ll2datum(ll, datum, LatLonDatum3Tuple.__name__)
+        r = _ll2datum(ll, datum, typename(LatLonDatum3Tuple))
         r =  LatLonDatum3Tuple(r.lat, r.lon, r.datum, name=n)
     else:  # must be ellipsoidal
         _xsubclassof(_LLEB, LatLon=LatLon)
-        r = _ll2datum(ll, datum, LatLon.__name__)
+        r = _ll2datum(ll, datum, typename(LatLon))
         r =  LatLon(r.lat, r.lon, datum=r.datum, **_xkwds(LatLon_kwds, name=n))
     if r._iteration != ll._iteration:
         r._iteration = ll._iteration
@@ -670,7 +671,7 @@ def toOsgr(latlon, lon=None, kTM=False, datum=_WGS84, Osgr=Osgr,  # MCCABE 14
     return r
 
 
-if __name__ == '__main__':
+if __name__ == _DMAIN_:
 
     from pygeodesy import printf
     from random import random, seed

pygeodesy/points.py

@@ -27,7 +27,7 @@ C{ilon} longitude index in each 2+tuple.
 
 from pygeodesy.basics import isclass, isint, isscalar, issequence, \
                             _xdup, issubclassof, _Sequence, _xcopy, \
-                            _xinstanceof
+                            _xinstanceof,  typename
 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
@@ -39,6 +39,7 @@ from pygeodesy.errors import CrossError, crosserrors, _IndexError, \
 from pygeodesy.fmath import favg, fdot, hypot,  Fsum, fsum
 # from pygeodesy.fsums import Fsum, fsum  # from .fmath
 from pygeodesy.formy import _bearingTo2, equirectangular4,  _spherical_datum
+# from pygeodesy.internals import typename  # from .basics
 from pygeodesy.interns import NN, _colinear_, _COMMASPACE_, _composite_, \
                              _DEQUALSPACED_, _ELLIPSIS_, _EW_, _immutable_, \
                              _near_, _no_, _NS_, _point_, _SPACE_, _UNDER_, \
@@ -62,7 +63,7 @@ from pygeodesy.utily import atan2b, degrees90, degrees180, degrees2m, \
 from math import cos, fabs, fmod as _fmod, radians, sin
 
 __all__ = _ALL_LAZY.points
-__version__ = '24.10.24'
+__version__ = '25.04.18'
 
 _ilat_  = 'ilat'
 _ilon_  = 'ilon'
@@ -164,7 +165,7 @@ class LatLon_(LatLonBase):  # XXX in heights._HeightBase.height
                     favg(self.height, r.height, f=f)
                 # = self._havg(r, f=f, h=height)
                 r = self.classof(lat, lon, height=h, datum=r.datum,
-                                           name=r.intermediateTo.__name__)
+                                           name=typename(r.intermediateTo))
         return r
 
     def toRepr(self, **kwds):
@@ -1085,8 +1086,8 @@ def _distanceTo(Error, **name_points):  # .frechet, .hausdorff, .heights
     name, ps = _xkwds_item2(name_points)
     for i, p in enumerate(ps):
         if not callable(_xattr(p, distanceTo=None)):
-            n = _distanceTo.__name__[1:]
-            t = _SPACE_(_no_, callable.__name__, n)
+            n =  typename(_distanceTo)[1:]
+            t = _SPACE_(_no_, typename(callable), n)
             raise Error(Fmt.SQUARE(name, i), p, txt=t)
     return ps
 
@@ -1159,7 +1160,7 @@ def fractional(points, fi, j=None, wrap=None, LatLon=None, Vector=None, **kwds):
         raise _TypeError(txt__=fractional, **kwds)
     w = wrap if LatLon else False  # intermediateTo
     try:
-        if not isscalar(fi) or fi < 0:
+        if (not isscalar(fi)) or fi < 0:
             raise IndexError
         n = _xattr(fi, fin=0)
         p = _fractional(points, fi, j, fin=n, wrap=w)  # see .units.FIx
@@ -1172,7 +1173,7 @@ def fractional(points, fi, j=None, wrap=None, LatLon=None, Vector=None, **kwds):
     return p
 
 
-def _fractional(points, fi, j, fin=None, wrap=None):  # in .frechet.py
+def _fractional(points, fi, j, fin=None, wrap=None, dup=False):  # in .frechet.py
     '''(INTERNAL) Compute point at L{fractional} index C{fi} and C{j}.
     '''
     i = int(fi)
@@ -1186,12 +1187,13 @@ def _fractional(points, fi, j, fin=None, wrap=None):  # in .frechet.py
         q = points[j]
         if r >= EPS1:  # PYCHOK no cover
             p = q
-        elif wrap is not None:  # in (True, False)
+        elif wrap is not None:  # isbool(wrap)
             p = p.intermediateTo(q, r, wrap=wrap)
         elif _isLatLon(p):  # backward compatible default
-            p = LatLon2Tuple(favg(p.lat, q.lat, f=r),
+            t = LatLon2Tuple(favg(p.lat, q.lat, f=r),
                              favg(p.lon, q.lon, f=r),
                              name__=fractional)
+            p = p.dup(lat=t.lat, lon=t.lon, name=t.name) if dup else t  # PYCHOK lat, lon
         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),
@@ -1573,7 +1575,7 @@ def nearestOn5(point, points, closed=False, wrap=False, adjust=True,
     a =  atan2b(dx, dy)  # azimuth
     d =  hypot( dx, dy)
     h = _h(c)
-    n =  nameof(point) or nearestOn5.__name__
+    n =  nameof(point) or typename(nearestOn5)
     if LatLon_and_kwds:
         LL, kwds = _xkwds_pop2(LatLon_and_kwds, LatLon=None)
         if LL is not None:

pygeodesy/props.py

@@ -13,20 +13,20 @@ choices, see callable L{DeprecationWarnings} below.
 from pygeodesy.basics import isclass as _isclass
 from pygeodesy.errors import _AssertionError, _AttributeError, \
                              _xcallable, _xkwds_get
-# from pygeodesy.internals import _tailof  # from .lazily
+from pygeodesy.internals import _tailof, typename
 from pygeodesy.interns import MISSING, NN, _an_, _COMMASPACE_, \
                              _DEPRECATED_, _DOT_, _EQUALSPACED_, \
                              _immutable_, _invalid_, _module_, \
                              _N_A_, _NL_, _not_, _SPACE_, _UNDER_
 # from pygeodesy.named import callname  # _MODS, avoid circular
 from pygeodesy.lazily import _ALL_LAZY, _ALL_MODS as _MODS, \
-                             _FOR_DOCS, _WARNINGS_X_DEV,  _tailof
+                             _FOR_DOCS, _WARNINGS_X_DEV
 # from pygeodesy.streprs import Fmt  # _MODS
 
 from functools import wraps as _wraps
 
 __all__ = _ALL_LAZY.props
-__version__ = '24.11.06'
+__version__ = '25.04.14'
 
 _class_       = 'class'
 _DNL_         = _NL_ * 2  # PYCHOK used!
@@ -45,7 +45,7 @@ def _allPropertiesOf(Clas_or_inst, *Bases, **excls):
         S = Clas_or_inst,  # just this Clas
     else:  # class and super-classes of inst
         try:
-            S = Clas_or_inst.__class__.__mro__[:-1]  # not object
+            S = type(Clas_or_inst).__mro__[:-1]  # not object
         except AttributeError:
             raise
             S = ()  # not an inst
@@ -162,7 +162,7 @@ class _PropertyBase(property):
         _xcallable(getter=method, fget=fget)
 
         self.method = method
-        self.name   = method.__name__
+        self.name   = typename(method)
         d = doc or method.__doc__
         if _FOR_DOCS and d:
             self.__doc__ = d   # PYCHOK no cover
@@ -173,8 +173,8 @@ class _PropertyBase(property):
         '''(INTERNAL) Return an C{AttributeError} instance.
         '''
         if farg:
-            n = _DOT_(self.name, nameter.__name__)
-            n = _SPACE_(n, farg.__name__)
+            n = _DOT_(self.name, typename(nameter))
+            n = _SPACE_(n, typename(farg))
         else:
             n = nameter
         e = _SPACE_(kind, _MODS.named.classname(self))
@@ -349,7 +349,7 @@ class property_RO(_PropertyBase):
             else:
                 d = getattr(inst.__class__, uname, MISSING)
 #               if d is MISSING:  # XXX superfluous
-#                   for c in inst.__class__.__mro__[:-1]:
+#                   for c in type(inst).__mro__[:-1]:
 #                       if uname in c.__dict__:
 #                           d = c.__dict__[uname]
 #                           break
@@ -409,7 +409,7 @@ class property_ROver(_property_RO___):
                 setattr(c, n, v)  # overwrite property_ROver
                 break
         else:
-            n = _DOT_(C.__name__, n)
+            n = _DOT_(typename(C), n)
             raise _AssertionError(_EQUALSPACED_(n, v))
         return v
 
@@ -421,7 +421,7 @@ class _NamedProperty(property):  # in .named
     def name(self):
         '''Get the name of this C{property} (C{str}).
         '''
-        return self.fget.__name__
+        return typename(self.fget)
 
 
 def property_doc_(doc):
@@ -460,16 +460,16 @@ def _deprecated(call, kind, qual_d):
        @see: Brett Slatkin, "Effective Python", 2019 page 105, 2nd
              ed, Addison-Wesley.
     '''
-    doc = _docof(call)
+    doc = _DOCof(call)
 
     @_wraps(call)  # PYCHOK self?
     def _deprecated_call(*args, **kwds):
         if qual_d:  # function
-            q = qual_d
+            q =  qual_d
         elif args:  # method
-            q = _qualified(args[0], call.__name__)
+            q = _qualified(args[0], typename(call))
         else:  # PYCHOK no cover
-            q = call.__name__
+            q =  typename(call)
         _throwarning(kind, q, doc)
         return call(*args, **kwds)
 
@@ -484,8 +484,8 @@ def deprecated_class(cls_or_class):
        @note: NOT a decorator!
     '''
     if _WARNINGS_X_DEV:
-        q = _DOT_(cls_or_class.__module__, cls_or_class.__name__)
-        _throwarning(_class_, q, cls_or_class.__doc__)
+        q = _DOT_(cls_or_class.__module__, typename(cls_or_class))
+        _throwarning(_class_, q, cls_or_class.__doc__)  # _DDOC_
 
 
 def deprecated_function(call):
@@ -496,7 +496,7 @@ def deprecated_function(call):
        @return: The B{C{call}} DEPRECATED.
     '''
     return _deprecated(call, _function_, _DOT_(
-                       call.__module__, call.__name__)) if \
+                       call.__module__, typename(call))) if \
            _WARNINGS_X_DEV else call
 
 
@@ -524,13 +524,13 @@ if _WARNINGS_X_DEV:
         def __init__(self, method):
             '''Decorator for a DEPRECATED C{property} or C{Property} getter.
             '''
-            doc = _docof(method)
+            doc = _DOCof(method)
 
             def _fget(inst):  # PYCHOK no cover
                 '''Get the C{property} or C{Property} value.
                 '''
                 q = _qualified(inst, self.name)
-                _throwarning(property.__name__, q, doc)
+                _throwarning(typename(property), q, doc)
                 return self.method(inst)  # == method
 
             _PropertyBase.__init__(self, method, _fget, None, doc=doc)
@@ -554,7 +554,7 @@ if _WARNINGS_X_DEV:
                     '''Set the C{property} or C{Property} value.
                     '''
                     q = _qualified(inst, self.name)
-                    _throwarning(property.__name__, q, _docof(method))
+                    _throwarning(typename(property), q, _DOCof(method))
                     method(inst, val)
                     # self._update(inst)  # un-cache this item
 
@@ -594,7 +594,7 @@ def deprecated_property_RO(method):
 def _deprecated_RO(method, _RO):
     '''(INTERNAL) Create a DEPRECATED C{property_RO} or C{Property_RO}.
     '''
-    doc = _docof(method)
+    doc = _DOCof(method)
 
     if _WARNINGS_X_DEV:
 
@@ -606,7 +606,7 @@ def _deprecated_RO(method, _RO):
 
             def _fget(self, inst):  # PYCHOK no cover
                 q = _qualified(inst, self.name)
-                _throwarning(_RO.__name__, q, doc)
+                _throwarning(typename(_RO), q, doc)
                 return self.method(inst)
 
         return _Deprecated_RO(method)
@@ -614,7 +614,7 @@ def _deprecated_RO(method, _RO):
         return _RO(method, doc=doc)
 
 
-def _docof(obj):
+def _DOCof(obj):
     '''(INTERNAL) Get uniform DEPRECATED __doc__ string.
     '''
     try:
@@ -629,8 +629,8 @@ def _qualified(inst, name):
     '''(INTERNAL) Fully qualify a name.
     '''
     # _DOT_(inst.classname, name), not _DOT_(inst.named4, name)
-    c =  inst.__class__
-    q = _DOT_(c.__module__, c.__name__, name)
+    t =  type(inst)
+    q = _DOT_(t.__module__, typename(t), name)  # _DMODULE_
     return q