pygeodesy 24.5.8__py2.py3-none-any.whl → 24.5.24__py2.py3-none-any.whl

pygeodesy/interns.py

@@ -5,14 +5,11 @@ modules and function L{pygeodesy.machine}.
 '''
 import sys as _sys
 try:
-    _intern =  intern  # PYCHOK in .lazily
+    _intern =  intern  # PYCHOK in .lazily, .trf
 except NameError:  # Python 3+
     _intern = _sys.intern
 
 _COMMASPACE_  = ', '  # overriden below
-_pf2List      = []    # cached _platform2 list
-_Py3List      = []    # cached _pythonarchine list
-
 _sub_packages = 'auxilats', 'deprecated', 'geodesicx', 'rhumb'  # PYCHOK in .lazily,
 # ... make._dist, MANIFEST, setup.setup, test.bases, test.testModules
 
@@ -204,11 +201,10 @@ _distance_            = 'distance'           # PYCHOK OK
 _distant_     = _Prefix('distant')           # PYCHOK OK
 _doesn_t_exist_       = "doesn't exist"      # PYCHOK OK
 _DOT_            = Str_('.')                 # PYCHOK OK
-_down_                = 'down'               # PYCHOK OK
+_dunder_name_         = '__name__'           # PYCHOK _DUNDER_(NN, _name_, NN)
 _e_                   = 'e'                  # PYCHOK OK
 _E_                   = 'E'                  # PYCHOK OK
 _earth_               = 'earth'              # PYCHOK OK
-_east_                = 'east'               # PYCHOK OK
 _easting_             = 'easting'            # PYCHOK OK
 _ecef_                = 'ecef'               # PYCHOK OK
 _edge_                = 'edge'               # PYCHOK OK
@@ -262,8 +258,8 @@ _isclockwise_         = 'isclockwise'        # PYCHOK OK
 _ispolar_             = 'ispolar'            # PYCHOK OK
 _j_                   = 'j'                  # PYCHOK OK
 _k0_                  = 'k0'                 # PYCHOK OK
+_keyword_             = 'keyword'            # PYCHOK OK
 _kind_                = 'kind'               # PYCHOK OK
-_knots_               = 'knots'              # PYCHOK OK
 _Krassovski1940_      = 'Krassovski1940'     # PYCHOK OK
 _Krassowsky1940_      = 'Krassowsky1940'     # PYCHOK OK
 _LANGLE_              = '<'                  # PYCHOK OK
@@ -320,7 +316,6 @@ _NLHASH_         = Str_(_NL_ + '# ')         # PYCHOK OK
 # _NLNL_              = _DNL_                # PYCHOK OK
 _NN_                  = 'NN'                 # PYCHOK OK
 _no_          = _Prefix('no')                # PYCHOK OK
-_north_               = 'north'              # PYCHOK OK
 _northing_            = 'northing'           # PYCHOK OK
 _NorthPole_           = 'NorthPole'          # PYCHOK OK
 _not_         = _Prefix('not')               # PYCHOK OK
@@ -397,7 +392,6 @@ _STAR_           = Str_('*')                 # PYCHOK OK
 _start_               = 'start'              # PYCHOK OK
 _std_                 = 'std'                # PYCHOK OK
 _stdev_               = 'stdev'              # PYCHOK OK
-_supported_           = 'supported'          # PYCHOK OK
 _tbd_                 = 'tbd'                # PYCHOK OK
 _TILDE_               = '~'                  # PYCHOK OK
 _to_                  = 'to'                 # PYCHOK OK
@@ -451,204 +445,9 @@ _LR_PAIRS  = {_LANGLE_:  _RANGLE_,
               _LPAREN_:  _RPAREN_,
               _LSQUARE_: _RSQUARE_}  # PYCHOK OK
 
-
-def _dunder_nameof(inst, *dflt):
-    '''(INTERNAL) Get the double_underscore __name__ attr.
-    '''
-    try:
-        return inst.__name__
-    except AttributeError:
-        pass
-    return dflt[0] if dflt else inst.__class__.__name__
-
-
-def _enquote(strs, quote=_QUOTE2_, white=NN):  # in .basics, .solveBase
-    '''(INTERNAL) Enquote a string containing whitespace or replace
-       whitespace by C{white} if specified.
-    '''
-    if strs:
-        t = strs.split()
-        if len(t) > 1:
-            strs = white.join(t if white else (quote, strs, quote))
-    return strs
-
-
-def _headof(name):
-    '''(INTERNAL) Get the head name of qualified C{name} or the C{name}.
-    '''
-    i = name.find(_DOT_)
-    return name if i < 0 else name[:i]
-
-
-def _is(a, b):  # PYCHOK no cover
-    '''(INTERNAL) C{a is b}? in C{PyPy}
-    '''
-    return (a == b) if _isPyPy() else (a is b)
-
-
-def _isPyPy():
-    '''(INTERNAL) Is this C{PyPy}?
-    '''
-    # platform.python_implementation() == 'PyPy'
-    return _pythonarchine()[0].startswith(_PyPy__)
-
-
-def _load_lib(name):
-    '''(INTERNAL) Load a C{dylib}, B{C{name}} must startwith('lib').
-    '''
-    # macOS 11+ (aka 10.16) no longer provides direct loading of
-    # system libraries.  As a result, C{ctypes.util.find_library}
-    # will not find any library, unless previously installed by a
-    # low-level dlopen(name) call (with the library base C{name}).
-    from ctypes import CDLL
-    from ctypes.util import find_library
-
-    ns = find_library(name), name
-    if _sys.platform[:6] == 'darwin':  # and os.name == 'posix'
-        from ctypes import _dlopen, DEFAULT_MODE
-        from os.path import join
-        ns += (_DOT_(name, 'dylib'),
-               _DOT_(name, 'framework'), join(
-               _DOT_(name, 'framework'), name))
-    else:  # non-macOS
-        DEFAULT_MODE = 0
-
-        def _dlopen(*unused):
-            return True
-
-    for n in ns:
-        try:
-            if n and _dlopen(n, DEFAULT_MODE):  # pre-load handle
-                lib = CDLL(n)  # == ctypes.cdll.LoadLibrary(n)
-                if lib._name:  # has a qualified name
-                    return lib
-        except (AttributeError, OSError):
-            pass
-
-    return None  # raise OSError
-
-
-def machine():
-    '''Return standard C{platform.machine}, but distinguishing Intel I{native}
-       from Intel I{emulation} on Apple Silicon (on macOS only).
-
-       @return: Machine C{'arm64'} for Apple Silicon I{native}, C{'x86_64'}
-                for Intel I{native}, C{"arm64_x86_64"} for Intel I{emulation},
-                etc. (C{str} with C{comma}s replaced by C{underscore}s).
-    '''
-    return _platform2()[1]
-
-
-def _platform2(sep=NN):
-    '''(INTERNAL) Get platform architecture and machine as C{2-list} or C{str}.
-    '''
-    L = _pf2List
-    if not L:
-        import platform
-        m = platform.machine()  # ARM64, arm64, x86_64, iPhone13,2, etc.
-        m = m.replace(_COMMA_, _UNDER_)
-        if m.lower() == 'x86_64':  # on Intel or Rosetta2 ...
-            v = platform.mac_ver()  # ... and only on macOS ...
-            if v and _version2(v[0]) > (10, 15):  # ... 11+ aka 10.16
-                # <https://Developer.Apple.com/forums/thread/659846>
-                if _sysctl_uint('sysctl.proc_translated') == 1:  # and \
-#                  _sysctl_uint('hw.optional.arm64') == 1:  # PYCHOK indent
-                    m = _UNDER_('arm64', m)  # Apple Si emulating Intel x86-64
-        L[:] = [platform.architecture()[0],  # bits
-                m]  # arm64, arm64_x86_64, x86_64, etc.
-    return sep.join(L) if sep else L  # 2-list()
-
-
-def _pythonarchine(sep=NN):  # in test/bases.py versions
-    '''(INTERNAL) Get PyPy and Python versions and C{_platform2} as C{3- or 4-list} or C{str}.
-    '''
-    L = _Py3List
-    if not L:
-        v    = _sys.version
-        L[:] = [_Python_(v)] + _platform2()
-        pypy = _PyPy__(v)
-        if pypy:
-            L.insert(0, pypy)
-    return sep.join(L) if sep else L  # 3- or 4-list
-
-
-def _sysctl_uint(name):
-    '''(INTERNAL) Get an unsigned int sysctl item by name, use on macOS ONLY!
-    '''
-    libc = _load_lib('libc')
-    if libc:  # <https://StackOverflow.com/questions/759892/python-ctypes-and-sysctl>
-        from ctypes import byref, c_char_p, c_size_t, c_uint, sizeof  # get_errno
-        n = name if str is bytes else bytes(name, _utf_8_)  # PYCHOK isPython2 = str is bytes
-        u = c_uint(0)
-        z = c_size_t(sizeof(u))
-        r = libc.sysctlbyname(c_char_p(n), byref(u), byref(z), None, c_size_t(0))
-    else:  # could find or load 'libc'
-        r = -2
-    return int(r if r else u.value)  # -1 ENOENT error, -2 no libc
-
-
-def _tailof(name):
-    '''(INTERNAL) Get the base name of qualified C{name} or the C{name}.
-    '''
-    i = name.rfind(_DOT_) + 1
-    return name[i:] if i > 0 else name
-
-
-def _under(name):  # PYCHOK in .datums, .auxilats, .ups, .utm, .utmupsBase, ...
-    '''(INTERNAL) Prefix C{name} with I{underscore}.
-    '''
-    return name if name.startswith(_UNDER_) else NN(_UNDER_, name)
-
-
-def _usage(file_py, *args):  # in .etm
-    '''(INTERNAL) Build "usage: python -m ..." cmd line for module B{C{file_py}}.
-    '''
-    import os
-    m = os.path.dirname(file_py).replace(os.getcwd(), _ELLIPSIS_) \
-                                .replace(os.sep, _DOT_).strip()
-    b, x = os.path.splitext(os.path.basename(file_py))
-    if x == '.py' and b != '__main__':
-        m = _DOT_(m or _pygeodesy_, b)
-    p = NN(_python_, _sys.version_info[0])
-    return NN('usage', _SPACE_(_COLON_, p, '-m', _enquote(m), *args))
-
-
-def _version2(version, n=2):
-    '''(INTERNAL) Split C{B{version} str} into a C{1-, 2- or 3-tuple} of C{int}s.
-    '''
-    t = _version_ints(version.split(_DOT_, 2))
-    if len(t) < n:
-        t += (0,) * n
-    return t[:n]
-
-
-def _version_info(package):  # in .Base.karney, .basics
-    '''(INTERNAL) Get the C{package.__version_info__} as a 2- or
-       3-tuple C{(major, minor, revision)} if C{int}s.
-    '''
-    try:
-        return _version_ints(package.__version_info__)
-    except AttributeError:
-        return _version2(package.__version__.strip(), n=3)
-
-
-def _version_ints(vs):
-    # helper for _version2 and _version_info above
-
-    def _ints(vs):
-        for v in vs:
-            try:
-                yield int(v.strip())
-            except (TypeError, ValueError):
-                pass
-
-    return tuple(_ints(vs))
-
-
-__all__ = (_NN_,  # not MISSING!
-            Str_.__name__,  # classes
-            machine.__name__)  # in .lazily
-__version__ = '24.05.08'
+__all__ = (_NN_,  # NOT MISSING!
+            Str_.__name__)  # classes
+__version__ = '24.05.21'
 
 if __name__ == '__main__':
 

pygeodesy/iters.py

@@ -9,15 +9,16 @@ the initial items, skipping of duplicate items and copying of the
 iterated items.
 '''
 
