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

pygeodesy/booleans.py

@@ -17,7 +17,7 @@ C{reverse-difference}, C{sum} and C{union}.
 # make sure int/int division yields float quotient, see .basics
 from __future__ import division as _; del _  # PYCHOK semicolon
 
-from pygeodesy.basics import isodd, issubclassof, map2, _xisscalar
+from pygeodesy.basics import isodd, issubclassof, map2, _xscalar
 from pygeodesy.constants import EPS, EPS2, INT0, _0_0, _0_5, _1_0
 from pygeodesy.errors import ClipError, _IsnotError, _TypeError, \
                             _ValueError, _xattr, _xkwds_get
@@ -25,13 +25,14 @@ from pygeodesy.fmath import favg, hypot, hypot2
 # from pygeodesy.fsums import fsum1  # _MODS
 from pygeodesy.interns import NN, _BANG_, _clip_, _clipid_, _COMMASPACE_, \
                              _composite_, _DOT_, _e_, _ELLIPSIS_, _few_, \
-                             _height_, _lat_,_LatLon_, _lon_, _not_, \
+                             _height_, _lat_, _LatLon_, _lon_, _not_, \
                              _points_, _SPACE_, _too_, _X_, _x_, \
                              _B_, _d_, _R_  # PYCHOK used!
 from pygeodesy.lazily import _ALL_DOCS, _ALL_LAZY, _ALL_MODS as _MODS
 from pygeodesy.latlonBase import LatLonBase, \
                                  LatLon2Tuple, Property_RO, property_RO
-from pygeodesy.named import Fmt, _Named, _NotImplemented, pairs, unstr
+from pygeodesy.named import _name__, _Named, _NotImplemented, \
+                             Fmt, pairs, unstr
 # from pygeodesy.namedTuples import LatLon2Tupe  # from .latlonBase
 # from pygeodesy.points import boundsOf  # _MODS
 # from pygeodesy.props import Property_RO, property_RO  # from .latlonBase
@@ -42,7 +43,7 @@ from pygeodesy.utily import fabs, _unrollon, _Wrap
 # from math import fabs  # from .utily
 
 __all__ = _ALL_LAZY.booleans
-__version__ = '24.02.06'
+__version__ = '24.05.24'
 
 _0_EPS =  EPS  # near-zero, positive
 _EPS_0 = -EPS  # near-zero, negative
@@ -124,7 +125,7 @@ class _LatLonBool(_Named):
     _prev    = None       # link to the previous vertex
 
     def __init__(self, lat_ll, lon=None, height=0, clipid=INT0,
-                                           wrap=False, name=NN):
+                                           wrap=False, **name):
         '''New C{LatLon[FHP|GH]} from separate C{lat}, C{lon}, C{height}
            and C{clipid} scalars or from a previous C{LatLon[FHP|GH]},
            a C{Clip[FHP|GH]4Tuple} or some other C{LatLon} instance.
@@ -330,7 +331,7 @@ class LatLonFHP(_LatLonBool):
         return self.x * other.x + self.y * other.y
 
     def __rmul__(self, other):  # scalar product
-        _xisscalar(other=other)
+        _xscalar(other=other)
         return self.__class__(self.y * other, self.x * other)
 
     def _e_x_str(self, t):  # PYCHOK no cover
@@ -883,10 +884,10 @@ class _CompositeBase(_Named):
     _raiser =  False
     _xtend  =  False
 
-    def __init__(self, lls, name=NN, kind=NN, eps=EPS):
+    def __init__(self, lls, kind=NN, eps=EPS, **name):
         '''(INTERNAL) See L{BooleanFHP} and L{BooleanGH}.
         '''
-        n = name or _xattr(lls, name=NN)
+        n = _name__(name, _or_nameof=lls)
         if n:
             self.name = n
         if kind:
@@ -1801,7 +1802,7 @@ class BooleanFHP(_CompositeFHP, _BooleanBase):
     '''
     _kind = _boolean_
 
