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

pygeodesy/datums.py

@@ -94,7 +94,7 @@ from pygeodesy.units import _isRadius, Radius_,  radians
 # import operator as _operator  # from .fmath
 
 __all__ = _ALL_LAZY.datums
-__version__ = '24.05.21'
+__version__ = '24.06.24'
 
 _a_ellipsoid_ = _UNDER_(_a_, _ellipsoid_)
 _BD72_        = 'BD72'
@@ -248,18 +248,18 @@ class Transform(_NamedEnumItem):
         self.s  = s = (s1 - _1_0) / _S1_S
         return s
 
-    def toStr(self, prec=5, fmt=Fmt.g, **name):  # PYCHOK expected
+    def toStr(self, prec=5, fmt=Fmt.g, **sep_name):  # PYCHOK expected
         '''Return this transform as a string.
 
            @kwarg prec: Number of (decimal) digits, unstripped (C{int}).
            @kwarg fmt: Optional C{float} format (C{letter}).
-           @kwarg name: Optional, override C{B{name}=NN} (C{str}) or
-                        C{None} to exclude this transform's name.
+           @kwarg sep_name: Optional C{B{name}=NN} (C{str}) or C{None}
+                      to exclude this transform's name and separater
+                      C{B{sep}=", "} to join the items (C{str}).
 
            @return: Transform attributes (C{str}).
         '''
