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

pygeodesy/unitsBase.py

@@ -4,17 +4,18 @@
 u'''Basic C{Float}, C{Int} and C{Str}ing units classes.
 '''
 
-from pygeodesy.errors import _UnexpectedError, UnitError, _XError
-from pygeodesy.interns import NN, _degrees_, _degrees2_, _invalid_, \
-                             _meter_, MISSING, _radians_, _radians2_, \
-                             _radius_, _UNDER_,  _std_  # PYCHOK used!
-from pygeodesy.lazily import _ALL_DOCS, _ALL_LAZY
-from pygeodesy.named import modulename, _Named, property_doc_
+from pygeodesy.basics import isstr, issubclassof, _xsubclassof
+from pygeodesy.errors import _IsnotError, _UnexpectedError, UnitError, _XError
+from pygeodesy.interns import NN, _degrees_, _degrees2_, _invalid_, _meter_, \
+                             _radians_, _radians2_, _radius_, _UNDER_, _units_, \
+                             _std_  # PYCHOK used!
+from pygeodesy.lazily import _ALL_DOCS, _ALL_LAZY, _ALL_MODS as _MODS
+from pygeodesy.named import modulename, _Named,  property_doc_
 # from pygeodesy.props import property_doc_  # from .named
 from pygeodesy.streprs import Fmt, fstr
 
 __all__ = _ALL_LAZY.unitsBase
-__version__ = '24.06.05'
+__version__ = '24.06.15'
 
 
 class _NamedUnit(_Named):
@@ -23,6 +24,56 @@ class _NamedUnit(_Named):
     _std_repr = True  # set below
     _units    = None
 
+    def __new__(cls, typ, arg, name, Error=UnitError, **name_arg):
+        '''(INTERNAL) Return a named C{typ.__new__(cls, arg)} instance.
+        '''
+        if name_arg:
+            name, arg = _NamedUnit._arg_name_arg2(arg, name, **name_arg)
+        try:  # assert typ in cls.__mro__
+            self = typ.__new__(cls, arg)
+            if name:
+                self.name = name
+        except Exception as x:
+            raise _NamedUnit._Error(cls, arg, name, Error, cause=x)
+        return self
+
+    @staticmethod
+    def _arg_name_arg2(arg, name=NN, name__=None, **name_arg):  # in .units
+        '''(INTERNAL) Get the 2-tuple C{(name, arg)}.
+        '''
+        if name_arg:
+            if len(name_arg) > 1:
+                raise _UnexpectedError(**name_arg)
+            for name, arg in name_arg.items():  # next(iter(.items()))
+                break
+        elif name:
+            pass
+        elif name__ is not None:
+            name = name__.__name__
+        return name, arg
+
+    @staticmethod  # PYCHOK unused suffix
+    def _Error(cls, arg, name, Error=UnitError, suffix=NN,  # unused
+                                txt=_invalid_, cause=None, **name_arg):
+        '''(INTERNAL) Return a C{_NamedUnit} error with explanation.
+
+           @returns: An B{C{Error}} instance.
+        '''
+        kwds, x = {}, cause
+        if x is not None:  # caught exception
+            if Error is UnitError:  # and isError(x)
+                Error = type(x)  # i.e. not overridden
+            if txt is _invalid_:
+                txt = str(x)  # i.e. not overridden
+            kwds.update(cause=x)
+        if name_arg:
+            try:
+                name, arg = _NamedUnit._arg_name_arg2(arg, name, **name_arg)
+            except Exception:  # ignore, same error?
+                kwds.update(name_arg)
+        n = name if name else modulename(cls).lstrip(_UNDER_)
+        return _XError(Error, n, arg, txt=txt, **kwds)
+
     @property_doc_(' standard C{repr} or named C{toRepr} representation.')
     def std_repr(self):
         '''Get the representation (C{bool}, C{True} means standard).
@@ -61,29 +112,20 @@ class Float(float, _NamedUnit):
     '''
     # _std_repr = True  # set below
 
-    def __new__(cls, arg=None, name=NN, Error=UnitError, **name_arg):
-        '''New C{Ffloat} instance.
+    def __new__(cls, arg=None, name=NN, **Error_name_arg):
+        '''New, named C{Ffloat}.
 
