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

pygeodesy/named.py

@@ -13,32 +13,29 @@ 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
 from pygeodesy.props import _allPropertiesOf_n, deprecated_method, _hasProperty, \
                             _update_all, property_doc_, Property_RO, property_RO, \
-                            _update_attrs, property_ROver
+                            _update_attrs
 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.28'
 
 _COMMANL_           = _COMMA_ + _NL_
 _COMMASPACEDOT_     = _COMMASPACE_ + _DOT_
@@ -49,7 +46,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 +91,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 +113,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 +137,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 +302,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 +322,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 +370,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 +434,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 +600,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 +636,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 +709,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 +745,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
@@ -899,148 +913,6 @@ class _NamedEnumItem(_NamedBase):
                 raise _AssertionError(t)
 
 
-class _NamedLocal(object):
-    '''(INTERNAL) Base class for C{CartesianBase}, C{Ecef9Tuple} and C{LatLonBase}.
-     '''
-
-    @property_ROver
-    def Ecef(self):
-        '''Get the ECEF I{class} (L{EcefKarney}), I{once}.
-        '''
-        return _MODS.ecef.EcefKarney
-
-    @property_RO
-    def _ecef9(self):
-        '''I{Must be overloaded}.'''
-        notOverloaded(self)
-
-    @Property_RO
-    def _Ltp(self):
-        '''(INTERNAL) Cache this instance' LTP (L{Ltp}).
-        '''
-        return self._ltp.Ltp(self._ecef9, ecef=self.Ecef(self.datum), name=self.name)
-
-    @property_ROver
-    def _ltp(self):
-        '''(INTERNAL) Get module L{pygeodesy.ltp}, I{once}.
-        '''
-        return _MODS.ltp
-
-    def _ltp_toLocal(self, ltp, Xyz_kwds, **Xyz):  # overloaded in C{Ecef9Tuple}
-        '''(INTERNAL) Invoke C{ltp._toLocal}.
-        '''
-        Xyz_ = self._ltp_toLocal2(Xyz_kwds, **Xyz)
-        return self._ltp._toLocal(self, ltp, *Xyz_)  # self._ecef9
-
-    def _ltp_toLocal2(self, Xyz_kwds, _None=None, **Xyz):
-        '''(INTERNAL) Return 2-tuple C{(Xyz_Class, Xyz_kwds)}.
-        '''
-        C, _ = Xyz_ = _xkwds_pop2(Xyz_kwds, **Xyz)
-        if C is not _None:  # validate C
-            n, X = _xkwds_item2(Xyz)
-            if X is not C:
-                _xsubclassof(X, **{n: C})
-        return Xyz_
-
-    @property_ROver
-    def _ltpTuples(self):
-        '''(INTERNAL) Get module L{pygeodesy.ltpTuples}, I{once}.
-        '''
-        return _MODS.ltpTuples
-
-    def toAer(self, ltp=None, **Aer_and_kwds):
-        '''Convert this instance to I{local} I{Azimuth, Elevation, slant Range} (AER) components.
-
-           @kwarg ltp: The I{local tangent plane} (LTP) to use (L{Ltp}), overriding this
-                       instance' L{LTP<pygeodesy.named._NamedLocal.toLtp>}.
-           @kwarg Aer_and_kwds: Optional AER class C{B{Aer}=}L{Aer<pygeodesy.ltpTuples.Aer>}
-                      to use and optionally, additional B{C{Aer}} keyword arguments.
-
-           @return: An B{C{Aer}} instance.
-
-           @raise TypeError: Invalid B{C{ltp}}.
-
-           @see: Method L{toLocal<pygeodesy.named._NamedLocal.toLocal>}.
-        '''
-        return self._ltp_toLocal(ltp, Aer_and_kwds, Aer=self._ltpTuples.Aer)
-
-    def toEnu(self, ltp=None, **Enu_and_kwds):
-        '''Convert this instance to I{local} I{East, North, Up} (ENU) components.
-
-           @kwarg ltp: The I{local tangent plane} (LTP) to use (L{Ltp}), overriding this
-                       instance' L{LTP<pygeodesy.named._NamedLocal.toLtp>}.
-           @kwarg Enu_and_kwds: Optional ENU class C{B{Enu}=}L{Enu<pygeodesy.ltpTuples.Enu>}
-                      to use and optionally, additional B{C{Enu}} keyword arguments.
-
-           @return: An B{C{Enu}} instance.
-
-           @raise TypeError: Invalid B{C{ltp}}.
-
-           @see: Method L{toLocal<pygeodesy.named._NamedLocal.toLocal>}.
-        '''
-        return self._ltp_toLocal(ltp, Enu_and_kwds, Enu=self._ltpTuples.Enu)
-
-    def toLocal(self, Xyz=None, ltp=None, **Xyz_kwds):
-        '''Convert this instance to I{local} components in a I{local tangent plane} (LTP)
-
-           @kwarg Xyz: Optional I{local} components class (L{XyzLocal}, L{Aer},
-                       L{Enu}, L{Ned}) or C{None}.
-           @kwarg ltp: The I{local tangent plane} (LTP) to use (L{Ltp}), overriding this
-                       cartesian's L{LTP<pygeodesy.named._NamedLocal.toLtp>}.
-           @kwarg Xyz_kwds: Optionally, additional B{C{Xyz}} keyword arguments, ignored
-                            if C{B{Xyz} is None}.
-
-           @return: An B{C{Xyz}} instance or a L{Local9Tuple}C{(x, y, z, lat, lon,
-                    height, ltp, ecef, M)} if C{B{Xyz} is None} (with C{M=None}).
-
-           @raise TypeError: Invalid B{C{ltp}}.
-        '''
-        return self._ltp_toLocal(ltp, Xyz_kwds, Xyz=Xyz, _None=Xyz)
-
-    def toLtp(self, Ecef=None, **name):
-        '''Return the I{local tangent plane} (LTP) for this instance.
-
-           @kwarg Ecef: Optional ECEF I{class} (L{EcefKarney}, ... L{EcefYou}), overriding
-                        this instance' L{Ecef<pygeodesy.named._NamedLocal.Ecef>}.
-           @kwarg name: Optional C{B{name}=NN} (C{str}).
-
-           @return: An B{C{Ltp}} instance.
-        '''
-        return self._ltp._toLtp(self, Ecef, self._ecef9, name)  # needs self.Ecef and self._Ltp
-
-    def toNed(self, ltp=None, **Ned_and_kwds):
-        '''Convert this instance to I{local} I{North, East, Down} (NED) components.
-
-           @kwarg ltp: The I{local tangent plane} (LTP) to use (L{Ltp}), overriding this
-                       instance' L{LTP<pygeodesy.named._NamedLocal.toLtp>}.
-           @kwarg Ned_and_kwds: Optional NED class C{B{Ned}=}L{Ned<pygeodesy.ltpTuples.Ned>}
-                      to use and optionally, additional B{C{Ned}} keyword arguments.
-
-           @return: An B{C{Ned}} instance.
-
-           @raise TypeError: Invalid B{C{ltp}}.
-
-           @see: Method L{toLocal<pygeodesy.named._NamedLocal.toLocal>}.
-        '''
-        return self._ltp_toLocal(ltp, Ned_and_kwds, Ned=self._ltpTuples.Ned)
-
-    def toXyz(self, ltp=None, **Xyz_and_kwds):
-        '''Convert this instance to I{local} I{X, Y, Z} (XYZ) components.
-
-           @kwarg ltp: The I{local tangent plane} (LTP) to use (L{Ltp}), overriding this
-                       instance' L{LTP<pygeodesy.named._NamedLocal.toLtp>}.
-           @kwarg Xyz_and_kwds: Optional XYZ class C{B{Xyz}=}L{Xyz<pygeodesy.ltpTuples.XyzLocal>}
-                      to use and optionally, additional B{C{Xyz}} keyword arguments.
-
-           @return: An B{C{Xyz}} instance.
-
-           @raise TypeError: Invalid B{C{ltp}}.
-
-           @see: Method L{toLocal<pygeodesy.named._NamedLocal.toLocal>}.
-        '''
-        return self._ltp_toLocal(ltp, Xyz_and_kwds, Xyz=self._ltpTuples.XyzLocal)
-
-
 # from pygeodesy.props import _NamedProperty
 
 
@@ -1288,7 +1160,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 +1169,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 +1229,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 +1241,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 +1257,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 +1278,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 +1315,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 +1333,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 +1342,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 +1350,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))
 
 
@@ -1595,7 +1467,6 @@ def _xvalid(name, underOK=False):
 __all__ += _ALL_DOCS(_Named,
                      _NamedBase,  # _NamedDict,
                      _NamedEnum, _NamedEnumItem,
-                     _NamedLocal,
                      _NamedTuple)
 
 # **) MIT License

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: