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

pygeodesy/ltp.py

@@ -13,8 +13,8 @@ and L{ChLVe} and L{Ltp}, L{ChLV}, L{LocalError}, L{Attitude} and L{Frustum}.
 # make sure int/int division yields float quotient, see .basics
 from __future__ import division as _; del _  # PYCHOK semicolon
 
-from pygeodesy.basics import _args_kwds_names, map1, map2, _xinstanceof, \
-                             _xsubclassof   # .datums
+from pygeodesy.basics import _args_kwds_names, _isin, map1, map2, _xinstanceof, \
+                             _xsubclassof,  typename   # .datums
 from pygeodesy.constants import EPS, INT0, _umod_360, _0_0, _0_01, _0_5, _1_0, \
                                _2_0, _60_0, _90_0, _100_0, _180_0, _3600_0, \
                                _N_1_0  # PYCHOK used!
@@ -23,8 +23,9 @@ from pygeodesy.ecef import _EcefBase, EcefKarney, Ecef9Tuple, _llhn4, \
                            _xyzn4,  _WGS84
 from pygeodesy.errors import _NotImplementedError, _ValueError, _xattr, \
                              _xkwds, _xkwds_get, _xkwds_pop2
-from pygeodesy.fmath import fabs, fdot, fdot_, Fhorner
+from pygeodesy.fmath import fabs, fdot, Fdot_, fdot_, Fhorner
 from pygeodesy.fsums import _floor, fsumf_
+# from pygeodesy.internals import typename  # from .basics
 from pygeodesy.interns import _0_, _COMMASPACE_, _DOT_, _ecef_, _height_, _M_, \
                               _invalid_, _lat0_, _lon0_, _name_, _too_
 # from pygeodesy.lazily import _ALL_LAZY  # from vector3d
@@ -44,7 +45,7 @@ from pygeodesy.vector3d import _ALL_LAZY, Vector3d
 # from math import fabs, floor as _floor  # from .fmath, .fsums
 
 __all__ = _ALL_LAZY.ltp
-__version__ = '24.12.12'
+__version__ = '25.05.01'
 
 _height0_ = _height_ + _0_
 _narrow_  = 'narrow'