-        name, _ = _name2__(**name)  # name=None
-        return self._instr(name, prec, *_Names11, fmt=fmt)
+        return self._instr(*_Names11, fmt=fmt, prec=prec, **sep_name)
 
     def transform(self, x, y, z, inverse=False, **Vector_and_kwds):
         '''Transform a (cartesian) position, forward or inverse.

pygeodesy/deprecated/__init__.py

@@ -27,7 +27,7 @@ __all__ = (_ALL_DEPRECATED.deprecated_bases +
            _ALL_DEPRECATED.deprecated_classes +
            _ALL_DEPRECATED.deprecated_consterns +
            _ALL_DEPRECATED.deprecated_functions)
-__version__ = '24.04.17'
+__version__ = '24.06.15'
 
 if _unLazy0:
     from pygeodesy.deprecated import bases, datum, nvector, rhumbBase, \

pygeodesy/deprecated/classes.py

@@ -19,10 +19,10 @@ from pygeodesy.namedTuples import Forward4Tuple as _Forward4Tuple, \
 from pygeodesy.props import deprecated_class, deprecated_method
 from pygeodesy.resections import TriAngle5Tuple as _TriAngle5Tuple
 from pygeodesy.trf import TRFXform7Tuple as _TRFXform7Tuple
-from pygeodesy.units import Bearing, Int, Lat, Lon, Meter
+from pygeodesy.units import Bearing, Int, Lamd, Lat, Lon, Meter, Phid
 
 __all__ = _ALL_DEPRECATED.deprecated_classes
-__version__ = '24.04.17'
+__version__ = '24.06.15'
 
 
 class _Deprecated_NamedTuple(_NamedTuple):
@@ -151,6 +151,13 @@ def HeightIDW3(knots, **kwds):  # PYCHOK no cover
     return HeightIDW3(knots, **kwds)
 
 
+class Lam_(Lamd):
+    '''DEPRECATED on 2024.06.15, use class L{Lamd}.'''
+    def __init__(self, *args, **kwds):  # PYCHOK signature
+        deprecated_class(self.__class__)
+        Lamd.__init__(self, *args, **kwds)
+
+
 class LatLonExact4Tuple(_Deprecated_NamedTuple):
     '''DEPRECATED, use class L{Reverse4Tuple}, item C{gamma} for C{convergence}.'''
     _Names_ = _reNames(_Reverse4Tuple._Names_, _gamma_, _convergence_)
@@ -163,6 +170,13 @@ class NearestOn4Tuple(_Deprecated_NamedTuple):  # PYCHOK no cover
     _Units_ = ( Lat,   Lon,   Meter,      Bearing)
 
 
+class Phi_(Phid):
+    '''DEPRECATED on 2024.06.15, use class L{Phid}.'''
+    def __init__(self, *args, **kwds):  # PYCHOK signature
+        deprecated_class(self.__class__)
+        Phid.__init__(self, *args, **kwds)
+
+
 class Ned3Tuple(_Deprecated_NamedTuple):  # was in .ellipsoidalNvector
     '''DEPRECATED, use class L{Ned4Tuple}, ignoring item C{ltp}.'''
     assert _Ned4Tuple._Names_.index(_ltp_) == 3

pygeodesy/deprecated/datum.py

@@ -5,17 +5,17 @@ u'''DEPRECATED on 2022.09.12, use module L{pygeodesy.datums} or L{pygeodesy.elli
 '''
 
 # XXX only the items previously public
-from pygeodesy.constants import R_M, R_MA, R_MB, R_KM, R_NM, R_SM, R_FM, R_VM
+from pygeodesy.constants import R_FM, R_KM, R_M, R_MA, R_MB, R_NM, R_SM, R_VM
 from pygeodesy.datums import Datum, Datums, Transform, Transforms
 from pygeodesy.ellipsoids import Ellipsoid, Ellipsoids, Curvature2Tuple
 from pygeodesy.lazily import _ALL_DEPRECATED, _ALL_OTHER
 
 __all__ = _ALL_DEPRECATED.deprecated_datum
-__version__ = '23.11.26'
+__version__ = '24.06.15'
 
 assert _ALL_OTHER(Curvature2Tuple, Datum,  Ellipsoid,  Transform) + \
             tuple(_.name for _ in (Datums, Ellipsoids, Transforms,
-                    R_M, R_MA, R_MB, R_KM, R_NM, R_SM, R_FM, R_VM)) == __all__
+                    R_FM, R_KM, R_M, R_MA, R_MB, R_NM, R_SM, R_VM)) == __all__
 
 # **) MIT License
 #

pygeodesy/deprecated/functions.py

@@ -14,7 +14,7 @@ from pygeodesy.props import deprecated_function
 from pygeodesy.units import Number_, Scalar_
 
 __all__ = _ALL_DEPRECATED.deprecated_functions
-__version__ = '24.05.25'
+__version__ = '24.06.11'
 
 _WGS84 = _UTM = object()
 
@@ -41,9 +41,8 @@ def atand(x):
 def bounds(points, wrap=True, LatLon=None):  # PYCHOK no cover
     '''DEPRECATED, use function L{pygeodesy.boundsOf}.
 
-       @return: 2-Tuple C{(latlonSW, latlonNE)} as B{C{LatLon}}
-                or 4-Tuple C{(latS, lonW, latN, lonE)} if
-                B{C{LatLon}} is C{None}.
+       @return: 2-Tuple C{(latlonSW, latlonNE)}, each a B{C{LatLon}} or
+                4-Tuple C{(latS, lonW, latN, lonE)} if C{B{LatLon} is None}.
     '''
     return tuple(_MODS.points.boundsOf(points, wrap=wrap, LatLon=LatLon))
 
@@ -253,7 +252,7 @@ def parseUTM(strUTM, datum=_WGS84, Utm=_UTM, name=NN):  # PYCHOK no cover
     '''DEPRECATED, use function L{parseUTM5}.
 
        @return: The UTM coordinate (B{L{Utm}}) or 4-tuple C{(zone,
-                hemisphere, easting, northing)} if B{C{Utm}} is C{None}.
+                hemisphere, easting, northing)} if C{B{Utm} is None}.
     '''
     d = _MODS.datums.Datums.WGS84 if datum is _WGS84 else datum  # PYCHOK shadows?
     U = _MODS.utm.Utm if Utm is _UTM else Utm
@@ -305,9 +304,8 @@ def tienstra(pointA, pointB, pointC, alpha, **beta_gamma_useZ_Clas_and_kwds):
 def toUtm(latlon, lon=None, datum=None, Utm=_UTM, cmoff=True, name=NN):  # PYCHOK no cover
     '''DEPRECATED, use function L{pygeodesy.toUtm8}.
 
