pygeodesy 24.9.29__py2.py3-none-any.whl → 24.10.24__py2.py3-none-any.whl

pygeodesy/dms.py

@@ -10,7 +10,7 @@ compass point suffix, including parsing of C{decimal} and C{sexagecimal} degrees
 Set env variable C{PYGEODESY_FMT_FORM} to any C{F_...} form to override default C{F_DMS}
 formatting of lat- and longitudes or to an empty string to restore the default.
 
-After I{(C) Chris Veness 2011-2015} published under the same MIT Licence**, see
+After I{(C) Chris Veness 2011-2024} published under the same MIT Licence**, see
 U{Latitude/Longitude<https://www.Movable-Type.co.UK/scripts/latlong.html>} and
 U{Vector-based geodesy<https://www.Movable-Type.co.UK/scripts/latlong-vectors.html>}.
 
@@ -61,17 +61,18 @@ U{Vector-based geodesy<https://www.Movable-Type.co.UK/scripts/latlong-vectors.ht
        non-ascii characters and if so, I{not} C{unicode}.
 '''
 
-from pygeodesy.basics import copysign0, isLatLon, isodd, issequence, isstr, map2, \
+from pygeodesy.basics import copysign0, isLatLon, isodd, issequence, isstr, \
                              neg as _neg  # in .ups
 from pygeodesy.constants import _umod_360, _0_0, _0_5, _60_0, _360_0, _3600_0
-from pygeodesy.errors import ParseError, RangeError, _TypeError, _ValueError,\
-                            _parseX, rangerrors, _xkwds, _xkwds_get
-from pygeodesy.interns import NN, _arg_, _COMMA_, _d_, _DASH_, _deg_, _degrees_, \
-                             _DOT_, _0_, _e_, _E_, _EW_, _f_, _F_, _g_, _keyword_, \
-                             _MINUS_, _N_, _NE_, _NS_, _NSEW_, _NW_, _of_, \
-                             _PERCENTDOTSTAR_, _PLUS_, _PLUSMINUS_, _QUOTE1_, \
-                             _QUOTE2_, _radians_, _S_, _SE_, _SPACE_, _SW_, _W_
-from pygeodesy.lazily import _ALL_LAZY, _ALL_MODS as _MODS, _getenv
+from pygeodesy.errors import ParseError, RangeError, _TypeError, _ValueError, \
+                            _parseX, rangerrors, _xError, _xkwds,  _getPYGEODESY
+# from pygeodesy.internals import _getPYGEODESY  # from .errors
+from pygeodesy.interns import NN, _COMMA_, _d_, _DASH_, _deg_, _degrees_, _DOT_, \
+                             _0_, _e_, _E_, _EW_, _f_, _F_, _g_, _MINUS_, _N_, \
+                             _NE_, _NS_, _NSEW_, _NW_, _PERCENTDOTSTAR_, _PLUS_, \
+                             _PLUSMINUS_, _QUOTE1_, _QUOTE2_, _radians_, _S_, \
+                             _SE_, _SPACE_, _SW_, _W_
+from pygeodesy.lazily import _ALL_LAZY, _ALL_MODS as _MODS
 # from pygeodesy.namedTuples import LatLon2Tuple  # _MODS
 # from pygeodesy.props import _throwarning  # _MODS
 from pygeodesy.streprs import Fmt, fstr, fstrzs, _0wpF
@@ -85,12 +86,10 @@ except ImportError:  # Python 3+
     from string import ascii_letters as _LETTERS
 
 __all__ = _ALL_LAZY.dms
-__version__ = '24.06.11'
+__version__ = '24.10.18'
 
 _beyond_      = 'beyond'
-_DDDMMSS_     = 'DDDMMSS'
 _deg_min_     = 'deg+min'
-_SDIGITS_     = '-0123456789+'
 _sexagecimal_ = 'sexagecimal'
 _SEXAGECIMUL  =  1.e4  # sexagecimal C{D.MMSSss} into decimal C{DMMSS.ss}
 
@@ -101,7 +100,7 @@ F_D_,  F_DM_,  F_DMS_,  F_DEG_,  F_MIN_,  F_SEC_,  F_D60_,  F__E_,  F__F_,  F__G
 F_D__, F_DM__, F_DMS__, F_DEG__, F_MIN__, F_SEC__, F_D60__, F__E__, F__F__, F__G__, F_RAD__ = (NN(
  _PLUS_, _)  for _ in _F_s)
 del _F_s
-_F_DMS  = _getenv('PYGEODESY_FMT_FORM', NN) or F_DMS
+_F_DMS  = _getPYGEODESY('FMT_FORM') or F_DMS
 
 _F_case = {F_D:   F_D,   F_DEG: F_D,   _degrees_: F_D,  # unsigned _F_s
            F_DM:  F_DM,  F_MIN: F_DM,  _deg_min_: F_DM,
@@ -150,13 +149,20 @@ def _DMS3(form, s_D=S_DEG, s_M=S_MIN, s_S=S_SEC, s_DMS=S_DMS, **unused):
 def _dms3(d, ddd, p, w):
     '''(INTERNAL) Format C{d} as (deg, min, sec) C{str}s with leading zeros.
     '''
-    d, s = divmod(round(d * _3600_0, p), _3600_0)
+    d =    round(d * _3600_0, p)
+    d, s = divmod(d, _3600_0)
     m, s = divmod(s, _60_0)
     return (_0wpF(ddd, 0, d),
             _0wpF(  2, 0, m),
             _0wpF(w+2, p, s))
 
 
+def _DR2(s_D=S_NUL, s_R=S_RAD, **unused):
+    '''(INTERNAL) Get the overridden or default C{D} and C{RAD} symbols.
+    '''
+    return s_D, s_R
+
+
 def _fstrzs(t, **unused):
     '''(INTERNAL) Pass-thru version of C{.streprs.fstrzs}.
     '''
@@ -169,79 +175,78 @@ def _split3(strDMS, suffix=_NSEW_):
     t = strDMS.strip()
     s = t[:1]   # sign or digit
     P = t[-1:]  # compass point or digit or dot
-    t = t.lstrip(_PLUSMINUS_).rstrip(suffix).strip()
-    return s, t, P
+    t = t.lstrip(_PLUSMINUS_).rstrip(suffix)
+    return s, t.strip(), P
 
 
-def _toDMS(deg, form, prec, sep, ddd, suff, s_D_M_S):  # MCCABE 13 in .units
+def _toDMS(deg, form, prec, sep, ddd, P, s_D_M_S):  # MCCABE 15 in .units
     '''(INTERNAL) Convert C{deg} to C{str}, with/-out sign, DMS symbols and/or suffix.
     '''
-    f = form
     try:
+        F   = None
         deg = float(deg)
-    except (TypeError, ValueError) as x:
-        raise _ValueError(deg=deg, form=f, prec=prec, cause=x)
-
-    if f[:1] in _PLUSMINUS_:  # signed
-        sign = _MINUS_ if deg < 0 else (
-               _PLUS_  if deg > 0 and f[:1] == _PLUS_ else NN)
-        f    =  f.lstrip(_PLUSMINUS_)
-        suff =  NN  # no suffix if signed
-    else:  # suffixed
-        sign =  NN  # no sign if suffixed
-        if suff and sep:  # no sep if no suffix
-            suff = NN(sep, suff)
-    try:
-        F = _F_case[f]  # .strip()
-    except KeyError:
-        f =  f.lower()  # .strip()
-        F = _F_case.get(f, F_DMS)
 
-    if prec is None:
-        z = p = _F_prec.get(F, 6)
-    else:
-        z = int(prec)
-        p = abs(z)
-    w = p + (1 if p else 0)
-    z = fstrzs if z > 1 else _fstrzs
-    d = fabs(deg)
+        f, s = form, form[:1]
+        if s in _PLUSMINUS_:  # signed
+            n = _MINUS_ if deg < 0 else (
+                _PLUS_  if deg > 0 and s == _PLUS_ else NN)
+            P = NN  # no suffix
+            f = f.lstrip(_PLUSMINUS_)
+        else:  # suffixed
+            n = NN
+            if sep and P:  # no sep if no suffix
+                P = NN(sep, P)
+        try:
+            F = _F_case[f]  # .strip()
+        except KeyError:
+            f =  f.lower()  # .strip()
+            F = _F_case.get(f, F_DMS)
+
+        if prec is None:
+            z = p = _F_prec.get(F, 6)
+        else:
+            z = int(prec)
+            p = abs(z)
+        w = p + (1 if p else 0)
+        z = fstrzs if z > 1 else _fstrzs
+        d = fabs(deg)
 
-    try:
         if F is F_DMS:  # 'deg+min+sec', default
             D, M, S = _DMS3(f, **s_D_M_S)
             d, m, s = _dms3(d, ddd, p, w)
-            t = NN(sign, d,  D, sep,
-                         m,  M, sep,
-                       z(s), S, suff)
+            t = NN(n, d,  D, sep,
+                      m,  M, sep,
+                    z(s), S, P)
 
         elif F is F_DM:  # 'deg+min'
             D, M, _ = _DMS3(f, **s_D_M_S)
             d, m = divmod(round(d * _60_0, p), _60_0)
-            t = NN(sign, _0wpF(ddd, 0, d),  D, sep,
-                       z(_0wpF(w+2, p, m)), M, suff)
+            t = NN(n, _0wpF(ddd, 0, d),  D, sep,
+                    z(_0wpF(w+2, p, m)), M, P)
 
         elif F is F_D:  # 'deg'
             D, _, _ = _DMS3(f, **s_D_M_S)
-            t = NN(sign, z(_0wpF(w+ddd, p, d)), D, suff)
+            t = NN(n, z(_0wpF(w+ddd, p, d)), D, P)
 
         elif F is F_D60:  # 'deg.MM|SSss|'
             D, M, S = _D603(sep, **s_D_M_S)
             d, m, s = _dms3(d, ddd, p, w)
-            t = z(s).split(_DOT_) + [S, suff]
-            t = NN(sign, d, D, m, M, *t)
+            t = z(s).split(_DOT_) + [S, P]
+            t = NN(n, d, D, m, M, *t)
 
         elif F is F_RAD:
-            R = _xkwds_get(s_D_M_S, s_R=S_RAD)
-            r =  NN(_PERCENTDOTSTAR_, _F_) % (p, radians(d))
-            t =  NN(sign, z(r), R, suff)
+            _, R = _DR2(**s_D_M_S)
+            r = NN(_PERCENTDOTSTAR_, _F_) % (p, radians(d))
+            t = NN(n, z(r), R, P)
 
         else:  # F in (F__E, F__F, F__G)
-            D = _xkwds_get(s_D_M_S, s_D=S_NUL)
-            d =  NN(_PERCENTDOTSTAR_, F) % (p, d)  # XXX f?
-            t =  NN(sign, z(d, ap1z=F is F__G), D, suff)
+            D, _ = _DR2(**s_D_M_S)
+            d = NN(_PERCENTDOTSTAR_, F) % (p, d)  # XXX f?
+            t = NN(n, z(d, ap1z=F is F__G), D, P)
 
     except Exception as x:
-        raise _ValueError(deg=deg, form=form, F=F, prec=prec, suff=suff, cause=x)
+        d = {} if F is None else dict(F_=F, P=P)
+        raise _xError(x, deg=deg, form=form, prec=prec, **d)
 
     return t  # NOT unicode in Python 2-
 
@@ -250,26 +255,15 @@ def bearingDMS(bearing, form=F_D, prec=None, sep=S_SEP, **s_D_M_S):
     '''Convert bearing to a string (without compass point suffix).
 
        @arg bearing: Bearing from North (compass C{degrees360}).
-       @kwarg form: Format specifier for B{C{deg}} (C{str} or L{F_D},
-                    L{F_DM}, L{F_DMS}, L{F_DEG}, L{F_MIN}, L{F_SEC},
-                    L{F_D60}, L{F__E}, L{F__F}, L{F__G}, L{F_RAD},
-                    L{F_D_}, L{F_DM_}, L{F_DMS_}, L{F_DEG_}, L{F_MIN_},
-                    L{F_SEC_}, L{F_D60_}, L{F__E_}, L{F__F_}, L{F__G_},
-                    L{F_RAD_}, L{F_D__}, L{F_DM__}, L{F_DMS__}, L{F_DEG__},
-                    L{F_MIN__}, L{F_SEC__}, L{F_D60__}, L{F__E__},
-                    L{F__F__}, L{F__G__} or L{F_RAD__}).
+       @kwarg form: Format specifier for B{C{deg}} (C{str} or C{F_...}).
        @kwarg prec: Number of decimal digits (0..9 or C{None} for default).
-                    Trailing zero decimals are stripped for B{C{prec}}
-                    values of 1 and above, but kept for negative B{C{prec}}.
        @kwarg sep: Separator between degrees, minutes, seconds, suffix (C{str}).
-       @kwarg s_D_M_S: Optional keyword arguments C{B{s_D}=str}, C{B{s_M}=str},
-                       C{B{s_S}=str} and C{B{s_DMS}=True} to override any or
-                       cancel all DMS symbols, defaults L{S_DEG}, L{S_MIN}
-                       respectively L{S_SEC}.
+       @kwarg s_D_M_S: Optional keyword arguments to override any or cancel all
+                       DMS symbol suffixes, see function L{pygeodesy.toDMS}.
 
        @return: Compass degrees per the specified B{C{form}} (C{str}).
 
-       @see: Function L{pygeodesy.toDMS}.
+       @see: Function L{pygeodesy.toDMS} and its B{Notes} for further details.
     '''
     return _toDMS(_umod_360(bearing), form, prec, sep, 1, NN, s_D_M_S)
 
@@ -317,26 +311,15 @@ def compassDMS(bearing, form=F_D, prec=None, sep=S_SEP, **s_D_M_S):
     '''Convert bearing to a string suffixed with compass point.
 
        @arg bearing: Bearing from North (compass C{degrees360}).
-       @kwarg form: Format specifier for B{C{deg}} (C{str} or L{F_D},
-                    L{F_DM}, L{F_DMS}, L{F_DEG}, L{F_MIN}, L{F_SEC},
-                    L{F_D60}, L{F__E}, L{F__F}, L{F__G}, L{F_RAD},
-                    L{F_D_}, L{F_DM_}, L{F_DMS_}, L{F_DEG_}, L{F_MIN_},
-                    L{F_SEC_}, L{F_D60_}, L{F__E_}, L{F__F_}, L{F__G_},
-                    L{F_RAD_}, L{F_D__}, L{F_DM__}, L{F_DMS__}, L{F_DEG__},
-                    L{F_MIN__}, L{F_SEC__}, L{F_D60__}, L{F__E__},
-                    L{F__F__}, L{F__G__} or L{F_RAD__}).
+       @kwarg form: Format specifier for B{C{deg}} (C{str} or C{F_...}).
        @kwarg prec: Number of decimal digits (0..9 or C{None} for default).
-                    Trailing zero decimals are stripped for B{C{prec}}
-                    values of 1 and above, but kept for negative B{C{prec}}.
        @kwarg sep: Separator between degrees, minutes, seconds, suffix (C{str}).
-       @kwarg s_D_M_S: Optional keyword arguments C{B{s_D}=str}, C{B{s_M}=str}
-                       C{B{s_S}=str} and C{B{s_DMS}=True} to override any or
-                       cancel all DMS symbols, defaults L{S_DEG}, L{S_MIN}
-                       respectively L{S_SEC}.
+       @kwarg s_D_M_S: Optional keyword arguments to override any or cancel all
+                       DMS symbol suffixes, see function L{pygeodesy.toDMS}.
 
        @return: Compass degrees and point in the specified form (C{str}).
 
-       @see: Function L{pygeodesy.toDMS}.
+       @see: Function L{pygeodesy.toDMS} and its B{Notes} for further details.
     '''
     b = _umod_360(bearing)
     return _toDMS(b, form, prec, sep, 1, compassPoint(b), s_D_M_S)
@@ -371,7 +354,7 @@ def compassPoint(bearing, prec=3):
         w *= int(b * m / _360_0 + _0_5) % m
         return _WINDS[w]
     except Exception as x:
-        raise _ValueError(bearing=bearing, prec=prec, cause=x)
+        raise _xError(x, bearing=bearing, prec=prec)
 
 
 def degDMS(deg, prec=6, s_D=S_DEG, s_M=S_MIN, s_S=S_SEC, neg=_MINUS_, pos=NN):
@@ -379,13 +362,13 @@ def degDMS(deg, prec=6, s_D=S_DEG, s_M=S_MIN, s_S=S_SEC, neg=_MINUS_, pos=NN):
 
        @arg deg: Value in degrees (C{scalar degrees}).
        @kwarg prec: Number of decimal digits (0..9 or C{None} for default).
-                    Trailing zero decimals are stripped for B{C{prec}}
-                    values of 1 and above, but kept for negative B{C{prec}}.
+                    Trailing zero decimals are stripped for C{B{prec}=1}
+                    and above, but kept for negative B{C{prec}}.
        @kwarg s_D: D symbol for degrees (C{str}).
-       @kwarg s_M: M symbol for minutes (C{str}) or C{""}.
-       @kwarg s_S: S symbol for seconds (C{str}) or C{""}.
+       @kwarg s_M: M symbol for minutes (C{str}) or C{""} aka L{pygeodesy.NN}.
+       @kwarg s_S: S symbol for seconds (C{str}) or C{""} aka L{pygeodesy.NN}.
        @kwarg neg: Optional sign for negative (C{'-'}).
-       @kwarg pos: Optional sign for positive (C{''}).
+       @kwarg pos: Optional sign for positive (C{""}) aka L{pygeodesy.NN}.
 
        @return: I{Either} degrees, minutes I{or} seconds (C{str}).
 
@@ -393,8 +376,8 @@ def degDMS(deg, prec=6, s_D=S_DEG, s_M=S_MIN, s_S=S_SEC, neg=_MINUS_, pos=NN):
     '''
     try:
         deg = float(deg)
-    except (TypeError, ValueError) as x:
-        raise _ValueError(deg=deg, prec=prec, cause=x)
+    except Exception as x:
+        raise _xError(x, deg=deg, prec=prec)
 
     d, s = fabs(deg), s_D
     if d < 1:
@@ -421,40 +404,28 @@ def latDMS(deg, form=_F_DMS, prec=None, sep=S_SEP, **s_D_M_S):
     '''Convert latitude to a string, optionally suffixed with N or S.
 
        @arg deg: Latitude to be formatted (C{scalar degrees}).
-       @kwarg form: Format specifier for B{C{deg}} (C{str} or L{F_D},
-                    L{F_DM}, L{F_DMS}, L{F_DEG}, L{F_MIN}, L{F_SEC},
-                    L{F_D60}, L{F__E}, L{F__F}, L{F__G}, L{F_RAD},
-                    L{F_D_}, L{F_DM_}, L{F_DMS_}, L{F_DEG_}, L{F_MIN_},
-                    L{F_SEC_}, L{F_D60_}, L{F__E_}, L{F__F_}, L{F__G_},
-                    L{F_RAD_}, L{F_D__}, L{F_DM__}, L{F_DMS__}, L{F_DEG__},
-                    L{F_MIN__}, L{F_SEC__}, L{F_D60__}, L{F__E__},
-                    L{F__F__}, L{F__G__} or L{F_RAD__}).
+       @kwarg form: Format specifier for B{C{deg}} (C{str} or C{F_...}).
        @kwarg prec: Number of decimal digits (0..9 or C{None} for default).
-                    Trailing zero decimals are stripped for B{C{prec}}
-                    values of 1 and above, but kept for negative B{C{prec}}.
        @kwarg sep: Separator between degrees, minutes, seconds, suffix (C{str}).
-       @kwarg s_D_M_S: Optional keyword arguments C{B{s_D}=str}, C{B{s_M}=str}
-                       C{B{s_S}=str} and C{B{s_DMS}=True} to override any or
-                       cancel all DMS symbols, defaults L{S_DEG}, L{S_MIN}
-                       respectively L{S_SEC}.
+       @kwarg s_D_M_S: Optional keyword arguments to override any or cancel all
+                       DMS symbol suffixes, see function L{pygeodesy.toDMS}.
 
        @return: Degrees in the specified form (C{str}).
 
-       @see: Functions L{pygeodesy.toDMS} and L{pygeodesy.lonDMS}.
+       @see: Function L{pygeodesy.toDMS} and its B{Notes} for further details.
     '''
-    p = _S_ if deg < 0 else _N_
-    return _toDMS(deg, form, prec, sep, 2, p, s_D_M_S)
+    P = _S_ if deg < 0 else _N_
+    return _toDMS(deg, form, prec, sep, 2, P, s_D_M_S)
 
 
 def latlonDMS(lls, **m_form_prec_sep_s_D_M_S):
     '''Convert one or more C{LatLon} instances to strings.
 
-       @arg lls: Single (C{LatLon}) or list, sequence, tuple, etc. (C{LatLon}s).
+       @arg lls: Single (C{LatLon}) or an iterable (C{LatLon}s).
        @kwarg m_form_prec_sep_s_D_M_S: Optional keyword arguments C{B{m}eter},
                 C{B{form}at}, C{B{prec}ision}, B{C{s_D}}, B{C{s_M}}, B{C{s_S}},
-                B{C{s_DMS}} and I{DEPRECATED} C{B{sep}=None}, see method
-                C{LatLon.toStr} and functions L{pygeodesy.latDMS} and
-                L{pygeodesy.lonDMS} for more details.
+                B{C{s_DMS}} and I{DEPRECATED}  C{B{sep}=None}, see function
+                L{pygeodesy.toDMS} and method C{LatLon.toStr} for more details.
 
        @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}.
@@ -462,15 +433,15 @@ def latlonDMS(lls, **m_form_prec_sep_s_D_M_S):
        @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 the resturned 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):
         t = lls.toStr(**kwds)
     elif issequence(lls):
         t = tuple(ll.toStr(**kwds) for ll in lls)
-        if sep:  # XXX TO BE REMOVED
+        if sep:  # XXX DEPRECATED, to be removed
             t = sep.join(t)
     else:
         raise _TypeError(lls=lls, **m_form_prec_sep_s_D_M_S)
@@ -481,12 +452,10 @@ def latlonDMS_(*lls, **m_form_prec_sep_s_D_M_S):
     '''Convert one or more C{LatLon} instances to strings.
 
        @arg lls: The instances (C{LatLon}s), all positional arguments.
-       @kwarg m_form_prec_sep_s_D_M_S: Optional keyword arguments
-                C{B{m}eter}, C{B{form}at}, C{B{prec}ision}, B{C{s_D}},
-                B{C{s_M}}, B{C{s_S}}, B{C{s_DMS}} and I{DEPRECATED}
-                C{B{sep}=None}, see method C{LatLon.toStr} and
-                functions L{pygeodesy.latDMS} and L{pygeodesy.lonDMS}
-                for more details.
+       @kwarg m_form_prec_sep_s_D_M_S: Optional keyword arguments C{B{m}eter},
+                C{B{form}at}, C{B{prec}ision}, B{C{s_D}}, B{C{s_M}}, B{C{s_S}},
+                B{C{s_DMS}} and I{DEPRECATED}  C{B{sep}=None}, see function
+                L{pygeodesy.toDMS} and method C{LatLon.toStr} for more details.
 
        @return: A C{tuple} of C{str}s if 2 or more C{LatLon} instances
                 or a single C{str} if only a single C{LatLon} instance
@@ -496,9 +465,8 @@ def latlonDMS_(*lls, **m_form_prec_sep_s_D_M_S):
              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 the resturned 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 not lls:
@@ -510,9 +478,11 @@ def latlonDMS_(*lls, **m_form_prec_sep_s_D_M_S):
 
 
 def _latlonDMS_sep2(where, sep=None, **kwds):
-    '''DEPRECATED, instead use: %r.join(%s(...))'''
-    if sep:
-        k = _SPACE_(_keyword_, _arg_, Fmt.EQUAL(sep=repr(sep)), _of_)
+    '''DEPRECATED, use %r.join(%s(...)) instead.'''
+    if sep:  # PYCHOK no cover
+        i = _MODS.inters
+        k =  Fmt.EQUAL(sep=repr(sep))
+        k = _SPACE_(i._keyword_, i._arg_, k, i._of_)
         n =  where.__name__
         t = _latlonDMS_sep2.__doc__ % (sep, n)
         _MODS.props._throwarning(k, n, t)
@@ -523,41 +493,29 @@ def lonDMS(deg, form=_F_DMS, prec=None, sep=S_SEP, **s_D_M_S):
     '''Convert longitude to a string, optionally suffixed with E or W.
 
        @arg deg: Longitude to be formatted (C{scalar degrees}).
-       @kwarg form: Format specifier for B{C{deg}} (C{str} or L{F_D},
-                    L{F_DM}, L{F_DMS}, L{F_DEG}, L{F_MIN}, L{F_SEC},
-                    L{F_D60}, L{F__E}, L{F__F}, L{F__G}, L{F_RAD},
-                    L{F_D_}, L{F_DM_}, L{F_DMS_}, L{F_DEG_}, L{F_MIN_},
-                    L{F_SEC_}, L{F_D60_}, L{F__E_}, L{F__F_}, L{F__G_},
-                    L{F_RAD_}, L{F_D__}, L{F_DM__}, L{F_DMS__}, L{F_DEG__},
-                    L{F_MIN__}, L{F_SEC__}, L{F_D60__}, L{F__E__},
-                    L{F__F__}, L{F__G__} or L{F_RAD__}).
+       @kwarg form: Format specifier for B{C{deg}} (C{str} or C{F_...}).
        @kwarg prec: Number of decimal digits (0..9 or C{None} for default).
-                    Trailing zero decimals are stripped for B{C{prec}}
-                    values of 1 and above, but kept for negative B{C{prec}}.
        @kwarg sep: Separator between degrees, minutes, seconds, suffix (C{str}).
-       @kwarg s_D_M_S: Optional keyword arguments C{B{s_D}=str}, C{B{s_M}=str}
-                       C{B{s_S}=str} and C{B{s_DMS}=True} to override any or
-                       cancel all DMS symbols, defaults L{S_DEG}, L{S_MIN}
-                       respectively L{S_SEC}.
+       @kwarg s_D_M_S: Optional keyword arguments to override any or cancel all
+                       DMS symbol suffixes.
 
        @return: Degrees in the specified form (C{str}).
 
-       @see: Functions L{pygeodesy.toDMS} and L{pygeodesy.latDMS}.
+       @see: Function L{pygeodesy.toDMS} and its B{Notes} for further details.
     '''
-    p = _W_ if deg < 0 else _E_
-    return _toDMS(deg, form, prec, sep, 3, p, s_D_M_S)
+    P = _W_ if deg < 0 else _E_
+    return _toDMS(deg, form, prec, sep, 3, P, s_D_M_S)
 
 
 def normDMS(strDMS, norm=None, **s_D_M_S):
-    '''Normalize all degrees, minutes and seconds (DMS) I{symbols} in
+    '''Normalize all degrees, minutes and seconds (DMS) I{symbol} suffixes in
        a string to the default symbols L{S_DEG}, L{S_MIN}, L{S_SEC}.
 
        @arg strDMS: Original DMS string (C{str}).
-       @kwarg norm: Optional replacement symbol (C{str}) or C{None} for
-                    the default DMS symbols).  Use C{B{norm}=""} to
-                    remove all DMS symbols.
-       @kwarg s_D_M_S: Optional, alternate DMS symbols C{B{s_D}=str},
-                       C{B{s_M}=str}, C{B{s_S}=str} and/or C{B{s_R}=str}
+       @kwarg norm: Optional replacement symbol (C{str}) or C{None} for the default
+                    DMS symbol).  Use C{B{norm}=""} to remove all DMS symbols.
+       @kwarg s_D_M_S: Optional, alternate DMS symbol suffixes C{B{s_D}=}L{S_DEG},
+                       C{B{s_M}=}L{S_MIN}, C{B{s_S}=}L{S_SEC} and C{B{s_R}=}L{S_RAD}
                        for radians, each to be replaced by B{C{norm}}.
 
        @return: Normalized DMS (C{str}).
@@ -588,13 +546,14 @@ def normDMS(strDMS, norm=None, **s_D_M_S):
     return strDMS  # NOT unicode in Python 2-
 
 
-def parseDDDMMSS(strDDDMMSS, suffix=_NSEW_, sep=S_SEP, clip=0, sexagecimal=False):  # MCCABE 14
+def parseDDDMMSS(strDDDMMSS, suffix=_NSEW_, sep=S_SEP, clip=0, sexagecimal=False):
     '''Parse a lat- or longitude represention forms as [D]DDMMSS in degrees.
 
        @arg strDDDMMSS: Degrees in any of several forms (C{str}) and types (C{float},
                         C{int}, other).
-       @kwarg suffix: Optional, valid compass points (C{str}, C{tuple}).
-       @kwarg sep: Optional separator between "[D]DD", "MM", "SS", B{C{suffix}} (L{S_SEP}).
+       @kwarg suffix: Optional compass points (C{str}), valid in B{C{strDDDMMSS}}.
+       @kwarg sep: Optional separator between "[D]DD", "MM", "SS", B{C{suffix}}
+                   (L{S_SEP}) in B{C{strDDDMMSS}}.
        @kwarg clip: Optionally, limit value to range C{-/+B{clip}} (C{degrees}).
        @kwarg sexagecimal: If C{True}, convert C{"D.MMSS"} or C{float(D.MMSS)} to
                            C{base-60} "MM" and "SS" digits.  See C{form}s L{F_D60},
@@ -603,8 +562,8 @@ def parseDDDMMSS(strDDDMMSS, suffix=_NSEW_, sep=S_SEP, clip=0, sexagecimal=False
        @return: Degrees (C{float}).
 
        @raise ParseError: Invalid B{C{strDDDMMSS}} or B{C{clip}} or the form of
-                          B{C{strDDDMMSS}} is incompatible with the suffixed or
-                          B{C{suffix}} compass point.
+                          B{C{strDDDMMSS}} is incompatible with or invalid for the
+                          given B{C{suffix}} compass point(s).
 
        @raise RangeError: Value of B{C{strDDDMMSS}} outside the valid C{-/+B{clip}}
                           range and L{rangerrors<pygeodesy.rangerrors>} is C{True}.
@@ -629,63 +588,39 @@ def parseDDDMMSS(strDDDMMSS, suffix=_NSEW_, sep=S_SEP, clip=0, sexagecimal=False
              L{pygeodesy.parse3llh}.
     '''
     def _DDDMMSS(strDDDMMSS, suffix, sep, clip, sexagecimal):
-        S = suffix.upper()
+        S = suffix.upper() or _N_  # bool('' in _NE_) is True
         if isstr(strDDDMMSS):
-            t = strDDDMMSS.replace(sep, NN) if sep else strDDDMMSS
-            s, t, P = _split3(t, S)
-            f = t.split(_DOT_)
-            n = len(f[0])
-            f = NN.join(f)
-            if 1 < n < 8 and f.isdigit() and (  # dddN/S/E/W or ddd or +/-ddd
-                                 (P in S and s.isdigit()) or
-                            (P.isdigit() and s in _SDIGITS_  # PYCHOK indent
-                                         and S in _WINDS)):
-                # check [D]DDMMSS form and compass point
-                X = _EW_ if isodd(n) else _NS_
-                if not (P in X or (S in X and (P.isdigit() or P == _DOT_))):
-                    t = _DDDMMSS_[int(X is _NS_):(n | 1)], _DASH_.join(X)
-                    raise ParseError('form %s applies %s' % t)
+            t =  strDDDMMSS.replace(sep, NN) if sep else strDDDMMSS
+            n, s, t, f, P, X = _DDDMMSS6(t, S)
+            if X:
+                pass
             elif not sexagecimal:  # try other forms
                 return _DMS2deg(strDDDMMSS, S, sep, clip, {})
 
             if sexagecimal:  # move decimal dot from ...
                 n += 4  # ... [D]DD.MMSSs to [D]DDMMSS.s
                 if n < 6:
-                    raise ParseError('%s digits (%s)' % (_sexagecimal_, n))
+                    t = _SPACE_(_sexagecimal_, 'digits')
+                    raise ParseError(t, n)
                 z = n - len(f)  # zeros to append
                 t = (f + (_0_ * z)) if z > 0 else _DOT_(f[:n], f[n:])
             f = _0_0  # fraction
-
         else:  # float or int to [D]DDMMSS[.fff]
-            f, m = float(strDDDMMSS), 0
-            if sexagecimal:
-                f *= _SEXAGECIMUL
-                m = 6
-            s = P = _0_  # anything except NN, _S_, _SW_, _W_
-            if f < 0:
-                f = -f
-                s = _MINUS_
-            f, i = modf(f)   # returns ...
-            t = str(int(i))  # ... float(i)
-            n = len(t)  # number of digits to ...
-            if n < m:  # ... required min or ...
-                t = (_0_ * (m - n)) + t
-            # ... match the given compass point
-            elif S in (_NS_ if isodd(n) else _EW_):
-                t = _0_ + t
-            #   P = S
-            # elif n > 1:
-            #   P = (_EW_ if isodd(n) else _NS_)[0]
-            n = len(t)
+            f = float(strDDDMMSS)
+            n, s, t, f, P = _DDDMMSS5(f, S, sexagecimal)
 
         if n < 4:  # [D]DD[.ddd]
-            t = (float(t) + f),
+            if t:
+                f += float(t)
+            t = f,
         else:
-            f += float(t[n-2:])
-            if n < 6:  # [D]DDMM[.mmm]
-                t = float(t[:n-2]), f
+            n -= 2
+            f += float(t[n:])
+            if n < 4:  # [D]DDMM[.mmm]
+                t = float(t[:n]), f
             else:  # [D]DDMMSS[.sss]
-                t = float(t[:n-4]), float(t[n-4:n-2]), f
+                d = n - 2
+                t = float(t[:d]), float(t[d:n]), f
         d = _dms2deg(s, P, *t)
         return clipDegrees(d, float(clip)) if clip else d
 
@@ -693,13 +628,54 @@ def parseDDDMMSS(strDDDMMSS, suffix=_NSEW_, sep=S_SEP, clip=0, sexagecimal=False
                              strDDDMMSS=strDDDMMSS, suffix=suffix, sexagecimal=sexagecimal)
 
 
-def _dms2deg(s, P, deg, min=_0_0, sec=_0_0):
-    '''(INTERNAL) Helper for C{parseDDDMMSS} and C{_DMS2deg}.
+def _DDDMMSS5(f, S, sexagecimal):
+    '''(INTERNAL) Partial C{parseDDDMMSS} of C{float}.
+    '''
+    if sexagecimal:
+        f *= _SEXAGECIMUL
+        m = 6
+    else:
+        m = 0
+    s = P = _PLUS_  # anything except NN, _S_, _SW_, _W_
+    if f < 0:
+        f = -f
+        s = _MINUS_
+    f, i = modf(f)   # returns ...
+    t = str(int(i))  # ... float(i)
+    n = len(t)  # number of digits to ...
+    if n < m:  # ... required min or ...
+        t = (_0_ * (m - n)) + t
+    # ... match the given compass point
+    elif S in (_NS_ if isodd(n) else _EW_):
+        t = _0_ + t
+    #   P = S
+    # elif n > 1:
+    #   P = (_EW_ if isodd(n) else _NS_)[0]
+    return len(t), s, t, f, P  # float(f) fraction
+
+
+def _DDDMMSS6(t, S):
+    '''(INTERNAL) Partial C{parseDDDMMSS} of C{str}.
     '''
-    deg += (min + (sec / _60_0)) / _60_0
-    if s == _MINUS_ or (P and P in _SW_):
-        deg = _neg(deg)
-    return deg
+    s, t, P = _split3(t, S)
+    f = t.split(_DOT_)
+    if len(f) > 2:
+        raise ParseError('dots', len(f) - 1)
+    n = len(f[0])
+    f = NN.join(f)
+    if 1 < n < 8 and f.isdigit() and (  # dddN/S/E/W or ddd or +/-ddd
+                         (P in S and  s.isdigit()) or
+                    (P.isdigit() and  S in _WINDS  # PYCHOK indent
+                                 and (s in _PLUSMINUS_ or s.isdigit()))):
+        # check [D]DDMMSS form and compass point
+        X = _EW_ if isodd(n) else _NS_
+        if not (P in X or (S in X and (P.isdigit() or P == _DOT_))):
+            t =  parseDDDMMSS.__name__[5 if isodd(n) else 6:]
+            t = _SPACE_('form', t, 'applies', _DASH_.join(X))
+            raise ParseError(t)
+    else:
+        X = NN
+    return n, s, t, f, P, X  # str(f) fraction
 
 
 def _DMS2deg(strDMS, suffix, sep, clip, s_D_M_S):
@@ -707,7 +683,6 @@ def _DMS2deg(strDMS, suffix, sep, clip, s_D_M_S):
     '''
     try:
         d = float(strDMS)
-
     except (TypeError, ValueError):
         s, t, P = _split3(strDMS, suffix.upper())
         if sep:  # remove all DMS symbols
@@ -715,29 +690,40 @@ def _DMS2deg(strDMS, suffix, sep, clip, s_D_M_S):
             t = normDMS(t, norm=NN, **s_D_M_S)
         else:  # replace all DMS symbols
             t = normDMS(t, norm=_SPACE_, **s_D_M_S)
-        t =  map2(float, t.strip().split())
-        d = _dms2deg(s, P, *t[:3])
-
+        t =  t.strip().split()
+        d = _dms2deg(s, P, *map(float, t))
     return clipDegrees(d, float(clip)) if clip else d
 
 
+def _dms2deg(n, P, d, m=_0_0, s=_0_0):
+    '''(INTERNAL) Helper for C{parseDDDMMSS}, C{parseRad} and C{_DMS2deg}.
+    '''
+    m += s / _60_0
+    d += m / _60_0
+    if n == _MINUS_ or (P and P in _SW_):
+        d = _neg(d)
+    return d
+
+
 def parseDMS(strDMS, suffix=_NSEW_, sep=S_SEP, clip=0, **s_D_M_S):  # MCCABE 14
     '''Parse a lat- or longitude representation in C{degrees}.
 
-       This is very flexible on formats, allowing signed decimal
-       degrees, degrees and minutes or degrees minutes and seconds
-       optionally suffixed by a cardinal compass point.
+       This is very flexible on formats, allowing signed decimal degrees, degrees
+       and minutes or degrees minutes and seconds optionally suffixed by a cardinal
+       compass point.
 
-       A variety of symbols, separators and suffixes are accepted,
-       for example "3°37′09″W".  Minutes and seconds may be omitted.
+       A variety of symbols, separators and suffixes are accepted, for example
+       "3°37′09″W".  Minutes and seconds may be omitted.
 
-       @arg strDMS: Degrees in any of several forms (C{str}) and
-                    types (C{float}, C{int}, other).
+       @arg strDMS: Degrees in any of several forms (C{str}) and types (C{float},
+                    C{int}, other).
        @kwarg suffix: Optional, valid compass points (C{str}, C{tuple}).
-       @kwarg sep: Optional separator between deg°, min′, sec″, B{C{suffix}} (C{''}).
+       @kwarg sep: Optional separator between C{deg°}, C{min′}, C{sec″},
+                   B{C{suffix}} (C{''}).
        @kwarg clip: Optionally, limit value to range C{-/+B{clip}} (C{degrees}).
-       @kwarg s_D_M_S: Optional, alternate symbol for degrees C{B{s_D}=str},
-                       minutes C{B{s_M}=str} and/or seconds C{B{s_S}=str}.
+       @kwarg s_D_M_S: Optional, alternate DMS symbol suffixes for degrees
+                       C{B{s_D}=}L{S_DEG}, minutes C{B{s_M}=}L{S_MIN} and
+                       seconds C{B{s_S}=}L{S_SEC}, see function L{pygeodesy.toDMS}.
 
        @return: Degrees (C{float}).
 
@@ -767,8 +753,9 @@ def parseDMS2(strLat, strLon, sep=S_SEP, clipLat=90, clipLon=180, wrap=False, **
        @kwarg clipLon: Limit longitude to range C{-/+B{clipLon}} (C{degrees}).
        @kwarg wrap: If C{True}, wrap or I{normalize} the lat- and longitude,
                     overriding B{C{clipLat}} and B{C{clipLon}} (C{bool}).
-       @kwarg s_D_M_S: Optional, alternate symbol for degrees C{B{s_D}=str},
-                       minutes C{B{s_M}=str} and/or seconds C{B{s_S}=str}.
+       @kwarg s_D_M_S: Optional, alternate DMS symbol suffixes for degrees
+                       C{B{s_D}=}L{S_DEG}, minutes C{B{s_M}=}L{S_MIN} and
+                       seconds C{B{s_S}=}L{S_SEC}, see function L{pygeodesy.toDMS}.
 
        @return: A L{LatLon2Tuple}C{(lat, lon)} in C{degrees}.
 
@@ -791,14 +778,14 @@ def _2Tuple(strLat, strLon, clipLat, clipLon, wrap, **kwds):
     '''
     if wrap:
         _W = _MODS.utily._Wrap
-        lat, lon = _W.latlon(parseDMS(strLat, suffix=_NS_, **kwds),
-                             parseDMS(strLon, suffix=_EW_, **kwds))
+        ll = _W.latlon(parseDMS(strLat, suffix=_NS_, **kwds),
+                       parseDMS(strLon, suffix=_EW_, **kwds))
     else:
         # if wrap is None:
         #     clipLat = clipLon = 0
-        lat = parseDMS(strLat, suffix=_NS_, clip=clipLat, **kwds)
-        lon = parseDMS(strLon, suffix=_EW_, clip=clipLon, **kwds)
-    return _MODS.namedTuples.LatLon2Tuple(lat, lon)
+        ll = (parseDMS(strLat, suffix=_NS_, clip=clipLat, **kwds),
+              parseDMS(strLon, suffix=_EW_, clip=clipLon, **kwds))
+    return _MODS.namedTuples.LatLon2Tuple(*ll)
 
 
 def parse3llh(strllh, height=0, sep=_COMMA_, clipLat=90, clipLon=180, wrap=False, **s_D_M_S):
@@ -819,8 +806,9 @@ def parse3llh(strllh, height=0, sep=_COMMA_, clipLat=90, clipLon=180, wrap=False
        @kwarg clipLon: Limit longitude to range C{-/+B{clipLon}} (C{degrees}).
        @kwarg wrap: If C{True}, wrap or I{normalize} the lat- and longitude,
                     overriding B{C{clipLat}} and B{C{clipLon}} (C{bool}).
-       @kwarg s_D_M_S: Optional, alternate symbol for degrees C{B{s_D}=str},
-                      minutes C{B{s_M}=str} and/or seconds C{B{s_S}=str}.
+       @kwarg s_D_M_S: Optional, alternate DMS symbol suffixes for degrees
+                       C{B{s_D}=}L{S_DEG}, minutes C{B{s_M}=}L{S_MIN} and
+                       seconds C{B{s_S}=}L{S_SEC}, see function L{pygeodesy.toDMS}.
 
        @return: A L{LatLon3Tuple}C{(lat, lon, height)} in C{degrees},
                 C{degrees} and C{float}.
@@ -836,7 +824,6 @@ def parse3llh(strllh, height=0, sep=_COMMA_, clipLat=90, clipLon=180, wrap=False
        @see: Functions L{pygeodesy.parseDDDMMSS}, L{pygeodesy.parseDMS},
              L{pygeodesy.parseDMS2} and L{pygeodesy.toDMS}.
     '''
-
     def _3llh(strllh, height, sep, wrap):
         ll = strllh.strip().split(sep)
         if len(ll) > 2:  # XXX interpret height unit
@@ -849,7 +836,8 @@ def parse3llh(strllh, height=0, sep=_COMMA_, clipLat=90, clipLon=180, wrap=False
         a, b = [_.strip() for _ in ll]  # PYCHOK false
         if a[-1:] in _EW_ or b[-1:] in _NS_:
             a, b = b, a
-        return _2Tuple(a, b, clipLat, clipLon, wrap, **s_D_M_S).to3Tuple(h)
+        t = _2Tuple(a, b, clipLat, clipLon, wrap, **s_D_M_S)
+        return t.to3Tuple(h)
 
     return _parseX(_3llh, strllh, height, sep, wrap, strllh=strllh)
 
@@ -871,11 +859,9 @@ def parseRad(strRad, suffix=_NSEW_, clip=0):
     def _Rad(strRad, suffix, clip):
         try:
             r = float(strRad)
-
         except (TypeError, ValueError):
             s, t, P = _split3(strRad, suffix.upper())
             r = _dms2deg(s, P, float(t))
-
         return clipRadians(r, float(clip)) if clip else r
 
     return _parseX(_Rad, strRad, suffix, clip, strRad=strRad, suffix=suffix)
@@ -884,13 +870,11 @@ def parseRad(strRad, suffix=_NSEW_, clip=0):
 def precision(form, prec=None):
     '''Set the default precison for a given F_ form.
 
-       @arg form: L{F_D}, L{F_DM}, L{F_DMS}, L{F_DEG}, L{F_MIN},
-                  L{F_SEC}, L{F_D60}, L{F__E}, L{F__F}, L{F__G}
-                  or L{F_RAD} (C{str}).
-       @kwarg prec: Number of decimal digits (0..9 or C{None} for
-                    default).  Trailing zero decimals are stripped
-                    for B{C{prec}} values of 1 and above, but kept
-                    for negative B{C{prec}}.
+       @arg form: L{F_D}, L{F_DM}, L{F_DMS}, L{F_DEG}, L{F_MIN}, L{F_SEC},
+                  L{F_D60}, L{F__E}, L{F__F}, L{F__G} or L{F_RAD} (C{str}).
+       @kwarg prec: Number of decimal digits (0..9 or C{None} for default).
+                    Trailing zero decimals are stripped for C{B{prec}=1}
+                    and above, but kept for negative B{C{prec}}.
 
        @return: Previous precision for the B{C{form}} (C{int}).
 
@@ -901,10 +885,9 @@ def precision(form, prec=None):
         p = _F_prec[form]
     except KeyError:
         raise _ValueError(form=form)
-
     if prec is not None:  # set as default
-        _F_prec[form] = _MODS.units.Precision_(prec, low=-9, high=9)
-
+        P_ = _MODS.units.Precision_
+        _F_prec[form] = P_(prec, low=-9, high=9)
     return p
 
 
@@ -912,41 +895,38 @@ def toDMS(deg, form=_F_DMS, prec=2, sep=S_SEP, ddd=2, neg=_MINUS_, pos=_PLUS_, *
     '''Convert I{signed} C{degrees} to string, without suffix.
 
        @arg deg: Degrees to be formatted (C{scalar degrees}).
-       @kwarg form: Format specifier for B{C{deg}} (C{str} or L{F_D},
-                    L{F_DM}, L{F_DMS}, L{F_DEG}, L{F_MIN}, L{F_SEC},
-                    L{F_D60}, L{F__E}, L{F__F}, L{F__G}, L{F_RAD},
-                    L{F_D_}, L{F_DM_}, L{F_DMS_}, L{F_DEG_}, L{F_MIN_},
-                    L{F_SEC_}, L{F_D60_}, L{F__E_}, L{F__F_}, L{F__G_},
-                    L{F_RAD_}, L{F_D__}, L{F_DM__}, L{F_DMS__}, L{F_DEG__},
-                    L{F_MIN__}, L{F_SEC__}, L{F_D60__}, L{F__E__},
+       @kwarg form: Format specifier for B{C{deg}} (C{str} or L{F_D}, L{F_DM}, L{F_DMS},
+                    L{F_DEG}, L{F_MIN}, L{F_SEC}, L{F_D60}, L{F__E}, L{F__F}, L{F__G},
+                    L{F_RAD}, L{F_D_}, L{F_DM_}, L{F_DMS_}, L{F_DEG_}, L{F_MIN_}, L{F_SEC_},
+                    L{F_D60_}, L{F__E_}, L{F__F_}, L{F__G_}, L{F_RAD_}, L{F_D__}, L{F_DM__},
+                    L{F_DMS__}, L{F_DEG__}, L{F_MIN__}, L{F_SEC__}, L{F_D60__}, L{F__E__},
                     L{F__F__}, L{F__G__} or L{F_RAD__}).
-       @kwarg prec: Number of decimal digits (0..9 or C{None} for default).
-                    Trailing zero decimals are stripped for B{C{prec}}
-                    values of 1 and above, but kept for negative B{C{prec}}.
+       @kwarg prec: Number of decimal digits (0..9 or C{None} for default).  Trailing zero
+                    decimals are stripped for C{B{prec}=1} and above, but kept for negative
+                    B{C{prec}}.
        @kwarg sep: Separator between degrees, minutes, seconds, suffix (C{str}).
-       @kwarg ddd: Number of digits for B{C{deg}°} (2 or 3).
+       @kwarg ddd: Number of (integer) digits for B{C{deg}°} (2 or 3).
        @kwarg neg: Prefix for negative B{C{deg}} (C{'-'}).
        @kwarg pos: Prefix for positive B{C{deg}} and signed B{C{form}} (C{'+'}).
-       @kwarg s_D_M_S: Optional keyword arguments C{B{s_D}=str}, C{B{s_M}=str}
-                       C{B{s_S}=str} and C{B{s_DMS}=True} to override any or
-                       cancel all DMS symbols, defaults L{S_DEG}, L{S_MIN}
-                       respectively L{S_SEC}.  See B{Notes} below.
+       @kwarg s_D_M_S: Optional keyword arguments C{B{s_D}=}L{S_DEG}, C{B{s_M}=}L{S_MIN}
+                       C{B{s_S}=}L{S_SEC}, C{B{s_R}=}L{S_RAD} and C{B{s_DMS}=True} to
+                       override any or cancel all DMS symbol suffixes.  See the B{Notes}
+                       below.
 
        @return: Degrees in the specified form (C{str}).
 
-       @note: The degrees, minutes and seconds (DMS) symbol can be overridden in
-              this and other C{*DMS} functions by using optional keyword argments
-              C{B{s_D}="d"}, C{B{s_M}="'"} respectively C{B{s_S}='"'}.  Using
-              keyword argument B{C{s_DMS}=None} cancels all C{DMS} symbols to
-              C{B{S_NUL}=NN}.
+       @note: The degrees, minutes and seconds (DMS) symbol can be overridden in this and
+              other C{*DMS} functions by using optional keyword argments C{B{s_D}="d"},
+              C{B{s_M}="'"} respectively C{B{s_S}='"'}.  Using B{C{s_DMS}=None} cancels
+              all C{DMS} symbols to C{""} aka L{pygeodesy.NN}.
 
        @note: Sexagecimal format B{C{F_D60}} supports overridable pseudo-DMS symbols
               positioned at C{"[D]DD<B{s_D}>MM<B{s_M}>SS<B{s_S}>"} with defaults
               C{B{s_D}="."}, C{B{s_M}=B{sep}} and C{B{s_S}=}L{pygeodesy.NN}.
 
-       @note: Formats B{C{F__E}}, B{C{F__F}} and B{C{F__G}} can be extended with
-              a C{D}-only symbol if defined with keyword argument C{B{s_D}=str}.
-              Likewise for B{C{F_RAD}} formats with keyword argument C{B{s_R}=str}.
+       @note: Formats B{C{F__E}}, B{C{F__F}} and B{C{F__G}} is extended with a C{D}-only
+              symbol suffix if defined with keyword argument C{B{s_D}=}L{pygeodesy.NN}.
+              Likewise for B{C{F_RAD}} forms with keyword argument C{B{s_R}=}L{S_RAD}.
 
        @see: Function L{pygeodesy.degDMS}
     '''