pygeodesy 24.5.24__py2.py3-none-any.whl → 24.6.1__py2.py3-none-any.whl

pygeodesy/mgrs.py

@@ -44,7 +44,7 @@ from pygeodesy.interns import NN, _0_, _A_, _AtoZnoIO_, _band_, _B_, \
                              _COMMASPACE_, _datum_, _easting_, _invalid_, \
                              _northing_, _SPACE_, _W_, _Y_, _Z_, _zone_
 from pygeodesy.lazily import _ALL_LAZY, _ALL_MODS as _MODS, _PYGEODESY_GEOCONVERT_
-from pygeodesy.named import _NamedBase, _NamedTuple, _Pass, _xnamed
+from pygeodesy.named import _name2__, _NamedBase, _NamedTuple, _Pass
 from pygeodesy.namedTuples import EasNor2Tuple, UtmUps5Tuple
 from pygeodesy.props import deprecated_property_RO, property_RO, Property_RO
 from pygeodesy.streprs import enstr2, _enstr2m3, Fmt, _resolution10, _xzipairs
@@ -55,7 +55,7 @@ from pygeodesy.utm import toUtm8, _to3zBlat, Utm, _UTM_ZONE_MAX, _UTM_ZONE_MIN
 # from pygeodesy.utmupsBase import _UTM_ZONE_MAX, _UTM_ZONE_MIN  # from .utm
 
 __all__ = _ALL_LAZY.mgrs
-__version__ = '24.05.24'
+__version__ = '24.05.31'
 
 _AN_    = 'AN'  # default south pole grid tile and band B
 _AtoPx_ = _AtoZnoIO_.tillP
@@ -87,7 +87,7 @@ class Mgrs(_NamedBase):
     _zone       =  0      # longitudinal or polar zone (C{int}), 0..60
 
     def __init__(self, zone=0, EN=NN, easting=0, northing=0, band=NN,
-                               datum=_WGS84, resolution=0, name=NN):
+                               datum=_WGS84, resolution=0, **name):
         '''New L{Mgrs} Military grid reference.
 
            @arg zone: The 6° I{longitudinal} zone (C{int}), 1..60 covering
@@ -104,7 +104,7 @@ class Mgrs(_NamedBase):
            @kwarg datum: This reference's datum (L{Datum}, L{Ellipsoid},
                          L{Ellipsoid2} or L{a_f2Tuple}).
            @kwarg resolution: Optional resolution (C{meter}), C{0} for default.
-           @kwarg name: Optional name (C{str}).
+           @kwarg name: Optional C{B{name}=NN} (C{str}).
 
            @raise MGRSError: Invalid B{C{zone}}, B{C{EN}}, B{C{easting}},
                              B{C{northing}}, B{C{band}} or B{C{resolution}}.
@@ -235,20 +235,18 @@ class Mgrs(_NamedBase):
             toUps8(a, 0, datum=self.datum, Ups=None)
         return int(u.northing / _100km) * _100km
 
-    def parse(self, strMGRS, name=NN):
+    def parse(self, strMGRS, **name):
         '''Parse a string to a similar L{Mgrs} instance.
 
-           @arg strMGRS: The MGRS reference (C{str}),
-                         see function L{parseMGRS}.
-           @kwarg name: Optional instance name (C{str}),
-                        overriding this name.
+           @arg strMGRS: The MGRS reference (C{str}), see function L{parseMGRS}.
+           @kwarg name: Optional C{B{name}=NN} (C{str}), overriding this name.
 
            @return: The similar instance (L{Mgrs}).
 
            @raise MGRSError: Invalid B{C{strMGRS}}.
         '''
         return parseMGRS(strMGRS, datum=self.datum, Mgrs=self.classof,
-                                  name=name or self.name)
+                                                    name=self._name__(name))
 
     @property
     def resolution(self):
@@ -536,7 +534,7 @@ class _RE(object):
 _RE = _RE()  # PYCHOK singleton
 
 
-def parseMGRS(strMGRS, datum=_WGS84, Mgrs=Mgrs, name=NN):
+def parseMGRS(strMGRS, datum=_WGS84, Mgrs=Mgrs, **name):
     '''Parse a string representing a MGRS grid reference,
        consisting of C{"[zone]Band, EN, easting, northing"}.
 
