pygeodesy 24.6.9__py2.py3-none-any.whl → 24.6.24__py2.py3-none-any.whl

pygeodesy/lcc.py

@@ -41,14 +41,14 @@ from pygeodesy.namedTuples import EasNor3Tuple, LatLonDatum3Tuple, \
                                   LatLon2Tuple, _LL4Tuple, PhiLam2Tuple
 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_, \
+from pygeodesy.units import Easting, Height, _heigHt,  Lamd, Northing, Phid, \
                             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__ = '24.06.09'
+__version__ = '24.06.24'
 
 _E0_   = 'E0'
 _N0_   = 'N0'
@@ -107,8 +107,8 @@ class Conic(_NamedEnumItem):
             _xinstanceof(_LLEB, latlon0=latlon0)
             self._phi0, self._lam0 = latlon0.philam
 
-            self._par1 = Phi_(par1=par1)
-            self._par2 = self._par1 if par2 is None else Phi_(par2=par2)
+            self._par1 = Phid(par1=par1)
+            self._par2 = self._par1 if par2 is None else Phid(par2=par2)
 
             if k0 != 1:
                 self._k0 = Scalar_(k0=k0)
@@ -117,7 +117,7 @@ class Conic(_NamedEnumItem):
             if N0:
                 self._N0 = Easting(N0=N0, falsed=True)
             if opt3:
-                self._opt3 = Lam_(opt3=opt3)
+                self._opt3 = Lamd(opt3=opt3)
 
             self.toDatum(latlon0.datum)._dup2(self)
             self._register(Conics, name)
@@ -278,20 +278,19 @@ class Conic(_NamedEnumItem):
 
         return c
 
-    def toStr(self, prec=8, name=NN, **unused):  # PYCHOK expected
+    def toStr(self, prec=8, **name):  # PYCHOK expected
         '''Return this conic as a string.
 
            @kwarg prec: Number of (decimal) digits, unstripped (C{int}).
-           @kwarg name: Overriding name (C{str}) or C{None} to exclude
-                        this conic's name.
+           @kwarg name: Overriding C{B{name}=NN} (C{str}) or C{None} to
+                        exclude this conic's name.
 
            @return: Conic attributes (C{str}).
         '''
-        a = [name, prec, _lat0_, _lon0_, _par1_, _par2_,
-                         _E0_, _N0_, _k0_, _SP_]
+        a = [_lat0_, _lon0_, _par1_, _par2_, _E0_, _N0_, _k0_, _SP_]
         if self._SP == 1:
             _ = a.pop(a.index(_par2_))
-        return self._instr(datum=self.datum, *a)
+        return self._instr(datum=self.datum, prec=prec, *a, **name)
 
     def _dup2(self, c):
         '''(INTERNAL) Copy this conic to C{c}.
@@ -537,22 +536,21 @@ class Lcc(_NamedBase):
     def toLatLon(self, LatLon=None, datum=None, height=None, **LatLon_kwds):
         '''Convert this L{Lcc} to an (ellipsoidal) geodetic point.
 
-           @kwarg LatLon: Optional, ellipsoidal class to return the
-                          geodetic point (C{LatLon}) or C{None}.
-           @kwarg datum: Optional datum to use, otherwise use this
-                         B{C{Lcc}}'s conic.datum (L{Datum}, L{Ellipsoid},
-                         L{Ellipsoid2} or L{a_f2Tuple}).
-           @kwarg height: Optional height for the point, overriding
-                          the default height (C{meter}).
-           @kwarg LatLon_kwds: Optional, additional B{C{LatLon}} keyword
-                               arguments, ignored if C{B{LatLon} is None}.
+           @kwarg LatLon: Optional, ellipsoidal class to return the geodetic
+                          point (C{LatLon}) or C{None}.
+           @kwarg datum: Optional datum to use, otherwise use this B{C{Lcc}}'s
+                         conic.datum (L{Datum}, L{Ellipsoid}, L{Ellipsoid2} or
+                         L{a_f2Tuple}).
+           @kwarg height: Optional height for the point, overriding the default height
+                          (C{meter}).
+           @kwarg LatLon_kwds: Optional, additional B{C{LatLon}} keyword arguments,
+                               ignored if C{B{LatLon} is None}.
 
-           @return: The point (B{C{LatLon}}) or a
-                    L{LatLon4Tuple}C{(lat, lon, height, datum)}
-                    if B{C{LatLon}} is C{None}.
+           @return: The point (B{C{LatLon}}) or if C{B{LatLon} is None}, a
+                    L{LatLon4Tuple}C{(lat, lon, height, datum)}.
 
