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

pygeodesy/ecef.py

@@ -58,7 +58,7 @@ plane} as opposed to I{geocentric} (ECEF) ones.
 '''
 
 from pygeodesy.basics import copysign0, isscalar, issubclassof, neg, map1, \
-                            _xinstanceof, _xsubclassof
+                            _xinstanceof, _xsubclassof  # _args_kwds_names
 from pygeodesy.constants import EPS, EPS0, EPS02, EPS1, EPS2, EPS_2, INT0, PI, PI_2, \
                                _0_0, _0_0001, _0_01, _0_5, _1_0, _1_0_1T, _N_1_0, \
                                _2_0, _N_2_0, _3_0, _4_0, _6_0, _60_0, _90_0, _N_90_0, \
@@ -73,7 +73,7 @@ from pygeodesy.interns import NN, _a_, _C_, _datum_, _ellipsoid_, _f_, _height_,
                              _lat_, _lon_, _M_, _name_, _singular_, _SPACE_, \
                              _x_, _xyz_, _y_, _z_
 from pygeodesy.lazily import _ALL_DOCS, _ALL_LAZY, _ALL_MODS as _MODS
-from pygeodesy.named import _name__, _NamedBase, _NamedTuple, _Pass, _xnamed
+from pygeodesy.named import _name__, _name1__, _NamedBase, _NamedTuple, _Pass, _xnamed
 from pygeodesy.namedTuples import LatLon2Tuple, LatLon3Tuple, \
                                   PhiLam2Tuple, Vector3Tuple, Vector4Tuple
 from pygeodesy.props import deprecated_method, Property_RO, property_RO, property_doc_
@@ -86,7 +86,7 @@ from pygeodesy.utily import atan1, atan1d, atan2d, degrees90, degrees180, \
 from math import atan2, cos, degrees, fabs, radians, sqrt
 
 __all__ = _ALL_LAZY.ecef
-__version__ = '24.05.21'
+__version__ = '24.06.09'
 
 _Ecef_    = 'Ecef'
 _prolate_ = 'prolate'
@@ -133,13 +133,13 @@ class _EcefBase(_NamedBase):
             elif _isRadius(E) and isscalar(f):
                 E = a_f2Tuple(E, f)
             else:
-                raise ValueError  # _invalid_
+                raise ValueError()  # _invalid_
 
             if E not in (_EWGS84, _WGS84):
                 d = _ellipsoidal_datum(E, **name)
                 E =  d.ellipsoid
                 if E.a < EPS or E.f > EPS1:
-                    raise ValueError  # _invalid_
+                    raise ValueError()  # _invalid_
                 self._datum = d
                 self._E     = E
 
@@ -209,7 +209,7 @@ class _EcefBase(_NamedBase):
         m = self._Matrix(sa, ca, sb, cb) if M else None
         return Ecef9Tuple(x * cb, x * sb, z, lat, lon, h,
                                              0, m, self.datum,
-                                             name=name or self.name)
+                                             name=self._name__(name))
 
     def forward(self, latlonh, lon=None, height=0, M=False, **name):
         '''Convert from geodetic C{(lat, lon, height)} to geocentric C{(x, y, z)}.
@@ -299,14 +299,14 @@ class _EcefBase(_NamedBase):
         '''
         return self._xnamed(EcefMatrix(sa, ca, sb, cb))
 
-    def _polon(self, y, x, R, **name_lon00):
+    def _polon(self, y, x, R, **lon00_name):
         '''(INTERNAL) Handle I{"polar"} longitude.
         '''
-        return atan2d(y, x) if R else _xkwds_get(name_lon00, lon00=self.lon00)
+        return atan2d(y, x) if R else _xkwds_get(lon00_name, lon00=self.lon00)
 
-    def reverse(self, xyz, y=None, z=None, M=False, **name_lon00):  # PYCHOK no cover
+    def reverse(self, xyz, y=None, z=None, M=False, **lon00_name):  # PYCHOK no cover
         '''I{Must be overloaded}.'''
-        self._notOverloaded(xyz, y=y, z=z, M=M, **name_lon00)
+        self._notOverloaded(xyz, y=y, z=z, M=M, **lon00_name)
 
     def toStr(self, prec=9, **unused):  # PYCHOK signature
         '''Return this C{Ecef*} as a string.
@@ -324,7 +324,7 @@ class EcefFarrell21(_EcefBase):
        books?id=fW4foWASY6wC>}, page 29.
     '''
 
-    def reverse(self, xyz, y=None, z=None, M=None, **name_lon00):  # PYCHOK unused M
+    def reverse(self, xyz, y=None, z=None, M=None, **lon00_name):  # PYCHOK unused M
         '''Convert from geocentric C{(x, y, z)} to geodetic C{(lat, lon, height)} using
            I{Farrell}'s U{Table 2.1<https://Books.Google.com/books?id=fW4foWASY6wC>},
            page 29.
