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

pygeodesy/errors.py

@@ -14,19 +14,20 @@ C{PYGEODESY_EXCEPTION_CHAINING=std} or to any non-empty string.
 # from pygeodesy.basics import isint, isodd, issubclassof, itemsorted, _xinstanceof, _zip  # _MODS
 # from pygeodesy.ellipsoidalBase import CartesianEllipsoidalBase, LatLonEllipsoidalBase  # _MODS
 # from pygeodesy import errors  # _MODS, _MODS.getattr
-from pygeodesy.internals import _plural, _tailof
+from pygeodesy.internals import _dunder_nameof_, _plural, _tailof
 from pygeodesy.interns import MISSING, NN, _a_, _an_, _and_, _clip_, _COLON_, _COLONSPACE_, \
                              _COMMASPACE_, _datum_, _ellipsoidal_, _incompatible_, _invalid_, \
-                             _keyword_, _len_, _not_, _or_, _SPACE_, _specified_, _UNDER_, \
-                             _vs_, _with_
+                             _keyword_, _LatLon_, _len_, _not_, _or_, _SPACE_, _specified_, \
+                             _UNDER_, _vs_, _with_
 from pygeodesy.lazily import _ALL_LAZY, _ALL_MODS as _MODS, _getenv, _PYTHON_X_DEV
-# from pygeodesy.streprs import Fmt, unstr  # _MODS
+# from pygeodesy import streprs as _streprs  # _MODS
+# from pygeodesy.unitsBase import Str  # _MODS
 # from pygeodesy.vector3dBase import Vector3dBase  # _MODS
 
 from copy import copy as _copy
 
 __all__ = _ALL_LAZY.errors  # _ALL_DOCS('_InvalidError', '_IsnotError')  _under
-__version__ = '24.06.08'
+__version__ = '24.07.07'
 
 _argument_   = 'argument'
 _box_        = 'box'
@@ -35,6 +36,7 @@ _limiterrors =  True  # in .formy
 _name_value_ =  repr('name=value')
 _rangerrors  =  True  # in .dms
 _region_     = 'region'
+_streprs     = _MODS.into(streprs=__name__)
 _vs__        = _SPACE_(NN, _vs_, NN)
 
 try:
@@ -155,7 +157,7 @@ class _UnexpectedError(TypeError):  # note, a TypeError!
             n = _and(a, _plural(_keyword_, n)) if n else a
         else:
             n = _plural(_SPACE_(_keyword_, _argument_), n)
-        u = _MODS.streprs.unstr(_SPACE_(n, NN), *args, **kwds)
+        u = _streprs.unstr(_SPACE_(n, NN), *args, **kwds)
         # _error_init(TypeError, self, (u,), txt_not_=_expected_)
         TypeError.__init__(self, _SPACE_(u, _not_, _expected_))
 
@@ -208,8 +210,8 @@ class CrossError(_ValueError):
 
 
 class GeodesicError(_ValueError):
-    '''Error raised for lack of convergence or other issues in L{pygeodesy.geodesicx},
-       L{pygeodesy.geodesicw} or L{pygeodesy.karney}.
+    '''Error raised for convergence or other issues in L{geodesicx<pygeodesy.geodesicx>},
+       L{geodesicw<pygeodesy.geodesicw>} or L{karney<pygeodesy.karney>}.
     '''
     pass
 
@@ -243,17 +245,17 @@ class LenError(_ValueError):  # in .ecef, .fmath, .heights, .iters, .named
 
         ns, vs, txt, x = _ns_vs_txt_x(**lens_txt)
         ns = _COMMASPACE_.join(ns)
-        t  = _MODS.streprs.Fmt.PAREN(where.__name__, ns)
+        t  = _streprs.Fmt.PAREN(where.__name__, ns)
         vs = _vs__.join(map(str, vs))
         t  = _SPACE_(t, _len_, vs)
         _ValueError.__init__(self, t, txt=txt, cause=x)
 
 
 class LimitError(_ValueError):
-    '''Error raised for lat- or longitudinal values or deltas exceeding
-       the given B{C{limit}} in functions L{pygeodesy.equirectangular},
-       L{pygeodesy.equirectangular4}, C{nearestOn*} and C{simplify*}
-       or methods with C{limit} or C{options} keyword arguments.
+    '''Error raised for lat- or longitudinal values or deltas exceeding the given
+       B{C{limit}} in functions L{equirectangular<pygeodesy.equirectangular>},
+       L{equirectangular4<pygeodesy.equirectangular4>}, C{nearestOn*} and
+       C{simplify*} or methods with C{limit} or C{options} keyword arguments.
 
        @see: Subclass L{UnitError}.
     '''