-           @raise TypeError: If B{C{LatLon}} or B{C{datum}} is
-                             not ellipsoidal or not valid.
+           @raise TypeError: If B{C{LatLon}} or B{C{datum}} is not ellipsoidal or
+                             not valid.
         '''
         if LatLon:
             _xsubclassof(_LLEB, LatLon=LatLon)
@@ -622,13 +620,12 @@ def toLcc(latlon, conic=Conics.WRF_Lb, height=None, Lcc=Lcc,
        @kwarg height: Optional height for the point, overriding the
                       default height (C{meter}).
        @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}.
+       @kwarg name_Lcc_kwds: Optional C{B{name}=NN} (C{str}) and optional,
+                   additional B{C{Lcc}} keyword arguments, ignored if
+                   B{C{Lcc} is None}.
 
-       @return: The I{Lambert} location (L{Lcc}) or an
-                L{EasNor3Tuple}C{(easting, northing, height)} if
-                C{B{Lcc} is None}.
+       @return: The I{Lambert} location (L{Lcc}) or if C{B{Lcc} is None},
+                an L{EasNor3Tuple}C{(easting, northing, height)}.
 
        @raise TypeError: If B{C{latlon}} is not ellipsoidal.
     '''

pygeodesy/ltp.py

@@ -44,7 +44,7 @@ from pygeodesy.vector3d import _ALL_LAZY, Vector3d
 # from math import fabs, floor as _floor  # from .fmath, .fsums
 
 __all__ = _ALL_LAZY.ltp
-__version__ = '24.06.07'
+__version__ = '24.06.11'
 
 _height0_ = _height_ + _0_
 _narrow_  = 'narrow'
@@ -154,7 +154,7 @@ class Attitude(_NamedBase):
                        additional B{C{Vector}} keyword arguments, ignored if
                        C{B{Vector} is None}.
 
-           @return: A named B{C{Vector}} instance or if B{C{Vector}} is C{None},
+           @return: A named B{C{Vector}} instance or if C{B{Vector} is None},
                     a named L{Vector3Tuple}C{(x, y, z)}.
 
            @raise AttitudeError: Invalid B{C{x_xyz}}, B{C{y}} or B{C{z}}.
@@ -419,13 +419,12 @@ class LocalCartesian(_NamedBase):
            @kwarg latlonh0: The (geodetic) origin (C{LatLon}, L{LatLon4Tuple}, L{Ltp}
                             L{LocalCartesian} or L{Ecef9Tuple}) or the C{scalar}
                             latitude of the (goedetic) origin (C{degrees}).
-           @kwarg lon0: Longitude of the (goedetic) origin (C{degrees}) for C{scalar}
-                        B{C{latlonh0}}, ignored otherwise.
+           @kwarg lon0: Longitude of the (goedetic) origin (C{degrees}), required if
+                        B{C{latlonh0}} is C{scalar}, ignored otherwise.
            @kwarg height0: Optional height (C{meter}, conventionally) at the (goedetic)
                            origin perpendicular to and above (or below) the ellipsoid's
-                           surface and for C{scalar} B{C{latlonh0}}, ignored otherwise.
-           @kwarg ecef: An ECEF converter (L{EcefKarney} I{only}) for C{scalar}
-                        B{C{latlonh0}}, ignored otherwise.
+                           surface, like B{C{lon0}}.
+           @kwarg ecef: An ECEF converter (L{EcefKarney} I{only}), like B{C{lon0}}.
            @kwarg lon00_name: Optional C{B{name}=NN} (C{str}) and keyword argument
                         C{B{lon00}=B{lon0}} for the arbitrary I{polar} longitude
                         (C{degrees}), see method C{reverse} and property C{lon00}
@@ -1104,7 +1103,7 @@ def tyr3d(tilt=INT0, yaw=INT0, roll=INT0, Vector=Vector3d, **name_Vector_kwds):
                    additional B{C{Vector}} keyword arguments, ignored if
                    C{B{Vector} is None}.
 
-       @return: A named B{C{Vector}} instance or if B{C{Vector}} is C{None},
+       @return: A named B{C{Vector}} instance or if C{B{Vector} is None},
                 a named L{Vector3Tuple}C{(x, y, z)}.
 
        @raise AttitudeError: Invalid B{C{tilt}}, B{C{yaw}} or B{C{roll}}.

pygeodesy/ltpTuples.py

