pygeodesy 24.7.24__py2.py3-none-any.whl → 24.8.4__py2.py3-none-any.whl

pygeodesy/geoids.py

@@ -117,7 +117,7 @@ except ImportError:  # Python 3+
     from io import BytesIO as _BytesIO  # PYCHOK expected
 
 __all__ = _ALL_LAZY.geoids
-__version__ = '24.07.12'
+__version__ = '24.07.25'
 
 _assert_ = 'assert'
 _bHASH_  =  b'#'
@@ -287,7 +287,7 @@ class _GeoidBase(_HeightsBase):
 
     def _called(self, llis, scipy, wrap=False, H=False):
         # handle __call__
-        _H = _MODS.formy.heightOrthometric if H else None
+        _H = self._heightOrthometric if H else None
         _as, llis = _as_llis2(llis, Error=GeoidError)
         hs, _w    =  [], _Wrap._latlonop(wrap)
         _a, _h    =  hs.append, self._hGeoid
@@ -416,6 +416,10 @@ class _GeoidBase(_HeightsBase):
         '''
         return _height_called(self, lats, lons, Error=GeoidError, **wrap)
 
+    @property_ROver
+    def _heightOrthometric(self):
+        return _MODS.formy.heightOrthometric  # overwrite property_ROver
+
     def _hGeoid(self, lat, lon):
         out = self.outside(lat, lon)
         if out:

pygeodesy/heights.py

@@ -69,7 +69,7 @@ C{>>> hs = hinterpolator.height(lats, lons)}
 from __future__ import division as _; del _  # PYCHOK semicolon
 
 from pygeodesy.basics import isscalar, len2, map1, map2, _xnumpy, _xscipy
-from pygeodesy.constants import EPS, PI, PI2, _0_0, _90_0, _180_0
+from pygeodesy.constants import EPS, PI, PI_2, PI2, _0_0, _90_0, _180_0
 from pygeodesy.datums import _ellipsoidal_datum, _WGS84
 from pygeodesy.errors import _AssertionError, LenError, PointsError, \
                              _SciPyIssue, _xattr, _xkwds, _xkwds_get, _xkwds_item2
@@ -83,7 +83,7 @@ from pygeodesy.interns import NN, _COMMASPACE_, _cubic_, _insufficient_, _linear
 from pygeodesy.lazily import _ALL_DOCS, _ALL_LAZY, _ALL_MODS as _MODS, _FOR_DOCS
 from pygeodesy.named import _name2__, _Named
 from pygeodesy.points import _distanceTo, LatLon_,  Fmt, radians, _Wrap
-from pygeodesy.props import Property_RO, property_RO
+from pygeodesy.props import Property_RO, property_RO, property_ROver
 # from pygeodesy.streprs import Fmt  # from .points
 from pygeodesy.units import _isDegrees, Float_, Int_
 # from pygeodesy.utily import _Wrap  # from .points
@@ -91,7 +91,7 @@ from pygeodesy.units import _isDegrees, Float_, Int_
 # from math import radians  # from .points
 
 __all__ = _ALL_LAZY.heights
-__version__ = '24.06.22'
+__version__ = '24.07.25'
 
 _error_     = 'error'
 _formy      = _MODS.into(formy=__name__)
@@ -169,14 +169,13 @@ def _insufficientError(need, Error=HeightError, **name_value):  # PYCHOK no cove
     return Error(txt=t, **name_value)
 
 
-def _ordedup(ts, lo=EPS, hi=PI2-EPS):
+def _orderedup(ts, lo=EPS, hi=PI2-EPS):
     # clip, order and remove duplicates
-    # p, ks = 0, []
+    # p = 0
     # for k in sorted(max(lo, min(hi, t)) for t in ts):
     #     if k > p:
-    #         ks.append(k)
+    #         yield k
     #         p = k
-    # return ks
     return sorted(set(max(lo, min(hi, t)) for t in ts))  # list
 
 
@@ -227,8 +226,6 @@ class _HeightBase(_Named):  # in .geoids
 class _HeightsBase(_HeightBase):  # in .geoids
     '''(INTERNAL) Interpolator base class.
     '''
-    _np_sp = None  # (numpy, scipy)
-
     def __call__(self, *llis, **wrap):  # PYCHOK no cover
         '''Interpolate the height for one or several locations.  I{Must be overloaded}.
 