-    def __init__(self, lls, raiser=False, eps=EPS, name=NN):
+    def __init__(self, lls, raiser=False, eps=EPS, **name):
         '''New L{BooleanFHP} operand for I{boolean} operation.
 
            @arg lls: The polygon points and clips (iterable of L{LatLonFHP}s,
@@ -1811,8 +1812,7 @@ class BooleanFHP(_CompositeFHP, _BooleanBase):
                        units as the B{C{lls}} coordinates).
            @kwarg name: Optional name (C{str}).
         '''
-        _CompositeFHP.__init__(self, lls, raiser=raiser,
-                                          eps=eps, name=name)
+        _CompositeFHP.__init__(self, lls, raiser=raiser, eps=eps, **name)
 
     def __isub__(self, other):
         '''Not implemented.'''
@@ -1864,7 +1864,7 @@ class BooleanGH(_CompositeGH, _BooleanBase):
     '''
     _kind = _boolean_
 
-    def __init__(self, lls, raiser=True, xtend=False, eps=EPS, name=NN):
+    def __init__(self, lls, raiser=True, xtend=False, eps=EPS, **name):
         '''New L{BooleanFHP} operand for I{boolean} operation.
 
            @arg lls: The polygon points and clips (iterable of L{LatLonGH}s,
@@ -1876,8 +1876,7 @@ class BooleanGH(_CompositeGH, _BooleanBase):
                        units as the B{C{lls}} coordinates).
            @kwarg name: Optional name (C{str}).
         '''
-        _CompositeGH.__init__(self, lls, raiser=raiser, xtend=xtend,
-                                         eps=eps, name=name)
+        _CompositeGH.__init__(self, lls, raiser=raiser, xtend=xtend, eps=eps, **name)
 
     def _boolean(self, other, s_entry, c_entry, op):
         # One C{BooleanGH} operation.
@@ -1921,7 +1920,7 @@ def _alpha4(a):
 def _Cps(Cp, composites_points, where):
     # Yield composites and points as a C{Cp} composite.
     try:
-        kwds = dict(kind=_points_, name=where.__name__)
+        kwds = dict(kind=_points_, name__=where)
         for cp in composites_points:
             yield cp if isBoolean(cp) else Cp(cp, **kwds)
     except (AttributeError, ClipError, TypeError, ValueError) as x:

pygeodesy/cartesianBase.py

@@ -21,10 +21,10 @@ from pygeodesy.errors import _IsnotError, _TypeError, _ValueError, \
 from pygeodesy.fmath import cbrt, hypot, hypot_, hypot2,  fabs, sqrt  # hypot
 # from pygeodesy.formy import _hartzell  # _MODS
 from pygeodesy.fsums import fsumf_,  Fmt
-from pygeodesy.interns import NN, _COMMASPACE_, _phi_  # _not_
+from pygeodesy.interns import _COMMASPACE_, _phi_
 from pygeodesy.interns import _ellipsoidal_, _spherical_  # PYCHOK used!
 from pygeodesy.lazily import _ALL_DOCS, _ALL_LAZY, _ALL_MODS as _MODS
-from pygeodesy.named import _NamedTuple, _Pass
+from pygeodesy.named import _name__, _name2__, _NamedTuple, _Pass
 from pygeodesy.namedTuples import LatLon4Tuple, Vector3Tuple, Vector4Tuple, \
                                   Bearing2Tuple  # PYCHOK .sphericalBase
 # from pygeodesy.nvectorBase import _N_vector  # _MODS
@@ -43,7 +43,7 @@ from pygeodesy.vector3d import Vector3d, _xyzhdn3
 # from math import atan2, degrees, fabs, radians, sqrt  # from .fmath, .utily
 
 __all__ = _ALL_LAZY.cartesianBase
-__version__ = '24.02.22'
+__version__ = '24.05.24'
 
 _r_     = 'r'
 _theta_ = 'theta'
@@ -55,7 +55,7 @@ class CartesianBase(Vector3d):
     _datum  = None  # L{Datum}, to be overriden
     _height = None  # height (L{Height}), set or approximated
 
-    def __init__(self, x_xyz, y=None, z=None, datum=None, ll=None, name=NN):
+    def __init__(self, x_xyz, y=None, z=None, datum=None, ll=None, **name):
         '''New C{Cartesian...}.
 
            @arg x_xyz: Cartesian X coordinate (C{scalar}) or a C{Cartesian},