-from pygeodesy.basics import islistuple, issubclassof, \
-                             len2, map2, _passarg
+from pygeodesy.basics import islistuple, issubclassof, len2, \
+                             map2,  _passarg
 # from pygeodesy.constants import _1_0  # from .utily
 from pygeodesy.errors import _IndexError, LenError, PointsError, \
                              _TypeError, _ValueError
-from pygeodesy.interns import NN, _0_, _composite_, _few_, \
-                             _latlon_, _points_, _too_
+# from pygeodesy.internals import _passarg  # from .basics
+from pygeodesy.interns import _0_, _composite_, _few_, _latlon_, \
+                              _points_, _too_
 from pygeodesy.lazily import _ALL_DOCS, _ALL_LAZY, _ALL_MODS as _MODS
-from pygeodesy.named import Fmt, _Named, property_RO
+from pygeodesy.named import _Named, property_RO,  Fmt
 from pygeodesy.namedTuples import Point3Tuple, Points2Tuple
 # from pygeodesy.props import property_RO  # from .named
 # from pygeodesy.streprs import Fmt  # from .named
@@ -25,7 +26,7 @@ from pygeodesy.units import Int, Radius
 from pygeodesy.utily import degrees2m, _Wrap,  _1_0
 
 __all__ = _ALL_LAZY.iters