-           @kwarg arg: The value (any C{type} convertable to C{float}).
-           @kwarg name: Optional instance name (C{str}).
-           @kwarg Error: Optional error to raise, overriding the default
-                         L{UnitError}.
-           @kwarg name_arg: Optional C{name=arg} keyword argument, inlieu
-                            of separate B{C{arg}} and B{C{name}} ones.
+           @kwarg arg: The value (any C{type} acceptable to C{float}).
+           @kwarg name: Optional name (C{str}).
+           @kwarg Error_name_arg: Optional C{B{Error}=UnitError} to raise
+                        and optional C{name=arg} keyword argument, inlieu
+                        of separate B{C{arg}} and B{C{name}} ones.
 
-           @returns: A C{Float} instance.
+           @returns: A named C{Float}.
 
            @raise Error: Invalid B{C{arg}}.
         '''
-        if name_arg:
-            name, arg = _arg_name_arg2(arg, **name_arg)
-        try:
-            self = float.__new__(cls, arg)
-            if name:
-                _NamedUnit.name.fset(self, name)  # see _Named.name
-        except Exception as x:  # XXX not ... as x:
-            raise _Error(cls, arg, name, Error, x=x)
-        return self
+        return _NamedUnit.__new__(cls, float, arg, name, **Error_name_arg)
 
     def __repr__(self):  # to avoid MRO(float)
         '''Return a representation of this C{Float}.
@@ -100,10 +142,11 @@ class Float(float, _NamedUnit):
     def __str__(self):  # to avoid MRO(float)
         '''Return this C{Float} as standard C{str}.
         '''
-        # XXX must use super(Float, self)... since super()...
-        # only works for Python 3+ and float.__str__(self)
-        # invokes .__repr__(self); calling self.toRepr(std=True)
-        # super(Float, self).__repr__() mimicks this behavior
+        # must use super(Float, self)... since super()... only works
+        # for Python 3+ and float.__str__(self) invokes .__repr__(self);
+        # calling self.toRepr(std=True) super(Float, self).__repr__()
+        # mimicks this bhavior
+
         # XXX the default number of decimals is 10-12 when using
         # float.__str__(self) with both python 3.8+ and 2.7-, but
         # float.__repr__(self) shows DIG decimals in python2.7!
@@ -116,20 +159,19 @@ class Float(float, _NamedUnit):
            @kwarg std: If C{True} return the standard C{repr},
                        otherwise the named representation (C{bool}).
 
-           @see: Methods L{Float.__repr__}, L{Float.toStr} and function
-                 L{pygeodesy.fstr} for more documentation.
+           @see: Function L{fstr<pygeodesy.streprs.fstr>} and methods
+                 L{Float.__repr__}, L{Float.toStr} for further details.
         '''
-        # XXX must use super(Float, self)... since
-        # super()... only works for Python 3+
-        # return super(Float, self).__repr__() if std else \
+        # must use super(Float, self)... since super()... only works for
+        # Python 3+; return super(Float, self).__repr__() if std else \
         return float.__repr__(self) if std else \
                self._toRepr(self.toStr(**prec_fmt_ints))
 
     def toStr(self, prec=12, fmt=Fmt.g, ints=False):  # PYCHOK prec=8, ...
         '''Format this C{Float} as C{str}.
 
-           @see: Method L{Float.__repr__} and function L{pygeodesy.fstr}
-                 for more documentation.
+           @see: Function L{fstr<pygeodesy.streprs.fstr>} and method
+                 L{Float.__repr__} and for further information.
         '''
         return fstr(self, prec=prec, fmt=fmt, ints=ints)
 
@@ -139,29 +181,20 @@ class Int(int, _NamedUnit):
     '''
     # _std_repr = True  # set below
 
-    def __new__(cls, arg=None, name=NN, Error=UnitError, **name_arg):
-        '''New C{Int} instance.
+    def __new__(cls, arg=None, name=NN, **Error_name_arg):
+        '''New, named C{Int}.
 