@@ -544,7 +542,7 @@ def parseMGRS(strMGRS, datum=_WGS84, Mgrs=Mgrs, name=NN):
        @kwarg datum: Optional datum to use (L{Datum}).
        @kwarg Mgrs: Optional class to return the MGRS grid
                     reference (L{Mgrs}) or C{None}.
-       @kwarg name: Optional B{C{Mgrs}} name (C{str}).
+       @kwarg name: Optional B{C{Mgrs}} C{B{name}=NN} (C{str}).
 
        @return: The MGRS grid reference as B{C{Mgrs}} or if
                 C{B{Mgrs} is None} as an L{Mgrs4Tuple}C{(zone,
@@ -582,29 +580,29 @@ def parseMGRS(strMGRS, datum=_WGS84, Mgrs=Mgrs, name=NN):
         e, n, m = _enstr2m3(*m[2:])
 
         if Mgrs is None:
-            r = Mgrs4Tuple(zB, EN, e, n, name=name)
+            r = Mgrs4Tuple(zB, EN, e, n, **name)
             _ = r.toMgrs(resolution=m)  # validate
         else:
-            r = Mgrs(zB, EN, e, n, datum=datum, resolution=m, name=name)
+            r = Mgrs(zB, EN, e, n, datum=datum, resolution=m, **name)
         return r
 
     return _parseX(_MGRS, strMGRS, datum, Mgrs, name,
                           strMGRS=strMGRS, Error=MGRSError)
 
 
-def toMgrs(utmups, Mgrs=Mgrs, name=NN, **Mgrs_kwds):
+def toMgrs(utmups, Mgrs=Mgrs, **name_Mgrs_kwds):
     '''Convert a UTM or UPS coordinate to an MGRS grid reference.
 
        @arg utmups: A UTM or UPS coordinate (L{Utm}, L{Etm} or L{Ups}).
        @kwarg Mgrs: Optional class to return the MGRS grid reference
                     (L{Mgrs}) or C{None}.
-       @kwarg name: Optional B{C{Mgrs}} name (C{str}).
-       @kwarg Mgrs_kwds: Optional, additional B{C{Mgrs}} keyword
-                         arguments, ignored if C{B{Mgrs} is None}.
+       @kwarg name_Mgrs_kwds: Optional C{B{name}=NN} (C{str}) and
+                   optional, additional B{C{Mgrs}} keyword arguments,
+                   ignored if C{B{Mgrs} is None}.
 
-       @return: The MGRS grid reference as B{C{Mgrs}} or if
-                C{B{Mgrs} is None} as an L{Mgrs6Tuple}C{(zone,
-                EN, easting, northing, band, datum)}.
+       @return: The MGRS grid reference as B{C{Mgrs}} or if C{B{Mgrs}
+                is None} as an L{Mgrs6Tuple}C{(zone, EN, easting,
+                northing, band, datum)}.
 
        @raise MGRSError: Invalid B{C{utmups}}.
 
@@ -634,12 +632,14 @@ def toMgrs(utmups, Mgrs=Mgrs, name=NN, **Mgrs_kwds):
     except (IndexError, TypeError, ValueError) as x:
         raise MGRSError(B=B, E=E, N=N, utmups=utmups, cause=x)
 
+    t, kwds = _name2__(name_Mgrs_kwds, _or_nameof=utmups)
     if Mgrs is None:
-        r = Mgrs4Tuple(Fmt.zone(z), EN, e, n).to6Tuple(B, utmups.datum)
+        r = Mgrs4Tuple(Fmt.zone(z), EN, e, n, name=t) \
+             .to6Tuple(B, utmups.datum)
     else:
-        kwds = _xkwds(Mgrs_kwds, band=B, datum=utmups.datum)
+        kwds = _xkwds(kwds, band=B, datum=utmups.datum, name=t)
         r = Mgrs(z, EN, e, n, **kwds)
-    return _xnamed(r, name or utmups.name)
+    return r
 
 
 def _um100km2(m):

pygeodesy/named.py

@@ -33,7 +33,7 @@ from pygeodesy.props import _allPropertiesOf_n, deprecated_method, _hasProperty,
 from pygeodesy.streprs import attrs, Fmt, lrstrip, pairs, reprs, unstr
 
 __all__ = _ALL_LAZY.named
-__version__ = '24.05.21'
+__version__ = '24.05.31'
 
 _COMMANL_           = _COMMA_ + _NL_
 _COMMASPACEDOT_     = _COMMASPACE_ + _DOT_
@@ -50,69 +50,6 @@ _Units_             = '_Units_'
 _UP                 =  2
 
 
-def _xjoined_(prefix, name=NN, enquote=True, **name__of_name):
-    '''(INTERNAL) Join C{prefix} and non-empty C{name}.
-    '''
-    if name__of_name:
-        name = _name__(name, **name__of_name)
-    if name and prefix:
-        if enquote:
-            name = repr(name)
-        t = _SPACE_(prefix, name)
-    else:
-        t =  prefix or name
-    return t
-
-
-def _xnamed(inst, name=NN, force=False, **name__of_name):
-    '''(INTERNAL) Set the instance' C{.name = B{name}}.
-
-       @arg inst: The instance (C{_Named}).
-       @kwarg name: The name (C{str}).
-       @kwarg force: If C{True}, force rename (C{bool}).
-
-       @return: The B{C{inst}}, renamed if B{C{force}}d
-                or if not named before.
-    '''
-    if name__of_name:
-        name = _name__(name, **name__of_name)
-    if name and isinstance(inst, _Named):
-        if not inst.name:
-            inst.name = name
-        elif force:
-            inst.rename(name)
-    return inst
-
-
-def _xother3(inst, other, name=_other_, up=1, **name_other):
-    '''(INTERNAL) Get C{name} and C{up} for a named C{other}.
-    '''
-    if name_other:  # and other is None
-        name, other = _xkwds_item2(name_other)
-    elif other and len(other) == 1:
-        name, other = _name__(name), other[0]
-    else:
-        raise _AssertionError(name, other, txt=classname(inst, prefixed=True))
-    return other, name, up
-
-
-def _xotherError(inst, other, name=_other_, up=1):
-    '''(INTERNAL) Return a C{_TypeError} for an incompatible, named C{other}.
-    '''
-    n = _callname(name, classname(inst, prefixed=True), inst.name, up=up + 1)
-    return _TypeError(name, other, txt=_incompatible(n))
-
-
-def _xvalid(name, underOK=False):
-    '''(INTERNAL) Check valid attribute name C{name}.
-    '''
-    return bool(name and isstr(name)
-                     and name != _name_
-                     and (underOK or not name.startswith(_UNDER_))
-                     and (not iskeyword(name))
-                     and isidentifier(name))
-
-
 class ADict(dict):
     '''A C{dict} with both key I{and} attribute access to
        the C{dict} items.
@@ -170,7 +107,6 @@ class ADict(dict):
            C{floats} formatted by function L{pygeodesy.fstr}.
         '''
         n = _xattr(self, name=NN) or self.__class__.__name__
-        print(1, n)
         return Fmt.PAREN(n, self._toT(_EQUAL_, **prec_fmt))
 
     def toStr(self, **prec_fmt):
@@ -1300,13 +1236,12 @@ def _name__(name=NN, **kwds):
     return name if name or name is None else NN
 
 
-def _name1__(kwds_name, _or_nameof=None):
+def _name1__(kwds_name, **name__or_nameof):
     '''(INTERNAL) Resolve and set the C{B{name}=NN}.
     '''
-    if kwds_name:
-        n, kwds_name = _name2__(kwds_name, _or_nameof=_or_nameof)
-        if n:
-            kwds_name.update(name=n)
+    if kwds_name or name__or_nameof:
+        n, kwds_name = _name2__(kwds_name, **name__or_nameof)
+        kwds_name.update(name=n)
     return kwds_name
 
 
@@ -1406,6 +1341,69 @@ def _Pass(arg, **unused):  # PYCHOK no cover
     return arg
 
 
+def _xjoined_(prefix, name=NN, enquote=True, **name__or_nameof):
+    '''(INTERNAL) Join C{prefix} and non-empty C{name}.
+    '''
+    if name__or_nameof:
+        name = _name__(name, **name__or_nameof)
+    if name and prefix:
+        if enquote:
+            name = repr(name)
+        t = _SPACE_(prefix, name)
+    else:
+        t =  prefix or name
+    return t
+
+
+def _xnamed(inst, name=NN, force=False, **name__or_nameof):
+    '''(INTERNAL) Set the instance' C{.name = B{name}}.
+
+       @arg inst: The instance (C{_Named}).
+       @kwarg name: The name (C{str}).
+       @kwarg force: If C{True}, force rename (C{bool}).
+
+       @return: The B{C{inst}}, renamed if B{C{force}}d
+                or if not named before.
+    '''
+    if name__or_nameof:
+        name = _name__(name, **name__or_nameof)
+    if name and isinstance(inst, _Named):
+        if not inst.name:
+            inst.name = name
+        elif force:
+            inst.rename(name)
+    return inst
+
+
+def _xother3(inst, other, name=_other_, up=1, **name_other):
+    '''(INTERNAL) Get C{name} and C{up} for a named C{other}.
+    '''
+    if name_other:  # and other is None
+        name, other = _xkwds_item2(name_other)
+    elif other and len(other) == 1:
+        name, other = _name__(name), other[0]
+    else:
+        raise _AssertionError(name, other, txt=classname(inst, prefixed=True))
+    return other, name, up
+
+
+def _xotherError(inst, other, name=_other_, up=1):
+    '''(INTERNAL) Return a C{_TypeError} for an incompatible, named C{other}.
+    '''
+    n = _callname(name, classname(inst, prefixed=True), inst.name, up=up + 1)
+    return _TypeError(name, other, txt=_incompatible(n))
+
+
+def _xvalid(name, underOK=False):
+    '''(INTERNAL) Check valid attribute name C{name}.
+    '''
+    return bool(name and isstr(name)
+                     and name != _name_
+                     and (underOK or not name.startswith(_UNDER_))
+                     and (not iskeyword(name))
+                     and isidentifier(name))
+
+
 __all__ += _ALL_DOCS(_Named,
                      _NamedBase,  # _NamedDict,
                      _NamedEnum, _NamedEnumItem,

pygeodesy/nvectorBase.py

@@ -39,7 +39,7 @@ from pygeodesy.vector3d import Vector3d, _xyzhdn3
 from math import fabs, sqrt
 
 __all__ = _ALL_LAZY.nvectorBase
-__version__ = '24.05.18'
+__version__ = '24.05.31'
 
 
 class NvectorBase(Vector3d):  # XXX kept private
@@ -385,7 +385,7 @@ SouthPole = NvectorBase(0, 0, -1, name=_SouthPole_)  # South pole (C{Nvector})
 class _N_vector_(NvectorBase):
     '''(INTERNAL) Minimal, low-overhead C{n-vector}.
     '''
-    def __init__(self, x, y, z, h=0, name=NN):
+    def __init__(self, x, y, z, h=0, **name):
         self._x, self._y, self._z = x, y, z
         if h:
             self._h = h

pygeodesy/osgr.py

@@ -33,14 +33,14 @@ from pygeodesy.datums import Datums, _ellipsoidal_datum, _WGS84
 # from pygeodesy.dms import parseDMS2   # _MODS
 from pygeodesy.ellipsoidalBase import LatLonEllipsoidalBase as _LLEB
 from pygeodesy.errors import _parseX, _TypeError, _ValueError, \
-                             _xkwds, _xkwds_get
+                             _xkwds, _xkwds_get, _xkwds_pop2
 from pygeodesy.fmath import Fdot, fpowers
 from pygeodesy.fsums import _Fsumf_
 from pygeodesy.interns import MISSING, NN, _A_, _COLON_, _COMMA_, \
                              _COMMASPACE_, _DOT_, _ellipsoidal_, \
                              _latlon_, _not_, _SPACE_
 from pygeodesy.lazily import _ALL_LAZY, _ALL_MODS as _MODS
-from pygeodesy.named import _NamedBase, nameof, _xnamed
+from pygeodesy.named import _name2__, _NamedBase, nameof
 from pygeodesy.namedTuples import EasNor2Tuple, LatLon2Tuple, \
                                   LatLonDatum3Tuple
 from pygeodesy.props import Property_RO, property_RO
@@ -53,7 +53,7 @@ from pygeodesy.utily import degrees90, degrees180, sincostan3, truncate
 from math import cos, fabs, radians, sin, sqrt
 
 __all__ = _ALL_LAZY.osgr
-__version__ = '24.05.13'
+__version__ = '24.05.31'
 
 _equivalent_ = 'equivalent'
 _OSGR_       = 'OSGR'
@@ -194,22 +194,17 @@ class Osgr(_NamedBase):
     _northing   =  0         # Nothing (C{meter})
     _resolution =  0         # from L{parseOSGR} (C{meter})
 
-    def __init__(self, easting, northing, datum=None, name=NN,
-                                          resolution=0):
+    def __init__(self, easting, northing, datum=None, resolution=0, **name):
         '''New L{Osgr} coordinate.
 
-           @arg easting: Easting from the OS C{National Grid}
-                         origin (C{meter}).
-           @arg northing: Northing from the OS C{National Grid}
-                          origin (C{meter}).
+           @arg easting: Easting from the OS C{National Grid} origin (C{meter}).
+           @arg northing: Northing from the OS C{National Grid} origin (C{meter}).
            @kwarg datum: Override default datum (C{Datums.OSGB36}).
-           @kwarg name: Optional name (C{str}).
-           @kwarg resolution: Optional resolution (C{meter}),
-                              C{0} for default.
+           @kwarg resolution: Optional resolution (C{meter}), C{0} for default.
+           @kwarg name: Optional C{B{name}=NN} (C{str}).
 
-           @raise OSGRError: Invalid or negative B{C{easting}} or
-                             B{C{northing}} or B{C{datum}} not an
-                             C{Datums.OSGB36} equivalent.
+           @raise OSGRError: Invalid or negative B{C{easting}} or B{C{northing}}
+                             or B{C{datum}} not an C{Datums.OSGB36} equivalent.
         '''
         if datum:  # PYCHOK no cover
             try:
@@ -267,17 +262,17 @@ class Osgr(_NamedBase):
         '''
         return self._northing
 
-    def parse(self, strOSGR, name=NN):
+    def parse(self, strOSGR, **name):
         '''Parse an OSGR reference to a similar L{Osgr} instance.
 
            @arg strOSGR: The OSGR reference (C{str}), see function L{parseOSGR}.
-           @kwarg name: Optional instance name (C{str}), overriding this name.
+           @kwarg name: Optional C{B{name}=NN} (C{str}), overriding this name.
 
            @return: The similar instance (L{Osgr})
 
            @raise OSGRError: Invalid B{C{strOSGR}}.
         '''
-        return parseOSGR(strOSGR, Osgr=self.classof, name=name or self.name)
+        return parseOSGR(strOSGR, Osgr=self.classof, name=self._name__(name))
 
     @property_RO
     def resolution(self):
@@ -496,19 +491,20 @@ def _ll2datum(ll, datum, name):
 def _ll2LatLon3(ll, LatLon, datum, LatLon_kwds):
     '''(INTERNAL) Convert C{ll} to C{LatLon}
     '''
+    n = nameof(ll)
     if LatLon is None:
         r = _ll2datum(ll, datum, LatLonDatum3Tuple.__name__)
-        r =  LatLonDatum3Tuple(r.lat, r.lon, r.datum)
+        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 =  LatLon(r.lat, r.lon, datum=r.datum, **LatLon_kwds)
+        r =  LatLon(r.lat, r.lon, datum=r.datum, **_xkwds(LatLon_kwds, name=n))
     if r._iteration != ll._iteration:
         r._iteration = ll._iteration
-    return _xnamed(r, nameof(ll))
+    return r
 
 
-def parseOSGR(strOSGR, Osgr=Osgr, name=NN, **Osgr_kwds):
+def parseOSGR(strOSGR, Osgr=Osgr, **name_Osgr_kwds):
     '''Parse a string representing an OS Grid Reference, consisting
        of C{"[GD] easting northing"}.
 
@@ -520,9 +516,9 @@ def parseOSGR(strOSGR, Osgr=Osgr, name=NN, **Osgr_kwds):
        @arg strOSGR: An OSGR coordinate (C{str}).
        @kwarg Osgr: Optional class to return the OSGR coordinate
                     (L{Osgr}) or C{None}.
-       @kwarg name: Optional B{C{Osgr}} name (C{str}).
-       @kwarg Osgr_kwds: Optional, additional B{C{Osgr}} keyword
-                         arguments, ignored if C{B{Osgr} is None}.
+       @kwarg name_Osgr_kwds: Optional C{B{name}=NN} (C{str}) and
+                   optional, additional B{C{Osgr}} keyword arguments,
+                   ignored if C{B{Osgr} is None}.
 
        @return: An (B{C{Osgr}}) instance or if B{C{Osgr}} is
                 C{None} an L{EasNor2Tuple}C{(easting, northing)}.
@@ -537,7 +533,7 @@ def parseOSGR(strOSGR, Osgr=Osgr, name=NN, **Osgr_kwds):
             raise ValueError
         return g
 
-    def _OSGR(strOSGR, Osgr, name):
+    def _OSGR(strOSGR, Osgr, kwds):
         s = _splituple(strOSGR.strip())
         p =  len(s)
         if not p:
@@ -570,20 +566,20 @@ def parseOSGR(strOSGR, Osgr=Osgr, name=NN, **Osgr_kwds):
             e +=  E * _100km
             n +=  N * _100km
 
+        name, kwds = _name2__(**kwds)
         if Osgr is None:
             _ = _MODS.osgr.Osgr(e, n, resolution=m)  # validate
             r =  EasNor2Tuple(e, n, name=name)
         else:
-            r =  Osgr(e, n, name=name,
-                         **_xkwds(Osgr_kwds, resolution=m))
+            r =  Osgr(e, n, name=name, **_xkwds(kwds, resolution=m))
         return r
 
-    return _parseX(_OSGR, strOSGR, Osgr, name,
+    return _parseX(_OSGR, strOSGR, Osgr, name_Osgr_kwds,
                           strOSGR=strOSGR, Error=OSGRError)
 
 
-def toOsgr(latlon, lon=None, kTM=False, datum=_WGS84, Osgr=Osgr, name=NN,  # MCCABE 14
-                                               **prec_Osgr_kwds):
+def toOsgr(latlon, lon=None, kTM=False, datum=_WGS84, Osgr=Osgr,  # MCCABE 14
+                                          **prec_name_Osgr_kwds):
     '''Convert a lat-/longitude point to an OSGR coordinate.
 
        @arg latlon: Latitude (C{degrees}) or an (ellipsoidal) geodetic
@@ -597,11 +593,10 @@ def toOsgr(latlon, lon=None, kTM=False, datum=_WGS84, Osgr=Osgr, name=NN,  # MCC
                      L{a_f2Tuple}).
        @kwarg Osgr: Optional class to return the OSGR coordinate
                     (L{Osgr}) or C{None}.
-       @kwarg name: Optional B{C{Osgr}} name (C{str}).
-       @kwarg prec_Osgr_kwds: Optional L{truncate} precision
-                              C{B{prec}=ndigits} and/or additional
-                              B{C{Osgr}} keyword arguments, ignored
-                              if C{B{Osgr} is None}.
+       @kwarg prec_name_Osgr_kwds: Optional C{B{name}=NN} (C{str}),
+                   optional L{truncate} precision C{B{prec}=ndigits}
+                   and additional B{C{Osgr}} keyword arguments,
+                   ignored if C{B{Osgr} is None}.
 
        @return: An (B{C{Osgr}}) instance or if B{C{Osgr}} is C{None}
                 an L{EasNor2Tuple}C{(easting, northing)}.
@@ -615,9 +610,6 @@ def toOsgr(latlon, lon=None, kTM=False, datum=_WGS84, Osgr=Osgr, name=NN,  # MCC
                          B{C{datum}}, B{C{Osgr}}, B{C{Osgr_kwds}}
                          or conversion to C{Datums.OSGB36} failed.
     '''
-    def _prec_kwds2(prec=MISSING, **kwds):
-        return prec, kwds
-
     if lon is not None:
         try:
             lat, lon = _MODS.dms.parseDMS2(latlon, lon)
@@ -626,8 +618,6 @@ def toOsgr(latlon, lon=None, kTM=False, datum=_WGS84, Osgr=Osgr, name=NN,  # MCC
             raise OSGRError(latlon=latlon, lon=lon, datum=datum, cause=x)
     elif not isinstance(latlon, _LLEB):
         raise _TypeError(latlon=latlon, txt=_not_(_ellipsoidal_))
-    elif not name:  # use latlon.name
-        name = nameof(latlon)
 
     NG = _NG
     # convert latlon to OSGB36 first
@@ -663,22 +653,24 @@ def toOsgr(latlon, lon=None, kTM=False, datum=_WGS84, Osgr=Osgr, name=NN,  # MCC
              d2 / 12 * (_Fsumf_( 5, ta2,  9 * n2) +
              d2 / 30 *  _Fsumf_(61, ta4, 58 * ta2)))).fsum_(m0, NG.nor0)
 
-    p, kwds = _prec_kwds2(**prec_Osgr_kwds)
-    if p is not MISSING:
-        e = truncate(e, p)
-        n = truncate(n, p)
+    t, kwds = _name2__(prec_name_Osgr_kwds, _or_nameof=latlon)
+    if kwds:
+        p, kwds = _xkwds_pop2(kwds, prec=MISSING)
+        if p is not MISSING:
+            e = truncate(e, p)
+            n = truncate(n, p)
 
     if Osgr is None:
         _ = _MODS.osgr.Osgr(e, n)  # validate
-        r =  EasNor2Tuple(e, n)
+        r =  EasNor2Tuple(e, n, name=t)
     else:
-        r = Osgr(e, n, **kwds)  # datum=NG.datum
+        r =  Osgr(e, n, name=t, **kwds)  # datum=NG.datum
         if lon is None and isinstance(latlon, _LLEB):
             if kTM:
                 r._latlonTM = latlon  # XXX weakref(latlon)?
             else:
                 r._latlon = latlon  # XXX weakref(latlon)?
-    return _xnamed(r, name or nameof(latlon))
+    return r
 
 
 if __name__ == '__main__':

pygeodesy/points.py

@@ -38,7 +38,7 @@ from pygeodesy.errors import CrossError, crosserrors, _IndexError, \
                             _xattr, _xkwds, _xkwds_item2, _xkwds_pop2
 from pygeodesy.fmath import favg, fdot, hypot,  Fsum, fsum
 # from pygeodesy.fsums import Fsum, fsum  # from .fmath
-from pygeodesy.formy import _bearingTo2, equirectangular_,  _spherical_datum
+from pygeodesy.formy import _bearingTo2, equirectangular4,  _spherical_datum
 from pygeodesy.interns import NN, _colinear_, _COMMASPACE_, _composite_, \
                              _DEQUALSPACED_, _ELLIPSIS_, _EW_, _immutable_, \
                              _near_, _no_, _NS_, _point_, _SPACE_, _UNDER_, \
@@ -62,7 +62,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.05.19'
+__version__ = '24.05.25'
 
 _ilat_  = 'ilat'
 _ilon_  = 'ilon'
@@ -1473,8 +1473,8 @@ def nearestOn5(point, points, closed=False, wrap=False, adjust=True,
        @kwarg closed: Optionally, close the path or polygon (C{bool}).
        @kwarg wrap: If C{True}, wrap or I{normalize} and unroll the
                     B{C{points}} (C{bool}).
-       @kwarg adjust: See function L{pygeodesy.equirectangular_} (C{bool}).
-       @kwarg limit: See function L{pygeodesy.equirectangular_} (C{degrees}),
+       @kwarg adjust: See function L{pygeodesy.equirectangular4} (C{bool}).
+       @kwarg limit: See function L{pygeodesy.equirectangular4} (C{degrees}),
                      default C{9 degrees} is about C{1,000 Kmeter} (for mean
                      spherical earth radius L{R_KM}).
        @kwarg LatLon_and_kwds: Optional, C{B{LatLon}=None} class to use for
@@ -1490,24 +1490,24 @@ def nearestOn5(point, points, closed=False, wrap=False, adjust=True,
                 compass C{degrees}, like function L{pygeodesy.compassAngle}.
 
        @raise LimitError: Lat- and/or longitudinal delta exceeds the B{C{limit}},
-                          see function L{pygeodesy.equirectangular_}.
+                          see function L{pygeodesy.equirectangular4}.
 
        @raise PointsError: Insufficient number of B{C{points}}
 
        @raise TypeError: Some B{C{points}} are not C{LatLon}.
 
-       @note: Distances are I{approximated} by function L{pygeodesy.equirectangular_}.
+       @note: Distances are I{approximated} by function L{pygeodesy.equirectangular4}.
               For more accuracy use one of the C{LatLon.nearestOn6} methods.
 
        @see: Function L{pygeodesy.degrees2m}.
     '''
     def _d2yx4(p2, p1, u, alw):
         # w = wrap if (i < (n - 1) or not closed) else False
-        # equirectangular_ returns a Distance4Tuple(distance
+        # equirectangular4 returns a Distance4Tuple(distance
         # in degrees squared, delta lat, delta lon, p2.lon
         # unroll/wrap'd); the previous p2.lon unroll/wrap'd
         # is also applied to the next edge's p1.lon
-        return equirectangular_(p1.lat, p1.lon + u,
+        return equirectangular4(p1.lat, p1.lon + u,
                                 p2.lat, p2.lon, **alw)
 
     def _h(p):  # get height or default 0
@@ -1604,7 +1604,7 @@ def perimeterOf(points, closed=False, adjust=True, radius=R_M, wrap=True):
        @raise ValueError: Invalid B{C{radius}} or C{B{closed}=False} with
                           C{B{points}} a composite.
 
-       @note: This perimeter is based on the L{pygeodesy.equirectangular_}
+       @note: This perimeter is based on the L{pygeodesy.equirectangular4}
               distance approximation and is ill-suited for regions exceeding
               several hundred Km or Miles or with near-polar latitudes.
 
@@ -1618,7 +1618,7 @@ def perimeterOf(points, closed=False, adjust=True, radius=R_M, wrap=True):
             if w and c:
                 w = not Ps.looped
             # apply previous x2's unroll/wrap'd to new x1
-            _, dy, dx, u = equirectangular_(p1.y, p1.x + u,
+            _, dy, dx, u = equirectangular4(p1.y, p1.x + u,
                                             p2.y, p2.x,
                                             adjust=a, limit=None,
                                             wrap=w)  # PYCHOK non-seq