@@ -11,11 +11,11 @@ L{ChLVYX2Tuple}, L{ChLVyx2Tuple} and L{Footprint5Tuple}.
 @see: References in module L{ltp}.
 '''
 
-# from pygeodesy.basics import issubclassof  # from .units
+# from pygeodesy.basics import issubclassof  # _MODS
 from pygeodesy.constants import _0_0, _1_0, _90_0, _N_90_0
 # from pygeodesy.dms import F_D, toDMS  # _MODS
-from pygeodesy.errors import _TypeError, _TypesError, _xattr, \
-                             _xkwds, _xkwds_item2
+from pygeodesy.errors import _TypeError, _TypesError, _xattr, _xkwds, \
+                             _xkwds_item2
 from pygeodesy.fmath import hypot, hypot_
 from pygeodesy.interns import NN, _4_, _azimuth_, _center_, _COMMASPACE_, \
                              _ecef_, _elevation_, _height_, _lat_, _lon_, \
@@ -29,14 +29,14 @@ from pygeodesy.props import deprecated_method, deprecated_Property_RO, \
                             Property_RO, property_RO
 from pygeodesy.streprs import Fmt, fstr, strs, _xzipairs
 from pygeodesy.units import Bearing, Degrees, Degrees_, Height, _isDegrees, \
-                           _isMeter, Lat, Lon, Meter, Meter_,  issubclassof
+                           _isMeter, Lat, Lon, Meter, Meter_
 from pygeodesy.utily import atan2d, atan2b, sincos2_, sincos2d_,  cos, radians
 from pygeodesy.vector3d import Vector3d
 
 # from math import cos, radians  # from .utily
 
 __all__ = _ALL_LAZY.ltpTuples
-__version__ = '24.06.08'
+__version__ = '24.06.15'
 
 _aer_        = 'aer'
 _alt_        = 'alt'
@@ -126,12 +126,12 @@ class _AbcBase(_NamedBase):
         '''Get the I{local} I{Azimuth, Elevation, slant Range} (AER) components.
 
            @kwarg Aer: Class to return AER (L{Aer}) or C{None}.
-           @kwarg name_Aer_kwds: Optional C{B{name}=NN} (C{str}) and
-                       optional, additional B{L{Aer}} keyword arguments,
-                       ignored if B{C{Aer}} is C{None}.
+           @kwarg name_Aer_kwds: Optional C{B{name}=NN} (C{str}) and optional,
+                       additional B{L{Aer}} keyword arguments, ignored if
+                       C{B{Aer} is None}.
 
-           @return: AER as an L{Aer} instance or if C{B{Aer} is None},
-                    an L{Aer4Tuple}C{(azimuth, elevation, slantrange, ltp)}.
+           @return: AER as an L{Aer} instance or if C{B{Aer} is None}, an
+                    L{Aer4Tuple}C{(azimuth, elevation, slantrange, ltp)}.
 
            @raise TypeError: Invalid B{C{Aer}} or B{C{name_Aer_kwds}}.
         '''
@@ -141,12 +141,12 @@ class _AbcBase(_NamedBase):
         '''Get the I{local} I{East, North, Up} (ENU) components.
 
            @kwarg Enu: Class to return ENU (L{Enu}) or C{None}.
-           @kwarg name_Enu_kwds: Optional C{B{name}=NN} (C{str}) and
-                       optional, additional B{L{Enu}} keyword arguments,
-                       ignored if C{B{Enu} is None}.
+           @kwarg name_Enu_kwds: Optional C{B{name}=NN} (C{str}) and optional,
+                       additional B{L{Enu}} keyword arguments, ignored if
+                       C{B{Enu} is None}.
 
-           @return: ENU as an L{Enu} instance or if C{B{Enu} is None},
-                    an L{Enu4Tuple}C{(east, north, up, ltp)}.
+           @return: ENU as an L{Enu} instance or if C{B{Enu} is None}, an
+                    L{Enu4Tuple}C{(east, north, up, ltp)}.
 
            @raise TypeError: Invalid B{C{Enu}} or B{C{name_Enu_kwds}}.
         '''
@@ -156,12 +156,12 @@ class _AbcBase(_NamedBase):
         '''Get the I{local} I{North, East, Down} (NED) components.
 
            @kwarg Ned: Class to return NED (L{Ned}) or C{None}.
-           @kwarg name_Ned_kwds: Optional C{B{name}=NN} (C{str}) and
-                       optional, additional B{L{Ned}} keyword arguments,
-                       ignored if B{C{Ned}} is C{None}.
+           @kwarg name_Ned_kwds: Optional C{B{name}=NN} (C{str}) and optional,
+                       additional B{L{Ned}} keyword arguments, ignored if
+                       C{B{Ned} is None}.
 
-           @return: NED as an L{Ned} instance or if C{B{Ned} is None},
-                    an L{Ned4Tuple}C{(north, east, down, ltp)}.
+           @return: NED as an L{Ned} instance or if C{B{Ned} is None}, an
+                    L{Ned4Tuple}C{(north, east, down, ltp)}.
 
            @raise TypeError: Invalid B{C{Ned}} or B{C{name_Ned_kwds}}.
         '''
@@ -170,14 +170,14 @@ class _AbcBase(_NamedBase):
     def toXyz(self, Xyz=None, **name_Xyz_kwds):
         '''Get the local I{X, Y, Z} (XYZ) components.
 