-__version__ = '23.12.14'
+__version__ = '24.05.23'
 
 _items_        = 'items'
 _iterNumpy2len =  1  # adjustable for testing purposes
@@ -49,7 +50,7 @@ class _BaseIter(_Named):
     _prev   = _NOTHING
     _wrap   =  False
 
-    def __init__(self, items, loop=0, dedup=False, Error=None, name=NN):
+    def __init__(self, items, loop=0, dedup=False, Error=None, **name):
         '''New iterator over an iterable of B{C{items}}.
 
            @arg items: Iterable (any C{type}, except composites).
@@ -57,7 +58,7 @@ class _BaseIter(_Named):
                         iterate index (non-negative C{int}).
            @kwarg dedup: Skip duplicate items (C{bool}).
            @kwarg Error: Error to raise (L{LenError}).
-           @kwarg name: Optional name (C{str}).
+           @kwarg name: Optional C{B{name}="items"} (C{str}).
 
            @raise Error: Invalid B{C{items}} or sufficient number of B{C{items}}.
 
@@ -237,10 +238,11 @@ class _BaseIter(_Named):
 class PointsIter(_BaseIter):
     '''Iterator for C{points} with optional loop-back and copies.
     '''
-    _base  = None
-    _Error = PointsError
+    _base  =  None
+    _Error =  PointsError
+    _name  = _points_
 
-    def __init__(self, points, loop=0, base=None, dedup=False, wrap=False, name=NN):
+    def __init__(self, points, loop=0, base=None, dedup=False, wrap=False, **name):
         '''New L{PointsIter} iterator.
 
            @arg points: C{Iterable} or C{list}, C{sequence}, C{set}, C{tuple},
