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

pygeodesy/epsg.py

@@ -28,7 +28,7 @@ from pygeodesy.utmupsBase import _to3zBhp, _UPS_ZONE, _UTM_ZONE_MIN, \
                                  _UTM_ZONE_MAX, _UTMUPS_ZONE_INVALID
 
 __all__ = _ALL_LAZY.epsg
-__version__ = '22.09.24'
+__version__ = '24.05.18'
 
 # _EPSG_INVALID = _UTMUPS_ZONE_INVALID
 _EPSG_N_01 = 32601  # EPSG code for UTM zone 01 N
@@ -49,11 +49,12 @@ class Epsg(Int):
     _utmups     =  None
     _zone       = _UTMUPS_ZONE_INVALID
 
-    def __new__(cls, eisu, name=NN):
+    def __new__(cls, eisu, **name):
         '''New L{Epsg} (I{European Petroleum Survey Group}) code from a
            UTM/USP coordinate or other EPSG code.
 
            @arg eisu: Other code (L{Epsg}, C{int}, C{str}, L{Utm} or L{Ups}).
+           @kwarg name: Optional C{B{name}=NN} (C{str}).
 
            @return: New L{Epsg}.
 
@@ -88,7 +89,7 @@ class Epsg(Int):
                 self.name = u.name
 
         if name:
-            self.name = name
+            self.rename(name)
         return self
 
     def __repr__(self):

pygeodesy/errors.py

@@ -14,20 +14,23 @@ 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 _tailof  # from .lazily
+from pygeodesy.internals import _plural, _tailof
 from pygeodesy.interns import MISSING, NN, _a_, _an_, _and_, _clip_, _COLON_, _COLONSPACE_, \
                              _COMMASPACE_, _datum_, _ellipsoidal_, _incompatible_, _invalid_, \
-                             _len_, _not_, _or_, _SPACE_, _specified_, _UNDER_, _vs_, _with_
-from pygeodesy.lazily import _ALL_LAZY, _ALL_MODS as _MODS, _getenv, _PYTHON_X_DEV,  _tailof
+                             _keyword_, _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.vector3dBase import Vector3dBase  # _MODS
 
 from copy import copy as _copy
 
 __all__ = _ALL_LAZY.errors  # _ALL_DOCS('_InvalidError', '_IsnotError')  _under
-__version__ = '24.05.15'
+__version__ = '24.05.29'
 
+_argument_   = 'argument'
 _box_        = 'box'
+_expected_   = 'expected'
 _limiterrors =  True  # in .formy
 _name_value_ =  repr('name=value')
 _rangerrors  =  True  # in .dms
@@ -142,6 +145,21 @@ def _TypesError(name, value, *Types, **kwds):
     return _TypeError(name, value, txt=t, **kwds)
 
 
+class _UnexpectedError(TypeError):  # note, a TypeError!
+    '''(INTERNAL) Format a C{TypeError} I{without exception chaining}.
+    '''
+    def __init__(self, *args, **kwds):
+        n = len(kwds)
+        if args:
+            a = _plural(_argument_, len(args))
+            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)
+        # _error_init(TypeError, self, (u,), txt_not_=_expected_)
+        TypeError.__init__(self, _SPACE_(u, _not_, _expected_))
+
+
 class _ValueError(ValueError):
     '''(INTERNAL) Format a C{ValueError} with/-out exception chaining.
     '''
@@ -234,7 +252,7 @@ class LenError(_ValueError):  # in .ecef, .fmath, .heights, .iters, .named
 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.equirectangular_}, C{nearestOn*} and C{simplify*}
+       L{pygeodesy.equirectangular4}, C{nearestOn*} and C{simplify*}
        or methods with C{limit} or C{options} keyword arguments.
 
        @see: Subclass L{UnitError}.
@@ -375,8 +393,8 @@ def crosserrors(raiser=None):
     return t
 
 
-def _error_init(Error, inst, args, fmt_name_value='%s (%r)', txt=NN,
-                                   cause=None, **kwds):  # by .lazily
+def _error_init(Error, inst, args, fmt_name_value='%s (%r)', txt_not_=NN,
+                                   txt__=None, txt=NN, cause=None, **kwds):
     '''(INTERNAL) Format an error text and initialize an C{Error} instance.
 
        @arg Error: The error super-class (C{Exception}).
