pygeodesy 24.10.24__py2.py3-none-any.whl → 24.11.11__py2.py3-none-any.whl

pygeodesy/internals.py

@@ -7,7 +7,7 @@ u'''Mostly INTERNAL functions, except L{machine}, L{print_} and L{printf}.
 # from pygeodesy.errors import _AttributeError, _error_init, _UnexpectedError, _xError2  # _MODS
 from pygeodesy.interns import NN, _BAR_, _COLON_, _DASH_, _DOT_, _ELLIPSIS_, _EQUALSPACED_, \
                              _immutable_, _NL_, _pygeodesy_, _PyPy__, _python_, _QUOTE1_, \
-                             _QUOTE2_, _s_, _SPACE_, _sys, _UNDER_, _utf_8_
+                             _QUOTE2_, _s_, _SPACE_, _sys, _UNDER_
 from pygeodesy.interns import _COMMA_, _Python_  # PYCHOK used!
 # from pygeodesy.streprs import anstr, pairs, unstr  # _MODS
 
@@ -16,6 +16,7 @@ from pygeodesy.interns import _COMMA_, _Python_  # PYCHOK used!
 # import sys as _sys  # from .interns
 
 _0_0      =  0.0  # PYCHOK in .basics, .constants
+_100_0    =  100.0  # in .constants
 _arm64_   = 'arm64'
 _iOS_     = 'iOS'
 _macOS_   = 'macOS'
@@ -40,14 +41,14 @@ def _DUNDER_nameof_(*names__):  # in .errors._IsnotError
 
 
 def _Property_RO(method):
-    '''(INTERNAL) Can't I{recursively} import L{props.property_RO}.
+    '''(INTERNAL) Can't import L{props.Property_RO}, I{recursively}.
     '''
     name = _DUNDER_nameof(method)
 
-    def _del(inst, attr):  # PYCHOK no cover
-        delattr(inst, attr)  # force error
+    def _del(inst, *unused):  # PYCHOK no cover
+        inst.__dict__.pop(name, None)
 
-    def _get(inst, **unused):  # PYCHOK 2 vs 3 args
+    def _get(inst, *unused):  # PYCHOK 2 vs 3 args
         try:  # to get the cached value immediately
             v = inst.__dict__[name]
         except (AttributeError, KeyError):
@@ -69,7 +70,8 @@ class _MODS_Base(object):
 
     def __setattr__(self, attr, value):  # PYCHOK no cover
         e = _MODS.errors
-        t = _EQUALSPACED_(self._DOT_(attr), repr(value))
+        n = _DOT_(self.name, attr)
+        t = _EQUALSPACED_(n, repr(value))
         raise e._AttributeError(_immutable_, txt=t)
 
     @_Property_RO
@@ -84,7 +86,6 @@ class _MODS_Base(object):
         '''Get platform 2-list C{[bits, machine]}, I{once}.
         '''
         import platform as p
-
         m = p.machine()  # ARM64, arm64, x86_64, iPhone13,2, etc.
         m = m.replace(_COMMA_, _UNDER_)
         if m.lower() == 'x86_64':  # PYCHOK on Intel or Rosetta2 ...
@@ -99,30 +100,15 @@ class _MODS_Base(object):
 
     @_Property_RO
     def ctypes3(self):
-        '''Get 3-tuple C{(ctypes.CDLL, ._dlopen, .util.findlibrary)}, I{once}.
+        '''Get C{ctypes.CDLL}, C{find_library} and C{dlopen}, I{once}.
         '''
-        if _ismacOS():
-            from ctypes import CDLL, DEFAULT_MODE, _dlopen
-
-            def dlopen(name):
-                return _dlopen(name, DEFAULT_MODE)
-
-        else:  # PYCHOK no cover
-            from ctypes import CDLL
-            dlopen = _passarg
-
-        from ctypes.util import find_library
-        return CDLL, dlopen, find_library
+        import ctypes as c
+        from ctypes.util import find_library as f
 
-    @_Property_RO
-    def ctypes5(self):
-        '''Get 5-tuple C{(ctypes.byref, .c_char_p, .c_size_t, .c_uint, .sizeof)}, I{once}.
-        '''
-        from ctypes import byref, c_char_p, c_size_t, c_uint, sizeof  # get_errno
-        return byref, c_char_p, c_size_t, c_uint, sizeof
+        def dlopen(name):  # on macOS only
+            return c._dlopen(name, c.DEFAULT_MODE)
 
-    def _DOT_(self, name):  # PYCHOK no cover
-        return _DOT_(self.name, name)
+        return c.CDLL, f, (dlopen if _ismacOS() else None)
 
     @_Property_RO
     def errors(self):
@@ -143,15 +129,10 @@ class _MODS_Base(object):
         '''
         try:  # Pythonista only
             from platform import iOS_ver
-            return iOS_ver()
+            t = iOS_ver()
         except (AttributeError, ImportError):
-            return NN, (NN, NN, NN), NN
-
-    @_Property_RO
-    def libc(self):
-        '''Load C{libc.dll|dylib}, I{once}.
-        '''
-        return _load_lib('libc')
+            t = NN, (NN, NN, NN), NN
+        return t
 
     @_Property_RO
     def name(self):
@@ -161,13 +142,12 @@ class _MODS_Base(object):
 
     @_Property_RO
     def nix2(self):  # PYCHOK no cover
-        '''Get Linux 2-list C{[distro, version]}, I{once}.
+        '''Get Linux 2-tuple C{(distro, version)}, I{once}.
         '''
-        import platform as p
-
-        n, v = p.uname()[0], NN
+        from platform import uname
+        v, n = NN, uname()[0]  # [0] == .system
         if n.lower() == 'linux':
-            try:  # use distro only for Linux, not macOS, etc.
+            try:  # use distro only on Linux, not macOS, etc.
                 import distro  # <https://PyPI.org/project/distro>
                 _a = _MODS.streprs.anstr
                 v  = _a(distro.version())  # first
@@ -197,7 +177,6 @@ class _MODS_Base(object):
         '''Get 2-list C{[OS, release]}, I{once}.
         '''
         import platform as p
-
         _Nix, _ = _MODS.nix2
         # - mac_ver() returns ('10.12.5', ..., 'x86_64') on
         #   macOS and ('10.3.3', ..., 'iPad4,2') on iOS
@@ -217,26 +196,26 @@ class _MODS_Base(object):
             if v and n:
                 break
         else:
-            n = v = NN  # XXX AssertioError?
+            n = v = NN  # XXX AssertionError?
         return [n, v]
 
     @_Property_RO
     def _Popen_kwds2(self):
         '''(INTERNAL) Get C{subprocess.Popen} and C{-kwds}.
         '''
-        import subprocess as _sub
+        import subprocess as s
         kwds = dict(creationflags=0,  # executable=sys.executable, shell=True,
-                    stdin=_sub.PIPE, stdout=_sub.PIPE, stderr=_sub.STDOUT)
-        if _sys.version_info[:2] > (3, 6):
+                    stdin=s.PIPE, stdout=s.PIPE, stderr=s.STDOUT)
+        if _MODS.sys_version_info2 > (3, 6):
             kwds.update(text=True)
-        return _sub.Popen, kwds
+        return s.Popen, kwds
 
     @_Property_RO
     def Pythonarchine(self):
         '''Get 3- or 4-list C{[PyPy, Python, bits, machine]}, I{once}.
         '''
         v  =  _sys.version
-        l3 = [_Python_(v)] + self.bits_machine2
+        l3 = [_Python_(v)] + _MODS.bits_machine2
         pypy = _PyPy__(v)
         if pypy:  # PYCHOK no cover
             l3.insert(0, pypy)
@@ -270,23 +249,23 @@ def _caller3(up, base=True):  # in .lazily, .named
        for the caller B{C{up}} frames back in the Python call stack.
 
        @kwarg base: Use C{B{base}=False} for the fully-qualified file
-                     name, otherwise the base (module) name (C{bool}).
+                    name, otherwise the base (module) name (C{bool}).
     '''
     f  =  None
-    _f = _MODS.os.path.basename if base else _passarg
+    _b = _MODS.os.path.basename if base else _passarg
     try:
         f = _sys._getframe(up + 1)  # == inspect.stack()[up + 1][0]
         t = _MODS.inspect.getframeinfo(f)