@@ -67,15 +67,15 @@ class CartesianBase(Vector3d):
            @kwarg datum: Optional datum (L{Datum}, L{Ellipsoid}, L{Ellipsoid2}
                          or L{a_f2Tuple}).
            @kwarg ll: Optional, original latlon (C{LatLon}).
-           @kwarg name: Optional name (C{str}).
+           @kwarg name: Optional C{B{name}=NN} (C{str}).
 
            @raise TypeError: Non-scalar B{C{x_xyz}}, B{C{y}} or B{C{z}} coordinate
                              or B{C{x_xyz}} not a C{Cartesian}, L{Ecef9Tuple},
                              L{Vector3Tuple} or L{Vector4Tuple} or B{C{datum}} is
                              not a L{Datum}.
         '''
-        h, d, n = _xyzhdn3(x_xyz, None, datum, ll)
-        Vector3d.__init__(self, x_xyz, y=y, z=z, ll=ll, name=name or n)
+        h, d, n = _xyzhdn3(x_xyz, None, datum, ll, **name)
+        Vector3d.__init__(self, x_xyz, y=y, z=z, ll=ll, name=n)
         if h is not None:
             self._height = Height(h)
         if d is not None:
@@ -325,7 +325,7 @@ class CartesianBase(Vector3d):
         try:
             r = self.datum.ellipsoid.height4(self, normal=True)
         except (AttributeError, ValueError):  # no datum, null cartesian,
-            r = Vector4Tuple(self.x, self.y, self.z, 0, name=self.height4.__name__)
+            r = Vector4Tuple(self.x, self.y, self.z, 0, name__=self.height4)
         return r
 
     def height4(self, earth=None, normal=True, **Cartesian_and_kwds):
@@ -840,7 +840,7 @@ class CartesianBase(Vector3d):
         else:
             # if inverse and d != _WGS84:
             #     raise _ValueError(inverse=inverse, datum=d,
-            #                       txt=_not_(_WGS84.name))
+            #                       txt_not_=_WGS84.name)
             xyz = transform.transform(*self.xyz, inverse=inverse)
             c = self.dup(xyz=xyz, datum=datum or self.datum)
         return c
@@ -871,12 +871,12 @@ class RadiusThetaPhi3Tuple(_NamedTuple):
     _Names_ = (_r_,    _theta_, _phi_)
     _Units_ = ( Meter, _Pass,   _Pass)
 
-    def toCartesian(self, name=NN, **Cartesian_and_kwds):
+    def toCartesian(self, **name_Cartesian_and_kwds):
         '''Convert this L{RadiusThetaPhi3Tuple} to a cartesian C{(x, y, z)} vector.
 
-           @kwarg name: Optional name (C{str}), overriding this name.
-           @kwarg Cartesian_and_kwds: Optional C{B{Cartesian}=None} class and additional
-                            C{B{Cartesian}} keyword arguments.
+           @kwarg name_Cartesian_and_kwds: Optional C{B{name}=NN}, overriding this
+                       name and optional class C{B{Cartesian}=None} and additional
+                       C{B{Cartesian}} keyword arguments.
 
            @return: A C{B{Cartesian}(x, y, z)} instance or if no C{B{Cartesian}} keyword
                     argument is given, a L{Vector3Tuple}C{(x, y, z)} with C{x}, C{y}
@@ -886,9 +886,10 @@ class RadiusThetaPhi3Tuple(_NamedTuple):
         '''
         r, t, p =  self
         t, p, _ = _toRadians(self, t, p)
-        return rtp2xyz_(r, t, p, name=name or self.name, **Cartesian_and_kwds)
+        n, kwds = _name2__(name_Cartesian_and_kwds, _or_nameof=self)
+        return rtp2xyz_(r, t, p, name=n, **kwds)
 
-    def toDegrees(self, name=NN):
+    def toDegrees(self, **name):
         '''Convert this L{RadiusThetaPhi3Tuple}'s angles to L{Degrees}.
 
            @kwarg name: Optional name (C{str}), overriding this name.