@@ -334,10 +334,9 @@ class EcefFarrell21(_EcefBase):
            @kwarg y: ECEF C{y} coordinate for C{scalar} B{C{xyz}} and B{C{z}} (C{meter}).
            @kwarg z: ECEF C{z} coordinate for C{scalar} B{C{xyz}} and B{C{y}} (C{meter}).
            @kwarg M: I{Ignored}, rotation matrix C{M} not available.
-           @kwarg name_lon00: Optional keyword arguments C{B{name}=NN} (C{str}) and
-                       I{"polar"} longitude C{B{lon00}=INT0} (C{degrees}), overriding
-                       the default and property C{lon00} setting and returned if
-                       C{B{x}=0} and C{B{y}=0}.
+           @kwarg lon00_name: Optional C{B{name}=NN} (C{str}) and optional keyword argument
+                       C{B{lon00}=INT0} (C{degrees}), an arbitrary I{"polar"} longitude
+                       returned if C{B{x}=0} and C{B{y}=0}, see property C{lon00}.
 
            @return: An L{Ecef9Tuple}C{(x, y, z, lat, lon, height, C, M, datum)} with
                     geodetic coordinates C{(lat, lon, height)} for the given geocentric
@@ -350,7 +349,7 @@ class EcefFarrell21(_EcefBase):
 
            @see: L{EcefFarrell22} and L{EcefVeness}.
         '''
-        x, y, z, name = _xyzn4(xyz, y, z, self._Geocentrics, **name_lon00)
+        x, y, z, name = _xyzn4(xyz, y, z, self._Geocentrics, **lon00_name)
 
         E   = self.ellipsoid
         a   = E.a
@@ -382,7 +381,7 @@ class EcefFarrell21(_EcefBase):
 
             h   = hypot(r, z) * (_1_0 - v)
             lat = atan1d((e2_ * v + _1_0) * z, p)
-            lon = self._polon(y, x, p, **name_lon00)
+            lon = self._polon(y, x, p, **lon00_name)
             # note, phi and lam are swapped on page 29
 
         except (ValueError, ZeroDivisionError) as e:
@@ -390,7 +389,7 @@ class EcefFarrell21(_EcefBase):
 
         return Ecef9Tuple(x, y, z, lat, lon, h,
                                    1, None, self.datum,
-                                   name=name or self.name)
+                                   name=self._name__(name))
 
 
 class EcefFarrell22(_EcefBase):
@@ -399,7 +398,7 @@ class EcefFarrell22(_EcefBase):
        books?id=fW4foWASY6wC>}, page 30.
     '''
 
-    def reverse(self, xyz, y=None, z=None, M=None, **name_lon00):  # PYCHOK unused M
+    def reverse(self, xyz, y=None, z=None, M=None, **lon00_name):  # PYCHOK unused M
         '''Convert from geocentric C{(x, y, z)} to geodetic C{(lat, lon, height)} using
            I{Farrell}'s U{Table 2.2<https://Books.Google.com/books?id=fW4foWASY6wC>},
            page 30.
@@ -409,10 +408,9 @@ class EcefFarrell22(_EcefBase):
            @kwarg y: ECEF C{y} coordinate for C{scalar} B{C{xyz}} and B{C{z}} (C{meter}).
            @kwarg z: ECEF C{z} coordinate for C{scalar} B{C{xyz}} and B{C{y}} (C{meter}).
            @kwarg M: I{Ignored}, rotation matrix C{M} not available.
-           @kwarg name_lon00: Optional keyword arguments C{B{name}=NN} (C{str}) and
-                       I{"polar"} longitude C{B{lon00}=INT0} (C{degrees}), overriding
-                       the default and property C{lon00} setting and returned in case
-                       C{B{x}=0} and C{B{y}=0}.
+           @kwarg lon00_name: Optional C{B{name}=NN} (C{str}) and optional keyword argument
+                       C{B{lon00}=INT0} (C{degrees}), an arbitrary I{"polar"} longitude
+                       returned if C{B{x}=0} and C{B{y}=0}, see property C{lon00}.
 
            @return: An L{Ecef9Tuple}C{(x, y, z, lat, lon, height, C, M, datum)} with
                     geodetic coordinates C{(lat, lon, height)} for the given geocentric
@@ -425,7 +423,7 @@ class EcefFarrell22(_EcefBase):
 
            @see: L{EcefFarrell21} and L{EcefVeness}.
         '''
-        x, y, z, name = _xyzn4(xyz, y, z, self._Geocentrics, **name_lon00)
+        x, y, z, name = _xyzn4(xyz, y, z, self._Geocentrics, **lon00_name)
 
         E = self.ellipsoid
         a = E.a
@@ -433,7 +431,7 @@ class EcefFarrell22(_EcefBase):
 
         try:  # see EcefVeness.reverse
             p   = hypot(x, y)
-            lon = self._polon(y, x, p, **name_lon00)
+            lon = self._polon(y, x, p, **lon00_name)
 
             s, c = sincos2(atan2(z * a, p * b))  # == _norm3
             lat  = atan1d(z + s**3 * b * E.e22,
@@ -451,7 +449,7 @@ class EcefFarrell22(_EcefBase):
 
         return Ecef9Tuple(x, y, z, lat, lon, h,
                                    1, None, self.datum,
-                                   name=name or self.name)
+                                   name=self._name__(name))
 
 
 class EcefKarney(_EcefBase):