-        t =  t.function, _f(t.filename), t.lineno
+        t =  t.function, _b(t.filename), t.lineno
 # or ...
         # f = _sys._getframe(up + 1)
         # c =  f.f_code
         # t = (c.co_name,  # caller name
-        #     _f(c.co_filename),  # file name .py
+        #     _b(c.co_filename),  # file name .py
         #      f.f_lineno)  # line number
 # or ...
         # t = _MODS.inspect.stack()[up + 1]  # (frame, filename, lineno, function, ...)
-        # t =  t[3], _f(t[1]), t[2]
+        # t =  t[3], _b(t[1]), t[2]
     except (AttributeError, IndexError, ValueError):
         # sys._getframe(1) ... 'importlib._bootstrap' line 1032,
         # may throw a ValueError('call stack not deep enough')
@@ -307,7 +286,7 @@ def _enquote(strs, quote=_QUOTE2_, white=NN):  # in .basics, .solveBase
     return strs
 
 
-def _fper(p, q, per=100.0, prec=1):
+def _fper(p, q, per=_100_0, prec=1):
     '''Format a percentage C{B{p} * B{per} / B{q}} (C{str}).
     '''
     return '%.*f%%' % (prec, (float(p) * per / float(q)))
@@ -335,7 +314,7 @@ def _headof(name):
 #     return (a == b) if _isPyPy() else (a is b)
 
 
-def _isAppleSi():
+def _isAppleSi():  # PYCHOK no cover
     '''(INTERNAL) Is this C{macOS on Apple Silicon}? (C{bool})
     '''
     return _ismacOS() and machine().startswith(_arm64_)
@@ -366,7 +345,7 @@ def _isNix():  # in test/bases
     return _MODS.nix2[0]
 
 
-def _isPyChecker():
+def _isPyChecker():  # PYCHOK no cover
     '''(INTERNAL) Is C{PyChecker} running? (C{bool}).
     '''
     # .../pychecker/checker.py --limit 0 --stdlib pygeodesy/<mod>/<name>.py
@@ -390,17 +369,19 @@ def _isWindows():  # in test/bases
 def _load_lib(name):
     '''(INTERNAL) Load a C{dylib}, B{C{name}} must startwith('lib').
     '''
-    # macOS 11+ (aka 10.16) no longer provides direct loading of
-    # system libraries.  As a result, C{ctypes.util.find_library}
-    # will not find any library, unless previously installed by a
-    # low-level dlopen(name) call (with the library base C{name}).
-    CDLL, dlopen, find_lib = _MODS.ctypes3
-
+    CDLL, find_lib, dlopen = _MODS.ctypes3
     ns = find_lib(name), name
-    if dlopen is not _passarg:  # _ismacOS()
+    if dlopen:
+        # macOS 11+ (aka 10.16) no longer provides direct loading of
+        # system libraries.  As a result, C{ctypes.util.find_library}
+        # will not find any library, unless previously installed by a
+        # low-level dlopen(name) call (with the library base C{name}).
         ns += (_DOT_(name, 'dylib'),
                _DOT_(name, 'framework'), _MODS.os.path.join(
                _DOT_(name, 'framework'),  name))
+    else:  # not macOS
+        dlopen = _passarg  # no-op
+
     for n in ns:
         try:
             if n and dlopen(n):  # pre-load handle
@@ -548,7 +529,7 @@ def _Pythonarchine(sep=NN):  # in .lazily, test/bases versions
 def _secs2str(secs):  # in .geoids, ../test/bases
     '''Convert a time in C{secs} to C{str}.
     '''
-    if secs < 100.0:  # _100_0
+    if secs < _100_0:
         unit = len(_SIsecs) - 1
         while 0 < secs < 1 and unit > 0:
             secs *= 1e3  # _1000_0
@@ -610,18 +591,18 @@ def _sizeof(obj, deep=True):
 
 
 def _sysctl_uint(name):