@@ -899,20 +900,20 @@ class RadiusThetaPhi3Tuple(_NamedTuple):
         r, t, p =  self
         t, p, _ = _toDegrees(self, t, p)
         return _ or self.classof(r, Degrees(theta=t), Degrees(phi=p),
-                                    name=name or self.name)
+                                    name=_name__(name, _or_nameof=self))
 
-    def toRadians(self, name=NN):
+    def toRadians(self, **name):
         '''Convert this L{RadiusThetaPhi3Tuple}'s angles to L{Radians}.
 
-           @kwarg name: Optional name (C{str}), overriding this name.
+           @kwarg name: Optional, overriding C{B{name}=NN} (C{str}).
 
-           @return: L{RadiusThetaPhi3Tuple}C{(r, theta, phi)} with C{theta}
-                    and C{phi} both in L{Radians}.
+           @return: L{RadiusThetaPhi3Tuple}C{(r, theta, phi)} with
+                    C{theta} and C{phi} both in L{Radians}.
         '''
         r, t, p =  self
         t, p, _ = _toRadians(self, t, p)
         return _ or self.classof(r, Radians(theta=t), Radians(phi=p),
-                                    name=name or self.name)
+                                    name=_name__(name, _or_nameof=self))
 
 
 def rtp2xyz(r_rtp, *theta_phi, **name_Cartesian_and_kwds):
@@ -974,8 +975,9 @@ def rtp2xyz_(r_rtp, *theta_phi, **name_Cartesian_and_kwds):
         else:
             x = y = z = r
 
-        def _n_C_kwds3(name=NN, Cartesian=None, **kwds):
-            return name, Cartesian, kwds
+        def _n_C_kwds3(Cartesian=None, **name_kwds):
+            n, kwds = _name2__(**name_kwds)
+            return n, Cartesian, kwds
 
         n, C, kwds = _n_C_kwds3(**name_Cartesian_and_kwds)
         c = Vector3Tuple(x, y, z, name=n) if C is None else \

pygeodesy/clipy.py

@@ -30,7 +30,7 @@ from pygeodesy.units import Bool, FIx, HeightX, Lat, Lon, Number_
 # from math import fabs  # from .fmath
 
 __all__ = _ALL_LAZY.clipy
-__version__ = '23.05.15'
+__version__ = '23.05.18'
 
 _fj_       = 'fj'
 _original_ = 'original'
@@ -284,7 +284,7 @@ def clipFHP4(points, corners, closed=False, inull=False, raiser=False, eps=EPS):
              L{clipGH4}.
     '''
     P = _MODS.booleans._CompositeFHP(points, kind=_points_, raiser=raiser,
-                                             name=clipFHP4.__name__, eps=eps)
+                                                   eps=eps, name__=clipFHP4)
     Q = _4corners(corners)
     return P._clip(Q, Union=False, Clas=ClipFHP4Tuple, closed=closed,
                                    inull=inull, raiser=P._raiser, eps=eps)
@@ -334,7 +334,7 @@ def clipGH4(points, corners, closed=False, inull=False, raiser=True, xtend=False
              and function L{clipFHP4}.
     '''
     S = _MODS.booleans._CompositeGH(points, raiser=raiser, xtend=xtend, eps=eps,
-                                            name=clipGH4.__name__, kind=_points_)
+                                            name__=clipGH4, kind=_points_)
     C = _4corners(corners)
     return S._clip(C, False, False, Clas=ClipGH4Tuple, closed=closed, inull=inull,
                                     raiser=S._raiser, xtend=S._xtend, eps=eps)

pygeodesy/constants.py