-           @kwarg Xyz: Class to return XYZ (L{XyzLocal}, L{Enu},
-                       L{Ned}, L{Aer}) or C{None}.
-           @kwarg name_Xyz_kwds: Optional C{B{name}=NN} (C{str}) and
-                       optional, additional B{C{Xyz}} keyword arguments,
-                       ignored if C{B{Xyz} is None}.
+           @kwarg Xyz: Class to return XYZ (L{XyzLocal}, L{Enu}, L{Ned}, L{Aer})
+                       or C{None}.
+           @kwarg name_Xyz_kwds: Optional C{B{name}=NN} (C{str}) and optional,
+                       additional B{C{Xyz}} keyword arguments, ignored if
+                       C{B{Xyz} is None}.
 
-           @return: XYZ as an B{C{Xyz}} instance or if C{B{Xyz} is None},
-                    an L{Xyz4Tuple}C{(x, y, z, ltp)}.
+           @return: XYZ as an B{C{Xyz}} instance or if C{B{Xyz} is None}, an
+                    L{Xyz4Tuple}C{(x, y, z, ltp)}.
 
            @raise TypeError: Invalid B{C{Xyz}} or B{C{name_Xyz_kwds}}.
         '''
@@ -209,7 +209,7 @@ class _Abc4Tuple(_NamedTuple):
         '''(INTERNAL) Convert 4-Tuple to C{Cls} instance.
         '''
         kwds = _name1__(Cls_kwds, _or_nameof=self)
-        _is  =  issubclassof
+        _is  = _MODS.basics.issubclassof
         if Cls is None:
             n, _ = _name2__(Cls_kwds)
             r = self.copy(name=n) if n else self
@@ -824,18 +824,17 @@ class XyzLocal(_Vector3d):
 
            @kwarg Cartesian: Optional class to return C{(x, y, z)} (C{Cartesian})
                              or C{None}.
-           @kwarg ltp: Optional I{local tangent plane} (LTP) (L{Ltp}),
-                       overriding this C{ltp}.
-           @kwarg name_Cartesian_kwds: Optional C{B{name}=NN} (C{str}) and
-                       optional, additional B{C{Cartesian}} keyword arguments,
-                       ignored if C{B{Cartesian} is None}.
+           @kwarg ltp: Optional I{local tangent plane} (LTP) (L{Ltp}), overriding
+                       this C{ltp}.
+           @kwarg name_Cartesian_kwds: Optional C{B{name}=NN} (C{str}) and optional,
+                       additional B{C{Cartesian}} keyword arguments, ignored if
+                       C{B{Cartesian} is None}.
 
            @return: A B{C{Cartesian}} instance of if C{B{Cartesian} is None}, an
-                    L{Ecef9Tuple}C{(x, y, z, lat, lon, height, C, M, datum)}
-                    with C{M=None}, always.
+                    L{Ecef9Tuple}C{(x, y, z, lat, lon, height, C, M, datum)} with
+                    C{M=None}, always.
 
-           @raise TypeError: Invalid B{C{ltp}}, B{C{Cartesian}} or
-                             B{C{name_Cartesian_kwds}}.
+           @raise TypeError: Invalid B{C{ltp}}, B{C{Cartesian}} or B{C{name_Cartesian_kwds}}.
         '''
         ltp, kwds, n = self._ltp_kwds_name3(ltp, name_Cartesian_kwds)
         if Cartesian is None:
@@ -851,12 +850,12 @@ class XyzLocal(_Vector3d):
         '''Get the local I{East, North, Up} (ENU) components.
 
            @kwarg Enu: Class to return ENU (L{Enu}) or C{None}.
-           @kwarg name_Enu_kwds: Optional C{B{name}=NN} (C{str}) and
-                       optional, additional B{C{Enu}} keyword arguments,
-                       ignored if C{B{Enu} is None}.
+           @kwarg name_Enu_kwds: Optional C{B{name}=NN} (C{str}) and optional,
+                       additional B{C{Enu}} keyword arguments, ignored if
+                       C{B{Enu} is None}.
 
-           @return: ENU as an L{Enu} instance or if C{B{Enu} is None},
-                    an L{Enu4Tuple}C{(east, north, up, ltp)}.
+           @return: ENU as an L{Enu} instance or if C{B{Enu} is None}, an
+                    L{Enu4Tuple}C{(east, north, up, ltp)}.
 
            @raise TypeError: Invalid B{C{Enu}} or B{C{name_Enu_kwds}}.
         '''