@@ -62,15 +63,18 @@ class Attitude(_NamedBase):
     def __init__(self, alt_attitude=INT0, tilt=INT0, yaw=INT0, roll=INT0, **name):
         '''New L{Attitude}.
 
-           @kwarg alt_attitude: Altitude (C{meter}) above earth or previous attitude
+           @kwarg alt_attitude: Altitude (C{meter}) above earth or a previous attitude
                       (L{Attitude} or L{Attitude4Tuple}) with the C{B{alt}itude},
                       B{C{tilt}}, B{C{yaw}} and B{C{roll}}.
            @kwarg tilt: Pitch, elevation from horizontal (C{degrees180}), negative down
-                        (clockwise rotation along and around the x- or East axis).
+                        (clockwise rotation along and around the x- or East axis), iff
+                        B{C{alt_attitude}} is C{meter}, ignored otherwise.
            @kwarg yaw: Bearing, heading (compass C{degrees360}), clockwise from North
-                       (counter-clockwise rotation along and around the z- or Up axis).
+                       (counter-clockwise rotation along and around the z- or Up axis)
+                       iff B{C{alt_attitude}} is C{meter}, ignored otherwise.
            @kwarg roll: Roll, bank (C{degrees180}), positive to the right and down
-                        (clockwise rotation along and around the y- or North axis).
+                        (clockwise rotation along and around the y- or North axis), iff
+                        B{C{alt_attitude}} is C{meter}, ignored otherwise.
            @kwarg name: Optional C{B{name}=NN} C{str}).
 
            @raise AttitudeError: Invalid B{C{alt_attitude}}, B{C{tilt}}, B{C{yaw}} or
@@ -145,8 +149,10 @@ class Attitude(_NamedBase):
 
            @arg x_xyz: X component of vector (C{scalar}) or (3-D) vector (C{Cartesian},
                        L{Vector3d} or L{Vector3Tuple}).
-           @kwarg y: Y component of vector (C{scalar}), same units as B{C{x}}.
-           @kwarg z: Z component of vector (C{scalar}), same units as B{C{x}}.
+           @kwarg y: Y component of vector (C{scalar}), same units as C{scalar} B{C{x}},
+                     ignored otherwise.
+           @kwarg z: Z component of vector (C{scalar}), same units as C{sclar} B{C{x}},
+                     ignored otherwise.
            @kwarg Vector: Class to return transformed point (C{Cartesian}, L{Vector3d}
                           or C{Vector3Tuple}) or C{None}.
            @kwarg name_Vector_kwds: Optional C{B{name}=NN} (C{str}) and optionally,
@@ -222,7 +228,7 @@ class Attitude(_NamedBase):
             _update_all(self)
             self._yaw = y
 
-    bearing = heading = yaw
+    bearing = heading = yaw  # azimuth
 
 
 class AttitudeError(_ValueError):
@@ -270,11 +276,14 @@ class Frustum(_NamedBase):
                               an attitude (L{Attitude} or L{Attitude4Tuple}) with the
                               C{B{alt}itude}, B{C{tilt}}, B{C{yaw}} and B{C{roll}}.
            @kwarg tilt: Pitch, elevation from horizontal (C{degrees}), negative down
-                        (clockwise rotation along and around the x- or East axis).
+                        (clockwise rotation along and around the x- or East axis) iff
+                        B{C{alt_attitude}} is C{meter}, ignored otherwise.
            @kwarg yaw: Bearing, heading (compass C{degrees}), clockwise from North
-                       (counter-clockwise rotation along and around the z- or Up axis).
+                       (counter-clockwise rotation along and around the z- or Up axis)
+                       iff B{C{alt_attitude}} is C{meter}, ignored otherwise.
            @kwarg roll: Roll, bank (C{degrees}), positive to the right and down
-                        (clockwise rotation along and around the y- or North axis).
+                        (clockwise rotation along and around the y- or North axis) iff
+                        B{C{alt_attitude}} is C{meter}, ignored otherwise.
            @kwarg z: Optional height of the footprint (C{meter}) above I{local tangent plane}.
            @kwarg ltp: The I{local tangent plane} (L{Ltp}), overriding this
                        frustum's C{ltp}.
@@ -462,7 +471,7 @@ class LocalCartesian(_NamedBase):
         '''
         return self._ecef
 
-    def _ecef2local(self, ecef, Xyz, name_Xyz_kwds):
+    def _ecef2local(self, ecef, Xyz, name_Xyz_kwds):  # in _EcefLocal._Ltp_ecef2local
         '''(INTERNAL) Convert geocentric/geodetic to local, like I{forward}.
 
            @arg ecef: Geocentric (and geodetic) (L{Ecef9Tuple}).
@@ -503,10 +512,11 @@ class LocalCartesian(_NamedBase):
 
            @arg latlonh: Either a C{LatLon}, L{Ltp}, L{Ecef9Tuple} or C{scalar}
                          (geodetic) latitude (C{degrees}).
-           @kwarg lon: Optional C{scalar} (geodetic) longitude for C{scalar}
-                       B{C{latlonh}} (C{degrees}).
+           @kwarg lon: Optional C{scalar} (geodetic) longitude (C{degrees}) iff
+                       B{C{latlonh}} is C{scalar}, ignored otherwise.
            @kwarg height: Optional height (C{meter}, conventionally) perpendicular
-                          to and above (or below) the ellipsoid's surface.
+                          to and above (or below) the ellipsoid's surface, iff
+                          B{C{latlonh}} is C{scalar}, ignored othewrise.
            @kwarg M: Optionally, return the I{concatenated} rotation L{EcefMatrix},
                      iff available (C{bool}).
            @kwarg name: Optional C{B{name}=NN} (C{str}).
@@ -590,7 +600,7 @@ class LocalCartesian(_NamedBase):
         return self._t0.M
 
     def reset(self, latlonh0=INT0, lon0=INT0, height0=INT0, ecef=None, **lon00_name):
-        '''Reset this converter, see L{LocalCartesian.__init__} for more details.
+        '''Reset this converter, see L{LocalCartesian.__init__} for further details.
         '''
         _, name = _xkwds_pop2(lon00_name, lon00=None)  # PYCHOK get **name
         if isinstance(latlonh0, LocalCartesian):