-    '''(INTERNAL) Get an unsigned int sysctl item by name, use on macOS ONLY!
+    '''(INTERNAL) Get an C{unsigned int sysctl} item by name, I{ONLY on macOS!}
     '''
-    libc = _MODS.libc
+    libc = _load_lib('libc') if _ismacOS() else None
     if libc:  # <https://StackOverflow.com/questions/759892/python-ctypes-and-sysctl>
-        byref, char_p, size_t, uint, sizeof = _MODS.ctypes5
-        n = name if str is bytes else bytes(name, _utf_8_)  # PYCHOK isPython2 = str is bytes
-        u = uint(0)
-        z = size_t(sizeof(u))
-        r = libc.sysctlbyname(char_p(n), byref(u), byref(z), None, size_t(0))
-    else:  # couldn't find or load 'libc'
+        import ctypes as c
+        n = c.c_char_p(_MODS.basics.str2ub(name))  # bytes(name, _utf_8_)
+        u = c.c_uint(0)
+        z = c.c_size_t(c.sizeof(u))
+        r = libc.sysctlbyname(n, c.byref(u), c.byref(z), None, c.c_size_t(0))  # PYCHOK attr
+    else:  # not macOS or couldn't find or load 'libc'=
         r = -2
-    return int(r if r else u.value)  # -1 ENOENT error, -2 no libc
+    return int(r if r else u.value)  # -1 ENOENT error, -2 no libc or not macOS
 
 
 def _tailof(name):
@@ -637,7 +618,7 @@ def _under(name):  # PYCHOK in .datums, .auxilats, .ups, .utm, .utmupsBase, ...
     return name if name.startswith(_UNDER_) else NN(_UNDER_, name)
 
 
-def _usage(file_py, *args, **opts_help):  # in .etm, .geodesici
+def _usage(file_py, *args, **opts_help):  # in .etm, .geodesici  # PYCHOK no cover
     '''(INTERNAL) Build "usage: python -m ..." cmd line for module B{C{file_py}}.
     '''
     if opts_help:
@@ -671,12 +652,12 @@ def _usage_argv(argv0, *args):
     o = _MODS.os
     m =  o.path.dirname(argv0)
     m =  m.replace(o.getcwd(), _ELLIPSIS_) \
-          .replace(o.sep, _DOT_).strip()
+          .replace(o.sep,      _DOT_).strip()
     b =  o.path.basename(argv0)
     b, x = o.path.splitext(b)
     if x == '.py' and not _is_DUNDER_main(b):
         m = _DOT_(m or _pygeodesy_, b)
-    p = NN(_python_, _sys.version_info[0])
+    p = NN(_python_, _MODS.sys_version_info2[0])
     return (p, '-m', _enquote(m)) + args
 
 
@@ -689,7 +670,7 @@ def _version2(version, n=2):
     return t[:n]
 
 
-def _version_info(package):  # in .Base.karney, .basics
+def _version_info(package):  # in .basics, .karney._kWrapped.Math
     '''(INTERNAL) Get the C{package.__version_info__} as a 2- or
        3-tuple C{(major, minor, revision)} if C{int}s.
     '''
@@ -713,14 +694,14 @@ def _version_ints(vs):
 
 
 def _versions(sep=_SPACE_):
-    '''(INTERNAL) Get pygeodesy, PyPy and Python versions, bits, machine and OS as C{7- or 8-list} or C{str}.
+    '''(INTERNAL) Get pygeodesy, PyPy and Python versions, bits, machine and OS as C{8- or 9-list} or C{str}.
     '''
     l7 = [_pygeodesy_, _MODS.version] + _Pythonarchine() + _osversion2()
     return sep.join(l7) if sep else l7  # 5- or 6-list
 
 
 __all__ = tuple(map(_DUNDER_nameof, (machine, print_, printf)))
-__version__ = '24.10.20'
+__version__ = '24.11.06'
 
 if _is_DUNDER_main(__name__):  # PYCHOK no cover
 
@@ -732,6 +713,9 @@ if _is_DUNDER_main(__name__):  # PYCHOK no cover
 
     _main()
 
+# % python3 -m pygeodesy.internals
+# pygeodesy 24.11.11 Python 3.13.0 64bit arm64 macOS 14.6.1 _isfrozen False isLazy 1
+
 # **) MIT License
 #
 # Copyright (C) 2016-2024 -- mrJean1 at Gmail -- All Rights Reserved.

pygeodesy/karney.py