-           @kwarg arg: The value (any C{type} convertable to C{float}).
-           @kwarg name: Optional instance name (C{str}).
-           @kwarg Error: Optional error to raise, overriding the
-                         default L{UnitError}.
-           @kwarg name_arg: Optional C{name=arg} keyword argument, inlieu
-                            of separate B{C{arg}} and B{C{name}} ones.
+           @kwarg arg: The value (any C{type} acceptable to C{int}).
+           @kwarg name: Optional name (C{str}).
+           @kwarg Error_name_arg: Optional C{B{Error}=UnitError} to raise
+                        and optional C{name=arg} keyword argument, inlieu
+                        of separate B{C{arg}} and B{C{name}} ones.
 
-           @returns: An C{Int} instance.
+           @returns: A named C{Int}.
 
            @raise Error: Invalid B{C{arg}}.
         '''
-        if name_arg:
-            name, arg = _arg_name_arg2(arg, **name_arg)
-        try:
-            self = int.__new__(cls, arg)
-            if name:
-                _NamedUnit.name.fset(self, name)  # see _Named.name
-        except Exception as x:  # XXX not ... as x:
-            raise _Error(cls, arg, name, Error, x=x)
-        return self
+        return _NamedUnit.__new__(cls, int, arg, name, **Error_name_arg)
 
     def __repr__(self):  # to avoid MRO(int)
         '''Return a representation of this named C{int}.
@@ -215,32 +248,23 @@ class Str(str, _NamedUnit):
     '''
     # _std_repr = True  # set below
 
-    def __new__(cls, arg=None, name=NN, Error=UnitError, **name_arg):
-        '''New  C{Str} instance.
+    def __new__(cls, arg=None, name=NN, **Error_name_arg):
+        '''New, named and callable C{Str}.
 
            @kwarg cls: This class (C{Str} or sub-class).
-           @kwarg arg: The value (any C{type} convertable to C{str}).
-           @kwarg name: Optional instance name (C{str}).
-           @kwarg Error: Optional error to raise, overriding the
-                         default (C{ValueError}).
-           @kwarg name_arg: Optional C{name=arg} keyword argument, inlieu
-                            of separate B{C{arg}} and B{C{name}} ones.
+           @kwarg arg: The value (any C{type} acceptable to C{str}).
+           @kwarg name: Optional name (C{str}).
+           @kwarg Error_name_arg: Optional C{B{Error}=UnitError} to raise
+                        and optional C{name=arg} keyword argument, inlieu
+                        of separate B{C{arg}} and B{C{name}} ones.
 
-           @returns: A L{Str} instance.
+           @returns: A named L{Str}.
 
            @raise Error: Invalid B{C{arg}}.
 
-           @see: Callable, not-nameable class L{pygeodesy.Str_}.
+           @see: Callable, not nameable class L{Str_<pygeodesy.interns.Str_>}.
         '''
-        if name_arg:
-            name, arg = _arg_name_arg2(arg, **name_arg)
-        try:
-            self = str.__new__(cls, arg)
-            if name:
-                _NamedUnit.name.fset(self, name)  # see _Named.name
-        except Exception as x:  # XXX not ... as x:
-            raise _Error(cls, arg, name, Error, x=x)
-        return self
+        return _NamedUnit.__new__(cls, str, arg, name, **Error_name_arg)
 
     def __repr__(self):
         '''Return a representation of this C{Str}.
@@ -279,18 +303,16 @@ class Str(str, _NamedUnit):
 
            @see: Method L{Str.__repr__} for more documentation.
         '''
-        # must use super(Str, self).. since
-        # super()... only works for Python 3+ and
-        # str.__repr__(self) fails with Python 3.8+
+        # must use super(Str, self)... since super()... only works
+        # for Python 3+ and str.__repr__(self) fails in Python 3.8+
         r = super(Str, self).__repr__()
         return r if std else self._toRepr(r)
 
     def toStr(self, **unused):  # PYCHOK **unused
         '''Return this C{Str} as standard C{str}.
         '''
-        # must use super(Str, self)... since
-        # super()... only works for Python 3+ and
-        # str.__str__(self) fails with Python 3.8+
+        # must use super(Str, self)... since super()... only works
+        # for Python 3+ and str.__repr__(self) fails in Python 3.8+
         return super(Str, self).__str__()
 
 
@@ -302,39 +324,25 @@ _Str_radians  = Str(_radians_)   # PYCHOK in .frechet, .hausdorff
 _Str_radians2 = Str(_radians2_)  # PYCHOK in .frechet, .hausdorff
 
 