-       @return: The UTM coordinate (B{C{Utm}}) or a 6-tuple C{(zone,
-                easting, northing, band, convergence, scale)} if
-                B{C{Utm}} is C{None} or B{C{cmoff}} is C{False}.
+       @return: The UTM coordinate (B{C{Utm}}) or a 6-tuple C{(zone, easting, northing,
+                band, convergence, scale)} if C{B{Utm} is None} or C{B{cmoff} is False}.
     '''
     U = _MODS.utm.Utm if Utm is _UTM else Utm
     r = _MODS.utm.toUtm8(latlon, lon=lon, datum=datum, Utm=U, name=name, falsed=cmoff)

pygeodesy/dms.py

@@ -85,7 +85,7 @@ except ImportError:  # Python 3+
     from string import ascii_letters as _LETTERS
 
 __all__ = _ALL_LAZY.dms
-__version__ = '24.05.18'
+__version__ = '24.06.11'
 
 _beyond_      = 'beyond'
 _DDDMMSS_     = 'DDDMMSS'
@@ -293,8 +293,8 @@ def clipDegrees(deg, limit):
 
        @return: Clipped value (C{degrees}).
 
-       @raise RangeError: If B{C{deg}} outside the valid C{-/+B{limit}}
-                          range and L{pygeodesy.rangerrors} set to C{True}.
+       @raise RangeError: If B{C{deg}} outside the valid C{-/+B{limit}} range
+                          and L{rangerrors<pygeodesy.rangerrors>} is C{True}.
     '''
     return _clip(deg, limit, _degrees_) if limit and limit > 0 else deg
 
@@ -307,8 +307,8 @@ def clipRadians(rad, limit):
 
        @return: Clipped value (C{radians}).
 
-       @raise RangeError: If B{C{rad}} outside the valid C{-/+B{limit}}
-                          range and  L{pygeodesy.rangerrors} set to C{True}.
+       @raise RangeError: If B{C{rad}} outside the valid C{-/+B{limit}} range
+                          and L{rangerrors<pygeodesy.rangerrors>} is C{True}.
     '''
     return _clip(rad, limit, _radians_) if limit and limit > 0 else rad
 
@@ -456,17 +456,14 @@ def latlonDMS(lls, **m_form_prec_sep_s_D_M_S):
                 C{LatLon.toStr} and functions L{pygeodesy.latDMS} and
                 L{pygeodesy.lonDMS} for more details.
 
-       @return: A C{tuple} of C{str}s if B{C{lls}} is a list, sequence,
-                tuple, etc. of C{LatLon} instances or a single C{str}
-                if B{C{lls}} is a single C{LatLon}.
+       @return: A C{tuple} of C{str}s if B{C{lls}} is a list, sequence, tuple, etc.
+                of C{LatLon}s or a single C{str} if B{C{lls}} is a single C{LatLon}.
 
-       @see: Functions L{pygeodesy.latlonDMS_}, L{pygeodesy.latDMS},
-             L{pygeodesy.lonDMS} and L{pygeodesy.toDMS} and method
-             C{LatLon.toStr}.
+       @see: Functions L{pygeodesy.latlonDMS_}, L{pygeodesy.latDMS}, L{pygeodesy.lonDMS}
+             and L{pygeodesy.toDMS} and method C{LatLon.toStr}.
 
-       @note: Keyword argument C{B{sep}=None} to join a C{str}ing
-              from the returned C{tuple} has been I{DEPRECATED},
-              use C{B{sep}.join(B{latlonDMS_}(...))} instead.
+       @note: Keyword argument C{B{sep}=None} to join a C{str}ing from the returned C{tuple}
+              has been I{DEPRECATED}, use C{B{sep}.join(B{latlonDMS_}(...))} instead.
     '''
     sep, kwds = _latlonDMS_sep2(latlonDMS, **m_form_prec_sep_s_D_M_S)
     if isLatLon(lls):