@@ -251,13 +253,13 @@ class PointsIter(_BaseIter):
            @kwarg dedup: Skip duplicate points (C{bool}).
            @kwarg wrap: If C{True}, wrap or I{normalize} the enum-/iterated
                         B{C{points}} (C{bool}).
-           @kwarg name: Optional name (C{str}).
+           @kwarg name: Optional C{B{name}="points"} (C{str}).
 
            @raise PointsError: Insufficient number of B{C{points}}.
 
            @raise TypeError: Some B{C{points}} are not B{C{base}}.
        '''
-        _BaseIter.__init__(self, points, loop=loop, dedup=dedup, name=name or _points_)
+        _BaseIter.__init__(self, points, loop=loop, dedup=dedup, **name)
 
         if base and not (isNumpy2(points) or isTuple2(points)):
             self._base = base
@@ -309,12 +311,13 @@ class PointsIter(_BaseIter):
 class LatLon2PsxyIter(PointsIter):
     '''Iterate and convert for C{points} with optional loop-back and copies.
     '''
-    _deg2m  = None
-    _radius = None  # keep degrees
-    _wrap   = True
+    _deg2m  =  None
+    _name   = _latlon_
+    _radius =  None  # keep degrees
+    _wrap   =  True
 
     def __init__(self, points, loop=0, base=None, wrap=True, radius=None,
-                                                  dedup=False, name=_latlon_):
+                                                  dedup=False, **name):
         '''New L{LatLon2PsxyIter} iterator.
 
            @note: The C{LatLon} latitude is considered the I{pseudo-y} and
@@ -330,13 +333,13 @@ class LatLon2PsxyIter(PointsIter):
            @kwarg radius: Mean earth radius (C{meter}) for conversion from
                           C{degrees} to C{meter} (or C{radians} if C{B{radius}=1}).
            @kwarg dedup: Skip duplicate points (C{bool}).