@@ -290,46 +287,37 @@ class _HeightsBase(_HeightBase):  # in .geoids
         '''
         self._notOverloaded(lats, lons, **wrap)
 
-    def _np_sp2(self, throwarnings=False):
+    def _np_sp2(self, throwarnings=False):  # PYCHOK no cover
         '''(INTERNAL) Import C{numpy} and C{scipy}, once.
         '''
-        t = _HeightsBase._np_sp
-        if not t:
-            # raise SciPyWarnings, but not if
-            # scipy has already been imported
-            if throwarnings:  # PYCHOK no cover
-                import sys
-                if _scipy_ not in sys.modules:
-                    import warnings
-                    warnings.filterwarnings(_error_)
-
-            sp = _xscipy(self.__class__, 1, 2)
-            np = _xnumpy(self.__class__, 1, 9)
-
-            _HeightsBase._np_sp = t = np, sp
-        return t
-
-    @Property_RO
+        # raise SciPyWarnings, but not if
+        # scipy has already been imported
+        if throwarnings:  # PYCHOK no cover
+            import sys
+            if _scipy_ not in sys.modules:
+                import warnings
+                warnings.filterwarnings(_error_)
+        return self.numpy, self.scipy
+
+    @property_ROver
     def numpy(self):
         '''Get the C{numpy} module or C{None}.
         '''
-        np, _ = self._np_sp2()
-        return np
+        return _xnumpy(self.__class__, 1, 9)  # overwrite property_ROver
 
-    @Property_RO
+    @property_ROver
     def scipy(self):
         '''Get the C{scipy} module or C{None}.
         '''
-        _, sp = self._np_sp2()
-        return sp
+        return _xscipy(self.__class__, 1, 2)  # overwrite property_ROver
 
-    @Property_RO
+    @property_ROver
     def scipy_interpolate(self):
         '''Get the C{scipy.interpolate} module or C{None}.
         '''
         _ = self.scipy
         import scipy.interpolate as spi  # scipy 1.2.2
-        return spi
+        return spi  # overwrite property_ROver
 
     def _scipy_version(self, **n):
         '''Get the C{scipy} version as 2- or 3-tuple C{(major, minor, micro)}.
@@ -441,19 +429,20 @@ class HeightLSQBiSpline(_HeightsBase):
     '''
     _kmin = 16  # k = 3, always
 
-    def __init__(self, knots, weight=None, **name_wrap):
+    def __init__(self, knots, weight=None, low=1e-4, **name_wrap):
         '''New L{HeightLSQBiSpline} interpolator.
 
            @arg knots: The points with known height (C{LatLon}s).
            @kwarg weight: Optional weight or weights for each B{C{knot}}
                           (C{scalar} or C{scalar}s).
+           @kwarg low: Optional lower bound for I{ordered knots} (C{radians}).
            @kwarg name_wrap: Optional C{B{name}=NN} for this height interpolator
                        (C{str}) and keyword argument C{b{wrap}=False} to wrap or
                        I{normalize} all B{C{knots}} and B{C{llis}} locations iff
                        C{True} (C{bool}).
 
-           @raise HeightError: Insufficient number of B{C{knots}} or
-                               an invalid B{C{knot}} or B{C{weight}}.
+           @raise HeightError: Insufficient number of B{C{knots}} or an invalid
+                               B{C{knot}},  B{C{weight}} or B{C{eps}}.
 
            @raise LenError: Unequal number of B{C{knots}} and B{C{weight}}s.
 