@@ -865,20 +864,19 @@ class XyzLocal(_Vector3d):
     def toLatLon(self, LatLon=None, ltp=None, **name_LatLon_kwds):
         '''Get the geodetic C{(lat, lon, height)} coordinates if this local.
 
-           @kwarg LatLon: Optional class to return C{(x, y, z)} (C{LatLon})
-                          or C{None}.
-           @kwarg ltp: Optional I{local tangent plane} (LTP) (L{Ltp}),
-                       overriding this ENU/NED/AER/XYZ's LTP.
-           @kwarg name_LatLon_kwds: Optional C{B{name}=NN} (C{str}) and
-                       optional, additional B{C{LatLon}} keyword arguments,
-                       ignored if C{B{LatLon} is None}.
+           @kwarg LatLon: Optional class to return C{(x, y, z)} (C{LatLon}) or
+                          C{None}.
+           @kwarg ltp: Optional I{local tangent plane} (LTP) (L{Ltp}), overriding
+                       this ENU/NED/AER/XYZ's LTP.
+           @kwarg name_LatLon_kwds: Optional C{B{name}=NN} (C{str}) and optional,
+                       additional B{C{LatLon}} keyword arguments, ignored if
+                       C{B{LatLon} is None}.
 
            @return: An B{C{LatLon}} instance of if C{B{LatLon} is None}, an
-                    L{Ecef9Tuple}C{(x, y, z, lat, lon, height, C, M,
-                    datum)} with C{M=None}, always.
+                    L{Ecef9Tuple}C{(x, y, z, lat, lon, height, C, M, datum)} with
+                    C{M=None}, always.
 
-           @raise TypeError: Invalid B{C{ltp}}, B{C{LatLon}} or
-                             B{C{name_LatLon_kwds}}.
+           @raise TypeError: Invalid B{C{LatLon}}, B{C{ltp}} or B{C{name_LatLon_kwds}}.
         '''
         ltp, kwds, n = self._ltp_kwds_name3(ltp, name_LatLon_kwds)
         t = ltp._local2ecef(self, nine=True)
@@ -895,9 +893,9 @@ class XyzLocal(_Vector3d):
            @kwarg M: Optionally include the rotation matrix (C{bool}).
            @kwarg name: Optional C{B{name}=NN} (C{str}).
 
-           @return: L{Local9Tuple}C{(x, y, z, lat, lon, height, ltp,
-                    ecef, M)} with C{ltp} this C{Ltp}, C{ecef} an
-                    L{Ecef9Tuple} and C{M} L{EcefMatrix} or C{None}.
+           @return: L{Local9Tuple}C{(x, y, z, lat, lon, height, ltp, ecef, M)}
+                    with C{ltp} this C{Ltp}, C{ecef} an L{Ecef9Tuple} and C{M}
+                    an L{EcefMatrix} or C{None}.
         '''
         ltp = self.ltp  # see C{self.toLatLon}
         t   = ltp._local2ecef(self, nine=True, M=M)
@@ -909,12 +907,12 @@ class XyzLocal(_Vector3d):
         '''Get the local I{North, East, Down} (Ned) components.
 
            @kwarg Ned: Class to return NED (L{Ned}) or C{None}.
-           @kwarg name_Ned_kwds: Optional C{B{name}=NN} (C{str}) and
-                       optional, additional B{C{Ned}} keyword arguments,
-                       ignored if C{B{Ned} is None}.
+           @kwarg name_Ned_kwds: Optional C{B{name}=NN} (C{str}) and optional,
+                       additional B{C{Ned}} keyword arguments, ignored if
+                       C{B{Ned} is None}.
 
-           @return: NED as an L{Ned} instance or if C{B{Ned} is None},
-                    an L{Ned4Tuple}C{(north, east, down, ltp)}.
+           @return: NED as an L{Ned} instance or if C{B{Ned} is None}, an
+                    L{Ned4Tuple}C{(north, east, down, ltp)}.
 
            @raise TypeError: Invalid B{C{Ned}} or B{C{name_Ned_kwds}}.
         '''
@@ -923,14 +921,14 @@ class XyzLocal(_Vector3d):
     def toXyz(self, Xyz=None, **name_Xyz_kwds):
         '''Get the local I{X, Y, Z} (XYZ) components.
 
-           @kwarg Xyz: Class to return XYZ (L{XyzLocal}, L{Enu},
-                       L{Ned}, L{Aer}) or C{None}.
-           @kwarg name_Xyz_kwds: Optional C{B{name}=NN} (C{str}) and
-                       optional, additional B{C{Xyz}} keyword arguments,
-                       ignored if C{B{Xyz} is None}.
+           @kwarg Xyz: Class to return XYZ (L{XyzLocal}, L{Enu}, L{Ned}, L{Aer})
+                       or C{None}.
+           @kwarg name_Xyz_kwds: Optional C{B{name}=NN} (C{str}) and optional,
+                       additional B{C{Xyz}} keyword arguments, ignored if
+                       C{B{Xyz} is None}.
 