@@ -620,8 +630,10 @@ class LocalCartesian(_NamedBase):
 
            @arg xyz: A I{local} (L{XyzLocal}, L{Enu}, L{Ned}, L{Aer}, L{Local9Tuple}) or
                      local C{x} coordinate (C{scalar}).
-           @kwarg y: Local C{y} coordinate for C{scalar} B{C{xyz}} and B{C{z}} (C{meter}).
-           @kwarg z: Local C{z} coordinate for C{scalar} B{C{xyz}} and B{C{y}} (C{meter}).
+           @kwarg y: Local C{y} coordinate (C{meter}), iff B{C{xyz}} is C{scalar},
+                     ignored otherwise.
+           @kwarg z: Local C{z} coordinate (C{meter}), iff B{C{xyz}} is C{scalar},
+                     ignored otherwise.
            @kwarg M: Optionally, return the I{concatenated} rotation L{EcefMatrix}, iff
                      available (C{bool}).
            @kwarg lon00_name: Optional C{B{name}=NN} (C{str}) and keyword argument
@@ -714,7 +726,7 @@ class _ChLV(object):
         '''
         if bool(M):  # PYCHOK no cover
             m =  self.forward if fw else self.reverse  # PYCHOK attr
-            n = _DOT_(self.__class__.__name__, m.__name__)
+            n = _DOT_(*map1(typename, type(self), m))
             raise _NotImplementedError(unstr(n, M=M), txt=None)
         t = Y_X_h_lat_lon_h + (self, self._t0, None)  # PYCHOK _t0
         return ChLV9Tuple(t, name=name)
@@ -733,18 +745,18 @@ class _ChLV(object):
         '''Convert WGS84 geodetic to I{Swiss} projection coordinates.  I{Must be overloaded}.
 
            @arg latlonh: Either a C{LatLon}, L{Ltp} or C{scalar} (geodetic) latitude (C{degrees}).
-           @kwarg lon: Optional, C{scalar} (geodetic) longitude for C{scalar} B{C{latlonh}} (C{degrees}).
+           @kwarg lon: Optional, C{scalar} (geodetic) longitude (C{degrees}) iff B{C{latlonh}} is
+                       C{scalar}, ignored otherwise.
            @kwarg height: Optional, height, vertically above (or below) the surface of the ellipsoid
-                          (C{meter}) for C{scalar} B{C{latlonh}} and B{C{lon}}.
+                          (C{meter}) iff B{C{latlonh}} and B{C{lon}} are C{scalar}, ignored otherwise.
            @kwarg M: If C{True}, return the I{concatenated} rotation L{EcefMatrix} iff available
-                     for C{ChLV} only, C{None} otherwise (C{bool}).
+                     and for C{ChLV} only, C{None} otherwise (C{bool}).
            @kwarg name: Optional C{B{name}=NN} (C{str}).
 
            @return: A L{ChLV9Tuple}C{(Y, X, h_, lat, lon, height, ltp, ecef, M)} with the unfalsed
                     I{Swiss Y, X} coordinates, I{Swiss h_} height, the given I{geodetic} C{lat},
