pygeodesy 24.7.24__py2.py3-none-any.whl → 24.8.24__py2.py3-none-any.whl

pygeodesy/internals.py

@@ -18,6 +18,7 @@ _0_0      =  0.0  # PYCHOK in .basics, .constants
 _arm64_   = 'arm64'
 _iOS_     = 'iOS'
 _macOS_   = 'macOS'
+_SIsecs   = 'fs', 'ps', 'ns', 'us', 'ms', 'sec'  # reversed
 _Windows_ = 'Windows'
 
 
@@ -213,6 +214,13 @@ class _MODS_Base(object):
         from pygeodesy import streprs  # DON'T _lazy_import2
         return streprs
 
+    @_Property_RO
+    def version(self):
+        '''Get pygeodesy version, I{once}.
+        '''
+        from pygeodesy import version
+        return version
+
 _MODS = _MODS_Base()  # PYCHOK overwritten by .lazily
 
 
@@ -430,12 +438,31 @@ def _print7(nl=0, nt=0, prec=6, prefix=NN, sep=_SPACE_, file=_sys.stdout,
 
 
 def _Pythonarchine(sep=NN):  # in .lazily, test/bases.py versions
-    '''(INTERNAL) Get PyPy and Python versions, bit and machine as C{3- or 4-list} or C{str}.
+    '''(INTERNAL) Get PyPy and Python versions, bits and machine as C{3- or 4-list} or C{str}.
     '''
     l3 = _MODS.Pythonarchine
     return sep.join(l3) if sep else l3  # 3- or 4-list
 
 
+def _secs2str(secs):  # in .geoids, ../test/bases.py
+    '''Convert a time in C{secs} to C{str}.
+    '''
+    if secs < _MODS.constants._100_0:
+        unit = len(_SIsecs) - 1
+        while 0 < secs < 1 and unit > 0:
+            secs *= 1e3  # _1000_0
+            unit -= 1
+        t = '%.3f %s' % (secs, _SIsecs[unit])
+    else:
+        m, s = divmod(secs, 60)
+        if m < 60:
+            t = '%d:%06.3f' % (int(m), s)
+        else:
+            h, m = divmod(int(m), 60)
+            t = '%d:%02d:%06.3f' % (h, m, s)
+    return t
+
+
 def _sizeof(obj):
     '''(INTERNAL) Recursively size an C{obj}ect.
 
@@ -576,16 +603,22 @@ def _version_ints(vs):
     return tuple(_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}.
+    '''
+    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.07.04'
+__version__ = '24.08.24'
 
 if _dunder_ismain(__name__):  # PYCHOK no cover
 
-    from pygeodesy import _isfrozen, isLazy, version as vs
+    from pygeodesy import _isfrozen, isLazy
 
-    print_(_pygeodesy_, vs, *(_Pythonarchine() + _osversion2()
-                                               + ['_isfrozen', _isfrozen,
-                                                  'isLazy',     isLazy]))
+    print_(*(_versions(sep=NN) + ['_isfrozen', _isfrozen,
+                                  'isLazy',     isLazy]))
 
 # **) MIT License
 #

pygeodesy/interns.py

@@ -184,7 +184,6 @@ _concentric_          = 'concentric'         # PYCHOK OK
 _convergence_ = _Prefix('convergence')       # PYCHOK OK
 _conversion_          = 'conversion'         # PYCHOK OK
 _convex_              = 'convex'             # PYCHOK OK
-_cubic_               = 'cubic'              # PYCHOK OK
 _d_                   = 'd'                  # PYCHOK OK
 _D_                   = 'D'                  # PYCHOK OK
 _DASH_           = Str_('-')                 # PYCHOK == _MINUS_
@@ -250,6 +249,7 @@ _inside_              = 'inside'             # PYCHOK OK
 _insufficient_        = 'insufficient'       # PYCHOK OK
 _intersection_        = 'intersection'       # PYCHOK OK
 _Intl1924_            = 'Intl1924'           # PYCHOK OK
+_INV_                 = 'INV'                # PYCHOK INValid
 _invalid_             = 'invalid'            # PYCHOK OK
 _invokation_          = 'invokation'         # PYCHOK OK
 _j_                   = 'j'                  # PYCHOK OK
@@ -270,7 +270,6 @@ _LCURLY_              = '{'                  # PYCHOK LBRACE
 _len_                 = 'len'                # PYCHOK OK
 _limit_               = 'limit'              # PYCHOK OK
 _line_                = 'line'               # PYCHOK OK
-_linear_              = 'linear'             # PYCHOK OK
 _LPAREN_              = '('                  # PYCHOK OK
 _lon_                 = 'lon'                # PYCHOK OK
 _lon0_                = 'lon0'               # PYCHOK OK
@@ -441,7 +440,7 @@ _LR_PAIRS  = {_LANGLE_:  _RANGLE_,
 
 __all__ = (_NN_,  # NOT MISSING!
             Str_.__name__)  # classes
-__version__ = '24.06.14'
+__version__ = '24.08.22'
 
 if __name__ == '__main__':
 

pygeodesy/karney.py

@@ -155,14 +155,14 @@ from pygeodesy.interns import NN, _2_, _a12_, _area_, _azi1_, _azi2_, _azi12_, \
 from pygeodesy.lazily import _ALL_DOCS, _ALL_LAZY, _ALL_MODS as _MODS, _getenv
 from pygeodesy.named import ADict, _NamedBase, _NamedTuple, notImplemented, _Pass
 from pygeodesy.props import deprecated_method, Property_RO, property_ROnce
-from pygeodesy.units import Bearing as _Azi, Degrees as _Deg, Lat, Lon, \
+from pygeodesy.units import Azimuth as _Azi, Degrees as _Deg, Lat, Lon, \
                             Meter as _M, Meter2 as _M2, Number_
 from pygeodesy.utily import atan2d, sincos2d, tand, _unrollon,  fabs
 
 # from math import fabs  # from .utily
 
 __all__ = _ALL_LAZY.karney
-__version__ = '24.07.16'
+__version__ = '24.07.25'
 
 _K_2_0      = _getenv('PYGEODESY_GEOGRAPHICLIB', _2_) == _2_
 _perimeter_ = 'perimeter'

pygeodesy/latlonBase.py

@@ -54,7 +54,7 @@ from contextlib import contextmanager
 from math import asin, cos, degrees, fabs, radians
 
 __all__ = _ALL_LAZY.latlonBase
-__version__ = '24.07.12'
+__version__ = '24.08.18'
 
 _formy = _MODS.into(formy=__name__)
 
@@ -247,7 +247,7 @@ class LatLonBase(_NamedBase):
 
            @arg point2: Second point (C{LatLon}).
            @arg point3: Third point (C{LatLon}).
-           @kwarg circum: If C{True} return the C{circumradius} and C{circumcenter},
+           @kwarg circum: If C{True}, return the C{circumradius} and C{circumcenter},
                           always, ignoring the I{Meeus}' Type I case (C{bool}).
            @kwarg eps: Tolerance for function L{pygeodesy.trilaterate3d2}.
            @kwarg wrap_name: Optional C{B{name}=NN} (C{str}) and optional keyword
@@ -699,9 +699,9 @@ class LatLonBase(_NamedBase):
                          I{overriding} this datum (L{Datum}, L{Ellipsoid},
                          L{Ellipsoid2}, L{a_f2Tuple}, L{Triaxial}, L{Triaxial_},
                          L{JacobiConformal} or C{meter}, conventionally).
-           @kwarg normal: If C{True} the projection is the normal to this
-                          ellipsoid's surface, otherwise the intersection of the
-                          I{radial} line to this ellipsoid's center (C{bool}).
+           @kwarg normal: If C{True}, the projection is the normal to this ellipsoid's
+                          surface, otherwise the intersection of the I{radial} line to
+                          this ellipsoid's center (C{bool}).
            @kwarg LatLon: Optional class to return the projection, height and
                           datum (C{LatLon}) or C{None}.
            @kwarg LatLon_kwds: Optional, additional B{C{LatLon}} keyword arguments,
@@ -1483,8 +1483,8 @@ class LatLonBase(_NamedBase):
         '''Get this point I{normalized} to C{abs(lat) <= 90}
            and C{abs(lon) <= 180}.
 
-           @kwarg deep: If C{True} make a deep, otherwise a
-                        shallow copy (C{bool}).
+           @kwarg deep: If C{True}, make a deep, otherwise a shallow
+                        copy (C{bool}).
            @kwarg name: Optional C{B{name}=NN} (C{str}).
 
            @return: A copy of this point, I{normalized} (C{LatLon}),
@@ -1534,7 +1534,7 @@ class LatLonBase(_NamedBase):
 
            @kwarg form: The lat-/longitude C{B{form}at} to use (C{str}), see
                         functions L{pygeodesy.latDMS} or L{pygeodesy.lonDMS}.
-           @kwarg joined: Separator to join the lat-, longitude and heigth
+           @kwarg joined: Separator to join the lat-, longitude and height
                           strings (C{str} or C{None} or C{NN} for non-joined).
            @kwarg m: Optional unit of the height (C{str}), use C{None} to
                      exclude height from the returned string.
@@ -1650,6 +1650,12 @@ class LatLonBase(_NamedBase):
         '''
         return self._ecef9.xyz
 
+    @property_RO
+    def xyz3(self):
+        '''Get the I{geocentric} C{(x, y, z)} coordinates as C{3-tuple}.
+        '''
+        return tuple(self.xyz)
+
     @Property_RO
     def xyzh(self):
         '''Get the I{geocentric} C{(x, y, z)} coordinates and height (L{Vector4Tuple}C{(x, y, z, h)})

pygeodesy/lazily.py

@@ -31,8 +31,7 @@ from pygeodesy import internals as _internals, interns as _interns, \
                      _isfrozen  # DON'T _lazy_import2
 # from pygeodesy.errors import _error_init, _xkwds_item2  # _ALL_MODS
 from pygeodesy.internals import _caller3, _dunder_nameof, _dunder_ismain, \
-                                _headof, _osversion2, printf, _Pythonarchine, \
-                                _tailof  # _Property_RO
+                                _headof, printf, _Pythonarchine, _tailof  # _Property_RO
 from pygeodesy.interns import NN, _attribute_, _by_, _COLONSPACE_, _COMMASPACE_, \
                              _doesn_t_exist_, _DOT_, _EQUALSPACED_, _from_, \
                              _HASH_, _immutable_, _line_, _module_, _no_, _not_, \
@@ -290,7 +289,7 @@ _ALL_LAZY = _NamedEnum_RO(_name='_ALL_LAZY',
                       geodesicx=_i('gx', 'gxarea', 'gxbases', 'gxline',  # modules
                                    'GeodesicAreaExact', 'GeodesicExact', 'GeodesicLineExact', 'PolygonArea'),
                       geodsolve=_i('GeodesicSolve', 'GeodesicLineSolve', 'GeodSolve12Tuple'),
-                        geohash=_i('Geohash', 'GeohashError', 'Neighbors8Dict', 'Resolutions2Tuple'),
+                        geohash=_i('Geohash', 'Geohashed', 'GeohashError', 'Neighbors8Dict', 'Resolutions2Tuple', 'Sizes3Tuple'),
                          geoids=_i('GeoidError', 'GeoidG2012B', 'GeoidKarney', 'GeoidPGM', 'egmGeoidHeights',
                                    'PGMError', 'GeoidHeight5Tuple'),
                       hausdorff=_i('Hausdorff', 'HausdorffDegrees', 'HausdorffError', 'HausdorffRadians',
@@ -368,7 +367,7 @@ _ALL_LAZY = _NamedEnum_RO(_name='_ALL_LAZY',
                       triaxials=_i('BetaOmega2Tuple', 'BetaOmega3Tuple', 'Jacobi2Tuple',
                                    'JacobiConformal', 'JacobiConformalSpherical',
                                    'Triaxial', 'Triaxial_', 'TriaxialError', 'Triaxials', 'hartzell4'),
-                          units=_i('Band', 'Bearing', 'Bearing_', 'Bool',
+                          units=_i('Azimuth', 'Band', 'Bearing', 'Bearing_', 'Bool',
                                    'Degrees', 'Degrees_', 'Degrees2', 'Distance', 'Distance_', 'Easting', 'Epoch',
                                    'Feet', 'FIx', 'Float_', 'Height', 'Height_', 'HeightX', 'Int_',
                                    'Lam', 'Lamd', 'Lat', 'Lat_', 'Lon', 'Lon_',
@@ -396,10 +395,10 @@ _ALL_LAZY = _NamedEnum_RO(_name='_ALL_LAZY',
                          utmups=_i('UtmUps', 'UTMUPSError', 'parseUTMUPS5', 'toUtmUps8',
                                    'utmupsValidate', 'utmupsValidateOK', 'utmupsZoneBand5'),
                      utmupsBase=_i(),  # module only
-                       vector2d=_i('Circin6Tuple', 'Circum3Tuple', 'Circum4Tuple', 'Meeus2Tuple', 'Radii11Tuple', 'Soddy4Tuple',
-                                   'circin6', 'circum3', 'circum4_', 'meeus2', 'radii11', 'soddy4'),
+                       vector2d=_i('Circin6Tuple', 'Circum3Tuple', 'Circum4Tuple', 'Meeus2Tuple', 'Radii11Tuple', 'Soddy4Tuple', 'Triaxum5Tuple',
+                                   'circin6', 'circum3', 'circum4', 'circum4_', 'meeus2', 'radii11', 'soddy4', 'triaxum5', 'trilaterate2d2'),
                        vector3d=_i('Vector3d', 'intersection3d3', 'iscolinearWith', 'nearestOn', 'nearestOn6', 'parse3d',
-                                   'trilaterate2d2', 'trilaterate3d2'),
+                                   'trilaterate3d2'),
                    vector3dBase=_i(),  # module only
                     webmercator=_i('Wm', 'WebMercatorError', 'parseWM', 'toWm', 'EasNorRadius3Tuple'),
                            wgrs=_i('Georef', 'WGRSError'),)
@@ -417,8 +416,8 @@ _ALL_DEPRECATED = _NamedEnum_RO(_name='_ALL_DEPRECATED',
                      deprecated_datum=_i('Curvature2Tuple', 'Datum',  'Ellipsoid',  'Transform',  # assert
                                                             'Datums', 'Ellipsoids', 'Transforms',
                                          'R_FM', 'R_KM', 'R_M', 'R_MA', 'R_MB', 'R_NM', 'R_SM', 'R_VM'),
-                 deprecated_functions=_i('anStr', 'areaof', 'atand', 'bounds',  # most of the DEPRECATED functions, except ...
-                                         'clipCS3', 'clipDMS', 'clipStr', 'collins', 'copysign',  # ...  ellipsoidal, spherical flavors
+                 deprecated_functions=_i('anStr', 'areaof', 'atand', 'bounds',  # most of the DEPRECATED functions, except ellipsoidal ...
+                                         'clipCS3', 'clipDMS', 'clipStr', 'collins', 'copysign',  # ... and spherical flavors
                                          'decodeEPSG2', 'encodeEPSG', 'enStr2', 'equirectangular_', 'equirectangular3',
                                          'excessAbc', 'excessGirard', 'excessLHuilier',
                                          'false2f', 'falsed2f', 'float0', 'fStr', 'fStrzs', 'hypot3',
@@ -522,7 +521,7 @@ class _ALL_MODS(_internals._MODS_Base):
 _internals._MODS = _ALL_MODS = _ALL_MODS()  # PYCHOK singleton
 
 __all__ = _ALL_LAZY.lazily
-__version__ = '24.07.18'
+__version__ = '24.08.18'
 
 
 def _ALL_OTHER(*objs):
@@ -862,13 +861,13 @@ def _lazy_module(name):  # overwritten by _lazy_import2
 #
 #     return _ALL_OTHER(*sm.values())
 
-
 # del _i, _i0
 
 # _ = _ALL_MODS.errors  # force import pygeodesy.errors
 
 if _dunder_ismain(__name__):  # PYCHOK no cover
 
+    from pygeodesy.internals import _versions
     from timeit import timeit
 
     def t1():
@@ -882,22 +881,24 @@ if _dunder_ismain(__name__):  # PYCHOK no cover
 
     t1 = timeit(t1, number=1000000)
     t2 = timeit(t2, number=1000000)
-    v = _SPACE_.join(_Pythonarchine() + _osversion2())
-    printf('%.6f import vs %.6f _ALL_MODS: %.2fX, %s', t1, t2, t1 / t2, v)
+    printf('%.6f import vs %.6f _ALL_MODS: %.2fX, %s', t1, t2, t1 / t2, _versions())
 
 #   del t1, t2, timeit, v
 
-# python3.12 -W ignore -m pygeodesy.lazily
-# 0.145177 import vs 0.075402 _ALL_MODS: 1.93X, Python 3.12.3 64bit arm64 macOS 14.4.1
+# % python3.13 -W ignore -m pygeodesy.lazily
+# 0.102670 import vs 0.076113 _ALL_MODS: 1.35X, pygeodesy 24.8.4 Python 3.13.0b4 64bit arm64 macOS 14.5
+
+# % python3.12 -W ignore -m pygeodesy.lazily
+# 0.132801 import vs 0.079125 _ALL_MODS: 1.68X, pygeodesy 24.8.4 Python 3.12.4 64bit arm64 macOS 14.5
 
-# python3.11 -W ignore -m pygeodesy.lazily
-# 0.381723 import vs 0.251589 _ALL_MODS: 1.52X, Python 3.11.5 64bit arm64 macOS 14.4.1
+# % python3.11 -W ignore -m pygeodesy.lazily
+# 0.381723 import vs 0.251589 _ALL_MODS: 1.52X, pygeodesy 24.8.4 Python 3.11.5 64bit arm64 macOS 14.4.1
 
-# python3.10 -W ignore -m pygeodesy.lazily
-# 0.378293 import vs 0.266507 _ALL_MODS: 1.42X, Python 3.10.8 64bit arm64 macOS 14.4.1
+# % python3.8 -W ignore -m pygeodesy.lazily
+# 0.570353 import vs 0.382842 _ALL_MODS: 1.49X, pygeodesy 24.8.4 Python 3.8.10 64bit arm64_x86_64 macOS 10.16
 
-# python2 -m pygeodesy.lazily
-# 1.213805 import vs 0.474075 _ALL_MODS: 2.56X, Python 2.7.18 64bit arm64_x86_64 macOS 10.16
+# % python2 -m pygeodesy.lazily
+# 1.213805 import vs 0.474075 _ALL_MODS: 2.56X, pygeodesy 24.8.4 Python 2.7.18 64bit arm64_x86_64 macOS 10.16
 
 # **) MIT License
 #

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.07.12'
+__version__ = '24.08.18'
 
 _height0_ = _height_ + _0_
 _narrow_  = 'narrow'
@@ -165,7 +165,7 @@ class Attitude(_NamedBase):
         '''
         try:
             try:
-                xyz = map2(float, x_xyz.xyz)
+                xyz = map2(float, x_xyz.xyz3)
             except AttributeError:
                 xyz = map1(float, x_xyz, y, z)
         except (TypeError, ValueError) as x:
@@ -730,7 +730,7 @@ class _ChLV(object):
         # assert _args_kwds_names( ChLV.reverse)[1:4] == t
         # assert _args_kwds_names(ChLVa.reverse)[1:4] == t
         # assert _args_kwds_names(ChLVe.reverse)[1:4] == t
-        return t  # overwrite propertyROver
+        return t  # overwrite property_ROver
 
     def forward(self, latlonh, lon=None, height=0, M=None, **name):  # PYCHOK no cover
         '''Convert WGS84 geodetic to I{Swiss} projection coordinates.  I{Must be overloaded}.
@@ -876,7 +876,7 @@ class ChLV(_ChLV, Ltp):
 
            @arg Y: Unfalsed I{Swiss Y} easting (C{meter}).
            @arg X: Unfalsed I{Swiss X} northing (C{meter}).
-           @kwarg LV95: If C{True} add C{LV95} falsing, if C{False} add
+           @kwarg LV95: If C{True}, add C{LV95} falsing, if C{False} add
                         C{LV03} falsing, otherwise leave unfalsed.
            @kwarg name: Optional C{B{name}=NN} (C{str}).
 
@@ -928,9 +928,8 @@ class ChLV(_ChLV, Ltp):
 
            @arg e: Falsed I{Swiss E_LV95} or I{y_LV03} easting (C{meter}).
            @arg n: Falsed I{Swiss N_LV95} or I{x_LV03} northing (C{meter}).
-           @kwarg LV95: If C{True} remove I{LV95} falsing, if C{False} remove
-                        I{LV03} falsing, otherwise use method C{isLV95(B{e},
-                        B{n})}.
+           @kwarg LV95: If C{True}, remove I{LV95} falsing, if C{False} remove
+                        I{LV03} falsing, otherwise use method C{isLV95(B{e}, B{n})}.
            @kwarg name: Optional C{B{name}=NN} (C{str}).
 
            @return: A L{ChLVYX2Tuple}C{(Y, X)} with the unfalsed B{C{e}}

pygeodesy/ltpTuples.py

@@ -28,15 +28,15 @@ from pygeodesy.namedTuples import LatLon2Tuple, PhiLam2Tuple, Vector3Tuple
 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_
+from pygeodesy.units import Azimuth, Bearing, Degrees, Degrees_, Height, \
+                           _isDegrees, _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.28'
+__version__ = '24.08.18'
 
 _aer_        = 'aer'
 _alt_        = 'alt'
@@ -93,7 +93,7 @@ def _xyz2aer4(inst):
     '''(INTERNAL) Convert C{(x, y, z}) to C{(A, E, R)}.
     '''
     x, y, z, _ = inst.xyz4
-    A = Bearing(azimuth=atan2b(x, y))
+    A = Azimuth(atan2b(x, y))
     E = Degrees(elevation=atan2d(z, hypot(x, y)))
     R = Meter(slantrange=hypot_(x, y, z))
     return Aer4Tuple(A, E, R, inst.ltp, name=inst.name)
@@ -189,6 +189,12 @@ class _AbcBase(_NamedBase):
         '''
         return Vector3Tuple(self.x, self.y, self.z, name=self.name)  # like Ecef9Tuple.xyz, Local6tuple.xyz
 
+    @property_RO
+    def xyz3(self):
+        '''Get the I{local} C{(X, Y, Z)} coordinates as C{3-tuple}.
+        '''
+        return tuple(self.xyz)
+
     @property_RO
     def xyz4(self):  # PYCHOK no cover
         '''I{Must be overloaded}.'''
@@ -268,7 +274,7 @@ class Aer(_AbcBase):
         '''
         if _isDegrees(azimuth_aer):
             aer =  None
-            t   = (Bearing(azimuth=azimuth_aer),
+            t   = (Azimuth(azimuth_aer),
                    Degrees_(elevation=elevation, low=_N_90_0, high=_90_0),
                    Meter_(slantrange=slantrange), ltp)
         else:  # PYCHOK no cover
@@ -421,7 +427,7 @@ class Attitude4Tuple(_NamedTuple):
        the attitude of a plane or camera.
     '''
     _Names_ = (_alt_, _tilt_,  _yaw_,   _roll_)
-    _Units_ = ( Meter, Bearing, Degrees, Degrees)
+    _Units_ = ( Meter, Degrees, Bearing, Degrees)
 
     @Property_RO
     def atyr(self):

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.07.12'
+__version__ = '24.08.13'
 
 _COMMANL_           = _COMMA_ + _NL_
 _COMMASPACEDOT_     = _COMMASPACE_ + _DOT_
@@ -214,8 +214,8 @@ class _Named(object):
     def copy(self, deep=False, **name):
         '''Make a shallow or deep copy of this instance.
 
-           @kwarg deep: If C{True} make a deep, otherwise
-                        a shallow copy (C{bool}).
+           @kwarg deep: If C{True}, make a deep, otherwise a shallow
+                        copy (C{bool}).
            @kwarg name: Optional, non-empty C{B{name}=NN} (C{str}).
 
            @return: The copy (C{This class}).
@@ -233,7 +233,8 @@ class _Named(object):
     def dup(self, deep=False, **items):
         '''Duplicate this instance, replacing some attributes.
 
-           @kwarg deep: If C{True} duplicate deep, otherwise shallow.
+           @kwarg deep: If C{True}, duplicate deep, otherwise shallow
+                        (C{bool}).
            @kwarg items: Attributes to be changed (C{any}), including
                          optional C{B{name}} (C{str}).
 

pygeodesy/namedTuples.py

@@ -28,7 +28,7 @@ from pygeodesy.units import Band, Bearing, Degrees, Degrees2, Easting, FIx, \
                             Radius, Scalar, Str,  INT0
 
 __all__ = _ALL_LAZY.namedTuples
-__version__ = '24.06.08'
+__version__ = '24.08.18'
 
 # __DUNDER gets mangled in class
 _closest_     = 'closest'
@@ -676,6 +676,12 @@ class Vector3Tuple(_NamedTuple):
         '''
         return self
 
+    @property_RO
+    def xyz3(self):
+        '''Get X, Y and Z components as C{3-tuple}.
+        '''
+        return tuple(self)
+
 
 class Vector4Tuple(_NamedTuple):  # .nvector.py
     '''4-Tuple C{(x, y, z, h)} of (geocentric) components, all
@@ -697,6 +703,13 @@ class Vector4Tuple(_NamedTuple):  # .nvector.py
         '''
         return Vector3Tuple(*self[:3])
 
+    @property_RO
+    def xyz3(self):
+        '''Get X, Y and Z components as C{3-tuple}.
+        '''
+        return tuple(self[:3])
+
+
 # **) MIT License
 #
 # Copyright (C) 2016-2024 -- mrJean1 at Gmail -- All Rights Reserved.

pygeodesy/osgr.py

@@ -53,7 +53,7 @@ from pygeodesy.utily import degrees90, degrees180, sincostan3, truncate
 from math import cos, fabs, radians, sin, sqrt
 
 __all__ = _ALL_LAZY.osgr
-__version__ = '24.06.15'
+__version__ = '24.08.13'
 
 _equivalent_ = 'equivalent'
 _OSGR_       = 'OSGR'
@@ -289,9 +289,9 @@ class Osgr(_NamedBase):
            @kwarg datum: Optional datum to convert to (L{Datum},
                          L{Ellipsoid}, L{Ellipsoid2}, L{Ellipsoid2}
                          or L{a_f2Tuple}).
-           @kwarg kTM: If C{True} use I{Karney}'s Krüger method from
-                       module L{ktm}, otherwise use the Ordnance
-                       Survey formulation (C{bool}).
+           @kwarg kTM: If C{True}, use I{Karney}'s Krüger method from
+                       module L{ktm}, otherwise use the Ordnance Survey
+                       formulation (C{bool}).
            @kwarg eps: Tolerance for OS convergence (C{meter}).
            @kwarg LatLon_kwds: Optional, additional B{C{LatLon}} keyword
                                arguments, ignored if C{B{LatLon} is None}.
@@ -585,9 +585,9 @@ def toOsgr(latlon, lon=None, kTM=False, datum=_WGS84, Osgr=Osgr,  # MCCABE 14
        @arg latlon: Latitude (C{degrees}) or an (ellipsoidal) geodetic
                     C{LatLon} point.
        @kwarg lon: Optional longitude in degrees (scalar or C{None}).
-       @kwarg kTM: If C{True} use I{Karney}'s Krüger method from
-                   module L{ktm}, otherwise use the Ordnance
-                   Survey formulation (C{bool}).
+       @kwarg kTM: If C{True}, use I{Karney}'s Krüger method from
+                   module L{ktm}, otherwise use the Ordnance Survey
+                   formulation (C{bool}).
        @kwarg datum: Optional datum to convert B{C{lat, lon}} from
                      (L{Datum}, L{Ellipsoid}, L{Ellipsoid2} or
                      L{a_f2Tuple}).

pygeodesy/points.py

@@ -62,7 +62,7 @@ from pygeodesy.utily import atan2b, degrees90, degrees180, degrees2m, \
 from math import cos, fabs, fmod as _fmod, radians, sin
 
 __all__ = _ALL_LAZY.points
-__version__ = '24.06.15'
+__version__ = '24.08.13'
 
 _ilat_  = 'ilat'
 _ilon_  = 'ilon'
@@ -217,7 +217,7 @@ class _Basequence(_Sequence):  # immutable, on purpose
     def copy(self, deep=False):  # PYCHOK no cover
         '''Make a shallow or deep copy of this instance.
 
-           @kwarg deep: If C{True} make a deep, otherwise a
+           @kwarg deep: If C{True}, make a deep, otherwise a
                         shallow copy (C{bool}).
 
            @return: The copy (C{This class}).

pygeodesy/resections.py

@@ -34,7 +34,7 @@ from pygeodesy.vector3d import _otherV3d, Vector3d
 from math import cos, atan2, degrees, fabs, radians, sin, sqrt
 
 __all__ = _ALL_LAZY.resections
-__version__ = '24.04.14'
+__version__ = '24.08.18'
 
 _concyclic_ = 'concyclic'
 _PA_        = 'PA'
@@ -356,8 +356,8 @@ def pierlot(point1, point2, point3, alpha12, alpha23, useZ=False, eps=EPS,
 def _pierlot3(B1, B2, B3, a12, a23, useZ, cot):
     '''(INTERNAL) Shared L{pierlot} and L{pierlotx}.
     '''
-    x1_, y1_, _ = B1.minus(B2).xyz
-    x3_, y3_, _ = B3.minus(B2).xyz
+    x1_, y1_, _ = B1.minus(B2).xyz3
+    x3_, y3_, _ = B3.minus(B2).xyz3
 
     s12, c12, s23, c23 = sincos2d_(a12, a23)
     # cot31 = (1 - cot12 * cot23) / (cot12 + cot32)
@@ -402,7 +402,7 @@ def _pierlot3(B1, B2, B3, a12, a23, useZ, cot):
         x, y = _pierlotxy2(B2, -K, Y12_23, X12_23, (X31_23 * Y12_23 -
                                                     X12_23 * Y31_23))
     else:
-        x, y, _ = B2.xyz
+        x, y, _ = B2.xyz3
     return x, y, _zidw(x, y, useZ, B1, B2, B3)
 
 
@@ -484,8 +484,8 @@ def _pierlotx3(a_z_Bs, useZ, cot, Cs):
         Cs(4)
         return _pierlot3(B1, B2, B3, a12, a23, useZ, cot)
 
-    x1_, y1_, _ = B1.minus(B3).xyz
-    x2_, y2_, _ = B2.minus(B3).xyz
+    x1_, y1_, _ = B1.minus(B3).xyz3
+    x2_, y2_, _ = B2.minus(B3).xyz3
 
     K = _Fsumf_(y1_ * x2_, -x1_ * y2_)
     if K:
@@ -508,7 +508,7 @@ def _pierlotx3(a_z_Bs, useZ, cot, Cs):
         x, y = _pierlotxy2(B3, K, Y31_23, X31_23, (X31_23 * _Fsumf_(x2_, -x1_) +
                                                    Y31_23 * _Fsumf_(y2_, -y1_)))
     else:
-        x, y, _ = B3.xyz
+        x, y, _ = B3.xyz3
     return x, y, _zidw(x, y, useZ, B1, B2, B3)
 
 

pygeodesy/rhumb/solve.py

@@ -21,7 +21,7 @@ from pygeodesy.solveBase import _SolveGDictBase, _SolveGDictLineBase
 from pygeodesy.utily import _unrollon, _Wrap, wrap360
 
 __all__ = _ALL_LAZY.rhumb_solve
-__version__ = '24.07.11'
+__version__ = '24.08.13'
 
 
 class _RhumbSolveBase(_SolveGDictBase):
@@ -94,8 +94,8 @@ class RhumbSolve(_RhumbSolveBase):
 #       '''Set up a L{RhumbArea} to compute area and
 #          perimeter of a polygon.
 #
-#          @kwarg polyline: If C{True} perimeter only, otherwise
-#                           area and perimeter (C{bool}).
+#          @kwarg polyline: If C{True}, compute the perimeter only,
+#                           otherwise perimeter and area (C{bool}).
 #          @kwarg name: Optional C{B{name}=NN} (C{str}).
 #
 #          @return: A L{RhumbArea} instance.