-           @kwarg name: Optional name (C{str}).
+           @kwarg name: Optional C{B{name}="latlon"} (C{str}).
 
            @raise PointsError: Insufficient number of B{C{points}}.
 
            @raise TypeError: Some B{C{points}} are not B{C{base}}-compatible.
         '''
-        PointsIter.__init__(self, points, loop=loop, base=base, dedup=dedup, name=name)
+        PointsIter.__init__(self, points, loop=loop, base=base, dedup=dedup, **name)
         if not wrap:
             self._wrap = False
         if radius:

pygeodesy/karney.py

@@ -140,15 +140,15 @@ in C{pygeodesy} are based on I{Karney}'s post U{Area of a spherical polygon
 from __future__ import division as _; del _  # PYCHOK semicolon
 
 from pygeodesy.basics import _copysign, int1s, isint, itemsorted, neg, unsigned0, \
-                             _xgeographiclib, _zip
+                             _xgeographiclib, _zip,  _version_info
 from pygeodesy.constants import NAN, _isfinite as _math_isfinite, _0_0, \
-                               _1_16th,  _1_0, _2_0, _180_0, _N_180_0, _360_0
+                               _1_16th, _1_0, _2_0, _180_0, _N_180_0, _360_0
 from pygeodesy.errors import GeodesicError, _ValueError, _xkwds, _xkwds_get
 from pygeodesy.fmath import cbrt, fremainder, norm2
+# from pygeodesy.internals import _version_info  # from .basics
 from pygeodesy.interns import NN, _2_, _a12_, _area_, _azi2_, _azi12_, _composite_, \
                              _lat1_, _lat2_, _lon1_, _lon2_, _m12_, _M12_, _M21_, \
-                             _number_, _s12_, _S12_, _UNDER_, _version_info, \
-                             _BAR_  # PYCHOK used!
+                             _number_, _s12_, _S12_, _UNDER_, _BAR_  # PYCHOK used!
 from pygeodesy.lazily import _ALL_DOCS, _ALL_LAZY, _ALL_MODS as _MODS, _getenv
 from pygeodesy.named import ADict, _NamedBase, _NamedTuple, notImplemented, _Pass
 from pygeodesy.props import deprecated_method, Property_RO
@@ -159,7 +159,7 @@ from pygeodesy.utily import atan2d, sincos2d, tand, _unrollon,  fabs
 # from math import fabs  # from .utily
 
 __all__ = _ALL_LAZY.karney
-__version__ = '24.03.22'
+__version__ = '24.05.20'
 
 _K_2_0      = _getenv('PYGEODESY_GEOGRAPHICLIB', _2_) == _2_
 _perimeter_ = 'perimeter'
@@ -168,7 +168,7 @@ _perimeter_ = 'perimeter'
 class _GTuple(_NamedTuple):  # in .testNamedTuples
     '''(INTERNAL) Helper.
     '''
-    def toGDict(self, **updates):
+    def toGDict(self, **updates):  # NO name=NN
         '''Convert this C{*Tuple} to a L{GDict}.
 
            @kwarg updates: Optional items to apply (C{nam=value} pairs)
@@ -359,12 +359,11 @@ class _CapsBase(_NamedBase):  # in .auxilats, .geodesicx.gxbases
         '''
         self._debug = Caps._DEBUG_ALL if debug else 0
 
-    def _iter2tion(self, r, s):
+    def _iter2tion(self, r, iter=None, **unused):
         '''(INTERNAL) Copy C{C{s}.iter} into C{B{r}._iteration}.
         '''
-        i = _xkwds_get(s, iter=None)
-        if i is not None:
-            self._iteration = r._iteration = i
+        if iter is not None:
+            self._iteration = r._iteration = iter
         return r
 
 
@@ -468,7 +467,7 @@ class Inverse10Tuple(_GTuple):
 
            @kwarg updates: Optional items to apply (C{nam=value} pairs)
         '''