@@ -388,6 +406,8 @@ def _error_init(Error, inst, args, fmt_name_value='%s (%r)', txt=NN,
                   given as C{name=value} keyword arguments.
        @kwarg fmt_name_value: Format for (name, value) (C{str}).
        @kwarg txt: Optional explanation of the error (C{str}).
+       @kwarg txt__: Alternate C{B{txt}=B{txt__}.__name__}.
+       @kwarg txt_not_: Negative explanation C{B{txt}=_not_(B{txt_not_})}.
        @kwarg cause: Optional, caught error (L{Exception}), for
                      exception chaining (supported in Python 3+).
        @kwarg kwds: Additional C{B{name}=value} pairs, if any.
@@ -409,8 +429,10 @@ def _error_init(Error, inst, args, fmt_name_value='%s (%r)', txt=NN,
         t += _fmtuple(_MODS.basics.itemsorted(kwds))
     t = _or(*t) if t else _SPACE_(_name_value_, MISSING)
 
-    if txt is not None:
-        x =  str(txt) or (str(cause) if cause else _invalid_)
+    x = _not_(txt_not_) if txt_not_ else (txt if txt__ is None
+                                    else  txt__.__name__)
+    if x is not None:
+        x =  str(x) or (str(cause) if cause else _invalid_)
         C = _COMMASPACE_ if _COLON_ in t else _COLONSPACE_
         t =  C(t, x)
 #   else:  # LenError, _xzip, .dms, .heights, .vector2d
@@ -599,7 +621,7 @@ def _xcallable(**names_callables):
     '''
     for n, c in names_callables.items():
         if not callable(c):
-            raise _TypeError(n, c, txt=_not_(callable.__name__))
+            raise _TypeError(n, c, txt_not_=callable.__name__)  # txt__
 
 
 def _xdatum(datum1, datum2, Error=None):
@@ -625,7 +647,7 @@ def _xellipsoidal(**name_value):  # see _xellipsoidall elel
                     return v
             except AttributeError:
                 pass
-            raise _TypeError(n, v, txt=_not_(_ellipsoidal_))
+            raise _TypeError(n, v, txt_not_=_ellipsoidal_)
     raise _xAssertionError(_xellipsoidal, name_value)
 
 
@@ -716,7 +738,7 @@ except AttributeError:
 #         b = getattr(inst, n, None)
 #         if b is None:  # invalid bool attr
 #             t = _SPACE_(_EQUAL_(n, repr(v)), 'for', inst.__class__.__name__)  # XXX .classname
-#             raise _AttributeError(t, txt=_not_('applicable'))
+#             raise _AttributeError(t, txt_not_='applicable')
 #         if v in (False, True) and v != b:
 #             setattr(inst, NN(_UNDER_, n), v)
 
@@ -726,8 +748,8 @@ def _xkwds_get(kwds, **name_default):
        C{default} if not present.
     '''
     if isinstance(kwds, dict) and len(name_default) == 1:
-        for n, d in name_default.items():
-            return kwds.get(n, d)
+        for n, v in name_default.items():
+            return kwds.get(n, v)
     raise _xAssertionError(_xkwds_get, kwds, **name_default)
 
 
@@ -737,8 +759,18 @@ def _xkwds_get_(kwds, **names_defaults):
     '''
     if not isinstance(kwds, dict):
         raise _xAssertionError(_xkwds_get_, kwds)
-    for n, d in _MODS.basics.itemsorted(names_defaults):
-        yield kwds.get(n, d)
+    for n, v in _MODS.basics.itemsorted(names_defaults):
+        yield kwds.get(n, v)
+
+
+def _xkwds_get1(kwds, **name_default):
+    '''(INTERNAL) Get one C{kwds} value by C{name} or the
+       C{default} if not present.
+    '''
+    v, kwds = _xkwds_pop2(kwds, **name_default)
+    if kwds:
+        raise _UnexpectedError(**kwds)
+    return v
 
 
 def _xkwds_item2(kwds):
@@ -762,11 +794,11 @@ def _xkwds_pop2(kwds, **name_default):
        reduced C{kwds} copy, otherwise the C{default} and original C{kwds}.
     '''
     if isinstance(kwds, dict) and len(name_default) == 1:
-        for n, d in name_default.items():
+        for n, v in name_default.items():
             if n in kwds:
                 kwds = _copy(kwds)
-                d = kwds.pop(n, d)
-            return d, kwds
+                v = kwds.pop(n, v)
+            return v, kwds
     raise _xAssertionError(_xkwds_pop2, kwds, **name_default)
 
 
@@ -777,7 +809,7 @@ def _Xorder(_Coeffs, Error, **Xorder):  # in .auxLat, .ktm, .rhumb.bases, .rhumb
     if m in _Coeffs and _MODS.basics.isint(m):
         return m
     t = sorted(map(str, _Coeffs.keys()))
-    raise Error(X, m, txt=_not_(_or(*t)))
+    raise Error(X, m, txt_not_=_or(*t))
 
 # **) MIT License
 #

pygeodesy/etm.py

@@ -71,10 +71,10 @@ from pygeodesy.datums import _ellipsoidal_datum, _WGS84,  _EWGS84
 # from pygeodesy.ellipsoids import _EWGS84  # from .datums
 from pygeodesy.elliptic import _ALL_LAZY, Elliptic
 # from pygeodesy.errors import _incompatible  # from .named
-from pygeodesy.fmath import cbrt, hypot, hypot1, hypot2
-from pygeodesy.fsums import Fsum, fsum1f_
-from pygeodesy.interns import NN, _COMMASPACE_, _DASH_, _near_, _SPACE_, \
-                             _spherical_
+# from pygeodesy.fsums import Fsum  # from .fmath
+from pygeodesy.fmath import cbrt, hypot, hypot1, hypot2,  Fsum
+from pygeodesy.interns import _COMMASPACE_, _DASH_, _near_, _SPACE_, \
+                              _spherical_
 from pygeodesy.karney import _copyBit, _diff182, _fix90, _norm2, _norm180, \
                              _tand, _unsigned2
 # from pygeodesy.lazily import _ALL_LAZY  # from .elliptic
@@ -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.13'
+__version__ = '24.05.31'
 
 _OVERFLOW = _1_EPS**2  # about 2e+31
 _TAYTOL   =  pow(EPS, 0.6)
@@ -101,12 +101,6 @@ _TOL_10   =  EPS * _0_1
 _TRIPS    =  21  # C++ 10
 
 
-def _overflow(x):
-    '''(INTERNAL) Like C{copysign0(OVERFLOW, B{x})}.
-    '''
-    return _copyBit(_OVERFLOW, x)
-
-
 class ETMError(UTMError):
     '''Exact Transverse Mercator (ETM) parse, projection or other
        L{Etm} issue or L{ExactTransverseMercator} conversion failure.
@@ -157,23 +151,21 @@ class Etm(Utm):
         self._exactTM = exactTM
         self._scale0  = exactTM.k0
 
-    def parse(self, strETM, name=NN):
+    def parse(self, strETM, **name):
         '''Parse a string to a similar L{Etm} instance.
 
-           @arg strETM: The ETM coordinate (C{str}),
-                        see function L{parseETM5}.
-           @kwarg name: Optional instance name (C{str}),
-                        overriding this name.
+           @arg strETM: The ETM coordinate (C{str}), see function L{parseETM5}.
+           @kwarg name: Optional C{B{name}=NN} (C{str}), overriding this name.
 
            @return: The instance (L{Etm}).
 
            @raise ETMError: Invalid B{C{strETM}}.
 
-           @see: Function L{pygeodesy.parseUPS5}, L{pygeodesy.parseUTM5}
-                 and L{pygeodesy.parseUTMUPS5}.
+           @see: Function L{pygeodesy.parseUPS5}, L{pygeodesy.parseUTM5} and
+                 L{pygeodesy.parseUTMUPS5}.
         '''
         return parseETM5(strETM, datum=self.datum, Etm=self.classof,
-                                 name=name or self.name)
+                                 name=self._name__(name))
 
     @deprecated_method
     def parseETM(self, strETM):  # PYCHOK no cover
@@ -217,9 +209,7 @@ class Etm(Utm):
         lat, lon, g, k = xTM.reverse(e, n, lon0=lon0)
 
         ll = _LLEB(lat, lon, datum=d, name=self.name)  # utm._LLEB
-        ll._gamma = g
-        ll._scale = k
-        self._latlon5args(ll, _toBand, unfalse, xTM)
+        self._latlon5args(ll, g, k, _toBand, unfalse, xTM)
 
     def toUtm(self):  # PYCHOK signature
         '''Copy this ETM to a UTM coordinate.
@@ -247,7 +237,7 @@ class ExactTransverseMercator(_NamedBase):
     _sigmaC    =  None        # most recent _sigmaInv04 case C{int}
     _zetaC     =  None        # most recent _zetaInv04 case C{int}
 
-    def __init__(self, datum=_WGS84, lon0=0, k0=_K0_UTM, extendp=False, name=NN, raiser=False):
+    def __init__(self, datum=_WGS84, lon0=0, k0=_K0_UTM, extendp=False, raiser=False, **name):
         '''New L{ExactTransverseMercator} projection.
 
            @kwarg datum: The I{non-spherical} datum or ellipsoid (L{Datum},
@@ -255,8 +245,8 @@ class ExactTransverseMercator(_NamedBase):
            @kwarg lon0: Central meridian, default (C{degrees180}).
            @kwarg k0: Central scale factor (C{float}).
            @kwarg extendp: Use the I{extended} domain (C{bool}), I{standard} otherwise.
-           @kwarg name: Optional name for the projection (C{str}).
            @kwarg raiser: If C{True}, throw an L{ETMError} for convergence failures (C{bool}).
+           @kwarg name: Optional C{B{name}=NN} for the projection (C{str}).
 
            @raise ETMError: Near-spherical B{C{datum}} or C{ellipsoid} or invalid B{C{lon0}}
                             or B{C{k0}}.
@@ -444,14 +434,14 @@ class ExactTransverseMercator(_NamedBase):
 
     f = flattening
 
-    def forward(self, lat, lon, lon0=None, name=NN):  # MCCABE 13
+    def forward(self, lat, lon, lon0=None, **name):  # MCCABE 13
         '''Forward projection, from geographic to transverse Mercator.
 
            @arg lat: Latitude of point (C{degrees}).
            @arg lon: Longitude of point (C{degrees}).
            @kwarg lon0: Central meridian (C{degrees180}), overriding
                         the default if not C{None}.
-           @kwarg name: Optional name (C{str}).
+           @kwarg name: Optional C{B{name}=NN} (C{str}).
 
            @return: L{Forward4Tuple}C{(easting, northing, gamma, scale)}.
 
@@ -500,7 +490,7 @@ class ExactTransverseMercator(_NamedBase):
         if _lon:
             x, g = neg_(x, g)
         return Forward4Tuple(x, y, g, k, iteration=self._iteration,
-                                         name=name or self.name)
+                                         name=self._name__(name))
 
     def _Inv03(self, psi, dlam, _3_mv_e):  # (xi, deta, _3_mv)
         '''(INTERNAL) Partial C{_zetaInv04} or C{_sigmaInv04}, Case 2
@@ -609,6 +599,7 @@ class ExactTransverseMercator(_NamedBase):
         _U_2  = Fsum(u).fsum2f_
         _V_2  = Fsum(v).fsum2f_
         # min iterations 2, max 6 or 7, mean 3.9 or 4.0
+        _hy2  = hypot2
         for i in range(1, _TRIPS):  # GEOGRAPHICLIB_PANIC
             sncndn6 =  self._sncndn6(u, v)
             du, dv  = _zetaDwd2(*sncndn6)
@@ -620,7 +611,7 @@ class ExactTransverseMercator(_NamedBase):
             if d2 < tol2:
                 r = False
                 break
-            d2 = hypot2(dU, dV)
+            d2 = _hy2(dU, dV)
 
         self._iteration = i
         if r:  # PYCHOK no cover
@@ -680,14 +671,14 @@ class ExactTransverseMercator(_NamedBase):
         self._mu = mu
         self._mv = mv
 
-    def reverse(self, x, y, lon0=None, name=NN):
+    def reverse(self, x, y, lon0=None, **name):
         '''Reverse projection, from Transverse Mercator to geographic.
 
            @arg x: Easting of point (C{meters}).
            @arg y: Northing of point (C{meters}).
-           @kwarg lon0: Central meridian (C{degrees180}), overriding
-                        the default if not C{None}.
-           @kwarg name: Optional name (C{str}).
+           @kwarg lon0: Optional central meridian (C{degrees180}),
+                        overriding the default (C{iff not None}).
+           @kwarg name: Optional C{B{name}=NN} (C{str}).
 
            @return: L{Reverse4Tuple}C{(lat, lon, gamma, scale)}.
 
@@ -730,9 +721,9 @@ class ExactTransverseMercator(_NamedBase):
             lon, g = neg_(lon, g)
         lat += self._lat0
         lon += self._lon0 if lon0 is None else _norm180(lon0)
-        return Reverse4Tuple(lat, _norm180(lon), g, k,  # _norm180(lat)
+        return Reverse4Tuple(lat, _norm180(lon), g, k,  # _fix90(lat)
                                    iteration=self._iteration,
-                                   name=name or self.name)
+                                   name=self._name__(name))
 
     def _scaled2(self, tau, d2, snu, cnu, dnu, snv, cnv, dnv):
         '''(INTERNAL) C{scaled}.
@@ -768,7 +759,7 @@ class ExactTransverseMercator(_NamedBase):
             #   = sqrt(mv + mv * tau**2 + mu) * sqrt(q2)
             k, q2 = _0_0, (mv * snv**2 + cnudnv**2)
             if q2 > 0:
-                k2 = fsum1f_(mu, mv, mv * tau**2)
+                k2 = (tau**2 + _1_0) * mv + mu
                 if k2 > 0:
                     k = sqrt(k2) * sqrt(q2 / d2) * self.k0
         else:
@@ -811,13 +802,14 @@ class ExactTransverseMercator(_NamedBase):
                                           real /*v*/, real snv, real cnv, real dnv,
                                           real &du, real &dv)}.
         '''
+        mu   = self._mu
         snuv = snu * snv
         # Reciprocal of 55.9: dw / ds = dn(w)^2/_mv,
         # expanding complex dn(w) using A+S 16.21.4
-        d = self._mv * (cnv**2 + self._mu * snuv**2)**2
-        r = cnv * dnu * dnv
-        i = cnu * snuv * self._mu
-        du = (r**2 - i**2) / d
+        d = (cnv**2 + snuv**2 * mu)**2 * self._mv
+        r =  cnv * dnu * dnv
+        i =  cnu * snuv * mu
+        du = (r**2 - i**2) / d  # (r + i) * (r - i) / d
         dv = neg(r * i * _2_0 / d)
         return du, dv
 
@@ -1030,7 +1022,13 @@ class ExactTransverseMercator(_NamedBase):
         return g_k  # or (g, k, lat, lon)
 
 
-def parseETM5(strUTM, datum=_WGS84, Etm=Etm, falsed=True, name=NN):
+def _overflow(x):
+    '''(INTERNAL) Like C{copysign0(OVERFLOW, B{x})}.
+    '''
+    return _copyBit(_OVERFLOW, x)
+
+
+def parseETM5(strUTM, datum=_WGS84, Etm=Etm, falsed=True, **name):
     '''Parse a string representing a UTM coordinate, consisting
        of C{"zone[band] hemisphere easting northing"}.
 
@@ -1040,7 +1038,7 @@ def parseETM5(strUTM, datum=_WGS84, Etm=Etm, falsed=True, name=NN):
        @kwarg Etm: Optional class to return the UTM coordinate
                    (L{Etm}) or C{None}.
        @kwarg falsed: Both easting and northing are C{falsed} (C{bool}).
-       @kwarg name: Optional B{C{Etm}} name (C{str}).
+       @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,
@@ -1051,29 +1049,30 @@ def parseETM5(strUTM, datum=_WGS84, Etm=Etm, falsed=True, name=NN):
 
        @raise TypeError: Invalid or near-spherical B{C{datum}}.
     '''
-    r = _parseUTM5(strUTM, datum, Etm, falsed, Error=ETMError, name=name)
+    r = _parseUTM5(strUTM, datum, Etm, falsed, Error=ETMError, **name)
     return r
 
 
 def toEtm8(latlon, lon=None, datum=None, Etm=Etm, falsed=True,
-                                         name=NN, strict=True,
-                                         zone=None, **cmoff):
+                             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}) or C{None}.
+       @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}.
        @kwarg falsed: False both easting and northing (C{bool}).