@@ -610,7 +607,7 @@ def parseDDDMMSS(strDDDMMSS, suffix=_NSEW_, sep=S_SEP, clip=0, sexagecimal=False
                           B{C{suffix}} compass point.
 
        @raise RangeError: Value of B{C{strDDDMMSS}} outside the valid C{-/+B{clip}}
-                          range and L{pygeodesy.rangerrors} set to C{True}.
+                          range and L{rangerrors<pygeodesy.rangerrors>} is C{True}.
 
        @note: Type C{str} values "[D]DD", "[D]DDMM", "[D]DDMMSS" and "[D]DD.MMSS"
               for B{C{strDDDMMSS}} are parsed properly only if I{either} unsigned
@@ -746,14 +743,13 @@ def parseDMS(strDMS, suffix=_NSEW_, sep=S_SEP, clip=0, **s_D_M_S):  # MCCABE 14
 
        @raise ParseError: Invalid B{C{strDMS}} or B{C{clip}}.
 
-       @raise RangeError: Value of B{C{strDMS}} outside the valid C{-/+B{clip}}
-                          range and L{pygeodesy.rangerrors} set to C{True}.
+       @raise RangeError: Value of B{C{strDMS}} outside the valid C{-/+B{clip}} range
+                          and L{rangerrors<pygeodesy.rangerrors>} is C{True}.
 
-       @note: Unlike function L{parseDDDMMSS}, type C{float}, C{int} and other
-              non-C{str} B{C{strDMS}} values are considered decimal (and not
-              sexagecimal) degrees.  For example, C{int(1230)} is returned
-              as 1230.0 I{and not as 12.5} degrees and C{float(345)} as 345.0
-              I{and not as 3.75} degrees!
+       @note: Unlike function L{parseDDDMMSS}, type C{float}, C{int} and other non-C{str}
+              B{C{strDMS}} values are considered decimal (and not sexagecimal) degrees.
+              For example, C{int(1230)} is returned as 1230.0 I{and not as 12.5} degrees
+              and C{float(345)} as 345.0 I{and not as 3.75} degrees!
 
        @see: Functions L{pygeodesy.parseDDDMMSS}, L{pygeodesy.parseDMS2},
              L{pygeodesy.parse3llh} and L{pygeodesy.toDMS}.
@@ -780,7 +776,7 @@ def parseDMS2(strLat, strLon, sep=S_SEP, clipLat=90, clipLon=180, wrap=False, **
 
        @raise RangeError: Value of B{C{strLat}} or B{C{strLon}} outside the
                           valid C{-/+B{clipLat}} or C{-/+B{clipLon}} range
-                          and L{pygeodesy.rangerrors} set to C{True}.
+                          and L{rangerrors<pygeodesy.rangerrors>} is C{True}.
 
        @note: See the B{Notes} at function L{parseDMS}.
 
@@ -829,9 +825,9 @@ def parse3llh(strllh, height=0, sep=_COMMA_, clipLat=90, clipLon=180, wrap=False
        @return: A L{LatLon3Tuple}C{(lat, lon, height)} in C{degrees},
                 C{degrees} and C{float}.
 
-       @raise RangeError: Lat- or longitude value of B{C{strllh}} outside
-                          the valid C{-/+B{clipLat}} or C{-/+B{clipLon}}
-                          range and L{pygeodesy.rangerrors} set to C{True}.
+       @raise RangeError: Lat- or longitude value of B{C{strllh}} outside the
+                          valid C{-/+B{clipLat}} or C{-/+B{clipLon}} range
+                          and L{rangerrors<pygeodesy.rangerrors>} is C{True}.
 
        @raise ValueError: Invalid B{C{strllh}} or B{C{height}}.
 
@@ -870,7 +866,7 @@ def parseRad(strRad, suffix=_NSEW_, clip=0):
        @raise ParseError: Invalid B{C{strRad}} or B{C{clip}}.
 
        @raise RangeError: Value of B{C{strRad}} outside the valid C{-/+B{clip}}
-                          range and L{pygeodesy.rangerrors} set to C{True}.
+                          range and L{rangerrors<pygeodesy.rangerrors>} is C{True}.
     '''
     def _Rad(strRad, suffix, clip):
         try:

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.11'
 
 _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
@@ -955,7 +949,7 @@ class EcefMatrix(_NamedTuple):
 
            @return: The matrix product (L{EcefMatrix}).
 
-           @raise TypeError: If B{C{other}} is not L{EcefMatrix}.
+           @raise TypeError: If B{C{other}} is not an L{EcefMatrix}.
         '''
         _xinstanceof(EcefMatrix, other=other)
         # like LocalCartesian.MatrixMultiply, C{self.matrixTransposed3 X other.matrix3}
@@ -1191,7 +1185,7 @@ class Ecef9Tuple(_NamedTuple):
                                B{C{LatLon}} keyword arguments.
 
            @return: An instance of C{B{LatLon}(lat, lon, **B{LatLon_kwds})}
-                    or if B{C{LatLon}} is C{None}, a L{LatLon3Tuple}C{(lat, lon,
+                    or if C{B{LatLon} is None}, a L{LatLon3Tuple}C{(lat, lon,
                     height)} respectively L{LatLon4Tuple}C{(lat, lon, height,
                     datum)} depending on whether C{datum} is un-/specified.
 
@@ -1239,7 +1233,7 @@ class Ecef9Tuple(_NamedTuple):
                                arguments, ignored if C{B{Vector} is None}.
 
            @return: A C{Vector}C{(x, y, z, **Vector_kwds)} instance or a
-                    L{Vector3Tuple}C{(x, y, z)} if B{C{Vector}} is C{None}.
+                    L{Vector3Tuple}C{(x, y, z)} if C{B{Vector} is None}.
 
            @see: Propertes C{xyz} and C{xyzh}
         '''

pygeodesy/elevations.py

@@ -34,7 +34,7 @@ from pygeodesy.units import Lat, Lon, Meter, Scalar, Str
 # from math import fabs  # from .karney
 
 __all__ = _ALL_LAZY.elevations
-__version__ = '24.05.13'
+__version__ = '24.06.11'
 
 try:
     from urllib2 import urlopen  # quote, urlcleanup
@@ -152,7 +152,7 @@ def elevation2(lat, lon, timeout=2.0):
 
        @raise ValueError: Invalid B{C{timeout}}.
 
-       @note: The returned C{elevation} is C{None} if B{C{lat}} or B{C{lon}} is
+       @note: The returned C{elevation is None} if B{C{lat}} or B{C{lon}} is
               invalid or outside the C{Conterminous US (CONUS)}, if conversion
               failed or if the query timed out.  The C{"error"} is the C{HTTP-,
               IO-, SSL-} or other C{-Error} as a string (C{str}).
@@ -208,8 +208,8 @@ def geoidHeight2(lat, lon, model=0, timeout=2.0):
 
        @raise ValueError: Invalid B{C{timeout}}.
 
-       @note: The returned C{height} is C{None} if B{C{lat}} or B{C{lon}}
-              is invalid or outside the C{Conterminous US (CONUS)}, if the
+       @note: The returned C{height is None} if B{C{lat}} or B{C{lon}} is
+              invalid or outside the C{Conterminous US (CONUS)}, if the
               B{C{model}} was invalid, if conversion failed or if the query
               timed out.  The C{"error"} is the C{HTTP-, IO-, SSL-, URL-}
               or other C{-Error} as a string (C{str}).