-                    C{lon} and C{height}, this C{ChLV*} instance and C{ecef} (L{Ecef9Tuple}) at
-                    I{Bern, Ch} and rotation matrix C{M}.  The returned C{ltp} is this C{ChLV},
-                    C{ChLVa} or C{ChLVe} instance.
+                    C{lon} and C{height}, C{ecef} (L{Ecef9Tuple}) at I{Bern, Ch}, rotation matrix
+                    C{M} and C{ltp} this C{ChLV}, C{ChLVa} or C{ChLVe} instance.
 
            @raise LocalError: Invalid or non-C{scalar} B{C{latlonh}}, B{C{lon}} or B{C{height}}.
         '''
@@ -755,18 +767,18 @@ class _ChLV(object):
 
            @arg enh_: A Swiss projection (L{ChLV9Tuple}) or the C{scalar}, falsed I{Swiss E_LV95}
                      or I{y_LV03} easting (C{meter}).
-           @kwarg n: Falsed I{Swiss N_LV85} or I{x_LV03} northing for C{scalar} B{C{enh_}} and
-                     B{C{h_}} (C{meter}).
-           @kwarg h_: I{Swiss h'} height for C{scalar} B{C{enh_}} and B{C{n}} (C{meter}).
+           @kwarg n: Falsed I{Swiss N_LV85} or I{x_LV03} northing (C{meter}) iff B{C{enh_}} is
+                     C{scalar}, ignored otherwise.
+           @kwarg h_: I{Swiss h'} height (C{meter}) iff B{C{enh_}} and B{C{n}} are C{scalar},
+                      ignored otherwise.
            @kwarg M: If C{True}, return the I{concatenated} rotation L{EcefMatrix} iff available
-                     for C{ChLV} only, C{None} otherwise (C{bool}).
+                     and for C{ChLV} only, C{None} otherwise (C{bool}).
            @kwarg name: Optional C{B{name}=NN} (C{str}).
 
            @return: A L{ChLV9Tuple}C{(Y, X, h_, lat, lon, height, ltp, ecef, M)} with the unfalsed
                     I{Swiss Y, X} coordinates, I{Swiss h_} height, the given I{geodetic} C{lat},
-                    C{lon} and C{height}, this C{ChLV*} instance and C{ecef} (L{Ecef9Tuple}) at
-                    I{Bern, Ch} and rotation matrix C{M}.  The returned C{ltp} is this C{ChLV},
-                    C{ChLVa} or C{ChLVe} instance.
+                    C{lon} and C{height}, C{ecef} (L{Ecef9Tuple}) at I{Bern, Ch}, rotation matrix
+                    C{M} and C{ltp} this C{ChLV}, C{ChLVa} or C{ChLVe} instance.
 
            @raise LocalError: Invalid or non-C{scalar} B{C{enh_}}, B{C{n}} or B{C{h_}}.
         '''
@@ -776,8 +788,8 @@ class _ChLV(object):
     def _falsing2(LV95):
         '''(INTERNAL) Get the C{LV95} or C{LV03} falsing.
         '''
-        return _ChLV._95_falsing if LV95 in (True, 95) else (
-               _ChLV._03_falsing if LV95 in (False, 3) else ChLVYX2Tuple(0, 0))
+        return _ChLV._95_falsing if _isin(LV95, True, 95) else (
+               _ChLV._03_falsing if _isin(LV95, False, 3) else ChLVYX2Tuple(0, 0))
 
     @staticmethod
     def _llh2abh_3(lat, lon, h):
@@ -817,7 +829,7 @@ class _ChLV(object):
     def _YXh_n4(self, enh_, n, h_, **name):
         '''(INTERNAL) Helper for C{ChLV*.reverse}.
         '''