@@ -487,9 +476,10 @@ class HeightLSQBiSpline(_HeightsBase):
                 w = Fmt.INDEX(weight=w.index(m))
                 raise HeightError(w, m)
         try:
-            T = 1.0e-4  # like SciPy example
-            ps = np.array(_ordedup(xs, T, PI2 - T))
-            ts = np.array(_ordedup(ys, T, PI  - T))
+            if not EPS < low < (PI_2 - EPS):  # 1e-4 like SciPy example
+                raise HeightError(low=low)
+            ps = np.array(_orderedup(xs, low, PI2 - low))
+            ts = np.array(_orderedup(ys, low, PI  - low))
             self._ev = spi.LSQSphereBivariateSpline(ys, xs, hs,
                                                     ts, ps, eps=EPS, w=w).ev
         except Exception as x:

pygeodesy/internals.py

@@ -213,6 +213,13 @@ class _MODS_Base(object):
         from pygeodesy import streprs  # DON'T _lazy_import2
         return streprs
 
+    @_Property_RO
+    def version(self):
+        '''Get pygeodesy version, I{once}.
+        '''
+        from pygeodesy import version
+        return version
+
 _MODS = _MODS_Base()  # PYCHOK overwritten by .lazily
 
 
@@ -430,7 +437,7 @@ def _print7(nl=0, nt=0, prec=6, prefix=NN, sep=_SPACE_, file=_sys.stdout,
 
 
 def _Pythonarchine(sep=NN):  # in .lazily, test/bases.py versions
-    '''(INTERNAL) Get PyPy and Python versions, bit and machine as C{3- or 4-list} or C{str}.
+    '''(INTERNAL) Get PyPy and Python versions, bits and machine as C{3- or 4-list} or C{str}.
     '''
     l3 = _MODS.Pythonarchine
     return sep.join(l3) if sep else l3  # 3- or 4-list
@@ -576,16 +583,22 @@ def _version_ints(vs):
     return tuple(_ints(vs))
 
 
+def _versions(sep=_SPACE_):
+    '''(INTERNAL) Get pygeodesy, PyPy and Python versions, bits, machine and OS as C{7- or 8-list} or C{str}.
+    '''
+    l7 = [_pygeodesy_, _MODS.version] + _Pythonarchine() + _osversion2()
+    return sep.join(l7) if sep else l7  # 5- or 6-list
+
+
 __all__ = tuple(map(_dunder_nameof, (machine, print_, printf)))
-__version__ = '24.07.04'
+__version__ = '24.08.01'
 
 if _dunder_ismain(__name__):  # PYCHOK no cover
 
-    from pygeodesy import _isfrozen, isLazy, version as vs
+    from pygeodesy import _isfrozen, isLazy
 
-    print_(_pygeodesy_, vs, *(_Pythonarchine() + _osversion2()
-                                               + ['_isfrozen', _isfrozen,
-                                                  'isLazy',     isLazy]))
+    print_(*(_versions(sep=NN) + ['_isfrozen', _isfrozen,
+                                  'isLazy',     isLazy]))
 
 # **) MIT License
 #

pygeodesy/karney.py

@@ -155,14 +155,14 @@ from pygeodesy.interns import NN, _2_, _a12_, _area_, _azi1_, _azi2_, _azi12_, \
 from pygeodesy.lazily import _ALL_DOCS, _ALL_LAZY, _ALL_MODS as _MODS, _getenv
 from pygeodesy.named import ADict, _NamedBase, _NamedTuple, notImplemented, _Pass
 from pygeodesy.props import deprecated_method, Property_RO, property_ROnce
-from pygeodesy.units import Bearing as _Azi, Degrees as _Deg, Lat, Lon, \
+from pygeodesy.units import Azimuth as _Azi, Degrees as _Deg, Lat, Lon, \
                             Meter as _M, Meter2 as _M2, Number_
 from pygeodesy.utily import atan2d, sincos2d, tand, _unrollon,  fabs
 
 # from math import fabs  # from .utily
 
 __all__ = _ALL_LAZY.karney
-__version__ = '24.07.16'
+__version__ = '24.07.25'
 
 _K_2_0      = _getenv('PYGEODESY_GEOGRAPHICLIB', _2_) == _2_
 _perimeter_ = 'perimeter'

pygeodesy/latlonBase.py

@@ -54,7 +54,7 @@ from contextlib import contextmanager
 from math import asin, cos, degrees, fabs, radians
 
 __all__ = _ALL_LAZY.latlonBase
-__version__ = '24.07.12'
+__version__ = '24.07.29'
 
 _formy = _MODS.into(formy=__name__)
 
@@ -1534,7 +1534,7 @@ class LatLonBase(_NamedBase):
 
            @kwarg form: The lat-/longitude C{B{form}at} to use (C{str}), see
                         functions L{pygeodesy.latDMS} or L{pygeodesy.lonDMS}.
-           @kwarg joined: Separator to join the lat-, longitude and heigth
+           @kwarg joined: Separator to join the lat-, longitude and height
                           strings (C{str} or C{None} or C{NN} for non-joined).
            @kwarg m: Optional unit of the height (C{str}), use C{None} to
                      exclude height from the returned string.

pygeodesy/lazily.py

@@ -31,8 +31,7 @@ from pygeodesy import internals as _internals, interns as _interns, \
                      _isfrozen  # DON'T _lazy_import2
 # from pygeodesy.errors import _error_init, _xkwds_item2  # _ALL_MODS
 from pygeodesy.internals import _caller3, _dunder_nameof, _dunder_ismain, \
-                                _headof, _osversion2, printf, _Pythonarchine, \
-                                _tailof  # _Property_RO
+                                _headof, printf, _Pythonarchine, _tailof  # _Property_RO
 from pygeodesy.interns import NN, _attribute_, _by_, _COLONSPACE_, _COMMASPACE_, \
                              _doesn_t_exist_, _DOT_, _EQUALSPACED_, _from_, \
                              _HASH_, _immutable_, _line_, _module_, _no_, _not_, \
@@ -290,7 +289,7 @@ _ALL_LAZY = _NamedEnum_RO(_name='_ALL_LAZY',
                       geodesicx=_i('gx', 'gxarea', 'gxbases', 'gxline',  # modules
                                    'GeodesicAreaExact', 'GeodesicExact', 'GeodesicLineExact', 'PolygonArea'),
                       geodsolve=_i('GeodesicSolve', 'GeodesicLineSolve', 'GeodSolve12Tuple'),
-                        geohash=_i('Geohash', 'GeohashError', 'Neighbors8Dict', 'Resolutions2Tuple'),
+                        geohash=_i('Geohash', 'Geohashed', 'GeohashError', 'Neighbors8Dict', 'Resolutions2Tuple', 'Sizes3Tuple'),
                          geoids=_i('GeoidError', 'GeoidG2012B', 'GeoidKarney', 'GeoidPGM', 'egmGeoidHeights',
                                    'PGMError', 'GeoidHeight5Tuple'),
                       hausdorff=_i('Hausdorff', 'HausdorffDegrees', 'HausdorffError', 'HausdorffRadians',
@@ -368,7 +367,7 @@ _ALL_LAZY = _NamedEnum_RO(_name='_ALL_LAZY',
                       triaxials=_i('BetaOmega2Tuple', 'BetaOmega3Tuple', 'Jacobi2Tuple',
                                    'JacobiConformal', 'JacobiConformalSpherical',
                                    'Triaxial', 'Triaxial_', 'TriaxialError', 'Triaxials', 'hartzell4'),
-                          units=_i('Band', 'Bearing', 'Bearing_', 'Bool',
+                          units=_i('Azimuth', 'Band', 'Bearing', 'Bearing_', 'Bool',
                                    'Degrees', 'Degrees_', 'Degrees2', 'Distance', 'Distance_', 'Easting', 'Epoch',
                                    'Feet', 'FIx', 'Float_', 'Height', 'Height_', 'HeightX', 'Int_',
                                    'Lam', 'Lamd', 'Lat', 'Lat_', 'Lon', 'Lon_',
@@ -522,7 +521,7 @@ class _ALL_MODS(_internals._MODS_Base):
 _internals._MODS = _ALL_MODS = _ALL_MODS()  # PYCHOK singleton
 
 __all__ = _ALL_LAZY.lazily
-__version__ = '24.07.18'
+__version__ = '24.08.01'
 
 
 def _ALL_OTHER(*objs):
@@ -862,13 +861,13 @@ def _lazy_module(name):  # overwritten by _lazy_import2
 #
 #     return _ALL_OTHER(*sm.values())
 
-
 # del _i, _i0
 
 # _ = _ALL_MODS.errors  # force import pygeodesy.errors
 
 if _dunder_ismain(__name__):  # PYCHOK no cover
 
+    from pygeodesy.internals import _versions
     from timeit import timeit
 
     def t1():
@@ -882,22 +881,24 @@ if _dunder_ismain(__name__):  # PYCHOK no cover
 
     t1 = timeit(t1, number=1000000)
     t2 = timeit(t2, number=1000000)
-    v = _SPACE_.join(_Pythonarchine() + _osversion2())
-    printf('%.6f import vs %.6f _ALL_MODS: %.2fX, %s', t1, t2, t1 / t2, v)
+    printf('%.6f import vs %.6f _ALL_MODS: %.2fX, %s', t1, t2, t1 / t2, _versions())
 
 #   del t1, t2, timeit, v
 
-# python3.12 -W ignore -m pygeodesy.lazily
-# 0.145177 import vs 0.075402 _ALL_MODS: 1.93X, Python 3.12.3 64bit arm64 macOS 14.4.1
+# % python3.13 -W ignore -m pygeodesy.lazily
+# 0.102670 import vs 0.076113 _ALL_MODS: 1.35X, pygeodesy 24.8.4 Python 3.13.0b4 64bit arm64 macOS 14.5
+
+# % python3.12 -W ignore -m pygeodesy.lazily
+# 0.132801 import vs 0.079125 _ALL_MODS: 1.68X, pygeodesy 24.8.4 Python 3.12.4 64bit arm64 macOS 14.5
 
-# python3.11 -W ignore -m pygeodesy.lazily
-# 0.381723 import vs 0.251589 _ALL_MODS: 1.52X, Python 3.11.5 64bit arm64 macOS 14.4.1
+# % python3.11 -W ignore -m pygeodesy.lazily
+# 0.381723 import vs 0.251589 _ALL_MODS: 1.52X, pygeodesy 24.8.4 Python 3.11.5 64bit arm64 macOS 14.4.1
 
-# python3.10 -W ignore -m pygeodesy.lazily
-# 0.378293 import vs 0.266507 _ALL_MODS: 1.42X, Python 3.10.8 64bit arm64 macOS 14.4.1
+# % python3.8 -W ignore -m pygeodesy.lazily
+# 0.570353 import vs 0.382842 _ALL_MODS: 1.49X, pygeodesy 24.8.4 Python 3.8.10 64bit arm64_x86_64 macOS 10.16
 
-# python2 -m pygeodesy.lazily
-# 1.213805 import vs 0.474075 _ALL_MODS: 2.56X, Python 2.7.18 64bit arm64_x86_64 macOS 10.16
+# % python2 -m pygeodesy.lazily
+# 1.213805 import vs 0.474075 _ALL_MODS: 2.56X, pygeodesy 24.8.4 Python 2.7.18 64bit arm64_x86_64 macOS 10.16
 
 # **) MIT License
 #

pygeodesy/ltp.py

@@ -44,7 +44,7 @@ from pygeodesy.vector3d import _ALL_LAZY, Vector3d
 # from math import fabs, floor as _floor  # from .fmath, .fsums
 
 __all__ = _ALL_LAZY.ltp
-__version__ = '24.07.12'
+__version__ = '24.07.25'
 
 _height0_ = _height_ + _0_
 _narrow_  = 'narrow'
@@ -730,7 +730,7 @@ class _ChLV(object):
         # assert _args_kwds_names( ChLV.reverse)[1:4] == t
         # assert _args_kwds_names(ChLVa.reverse)[1:4] == t
         # assert _args_kwds_names(ChLVe.reverse)[1:4] == t
-        return t  # overwrite propertyROver
+        return t  # overwrite property_ROver
 
     def forward(self, latlonh, lon=None, height=0, M=None, **name):  # PYCHOK no cover
         '''Convert WGS84 geodetic to I{Swiss} projection coordinates.  I{Must be overloaded}.

pygeodesy/ltpTuples.py

@@ -28,15 +28,15 @@ from pygeodesy.namedTuples import LatLon2Tuple, PhiLam2Tuple, Vector3Tuple
 from pygeodesy.props import deprecated_method, deprecated_Property_RO, \
                             Property_RO, property_RO
 from pygeodesy.streprs import Fmt, fstr, strs, _xzipairs
-from pygeodesy.units import Bearing, Degrees, Degrees_, Height, _isDegrees, \
-                           _isMeter, Lat, Lon, Meter, Meter_
+from pygeodesy.units import Azimuth, Bearing, Degrees, Degrees_, Height, \
+                           _isDegrees, _isMeter, Lat, Lon, Meter, Meter_
 from pygeodesy.utily import atan2d, atan2b, sincos2_, sincos2d_,  cos, radians
 from pygeodesy.vector3d import Vector3d
 
 # from math import cos, radians  # from .utily
 
 __all__ = _ALL_LAZY.ltpTuples
-__version__ = '24.06.28'
+__version__ = '24.07.25'
 
 _aer_        = 'aer'
 _alt_        = 'alt'
@@ -93,7 +93,7 @@ def _xyz2aer4(inst):
     '''(INTERNAL) Convert C{(x, y, z}) to C{(A, E, R)}.
     '''
     x, y, z, _ = inst.xyz4
-    A = Bearing(azimuth=atan2b(x, y))
+    A = Azimuth(atan2b(x, y))
     E = Degrees(elevation=atan2d(z, hypot(x, y)))
     R = Meter(slantrange=hypot_(x, y, z))
     return Aer4Tuple(A, E, R, inst.ltp, name=inst.name)
@@ -268,7 +268,7 @@ class Aer(_AbcBase):
         '''
         if _isDegrees(azimuth_aer):
             aer =  None
-            t   = (Bearing(azimuth=azimuth_aer),
+            t   = (Azimuth(azimuth_aer),
                    Degrees_(elevation=elevation, low=_N_90_0, high=_90_0),
                    Meter_(slantrange=slantrange), ltp)
         else:  # PYCHOK no cover
@@ -421,7 +421,7 @@ class Attitude4Tuple(_NamedTuple):
        the attitude of a plane or camera.
     '''
     _Names_ = (_alt_, _tilt_,  _yaw_,   _roll_)
-    _Units_ = ( Meter, Bearing, Degrees, Degrees)
+    _Units_ = ( Meter, Degrees, Bearing, Degrees)
 
     @Property_RO
     def atyr(self):

pygeodesy/triaxials.py

@@ -59,7 +59,7 @@ from pygeodesy.vector3d import _otherV3d, Vector3d,  _ALL_LAZY, _MODS
 from math import atan2, fabs, sqrt
 
 __all__ = _ALL_LAZY.triaxials
-__version__ = '24.07.12'
+__version__ = '24.07.29'
 
 _not_ordered_ = _not_('ordered')
 _omega_       = 'omega'
@@ -364,7 +364,7 @@ class Triaxial_(_NamedEnumItem):
     def _Elliptic(self):
         '''(INTERNAL) Get class L{Elliptic}, I{once}.
         '''
-        return _MODS.elliptic.Elliptic  # overwrite propertyROver
+        return _MODS.elliptic.Elliptic  # overwrite property_ROver
 
     def hartzell4(self, pov, los=False, **name):
         '''Compute the intersection of this triaxial's surface with a Line-Of-Sight
@@ -753,7 +753,7 @@ class Triaxial(Triaxial_):
         return self.height4(x_xyz, y, z, **normal_eps_name)
 
     def forwardLatLon(self, lat, lon, height=0, **name):
-        '''Convert I{geodetic} lat-, longitude and heigth to cartesian.
+        '''Convert I{geodetic} lat-, longitude and height to cartesian.
 
            @arg lat: Geodetic latitude (C{degrees}).
            @arg lon: Geodetic longitude (C{degrees}).
@@ -769,7 +769,7 @@ class Triaxial(Triaxial_):
         return self._forwardLatLon3(height, name, *sincos2d_(lat, lon))
 
     def forwardLatLon_(self, slat, clat, slon, clon, height=0, **name):
-        '''Convert I{geodetic} lat-, longitude and heigth to cartesian.
+        '''Convert I{geodetic} lat-, longitude and height to cartesian.
 
            @arg slat: Geodetic latitude C{sin(lat)} (C{scalar}).
            @arg clat: Geodetic latitude C{cos(lat)} (C{scalar}).

pygeodesy/units.py

@@ -11,11 +11,11 @@ from pygeodesy.constants import EPS, EPS1, PI, PI2, PI_2, _umod_360, _0_0, \
                                _0_001,  _0_5, INT0  # PYCHOK for .mgrs, .namedTuples
 from pygeodesy.dms import F__F, F__F_, S_NUL, S_SEP, parseDMS, parseRad, _toDMS
 from pygeodesy.errors import _AssertionError, TRFError, UnitError, _xattr, _xcallable
-from pygeodesy.interns import NN, _band_, _bearing_, _COMMASPACE_, _degrees_, \
-                             _degrees2_, _distance_, _E_, _easting_, _epoch_, _EW_, \
-                             _feet_, _height_, _lam_, _lat_, _LatLon_, _lon_, \
-                             _meter_, _meter2_, _N_, _negative_, _northing_, _NS_, \
-                             _NSEW_, _number_, _PERCENT_, _phi_, _precision_, \
+from pygeodesy.interns import NN, _azimuth_, _band_, _bearing_, _COMMASPACE_, \
+                             _degrees_, _degrees2_, _distance_, _E_, _easting_, \
+                             _epoch_, _EW_, _feet_, _height_, _lam_, _lat_, _LatLon_, \
+                             _lon_, _meter_, _meter2_, _N_, _negative_, _northing_, \
+                             _NS_, _NSEW_, _number_, _PERCENT_, _phi_, _precision_, \
                              _radians_, _radians2_, _radius_, _S_, _scalar_, \
                              _units_, _W_, _zone_,  _std_  # PYCHOK used!
 from pygeodesy.lazily import _ALL_DOCS, _ALL_LAZY, _ALL_MODS as _MODS, _getenv
@@ -24,10 +24,10 @@ from pygeodesy.props import Property_RO
 # from pygeodesy.streprs import Fmt, fstr  # from .unitsBase
 from pygeodesy.unitsBase import Float, Int, _NamedUnit, Radius, Str,  Fmt, fstr
 
-from math import degrees, radians
+from math import degrees, isnan, radians
 
 __all__ = _ALL_LAZY.units
-__version__ = '24.06.29'
+__version__ = '24.08.02'
 
 
 class Float_(Float):
@@ -339,18 +339,35 @@ class Radians2(Float_):
         return Float_.__new__(cls, arg=arg, name=name, low=_0_0, **Error_name_arg)
 
 
+def _Degrees_new(cls, **arg_name_suffix_clip_Error_name_arg):
+    d =  Degrees.__new__(cls, **arg_name_suffix_clip_Error_name_arg)
+    b = _umod_360(d)  # 0 <= b < 360
+    return d if b == d else Degrees.__new__(cls, arg=b, name=d.name)
+
+
+class Azimuth(Degrees):
+    '''Named C{float} representing an azimuth in compass C{degrees} from (true) North.
+    '''
+    _ddd_ =  1
+    _suf_ = _W_, S_NUL, _E_  # no zero suffix
+
+    def __new__(cls, arg=None, name=_azimuth_, **clip_Error_name_arg):
+        '''New, named L{Azimuth} with optional suffix 'E' for clockwise or 'W' for
+           anti-clockwise, see L{Degrees}.
+        '''
+        return _Degrees_new(cls, arg=arg, name=name, suffix=_EW_, **clip_Error_name_arg)
+
+
 class Bearing(Degrees):
     '''Named C{float} representing a bearing in compass C{degrees} from (true) North.
     '''
     _ddd_ =  1
     _suf_ = _N_ * 3  # always suffix N
 
-    def __new__(cls, arg=None, name=_bearing_, clip=0, **Error_name_arg):
+    def __new__(cls, arg=None, name=_bearing_, **clip_Error_name_arg):
         '''New, named L{Bearing}, see L{Degrees}.
         '''
-        d =  Degrees.__new__(cls, arg=arg, name=name, suffix=_N_, clip=clip, **Error_name_arg)
-        b = _umod_360(d)  # 0 <= b < 360
-        return d if b == d else Degrees.__new__(cls, arg=b, name=d.name)
+        return _Degrees_new(cls, arg=arg, name=name, suffix=_N_, **clip_Error_name_arg)
 
 
 class Bearing_(Radians):
@@ -782,7 +799,7 @@ class Zone(Int):
 
 
 _ScalarU =  Float, Float_, Scalar, Scalar_
-_Degrees = (Bearing, Bearing_, Degrees, Degrees_) + _ScalarU
+_Degrees = (Azimuth, Bearing, Bearing_, Degrees, Degrees_) + _ScalarU
 _Meters  = (Distance, Distance_, Meter, Meter_) + _ScalarU
 _Radians = (Radians, Radians_) + _ScalarU  # PYCHOK unused
 _Radii   = _Meters + (Radius, Radius_)
@@ -794,7 +811,7 @@ def _isDegrees(obj):
 
 
 def _isHeight(obj):
-    # Check for valid heigth types.
+    # Check for valid height types.
     return isinstance(obj, _Meters) or _isScalar(obj)
 
 
@@ -823,13 +840,13 @@ def _toUnit(Unit, arg, name=NN, **Error):
 
 
 def _xlimits(arg, low, high, g=False):
-    '''(INTERNAL) Check C{low <= unit <= high}.
+    '''(INTERNAL) Check C{low <= arg <= high}.
     '''
-    if (low is not None) and arg < low:
+    if (low is not None) and (arg < low or isnan(arg)):
         if g:
             low = Fmt.g(low, prec=6, ints=isinstance(arg, Epoch))
         t = Fmt.limit(below=low)
-    elif (high is not None) and arg > high:
+    elif (high is not None) and (arg > high or isnan(arg)):
         if g:
             high = Fmt.g(high, prec=6, ints=isinstance(arg, Epoch))
         t = Fmt.limit(above=high)
@@ -847,7 +864,7 @@ def _std_repr(*Classes):
             if _getenv(env, _std_).lower() != _std_:
                 C._std_repr = False
 
-_std_repr(Bearing, Bool, Degrees, Float, Int, Meter, Radians, Str)  # PYCHOK expected
+_std_repr(Azimuth, Bearing, Bool, Degrees, Float, Int, Meter, Radians, Str)  # PYCHOK expected
 del _std_repr
 
 __all__ += _ALL_DOCS(_NamedUnit)