@@ -64,7 +64,7 @@ Karney-based functionality
     <https://GeographicLib.SourceForge.io/C++/doc/classGeographicLib_1_1Intersect.html>} from I{GeographicLib 2.3+}
 
   - L{JacobiConformal} -- U{JacobiConformal
-    <https://geographiclib.sourceforge.io/C++/doc/classGeographicLib_1_1experimental_1_1JacobiConformal.html>}
+    <https://GeographicLib.SourceForge.io/C++/doc/classGeographicLib_1_1experimental_1_1JacobiConformal.html>}
 
   - L{KTransverseMercator} - U{TransverseMercator
     <https://GeographicLib.SourceForge.io/C++/doc/classGeographicLib_1_1TransverseMercator.html>}
@@ -165,7 +165,7 @@ from pygeodesy.utily import atan2d, sincos2d, tand, _unrollon,  fabs
 # from math import fabs  # from .utily
 
 __all__ = _ALL_LAZY.karney
-__version__ = '24.10.14'
+__version__ = '24.11.09'
 
 _2_4_       = '2.4'
 _K_2_0      = _getenv(_PYGEODESY(_xgeographiclib, 1), _2_)

pygeodesy/ktm.py

@@ -49,8 +49,7 @@ from pygeodesy.constants import INF, _K0_UTM, PI, PI_2, _0_0s, _0_0, \
 from pygeodesy.datums import Datum, _spherical_datum, _WGS84,  _EWGS84
 # from pygeodesy.ellipsoids import _EWGS84  # from .datums
 from pygeodesy.errors import _ValueError, _xkwds_pop2, _Xorder
-from pygeodesy.fmath import hypot, hypot1
-from pygeodesy.fsums import fsum1f_
+from pygeodesy.fmath import fdot_, hypot, hypot1
 from pygeodesy.interns import _COMMASPACE_, _singular_
 from pygeodesy.karney import _atan2d, _diff182, _fix90, _norm180, \
                              _polynomial, _unsigned2
@@ -67,7 +66,7 @@ from cmath import polar
 from math import atan2, asinh, cos, cosh, degrees, fabs, sin, sinh, sqrt, tanh
 
 __all__ = _ALL_LAZY.ktm
-__version__ = '24.08.31'
+__version__ = '24.11.11'
 
 
 class KTMError(_ValueError):
@@ -433,10 +432,10 @@ def _cma(a, b0, b1, Cn):
        @see: CPython function U{_Py_c_prod<https://GitHub.com/python/
              cpython/blob/main/Objects/complexobject.c>}.
 
-       @note: Python function C{cmath.fsum} is no longer available.
+       @note: Python function C{cmath.fsum} no longer exists.
     '''
-    r = fsum1f_(a.real * b0.real, -a.imag * b0.imag, -b1.real, Cn)
-    j = fsum1f_(a.real * b0.imag,  a.imag * b0.real, -b1.imag)
+    r = fdot_(a.real, b0.real, -a.imag, b0.imag, -b1.real, _1_0, start=Cn)
+    j = fdot_(a.real, b0.imag,  a.imag, b0.real, -b1.imag, _1_0)
     return complex(r, j)
 
 
@@ -461,19 +460,18 @@ def _Cyxgk4(E, xi_, eta_, C):
             y0 = complex(Cn)  # +0j
             z0 = complex(Cn * (n * 2))
             n -= 1
-        _c = _cma
         while n > 0:
             Cn =  C[n]
-            y1 = _c(a, y0, y1, Cn)
-            z1 = _c(a, z0, z1, Cn * (n * 2))
+            y1 = _cma(a, y0, y1, Cn)
+            z1 = _cma(a, z0, z1, Cn * (n * 2))
             n -=  1
             Cn =  C[n]
-            y0 = _c(a, y1, y0, Cn)
-            z0 = _c(a, z1, z0, Cn * (n * 2))
+            y0 = _cma(a, y1, y0, Cn)
+            z0 = _cma(a, z1, z0, Cn * (n * 2))
             n -=  1
         # assert n == 0
-        x = _c(s, y0, -x, _0_0)
-        c = _c(c, z0, z1, _1_0)
+        x = _cma(s, y0, -x, _0_0)
+        c = _cma(c, z0, z1, _1_0)
 
         # Gauss-Schreiber to Gauss-Krueger TM
         # C{cmath.polar} handles INF, NAN, etc.

pygeodesy/latlonBase.py

@@ -47,14 +47,14 @@ from pygeodesy.units import _isDegrees, _isRadius, Distance_, Lat, Lon, \
                              Height, Radius, Radius_, Scalar, Scalar_
 from pygeodesy.utily import _unrollon, _unrollon3, _Wrap
 # from pygeodesy.vector2d import _circin6, Circin6Tuple, _circum3, circum4_, \
-#                                 Circum3Tuple, _radii11ABC  # _MODS
+#                                 Circum3Tuple, _radii11ABC4  # _MODS
 # from pygeodesy.vector3d import nearestOn6, Vector3d  # _MODS
 
 from contextlib import contextmanager
 from math import asin, cos, degrees, fabs, radians
 
 __all__ = _ALL_LAZY.latlonBase
-__version__ = '24.10.19'
+__version__ = '24.11.10'
 
 _formy = _MODS.into(formy=__name__)
 
@@ -1142,7 +1142,7 @@ class LatLonBase(_NamedBase):
                  Circles<https://MathWorld.Wolfram.com/TangentCircles.html>}.
         '''
         with _toCartesian3(self, point2, point3, wrap) as cs:
-            return _MODS.vector2d._radii11ABC(*cs, useZ=True)[0]
+            return _MODS.vector2d._radii11ABC4(*cs, useZ=True)[0]
 
     def _rhumb3(self, exact, radius):  # != .sphericalBase._rhumbs3
         '''(INTERNAL) Get the C{rhumb} for this point's datum or for
@@ -1505,9 +1505,9 @@ class LatLonBase(_NamedBase):
            @kwarg h: Optional height, overriding this point's height (C{meter}).
            @kwarg Nvector: Optional class to return the C{n-vector} components
                            (C{Nvector}) or C{None}.
-           @kwarg name_Nvector_kwds: Optional C{B{name}=NN} (C{str}) and optional,
-                       additional B{C{Nvector}} keyword arguments, ignored if
-                       C{B{Nvector} is None}.
+           @kwarg name_Nvector_kwds: Optional C{B{name}=NN} (C{str}) and optionally,
+                       additional B{C{Nvector}} keyword arguments, ignored if C{B{Nvector}
+                       is None}.
 
            @return: An named B{C{Nvector}} or if C{B{Nvector} is None} a named
                     L{Vector4Tuple}C{(x, y, z, h)}.

pygeodesy/lazily.py

@@ -174,8 +174,8 @@ _ALL_INIT = _a(_pygeodesy_abspath_, _version_)
 # __all__ value for most modules, accessible as _ALL_LAZY.<module>
 _ALL_LAZY = _NamedEnum_RO(_name='_ALL_LAZY',
                          albers=_a('AlbersEqualArea', 'AlbersEqualArea2', 'AlbersEqualArea4',
-                                    'AlbersEqualAreaCylindrical', 'AlbersEqualAreaNorth', 'AlbersEqualAreaSouth',
-                                    'AlbersError', 'Albers7Tuple'),
+                                   'AlbersEqualAreaCylindrical', 'AlbersEqualAreaNorth', 'AlbersEqualAreaSouth',
+                                   'AlbersError', 'Albers7Tuple'),
                        auxilats=_a(),  # module only
                       azimuthal=_a('AzimuthalError', 'Azimuthal7Tuple',
                                    'Equidistant', 'EquidistantExact', 'EquidistantGeodSolve', 'EquidistantKarney',
@@ -241,8 +241,8 @@ _ALL_LAZY = _NamedEnum_RO(_name='_ALL_LAZY',
                           fmath=_a('Fdot', 'Fhorner', 'Fhypot', 'Fpolynomial', 'Fpowers', 'Fcbrt', 'Froot', 'Fsqrt',
                                    'bqrt', 'cbrt', 'cbrt2', 'euclid', 'euclid_',
                                    'facos1', 'fasin1', 'fatan', 'fatan1', 'fatan2', 'favg',
-                                   'fdot', 'fdot3', 'fma', 'fmean', 'fmean_', 'fhorner', 'fidw', 'f2mul_', 'fpolynomial',
-                                   'fpowers', 'fprod', 'frandoms', 'frange', 'freduce', 'fremainder',
+                                   'fdot', 'fdot_', 'fdot3', 'fma', 'fmean', 'fmean_', 'fhorner', 'fidw', 'f2mul_',
+                                   'fpolynomial', 'fpowers', 'fprod', 'frandoms', 'frange', 'freduce', 'fremainder',
                                    'hypot', 'hypot_', 'hypot1', 'hypot2', 'hypot2_',
                                    'norm2', 'norm_', 'sqrt0', 'sqrt3', 'sqrt_a', 'zcrt', 'zqrt'),
                           formy=_a('Radical2Tuple',
@@ -511,7 +511,7 @@ class _ALL_MODS(_internals._MODS_Base):
 _internals._MODS = _ALL_MODS = _ALL_MODS()  # PYCHOK singleton
 
 __all__ = _ALL_LAZY.lazily
-__version__ = '24.10.15'
+__version__ = '24.11.09'
 
 
 def _ALL_OTHER(*objs):

pygeodesy/lcc.py

@@ -48,7 +48,7 @@ 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.24'
+__version__ = '24.11.06'
 
 _E0_   = 'E0'
 _N0_   = 'N0'
@@ -620,9 +620,9 @@ 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}) and optional,
-                   additional B{C{Lcc}} keyword arguments, ignored if
-                   B{C{Lcc} is None}.
+       @kwarg name_Lcc_kwds: Optional C{B{name}=NN} (C{str}) and optionally,
+                   additional B{C{Lcc}} keyword arguments, ignored if B{C{Lcc}
+                   is None}.
 
        @return: The I{Lambert} location (L{Lcc}) or if C{B{Lcc} is None},
                 an L{EasNor3Tuple}C{(easting, northing, height)}.

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.08.18'
+__version__ = '24.11.06'
 
 _height0_ = _height_ + _0_
 _narrow_  = 'narrow'
@@ -150,9 +150,9 @@ class Attitude(_NamedBase):
            @kwarg z: Z component of vector (C{scalar}), same units as B{C{x}}.
            @kwarg Vector: Class to return transformed point (C{Cartesian}, L{Vector3d}
                           or C{Vector3Tuple}) or C{None}.
-           @kwarg name_Vector_kwds: Optional C{B{name}=NN} (C{str}) and optional,
-                       additional B{C{Vector}} keyword arguments, ignored if
-                       C{B{Vector} is None}.
+           @kwarg name_Vector_kwds: Optional C{B{name}=NN} (C{str}) and optionally,
+                       additional B{C{Vector}} keyword arguments, ignored if C{B{Vector}
+                       is None}.
 
            @return: A named B{C{Vector}} instance or if C{B{Vector} is None},
                     a named L{Vector3Tuple}C{(x, y, z)}.
@@ -469,9 +469,9 @@ class LocalCartesian(_NamedBase):
 
            @arg ecef: Geocentric (and geodetic) (L{Ecef9Tuple}).
            @arg Xyz: An L{XyzLocal}, L{Enu} or L{Ned} I{class} or C{None}.
-           @arg 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}.
+           @arg name_Xyz_kwds: Optional C{B{name}=NN} (C{str}) and optionally,
+                     additional B{C{Xyz}} keyword arguments, ignored if C{B{Xyz}
+                     is None}.
 
            @return: An C{B{Xyz}(x, y, z, ltp, **B{name_Xyz_kwds}} instance or
                     if C{B{Xyz} is None}, a L{Local9Tuple}C{(x, y, z, lat, lon,
@@ -1098,9 +1098,9 @@ def tyr3d(tilt=INT0, yaw=INT0, roll=INT0, Vector=Vector3d, **name_Vector_kwds):
                     (clockwise rotation along and around the y-axis).
        @kwarg Vector: Class to return the direction vector (C{Cartesian},
                       L{Vector3d} or C{Vector3Tuple}) or C{None}.
-       @kwarg name_Vector_kwds: Optional C{B{name}=NN} (C{str}) and optional,
-                   additional B{C{Vector}} keyword arguments, ignored if
-                   C{B{Vector} is None}.
+       @kwarg name_Vector_kwds: Optional C{B{name}=NN} (C{str}) and optionally,
+                   additional B{C{Vector}} keyword arguments, ignored if C{B{Vector}
+                   is None}.
 
        @return: A named B{C{Vector}} instance or if C{B{Vector} is None},
                 a named L{Vector3Tuple}C{(x, y, z)}.