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

pygeodesy/ecef.py

@@ -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.31'
+__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
 
@@ -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:
@@ -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,
@@ -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,7 +600,7 @@ 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=self._name__(name))
@@ -615,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>}.
 
@@ -624,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)},
@@ -636,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
@@ -678,7 +674,7 @@ 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
@@ -712,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>}.
@@ -726,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
@@ -747,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
@@ -778,7 +773,7 @@ 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=self._name__(name))
@@ -795,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
@@ -806,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.
 
@@ -815,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
@@ -829,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
@@ -854,7 +848,7 @@ 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:
@@ -898,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

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.31'
+__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,20 +707,6 @@ 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]"},
@@ -832,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.
@@ -869,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.
@@ -881,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.
@@ -911,12 +879,7 @@ class LatLonEllipsoidalBase(LatLonBase):
 
            @see: Function L{pygeodesy.toOsgr}.
         '''
-        if toOsgr_kwds:
-            kwds = _name1__(toOsgr_kwds, _or_nameof=self)
-            r = _MODS.osgr.toOsgr(self, kTM=kTM, **kwds)
-        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/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)
 
 

pygeodesy/errors.py

@@ -26,7 +26,7 @@ from pygeodesy.lazily import _ALL_LAZY, _ALL_MODS as _MODS, _getenv, _PYTHON_X_D
 from copy import copy as _copy
 
 __all__ = _ALL_LAZY.errors  # _ALL_DOCS('_InvalidError', '_IsnotError')  _under
-__version__ = '24.05.29'
+__version__ = '24.06.08'
 
 _argument_   = 'argument'
 _box_        = 'box'
@@ -43,7 +43,7 @@ try:
 
     if _PYTHON_X_DEV or _getenv('PYGEODESY_EXCEPTION_CHAINING', NN):  # == _std_
         _exception_chaining = True  # turned on, std
-        raise AttributeError  # allow exception chaining
+        raise AttributeError()  # allow exception chaining
 
     _exception_chaining = False  # turned off
 

pygeodesy/frechet.py

@@ -103,7 +103,7 @@ from collections import defaultdict as _defaultdict
 # from math import radians  # from .points
 
 __all__ = _ALL_LAZY.frechet
-__version__ = '24.05.26'
+__version__ = '24.06.10'
 
 
 def _fraction(fraction, n):
@@ -842,12 +842,11 @@ class Frechet6Tuple(_NamedTuple):
     _Names_ = ('fd',  'fi1', 'fi2', 'r',     _n_,      _units_)
     _Units_ = (_Pass,  FIx,   FIx,   Number_, Number_, _Pass)
 
-    def toUnits(self, **Error):  # PYCHOK expected
+    def toUnits(self, **Error_name):  # PYCHOK expected
         '''Overloaded C{_NamedTuple.toUnits} for C{fd} units.
         '''
         U = _xUnit(self.units, Float)  # PYCHOK expected
-        self._Units_ = (U,) + Frechet6Tuple._Units_[1:]
-        return _NamedTuple.toUnits(self, **Error)
+        return _NamedTuple.toUnits(self.reUnit(U), **Error_name)  # PYCHOK self
 
 #   def __gt__(self, other):
 #       _xinstanceof(Frechet6Tuple, other=other)

pygeodesy/fsums.py

@@ -47,7 +47,7 @@ from pygeodesy.streprs import Fmt, fstr, unstr
 from math import ceil as _ceil, fabs, floor as _floor  # PYCHOK used! .ltp
 
 __all__ = _ALL_LAZY.fsums
-__version__ = '24.05.29'
+__version__ = '24.06.09'
 
 _add_op_      = _PLUS_  # in .auxilats.auxAngle
 _eq_op_       = _EQUAL_ * 2  # _DEQUAL_
@@ -2178,7 +2178,7 @@ try:
     # float.__getformat__('float')[:4] == 'IEEE'?)
     if _fsum((1, 1e101, 1, -1e101)) != 2:  # PYCHOK no cover
         del _fsum  # nope, remove _fsum ...
-        raise ImportError  # ... use _fsum below
+        raise ImportError()  # ... use _fsum below
 
     Fsum._math_fsum = _sum = _fsum  # PYCHOK exported
 except ImportError:

pygeodesy/geodsolve.py

@@ -26,7 +26,7 @@ from pygeodesy.solveBase import _SolveBase, _SolveLineBase
 from pygeodesy.utily import _unrollon, _Wrap, wrap360
 
 __all__ = _ALL_LAZY.geodsolve
-__version__ = '24.05.31'
+__version__ = '24.06.04'
 
 
 class GeodSolve12Tuple(_GTuple):
@@ -59,11 +59,11 @@ class _GeodesicSolveBase(_SolveBase):
     def _cmdBasic(self):
         '''(INTERNAL) Get the basic C{GeodSolve} cmd (C{tuple}).
         '''
-        return (self.GeodSolve,) + self._b_option \
-                                 + self._e_option \
-                                 + self._E_option \
-                                 + self._p_option \
-                                 + self._u_option + ('-f',)
+        return (self.GeodSolve, '-f') + (self._b_option +
+                                         self._e_option +
+                                         self._E_option +
+                                         self._p_option +
+                                         self._u_option)
 
     @Property_RO
     def _E_option(self):
@@ -362,49 +362,47 @@ if __name__ == '__main__':
     p = glS.ArcPosition(49.475527)
     printf('ArcPosition: %s %r', p == r, p)
 
-# % python3 -m pygeodesy.geodsolve
 
-# version: /opt/local/bin/GeodSolve: GeographicLib version 1.51
+# % python3 -m pygeodesy.geodsolve
 
-# version: /opt/local/bin/GeodSolve: GeographicLib version 1.51
+# version: /opt/local/bin/GeodSolve: GeographicLib version 2.2
 
-# Direct: GDict(M12=0.650911, M21=0.651229, S12=39735075134877.09375, a12=49.475527, azi1=51.0, azi2=107.189397, lat1=40.6, lat2=51.884565, lon1=-73.8, lon2=-1.141173, m12=4844148.703101, s12=5500000.0)
+# Direct: GDict(a12=49.475527, azi1=51.0, azi2=107.189397, lat1=40.6, lat2=51.884565, lon1=-73.8, lon2=-1.141173, m12=4844148.703101, M12=0.650911, M21=0.651229, s12=5500000.0, S12=39735075134877.09375)
 # Direct3: Destination3Tuple(lat=51.884565, lon=-1.141173, final=107.189397)
 
-# Inverse: GDict(M12=0.64473, M21=0.645046, S12=40041368848742.53125, a12=49.94131, azi1=51.198883, azi2=107.821777, lat1=40.6, lat2=51.6, lon1=-73.8, lon2=-0.5, m12=4877684.602706, s12=5551759.400319)
+# Inverse: GDict(a12=49.94131, azi1=51.198883, azi2=107.821777, lat1=40.6, lat2=51.6, lon1=-73.8, lon2=-0.5, m12=4877684.602706, M12=0.64473, M21=0.645046, s12=5551759.400319, S12=40041368848742.53125)
 # Inverse1: 49.94131021789904
 # Inverse3: Distance3Tuple(distance=5551759.400319, initial=51.198883, final=107.821777)
 
-# Position:    True  GDict(M12=0.650911, M21=0.651229, S12=39735075134877.09375, a12=49.475527, azi1=51.0, azi2=107.189397, lat1=40.6, lat2=51.884565, lon1=-73.8, lon2=-1.141173, m12=4844148.703101, s12=5500000.0)
-# ArcPosition: False GDict(M12=0.650911, M21=0.651229, S12=39735074737272.734375, a12=49.475527, azi1=51.0, azi2=107.189397, lat1=40.6, lat2=51.884565, lon1=-73.8, lon2=-1.141174, m12=4844148.669561, s12=5499999.948497)
+# Position:    True  GDict(a12=49.475527, azi1=51.0, azi2=107.189397, lat1=40.6, lat2=51.884565, lon1=-73.8, lon2=-1.141173, m12=4844148.703101, M12=0.650911, M21=0.651229, s12=5500000.0, S12=39735075134877.09375)
+# ArcPosition: False GDict(a12=49.475527, azi1=51.0, azi2=107.189397, lat1=40.6, lat2=51.884565, lon1=-73.8, lon2=-1.141174, m12=4844148.669561, M12=0.650911, M21=0.651229, s12=5499999.948497, S12=39735074737272.734375)
 
 
 # % python3 -m pygeodesy.geodsolve --verbose
 
 # GeodesicSolve 'Test' 1: /opt/local/bin/GeodSolve --version (invoke)
-# GeodesicSolve 'Test' 1: /opt/local/bin/GeodSolve: GeographicLib version 1.51 (0)
-# version: /opt/local/bin/GeodSolve: GeographicLib version 1.51
-# GeodesicSolve 'Test' 2: /opt/local/bin/GeodSolve -E -p 10 -f \ 40.600000000000001 -73.799999999999997 51.0 5500000.0 (Direct)
+# GeodesicSolve 'Test' 1: /opt/local/bin/GeodSolve: GeographicLib version 2.2 (0)
+# version: /opt/local/bin/GeodSolve: GeographicLib version 2.2
+# GeodesicSolve 'Test' 2: /opt/local/bin/GeodSolve -f -E -p 10 \ 40.600000000000001 -73.799999999999997 51.0 5500000.0 (Direct)
 # GeodesicSolve 'Test' 2: lat1=40.600000000000001, lon1=-73.799999999999997, azi1=51.0, lat2=51.884564505606761, lon2=-1.141172861200829, azi2=107.189397162605886, s12=5500000.0, a12=49.475527463251467, m12=4844148.703101486, M12=0.65091056699808603, M21=0.65122865892196558, S12=39735075134877.094 (0)
 
-# Direct: GDict(M12=0.650911, M21=0.651229, S12=39735075134877.09375, a12=49.475527, azi1=51.0, azi2=107.189397, lat1=40.6, lat2=51.884565, lon1=-73.8, lon2=-1.141173, m12=4844148.703101, s12=5500000.0)
-# GeodesicSolve 'Test' 3: /opt/local/bin/GeodSolve -E -p 10 -f \ 40.600000000000001 -73.799999999999997 51.0 5500000.0 (Direct3)
+# Direct: GDict(a12=49.475527, azi1=51.0, azi2=107.189397, lat1=40.6, lat2=51.884565, lon1=-73.8, lon2=-1.141173, m12=4844148.703101, M12=0.650911, M21=0.651229, s12=5500000.0, S12=39735075134877.09375)
+# GeodesicSolve 'Test' 3: /opt/local/bin/GeodSolve -f -E -p 10 \ 40.600000000000001 -73.799999999999997 51.0 5500000.0 (Direct3)
 # GeodesicSolve 'Test' 3: lat1=40.600000000000001, lon1=-73.799999999999997, azi1=51.0, lat2=51.884564505606761, lon2=-1.141172861200829, azi2=107.189397162605886, s12=5500000.0, a12=49.475527463251467, m12=4844148.703101486, M12=0.65091056699808603, M21=0.65122865892196558, S12=39735075134877.094 (0)
 # Direct3: Destination3Tuple(lat=51.884565, lon=-1.141173, final=107.189397)
-# GeodesicSolve 'Test' 4: /opt/local/bin/GeodSolve -E -p 10 -f -i \ 40.600000000000001 -73.799999999999997 51.600000000000001 -0.5 (Inverse)
+# GeodesicSolve 'Test' 4: /opt/local/bin/GeodSolve -f -E -p 10 -i \ 40.600000000000001 -73.799999999999997 51.600000000000001 -0.5 (Inverse)
 # GeodesicSolve 'Test' 4: lat1=40.600000000000001, lon1=-73.799999999999997, azi1=51.198882845579824, lat2=51.600000000000001, lon2=-0.5, azi2=107.821776735514248, s12=5551759.4003186841, a12=49.941310217899037, m12=4877684.6027061976, M12=0.64472969205948238, M21=0.64504567852134398, S12=40041368848742.531 (0)
 
-# Inverse: GDict(M12=0.64473, M21=0.645046, S12=40041368848742.53125, a12=49.94131, azi1=51.198883, azi2=107.821777, lat1=40.6, lat2=51.6, lon1=-73.8, lon2=-0.5, m12=4877684.602706, s12=5551759.400319)
-# GeodesicSolve 'Test' 5: /opt/local/bin/GeodSolve -E -p 10 -f -i \ 40.600000000000001 -73.799999999999997 51.600000000000001 -0.5 (Inverse1)
+# Inverse: GDict(a12=49.94131, azi1=51.198883, azi2=107.821777, lat1=40.6, lat2=51.6, lon1=-73.8, lon2=-0.5, m12=4877684.602706, M12=0.64473, M21=0.645046, s12=5551759.400319, S12=40041368848742.53125)
+# GeodesicSolve 'Test' 5: /opt/local/bin/GeodSolve -f -E -p 10 -i \ 40.600000000000001 -73.799999999999997 51.600000000000001 -0.5 (Inverse1)
 # GeodesicSolve 'Test' 5: lat1=40.600000000000001, lon1=-73.799999999999997, azi1=51.198882845579824, lat2=51.600000000000001, lon2=-0.5, azi2=107.821776735514248, s12=5551759.4003186841, a12=49.941310217899037, m12=4877684.6027061976, M12=0.64472969205948238, M21=0.64504567852134398, S12=40041368848742.531 (0)
 # Inverse1: 49.94131021789904
-# GeodesicSolve 'Test' 6: /opt/local/bin/GeodSolve -E -p 10 -f -i \ 40.600000000000001 -73.799999999999997 51.600000000000001 -0.5 (Inverse3)
+# GeodesicSolve 'Test' 6: /opt/local/bin/GeodSolve -f -E -p 10 -i \ 40.600000000000001 -73.799999999999997 51.600000000000001 -0.5 (Inverse3)
 # GeodesicSolve 'Test' 6: lat1=40.600000000000001, lon1=-73.799999999999997, azi1=51.198882845579824, lat2=51.600000000000001, lon2=-0.5, azi2=107.821776735514248, s12=5551759.4003186841, a12=49.941310217899037, m12=4877684.6027061976, M12=0.64472969205948238, M21=0.64504567852134398, S12=40041368848742.531 (0)
 # Inverse3: Distance3Tuple(distance=5551759.400319, initial=51.198883, final=107.821777)
 
-# Position:    True  GDict(M12=0.650911, M21=0.651229, S12=39735075134877.09375, a12=49.475527, azi1=51.0, azi2=107.189397, lat1=40.6, lat2=51.884565, lon1=-73.8, lon2=-1.141173, m12=4844148.703101, s12=5500000.0)
-# ArcPosition: False GDict(M12=0.650911, M21=0.651229, S12=39735074737272.734375, a12=49.475527, azi1=51.0, azi2=107.189397, lat1=40.6, lat2=51.884565, lon1=-73.8, lon2=-1.141174, m12=4844148.669561, s12=5499999.948497)
-
+# Position:    True  GDict(a12=49.475527, azi1=51.0, azi2=107.189397, lat1=40.6, lat2=51.884565, lon1=-73.8, lon2=-1.141173, m12=4844148.703101, M12=0.650911, M21=0.651229, s12=5500000.0, S12=39735075134877.09375)
+# ArcPosition: False GDict(a12=49.475527, azi1=51.0, azi2=107.189397, lat1=40.6, lat2=51.884565, lon1=-73.8, lon2=-1.141174, m12=4844148.669561, M12=0.650911, M21=0.651229, s12=5499999.948497, S12=39735074737272.734375)
 
 # **) MIT License
 #