-       @kwarg name: Optional B{C{Utm}} name (C{str}).
        @kwarg strict: Restrict B{C{lat}} to UTM ranges (C{bool}).
        @kwarg zone: Optional UTM zone to enforce (C{int} or C{str}).
-       @kwarg cmoff: DEPRECATED, use B{C{falsed}}.  Offset longitude
-                     from the zone's central meridian (C{bool}).
+       @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,
@@ -1097,24 +1096,25 @@ def toEtm8(latlon, lon=None, datum=None, Etm=Etm, falsed=True,
        @raise ValueError: The B{C{lon}} value is missing or B{C{latlon}}
                           is invalid.
     '''
-    z, B, lat, lon, d, f, name = _to7zBlldfn(latlon, lon, datum,
-                                             falsed, name, zone,
-                                             strict, ETMError, **cmoff)
+    z, B, lat, lon, d, f, n = _to7zBlldfn(latlon, lon, datum,
+                                          falsed, zone, strict,
+                                          ETMError, **name_cmoff)
     lon0 = _cmlon(z) if f else None
     x, y, g, k = d.exactTM.forward(lat, lon, lon0=lon0)
 
     return _toXtm8(Etm, z, lat, x, y, B, d, g, k, f,
-                        name, latlon, d.exactTM, Error=ETMError)
+                        n, latlon, d.exactTM, Error=ETMError)
 
 
 if __name__ == '__main__':  # MCCABE 13
 
-    from pygeodesy.internals import _usage
     from pygeodesy import fstr, KTransverseMercator, printf
+    from pygeodesy.internals import _usage
     from sys import argv, exit as _exit
 
     # mimick some of I{Karney}'s utility C{TransverseMercatorProj}
     _f = _r = _s = _t = False
+    _p = -6
     _as = argv[1:]
     while _as and _as[0].startswith(_DASH_):
         _a = _as.pop(0)
@@ -1124,16 +1124,19 @@ if __name__ == '__main__':  # MCCABE 13
             _f, _r = True, False
         elif '-reverse'.startswith(_a):
             _f, _r = False, True
+        elif '-precision'.startswith(_a):
+            _p = int(_as.pop(0))
         elif '-series'.startswith(_a):
             _s, _t = True, False
         elif _a == '-t':
             _s, _t = False, True
         elif '-help'.startswith(_a):
-            _exit(_usage(argv[0], '[-s | -t]',
+            _exit(_usage(argv[0], '[-s | -t ]',
+                                  '[-p[recision] <ndigits>',
                                   '[-f[orward] <lat> <lon>',
-                                  '| -r[everse] <easting> <northing>',
-                                  '| <lat> <lon>]',
-                                  '| -h[elp]'))
+                                  '|-r[everse] <easting> <northing>',
+                                  '|<lat> <lon>]',
+                                  '|-h[elp]'))
         else:
             _exit('%s: option %r not supported' % (_usage(*argv), _a))
     if len(_as) > 1:
@@ -1152,18 +1155,18 @@ if __name__ == '__main__':  # MCCABE 13
         t = tm.reverse(*f2)
     else:
         t = tm.forward(*f2)
-        printf('%s: %s', tm.classname, fstr(t, sep=_SPACE_))
+        printf('%s: %s', tm.classname, fstr(t, prec=_p, sep=_SPACE_))
         t = tm.reverse(t.easting, t.northing)
-    printf('%s: %s', tm.classname, fstr(t, sep=_SPACE_))
+    printf('%s: %s', tm.classname, fstr(t, prec=_p, sep=_SPACE_))
 
 
-# % python3 -m pygeodesy.etm 33.33 44.44
-# ExactTransverseMercator: 4276926.114804 4727193.767015 28.375537 1.233325
-# ExactTransverseMercator: 33.33 44.44 28.375537 1.233325
+# % python3 -m pygeodesy.etm -p 12 33.33 44.44
+# ExactTransverseMercator: 4276926.11480390653 4727193.767015309073 28.375536563148 1.233325101778
+# ExactTransverseMercator: 33.33 44.44 28.375536563148 1.233325101778
 
-# % python3 -m pygeodesy.etm -s 33.33 44.44
-# KTransverseMercator: 4276926.114804 4727193.767015 28.375537 1.233325
-# KTransverseMercator: 33.33 44.44 28.375537 1.233325
+# % python3 -m pygeodesy.etm -s -p 12 33.33 44.44
+# KTransverseMercator: 4276926.114803904667 4727193.767015310004 28.375536563148 1.233325101778
+# KTransverseMercator: 33.33 44.44 28.375536563148 1.233325101778
 
 # % echo 33.33 44.44 | .../bin/TransverseMercatorProj
 # 4276926.114804 4727193.767015 28.375536563148 1.233325101778