@@ -473,7 +471,7 @@ class EcefKarney(_EcefBase):
         '''
         return self.equatoradius / EPS_2  # self.equatoradius * _2_EPS, 12M lighyears
 
-    def reverse(self, xyz, y=None, z=None, M=False, **name_lon00):
+    def reverse(self, xyz, y=None, z=None, M=False, **lon00_name):
         '''Convert from geocentric C{(x, y, z)} to geodetic C{(lat, lon, height)}.
 
            @arg xyz: A geocentric (C{Cartesian}, L{Ecef9Tuple}) or C{scalar} ECEF C{x}
@@ -481,10 +479,9 @@ class EcefKarney(_EcefBase):
            @kwarg y: ECEF C{y} coordinate for C{scalar} B{C{xyz}} and B{C{z}} (C{meter}).
            @kwarg z: ECEF C{z} coordinate for C{scalar} B{C{xyz}} and B{C{y}} (C{meter}).
            @kwarg M: Optionally, return the rotation L{EcefMatrix} (C{bool}).
-           @kwarg name_lon00: Optional keyword arguments C{B{name}=NN} (C{str}) and
-                       I{"polar"} longitude C{B{lon00}=INT0} (C{degrees}), overriding
-                       the default and property C{lon00} setting and returned in case
-                       C{B{x}=0} and C{B{y}=0}.
+           @kwarg lon00_name: Optional C{B{name}=NN} (C{str}) and optional keyword argument
+                       C{B{lon00}=INT0} (C{degrees}), an arbitrary I{"polar"} longitude
+                       returned if C{B{x}=0} and C{B{y}=0}, see property C{lon00}.
 
            @return: An L{Ecef9Tuple}C{(x, y, z, lat, lon, height, C, M, datum)} with
                     geodetic coordinates C{(lat, lon, height)} for the given geocentric
@@ -508,7 +505,7 @@ class EcefKarney(_EcefBase):
             h = hypot(y, x)  # EPS0, EPS_2
             return (y / h, x / h, h) if h > 0 else (_0_0, _1_0, h)
 
-        x, y, z, name = _xyzn4(xyz, y, z, self._Geocentrics, **name_lon00)
+        x, y, z, name = _xyzn4(xyz, y, z, self._Geocentrics, **lon00_name)
 
         E = self.ellipsoid
         f = E.f
@@ -603,11 +600,10 @@ class EcefKarney(_EcefBase):
             C  = 4
 
         # lon00 <https://GitHub.com/mrJean1/PyGeodesy/issues/77>
-        lon = self._polon(sb, cb, R, **name_lon00)
+        lon = self._polon(sb, cb, R, **lon00_name)
         m   = self._Matrix(sa, ca, sb, cb) if M else None
         return Ecef9Tuple(x, y, z, atan1d(sa, ca), lon, h,
-                                   C, m, self.datum,
-                                   name=name or self.name)
+                                   C, m, self.datum, name=self._name__(name))
 
 
 class EcefSudano(_EcefBase):
@@ -616,7 +612,7 @@ class EcefSudano(_EcefBase):
     '''
     _tol = EPS2
 
-    def reverse(self, xyz, y=None, z=None, M=None, **name_lon00):  # PYCHOK unused M
+    def reverse(self, xyz, y=None, z=None, M=None, **lon00_name):  # PYCHOK unused M
         '''Convert from geocentric C{(x, y, z)} to geodetic C{(lat, lon, height)} using
            I{Sudano}'s U{iterative method<https://www.ResearchGate.net/publication/3709199>}.
 
@@ -625,10 +621,9 @@ class EcefSudano(_EcefBase):
            @kwarg y: ECEF C{y} coordinate for C{scalar} B{C{xyz}} and B{C{z}} (C{meter}).
            @kwarg z: ECEF C{z} coordinate for C{scalar} B{C{xyz}} and B{C{y}} (C{meter}).
            @kwarg M: I{Ignored}, rotation matrix C{M} not available.
-           @kwarg name_lon00: Optional keyword arguments C{B{name}=NN} (C{str}) and
-                       I{"polar"} longitude C{B{lon00}=INT0} (C{degrees}), overriding
-                       the default and property C{lon00} setting and returned in case
-                       C{B{x}=0} and C{B{y}=0}.
+           @kwarg lon00_name: Optional C{B{name}=NN} (C{str}) and optional keyword argument
+                       C{B{lon00}=INT0} (C{degrees}), an arbitrary I{"polar"} longitude
+                       returned if C{B{x}=0} and C{B{y}=0}, see property C{lon00}.
 
            @return: An L{Ecef9Tuple}C{(x, y, z, lat, lon, height, C, M, datum)} with geodetic
                     coordinates C{(lat, lon, height)} for the given geocentric ones C{(x, y, z)},
