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

pygeodesy/internals.py

@@ -3,11 +3,11 @@
 u'''Mostly INTERNAL functions, except L{machine}, L{print_} and L{printf}.
 '''
 # from pygeodesy.basics import isiterablen  # _MODS
-# from pygeodesy.errors import _AttributeError, _error_init, _xError2  # _MODS
+# from pygeodesy.errors import _AttributeError, _error_init, _UnexpectedError, _xError2  # _MODS
 from pygeodesy.interns import NN, _COLON_, _DOT_, _ELLIPSIS_, _EQUALSPACED_, \
                              _immutable_, _NL_, _pygeodesy_, _PyPy__, _python_, \
-                             _QUOTE1_, _QUOTE2_, _SPACE_, _UNDER_, _utf_8_
-from pygeodesy.interns import _COMMA_, _sys, _Python_  # PYCHOK used!
+                             _QUOTE1_, _QUOTE2_, _s_, _SPACE_, _sys, _UNDER_, _utf_8_
+from pygeodesy.interns import _COMMA_, _Python_  # PYCHOK used!
 # from pygeodesy.streprs import anstr, pairs, unstr  # _MODS
 
 import os as _os  # in .lazily, ...
@@ -222,7 +222,7 @@ def _caller3(up):  # in .lazily, .named
             f.f_lineno)  # line number
 
 
-def _dunder_main(name):
+def _dunder_ismain(name):
     '''(INTERNAL) Return C{name == '__main__'}.
     '''
     return name == '__main__'
@@ -353,6 +353,12 @@ def _passargs(*args):
     return args
 
 
+def _plural(noun, n):
+    '''(INTERNAL) Return C{noun}['s'] or C{NN}.
+    '''
+    return NN(noun, _s_) if n > 1 else (noun if n else NN)
+
+
 def print_(*args, **nl_nt_prec_prefix__end_file_flush_sep_kwds):  # PYCHOK no cover
     '''Python 3+ C{print}-like formatting and printing.
 
@@ -497,7 +503,7 @@ def _usage(file_py, *args):  # in .etm
     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 not _dunder_main(b):
+    if x == '.py' and not _dunder_ismain(b):
         m = _DOT_(m or _pygeodesy_, b)
     p =  NN(_python_, _sys.version_info[0])
     u = _COLON_(_dunder_nameof(_usage)[1:], NN)
@@ -536,11 +542,10 @@ def _version_ints(vs):
     return tuple(_ints(vs))
 
 
-__all__ = (machine.__name__,
-           print_.__name__, printf.__name__)  # _dunder_nameof
-__version__ = '24.05.15'
+__all__ = tuple(map(_dunder_nameof, (machine, print_, printf)))
+__version__ = '24.05.21'
 
-if _dunder_main(__name__):  # PYCHOK no cover
+if _dunder_ismain(__name__):  # PYCHOK no cover
 
     from pygeodesy import _isfrozen, isLazy, version as vs
 

pygeodesy/interns.py

@@ -201,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
@@ -259,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
@@ -317,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
@@ -394,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
@@ -450,7 +447,7 @@ _LR_PAIRS  = {_LANGLE_:  _RANGLE_,
 
 __all__ = (_NN_,  # NOT MISSING!
             Str_.__name__)  # classes
-__version__ = '24.05.13'
+__version__ = '24.05.21'
 
 if __name__ == '__main__':
 

pygeodesy/iters.py

@@ -15,10 +15,10 @@ from pygeodesy.basics import islistuple, issubclassof, len2, \
 from pygeodesy.errors import _IndexError, LenError, PointsError, \
                              _TypeError, _ValueError
 # from pygeodesy.internals import _passarg  # from .basics
-from pygeodesy.interns import NN, _0_, _composite_, _few_, \
-                             _latlon_, _points_, _too_
+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
@@ -26,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
@@ -50,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).
@@ -58,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}}.
 
@@ -238,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},
@@ -252,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
@@ -310,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
@@ -331,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

@@ -142,7 +142,7 @@ from __future__ import division as _; del _  # PYCHOK semicolon
 from pygeodesy.basics import _copysign, int1s, isint, itemsorted, neg, unsigned0, \
                              _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
@@ -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.05.13'
+__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,10 +48,10 @@ 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
 # from pygeodesy.lazily import _ALL_LAZY  # from .named
@@ -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.05.11'
+__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):

pygeodesy/latlonBase.py

@@ -53,7 +53,7 @@ from contextlib import contextmanager
 from math import asin, cos, degrees, fabs, radians
 
 __all__ = _ALL_LAZY.latlonBase
-__version__ = '24.04.07'
+__version__ = '24.05.18'
 
 
 class LatLonBase(_NamedBase):
@@ -66,7 +66,7 @@ class LatLonBase(_NamedBase):
     _lat    = 0     # latitude (C{degrees})
     _lon    = 0     # longitude (C{degrees})
 
-    def __init__(self, latlonh, lon=None, height=0, wrap=False, name=NN, datum=None):
+    def __init__(self, latlonh, lon=None, height=0, wrap=False, datum=None, **name):
         '''New C{LatLon}.
 
            @arg latlonh: Latitude (C{degrees} or DMS C{str} with N or S suffix) or
