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

pygeodesy/geohash.py

@@ -20,7 +20,7 @@ from pygeodesy.basics import isodd, isstr, map2
 from pygeodesy.constants import EPS, R_M, _floatuple, _0_0, _0_5, _180_0, \
                                _360_0,  _90_0, _N_90_0, _N_180_0  # PYCHOK used!
 from pygeodesy.dms import parse3llh  # parseDMS2
-from pygeodesy.errors import _ValueError, _xkwds
+from pygeodesy.errors import _ValueError, _xkwds, _xStrError
 from pygeodesy.fmath import favg
 # from pygeodesy import formy as _formy  # _MODS
 from pygeodesy.interns import NN, _COMMA_, _DOT_, _E_, _N_, _NE_, _NW_, \
@@ -32,13 +32,12 @@ from pygeodesy.namedTuples import Bounds2Tuple, Bounds4Tuple, LatLon2Tuple, \
 from pygeodesy.props import deprecated_function, deprecated_method, \
                             deprecated_property_RO, Property_RO
 from pygeodesy.streprs import fstr
-from pygeodesy.units import Degrees_, Int, Lat, Lon, Precision_, Str, \
-                           _xStrError
+from pygeodesy.units import Degrees_, Int, Lat, Lon, Precision_, Str
 
 from math import fabs, ldexp, log10, radians
 
 __all__ = _ALL_LAZY.geohash
-__version__ = '24.06.10'
+__version__ = '24.06.15'
 
 _formy = _MODS.into(formy=__name__)
 
@@ -237,7 +236,7 @@ class Geohash(Str):
            @kwarg LatLon: Optional class to return I{bounds} (C{LatLon})
                           or C{None}.
            @kwarg LatLon_kwds: Optional, additional B{C{LatLon}} keyword
-                               arguments, ignored if B{C{LatLon}} is C{None}.
+                               arguments, ignored if C{B{LatLon} is None}.
 
            @return: A L{Bounds2Tuple}C{(latlonSW, latlonNE)} of B{C{LatLon}}s
                     or a L{Bounds4Tuple}C{(latS, lonW, latN, lonE)} if
@@ -300,16 +299,15 @@ class Geohash(Str):
 
            @arg other: The other geohash (L{Geohash}, C{LatLon} or C{str}).
            @kwarg radius: Mean earth radius, ellipsoid or datum (C{meter},
-                          L{Ellipsoid}, L{Ellipsoid2}, L{Datum} or
-                          L{a_f2Tuple}) or C{None}, see function
-                          L{pygeodesy.equirectangular}.
+                          L{Ellipsoid}, L{Ellipsoid2}, L{Datum} or L{a_f2Tuple})
+                          or C{None}, see function L{pygeodesy.equirectangular}.
            @kwarg adjust_limit_wrap: Optional keyword arguments for function
                          L{pygeodesy.equirectangular4}, overriding defaults
                          C{B{adjust}=False, B{limit}=None} and C{B{wrap}=False}.
 
-           @return: Distance (C{meter}, same units as B{C{radius}} or the
-                    ellipsoid or datum axes or C{radians I{squared}} if
-                    B{C{radius}} is C{None} or C{0}).
+           @return: Distance (C{meter}, same units as B{C{radius}} or the ellipsoid
+                    or datum axes or C{radians I{squared}} if B{C{radius} is None}
+                    or C{0}).
 
            @raise TypeError: The B{C{other}} is not a L{Geohash}, C{LatLon} or
                              C{str} or invalid B{C{radius}}.
@@ -398,13 +396,11 @@ class Geohash(Str):
            as an instance of the supplied C{LatLon} class.
 
            @arg LatLon: Class to use (C{LatLon}) or C{None}.
-           @kwarg LatLon_kwds: Optional, additional B{C{LatLon}}
-                               keyword arguments, ignored if
-                               C{B{LatLon} is None}.
+           @kwarg LatLon_kwds: Optional, additional B{C{LatLon}} keyword
+                               arguments, ignored if C{B{LatLon} is None}.
 