-def _Error(clas, arg, name, Error, txt=_invalid_, x=None):
-    '''(INTERNAL) Return an error with explanation.
-
-       @arg clas: The C{units} class or sub-class.
-       @arg arg: The original C{unit} value.
-       @arg name: The instance name (C{str}).
-       @arg Error: The Error class to use (C{Excetion}).
-       @kwarg txt: An explanation of the error )C{str}).
-       @kwarg x: Caught exception, used for exception
-                 chaining (iff enabled in Python3+).
-
-       @returns: An B{C{Error}} instance.
+def _xUnit(units, Base):  # PYCHOK in .frechet,  .hausdorff
+    '''(INTERNAL) Get C{Unit} from C{units} or C{name}, ortherwise C{Base}.
     '''
-    if x is not None:  # caught exception, cause
-        if Error is UnitError:  # and isError(x)
-            Error = type(x)  # i.e. if not overridden
-        if txt is _invalid_:
-            txt = str(x)  # i.e. if not overridden
-    n = name if name else modulename(clas).lstrip(_UNDER_)
-    return _XError(Error, n, arg, txt=txt, cause=x)
+    _xsubclassof(_NamedUnit, Base=Base)
+    U = getattr(_MODS, units.capitalize(), Base) if isstr(units) else units
+    return U if issubclassof(U, Base) else Base
 
 
-def _arg_name_arg2(arg, name__=None, **name_arg):  # in .units
-    '''(INTERNAL) Get the 2-tuple C{(name, arg)}.
+def _xUnits(units, Base=_NamedUnit):  # in .frechet, .hausdorff
+    '''(INTERNAL) Set property C{units} as C{Unit} or C{Str}.
     '''
-    if name__ is None:
-        t =  name_arg.popitem() if len(name_arg) == 1 else \
-            (MISSING, arg)
+    _xsubclassof(_NamedUnit, Base=Base)
+    if issubclassof(units, Base):
+        U = units
+    elif isstr(units):
+        U = Str(units, name=_units_)  # XXX Str to _Pass and for backward compatibility
     else:
-        t =  name__.__name__, arg
-    if name_arg:
-        raise _UnexpectedError(**name_arg)
-    return t
+        raise _IsnotError(Base, Str, str, units=units)
+    return U
 
 
 __all__ += _ALL_DOCS(_NamedUnit)

pygeodesy/ups.py

@@ -49,7 +49,7 @@ from pygeodesy.utmupsBase import Fmt, _LLEB, _hemi, _parseUTMUPS5, _to4lldn, \
 from math import atan2, fabs, radians, tan
 
 __all__ = _ALL_LAZY.ups
-__version__ = '25.05.31'
+__version__ = '24.06.11'
 
 _BZ_UPS  = _getenv('PYGEODESY_UPS_POLES', _std_) == _std_
 _Falsing =  Meter(2000e3)  # false easting and northing (C{meter})
@@ -183,7 +183,7 @@ class Ups(UtmUpsBase):
            @arg scale0: UPS k0 scale at B{C{lat}} latitude (C{scalar}).
 
            @raise RangeError: If B{C{lat}} outside the valid range and