@@ -77,9 +77,9 @@ class LatLonBase(_NamedBase):
                           (C{meter}, conventionally).
            @kwarg wrap: If C{True}, wrap or I{normalize} B{C{lat}} and B{C{lon}}
                         (C{bool}).
-           @kwarg name: Optional name (C{str}).
            @kwarg datum: Optional datum (L{Datum}, L{Ellipsoid}, L{Ellipsoid2},
                          L{a_f2Tuple} or I{scalar} radius) or C{None}.
+           @kwarg name: Optional C{B{name}=NN} (C{str}).
 
            @return: New instance (C{LatLon}).
 
@@ -1418,13 +1418,14 @@ class LatLonBase(_NamedBase):
             for p in (p, c):
                 e = _xattr(p, Ecef=None)
                 if e not in (None, E):  # PYCHOK no cover
-                    n = Fmt.INDEX(_xkwds_item2(name_point)[0], i)
-                    raise _ValueError(n, e, txt=_incompatible(E.__name__))
+                    n, _ = _xkwds_item2(name_point)
+                    n = Fmt.INDEX(n, i)
+                    raise _ValueError(n, e, txt=_incompatible(E.__name__))  # txt__
         return c
 
-    def toDatum(self, datum2, height=None, name=NN):
+    def toDatum(self, datum2, height=None, **name):
         '''I{Must be overloaded}.'''
-        self._notOverloaded(datum2, height=height, name=name)
+        self._notOverloaded(datum2, height=height, **name)
 
     def toEcef(self, height=None, M=False):
         '''Convert this point to I{geocentric} coordinates, also known as
@@ -1476,16 +1477,16 @@ class LatLonBase(_NamedBase):
         return self._Ltp if Ecef in (None, self.Ecef) else self._ltp.Ltp(
                self, ecef=Ecef(self.datum), name=self.name)
 
-    def toNormal(self, deep=False, name=NN):
+    def toNormal(self, deep=False, **name):
         '''Get this point I{normalized} to C{abs(lat) <= 90}
            and C{abs(lon) <= 180}.
 
            @kwarg deep: If C{True} make a deep, otherwise a
                         shallow copy (C{bool}).
-           @kwarg name: Optional name of the copy (C{str}).
+           @kwarg name: Optional C{B{name}=NN} (C{str}).
 
-           @return: A copy of this point, I{normalized} and
-                    optionally renamed (C{LatLon}).
+           @return: A copy of this point, I{normalized} (C{LatLon}),
+                    optionally renamed.
 
            @see: Property L{isnormal}, method L{normal} and function
                  L{pygeodesy.normal}.

pygeodesy/lazily.py

@@ -30,7 +30,7 @@ and line number.
 from pygeodesy import internals as _internals, interns as _interns, \
                      _isfrozen  # DON'T _lazy_import2
 # from pygeodesy.errors import _error_init  # _ALL_MODS
-from pygeodesy.internals import _caller3, _dunder_nameof, _dunder_main, \
+from pygeodesy.internals import _caller3, _dunder_nameof, _dunder_ismain, \
                                 _headof, _osversion2, printf, _Pythonarchine, \
                                 _tailof
 from pygeodesy.interns import NN, _areaOf_, _attribute_, _by_, _COLONSPACE_, \