-           @return: This geohash location (B{C{LatLon}}) or a
-                    L{LatLon2Tuple}C{(lat, lon)} if B{C{LatLon}}
-                    is C{None}.
+           @return: This geohash location (B{C{LatLon}}) or if C{B{LatLon}
+                    is None}, a L{LatLon2Tuple}C{(lat, lon)}.
 
            @raise TypeError: Invalid B{C{LatLon}} or B{C{LatLon_kwds}}.
         '''
@@ -500,19 +496,17 @@ _Neighbors8Defaults = dict(zip(Neighbors8Dict._Keys_, (None,) *
 def bounds(geohash, LatLon=None, **LatLon_kwds):
     '''Returns the lower-left SW and upper-right NE corners of a geohash.
 
-       @arg geohash: To be bound (L{Geohash}).
-       @kwarg LatLon: Optional class to return the bounds (C{LatLon})
-                      or C{None}.
-       @kwarg LatLon_kwds: Optional, additional B{C{LatLon}} keyword
-                           arguments, ignored if C{B{LatLon} is None}.
+       @arg geohash: To be "bound" (L{Geohash}).
+       @kwarg LatLon: Optional class to return the bounds (C{LatLon}) or C{None}.
+       @kwarg LatLon_kwds: Optional, additional B{C{LatLon}} keyword arguments,
+                           ignored if C{B{LatLon} is None}.
 
-       @return: A L{Bounds2Tuple}C{(latlonSW, latlonNE)} of B{C{LatLon}}s
-                or if B{C{LatLon}} is C{None}, a L{Bounds4Tuple}C{(latS,
-                lonW, latN, lonE)}.
+       @return: A L{Bounds2Tuple}C{(latlonSW, latlonNE)}, each a B{C{LatLon}}
+                or if C{B{LatLon} is None}, a L{Bounds4Tuple}C{(latS, lonW,
+                latN, lonE)}.
 
-       @raise TypeError: The B{C{geohash}} is not a L{Geohash}, C{LatLon}
-                         or C{str} or invalid B{C{LatLon}} or invalid
-                         B{C{LatLon_kwds}}.
+       @raise TypeError: The B{C{geohash}} is not a L{Geohash}, C{LatLon} or
+                         C{str} or invalid B{C{LatLon}} or invalid B{C{LatLon_kwds}}.
 
        @raise GeohashError: Invalid or C{null} B{C{geohash}}.
     '''
@@ -847,14 +841,12 @@ def resolution2(prec1, prec2=None):
 def sizes(geohash):
     '''Return the lat- and longitudinal size of this L{Geohash} cell.
 
-       @arg geohash: Cell for which size are required (L{Geohash} or
-                     C{str}).
+       @arg geohash: Cell for which size are required (L{Geohash} or C{str}).
 
-       @return: A L{LatLon2Tuple}C{(lat, lon)} with the latitudinal
-                height and longitudinal width in (C{meter}).
+       @return: A L{LatLon2Tuple}C{(lat, lon)} with the latitudinal height and
+                longitudinal width in (C{meter}).
 
-       @raise TypeError: The B{C{geohash}} is not a L{Geohash},
-                         C{LatLon} or C{str}.
+       @raise TypeError: The B{C{geohash}} is not a L{Geohash}, C{LatLon} or C{str}.
     '''
     return _2Geohash(geohash).sizes
 

pygeodesy/geoids.py

@@ -118,7 +118,7 @@ except ImportError:  # Python 3+
     from io import BytesIO as _BytesIO  # PYCHOK expected
 
 __all__ = _ALL_LAZY.geoids
-__version__ = '24.06.03'
+__version__ = '24.06.11'
 
 _assert_ = 'assert'
 _bHASH_  =  b'#'
@@ -323,10 +323,9 @@ class _GeoidBase(_HeightsBase):
            @kwarg LatLon: Optional class to return the location and height
                           (C{LatLon}) or C{None}.
 
-           @return: If B{C{LatLon}} is C{None}, a L{LatLon3Tuple}C{(lat,
-                    lon, height)} otherwise a B{C{LatLon}} instance
-                    with the lat-, longitude and geoid height of the
-                    center grid location.
+           @return: If C{B{LatLon} is None}, a L{LatLon3Tuple}C{(lat, lon,
+                    height)} otherwise a B{C{LatLon}} instance with the lat-,
+                    longitude and geoid height of the center grid location.
         '''
         return self._llh3LL(self._center, LatLon)
 