-                              L{pygeodesy.rangerrors} set to C{True}.
+                              L{rangerrors<pygeodesy.rangerrors>} is C{True}.
 
            @raise UPSError: Invalid B{C{scale}}.
         '''
@@ -206,8 +206,8 @@ class Ups(UtmUpsBase):
            @kwarg LatLon_kwds: Optional, additional B{C{LatLon}} keyword
                                arguments, ignored if C{B{LatLon} is None}.
 
-           @return: This UPS coordinate (B{C{LatLon}}) or if B{C{LatLon}}
-                    is C{None}, a L{LatLonDatum5Tuple}C{(lat, lon, datum,
+           @return: This UPS coordinate (B{C{LatLon}}) or if C{B{LatLon}
+                    is None}, a L{LatLonDatum5Tuple}C{(lat, lon, datum,
                     gamma, scale)}.
 
            @raise TypeError: If B{C{LatLon}} is not ellipsoidal.
@@ -257,8 +257,8 @@ class Ups(UtmUpsBase):
            @return: This UPS as a string with C{00[Band] pole, easting,
                     northing, [convergence, scale]} as C{"[Z:00[Band],
                     P:N|S, E:meter, N:meter]"} plus C{", C:DMS, S:float"}
-                    if B{C{cs}} is C{True}, where C{[Band]} is present and
-                    C{'A'|'B'|'Y'|'Z'} only if B{C{B}} is C{True} and
+                    if C{B{cs} is True}, where C{[Band]} is present and
+                    C{'A'|'B'|'Y'|'Z'} only if C{B{B} is True} and
                     convergence C{DMS} is in I{either} degrees, minutes
                     I{or} seconds (C{str}).
 
@@ -352,10 +352,10 @@ def parseUPS5(strUPS, datum=_WGS84, Ups=Ups, falsed=True, **name):
                       are falsed (C{bool}).
        @kwarg name: Optional B{C{Ups}} C{B{name}=NN} (C{str}).
 
-       @return: The UPS coordinate (B{C{Ups}}) or a
-                L{UtmUps5Tuple}C{(zone, hemipole, easting, northing,
-                band)} if B{C{Ups}} is C{None}.  The C{hemipole} is
-                the C{'N'|'S'} pole, the UPS projection top/center.
+       @return: The UPS coordinate (B{C{Ups}}) or if C{B{Ups} is None}, a
+                L{UtmUps5Tuple}C{(zone, hemipole, easting, northing, band)}.
+                The C{hemipole} is the C{'N'|'S'} pole, the UPS projection
+                top/center.
 
        @raise UPSError: Invalid B{C{strUPS}}.
     '''