@@ -9,12 +9,13 @@ L{pygeodesy.isnon0} and L{pygeodesy.remainder}.
 # make sure int/int division yields float quotient, see .basics
 from __future__ import division as _; del _  # PYCHOK semicolon
 
-from pygeodesy.basics import _0_0, _copysign, isbool, iscomplex, isint,  _ALL_LAZY
+from pygeodesy.basics import _copysign, isbool, iscomplex, isint,  _0_0
 from pygeodesy.errors import _xError, _xError2, _xkwds_get, _xkwds_item2
+# from pygeodesy.internals import _0_0  # from .basics
 from pygeodesy.interns import _INF_, _NAN_, _UNDER_
-# from pygeodesy.lazily import _ALL_LAZY  # from .basics
+# from pygeodesy.lazily import _ALL_LAZY  # from .unitsBase
 # from pygeodesy.streprs import Fmt  # from .unitsBase
-from pygeodesy.unitsBase import Float, Int, Radius,  Fmt
+from pygeodesy.unitsBase import Float, Int, Radius,  _ALL_LAZY, Fmt
 
 from math import fabs, isinf, isnan, pi as _PI, sqrt
 try:
@@ -23,7 +24,7 @@ except ImportError:  # Python 2-
     _inf, _nan = float(_INF_), float(_NAN_)
 
 __all__ = _ALL_LAZY.constants
-__version__ = '24.04.23'
+__version__ = '24.05.14'
 
 
 def _copysign_0_0(y):
@@ -355,8 +356,9 @@ def isint0(obj, both=False):
        @return: C{True} if B{C{obj}} is L{INT0}, C{int(0)} or
                 C{float(0)}, C{False} otherwise.
     '''
-    return (obj is INT0 or obj is int(0) or bool(both and
-       (not obj) and isint(obj, both=True))) and not isbool(obj)
+    return (obj is INT0 or obj is int(0) or
+            bool(both and (not obj) and isint(obj, both=True))) and \
+            not isbool(obj)
 
 
 def isnear0(x, eps0=EPS0):

pygeodesy/css.py

@@ -14,14 +14,14 @@ from pygeodesy.datums import _ellipsoidal_datum, _WGS84
 from pygeodesy.ellipsoidalBase import LatLonEllipsoidalBase as _LLEB
 from pygeodesy.errors import _ValueError, _xdatum, _xellipsoidal, \
                              _xattr, _xkwds
-from pygeodesy.interns import NN, _azimuth_, _COMMASPACE_, _easting_, \
-                             _lat_, _lon_, _m_, _name_, _northing_, \
-                             _reciprocal_, _SPACE_
+from pygeodesy.interns import _azimuth_, _COMMASPACE_, _easting_, \
+                              _lat_, _lon_, _m_, _name_, _northing_, \
+                              _reciprocal_, _SPACE_
 from pygeodesy.interns import _C_  # PYCHOK used!
 from pygeodesy.karney import _atan2d, _copysign, _diff182, _norm2, \
                              _norm180, _signBit, _sincos2d,  fabs
 from pygeodesy.lazily import _ALL_LAZY, _ALL_MODS as _MODS
-from pygeodesy.named import _NamedBase, _NamedTuple, nameof
+from pygeodesy.named import _name2__, _NamedBase, _NamedTuple
 from pygeodesy.namedTuples import EasNor2Tuple, EasNor3Tuple, \
                                   LatLon2Tuple, LatLon4Tuple, _LL4Tuple
 from pygeodesy.props import deprecated_Property_RO, Property, \
@@ -33,7 +33,7 @@ from pygeodesy.units import Bearing, Degrees, Easting, Height, _heigHt, \
 # from math import fabs  # from .karney
 
 __all__ = _ALL_LAZY.css
-__version__ = '24.02.21'
+__version__ = '24.05.24'
 
 
 def _CS0(cs0):
@@ -65,19 +65,19 @@ class CassiniSoldner(_NamedBase):
     _meridian =  None
     _sb0      = _0_0
 
-    def __init__(self, lat0, lon0, datum=_WGS84, name=NN):
+    def __init__(self, lat0, lon0, datum=_WGS84, **name):
         '''New L{CassiniSoldner} projection.
 
            @arg lat0: Latitude of center point (C{degrees90}).
            @arg lon0: Longitude of center point (C{degrees180}).
            @kwarg datum: Optional datum or ellipsoid (L{Datum},
                          L{Ellipsoid}, L{Ellipsoid2} or L{a_f2Tuple}).