@@ -285,26 +287,25 @@ class PointsError(_ValueError):  # in .clipy, .frechet, ...
 
 
 class RangeError(_ValueError):
-    '''Error raised for lat- or longitude values outside the B{C{clip}},
-       B{C{clipLat}}, B{C{clipLon}} in functions L{pygeodesy.parse3llh},
-       L{pygeodesy.parseDMS}, L{pygeodesy.parseDMS2} and L{pygeodesy.parseRad}
-       or the given B{C{limit}} in functions L{pygeodesy.clipDegrees} and
-       L{pygeodesy.clipRadians}.
+    '''Error raised for lat- or longitude values outside the B{C{clip}}, B{C{clipLat}},
+       B{C{clipLon}} in functions L{parse3llh<pygeodesy.dms.parse3llh>}, L{parseDMS<pygeodesy.dms.parseDMS>},
+       L{parseDMS2<pygeodesy.dms.parseDMS2>} and L{parseRad<pygeodesy.dms.parseRad>} or the B{C{limit}} set
+       with functions L{clipDegrees<pygeodesy.dms.clipDegrees>} and L{clipRadians<pygeodesy.dms.clipRadians>}.
 
-       @see: Function L{pygeodesy.rangerrors}.
+       @see: Function L{rangerrors<pygeodesy.errors.rangerrors>}.
     '''
     pass
 
 
 class RhumbError(_ValueError):
-    '''Error raised for a L{pygeodesy.rhumb.aux_}, L{pygeodesy.rhumb.ekx}
-       or L{pygeodesy.rhumb.solve} issue.
+    '''Error raised for a rhumb L{aux_<pygeodesy.rhumb.aux_>}, L{ekx<pygeodesy.rhumb.ekx>} or
+       L{solve<pygeodesy.rhumb.solve>} issue.
     '''
     pass
 
 
 class TriangleError(_ValueError):  # in .resections, .vector2d
-    '''Error raised for triangle, inter- or resection issues.
+    '''Error raised for triangle, intersection or resection issues.
     '''
     pass
 
@@ -330,15 +331,15 @@ class SciPyWarning(PointsError):
 
 
 class TRFError(_ValueError):  # in .ellipsoidalBase, .trf, .units
-    '''Terrestrial Reference Frame (TRF), L{Epoch}, L{RefFrame}
-       or L{RefFrame} conversion issue.
+    '''Terrestrial Reference Frame (TRF), L{Epoch}, L{RefFrame} or L{RefFrame}
+       conversion issue.
     '''
     pass
 
 
 class UnitError(LimitError):  # in .named, .units
-    '''Default exception for L{units} issues for a value exceeding the
-       C{low} or C{high} limit.
+    '''Default exception for L{units} issues for a value exceeding the C{low}
+       or C{high} limit.
     '''
     pass
 
@@ -460,8 +461,8 @@ def exception_chaining(exc=None):
        @return: If C{B{exc} is None}, return C{True} if exception
                 chaining is enabled for PyGeodesy errors, C{False}
                 if turned off and C{None} if not available.  If
-                B{C{exc}} is not C{None}, return it's error I{cause}
-                or C{None}.
+                C{B{exc} is not None}, return it's error I{cause}
+                or C{None} if there is none.
 
        @note: To enable exception chaining for C{pygeodesy} errors,
               set env var C{PYGEODESY_EXCEPTION_CHAINING} to any
@@ -511,23 +512,22 @@ def isError(exc):
           _X(exc) if isinstance(exc,  Exception) else None)
 
 
-def _IsnotError(*nouns, **name_value_Error_cause):  # name=value [, Error=TypeError, cause=None]
+def _IsnotError(*types__, **name_value_Error_cause):  # name=value [, Error=TypeError, cause=None]
     '''Create a C{TypeError} for an invalid C{name=value} type.
 
-       @arg nouns: One or more expected class or type names, usually nouns (C{str}).
+       @arg types__: One or more types or type names.
        @kwarg name_value_Error_cause: One C{B{name}=value} pair and optionally,