@@ -637,7 +632,7 @@ class EcefSudano(_EcefBase):
            @raise EcefError: Invalid B{C{xyz}} or C{scalar} C{x} or B{C{y}} and/or B{C{z}}
                              not C{scalar} for C{scalar} B{C{xyz}} or no convergence.
         '''
-        x, y, z, name = _xyzn4(xyz, y, z, self._Geocentrics, **name_lon00)
+        x, y, z, name = _xyzn4(xyz, y, z, self._Geocentrics, **lon00_name)
 
         E = self.ellipsoid
         e = E.e2 * E.a
@@ -679,14 +674,14 @@ class EcefSudano(_EcefBase):
 
         if lat is None:
             lat = copysign0(atan1d(_a(sa), ca), z)
-        lon = self._polon(y, x, R, **name_lon00)
+        lon = self._polon(y, x, R, **lon00_name)
 
         h = fsumf_(R * ca, _a(z * sa), -E.a * E.e2s(sa))  # use Veness'
         # because Sudano's Eq (7) doesn't produce the correct height
         # h = (fabs(z) + R - E.a * cos(a + E.e21) * sa / ca) / (ca + sa)
         return Ecef9Tuple(x, y, z, lat, lon, h,
                                    i, None, self.datum,  # C=i, M=None
-                                   iteration=i, name=name or self.name)
+                                   iteration=i, name=self._name__(name))
 
     @property_doc_(''' the convergence tolerance (C{float}).''')
     def tolerance(self):
@@ -713,7 +708,7 @@ class EcefVeness(_EcefBase):
              between 3D Cartesian and ellipsoidal latitude, longitude and height coordinates}.
     '''
 
-    def reverse(self, xyz, y=None, z=None, M=None, **name_lon00):  # PYCHOK unused M
+    def reverse(self, xyz, y=None, z=None, M=None, **lon00_name):  # PYCHOK unused M
         '''Conversion from geocentric C{(x, y, z)} to geodetic C{(lat, lon, height)}
            transcoded from I{Chris Veness}' U{JavaScript<https://www.Movable-Type.co.UK/
            scripts/geodesy/docs/latlon-ellipsoidal.js.html>}.
@@ -727,10 +722,9 @@ class EcefVeness(_EcefBase):
            @kwarg y: ECEF C{y} coordinate for C{scalar} B{C{xyz}} and B{C{z}} (C{meter}).
            @kwarg z: ECEF C{z} coordinate for C{scalar} B{C{xyz}} and B{C{y}} (C{meter}).
            @kwarg M: I{Ignored}, rotation matrix C{M} not available.
-           @kwarg name_lon00: Optional keyword arguments C{B{name}=NN} (C{str}) and
-                       I{"polar"} longitude C{B{lon00}=INT0} (C{degrees}), overriding
-                       the default and property C{lon00} setting and returned in case
-                       C{B{x}=0} and C{B{y}=0}.
+           @kwarg lon00_name: Optional C{B{name}=NN} (C{str}) and optional keyword argument
+                       C{B{lon00}=INT0} (C{degrees}), an arbitrary I{"polar"} longitude
+                       returned if C{B{x}=0} and C{B{y}=0}, see property C{lon00}.
 
            @return: An L{Ecef9Tuple}C{(x, y, z, lat, lon, height, C, M, datum)} with
                     geodetic coordinates C{(lat, lon, height)} for the given geocentric
@@ -748,7 +742,7 @@ class EcefVeness(_EcefBase):
                  system to latitude longitude and altitude}<https://www.ResearchGate.net/
                  publication/3709199>}.
         '''
-        x, y, z, name = _xyzn4(xyz, y, z, self._Geocentrics, **name_lon00)
+        x, y, z, name = _xyzn4(xyz, y, z, self._Geocentrics, **lon00_name)
 
         E = self.ellipsoid
         a = E.a
@@ -779,10 +773,10 @@ class EcefVeness(_EcefBase):
         else:  # polar lat, lon arbitrarily lon00
             C, lat, h = 3, (_N_90_0 if z < 0 else _90_0), (fabs(z) - E.b)
 
-        lon = self._polon(y, x, p, **name_lon00)
+        lon = self._polon(y, x, p, **lon00_name)
         return Ecef9Tuple(x, y, z, lat, lon, h,
                                    C, None, self.datum,  # M=None
-                                   name=name or self.name)
+                                   name=self._name__(name))
 
 
 class EcefYou(_EcefBase):