@@ -399,21 +399,18 @@ def toUps8(latlon, lon=None, datum=None, Ups=Ups, pole=NN,
        @kwarg strict: Restrict B{C{lat}} to UPS ranges (C{bool}).
        @kwarg name: Optional B{C{Ups}} C{B{name}=NN} (C{str}).
 
-       @return: The UPS coordinate (B{C{Ups}}) or a L{UtmUps8Tuple}C{(zone,
-                hemipole, easting, northing, band, datum, gamma, scale)} if
-                B{C{Ups}} is C{None}.  The C{hemipole} is the C{'N'|'S'}
+       @return: The UPS coordinate (B{C{Ups}}) or if C{B{Ups} is None}, a
+                L{UtmUps8Tuple}C{(zone, hemipole, easting, northing, band,
+                datum, gamma, scale)} where C{hemipole} is the C{'N'|'S'}
                 pole, the UPS projection top/center.
 
-       @raise RangeError: If B{C{strict}} and B{C{lat}} outside the valid
-                          UPS bands or if B{C{lat}} or B{C{lon}} outside
-                          the valid range and L{pygeodesy.rangerrors} set
-                          to C{True}.
+       @raise RangeError: If B{C{strict}} and B{C{lat}} outside the valid UPS bands
+                          or if B{C{lat}} or B{C{lon}} outside the valid range and
+                          L{rangerrors<pygeodesy.rangerrors>} is C{True}.
 
-       @raise TypeError: If B{C{latlon}} is not ellipsoidal or if B{C{datum}}
-                         is invalid.
+       @raise TypeError: If B{C{latlon}} is not ellipsoidal or if B{C{datum}} is invalid.
 
-       @raise ValueError: If B{C{lon}} value is missing or if B{C{latlon}}
-                          is invalid.
+       @raise ValueError: If B{C{lon}} value is missing or if B{C{latlon}} is invalid.
 
        @see: I{Karney}'s C++ class U{UPS
              <https://GeographicLib.SourceForge.io/C++/doc/classGeographicLib_1_1UPS.html>}.
@@ -478,18 +475,16 @@ def upsZoneBand5(lat, lon, strict=True, **name):
        @kwarg strict: Restrict B{C{lat}} to UPS ranges (C{bool}).
        @kwarg name: Optional B{C{Ups}} C{B{name}=NN} (C{str}).
 
-       @return: A L{UtmUpsLatLon5Tuple}C{(zone, band, hemipole, lat,
-                lon)} where C{hemipole} is the C{'N'|'S'} pole, the
-                UPS projection top/center and C{lon} [-180..180).
+       @return: A L{UtmUpsLatLon5Tuple}C{(zone, band, hemipole, lat, lon)}
+                where C{hemipole} is the C{'N'|'S'} pole, the UPS projection
+                top/center and C{lon} [-180..180).
 
-       @note: The C{lon} is set to C{0} if B{C{lat}} is C{-90} or
-              C{90}, see env variable C{PYGEODESY_UPS_POLES} in
-              module L{pygeodesy.ups}.
+       @note: The C{lon} is set to C{0} if B{C{lat}} is C{-90} or C{90}, see env
+              variable C{PYGEODESY_UPS_POLES} in module L{ups<pygeodesy.ups>}.
 
-       @raise RangeError: If B{C{strict}} and B{C{lat}} in the UTM
-                          and not the UPS range or if B{C{lat}} or
-                          B{C{lon}} outside the valid range and
-                          L{pygeodesy.rangerrors} set to C{True}.
+       @raise RangeError: If B{C{strict} is True} and B{C{lat}} within the UTM but not
+                          the UPS range or if B{C{lat}} or B{C{lon}} outside the valid
+                          range and L{rangerrors<pygeodesy.rangerrors>} is C{True}.
 
        @raise ValueError: Invalid B{C{lat}} or B{C{lon}}.
     '''

pygeodesy/utily.py

@@ -21,13 +21,13 @@ from pygeodesy.errors import _ValueError, _xkwds, _xkwds_get1,  _ALL_LAZY, _MODS
 from pygeodesy.internals import _passargs  # , _MODS?
 from pygeodesy.interns import _edge_, _radians_, _semi_circular_, _SPACE_
 # from pygeodesy.lazily import _ALL_LAZY, _ALL_MODS as _MODS  # from .errors
-from pygeodesy.units import Degrees, Degrees_, Feet, Float, Lam, Lam_, \
+from pygeodesy.units import Degrees, Degrees_, Feet, Float, Lam, Lamd, \
                             Meter, Meter2, Radians, Radians_
 
 from math import acos, asin, atan2, cos, degrees, fabs, radians, sin, tan  # pow
 
 __all__ = _ALL_LAZY.utily
-__version__ = '24.06.03'
+__version__ = '24.06.15'
 
 # read constant name "_M_Unit" as "meter per Unit"
 _M_CHAIN     = _F(  20.1168)     # yard2m(1) * 22
@@ -171,7 +171,7 @@ def circle4(earth, lat):
                 instance.
 
        @raise RangeError: Latitude B{C{lat}} outside valid range and
-                          L{pygeodesy.rangerrors} set to C{True}.
+                          L{rangerrors<pygeodesy.rangerrors>} is C{True}.
 
        @raise TypeError: Invalid B{C{earth}}.
 
@@ -308,7 +308,7 @@ def degrees2m(deg, radius=R_M, lat=0):
                 near-polar B{C{lat}}.
 
        @raise RangeError: Latitude B{C{lat}} outside valid range and
-                          L{pygeodesy.rangerrors} set to C{True}.
+                          L{rangerrors<pygeodesy.rangerrors>} is C{True}.
 
        @raise TypeError: Invalid B{C{radius}}.
 
@@ -317,7 +317,7 @@ def degrees2m(deg, radius=R_M, lat=0):
 
        @see: Function L{radians2m} and L{m2degrees}.
     '''
-    return _Radians2m(Lam_(deg=deg, clip=0), radius, lat)
+    return _Radians2m(Lamd(deg=deg, clip=0), radius, lat)
 
 
 def fathom2m(fathoms):
@@ -449,7 +449,7 @@ def m2degrees(distance, radius=R_M, lat=0):
        @return: Angle (C{degrees}) or C{INF} for near-polar B{C{lat}}.
 
        @raise RangeError: Latitude B{C{lat}} outside valid range and
-                          L{pygeodesy.rangerrors} set to C{True}.
+                          L{rangerrors<pygeodesy.rangerrors>} is C{True}.
 
        @raise TypeError: Invalid B{C{radius}}.
 
@@ -546,7 +546,7 @@ def m2radians(distance, radius=R_M, lat=0):
        @return: Angle (C{radians}) or C{INF} for near-polar B{C{lat}}.
 
        @raise RangeError: Latitude B{C{lat}} outside valid range and
-                          L{pygeodesy.rangerrors} set to C{True}.
+                          L{rangerrors<pygeodesy.rangerrors>} is C{True}.
 
        @raise TypeError: Invalid B{C{radius}}.
 
@@ -624,7 +624,7 @@ def radians2m(rad, radius=R_M, lat=0):
                 near-polar B{C{lat}}.
 
        @raise RangeError: Latitude B{C{lat}} outside valid range and
-                          L{pygeodesy.rangerrors} set to C{True}.
+                          L{rangerrors<pygeodesy.rangerrors>} is C{True}.
 
        @raise TypeError: Invalid B{C{radius}}.
 

pygeodesy/utm.py

@@ -63,7 +63,7 @@ from math import asinh, atanh, atan2, cos, cosh, degrees, fabs, \
 # import operator as _operator  # from .fmath
 
 __all__ = _ALL_LAZY.utm
-__version__ = '24.05.31'
+__version__ = '24.06.11'
 
 _Bands = 'CDEFGHJKLMNPQRSTUVWXX'  # UTM latitude bands C..X (no
 # I|O) 8° each, covering 80°S to 84°N and X repeated for 80-84°N
@@ -386,8 +386,8 @@ class Utm(UtmUpsBase):
                       the precison like B{C{prec}}).
 
            @return: This UTM as a string C{"[Z:09[band], H:N|S, E:meter,
-                    N:meter]"} plus C{", C:degrees, S:float"} if B{C{cs}} is
-                    C{True} (C{str}).
+                    N:meter]"} plus C{", C:degrees, S:float"} if C{B{cs}
+                    is True} (C{str}).
         '''
         return self._toRepr(fmt, B, cs, prec, sep)
 
@@ -411,7 +411,7 @@ class Utm(UtmUpsBase):
            @return: This UTM as a string with C{zone[band], hemisphere,
                     easting, northing, [convergence, scale]} in
                     C{"00 N|S meter meter"} plus C{" degrees float"} if
-                    B{C{cs}} is C{True} (C{str}).
+                    C{B{cs} is True} (C{str}).
         '''
         return self._toStr(self.hemisphere, B, cs, prec, sep)
 