-                   keyword argument C{B{Error}=TypeError} to override the default
-                   and C{B{cause}=None} for exception chaining.
+                   keyword arguments C{B{Error}=TypeError} and C{B{cause}=None}
+                   for exception chaining.
 
        @return: A C{TypeError} or an B{C{Error}} instance.
     '''
-    def _n_v_E_x(cause=None, Error=TypeError, **name_value):
-        return _xkwds_item2(name_value) + (Error, cause)
+    x, kwds = _xkwds_pop2(name_value_Error_cause, cause=None)
+    E, kwds = _xkwds_pop2(kwds, Error=TypeError)
+    n, v    = _xkwds_item2(kwds)
 
-    n, v, E, x = _n_v_E_x(**name_value_Error_cause)
-
-    n = _MODS.streprs.Fmt.PARENSPACED(n, repr(v))
-    t = _not_(_an(_or(*nouns)) if nouns else _specified_)
+    n = _streprs.Fmt.PARENSPACED(n, repr(v))
+    t = _not_(_an(_or(*_dunder_nameof_(*types__))) if types__ else _specified_)
     return _XError(E, n, txt=t, cause=x)
 
 
@@ -553,14 +553,13 @@ def _or(*words):
     return _and_or(_or_, *words)
 
 
-def _parseX(parser, *args, **name_values_Error):  # name=value[, ..., Error=ParseError]
+def _parseX(parser, *args, **Error_name_values):  # name=value[, ..., Error=ParseError]
     '''(INTERNAL) Invoke a parser and handle exceptions.
 