@@ -771,7 +771,7 @@ def _lazy_init2(pack):
     _unLazy0 = _unlazy or not isLazy  # pre-3.7 or w/o lazy import
 
     if isLazy < 1:  # not enabled
-        raise LazyImportError(_PYGEODESY_LAZY_IMPORT_, repr(z), txt=_not_(_enabled_))
+        raise LazyImportError(_PYGEODESY_LAZY_IMPORT_, repr(z), txt_not_=_enabled_)
     if _getenv('PYTHONVERBOSE', None):  # PYCHOK no cover
         isLazy += 1
 
@@ -805,7 +805,7 @@ def _lazy_module(name):  # overwritten by _lazy_import2
 #        update the package's C{__dict__} accordingly.
 #     '''
 #     sm = dict()
-#     if force and not _dunder_main(_dunder_name_):
+#     if force and not _dunder_ismain(_dunder_name_):
 #         nm = _tailof(_dunder_name_)
 #         _a = _ALL_MODS.getattr
 #         _m = _ALL_MODS.getmodule
@@ -827,7 +827,7 @@ def _lazy_module(name):  # overwritten by _lazy_import2
 
 # del _i, _i0
 
-if _dunder_main(__name__):  # PYCHOK no cover
+if _dunder_ismain(__name__):  # PYCHOK no cover
 
     from timeit import timeit
 

pygeodesy/lcc.py

@@ -30,26 +30,25 @@ from pygeodesy.constants import EPS, EPS02, PI_2, _float as _F, _0_0, _0_5, \
 from pygeodesy.ellipsoidalBase import LatLonEllipsoidalBase as _LLEB
 from pygeodesy.datums import Datums, _ellipsoidal_datum
 from pygeodesy.errors import _IsnotError, _ValueError
-from pygeodesy.fmath import _ALL_LAZY, hypot
+from pygeodesy.fmath import hypot, _ALL_LAZY
 from pygeodesy.interns import NN, _COMMASPACE_, _ellipsoidal_, _GRS80_, _k0_, \
-                             _lat0_, _lon0_, _m_, _NAD83_, _NTF_, _SPACE_, _WGS84_, \
-                             _C_  # PYCHOK used!
+                             _lat0_, _lon0_, _m_, _NAD83_, _NTF_, _SPACE_, \
+                             _WGS84_,  _C_  # PYCHOK used!
 # from pygeodesy.lazily import _ALL_LAZY  # from .fmath
-from pygeodesy.named import _lazyNamedEnumItem as _lazy, _NamedBase, \
-                            _NamedEnum, _NamedEnumItem, nameof, _xnamed
+from pygeodesy.named import _lazyNamedEnumItem as _lazy, _name2__, _NamedBase, \
+                    _NamedEnum, _NamedEnumItem, _xnamed
 from pygeodesy.namedTuples import EasNor3Tuple, LatLonDatum3Tuple, \
                                   LatLon2Tuple, _LL4Tuple, PhiLam2Tuple
-from pygeodesy.props import deprecated_method, Property, Property_RO, \
-                           _update_all
+from pygeodesy.props import deprecated_method, Property, Property_RO, _update_all
 from pygeodesy.streprs import Fmt, _fstrENH2, _xzipairs
-from pygeodesy.units import Easting, Height, _heigHt,  Lam_, Northing, \
-                            Phi_, Scalar_
+from pygeodesy.units import Easting, Height, _heigHt,  Lam_, Northing, Phi_, \
+                            Scalar_
 from pygeodesy.utily import atan1, degrees90, degrees180, sincos2, tanPI_2_2
 
 from math import atan, fabs, log, radians, sin, sqrt
 
 __all__ = _ALL_LAZY.lcc
-__version__ = '23.12.03'
+__version__ = '24.05.24'
 
 _E0_   = 'E0'
 _N0_   = 'N0'