@@ -437,10 +436,9 @@ class _GeoidBase(_HeightsBase):
            @kwarg LatLon: Optional class to return the location and height
                           (C{LatLon}) or C{None}.
 
-           @return: If B{C{LatLon}} is C{None}, a L{LatLon3Tuple}C{(lat,
-                    lon, height)} otherwise a B{C{LatLon}} instance
-                    with the lat-, longitude and geoid height of the
-                    highest grid location.
+           @return: If C{B{LatLon} is None}, a L{LatLon3Tuple}C{(lat, lon,
+                    height)} otherwise a B{C{LatLon}} instance with the lat-,
+                    longitude and geoid height of the highest grid location.
         '''
         return self._llh3LL(self._highest, LatLon)
 
@@ -513,10 +511,9 @@ class _GeoidBase(_HeightsBase):
            @kwarg LatLon: Optional class to return the location
                           (C{LatLon}) and height or C{None}.
 
-           @return: If B{C{LatLon}} is C{None}, a L{LatLon3Tuple}C{(lat,
-                    lon, height)} otherwise a B{C{LatLon}} instance
-                    with the lat-, longitude and geoid height of the
-                    lower-left, SW grid corner.
+           @return: If C{B{LatLon} is None}, a L{LatLon3Tuple}C{(lat, lon, height)}
+                    otherwise a B{C{LatLon}} instance with the lat-, longitude and
+                    geoid height of the lower-left, SW grid corner.
         '''
         return self._llh3LL(self._lowerleft, LatLon)
 
@@ -532,10 +529,9 @@ class _GeoidBase(_HeightsBase):
            @kwarg LatLon: Optional class to return the location and height
                           (C{LatLon}) or C{None}.
 
-           @return: If B{C{LatLon}} is C{None}, a L{LatLon3Tuple}C{(lat,
-                    lon, height)} otherwise a B{C{LatLon}} instance
-                    with the lat-, longitude and geoid height of the
-                    lower-right, SE grid corner.
+           @return: If C{B{LatLon} is None}, a L{LatLon3Tuple}C{(lat, lon, height)}
+                    otherwise a B{C{LatLon}} instance with the lat-, longitude and
+                    geoid height of the lower-right, SE grid corner.
         '''
 
         return self._llh3LL(self._loweright, LatLon)
@@ -554,10 +550,9 @@ class _GeoidBase(_HeightsBase):
            @kwarg LatLon: Optional class to return the location and height
                           (C{LatLon}) or C{None}.
 
-           @return: If B{C{LatLon}} is C{None}, a L{LatLon3Tuple}C{(lat,
-                    lon, height)} otherwise a B{C{LatLon}} instance
-                    with the lat-, longitude and geoid height of the
-                    lowest grid location.
+           @return: If C{B{LatLon} is None}, a L{LatLon3Tuple}C{(lat, lon,
+                    height)} otherwise a B{C{LatLon}} instance with the lat-,
+                    longitude and geoid height of the lowest grid location.
         '''
         return self._llh3LL(self._lowest, LatLon)
 
@@ -701,10 +696,9 @@ class _GeoidBase(_HeightsBase):
            @kwarg LatLon: Optional class to return the location and height
                           (C{LatLon}) or C{None}.
 