-        Y, X, h_, name = _xyzn4(enh_, n, h_, ChLV9Tuple,
+        Y, X, h_, name = _xyzn4(enh_, n, h_, (ChLV9Tuple,),
                          _xyz_y_z_names=self._enh_n_h, **name)
         if isinstance(enh_, ChLV9Tuple):
             Y, X = enh_.Y, enh_.X
@@ -973,15 +985,15 @@ class ChLVa(_ChLV, LocalCartesian):
         a, b, h      = _ChLV._YXh_2abh3(Y, X, h_)
         ab_d, a2, b2 =  ChLV._ab_d, a**2, b**2
 
-        lat = fdot_(3.238272, b,
+        lat = Fdot_(3.238272, b,
                    -0.270978, a2,
                    -0.002528, b2,
                      -0.0447, a2 * b,
-                      -0.014, b2 * b, start=16.9023892) / ab_d
-        lon = fdot_(4.728982, a,
+                      -0.014, b2 * b, start=16.9023892).fover(ab_d)
+        lon = Fdot_(4.728982, a,
                     0.791484, a * b,
                       0.1306, a * b2,
-                     -0.0436, a * a2, start=2.6779094) / ab_d
+                     -0.0436, a * a2, start=2.6779094).fover(ab_d)
         return self._ChLV9Tuple(False, M, n, Y, X, h_, lat, lon, h)
 
 
@@ -996,8 +1008,8 @@ class ChLVe(_ChLV, LocalCartesian):
               argument C{B{gamma}=False} to approximate the I{meridian convergence}.
               If C{B{gamma}=True} a 2-tuple C{(t, gamma)} is returned with C{t} the
               usual result (C{ChLV9Tuple}) and C{gamma}, the I{meridian convergence}
-              (decimal C{degrees}).  To convert C{gamma} to C{grades} or C{gons},
-              use function L{pygeodesy.degrees2grades}.
+              (decimal C{degrees}).  To convert C{gamma} to C{grades} or C{gons}, use
+              function L{pygeodesy.degrees2grades}.
 
        @see: Older U{references<https://GitHub.com/alphasldiallo/Swisstopo-WGS84-LV03>}.
     '''
@@ -1069,20 +1081,6 @@ def _fov_2(**fov):
     raise LocalError(txt=t, **fov)
 
 
-def _toLocal(inst, ltp, Xyz, Xyz_kwds):
-    '''(INTERNAL) Helper for C{CartesianBase.toAer}, C{CartesianBase.toEnu},
-       C{CartesianBase.toLocal}, C{CartesianBase.toNed} and C{latLonBase.toLocal}.
-    '''
-    return _xLtp(ltp, inst._Ltp)._ecef2local(inst._ecef9, Xyz, Xyz_kwds)
-
-
-def _toLtp(inst, Ecef, ecef9, name):
-    '''(INTERNAL) Helper for C{CartesianBase.toLtp}, C{ecef.toLtp} and C{latLonBase.toLtp}.
-    '''
-    return inst._Ltp if (not name) and Ecef in (None, inst.Ecef) else \
-                 Ltp(ecef9, ecef=Ecef(inst.datum), name=inst._name__(name))
-
-
 def tyr3d(tilt=INT0, yaw=INT0, roll=INT0, Vector=Vector3d, **name_Vector_kwds):
     '''Convert an attitude pose into a (3-D) direction vector.
 

pygeodesy/ltpTuples.py

@@ -11,18 +11,19 @@ L{ChLVYX2Tuple}, L{ChLVyx2Tuple} and L{Footprint5Tuple}.
 @see: References in module L{ltp}.
 '''
 
-# from pygeodesy.basics import issubclassof  # _MODS
+from pygeodesy.basics import issubclassof,  typename
 from pygeodesy.constants import _0_0, _1_0, _90_0, _N_90_0
 # from pygeodesy.dms import F_D, toDMS  # _MODS
 from pygeodesy.errors import _TypeError, _TypesError, _xattr, _xkwds, \
                              _xkwds_item2
 from pygeodesy.fmath import fdot_, hypot, hypot_
+# rom pygeodesy.internals import typename  # from .basics
 from pygeodesy.interns import NN, _4_, _azimuth_, _center_, _COMMASPACE_, \
                              _ecef_, _elevation_, _height_, _lat_, _lon_, \
                              _ltp_, _M_, _name_, _up_, _X_, _x_, _xyz_, \
                              _Y_, _y_, _z_
 from pygeodesy.lazily import _ALL_DOCS, _ALL_LAZY, _ALL_MODS as _MODS
-# from pygeodesy.ltp import Attitude, ChLV, ChLVa, ChLVe, _xLtp  # _MODS
+# from pygeodesy.ltp Attitude, ChLV, ChLVa, ChLVe _Xltp  # _MODS.into
 from pygeodesy.named import _name__, _name1__, _name2__, _NamedBase, \
                             _NamedTuple, _Pass, _xnamed
 from pygeodesy.namedTuples import LatLon2Tuple, PhiLam2Tuple, Vector3Tuple
@@ -37,7 +38,7 @@ from pygeodesy.vector3d import Vector3d
 # from math import cos, radians  # from .utily
 
 __all__ = _ALL_LAZY.ltpTuples
-__version__ = '24.12.06'
+__version__ = '25.05.01'
 
 _aer_        = 'aer'
 _alt_        = 'alt'
@@ -48,6 +49,7 @@ _h__         = 'h_'
 _ned_        = 'ned'
 _north_      = 'north'
 _local_      = 'local'
+_ltp         = _MODS.into(ltp=__name__)
 _roll_       = 'roll'
 _slantrange_ = 'slantrange'
 _tilt_       = 'tilt'
@@ -158,25 +160,25 @@ class _Abc4Tuple(_NamedTuple):
     def _2Cls(self, Abc, Cls, Cls_kwds):
         '''(INTERNAL) Convert 4-Tuple to C{Cls} instance.
         '''
+        _isc =  issubclassof
         kwds = _name1__(Cls_kwds, _or_nameof=self)
-        _is  = _MODS.basics.issubclassof
         if Cls is None:
             n, _ = _name2__(Cls_kwds)
             r = self.copy(name=n) if n else self
-        elif _is(Cls, Abc):
+        elif _isc(Cls, Abc):
             r = Cls(*self, **kwds)
-        elif _is(Cls, Aer):
+        elif _isc(Cls, Aer):
             r = self.xyzLocal.toAer(**_xkwds(kwds, Aer=Cls))
-        elif _is(Cls, Enu):  # PYCHOK no cover
+        elif _isc(Cls, Enu):  # PYCHOK no cover
             r = self.xyzLocal.toEnu(**_xkwds(kwds, Enu=Cls))
-        elif _is(Cls, Ned):
+        elif _isc(Cls, Ned):
             r = self.xyzLocal.toNed(**_xkwds(kwds, Ned=Cls))
-        elif _is(Cls, XyzLocal):  # PYCHOK no cover
+        elif _isc(Cls, XyzLocal):  # PYCHOK no cover
             r = self.xyzLocal.toXyz(**_xkwds(kwds, Xyz=Cls))
         elif Cls is Local9Tuple:  # PYCHOK no cover
             r = self.xyzLocal.toLocal9Tuple(**kwds)
         else:  # PYCHOK no cover
-            n = Abc.__name__[:3]
+            n = typename(Abc)[:3]
             raise _TypesError(n, Cls, Aer, Enu, Ned, XyzLocal)
         return r
 
@@ -383,7 +385,7 @@ class Attitude4Tuple(_NamedTuple):
     def tyr3d(self):
         '''Get this attitude's (3-D) directional vector (L{Vector3d}).
         '''
-        return _MODS.ltp.Attitude(self).tyr3d
+        return _ltp.Attitude(self).tyr3d
 
 
 class Ned(_AbcBase):
@@ -731,7 +733,7 @@ class XyzLocal(_Vector3d):
     def _ltp_kwds_name3(self, ltp, kwds):
         '''(INTERNAL) Helper for methods C{toCartesian} and C{toLatLon}.
         '''
-        ltp  = _xLtp(ltp, self.ltp)
+        ltp  = _ltp._xLtp(ltp, self.ltp)
         kwds = _name1__(kwds, _or_nameof=self)
         kwds = _name1__(kwds, _or_nameof=ltp)
         return ltp, kwds, kwds.get(_name_, NN)
@@ -965,10 +967,11 @@ class Enu(XyzLocal):
                           I{local} instance (L{Enu}, L{Enu4Tuple}, L{Aer},
                           L{Aer4Tuple}, L{Local9Tuple}, L{Ned}, L{Ned4Tuple},
                           L{XyzLocal} or L{Xyz4Tuple}).
-           @kwarg north: Scalar North component (C{meter}) only used with
-                         scalar B{C{east_enu}}.
-           @kwarg up: Scalar Up component only used with scalar B{C{east_enu}},
-                      normal from the surface of the ellipsoid or sphere (C{meter}).
+           @kwarg north: Scalar North component (C{meter}), iff B{C{east_enu}}
+                         is C{meter}, ignored otherwise.
+           @kwarg up: Scalar Up component (C{meter}, normal from the surface
+                      of the ellipsoid or sphere), iff B{C{east_enu}} is
+                      C{meter}, ignored otherwise.
            @kwarg ltp: The I{local tangent plane}, (geodetic) origin (L{Ltp},
                        L{LocalCartesian}).
            @kwarg name: Optional C{B{name}=NN} (C{str}).
@@ -1249,10 +1252,12 @@ class Uvw(_Vector3d):
     def __init__(self, u_uvw, v=0, w=0, **name):
         '''New L{Uvw}.
 
-           @arg u_uvw: Scalar U component (C{meter}) or a previous instance
-                       (L{Uvw}, L{Uvw3Tuple}, L{Vector3d}).
-           @kwarg v: V component (C{meter}) only used with scalar B{C{u_uvw}}.
-           @kwarg w: W component (C{meter}) only used with scalar B{C{u_uvw}}.
+           @arg u_uvw: Scalar U component (C{meter}) or a previous instance (L{Uvw},
+                       L{Uvw3Tuple}, L{Vector3d}).
+           @kwarg v: V component (C{meter}), iff B{C{u_uvw}} is C{meter}, ignored
+                     otherwise.
+           @kwarg w: W component (C{meter}), iff B{C{u_uvw}} is C{meter}, ignored
+                     otherwise.
            @kwarg name: Optional C{B{name}=NN} (C{str}).
 
            @raise TypeError: Invalid B{C{east_enu}}.
@@ -1323,8 +1328,8 @@ class Los(Aer):
                              or a previous instance (L{Aer}, L{Aer4Tuple}, L{Enu},
                              L{Enu4Tuple} or L{Los}).
            @kwarg elevation: Scalar angle I{above} the horizon (C{degrees}, horizon
-                             is 0, zenith +90, nadir -90), only used with scalar
-                             B{C{azimuth_aer}}.
+                             is 0, zenith +90, nadir -90), if B{C{azimuth_aer}} is
+                             C{degrees}, ignored otherwise.
            @kwarg name: Optional C{B{name}=NN} (C{str}).
 
            @raise TypeError: Invalid B{C{azimuth_aer}}.
@@ -1388,19 +1393,19 @@ class ChLV9Tuple(Local9Tuple):
     def isChLV(self):
         '''Is this a L{ChLV}-generated L{ChLV9Tuple}?.
         '''
-        return self.ltp.__class__ is _MODS.ltp.ChLV
+        return self.ltp.__class__ is _ltp.ChLV
 
     @property_RO
     def isChLVa(self):
         '''Is this a L{ChLVa}-generated L{ChLV9Tuple}?.
         '''
-        return self.ltp.__class__ is _MODS.ltp.ChLVa
+        return self.ltp.__class__ is _ltp.ChLVa
 
     @property_RO
     def isChLVe(self):
         '''Is this a L{ChLVe}-generated L{ChLV9Tuple}?.
         '''
-        return self.ltp.__class__ is _MODS.ltp.ChLVe
+        return self.ltp.__class__ is _ltp.ChLVe
 
     @Property_RO
     def N_LV95(self):
@@ -1526,7 +1531,7 @@ class Footprint5Tuple(_NamedTuple):
 
            @see: Methods L{XyzLocal.toLatLon} and L{Footprint5Tuple.xyzLocal5}.
         '''
-        ltp  = _xLtp(ltp, self.center.ltp)  # PYCHOK .center
+        ltp  = _ltp._xLtp(ltp, self.center.ltp)  # PYCHOK .center
         kwds = _name1__(name_LatLon_kwds, _or_nameof=self)
         kwds = _xkwds(kwds, ltp=ltp, LatLon=LatLon)
         return Footprint5Tuple(t.toLatLon(**kwds) for t in self.xyzLocal5())
@@ -1544,7 +1549,7 @@ class Footprint5Tuple(_NamedTuple):
         if ltp is None:
             p =  self
         else:
-            p = _xLtp(ltp)
+            p = _ltp._xLtp(ltp)
             p =  tuple(Xyz4Tuple(t.x, t.y, t.z, p) for t in self)
         return Footprint5Tuple(t.xyzLocal for t in p)
 
@@ -1552,13 +1557,13 @@ class Footprint5Tuple(_NamedTuple):
 def _ChLV_false2(Y, X, **LV95_name):
     '''(INTERNAL) Invoke static method C{ltp.ChLV.false2}.
     '''
-    return _MODS.ltp.ChLV.false2(Y, X, **LV95_name)
+    return _ltp.ChLV.false2(Y, X, **LV95_name)
 
 
 def _ChLV_unfalse2(e, n, **LV95_name):
     '''(INTERNAL) Invoke static method C{ltp.ChLV.unfalse2}.
     '''
-    return _MODS.ltp.ChLV.unfalse2(e, n, **LV95_name)
+    return _ltp.ChLV.unfalse2(e, n, **LV95_name)
 
 
 def _er2gr(e, r):
@@ -1577,7 +1582,7 @@ def _init(inst, abc, ltp, name):
         n =  abc._name__(name)
         ltp = _xattr(abc, ltp=ltp)
     if ltp:
-        inst._ltp = _xLtp(ltp)
+        inst._ltp = _ltp._xLtp(ltp)
     if n:
         inst.name = n
 
@@ -1595,12 +1600,6 @@ def _toStr2(inst, prec=None, fmt=Fmt.SQUARE, sep=_COMMASPACE_):
     return a, t
 
 
-def _xLtp(ltp, *dflt):
-    '''(INTERNAL) Invoke C{ltp._xLtp}.
-    '''
-    return _MODS.ltp._xLtp(ltp, *dflt)
-
-
 def _xyz2aer4(inst):
     '''(INTERNAL) Convert C{(x, y, z}) to C{(A, E, R)}.
     '''

pygeodesy/mgrs.py

@@ -35,14 +35,15 @@ and compare the MGRS results with those from I{Karney}'s utility U{GeoConvert
 <https://GeographicLib.sourceforge.io/C++/doc/GeoConvert.1.html>}.
 '''
 
-from pygeodesy.basics import halfs2, _splituple, _xinstanceof
+from pygeodesy.basics import halfs2, _isin, _splituple, _xinstanceof
 # from pygeodesy.constants import _0_5  # from .units
 from pygeodesy.datums import _ellipsoidal_datum, _WGS84
 from pygeodesy.errors import _AssertionError, MGRSError, _parseX, \
                              _ValueError, _xkwds
 from pygeodesy.interns import NN, _0_, _A_, _AtoZnoIO_, _band_, _B_, \
-                             _COMMASPACE_, _datum_, _easting_, _invalid_, \
-                             _northing_, _SPACE_, _W_, _Y_, _Z_, _zone_
+                             _COMMASPACE_, _datum_, _DMAIN_, _easting_, \
+                             _invalid_, _northing_, _SPACE_, _W_, _Y_, \
+                             _Z_, _zone_
 from pygeodesy.lazily import _ALL_LAZY, _ALL_MODS as _MODS
 from pygeodesy.named import _name2__, _NamedBase, _NamedTuple, _Pass
 from pygeodesy.namedTuples import EasNor2Tuple, UtmUps5Tuple
@@ -55,7 +56,7 @@ from pygeodesy.utm import toUtm8, _to3zBlat, Utm, _UTM_ZONE_MAX, _UTM_ZONE_MIN
 # from pygeodesy.utmupsBase import _UTM_ZONE_MAX, _UTM_ZONE_MIN  # from .utm
 
 __all__ = _ALL_LAZY.mgrs
-__version__ = '24.11.06'
+__version__ = '25.04.14'
 
 _AN_    = 'AN'  # default south pole grid tile and band B
 _AtoPx_ = _AtoZnoIO_.tillP
@@ -128,7 +129,7 @@ class Mgrs(_NamedBase):
 
         self._easting  = Easting(easting,   Error=MGRSError)
         self._northing = Northing(northing, Error=MGRSError)
-        if datum not in (None, Mgrs._datum):
+        if not _isin(datum, None, Mgrs._datum):
             self._datum = _ellipsoidal_datum(datum, name=name)  # XXX raiser=_datum_
 
         if resolution:
@@ -649,7 +650,7 @@ def _um100km2(m):
     return int(M), m
 
 
-if __name__ == '__main__':
+if __name__ == _DMAIN_:
 
     def _main():