-        return _GTuple.toGDict(self, azi1=atan2d(self.salp1, self.calp1),  # PYCHOK indent, namedTuple
+        return _GTuple.toGDict(self, azi1=atan2d(self.salp1, self.calp1),  # PYCHOK namedTuple
                                      azi2=atan2d(self.salp2, self.calp2),  # PYCHOK namedTuple
                                    **updates)  # PYCHOK indent
 
@@ -750,7 +749,10 @@ def _polynomial(x, cs, i, j):  # PYCHOK shared
 #       for c in cs[i+1:j]:
 #           s, t = _sum2_(s * x, t * x, c)
 #       return s  # + t
-    s, _ = _sum2_(cs[i], _0_0, x=x, *cs[i+1:j])
+    s  = cs[i]
+    i += 1
+    if x and i < j:
+        s, _ = _sum2_(s, _0_0, x=x, *cs[i:j])
     return s  # + t
 
 
@@ -843,11 +845,12 @@ def _sum2_(s, t, *vs, **x):
 
        @note: NOT "error-free", see C{pygeodesy.test/testKarney.py}.
     '''
-    x = _xkwds_get(x, x=0)
+    x = _xkwds_get(x, x=_1_0)
+    p =  x != _1_0
 
     _s2, _u0 = _sum2, unsigned0
     for v in vs:
-        if x:
+        if p:
             s *= x
             t *= x
         if v:
@@ -857,7 +860,7 @@ def _sum2_(s, t, *vs, **x):
                 if s:
                     t += u  # accumulate u into t
 #               elif t:  # s == 0 implies t == 0
-#                   raise _AssertionError(t=t, txt=_not_(_0_))
+#                   raise _AssertionError(t=t, txt_not_=_0_)
                 else:
                     s = _u0(u)  # result is u, t = 0
             else:

pygeodesy/ktm.py

@@ -48,18 +48,18 @@ from pygeodesy.constants import INF, _K0_UTM, PI, PI_2, _0_0s, _0_0, \
                                _1_0, _90_0, _copysignINF
 from pygeodesy.datums import Datum, _spherical_datum, _WGS84,  _EWGS84
 # from pygeodesy.ellipsoids import _EWGS84  # from .datums
-from pygeodesy.errors import _ValueError, _xkwds_get, _Xorder
+from pygeodesy.errors import _ValueError, _xkwds_pop2, _Xorder
 from pygeodesy.fmath import hypot, hypot1
 from pygeodesy.fsums import fsum1f_
-from pygeodesy.interns import NN, _COMMASPACE_, _singular_
+from pygeodesy.interns import _COMMASPACE_, _singular_
 from pygeodesy.karney import _atan2d, _diff182, _fix90, _norm180, \
-                             _polynomial, _unsigned2,  _NamedBase
-from pygeodesy.lazily import _ALL_LAZY,  _pairs
-# from pygeodesy.named import _NamedBase  # from .karney
+                             _polynomial, _unsigned2
+# from pygeodesy.lazily import _ALL_LAZY  # from .named
+from pygeodesy.named import _NamedBase, pairs,  _ALL_LAZY
 from pygeodesy.namedTuples import Forward4Tuple, Reverse4Tuple
 from pygeodesy.props import property_doc_, Property, Property_RO, \
                            _update_all
-# from pygeodesy.streprs import pairs as _pairs  # from .lazily
+# from pygeodesy.streprs import pairs  # from .named
 from pygeodesy.units import Degrees, Scalar_, _1mm as _TOL_10  # PYCHOK used!
 from pygeodesy.utily import atan1d, _loneg, sincos2, sincos2d_
 
@@ -67,7 +67,7 @@ from cmath import polar
 from math import atan2, asinh, cos, cosh, degrees, fabs, sin, sinh, sqrt, tanh
 
 __all__ = _ALL_LAZY.ktm
-__version__ = '24.01.02'
+__version__ = '24.05.24'
 
 
 class KTMError(_ValueError):
@@ -115,24 +115,33 @@ class KTransverseMercator(_NamedBase):
     _mTM    =  6
     _raiser =  False   # throw Error
 
-    def __init__(self, a_earth=_EWGS84, f=None, lon0=0, k0=_K0_UTM, name=NN,
-                                                raiser=False, **TMorder):
+    def __init__(self, a_earth=_EWGS84, f=None, lon0=0, k0=_K0_UTM,
+                                   raiser=False, **TMorder_name):
         '''New L{KTransverseMercator}.
 
            @kwarg a_earth: This rhumb's earth (L{Ellipsoid}, L{Ellipsoid2},
                            L{a_f2Tuple}, L{Datum}, 2-tuple (C{a, f})) or the
                            equatorial radius (C{scalar}, C{meter}).
-           @kwarg f: The ellipsoid's flattening (C{scalar}), iff B{C{a_earth}} is
-                     a C{scalar}, ignored otherwise.
+           @kwarg f: The ellipsoid's flattening (C{scalar}), iff B{C{a_earth}}
+                     is a C{scalar}, ignored otherwise.
            @kwarg lon0: The central meridian (C{degrees180}).
            @kwarg k0: Central scale factor (C{scalar}).