@@ -502,16 +502,15 @@ def parseUTM5(strUTM, datum=_WGS84, Utm=Utm, falsed=True, **name):
        @arg strUTM: A UTM coordinate (C{str}).
        @kwarg datum: Optional datum to use (L{Datum}, L{Ellipsoid},
                      L{Ellipsoid2} or L{a_f2Tuple}).
-       @kwarg Utm: Optional class to return the UTM coordinate
-                   (L{Utm}) or C{None}.
-       @kwarg falsed: Use C{B{falsed}=True} if both easting and
-                      northing are falsed (C{bool}).
-       @kwarg name: Optional B{C{Utm}} C{B{name}=NN} (C{str}).
+       @kwarg Utm: Optional class to return the UTM coordinate (L{Utm})
+                   or C{None}.
+       @kwarg falsed: Use C{B{falsed}=False} if both easting and northing
+                      are I{not falsed} (C{bool}).
+       @kwarg name: Optional C{B{name}=NN} (C{str}).
 
-       @return: The UTM coordinate (B{C{Utm}}) or if B{C{Utm}}
-                is C{None}, a L{UtmUps5Tuple}C{(zone, hemipole,
-                easting, northing, band)}.  The C{hemipole} is
-                the C{'N'|'S'} hemisphere.
+       @return: The UTM coordinate (B{C{Utm}}) or if C{B{Utm} is None}, a
+                L{UtmUps5Tuple}C{(zone, hemipole, easting, northing, band)}.
+                The C{hemipole} is the C{'N'|'S'} hemisphere.
 
        @raise UTMError: Invalid B{C{strUTM}}.
 