-           @return: If B{C{LatLon}} is C{None}, a L{LatLon3Tuple}C{(lat,
-                    lon, height)} otherwise a B{C{LatLon}} instance
-                    with the lat-, longitude and geoid height of the
-                    upper-left, NW grid corner.
+           @return: If C{B{LatLon} is None}, a L{LatLon3Tuple}C{(lat, lon, height)}
+                    otherwise a B{C{LatLon}} instance with the lat-, longitude and
+                    geoid height of the upper-left, NW grid corner.
         '''
         return self._llh3LL(self._upperleft, LatLon)
 
@@ -720,10 +714,9 @@ class _GeoidBase(_HeightsBase):
            @kwarg LatLon: Optional class to return the location and height
                           (C{LatLon}) or C{None}.
 
-           @return: If B{C{LatLon}} is C{None}, a L{LatLon3Tuple}C{(lat,
-                    lon, height)} otherwise a B{C{LatLon}} instance
-                    with the lat-, longitude and geoid height of the
-                    upper-right, NE grid corner.
+           @return: If C{B{LatLon} is None}, a L{LatLon3Tuple}C{(lat, lon, height)}
+                    otherwise a B{C{LatLon}} instance with the lat-, longitude and
+                    geoid height of the upper-right, NE grid corner.
         '''
         return self._llh3LL(self._upperright, LatLon)
 
@@ -1169,10 +1162,9 @@ class GeoidKarney(_GeoidBase):
                           (C{LatLon}) or C{None}.
            @kwarg full: Search the full or limited latitude range (C{bool}).
 
-           @return: If B{C{LatLon}} is C{None}, a L{LatLon3Tuple}C{(lat,
-                    lon, height)} otherwise a B{C{LatLon}} instance
-                    with the lat-, longitude and geoid height at the
-                    highest grid location.
+           @return: If C{B{LatLon} is None}, a L{LatLon3Tuple}C{(lat, lon,
+                    height)} otherwise a B{C{LatLon}} instance with the lat-,
+                    longitude and geoid height of the highest grid location.
         '''
         llh = self._highest if full or self.cropped else self._highest_ltd
         return self._llh3LL(llh, LatLon)
@@ -1223,10 +1215,9 @@ class GeoidKarney(_GeoidBase):
                           (C{LatLon}) or C{None}.
            @kwarg full: Search the full or limited latitude range (C{bool}).
 
-           @return: If B{C{LatLon}} is C{None}, a L{LatLon3Tuple}C{(lat,
-                    lon, height)} otherwise a B{C{LatLon}} instance
-                    with the lat-, longitude and geoid height of the
-                    lowest grid location.
+           @return: If C{B{LatLon} is None}, a L{LatLon3Tuple}C{(lat, lon,
+                    height)} otherwise a B{C{LatLon}} instance with the lat-,
+                    longitude and geoid height of the lowest grid location.
         '''
         llh = self._lowest if full or self.cropped else self._lowest_ltd
         return self._llh3LL(llh, LatLon)

pygeodesy/hausdorff.py

@@ -72,21 +72,20 @@ from pygeodesy.datums import _ellipsoidal_datum, _WGS84
 from pygeodesy.errors import PointsError, _xattr, _xcallable, _xkwds, _xkwds_get
 import pygeodesy.formy as _formy
 from pygeodesy.interns import NN, _i_, _j_, _units_
-# from pygeodesy.iters import points2  # from .points
+# from pygeodesy.iters import points2 as _points  # from .points
 from pygeodesy.lazily import _ALL_LAZY, _FOR_DOCS
 from pygeodesy.named import _name2__, _Named, _NamedTuple, _Pass
 # from pygeodesy.namedTuples import PhiLam2Tuple  # from .points
-from pygeodesy.points import _distanceTo, points2 as _points2,  PhiLam2Tuple, radians
+from pygeodesy.points import _distanceTo,  PhiLam2Tuple, points2 as _points2, radians
 from pygeodesy.props import Property, Property_RO, property_doc_, property_RO