@@ -83,7 +82,7 @@ class Conic(_NamedEnumItem):
     _r0  = _0_0  # precomputed rho0 (C{float})
 
     def __init__(self, latlon0, par1, par2=None, E0=0, N0=0,
-                       k0=1, opt3=0, name=NN, auth=NN):
+                       k0=1, opt3=0, auth=NN, **name):
         '''New Lambert conformal conic projection.
 
            @arg latlon0: Origin with (ellipsoidal) datum (C{LatLon}).
@@ -93,8 +92,8 @@ class Conic(_NamedEnumItem):
            @kwarg N0: Optional, false northing (C{meter}).
            @kwarg k0: Optional scale factor (C{scalar}).
            @kwarg opt3: Optional meridian (C{degrees180}).
-           @kwarg name: Optional name of the conic (C{str}).
            @kwarg auth: Optional authentication authority (C{str}).
+           @kwarg name: Optional C{B{name}=NN} for the conic (C{str}).
 
            @return: A Lambert projection (L{Conic}).
 
@@ -283,7 +282,7 @@ class Conic(_NamedEnumItem):
         '''Return this conic as a string.
 
            @kwarg prec: Number of (decimal) digits, unstripped (C{int}).
-           @kwarg name: Override name (C{str}) or C{None} to exclude
+           @kwarg name: Overriding name (C{str}) or C{None} to exclude
                         this conic's name.
 
            @return: Conic attributes (C{str}).
@@ -400,14 +399,14 @@ class Lcc(_NamedBase):
     _height   =  0     # height (C{meter})
     _northing = _0_0   # Northing (C{float})
 
-    def __init__(self, e, n, h=0, conic=Conics.WRF_Lb, name=NN):
+    def __init__(self, e, n, h=0, conic=Conics.WRF_Lb, **name):
         '''New L{Lcc} Lamber conformal conic position.
 
            @arg e: Easting (C{meter}).
            @arg n: Northing (C{meter}).
            @kwarg h: Optional height (C{meter}).
            @kwarg conic: Optional, the conic projection (L{Conic}).
-           @kwarg name: Optional name (C{str}).
+           @kwarg name: Optional C{B{name}=NN} (C{str}).
 
            @return: The Lambert location (L{Lcc}).
 
@@ -614,27 +613,27 @@ class Lcc(_NamedBase):
         return t if sep is None else sep.join(t)
 
 
-def toLcc(latlon, conic=Conics.WRF_Lb, height=None, Lcc=Lcc, name=NN,
-                                                  **Lcc_kwds):
+def toLcc(latlon, conic=Conics.WRF_Lb, height=None, Lcc=Lcc,
+                                             **name_Lcc_kwds):
     '''Convert an (ellipsoidal) geodetic point to a I{Lambert} location.
 
        @arg latlon: Ellipsoidal point (C{LatLon}).
        @kwarg conic: Optional Lambert projection to use (L{Conic}).
        @kwarg height: Optional height for the point, overriding the
                       default height (C{meter}).
-       @kwarg Lcc: Optional class to return the I{Lambert} location
-                   (L{Lcc}).
-       @kwarg name: Optional B{C{Lcc}} name (C{str}).
-       @kwarg Lcc_kwds: Optional, additional B{C{Lcc}} keyword
-                        arguments, ignored if B{C{Lcc}} is C{None}.
+       @kwarg Lcc: Class to return the I{Lambert} location (L{Lcc}).
+       @kwarg name_Lcc_kwds: Optional C{B{name}=NN} (C{str}) for the
+                   location and optional, additional B{C{Lcc}} keyword
+                   arguments, ignored if B{C{Lcc}} is C{None}.
 
        @return: The I{Lambert} location (L{Lcc}) or an
-                L{EasNor3Tuple}C{(easting, northing, height)}
-                if C{B{Lcc} is None}.
+                L{EasNor3Tuple}C{(easting, northing, height)} if
+                C{B{Lcc} is None}.
 
        @raise TypeError: If B{C{latlon}} is not ellipsoidal.
     '''
     _xinstanceof(_LLEB, latlon=latlon)
+    name, Lcc_kwds = _name2__(name_Lcc_kwds)
 
     a, b = latlon.philam
     c = conic.toDatum(latlon.datum)
@@ -649,7 +648,7 @@ def toLcc(latlon, conic=Conics.WRF_Lb, height=None, Lcc=Lcc, name=NN,
     h = _heigHt(latlon, height)
     r =  EasNor3Tuple(e, n, h) if Lcc is None else \
                   Lcc(e, n, h=h, conic=c, **Lcc_kwds)
-    return _xnamed(r, name or nameof(latlon))
+    return _xnamed(r, name) if name else r
 
 
 if __name__ == '__main__':