-           @kwarg name: Optional name (C{str}).
+           @kwarg name: Optional C{B{name}=NN} (C{str}).
 
            @raise CSSError: Invalid B{C{lat}} or B{C{lon}}.
         '''
         if datum not in (None, self._datum):
-            self._datum = _xellipsoidal(datum=_ellipsoidal_datum(datum, name=name))
+            self._datum = _xellipsoidal(datum=_ellipsoidal_datum(datum, **name))
         if name:
             self.name = name
 
@@ -125,13 +125,14 @@ class CassiniSoldner(_NamedBase):
 
     f = flattening
 
-    def forward(self, lat, lon, name=NN):
+    def forward(self, lat, lon, **name):
         '''Convert an (ellipsoidal) geodetic location to Cassini-Soldner
            easting and northing.
 
            @arg lat: Latitude of the location (C{degrees90}).
            @arg lon: Longitude of the location (C{degrees180}).
-           @kwarg name: Name inlieu of this projection's name (C{str}).
+           @kwarg name: Optional C{B{name}=NN} inlieu of this projection's
+                        name (C{str}).
 
            @return: An L{EasNor2Tuple}C{(easting, northing)}.
 
@@ -140,16 +141,17 @@ class CassiniSoldner(_NamedBase):
 
            @raise CSSError: Invalid B{C{lat}} or B{C{lon}}.
         '''
-        t = self.forward6(lat, lon, name=name)
+        t = self.forward6(lat, lon, **name)
         return EasNor2Tuple(t.easting, t.northing, name=t.name)
 
-    def forward4(self, lat, lon, name=NN):
+    def forward4(self, lat, lon, **name):
         '''Convert an (ellipsoidal) geodetic location to Cassini-Soldner
            easting and northing.
 
            @arg lat: Latitude of the location (C{degrees90}).
            @arg lon: Longitude of the location (C{degrees180}).
-           @kwarg name: Name inlieu of this projection's name (C{str}).
+           @kwarg name: Optional B{C{name}=NN} inlieu of this projection's
+                        name (C{str}).
 
            @return: An L{EasNorAziRk4Tuple}C{(easting, northing,
                     azimuth, reciprocal)}.
@@ -159,17 +161,18 @@ class CassiniSoldner(_NamedBase):
 
            @raise CSSError: Invalid B{C{lat}} or B{C{lon}}.
         '''
-        t = self.forward6(lat, lon, name=name)
+        t = self.forward6(lat, lon, **name)
         return EasNorAziRk4Tuple(t.easting, t.northing,
                                  t.azimuth, t.reciprocal, name=t.name)
 
-    def forward6(self, lat, lon, name=NN):
+    def forward6(self, lat, lon, **name):
         '''Convert an (ellipsoidal) geodetic location to Cassini-Soldner
            easting and northing.
 
            @arg lat: Latitude of the location (C{degrees90}).
            @arg lon: Longitude of the location (C{degrees180}).
-           @kwarg name: Name inlieu of this projection's name (C{str}).
+           @kwarg name: Optional B{C{name}=NN} inlieu of this projection's
+                        name (C{str}).
 
            @return: An L{EasNorAziRkEqu6Tuple}C{(easting, northing,
                     azimuth, reciprocal, equatorarc, equatorazimuth)}.
@@ -209,7 +212,7 @@ class CassiniSoldner(_NamedBase):
         n = self._meridian.ArcPosition(d, g.DISTANCE).s12
         # n = self._meridian._GenPosition(True, d, g.DISTANCE)[4]
         return EasNorAziRkEqu6Tuple(e, n, z, rk, p.a1, p.azi0,
-                                    name=name or self.name)
+                                             name=self._name__(name))
 
     @Property
     def geodesic(self):