-from pygeodesy.units import Float, Number_, _xUnit, _xUnits
-from pygeodesy.unitsBase import _Str_degrees, _Str_degrees2, _Str_meter, _Str_NN, \
-                                _Str_radians, _Str_radians2
+from pygeodesy.units import Float, Number_
+from pygeodesy import unitsBase as _unitsBase  # _Str_..., _xUnit, _xUnits
 
 # from math import radians  # from .points
 from random import Random
 
 __all__ = _ALL_LAZY.hausdorff
-__version__ = '24.06.08'
+__version__ = '24.06.15'
 
 
 class HausdorffError(PointsError):
@@ -104,7 +103,7 @@ class Hausdorff(_Named):
     _kwds  = {}     # func_ options
     _model = ()
     _seed  =  None
-    _units = _Str_NN  # XXX Str to _Pass and for backward compatibility
+    _units = _unitsBase._Str_NN  # XXX Str to _Pass and for backward compatibility
 
     def __init__(self, point1s, seed=None, units=NN, **name__kwds):
         '''New C{Hausdorff...} calculator.
@@ -261,7 +260,7 @@ class Hausdorff(_Named):
 
            @raise TypeError: Invalid B{C{units}}.
         '''
-        self._units = _xUnits(units, Base=Float)
+        self._units = _unitsBase._xUnits(units, Base=Float)
 
     @Property_RO
     def wrap(self):
@@ -274,7 +273,7 @@ class HausdorffDegrees(Hausdorff):
     '''L{Hausdorff} base class for distances from C{LatLon}
        points in C{degrees}.
     '''
-    _units = _Str_degrees
+    _units = _unitsBase._Str_degrees
 
     if _FOR_DOCS:
         __init__  = Hausdorff.__init__
@@ -290,7 +289,7 @@ class HausdorffRadians(Hausdorff):
     '''L{Hausdorff} base class for distances from C{LatLon}
        points converted from C{degrees} to C{radians}.
     '''
-    _units = _Str_radians
+    _units = _unitsBase._Str_radians
 
     if _FOR_DOCS:
         __init__  = Hausdorff.__init__
@@ -318,8 +317,8 @@ class _HausdorffMeterRadians(Hausdorff):
        the optional keyword arguments supplied at instantiation
        of the C{Hausdorff*} sub-class.
     '''
-    _units  = _Str_meter
-    _units_ = _Str_radians
+    _units  = _unitsBase._Str_meter
+    _units_ = _unitsBase._Str_radians
 
     def directed(self, point2s, early=True):
         '''Overloaded method L{Hausdorff.directed} to determine
@@ -426,7 +425,7 @@ class HausdorffDistanceTo(Hausdorff):
     '''Compute the C{Hausdorff} distance based on the distance from the
        points' C{LatLon.distanceTo} method, conventionally in C{meter}.
     '''
-    _units = _Str_meter
+    _units = _unitsBase._Str_meter
 
     def __init__(self, point1s, **seed_name__distanceTo_kwds):
         '''New L{HausdorffDistanceTo} calculator.
@@ -464,7 +463,7 @@ class HausdorffEquirectangular(Hausdorff):
     '''Compute the C{Hausdorff} distance based on the C{equirectangular} distance
        in C{radians squared} like function L{pygeodesy.equirectangular}.
     '''
-    _units = _Str_degrees2
+    _units = _unitsBase._Str_degrees2
 
     def __init__(self, point1s, **seed_name__adjust_limit_wrap):
         '''New L{HausdorffEquirectangular} calculator.
@@ -513,7 +512,7 @@ class HausdorffExact(Hausdorff):
     '''Compute the C{Hausdorff} distance based on the I{angular}
        distance in C{degrees} from method L{GeodesicExact}C{.Inverse}.
     '''