@@ -526,40 +525,36 @@ def toUtm8(latlon, lon=None, datum=None, Utm=Utm, falsed=True,
 
        @arg latlon: Latitude (C{degrees}) or an (ellipsoidal)
                     geodetic C{LatLon} point.
-       @kwarg lon: Optional longitude (C{degrees}), required
-                   if B{C{latlon}} is in C{degrees}.
-       @kwarg datum: Optional datum for this UTM coordinate,
-                     overriding B{C{latlon}}'s datum (L{Datum},
-                     L{Ellipsoid}, L{Ellipsoid2} or L{a_f2Tuple}).
-       @kwarg Utm: Optional class to return the UTM coordinate
-                   (L{Utm}) or C{None}.
-       @kwarg falsed: False both easting and northing (C{bool}).
-       @kwarg strict: Restrict B{C{lat}} to UTM ranges (C{bool}).
+       @kwarg lon: Longitude (C{degrees}), required if B{C{latlon}} is
+                   C{degrees}, ignored otherwise.
+       @kwarg datum: Optional datum for this UTM coordinate, overriding
+                     B{C{latlon}}'s datum (L{Datum}, L{Ellipsoid}, L{Ellipsoid2}
+                     or L{a_f2Tuple}).
+       @kwarg Utm: Optional class to return the UTM coordinate (L{Utm}) or C{None}.
+       @kwarg falsed: If C{True}, false both easting and northing (C{bool}).
+       @kwarg strict: If C{True}, restrict B{C{lat}} to UTM ranges (C{bool}).
        @kwarg zone: Optional UTM zone to enforce (C{int} or C{str}).
-       @kwarg name_cmoff: Optional B{C{Utm}} C{B{name}=NN} (C{str}) and
-                   DEPRECATED C{B{cmoff}=True} to offset the longitude
-                   from the zone's central meridian (C{bool}), use
-                   C{B{falsed}} instead.
+       @kwarg name_cmoff: Optional C{B{name}=NN} (C{str}) and DEPRECATED keyword
+                   argument C{B{cmoff}=True} to offset the longitude from the zone's
+                   central meridian (C{bool}), use C{B{falsed}} instead.
 
-       @return: The UTM coordinate (B{C{Utm}}) or if B{C{Utm}} is
-                C{None} or not B{C{falsed}}, a L{UtmUps8Tuple}C{(zone,
-                hemipole, easting, northing, band, datum, gamma,
-                scale)}.  The C{hemipole} is the C{'N'|'S'} hemisphere.
+       @return: The UTM coordinate (B{C{Utm}}) or if C{B{Utm} is None} or C{B{falsed}
+                is False}, a L{UtmUps8Tuple}C{(zone, hemipole, easting, northing, band,
+                datum, gamma, scale)} where C{hemipole} is the C{'N'|'S'} hemisphere.
 
-       @raise RangeError: If B{C{lat}} outside the valid UTM bands or if
-                          B{C{lat}} or B{C{lon}} outside the valid range
-                          and L{pygeodesy.rangerrors} set to C{True}.
+       @raise RangeError: If B{C{lat}} outside the valid UTM bands or if B{C{lat}}
+                          or B{C{lon}} outside the valid range and L{rangerrors
+                          <pygeodesy.rangerrors>} is C{True}.
 
        @raise TypeError: Invalid B{C{datum}} or B{C{latlon}} not ellipsoidal.
 
        @raise UTMError: Invalid B{C{zone}}.
 
-       @raise ValueError: If B{C{lon}} value is missing or B{C{latlon}}
-                          is invalid.
+       @raise ValueError: If B{C{lon}} is missing or B{C{latlon}} is invalid.
 
-       @note: Implements Karney’s method, using 8-th order Krüger series,
-              giving results accurate to 5 nm (or better) for distances
-              up to 3,900 Km from the central meridian.
+       @note: Implements Karney’s method, using 8-th order Krüger series, giving
+              results accurate to 5 nm (or better) for distances up to 3,900 Km
+              from the central meridian.
     '''
     z, B, lat, lon, d, f, n = _to7zBlldfn(latlon, lon, datum,
                                           falsed, zone, strict,
@@ -727,8 +722,8 @@ def utmZoneBand5(lat, lon, cmoff=False, **name):
                 where C{hemipole} is the C{'N'|'S'} UTM hemisphere.
 
        @raise RangeError: If B{C{lat}} outside the valid UTM bands or if
-                          B{C{lat}} or B{C{lon}} outside the valid range
-                          and L{pygeodesy.rangerrors} set to C{True}.
+                          B{C{lat}} or B{C{lon}} outside the valid range and
+                          L{rangerrors<pygeodesy.rangerrors>} is C{True}.
 
        @raise ValueError: Invalid B{C{lat}} or B{C{lon}}.
     '''