-       @arg parser: The parser (C{callable}).
+       @arg parser: The parser (C{callable(*B{args}}).
        @arg args: Any B{C{parser}} arguments (any C{type}s).
-       @kwarg name_values_Error: Any C{B{name}=value} pairs and
-                   optionally, C{B{Error}=ParseError} keyword
-                   argument to override the default.
+       @kwarg Error_name_values: Optional C{B{Error}=ParseError}
+                    and number of C{B{name}=value} pairs.
 
        @return: Parser result.
 
@@ -570,7 +569,7 @@ def _parseX(parser, *args, **name_values_Error):  # name=value[, ..., Error=Pars
         return parser(*args)
     except Exception as x:
         E = type(x) if isError(x) else ParseError
-        E, kwds = _xkwds_pop2(name_values_Error, Error=E)
+        E, kwds = _xkwds_pop2(Error_name_values, Error=E)
         raise _XError(E, **_xkwds(kwds, cause=x))
 
 
@@ -603,11 +602,11 @@ def _xAssertionError(where, *args, **kwds):
     '''(INTERNAL) Embellish an C{AssertionError} with/-out exception chaining.
     '''
     x, kwds = _xkwds_pop2(kwds, cause=None)
-    w = _MODS.streprs.unstr(where, *args, **kwds)
+    w = _streprs.unstr(where, *args, **kwds)
     return _AssertionError(w, txt=None, cause=x)
 
 
-def _xattr(obj, **name_default):  # see .strerprs._xattrs
+def _xattr(obj, **name_default):
     '''(INTERNAL) Get an C{obj}'s attribute by C{name}.
     '''
     if len(name_default) == 1:
@@ -616,6 +615,34 @@ def _xattr(obj, **name_default):  # see .strerprs._xattrs
     raise _xAssertionError(_xattr, obj, **name_default)
 
 
+def _xattrs(inst, other, *attrs):  # see .errors._xattr
+    '''(INTERNAL) Copy attribute values from B{C{other}} to B{C{inst}}.
+
+       @arg inst: Object to copy attribute values to (any C{type}).
+       @arg other: Object to copy attribute values from (any C{type}).
+       @arg attrs: One or more attribute names (C{str}s).
+
+       @return: Object B{C{inst}}, updated.
+
+       @raise AttributeError: An B{C{attrs}} doesn't exist or isn't settable.
+    '''
+    def _getattr(o, a):
+        if hasattr(o, a):
+            return getattr(o, a)
+        try:
+            n =  o._DOT_(a)
+        except AttributeError:
+            n = _streprs.Fmt.DOT(a)
+        raise _AttributeError(o, name=n)
+
+    for a in attrs:
+        s = _getattr(other, a)
+        g = _getattr(inst, a)
+        if (g is None and s is not None) or g != s:
+            setattr(inst, a, s)  # not settable?
+    return inst
+
+
 def _xcallable(**names_callables):
     '''(INTERNAL) Check one or more C{callable}s.
     '''
@@ -651,9 +678,9 @@ def _xellipsoidal(**name_value):  # see _xellipsoidall elel
     raise _xAssertionError(_xellipsoidal, name_value)
 
 
-def _xellipsoidall(point):  # see _xellipsoidal
+def _xellipsoidall(point):  # ... elel, see _xellipsoidal
     '''(INTERNAL) Check an ellipsoidal C{point}, return C{True}
-       if geodetic latlon or C{False} if cartesian.
+       if geodetic latlon, C{False} if cartesian or TypeError.
     '''
     m = _MODS.ellipsoidalBase
     ll = isinstance(point, m.LatLonEllipsoidalBase)
@@ -664,6 +691,14 @@ def _xellipsoidall(point):  # see _xellipsoidal
     return ll
 
 
+def _xellipsoids(E1, E2, Error=_ValueError):  # see .ellipsoidalBase
+    '''(INTERNAL) Check ellipsoid mis-match, E2 vs E1.
+    '''
+    if E2 != E1:
+        raise Error(E2.named2, txt=_incompatible(E1.named2))
+    return E1
+
+
 def _XError(Error, *args, **kwds):
     '''(INTERNAL) Format an C{Error} or C{_Error}.
     '''
@@ -711,6 +746,15 @@ _XErrors = (_AssertionError, _AttributeError,  # some isError's
 # _X2Error = {AssertionError:    _AssertionError, ...
 #             ZeroDivisionError: _ZeroDivisionError}
 
+
+def _xgeodesics(G1, G2, Error=_ValueError):  # see .geodesici
+    '''(INTERNAL) Check geodesics mis-match.
+    '''
+    if G1.ellipsoid != G2.ellipsoid:
+        raise Error(G1.named2, txt=_incompatible(G2.named2))
+    return G1
+
+
 try:
     _ = {}.__or__  # {} | {}  # Python 3.9+
 
@@ -783,6 +827,15 @@ def _xkwds_item2(kwds):
     raise _xAssertionError(_xkwds_item2, kwds)
 
 
+def _xkwds_kwds(kwds, **names_defaults):
+    '''(INTERNAL) Return a C{dict} of C{named_defaults} items replaced with C{kwds}.
+    '''
+    if not isinstance(kwds, dict):
+        raise _xAssertionError(_xkwds_get_, kwds)
+    _g = kwds.get
+    return dict((n, _g(n, v)) for n, v in names_defaults.items())
+
+
 def _xkwds_not(*args, **kwds):
     '''(INTERNAL) Return C{kwds} with a value not in C{args}.
     '''
@@ -811,6 +864,14 @@ def _Xorder(_Coeffs, Error, **Xorder):  # in .auxLat, .ktm, .rhumb.bases, .rhumb
     t = sorted(map(str, _Coeffs.keys()))
     raise Error(X, m, txt_not_=_or(*t))
 
+
+def _xStrError(*Refs, **name_value_Error):  # in .gars, .geohash, .wgrs
+    '''(INTERNAL) Create a C{TypeError} for C{Garef}, C{Geohash}, C{Wgrs}.
+    '''
+    S = _MODS.unitsBase.Str
+    r =  tuple(r.__name__ for r in Refs) + (S.__name__, _LatLon_, 'LatLon*Tuple')
+    return _IsnotError(*r, **name_value_Error)
+
 # **) MIT License
 #
 # Copyright (C) 2016-2024 -- mrJean1 at Gmail -- All Rights Reserved.

pygeodesy/etm.py

@@ -92,7 +92,7 @@ from pygeodesy.utm import _cmlon, _LLEB, _parseUTM5, _toBand, _toXtm8, \
 from math import asinh, atan2, degrees, radians, sinh, sqrt
 
 __all__ = _ALL_LAZY.etm
-__version__ = '24.05.31'
+__version__ = '24.06.11'
 
 _OVERFLOW = _1_EPS**2  # about 2e+31
 _TAYTOL   =  pow(EPS, 0.6)
@@ -176,18 +176,15 @@ class Etm(Utm):
     def toLatLon(self, LatLon=None, unfalse=True, **unused):  # PYCHOK expected
         '''Convert this ETM coordinate to an (ellipsoidal) geodetic point.
 
-           @kwarg LatLon: Optional, ellipsoidal class to return the geodetic
-                          point (C{LatLon}) or C{None}.
-           @kwarg unfalse: Unfalse B{C{easting}} and B{C{northing}} if
-                           C{falsed} (C{bool}).
+           @kwarg LatLon: Optional, ellipsoidal class to return the geodetic point
+                          (C{LatLon}) or C{None}.
+           @kwarg unfalse: Unfalse B{C{easting}} and B{C{northing}} if C{falsed} (C{bool}).
 
-           @return: This ETM coordinate as (B{C{LatLon}}) or a
-                    L{LatLonDatum5Tuple}C{(lat, lon, datum, gamma,
-                    scale)} if B{C{LatLon}} is C{None}.
+           @return: This ETM coordinate as (B{C{LatLon}}) or if C{B{LatLon} is None},
+                    a L{LatLonDatum5Tuple}C{(lat, lon, datum, gamma, scale)}.
 
-           @raise ETMError: This ETM coordinate's C{exacTM} and this C{datum}
-                            incompatible or no convergence transforming to
-                            lat- and longitude.
+           @raise ETMError: This ETM coordinate's C{exacTM} and this C{datum} are not
+                            compatible or no convergence transforming to lat-/longitude.
 
            @raise TypeError: Invalid or non-ellipsoidal B{C{LatLon}}.
         '''
@@ -1040,10 +1037,9 @@ def parseETM5(strUTM, datum=_WGS84, Etm=Etm, falsed=True, **name):
        @kwarg falsed: Both easting and northing are C{falsed} (C{bool}).
        @kwarg name: Optional B{C{Etm}} C{B{name}=NN} (C{str}).
 
-       @return: The UTM coordinate (B{C{Etm}}) or if B{C{Etm}} is
-                C{None}, a L{UtmUps5Tuple}C{(zone, hemipole, easting,
-                northing, band)}.  The C{hemipole} is the hemisphere
-                C{'N'|'S'}.
+       @return: The UTM coordinate (B{C{Etm}}) or if C{B{Etm} is None}, a
+                L{UtmUps5Tuple}C{(zone, hemipole, easting, northing, band)}
+                with C{hemipole} is the hemisphere C{'N'|'S'}.
 
        @raise ETMError: Invalid B{C{strUTM}}.
 
@@ -1057,44 +1053,36 @@ def toEtm8(latlon, lon=None, datum=None, Etm=Etm, falsed=True,
                              strict=True, zone=None, **name_cmoff):
     '''Convert a geodetic lat-/longitude to an ETM coordinate.
 
-       @arg latlon: Latitude (C{degrees}) or an (ellipsoidal)
-                    geodetic C{LatLon} instance.
-       @kwarg lon: Optional longitude (C{degrees}), required
-                   if B{C{latlon}} is in C{degrees}.
-       @kwarg datum: Optional datum for the ETM coordinate,
-                     overriding B{C{latlon}}'s datum (L{Datum},
-                     L{Ellipsoid}, L{Ellipsoid2} or L{a_f2Tuple}).
-       @kwarg Etm: Optional class to return the ETM coordinate
-                   (L{Etm}) or C{None}.
+       @arg latlon: Latitude (C{degrees}) or an (ellipsoidal) geodetic
+                    C{LatLon} instance.
+       @kwarg lon: Optional longitude (C{degrees}), required if B{C{latlon}}
+                   is C{degrees}, ignored otherwise.
+       @kwarg datum: Optional datum for the ETM coordinate, overriding
+                     B{C{latlon}}'s datum (L{Datum}, L{Ellipsoid},
+                     L{Ellipsoid2} or L{a_f2Tuple}).
+       @kwarg Etm: Optional class to return the ETM coordinate (L{Etm}) or C{None}.
        @kwarg falsed: False both easting and northing (C{bool}).
        @kwarg strict: Restrict B{C{lat}} to UTM ranges (C{bool}).
        @kwarg zone: Optional UTM zone to enforce (C{int} or C{str}).
-       @kwarg name_cmoff: Optional B{C{Etm}} C{B{name}=NN} (C{str})
-                   and DEPRECATED keyword argument C{B{cmoff}=True}
-                   to offset the longitude from the zone's central
-                   meridian (C{bool}), use B{C{falsed}} instead.
+       @kwarg name_cmoff: Optional B{C{Etm}} C{B{name}=NN} (C{str}) and DEPRECATED
+                   keyword argument C{B{cmoff}=True} to offset the longitude from
+                   the zone's central meridian (C{bool}), use B{C{falsed}} instead.
 
-       @return: The ETM coordinate as an B{C{Etm}} instance or a
-                L{UtmUps8Tuple}C{(zone, hemipole, easting, northing,
-                band, datum, gamma, scale)} if B{C{Etm}} is C{None}
-                or not B{C{falsed}}.  The C{hemipole} is the C{'N'|'S'}
-                hemisphere.
+       @return: The ETM coordinate as B{C{Etm}} or if C{B{Etm} is None} or not B{C{falsed}},
+                a L{UtmUps8Tuple}C{(zone, hemipole, easting, northing, band, datum, gamma,
+                scale)}.  The C{hemipole} is the C{'N'|'S'} hemisphere.
 
-       @raise ETMError: No convergence transforming to ETM easting
-                        and northing.
+       @raise ETMError: No convergence transforming to ETM easting and northing.
 
-       @raise ETMError: Invalid B{C{zone}} or near-spherical or
-                        incompatible B{C{datum}} or C{ellipsoid}.
+       @raise ETMError: Invalid B{C{zone}} or near-spherical or incompatible B{C{datum}}
+                        or C{ellipsoid}.
 
-       @raise RangeError: If B{C{lat}} outside the valid UTM bands or
-                          if B{C{lat}} or B{C{lon}} outside the valid
-                          range and L{pygeodesy.rangerrors} set to C{True}.
+       @raise RangeError: If B{C{lat}} outside the valid UTM bands or if B{C{lat}} or B{C{lon}}
+                          outside the valid range and L{rangerrors<pygeodesy.rangerrors>} is C{True}.
 
-       @raise TypeError: Invalid or near-spherical B{C{datum}} or
-                         B{C{latlon}} not ellipsoidal.
+       @raise TypeError: Invalid or near-spherical B{C{datum}} or B{C{latlon}} not ellipsoidal.
 
-       @raise ValueError: The B{C{lon}} value is missing or B{C{latlon}}
-                          is invalid.
+       @raise ValueError: The B{C{lon}} value is missing or B{C{latlon}} is invalid.
     '''
     z, B, lat, lon, d, f, n = _to7zBlldfn(latlon, lon, datum,
                                           falsed, zone, strict,

pygeodesy/formy.py

@@ -29,7 +29,7 @@ from pygeodesy.namedTuples import Bearing2Tuple, Distance4Tuple, LatLon2Tuple, \
 # from pygeodesy.streprs import Fmt, unstr  # from .fsums
 # from pygeodesy.triaxials import _hartzell3  # _MODS
 from pygeodesy.units import _isHeight, _isRadius, Bearing, Degrees_, Distance, \
-                             Distance_, Height, Lam_, Lat, Lon, Meter_,  Phi_, \
+                             Distance_, Height, Lamd, Lat, Lon, Meter_,  Phid, \
                              Radians, Radians_, Radius, Radius_, Scalar, _100km
 from pygeodesy.utily import acos1, atan2b, atan2d, degrees2m, _loneg, m2degrees, \
                             tan_2, sincos2, sincos2_, sincos2d_, _Wrap
@@ -42,7 +42,7 @@ from contextlib import contextmanager
 from math import asin, atan, atan2, cos, degrees, fabs, radians, sin, sqrt  # pow
 
 __all__ = _ALL_LAZY.formy
-__version__ = '24.05.28'
+__version__ = '24.06.15'
 
 _RADIANS2 = (PI / _180_0)**2  # degrees- to radians-squared
 _ratio_   = 'ratio'
@@ -62,8 +62,8 @@ def _anti2(a, b, n_2, n, n2):
 
 
 def antipode(lat, lon, **name):
-    '''Return the antipode, the point diametrically opposite
-       to a given point in C{degrees}.
+    '''Return the antipode, the point diametrically opposite to a given
+       point in C{degrees}.
 
        @arg lat: Latitude (C{degrees}).
        @arg lon: Longitude (C{degrees}).
@@ -78,8 +78,8 @@ def antipode(lat, lon, **name):
 
 
 def antipode_(phi, lam, **name):
-    '''Return the antipode, the point diametrically opposite
-       to a given point in C{radians}.
+    '''Return the antipode, the point diametrically opposite to a given
+       point in C{radians}.
 
        @arg phi: Latitude (C{radians}).
        @arg lam: Longitude (C{radians}).
@@ -94,8 +94,8 @@ def antipode_(phi, lam, **name):
 
 
 def bearing(lat1, lon1, lat2, lon2, **final_wrap):
-    '''Compute the initial or final bearing (forward or reverse
-       azimuth) between a (spherical) start and end point.
+    '''Compute the initial or final bearing (forward or reverse azimuth)
+       between two (spherical) points.
 
        @arg lat1: Start latitude (C{degrees}).
        @arg lon1: Start longitude (C{degrees}).
@@ -104,33 +104,33 @@ def bearing(lat1, lon1, lat2, lon2, **final_wrap):
        @kwarg final_wrap: Optional keyword arguments for function
                           L{pygeodesy.bearing_}.
 
-       @return: Initial or final bearing (compass C{degrees360}) or
-                zero if start and end point coincide.
+       @return: Initial or final bearing (compass C{degrees360}) or zero if
+                both points coincide.
     '''
-    r = bearing_(Phi_(lat1=lat1), Lam_(lon1=lon1),
-                 Phi_(lat2=lat2), Lam_(lon2=lon2), **final_wrap)
+    r = bearing_(Phid(lat1=lat1), Lamd(lon1=lon1),
+                 Phid(lat2=lat2), Lamd(lon2=lon2), **final_wrap)
     return degrees(r)
 
 
 def bearing_(phi1, lam1, phi2, lam2, final=False, wrap=False):
-    '''Compute the initial or final bearing (forward or reverse azimuth)
-       between a (spherical) start and end point.
+    '''Compute the initial or final bearing (forward or reverse azimuth) between
+       two (spherical) points.
 
        @arg phi1: Start latitude (C{radians}).
        @arg lam1: Start longitude (C{radians}).
        @arg phi2: End latitude (C{radians}).
        @arg lam2: End longitude (C{radians}).
-       @kwarg final: If C{True}, return the final, otherwise the initial
-                     bearing (C{bool}).
-       @kwarg wrap: If C{True}, wrap or I{normalize} and unroll B{C{phi2}}
-                    and B{C{lam2}} (C{bool}).
+       @kwarg final: If C{True}, return the final, otherwise the initial bearing
+                     (C{bool}).
+       @kwarg wrap: If C{True}, wrap or I{normalize} and unroll B{C{phi2}} and
+                    B{C{lam2}} (C{bool}).
 
-       @return: Initial or final bearing (compass C{radiansPI2}) or zero if
-                start and end point coincide.
+       @return: Initial or final bearing (compass C{radiansPI2}) or zero if both
+                are coincident.
 
-       @see: U{Bearing<https://www.Movable-Type.co.UK/scripts/latlong.html>},
-             U{Course between two points<https://www.EdWilliams.org/avform147.htm#Crs>}
-             and U{Bearing Between Two Points<https://web.Archive.org/web/20020630205931/
+       @see: U{Bearing<https://www.Movable-Type.co.UK/scripts/latlong.html>}, U{Course
+             between two points<https://www.EdWilliams.org/avform147.htm#Crs>} and
+             U{Bearing Between Two Points<https://web.Archive.org/web/20020630205931/
              https://MathForum.org/library/drmath/view/55417.html>}.
     '''
     db, phi2, lam2 = _Wrap.philam3(lam1, phi2, lam2, wrap)
@@ -198,13 +198,13 @@ def cosineAndoyerLambert(lat1, lon1, lat2, lon2, datum=_WGS84, wrap=False):
        @arg lon1: Start longitude (C{degrees}).
        @arg lat2: End latitude (C{degrees}).
        @arg lon2: End longitude (C{degrees}).
-       @kwarg datum: Datum (L{Datum}) or ellipsoid (L{Ellipsoid},
-                     L{Ellipsoid2} or L{a_f2Tuple}) to use.
-       @kwarg wrap: If C{True}, wrap or I{normalize} and unroll
-                    B{C{lat2}} and B{C{lon2}} (C{bool}).
+       @kwarg datum: Datum (L{Datum}) or ellipsoid (L{Ellipsoid}, L{Ellipsoid2} or
+                     L{a_f2Tuple}) to use.
+       @kwarg wrap: If C{True}, wrap or I{normalize} and unroll B{C{lat2}} and
+                    B{C{lon2}} (C{bool}).
 
-       @return: Distance (C{meter}, same units as the B{C{datum}}'s
-                ellipsoid axes or C{radians} if B{C{datum}} is C{None}).
+       @return: Distance (C{meter}, same units as the B{C{datum}}'s ellipsoid axes or
+                C{radians} if C{B{datum} is None}).
 
        @raise TypeError: Invalid B{C{datum}}.
 
@@ -224,8 +224,8 @@ def cosineAndoyerLambert_(phi2, phi1, lam21, datum=_WGS84):
        @arg phi2: End latitude (C{radians}).
        @arg phi1: Start latitude (C{radians}).
        @arg lam21: Longitudinal delta, M{end-start} (C{radians}).
-       @kwarg datum: Datum (L{Datum}) or ellipsoid (L{Ellipsoid},
-                     L{Ellipsoid2} or L{a_f2Tuple}) to use.
+       @kwarg datum: Datum (L{Datum}) or ellipsoid (L{Ellipsoid}, L{Ellipsoid2} or
+                     L{a_f2Tuple}) to use.
 
        @return: Angular distance (C{radians}).
 
@@ -263,13 +263,13 @@ def cosineForsytheAndoyerLambert(lat1, lon1, lat2, lon2, datum=_WGS84, wrap=Fals
        @arg lon1: Start longitude (C{degrees}).
        @arg lat2: End latitude (C{degrees}).
        @arg lon2: End longitude (C{degrees}).
-       @kwarg datum: Datum (L{Datum}) or ellipsoid (L{Ellipsoid},
-                     L{Ellipsoid2} or L{a_f2Tuple}) to use.
-       @kwarg wrap: If C{True}, wrap or I{normalize} and unroll
-                    B{C{lat2}} and B{C{lon2}} (C{bool}).
+       @kwarg datum: Datum (L{Datum}) or ellipsoid (L{Ellipsoid}, L{Ellipsoid2} or
+                     L{a_f2Tuple}) to use.
+       @kwarg wrap: If C{True}, wrap or I{normalize} and unroll B{C{lat2}} and
+                    B{C{lon2}} (C{bool}).
 
-       @return: Distance (C{meter}, same units as the B{C{datum}}'s
-                ellipsoid axes or C{radians} if B{C{datum}} is C{None}).
+       @return: Distance (C{meter}, same units as the B{C{datum}}'s ellipsoid axes or
+                C{radians} if C{B{datum} is None}).
 
        @raise TypeError: Invalid B{C{datum}}.
 
@@ -380,9 +380,9 @@ def _d3(wrap, lat1, lon1, lat2, lon2):
     '''
     if wrap:
         d_lon, lat2, _ = _Wrap.latlon3(lon1, lat2, lon2, wrap)
-        return radians(lat2), Phi_(lat1=lat1), radians(d_lon)
+        return radians(lat2), Phid(lat1=lat1), radians(d_lon)
     else:  # for backward compaibility
-        return Phi_(lat2=lat2), Phi_(lat1=lat1), Phi_(d_lon=lon2 - lon1)
+        return Phid(lat2=lat2), Phid(lat1=lat1), Phid(d_lon=lon2 - lon1)
 
 
 def _dE(func_, earth, *wrap_lls):
@@ -458,34 +458,31 @@ def equirectangular4(lat1, lon1, lat2, lon2, adjust=True, limit=45, wrap=False):
     '''Compute the distance between two points using the U{Equirectangular Approximation
        / Projection<https://www.Movable-Type.co.UK/scripts/latlong.html#equirectangular>}.
 
-       This approximation is valid for short distance of several hundred Km
-       or Miles, see the B{C{limit}} keyword argument and L{LimitError}.
+       This approximation is valid for short distance of several hundred Km or Miles, see
+       the B{C{limit}} keyword argument and L{LimitError}.
 
        @arg lat1: Start latitude (C{degrees}).
        @arg lon1: Start longitude (C{degrees}).
        @arg lat2: End latitude (C{degrees}).
        @arg lon2: End longitude (C{degrees}).
-       @kwarg adjust: Adjust the wrapped, unrolled longitudinal delta by the cosine
-                      of the mean latitude (C{bool}).
-       @kwarg limit: Optional limit for lat- and longitudinal deltas (C{degrees}) or
-                     C{None} or C{0} for unlimited.
-       @kwarg wrap: If C{True}, wrap or I{normalize} and unroll B{C{lat2}} and
-                    B{C{lon2}} (C{bool}).
+       @kwarg adjust: Adjust the wrapped, unrolled longitudinal delta by the cosine of the mean
+                      latitude (C{bool}).
+       @kwarg limit: Optional limit for lat- and longitudinal deltas (C{degrees}) or C{None}
+                     or C{0} for unlimited.
+       @kwarg wrap: If C{True}, wrap or I{normalize} and unroll B{C{lat2}} and B{C{lon2}}
+                    (C{bool}).
 
        @return: A L{Distance4Tuple}C{(distance2, delta_lat, delta_lon, unroll_lon2)}
                 in C{degrees squared}.
 
-       @raise LimitError: If the lat- and/or longitudinal delta exceeds the
-                          B{C{-limit..limit}} range and L{pygeodesy.limiterrors}
-                          set to C{True}.
+       @raise LimitError: If the lat- and/or longitudinal delta exceeds the B{C{-limit..limit}}
+                          range and L{limiterrors<pygeodesy.limiterrors>} is C{True}.
 
-       @see: U{Local, flat earth approximation
-             <https://www.EdWilliams.org/avform.htm#flat>}, functions
-             L{equirectangular}, L{cosineAndoyerLambert},
-             L{cosineForsytheAndoyerLambert}, L{cosineLaw}, L{euclidean},
-             L{flatLocal}/L{hubeny}, L{flatPolar}, L{haversine}, L{thomas}
-             and L{vincentys} and methods L{Ellipsoid.distance2},
-             C{LatLon.distanceTo*} and C{LatLon.equirectangularTo}.
+       @see: U{Local, flat earth approximation<https://www.EdWilliams.org/avform.htm#flat>},
+             functions L{equirectangular}, L{cosineAndoyerLambert}, L{cosineForsytheAndoyerLambert},
+             L{cosineLaw}, L{euclidean}, L{flatLocal}/L{hubeny}, L{flatPolar}, L{haversine},
+             L{thomas} and L{vincentys} and methods L{Ellipsoid.distance2}, C{LatLon.distanceTo*}
+             and C{LatLon.equirectangularTo}.
     '''
     d_lon,  lat2, ulon2 = _Wrap.latlon3(lon1, lat2, lon2, wrap)
     d_lat = lat2 - lat1
@@ -1078,7 +1075,7 @@ def heightOf(angle, distance, radius=R_M):
 
     if d > EPS0:  # and h > EPS0
         d = d / h  # /= h chokes PyChecker
-        s = sin(Phi_(angle=angle, clip=_180_0))
+        s = sin(Phid(angle=angle, clip=_180_0))
         s = fsumf_(_1_0, s * d * _2_0, d**2)
         if s > 0:
             return h * sqrt(s) - r