-    _units = _Str_degrees
+    _units = _unitsBase._Str_degrees
 
     def __init__(self, point1s, datum=None, **seed_name__wrap):
         '''New L{HausdorffKarney} calculator.
@@ -543,7 +542,7 @@ class HausdorffFlatLocal(_HausdorffMeterRadians):
     '''Compute the C{Hausdorff} distance based on the I{angular} distance in
        C{radians squared} like function L{pygeodesy.flatLocal_}/L{pygeodesy.hubeny_}.
     '''
-    _units = _Str_radians2
+    _units = _unitsBase._Str_radians2
 
     def __init__(self, point1s, **seed_name__datum_scaled_wrap):
         '''New L{HausdorffFlatLocal}/L{HausdorffHubeny} calculator.
@@ -634,7 +633,7 @@ class HausdorffKarney(Hausdorff):
        <https://GeographicLib.SourceForge.io/Python/doc/code.html>}
        Inverse method.
     '''
-    _units = _Str_degrees
+    _units = _unitsBase._Str_degrees
 
     def __init__(self, point1s, datum=None, **seed_name__wrap):
         '''New L{HausdorffKarney} calculator.
@@ -823,7 +822,7 @@ class Hausdorff6Tuple(_NamedTuple):
         '''Overloaded C{_NamedTuple.toUnits} for C{hd} and C{md} units.
         '''
         u    = list(Hausdorff6Tuple._Units_)
-        u[0] = U = _xUnit(self.units, Float)  # PYCHOK expected
+        u[0] = U = _unitsBase._xUnit(self.units, Float)  # PYCHOK expected
         u[4] =     _Pass if self.md is None else U  # PYCHOK expected
         return _NamedTuple.toUnits(self.reUnit(*u), **Error_name)  # PYCHOK self
 

pygeodesy/heights.py

@@ -1,7 +1,7 @@
 
 # -*- coding: utf-8 -*-
 
-u'''Height interpolations at C{LatLon} points from C{knots}.
+u'''Height interpolations at C{LatLon} points from known C{knots}.
 
 Classes L{HeightCubic}, L{HeightIDWcosineAndoyerLambert},
 L{HeightIDWcosineForsytheAndoyerLambert}, L{HeightIDWcosineLaw},
@@ -91,7 +91,7 @@ from pygeodesy.units import _isDegrees, Float_, Int_
 # from math import radians  # from .points
 
 __all__ = _ALL_LAZY.heights
-__version__ = '24.06.03'
+__version__ = '24.06.22'
 
 _error_     = 'error'
 _formy      = _MODS.into(formy=__name__)

pygeodesy/internals.py

@@ -4,9 +4,9 @@ u'''Mostly INTERNAL functions, except L{machine}, L{print_} and L{printf}.
 '''
 # from pygeodesy.basics import isiterablen  # _MODS
 # from pygeodesy.errors import _AttributeError, _error_init, _UnexpectedError, _xError2  # _MODS
-from pygeodesy.interns import NN, _COLON_, _DOT_, _ELLIPSIS_, _EQUALSPACED_, \
-                             _immutable_, _NL_, _pygeodesy_, _PyPy__, _python_, \
-                             _QUOTE1_, _QUOTE2_, _s_, _SPACE_, _sys, _UNDER_, _utf_8_
+from pygeodesy.interns import NN, _BAR_, _COLON_, _DASH_, _DOT_, _ELLIPSIS_, _EQUALSPACED_, \
+                             _immutable_, _NL_, _pygeodesy_, _PyPy__, _python_, _QUOTE1_, \
+                             _QUOTE2_, _s_, _SPACE_, _sys, _UNDER_, _utf_8_
 from pygeodesy.interns import _COMMA_, _Python_  # PYCHOK used!
 # from pygeodesy.streprs import anstr, pairs, unstr  # _MODS
 
@@ -31,6 +31,12 @@ def _dunder_nameof(inst, *dflt):
     return dflt[0] if dflt else inst.__class__.__name__
 
 
+def _dunder_nameof_(*names__):  # in .errors._IsnotError
+    '''(INTERNAL) Yield the _dunder_nameof or name.
+    '''
+    return map(_dunder_nameof, names__, names__)
+
+
 def _Property_RO(method):
     '''(INTERNAL) Can't I{recursively} import L{props.property_RO}.
     '''