-           @return: XYZ as an B{C{Xyz}} instance or if C{B{Xyz} is None},
-                    an L{Xyz4Tuple}C{(x, y, z, ltp)}.
+           @return: XYZ as an B{C{Xyz}} instance or if C{B{Xyz} is None}, an
+                    L{Xyz4Tuple}C{(x, y, z, ltp)}.
 
            @raise TypeError: Invalid B{C{Xyz}} or B{C{name_EXyz_kwds}}.
         '''
@@ -1183,7 +1181,7 @@ class Local9Tuple(_NamedTuple):
            @kwarg Aer: Class to return AER (L{Aer}) or C{None}.
            @kwarg name_Aer_kwds: Optional C{B{name}=NN} (C{str}) and optional,
                        additional B{L{Aer}} keyword arguments, ignored if
-                       B{C{Aer}} is C{None}.
+                       C{B{Aer} is None}.
 
            @return: AER as an L{Aer} instance or if C{B{Aer} is None}, an
                     L{Aer4Tuple}C{(azimuth, elevation, slantrange, ltp)}.
@@ -1247,7 +1245,7 @@ class Local9Tuple(_NamedTuple):
            @kwarg Ned: Class to return NED (L{Ned}) or C{None}.
            @kwarg name_Ned_kwds: Optional C{B{name}=NN} (C{str}) and optional,
                        additional B{L{Ned}} keyword arguments, ignored if
-                       B{C{Ned}} is C{None}.
+                       C{B{Ned} is None}.
 
            @return: NED as an L{Ned} instance or if C{B{Ned} is None}, an
                     L{Ned4Tuple}C{(north, east, down, ltp)}.

pygeodesy/mgrs.py

@@ -55,7 +55,7 @@ from pygeodesy.utm import toUtm8, _to3zBlat, Utm, _UTM_ZONE_MAX, _UTM_ZONE_MIN
 # from pygeodesy.utmupsBase import _UTM_ZONE_MAX, _UTM_ZONE_MIN  # from .utm
 
 __all__ = _ALL_LAZY.mgrs
-__version__ = '24.06.04'
+__version__ = '24.06.11'
 
 _AN_    = 'AN'  # default south pole grid tile and band B
 _AtoPx_ = _AtoZnoIO_.tillP
@@ -596,18 +596,17 @@ def toMgrs(utmups, Mgrs=Mgrs, **name_Mgrs_kwds):
        @arg utmups: A UTM or UPS coordinate (L{Utm}, L{Etm} or L{Ups}).
        @kwarg Mgrs: Optional class to return the MGRS grid reference
                     (L{Mgrs}) or C{None}.
-       @kwarg name_Mgrs_kwds: Optional C{B{name}=NN} (C{str}) and
-                   optional, additional B{C{Mgrs}} keyword arguments,
-                   ignored if C{B{Mgrs} is None}.
+       @kwarg name_Mgrs_kwds: Optional C{B{name}=NN} (C{str}) and optional,
+                   additional B{C{Mgrs}} keyword arguments, ignored if
+                   C{B{Mgrs} is None}.
 
-       @return: The MGRS grid reference as B{C{Mgrs}} or if C{B{Mgrs}
-                is None} as an L{Mgrs6Tuple}C{(zone, EN, easting,
-                northing, band, datum)}.
+       @return: The MGRS grid reference as B{C{Mgrs}} or if C{B{Mgrs} is
+                None} as an L{Mgrs6Tuple}C{(zone, EN, easting, northing,
+                band, datum)}.
 
        @raise MGRSError: Invalid B{C{utmups}}.
 
-       @raise TypeError: If B{C{utmups}} is not L{Utm} nor L{Etm}
-                         nor L{Ups}.
+       @raise TypeError: If B{C{utmups}} is not L{Utm}, L{Etm} nor L{Ups}.
     '''
 #   _MODS.utmups.utmupsValidate(utmups, MGRS=True, Error-MGRSError)
     _xinstanceof(Utm, Ups, utmups=utmups)  # Utm, Etm, Ups

pygeodesy/named.py

@@ -34,7 +34,7 @@ from pygeodesy.streprs import attrs, Fmt, lrstrip, pairs, reprs, unstr
 # from pygeodesy.units import _toUnit  # _MODS
 
 __all__ = _ALL_LAZY.named
-__version__ = '24.06.10'
+__version__ = '24.06.24'
 
 _COMMANL_           = _COMMA_ + _NL_
 _COMMASPACEDOT_     = _COMMASPACE_ + _DOT_
@@ -72,6 +72,15 @@ class ADict(dict):
         '''
         return self.toRepr()
 
+    def __setattr__(self, name, value):
+        '''Set the value of a I{known} item by B{C{name}}.
+        '''
+        try:
+            if self[name] != value:
+                self[name] = value
+        except KeyError:
+            dict.__setattr__(self, name, value)
+
     def __str__(self):
         '''Default C{str(self)}.
         '''
@@ -241,15 +250,16 @@ class _Named(object):
 #           _update_all(d)
         return d
 
-    def _instr(self, name, prec, *attrs, **fmt_props_kwds):
-        '''(INTERNAL) Format, used by C{Conic}, C{Ellipsoid}, C{Transform}, C{Triaxial}.
+    def _instr(self, *attrs, **fmt_prec_props_sep_name__kwds):
+        '''(INTERNAL) Format, used by C{Conic}, C{Ellipsoid}, C{Geodesic...}, C{Transform}, C{Triaxial}.
         '''