@@ -309,20 +312,21 @@ class CassiniSoldner(_NamedBase):
         s, c = _sincos2d(m.lat1)  # == self.lat0 == self.LatitudeOrigin()
         self._sb0, self._cb0 = _norm2(s * g.f1, c)
 
-    def reverse(self, easting, northing, name=NN, LatLon=None, **LatLon_kwds):
+    def reverse(self, easting, northing, LatLon=None, **LatLon_kwds_name):
         '''Convert a Cassini-Soldner location to (ellipsoidal) geodetic
            lat- and longitude.
 
            @arg easting: Easting of the location (C{meter}).
            @arg northing: Northing of the location (C{meter}).
-           @kwarg name: Name inlieu of this projection's name (C{str}).
-           @kwarg LatLon: Optional, ellipsoidal class to return the
-                          geodetic location as (C{LatLon}) or C{None}.
-           @kwarg LatLon_kwds: Optional (C{LatLon}) keyword arguments,
-                               ignored if C{B{LatLon} is None}.
+           @kwarg LatLon: Optional, ellipsoidal class to return the geodetic
+                          location as (C{LatLon}) or C{None}.
+           @kwarg LatLon_kwds_name: Optional (C{LatLon}) keyword arguments,
+                              ignored if C{B{LatLon} is None} and optional
+                              C{B{name}=NN} inlieu of this this projection's
+                              name (C{str}).
 
-           @return: Geodetic location B{C{LatLon}} or if B{C{LatLon}}
-                    is C{None}, a L{LatLon2Tuple}C{(lat, lon)}.
+           @return: Geodetic location B{C{LatLon}} or if B{C{LatLon}} is C{None},
+                    a L{LatLon2Tuple}C{(lat, lon)}.
 
            @raise CSSError: Ellipsoidal mismatch of B{C{LatLon}} and this projection.
 
@@ -331,23 +335,25 @@ class CassiniSoldner(_NamedBase):
            @see: Method L{CassiniSoldner.reverse4}, L{CassiniSoldner.forward}.
                  L{CassiniSoldner.forward4} and L{CassiniSoldner.forward6}.
         '''
-        r = self.reverse4(easting, northing, name=name)
+        n, kwds = _name2__(LatLon_kwds_name, _or_nameof=self)
+        r = self.reverse4(easting, northing, name=n)
         if LatLon is None:
             r = LatLon2Tuple(r.lat, r.lon, name=r.name)  # PYCHOK expected
         else:
             _xsubclassof(_LLEB, LatLon=LatLon)
-            kwds = _xkwds(LatLon_kwds, datum=self.datum, name=r.name)
+            kwds = _xkwds(kwds, datum=self.datum, name=r.name)
             r = LatLon(r.lat, r.lon, **kwds)  # PYCHOK expected
             self._datumatch(r)
         return r
 
-    def reverse4(self, easting, northing, name=NN):
+    def reverse4(self, easting, northing, **name):
         '''Convert a Cassini-Soldner location to (ellipsoidal) geodetic
            lat- and longitude.
 
            @arg easting: Easting of the location (C{meter}).
            @arg northing: Northing of the location (C{meter}).
-           @kwarg name: Name inlieu of this projection's name (C{str}).
+           @kwarg name: Optional B{C{name}=NN} inlieu of this projection's
+                        name (C{str}).
 
            @return: A L{LatLonAziRk4Tuple}C{(lat, lon, azimuth, reciprocal)}.
 
@@ -361,7 +367,7 @@ class CassiniSoldner(_NamedBase):
         # include z azimuth of easting direction and rk reciprocal
         # of azimuthal northing scale (see C++ member Direct() 5/6
         # <https://GeographicLib.SourceForge.io/C++/doc/classGeographicLib_1_1Geodesic.html>)
-        return LatLonAziRk4Tuple(r.lat2, r.lon2, z, r.M12, name=name or self.name)
+        return LatLonAziRk4Tuple(r.lat2, r.lon2, z, r.M12, name=self._name__(name))
 
     toLatLon = reverse  # XXX not reverse4
 
@@ -396,7 +402,7 @@ class Css(_NamedBase):
     _height   =  0     # height (C{meter})
     _northing = _0_0   # northing (C{float})
 
-    def __init__(self, e, n, h=0, cs0=None, name=NN):
+    def __init__(self, e, n, h=0, cs0=None, **name):
         '''New L{Css} Cassini-Soldner position.
 
            @arg e: Easting (C{meter}).