@@ -354,10 +360,10 @@ def _passargs(*args):
     return args
 
 
-def _plural(noun, n):
+def _plural(noun, n, nn=NN):
     '''(INTERNAL) Return C{noun}['s'] or C{NN}.
     '''
-    return NN(noun, _s_) if n > 1 else (noun if n else NN)
+    return NN(noun, _s_) if n > 1 else (noun if n else nn)
 
 
 def print_(*args, **nl_nt_prec_prefix__end_file_flush_sep__kwds):  # PYCHOK no cover
@@ -498,17 +504,44 @@ 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):  # in .etm
+def _usage(file_py, *args, **opts_help):  # in .etm, .geodesici
     '''(INTERNAL) Build "usage: python -m ..." cmd line for module B{C{file_py}}.
     '''
-    m = _os_path.dirname(file_py).replace(_os.getcwd(), _ELLIPSIS_) \
-                                 .replace(_os.sep, _DOT_).strip()
-    b, x = _os_path.splitext(_os_path.basename(file_py))
+    if opts_help:
+
+        def _help(alts=(), help=NN, **unused):
+            if alts and help:
+                h = NN(help, _SPACE_).lstrip(_DASH_)
+                for a in alts:
+                    if a.startswith(h):
+                        return NN(_DASH_, a),
+
+        def _opts(opts=NN, alts=(), **unused):
+            # opts='T--v-C-R meter-c|i|n|o'
+            d, fmt = NN, _MODS.streprs.Fmt.SQUARE
+            for o in (opts + _BAR_(*alts)).split(_DASH_):
+                if o:
+                    yield fmt(NN(d, _DASH_, o.replace(_BAR_, ' | -')))
+                    d =  NN
+                else:
+                    d = _DASH_
+
+        args = _help(**opts_help) or (tuple(_opts(**opts_help)) + args)
+
+    u = _COLON_(_dunder_nameof(_usage)[1:], NN)
+    return _SPACE_(u, *_usage_argv(file_py, *args))
+
+
+def _usage_argv(argv0, *args):
+    '''(INTERNAL) Return 3-tuple C{(python, '-m', module, *args)}.
+    '''
+    m = _os_path.dirname(argv0).replace(_os.getcwd(), _ELLIPSIS_) \
+                               .replace(_os.sep, _DOT_).strip()
+    b, x = _os_path.splitext(_os_path.basename(argv0))
     if x == '.py' and not _dunder_ismain(b):
         m = _DOT_(m or _pygeodesy_, b)
-    p =  NN(_python_, _sys.version_info[0])
-    u = _COLON_(_dunder_nameof(_usage)[1:], NN)
-    return _SPACE_(u, p, '-m', _enquote(m), *args)
+    p = NN(_python_, _sys.version_info[0])
+    return (p, '-m', _enquote(m)) + args
 
 
 def _version2(version, n=2):
@@ -544,7 +577,7 @@ def _version_ints(vs):
 
 
 __all__ = tuple(map(_dunder_nameof, (machine, print_, printf)))
-__version__ = '24.06.05'
+__version__ = '24.07.04'
 
 if _dunder_ismain(__name__):  # PYCHOK no cover
 

pygeodesy/interns.py

@@ -32,7 +32,7 @@ class _Int(int):
 class Str_(str):
     '''Extended, I{callable} C{str} class, not nameable.
 
-       @see: Nameable and callable class L{pygeodesy.Str}.
+       @see: Nameable and callable class L{Str<pygeodesy.unitsBase.Str>}.
     '''
     def join_(self, *args):
         '''Join all positional B{C{args}} like C{self.join(B{args})}.
@@ -441,7 +441,7 @@ _LR_PAIRS  = {_LANGLE_:  _RANGLE_,
 
 __all__ = (_NN_,  # NOT MISSING!
             Str_.__name__)  # classes
-__version__ = '24.06.05'
+__version__ = '24.06.14'
 
 if __name__ == '__main__':