-        def _fmt_props_kwds(fmt=Fmt.F, props=(), **kwds):
-            return fmt, props, kwds
+        def _fmt_prec_props_kwds(fmt=Fmt.F, prec=6, props=(), sep=_COMMASPACE_, **kwds):
+            return fmt, prec, props, sep, kwds
 
-        fmt, props, kwds = _fmt_props_kwds(**fmt_props_kwds)
+        name, kwds = _name2__(**fmt_prec_props_sep_name__kwds)
+        fmt, prec, props, sep, kwds = _fmt_prec_props_kwds(**kwds)
 
-        t = () if name is None else (Fmt.EQUAL(name=repr(self._name__(name))),)
+        t = () if name is None else (Fmt.EQUAL(name=repr(name or self.name)),)
         if attrs:
             t += pairs(((a, getattr(self, a)) for a in attrs),
                        prec=prec, ints=True, fmt=fmt)
@@ -258,7 +268,7 @@ class _Named(object):
                        prec=prec, ints=True)
         if kwds:
             t += pairs(kwds, prec=prec)
-        return _COMMASPACE_.join(t)
+        return sep.join(t) if sep else t
 
     @property_RO
     def iteration(self):  # see .karney.GDict
@@ -1090,8 +1100,7 @@ class _NamedTuple(tuple, _Named):
         '''Yield the items, each as a C{2-tuple (name, value}) with the
            value wrapped as an instance of its L{units} class.
 
-           @kwarg Error: Optional C{B{Error}=UnitError} to raise for
-                         L{units} issues.
+           @kwarg Error: Optional C{B{Error}=UnitError} to raise.
 
            @raise Error: Invalid C{Named-Tuple} item or L{units} class.
 

pygeodesy/nvectorBase.py

@@ -14,7 +14,7 @@ and published under the same MIT Licence**, see U{Vector-based geodesy
 from pygeodesy.constants import EPS, EPS1, EPS_2, R_M, _2_0, _N_2_0
 # from pygeodesy.datums import _spherical_datum  # from .formy
 from pygeodesy.errors import IntersectionError, _ValueError, VectorError, \
-                            _xkwds, _xkwds_pop2
+                            _xattrs, _xkwds, _xkwds_pop2
 from pygeodesy.fmath import fdot, fidw, hypot_  # PYCHOK fdot shared
 from pygeodesy.fsums import Fsum, fsumf_
 from pygeodesy.formy import _isequalTo, n_xyz2latlon, n_xyz2philam, \
@@ -30,7 +30,7 @@ from pygeodesy.namedTuples import Trilaterate5Tuple, Vector3Tuple, \
                                   Vector4Tuple,  map1
 from pygeodesy.props import deprecated_method, Property_RO, property_doc_, \
                             property_RO, _update_all
-from pygeodesy.streprs import Fmt, hstr, unstr, _xattrs
+from pygeodesy.streprs import Fmt, hstr, unstr
 from pygeodesy.units import Bearing, Height, Radius_, Scalar
 from pygeodesy.utily import sincos2d, _unrollon, _unrollon3
 from pygeodesy.vector3d import Vector3d, _xyzhdlln4
@@ -38,7 +38,7 @@ from pygeodesy.vector3d import Vector3d, _xyzhdlln4
 from math import fabs, sqrt
 
 __all__ = _ALL_LAZY.nvectorBase
-__version__ = '24.06.06'
+__version__ = '24.06.12'
 
 
 class NvectorBase(Vector3d):  # XXX kept private
@@ -53,10 +53,9 @@ class NvectorBase(Vector3d):  # XXX kept private
 
            @arg x_xyz: X component of vector (C{scalar}) or (3-D) vector
                        (C{Nvector}, L{Vector3d}, L{Vector3Tuple} or L{Vector4Tuple}).
-           @kwarg y: Y component of vector (C{scalar}), ignored if B{C{x_xyz}} is not
-                     C{scalar}, otherwise same units as B{C{x_xyz}}.
-           @kwarg z: Z component of vector (C{scalar}), ignored if B{C{x_xyz}} is not
-                     C{scalar}, otherwise same units as B{C{x_xyz}}.
+           @kwarg y: Y component of vector (C{scalar}), required if B{C{x_xyz}} is
+                     C{scalar} and same units as B{C{x_xyz}}, ignored otherwise.
+           @kwarg z: Z component of vector (C{scalar}), like B{C{y}}.
            @kwarg h: Optional height above surface (C{meter}).
            @kwarg datum: Optional, I{pass-thru} datum (L{Datum}).
            @kwarg ll_name: Optional C{B{name}=NN} (C{str}) and optional, original
@@ -346,7 +345,7 @@ class NvectorBase(Vector3d):  # XXX kept private
     def toVector3d(self, norm=True):
         '''Convert this n-vector to a 3-D vector, I{ignoring height}.
 