@@ -404,7 +410,7 @@ class Css(_NamedBase):
            @kwarg h: Optional height (C{meter}).
            @kwarg cs0: Optional, the Cassini-Soldner projection
                        (L{CassiniSoldner}).
-           @kwarg name: Optional name (C{str}).
+           @kwarg name: Optional C{B{name}=NN} (C{str}).
 
            @return: The Cassini-Soldner location (L{Css}).
 
@@ -447,20 +453,21 @@ class Css(_NamedBase):
             _update_all(self)
             self._cs0 = cs0
 
-#   def dup(self, name=NN, **e_n_h_cs0):  # PYCHOK signature
+#   def dup(self, **e_n_h_cs0_name):  # PYCHOK signature
 #       '''Duplicate this position with some attributes modified.
 #
-#          @kwarg e_n_h_cs0: Use keyword argument C{B{e}=...}, C{B{n}=...},
-#                            C{B{h}=...} and/or C{B{cs0}=...} to override
-#                            the current C{easting}, C{northing} C{height}
-#                            or C{cs0} projectio, respectively.
+#          @kwarg e_n_h_cs0_name: Use keyword argument C{B{e}=...},
+#                       C{B{n}=...}, C{B{h}=...} and/or C{B{cs0}=...}
+#                       to override the current C{easting}, C{northing}
+#                       C{height} or C{cs0} projectio, respectively and
+#                       an optional C{B{name}=NN} (C{str}).
 #       '''
 #       def _args_kwds(e=None, n=None, **kwds):
 #           return (e, n), kwds
 #
 #       kwds = _xkwds(e_n_h_cs0, e=self.easting, n=self.northing,
 #                                h=self.height, cs0=self.cs0,
-#                                name=name or self.name)
+#                                name=_name__(name, _or_nameof(self)))
 #       args, kwds = _args_kwds(**kwds)
 #       return self.__class__(*args, **kwds)  # .classof
 
@@ -596,7 +603,7 @@ class LatLonAziRk4Tuple(_NamedTuple):
     _Units_ = ( Lat_,  Lon_,  Bearing,   Scalar)
 
 
-def toCss(latlon, cs0=None, height=None, Css=Css, name=NN):
+def toCss(latlon, cs0=None, height=None, Css=Css, **name):
     '''Convert an (ellipsoidal) geodetic point to a Cassini-Soldner
        location.
 
@@ -605,8 +612,9 @@ def toCss(latlon, cs0=None, height=None, Css=Css, name=NN):
                    (L{CassiniSoldner}).
        @kwarg height: Optional height for the point, overriding the
                       default height (C{meter}).
-       @kwarg Css: Optional class to return the location (L{Css}) or C{None}.
-       @kwarg name: Optional B{C{Css}} name (C{str}).
+       @kwarg Css: Optional class to return the location (L{Css}) or
+                   C{None}.
+       @kwarg name: Optional B{C{Css}} C{B{name}=NN} (C{str}).
 
        @return: The Cassini-Soldner location (B{C{Css}}) or an
                 L{EasNor3Tuple}C{(easting, northing, height)}
@@ -627,7 +635,7 @@ def toCss(latlon, cs0=None, height=None, Css=Css, name=NN):
 
     c =  cs.forward4(latlon.lat, latlon.lon)
     h = _heigHt(latlon, height)
-    n =  name or nameof(latlon)
+    n =  latlon._name__(name)
 
     if Css is None:
         r = EasNor3Tuple(c.easting, c.northing, h, name=n)