-           @kwarg name: Optional name (C{str}).
            @kwarg raiser: If C{True}, throw a L{KTMError} for C{forward}
                           singularities (C{bool}).
-           @kwarg TMorder: Keyword argument B{C{TMorder}}, see property C{TMorder}.
+           @kwarg TMorder_name: Optional C{B{name}=NN} (C{str}) and optional
+                          keyword argument C{B{TMorder}=6} for the order of
+                          this L{KTransverseMercator}, see property C{TMorder}.
 
            @raise KTMError: Invalid B{C{a_earth}}, B{C{f}} or B{C{TMorder}}.
         '''
+        if TMorder_name:
+            M = self._mTM
+            m, name = _xkwds_pop2(TMorder_name, TMorder=M)
+            if m != M:
+                self.TMorder = m
+            if name:
+                self.name = name
+
         if f is not None:
             self.ellipsoid = a_earth, f
         elif a_earth in (_EWGS84, _WGS84, None):
@@ -141,14 +150,11 @@ class KTransverseMercator(_NamedBase):
             self.datum = a_earth
         else:
             self.ellipsoid = a_earth
+
         self.lon0 = lon0
         self.k0 = k0
-        if name:  # PYCHOK no cover
-            self.name = name
         if raiser:
             self.raiser = True
-        if TMorder:
-            self.TMorder = _xkwds_get(TMorder, TMorder=self._mTM)
 
     @Property_RO
     def _Alp(self):
@@ -215,13 +221,13 @@ class KTransverseMercator(_NamedBase):
 
     f = flattening
 
-    def forward(self, lat, lon, lon0=None, name=NN):
+    def forward(self, lat, lon, lon0=None, **name):
         '''Forward projection, from geographic to transverse Mercator.
 
            @arg lat: Latitude of point (C{degrees90}).
            @arg lon: Longitude of point (C{degrees180}).
            @arg lon0: Central meridian of the projection (C{degrees180}).
-           @kwarg name: Optional name (C{str}).
+           @kwarg name: Optional C{B{name}=NN} (C{str}).
 
            @return: L{Forward4Tuple}C{(easting, northing, gamma, scale)}
                     with C{easting} and C{northing} in C{meter}, unfalsed, the
@@ -272,7 +278,7 @@ class KTransverseMercator(_NamedBase):
             y, g = neg_(y, g)
         if _lon:
             x, g = neg_(x, g)
-        return Forward4Tuple(x, y, _norm180(g), k, name=name or self.name)
+        return Forward4Tuple(x, y, _norm180(g), k, name=self._name__(name))
 
     @property_doc_(''' the central scale factor (C{float}).''')
     def k0(self):
@@ -347,12 +353,13 @@ class KTransverseMercator(_NamedBase):
         self. lon0 =  lon0
         return t
 
-    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{meter}).
            @arg y: Northing of point (C{meter}).
            @arg lon0: Central meridian of the projection (C{degrees180}).
+           @kwarg name: Optional C{B{name}=NN} (C{str}).
 
            @return: L{Reverse4Tuple}C{(lat, lon, gamma, scale)} with
                     C{lat}- and C{lon}gitude in C{degrees}, I{unfalsed}.
@@ -394,7 +401,7 @@ class KTransverseMercator(_NamedBase):
         lat += self._lat0
         lon += self._lon0 if lon0 is None else _norm180(lon0)
         return Reverse4Tuple(lat, _norm180(lon), _norm180(g), k,
-                                   name=name or self.name)
+                                   name=self._name__(name))
 
     @Property
     def TMorder(self):
@@ -419,7 +426,7 @@ class KTransverseMercator(_NamedBase):
         d = dict(ellipsoid=self.ellipsoid, k0=self.k0, TMorder=self.TMorder)
         if self.name:  # PYCHOK no cover
             d.update(name=self.name)
-        return _COMMASPACE_.join(_pairs(d, **kwds))
+        return _COMMASPACE_.join(pairs(d, **kwds))
 
 
 def _cma(a, b0, b1, Cn):
@@ -605,7 +612,7 @@ assert set(_AlpCoeffs.keys()) == set(_BetCoeffs.keys())
 
 if __name__ == '__main__':
 
-    from pygeodesy.interns import _usage
+    from pygeodesy.internals import _usage
     from sys import argv, exit as _exit
 
     _exit(_usage(*argv).replace('.ktm', '.etm -series'))