@@ -796,8 +790,8 @@ class EcefYou(_EcefBase):
              pages 1-18 and U{PyMap3D <https://PyPI.org/project/pymap3d>}.
     '''
 
-    def __init__(self, a_ellipsoid=_EWGS84, f=None, **name_lon00):  # PYCHOK signature
-        _EcefBase.__init__(self, a_ellipsoid, f=f, **name_lon00)  # inherited documentation
+    def __init__(self, a_ellipsoid=_EWGS84, f=None, **lon00_name):  # PYCHOK signature
+        _EcefBase.__init__(self, a_ellipsoid, f=f, **lon00_name)  # inherited documentation
         self._ee2 = EcefYou._ee2(self.ellipsoid)
 
     @staticmethod
@@ -807,7 +801,7 @@ class EcefYou(_EcefBase):
             raise EcefError(ellipsoid=E, txt=_prolate_)
         return sqrt0(e2), e2
 
-    def reverse(self, xyz, y=None, z=None, M=None, **name_lon00):  # PYCHOK unused M
+    def reverse(self, xyz, y=None, z=None, M=None, **lon00_name):  # PYCHOK unused M
         '''Convert geocentric C{(x, y, z)} to geodetic C{(lat, lon, height)}
            using I{Rey-Jer You}'s transformation.
 
@@ -816,10 +810,9 @@ class EcefYou(_EcefBase):
            @kwarg y: ECEF C{y} coordinate for C{scalar} B{C{xyz}} and B{C{z}} (C{meter}).
            @kwarg z: ECEF C{z} coordinate for C{scalar} B{C{xyz}} and B{C{y}} (C{meter}).
            @kwarg M: I{Ignored}, rotation matrix C{M} not available.
-           @kwarg name_lon00: Optional keyword arguments C{B{name}=NN} (C{str}) and
-                       I{"polar"} longitude C{B{lon00}=INT0} (C{degrees}), overriding
-                       the default and property C{lon00} setting and returned in case
-                       C{B{x}=0} and C{B{y}=0}.
+           @kwarg lon00_name: Optional C{B{name}=NN} (C{str}) and optional keyword argument
+                       C{B{lon00}=INT0} (C{degrees}), an arbitrary I{"polar"} longitude
+                       returned if C{B{x}=0} and C{B{y}=0}, see property C{lon00}.
 
            @return: An L{Ecef9Tuple}C{(x, y, z, lat, lon, height, C, M, datum)} with
                     geodetic coordinates C{(lat, lon, height)} for the given geocentric
@@ -830,7 +823,7 @@ class EcefYou(_EcefBase):
                              B{C{z}} not C{scalar} for C{scalar} B{C{xyz}} or the
                              ellipsoid is I{prolate}.
         '''
-        x, y, z, name = _xyzn4(xyz, y, z, self._Geocentrics, **name_lon00)
+        x, y, z, name = _xyzn4(xyz, y, z, self._Geocentrics, **lon00_name)
 
         E = self.ellipsoid
         e, e2 = self._ee2
@@ -855,14 +848,14 @@ class EcefYou(_EcefBase):
             sB, cB = _copysign_1_0(z), _0_0
 
         lat = atan1d(E.a * sB, E.b * cB)  # atan(E.a_b * tan(B))
-        lon = self._polon(y, x, q, **name_lon00)
+        lon = self._polon(y, x, q, **lon00_name)
 
         h = hypot(z - E.b * sB, q - E.a * cB)
         if hypot2_(x, y, z * E.a_b) < E.a2:
             h = neg(h)  # inside ellipsoid
         return Ecef9Tuple(x, y, z, lat, lon, h,
                                    1, None, self.datum,  # C=1, M=None
-                                   name=name or self.name)
+                                   name=self._name__(name))
 
 
 class EcefMatrix(_NamedTuple):
@@ -899,7 +892,7 @@ class EcefMatrix(_NamedTuple):
             t += _more  # ... from .multiply
 
         elif max(map(fabs, t)) > _1_0:
-            raise EcefError(unstr(EcefMatrix.__name__, *t))
+            raise EcefError(unstr(EcefMatrix, *t))
 
         else:  # build matrix from the following quaternion operations
             #   qrot(lam, [0,0,1]) * qrot(phi, [0,-1,0]) * [1,1,1,1]/2
@@ -1160,22 +1153,24 @@ class Ecef9Tuple(_NamedTuple):
             r = self.xyz
         else:
             _xsubclassof(self._CartesianBase, Cartesian=Cartesian)
-            r = Cartesian(self, **_xkwds(Cartesian_kwds, name=self.name))
+            r = Cartesian(self, **_name1__(Cartesian_kwds, _or_nameof=self))
         return r
 
-    def toDatum(self, datum2):
+    def toDatum(self, datum2, **name):
         '''Convert this C{Ecef9Tuple} to an other datum.
 
            @arg datum2: Datum to convert I{to} (L{Datum}).
+           @kwarg name: Optional C{B{name}=NN} (C{str}).
 
            @return: The converted 9-Tuple (C{Ecef9Tuple}).
 
            @raise TypeError: The B{C{datum2}} is not a L{Datum}.
         '''
+        n = _name__(name, _or_nameof=self)
         if self.datum in (None, datum2):  # PYCHOK _Names_
-            r = self.copy()
+            r = self.copy(name=n)
         else:
-            c = self._CartesianBase(self, datum=self.datum, name=self.name)  # PYCHOK _Names_
+            c = self._CartesianBase(self, datum=self.datum, name=n)  # PYCHOK _Names_
             # c.toLatLon converts datum, x, y, z, lat, lon, etc.
             # and returns another Ecef9Tuple iff LatLon is None
             r = c.toLatLon(datum=datum2, LatLon=None)
@@ -1197,8 +1192,9 @@ class Ecef9Tuple(_NamedTuple):
            @raise TypeError: Invalid B{C{LatLon}} or B{C{LatLon_kwds}}.
         '''
         lat, lon, D = self.lat, self.lon, self.datum  # PYCHOK Ecef9Tuple
-        kwds = _xkwds(LatLon_kwds, height=self.height, datum=D, name=self.name)  # PYCHOK Ecef9Tuple
-        d = kwds.get(_datum_, LatLon)
+        kwds = _name1__(LatLon_kwds, _or_nameof=self)
+        kwds = _xkwds(kwds, height=self.height, datum=D)  # PYCHOK Ecef9Tuple
+        d    =  kwds.get(_datum_, LatLon)
         if LatLon is None:
             r = LatLon3Tuple(lat, lon, kwds[_height_], name=kwds[_name_])
             if d is not None:
@@ -1242,7 +1238,7 @@ class Ecef9Tuple(_NamedTuple):
            @see: Propertes C{xyz} and C{xyzh}
         '''
         return self.xyz if Vector is None else Vector(
-              *self.xyz, **_xkwds(Vector_kwds, name=self.name))  # PYCHOK Ecef9Tuple
+              *self.xyz, **_name1__(Vector_kwds, _or_nameof=self))  # PYCHOK Ecef9Tuple
 
 #   def _T_x_M(self, T):
 #       '''(INTERNAL) Update M{self.M = T.multiply(self.M)}.
@@ -1281,7 +1277,6 @@ def _llhn4(latlonh, lon, height, suffix=NN, Error=EcefError, **name):  # in .ltp
         n = _name__(name, _or_nameof=latlonh)  # == latlonh._name__(name)
     except AttributeError:
         lat, h, n = latlonh, height, _name__(**name)
-
     try:
         return Lat(lat), Lon(lon), Height(h), n
     except (TypeError, ValueError) as x:
@@ -1313,11 +1308,11 @@ def _xyzn4(xyz, y, z, Types, Error=EcefError, lon00=0,  # PYCHOK unused
                 raise _TypesError(_xyz_y_z_names[0], xyz, *Types)
         except AttributeError:
             t = map1(float, xyz, y, z) + (n,)
-        return t
     except (TypeError, ValueError) as x:
         d = dict(zip(_xyz_y_z_names, (xyz, y, z)))
         raise Error(cause=x, **d)
-# assert _xyz_y_z == _MODS.basics._args_kwds_names(_xyzn4)[:3]
+    return t
+# assert _xyz_y_z == _args_kwds_names(_xyzn4)[:3]
 
 
 _Ecefs = (EcefKarney, EcefSudano, EcefVeness, EcefYou,

pygeodesy/ellipsoidalBase.py

@@ -24,9 +24,8 @@ from pygeodesy.errors import _incompatible, _IsnotError, RangeError, _TypeError,
 # from pygeodesy.fmath import favg  # _MODS
 from pygeodesy.interns import NN, _COMMA_, _ellipsoidal_
 from pygeodesy.latlonBase import LatLonBase, _trilaterate5,  fabs, _Wrap
-# from pygeodesy.lazily import _ALL_DOCS, _ALL_LAZY, _ALL_MODS as _MODS  # from .named
+from pygeodesy.lazily import _ALL_DOCS, _ALL_LAZY, _ALL_MODS as _MODS
 # from pygeodesy.lcc import toLcc  # _MODS
-from pygeodesy.named import _name1__,  _ALL_DOCS, _ALL_LAZY, _MODS
 # from pygeodesy.namedTuples import Vector3Tuple  # _MODS
 from pygeodesy.props import deprecated_method, deprecated_property_RO, \
                             Property_RO, property_doc_, property_RO, _update_all
@@ -37,7 +36,7 @@ from pygeodesy.units import Epoch, _isDegrees, Radius_, _1mm as _TOL_M
 # from math import fabs  # from .latlonBase
 
 __all__ = _ALL_LAZY.ellipsoidalBase
-__version__ = '24.05.21'
+__version__ = '24.06.06'
 
 
 class CartesianEllipsoidalBase(CartesianBase):
@@ -291,13 +290,6 @@ class LatLonEllipsoidalBase(LatLonBase):
         '''DEPRECATED, use method L{toRefFrame}.'''
         return self.toRefFrame(reframe2)
 
-    @Property_RO
-    def _css(self):
-        '''(INTERNAL) Get this C{LatLon} point as a Cassini-Soldner location (L{Css}).
-        '''
-        css = _MODS.css
-        return css.toCss(self, height=self.height, Css=css.Css, name=self.name)
-
     @property_doc_(''' this points's datum (L{Datum}).''')
     def datum(self):
         '''Get this point's datum (L{Datum}).
@@ -644,13 +636,6 @@ class LatLonEllipsoidalBase(LatLonBase):
         '''
         return self._iteration
 
-    @Property_RO
-    def _lcc(self):
-        '''(INTERNAL) Get this C{LatLon} point as a Lambert location (L{Lcc}).
-        '''
-        lcc = _MODS.lcc
-        return lcc.toLcc(self, height=self.height, Lcc=lcc.Lcc, name=self.name)
-
     def midpointTo(self, other, height=None, fraction=_0_5, wrap=False):
         '''Find the midpoint on a geodesic between this and an other point.
 
@@ -722,40 +707,24 @@ class LatLonEllipsoidalBase(LatLonBase):
                                          height=height, wrap=wrap, tol=tol)
         return t.closest
 
-    @Property_RO
-    def _osgr(self):
-        '''(INTERNAL) Get this C{LatLon} point as an OSGR coordinate (L{Osgr}),
-           based on the OS recommendation.
-        '''
-        return _MODS.osgr.toOsgr(self, kTM=False, name=self.name)  # datum=self.datum
-
-    @Property_RO
-    def _osgrTM(self):
-        '''(INTERNAL) Get this C{LatLon} point as an OSGR coordinate (L{Osgr})
-           based on I{Karney}'s Krüger implementation.
-        '''
-        return _MODS.osgr.toOsgr(self, kTM=True, name=self.name)  # datum=self.datum
-
     def parse(self, strllh, height=0, datum=None, epoch=None, reframe=None,
                                         sep=_COMMA_, wrap=False, **name):
         '''Parse a string consisting of C{"lat, lon[, height]"},
            representing a similar, ellipsoidal C{LatLon} point.
 
-           @arg strllh: Lat, lon and optional height (C{str}),
-                        see function L{pygeodesy.parse3llh}.
-           @kwarg height: Optional, default height (C{meter} or
-                          C{None}).
-           @kwarg datum: Optional datum (L{Datum}), overriding this
-                         datum I{without conversion}.
-           @kwarg epoch: Optional datum (L{Epoch}), overriding this
-                         epoch I{without conversion}.
-           @kwarg reframe: Optional datum (L{RefFrame}), overriding
-                           this reframe I{without conversion}.
+           @arg strllh: Lat, lon and optional height (C{str}), see function
+                        L{pygeodesy.parse3llh}.
+           @kwarg height: Optional, default height (C{meter} or C{None}).
+           @kwarg datum: Optional datum (L{Datum}), overriding this datum
+                         I{without conversion}.
+           @kwarg epoch: Optional datum (L{Epoch}), overriding this epoch
+                         I{without conversion}.
+           @kwarg reframe: Optional datum (L{RefFrame}), overriding this
+                           reframe I{without conversion}.
            @kwarg sep: Optional separator (C{str}).
-           @kwarg wrap: If C{True}, wrap or I{normalize} the lat-
-                        and longitude (C{bool}).
-           @kwarg name: Optional C{B{name}=NN} (C{str}), overriding
-                        this name.
+           @kwarg wrap: If C{True}, wrap or I{normalize} the lat- and
+                        longitude (C{bool}).
+           @kwarg name: Optional C{B{name}=NN} (C{str}), overriding this name.
 
            @return: The similar point (ellipsoidal C{LatLon}).
 
@@ -834,8 +803,7 @@ class LatLonEllipsoidalBase(LatLonBase):
 
            @see: Function L{pygeodesy.toCss}.
         '''
-        return self._css if not toCss_kwds else _MODS.css.toCss(
-               self, **_name1__(toCss_kwds, _or_nameof=self))
+        return _MODS.css.toCss(self, **self._name1__(toCss_kwds))
 
     def toDatum(self, datum2, height=None, **name):
         '''Convert this point to an other datum.
@@ -871,8 +839,7 @@ class LatLonEllipsoidalBase(LatLonBase):
 
            @see: Function L{pygeodesy.toEtm8}.
         '''
-        return self._etm if not toEtm8_kwds else _MODS.etm.toEtm8(
-               self, **_name1__(toEtm8_kwds, _or_nameof=self))
+        return _MODS.etm.toEtm8(self, **self._name1__(toEtm8_kwds)) if toEtm8_kwds else self._etm
 
     def toLcc(self, **toLcc_kwds):
         '''Convert this C{LatLon} point to a Lambert location.
@@ -883,8 +850,7 @@ class LatLonEllipsoidalBase(LatLonBase):
 
            @see: Function L{pygeodesy.toLcc}.
         '''
-        return self._lcc if not toLcc_kwds else _MODS.lcc.toLcc(
-               self, **_name1__(toLcc_kwds, _or_nameof=self))
+        return _MODS.lcc.toLcc(self, **self._name1__(toLcc_kwds))
 
     def toMgrs(self, center=False, pole=NN):
         '''Convert this C{LatLon} point to an MGRS coordinate.
@@ -913,11 +879,7 @@ class LatLonEllipsoidalBase(LatLonBase):
 
            @see: Function L{pygeodesy.toOsgr}.
         '''
-        if toOsgr_kwds:
-            r = _MODS.osgr.toOsgr(self, kTM=kTM, **_xkwds(toOsgr_kwds, name=self.name))
-        else:
-            r =  self._osgrTM if kTM else self._osgr
-        return r
+        return _MODS.osgr.toOsgr(self, kTM=kTM, **self._name1__(toOsgr_kwds))
 
     def toRefFrame(self, reframe2, reframe=None, epoch=None, epoch2=None, height=None, **name):
         '''Convert this point to an other reference frame and epoch.

pygeodesy/ellipsoidalGeodSolve.py

@@ -24,7 +24,7 @@ from pygeodesy.points import _areaError, ispolar  # PYCHOK exported
 # from math import fabs  # from .karney
 
 __all__ = _ALL_LAZY.ellipsoidalGeodSolve
-__version__ = '24.02.21'
+__version__ = '24.05.25'
 
 
 class Cartesian(CartesianEllipsoidalBase):
@@ -76,7 +76,7 @@ class LatLon(LatLonEllipsoidalBaseDI):
            @kwarg Cartesian_datum_kwds: Optional L{Cartesian}, B{C{datum}}
                   and other keyword arguments, ignored if C{B{Cartesian} is None}.
                   Use C{B{Cartesian}=...} to override this L{Cartesian} class
-                  or set C{B{Cartesian} is None}.
+                  or set C{B{Cartesian}=None}.
 
            @return: The cartesian (ECEF) coordinates (L{Cartesian}) or if
                     B{C{Cartesian}} is C{None}, an L{Ecef9Tuple}C{(x, y, z,

pygeodesy/ellipsoidalKarney.py

@@ -43,7 +43,7 @@ from pygeodesy.props import deprecated_method, Property_RO
 # from math import fabs  # from .karney
 
 __all__ = _ALL_LAZY.ellipsoidalKarney
-__version__ = '24.02.21'
+__version__ = '24.05.25'
 
 
 class Cartesian(CartesianEllipsoidalBase):
@@ -105,8 +105,8 @@ class LatLon(LatLonEllipsoidalBaseDI):
 
            @kwarg Cartesian_datum_kwds: Optional L{Cartesian}, B{C{datum}}
                   and other keyword arguments, ignored if C{B{Cartesian} is None}.
-                  Use C{B{Cartesian}=...} to override this L{Cartesian} class
-                  or set C{B{Cartesian} is None}.
+                  Use C{B{Cartesian}=...} to override this L{Cartesian} class or
+                  set C{B{Cartesian}=None}.
 
            @return: The cartesian (ECEF) coordinates (L{Cartesian}) or if
                     B{C{Cartesian}} is C{None}, an L{Ecef9Tuple}C{(x, y, z,

pygeodesy/ellipsoidalNvector.py

@@ -25,7 +25,7 @@ from __future__ import division as _; del _  # PYCHOK semicolon
 
 from pygeodesy.basics import issubclassof, map2, _xinstanceof
 from pygeodesy.datums import _earth_ellipsoid, _ellipsoidal_datum, _WGS84
-# from pygeodesy.dms import toDMS  # _MODS
+# from pygeodesy.dms import F_D, toDMS  # _MODS
 from pygeodesy.ellipsoidalBase import CartesianEllipsoidalBase, \
                                      _nearestOn, LatLonEllipsoidalBase, \
                                      _TOL_M,  _Wrap
@@ -37,8 +37,8 @@ from pygeodesy.lazily import _ALL_LAZY, _ALL_MODS as _MODS, _ALL_OTHER
 from pygeodesy.ltpTuples import Aer as _Aer, Ned as _Ned, Ned4Tuple, \
                                 sincos2d_, _xnamed
 # from pygeodesy.named import _xnamed  # from .ltpTuples
-from pygeodesy.nvectorBase import fabs, fdot, NorthPole, LatLonNvectorBase, \
-                                  NvectorBase, sumOf as _sumOf
+from pygeodesy.nvectorBase import LatLonNvectorBase, NorthPole, NvectorBase, \
+                                  sumOf as _sumOf,  fabs, fdot
 from pygeodesy.props import deprecated_class, deprecated_function, \
                             deprecated_method, Property_RO, property_RO
 from pygeodesy.streprs import Fmt, fstr, _xzipairs
@@ -48,7 +48,7 @@ from pygeodesy.units import Bearing, Distance, Height, Scalar
 # from math import fabs  # from .nvectorBase
 
 __all__ = _ALL_LAZY.ellipsoidalNvector
-__version__ = '24.05.19'
+__version__ = '24.06.08'
 
 
 class Ned(_Ned):
@@ -70,10 +70,10 @@ class Ned(_Ned):
                     with length or slantrange C{L}, bearing or azimuth C{B}
                     and elevation C{E}.
         '''
-        dms = _MODS.dms
+        m = _MODS.dms
         t = (fstr(self.slantrange, prec=prec),
-             dms.toDMS(self.azimuth,   form=dms.F_D, prec=prec, ddd=0),
-             dms.toDMS(self.elevation, form=dms.F_D, prec=prec, ddd=0))
+             m.toDMS(self.azimuth,   form=m.F_D, prec=prec, ddd=0),
+             m.toDMS(self.elevation, form=m.F_D, prec=prec, ddd=0))
         return _xzipairs('LBE', t, sep=sep, fmt=fmt)