-           @kwarg norm: Normalize the 3-D vector (C{bool}).
+           @kwarg norm: If C{True}, normalize the 3-D vector (C{bool}).
 
            @return: The (normalized) vector (L{Vector3d}).
         '''
@@ -366,7 +365,7 @@ class NvectorBase(Vector3d):  # XXX kept private
 
            @return: Normalized vector (C{Nvector}).
         '''
-        return _xattrs(Vector3d.unit(self, ll=ll), _under(_h_))
+        return _xattrs(Vector3d.unit(self, ll=ll), self, _under(_h_))
 
     @Property_RO
     def xyzh(self):
@@ -572,7 +571,7 @@ def sumOf(nvectors, Vector=None, h=None, **Vector_kwds):
                            arguments, ignored if C{B{Vector} is None}.
 
        @return: Vectorial sum (B{C{Vector}}) or a L{Vector4Tuple}C{(x, y,
-                z, h)} if B{C{Vector}} is C{None}.
+                z, h)} if C{B{Vector} is None}.
 
        @raise VectorError: No B{C{nvectors}}.
     '''

pygeodesy/osgr.py

@@ -46,14 +46,14 @@ from pygeodesy.namedTuples import EasNor2Tuple, LatLon2Tuple, \
 from pygeodesy.props import Property_RO, property_RO
 from pygeodesy.streprs import _EN_WIDE, enstr2, _enstr2m3, Fmt, \
                               _resolution10, unstr, _xzipairs
-from pygeodesy.units import Easting, Lam_, Lat, Lon, Northing, \
-                            Phi_, Scalar, _10um, _100km
+from pygeodesy.units import Easting, Lamd, Lat, Lon, Northing, \
+                            Phid, Scalar, _10um, _100km
 from pygeodesy.utily import degrees90, degrees180, sincostan3, truncate
 
 from math import cos, fabs, radians, sin, sqrt
 
 __all__ = _ALL_LAZY.osgr
-__version__ = '24.05.31'
+__version__ = '24.06.15'
 
 _equivalent_ = 'equivalent'
 _OSGR_       = 'OSGR'
@@ -108,7 +108,7 @@ class _NG(object):
 
     @Property_RO
     def lam0(self):  # True origin longitude C{radians}
-        return Lam_(self.lon0)
+        return Lamd(self.lon0)
 
     @Property_RO
     def lat0(self):  # True origin latitude, 49°N
@@ -160,7 +160,7 @@ class _NG(object):
 
     @Property_RO
     def phi0(self):  # True origin latitude C{radians}
-        return Phi_(self.lat0)
+        return Phid(self.lat0)
 
     def reverse(self, osgr):  # convert C{osgr} to (ellipsoidal} LatLon, as I{Karney}'s
         # U{Reverse<https://GeographicLib.SourceForge.io/C++/doc/OSGB_8hpp_source.html>}
@@ -296,7 +296,7 @@ class Osgr(_NamedBase):
            @kwarg LatLon_kwds: Optional, additional B{C{LatLon}} keyword
                                arguments, ignored if C{B{LatLon} is None}.
 
-           @return: A B{C{LatLon}} instance or if B{C{LatLon}} is C{None}
+           @return: A B{C{LatLon}} instance or if C{B{LatLon} is None}
                     a L{LatLonDatum3Tuple}C{(lat, lon, datum)}.
 
            @note: While OS grid references are based on the OSGB36 datum,
@@ -520,8 +520,8 @@ def parseOSGR(strOSGR, Osgr=Osgr, **name_Osgr_kwds):
                    optional, additional B{C{Osgr}} keyword arguments,
                    ignored if C{B{Osgr} is None}.
 
-       @return: An (B{C{Osgr}}) instance or if B{C{Osgr}} is
-                C{None} an L{EasNor2Tuple}C{(easting, northing)}.
+       @return: An (B{C{Osgr}}) instance or if C{B{Osgr} is None}, an
+                L{EasNor2Tuple}C{(easting, northing)}.
 
        @raise OSGRError: Invalid B{C{strOSGR}}.
     '''
@@ -598,7 +598,7 @@ def toOsgr(latlon, lon=None, kTM=False, datum=_WGS84, Osgr=Osgr,  # MCCABE 14
                    and additional B{C{Osgr}} keyword arguments,
                    ignored if C{B{Osgr} is None}.
 
-       @return: An (B{C{Osgr}}) instance or if B{C{Osgr}} is C{None}
+       @return: An (B{C{Osgr}}) instance or if C{B{Osgr} is None}
                 an L{EasNor2Tuple}C{(easting, northing)}.
 
        @note: If L{isint}C{(B{prec})} both easting and northing are