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

pygeodesy/lazily.py

@@ -29,39 +29,33 @@ and line number.
 
 from pygeodesy import internals as _internals, interns as _interns, \
                      _isfrozen  # DON'T _lazy_import2
-# from pygeodesy.errors import _error_init  # _ALL_MODS
+# from pygeodesy.errors import _error_init, _xkwds_item2  # _ALL_MODS
 from pygeodesy.internals import _caller3, _dunder_nameof, _dunder_ismain, \
                                 _headof, _osversion2, printf, _Pythonarchine, \
-                                _tailof
-from pygeodesy.interns import NN, _areaOf_, _attribute_, _by_, _COLONSPACE_, \
-                             _COMMASPACE_, _doesn_t_exist_, _DOT_, _enabled_, \
-                             _EQUALSPACED_, _from_, _HASH_, _immutable_, \
-                             _isclockwise_, _ispolar_, _line_, _module_, \
-                             _no_, _NorthPole_, _not_, _or_, _pygeodesy_, \
-                             _pygeodesy_abspath_, _SouthPole_, \
-                             _SPACE_, _sub_packages, _sys, _UNDER_, _version_, \
+                                _tailof  # _Property_RO
+from pygeodesy.interns import NN, _attribute_, _by_, _COLONSPACE_, _COMMASPACE_, \
+                             _doesn_t_exist_, _DOT_, _EQUALSPACED_, _from_, \
+                             _HASH_, _immutable_, _line_, _module_, _no_, _not_, \
+                             _or_, _pygeodesy_abspath_, _pygeodesy_, _SPACE_, \
+                             _SUB_PACKAGES, _UNDER_, _version_,  _sys, \
                              _intern  # function
 # from pygeodesy.streprs import unstr  # _ALL_MODS
 
-from os import getenv as _getenv
 try:
     from importlib import import_module
 except ImportError as x:  # Python 2.6-
-    _str_x = str(x)
-
-    def import_module(name, *package):
-        t = _ALL_MODS.streprs.unstr(import_module, name, *package)
-        raise LazyImportError(t, txt=_str_x)
+    raise ImportError(_COLONSPACE_(_Pythonarchine(sep=_SPACE_), x))
+from os import getenv as _getenv
+# import sys as _sys  # from .interns
 
 __as__                  = ' as '
 _dunder_all_            = '__all__'  # in .__main__
-_dunder_package_        = '__package__'
+_enabled_               = 'enabled'
 _FOR_DOCS               = _getenv('PYGEODESY_FOR_DOCS', NN)  # for epydoc ...
-_from_DOT__             = _SPACE_(NN, _from_, _DOT_)
 _i0                     = ()  # PYCHOK empty tuple
 _init__all__            = _FOR_DOCS or _getenv('PYGEODESY_INIT__ALL__', _dunder_all_) == _dunder_all_  # PYCHOK exported
 _lazily_                = 'lazily'
-_lazily_imported__      = _SPACE_(_HASH_, _lazily_, 'imported', NN)
+_lazily_imported_       = _SPACE_(_HASH_, _lazily_, 'imported')
 _PYGEODESY_GEOCONVERT_  = 'PYGEODESY_GEOCONVERT'  # PYCHOK .mgrs, test.bases
 _PYGEODESY_GEODSOLVE_   = 'PYGEODESY_GEODSOLVE'   # PYCHOK .geodsolve, test.bases
 _PYGEODESY_LAZY_IMPORT_ = 'PYGEODESY_LAZY_IMPORT'
@@ -73,7 +67,7 @@ _unlazy = _unLazy0      = _isfrozen or _sys_version_info2 < (3, 7)  # PYCHOK mod
 _WARNINGS_X_DEV         = _getenv('PYGEODESY_WARNINGS', NN) and (
                           _PYTHON_X_DEV or bool(_sys.warnoptions))  # PYCHOK .props
 # @module_property[_RO?] <https://GitHub.com/jtushman/proxy_tools/>
-isLazy                  = None  # see @var isLazy in .__init__
+isLazy                  =  None  # see @var isLazy in .__init__
 
 
 class LazyAttributeError(AttributeError):
@@ -168,7 +162,7 @@ class _NamedEnum_RO(dict):
             for a in t:
                 a, _, as_ = a.partition(__as__)
                 if as_:  # import attr as attr_
-                    _a(as_, _DOT_(m, a, NN), *_sub_packages)
+                    _a(as_, _DOT_(m, a, NN), *_SUB_PACKAGES)
                 else:
                     _a(a, m)
         return _D
@@ -185,7 +179,7 @@ def _ALL_ATTRS(*attrs):
     '''
     t = ()
     for attr in attrs:
-        t += tuple(map(_attrof, attr))
+        t += tuple(map(_getattrof, attr))
     return t
 
 
@@ -289,8 +283,9 @@ _ALL_LAZY = _NamedEnum_RO(_name='_ALL_LAZY',
                           fsums=_i('Fsum', 'DivMod2Tuple', 'Fsum2Tuple', 'ResidualError',
                                    'fsum', 'fsum_', 'fsumf_', 'fsum1', 'fsum1_', 'fsum1f_'),
                            gars=_i('Garef', 'GARSError'),
+                      geodesici=_i('Intersector', 'Intersector5Tuple', 'XDist'),
                       geodesicw=_i('Geodesic', 'GeodesicLine', 'Geodesic_WGS84'),
-                      geodesicx=_i('gx', 'gxarea', 'gxbases', 'gxline',  # modules, see _sub_packages
+                      geodesicx=_i('gx', 'gxarea', 'gxbases', 'gxline',  # modules
                                    'GeodesicAreaExact', 'GeodesicExact', 'GeodesicLineExact', 'PolygonArea'),
                       geodsolve=_i('GeodesicSolve', 'GeodesicLineSolve', 'GeodSolve12Tuple'),
                         geohash=_i('Geohash', 'GeohashError', 'Neighbors8Dict', 'Resolutions2Tuple'),
@@ -340,11 +335,11 @@ _ALL_LAZY = _NamedEnum_RO(_name='_ALL_LAZY',
                                    'Reverse4Tuple', 'Triangle7Tuple', 'Triangle8Tuple', 'Trilaterate5Tuple',
                                    'UtmUps2Tuple', 'UtmUps5Tuple', 'UtmUps8Tuple', 'UtmUpsLatLon5Tuple',
                                    'Vector2Tuple', 'Vector3Tuple', 'Vector4Tuple'),
-                    nvectorBase=_i(_NorthPole_, _SouthPole_),
+                    nvectorBase=_i('NorthPole', 'SouthPole'),
                            osgr=_i('Osgr', 'OSGRError', 'parseOSGR', 'toOsgr'),
                          points=_i('LatLon_', 'LatLon2psxy', 'Numpy2LatLon', 'Shape2Tuple', 'Tuple2LatLon',
-                                   _areaOf_, 'boundsOf', 'centroidOf', 'fractional',
-                                   _isclockwise_, 'isconvex', 'isconvex_', 'isenclosedBy', _ispolar_,
+                                   'areaOf', 'boundsOf', 'centroidOf', 'fractional',
+                                   'isclockwise', 'isconvex', 'isconvex_', 'isenclosedBy', 'ispolar',
                                    'luneOf', 'nearestOn5', 'perimeterOf', 'quadOf'),
                           props=_i('Property', 'Property_RO', 'property_RO', 'property_doc_',
                                    'deprecated_class', 'deprecated_function', 'deprecated_method',
@@ -373,9 +368,9 @@ _ALL_LAZY = _NamedEnum_RO(_name='_ALL_LAZY',
                           units=_i('Band', 'Bearing', 'Bearing_', 'Bool',
                                    'Degrees', 'Degrees_', 'Degrees2', 'Distance', 'Distance_', 'Easting', 'Epoch',
                                    'Feet', 'FIx', 'Float_', 'Height', 'Height_', 'HeightX', 'Int_',
-                                   'Lam', 'Lam_', 'Lat', 'Lat_', 'Lon', 'Lon_',
+                                   'Lam', 'Lamd', 'Lat', 'Lat_', 'Lon', 'Lon_',
                                    'Meter', 'Meter_', 'Meter2', 'Meter3', 'Northing', 'Number_',
-                                   'Phi', 'Phi_', 'Precision_', 'Radians', 'Radians_', 'Radians2',
+                                   'Phi', 'Phid', 'Precision_', 'Radians', 'Radians_', 'Radians2',
                                    'Radius_', 'Scalar', 'Scalar_', 'Zone'),
                       unitsBase=_i('Float', 'Int', 'Radius', 'Str'),
                             ups=_i('Ups', 'UPSError', 'parseUPS5', 'toUps8', 'upsZoneBand5'),
@@ -412,13 +407,13 @@ _ALL_DEPRECATED = _NamedEnum_RO(_name='_ALL_DEPRECATED',
                      deprecated_bases=_i('LatLonHeightBase', 'points2'),
                    deprecated_classes=_i('ClipCS3Tuple', 'EasNorExact4Tuple', 'EcefCartesian', 'Fn_rt',
                                          'HeightIDW', 'HeightIDW2', 'HeightIDW3', 'Helmert7Tuple',
-                                         'LatLonExact4Tuple', 'NearestOn4Tuple', 'Ned3Tuple',
-                                         'RefFrameError', 'Rhumb7Tuple', 'RhumbOrder2Tuple',
+                                         'Lam_', 'LatLonExact4Tuple', 'NearestOn4Tuple', 'Ned3Tuple',
+                                         'Phi_', 'RefFrameError', 'Rhumb7Tuple', 'RhumbOrder2Tuple',
                                          'Transform7Tuple', 'TriAngle4Tuple', 'UtmUps4Tuple'),
                  deprecated_consterns=_i('EPS1_2', 'MANTIS', 'OK'),
                      deprecated_datum=_i('Curvature2Tuple', 'Datum',  'Ellipsoid',  'Transform',  # assert
                                                             'Datums', 'Ellipsoids', 'Transforms',
-                                         'R_M', 'R_MA', 'R_MB', 'R_KM', 'R_NM', 'R_SM', 'R_FM', 'R_VM'),
+                                         '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
                                          'decodeEPSG2', 'encodeEPSG', 'enStr2', 'equirectangular_', 'equirectangular3',
@@ -432,7 +427,7 @@ _ALL_DEPRECATED = _NamedEnum_RO(_name='_ALL_DEPRECATED',
                    deprecated_nvector=_i('LatLonNvectorBase', 'Nvector', 'sumOf', 'NorthPole', 'SouthPole'),)
 
 
-class _ALL_MODS(_internals._ALL_MODS_Base):
+class _ALL_MODS(_internals._MODS_Base):
     '''(INTERNAL) Memoized import of any L{pygeodesy} module.
     '''
     def __getattr__(self, name):
@@ -474,7 +469,7 @@ class _ALL_MODS(_internals._ALL_MODS_Base):
         return v
 
     def getmodule(self, name, parent=_pygeodesy_):
-        '''Get a C{pygeodesy} module.
+        '''Get a C{pygeodesy} module or the C{__main__}.
 
            @arg name: Un/qualified module name (C{str}).
 
@@ -482,12 +477,36 @@ class _ALL_MODS(_internals._ALL_MODS_Base):
 
            @raise ImportError: Importing module B{C{name}} failed.
         '''
-        if _headof(name) != parent:
+        if _headof(name) != parent and not _dunder_ismain(name):
             name = _DOT_(parent, name)
         try:
             return _sys.modules[name]
         except KeyError:
-            return import_module(name, parent)
+            return _getmodule(name, parent)
+
+    def into(self, **mod_dunder_name_):
+        '''Lazily import module C{mod} into module C{_dunder_name_}
+           and set C{_dunder_name_._mod} to module C{mod}, I{once}.
+        '''
+        class _Into(object):
+
+            def __getattr__(unused, name):
+                mod, dun = self.errors._xkwds_item2(mod_dunder_name_)
+                _mod = _UNDER_(NN, mod)
+                d =  self.getmodule(dun)  # '__main__' OK
+                i = _getattribute(d, _mod, dun)
+                assert isinstance(i, _Into)
+                m =  self.getmodule(mod)
+                setattr(d, _mod, m)  # overwrite C{d._mod}
+                return getattr(m, name)
+
+        return _Into()
+
+#   @_Property_RO
+#   def _isBoolean(self):
+#       '''(INTERNAL) Get function C(.booleans.isBoolean}, I{once}.
+#       '''
+#       return self.booleans.isBoolean
 
     def items(self):  # no module named 'items'
         '''Yield the modules imported so far.
@@ -500,7 +519,7 @@ class _ALL_MODS(_internals._ALL_MODS_Base):
 _internals._MODS = _ALL_MODS = _ALL_MODS()  # PYCHOK singleton
 
 __all__ = _ALL_LAZY.lazily
-__version__ = '24.05.15'
+__version__ = '24.06.19'
 
 
 def _ALL_OTHER(*objs):
@@ -565,11 +584,34 @@ def _all_missing2(_all_):
             (_DOT_(_pygeodesy_, _dunder_all_), _diff(_alzy.keys(), _all_)))
 
 
-def _attrof(attr_as):  # .testDeprecated
+def _getattribute(m, name, mod=_pygeodesy_):
+    '''(INTERNAL) Get attr C{m.name}.
+    '''
+    try:
+        return getattr(m, name)
+    except AttributeError:
+        name = _DOT_(mod, name)
+        # <https://GitHub.com/mrJean1/PyGeodesy/issues/76>
+        raise LazyAttributeError(_no_(_attribute_), txt=name)
+
+
+def _getattrof(attr_as):  # .testDeprecated
+    '''(INTERNAL) Get the C{"as name"} or C{"name"} of a lazy entry.
+    '''
     a_, _, as_ = attr_as.partition(__as__)
     return as_ or a_.rstrip(_DOT_)
 
 
+def _getmodule(name, *parent):
+    '''(INTERNAL) Wrapper for C{import_module}.
+    '''
+    try:
+        return import_module(name, parent)
+    except ImportError:
+        # <https://GitHub.com/mrJean1/PyGeodesy/issues/76>
+        raise LazyImportError(_no_(_module_), txt=name)
+
+
 # def _lazy_attributes(_dunder_name_):
 #     '''(INTERNAL) Return a function to C{B{__name__}.__getattr__(attr)}
 #        on lazily imported modules and sub-modules.
@@ -615,17 +657,19 @@ def _lazy_import2(pack):  # MCCABE 14
              U{PEP 562<https://www.Python.org/dev/peps/pep-0562>} and the
              U{new way<https://Snarky.Ca/lazy-importing-in-python-3-7/>}.
     '''
+    _DOT_    = _interns._DOT_
+    _SPACE_  = _interns._SPACE_
+
     if pack != _pygeodesy_ or _unlazy:  # Python 3.7+
         t = _no_(_DOT_(pack, _dunder_nameof(_lazy_import2)))  # PYCHOK no cover
         raise LazyImportError(t, txt=_Pythonarchine(sep=_SPACE_))
 
-    package, parent = _lazy_init2(pack)  # _pygeodesy_
-
-    subpacks   =  set((parent, NN) + tuple(
-                      _DOT_(parent, s) for s in _sub_packages))
-    MISSING    =  object()  # DON'T interns.MISSING!
-    imports    = _all_imports()
-    deprecates = _all_deprecates()
+    package, parent  = _lazy_init2(pack)  # _pygeodesy_
+    sub_packages     =  set((parent, NN) + tuple(
+                           _DOT_(parent, s) for s in _SUB_PACKAGES))
+    imports          = _all_imports()
+    deprecates       = _all_deprecates()
+    _dunder_package_ = '__package__'
 
     def __getattr__(name):  # __getattr__ only for Python 3.7+
         # only called once for each undefined pygeodesy attribute
@@ -638,21 +682,12 @@ def _lazy_import2(pack):  # MCCABE 14
                 mod, _, attr = mod[:-1].rpartition(_DOT_)
             else:  # from mod import name
                 attr = name
-            try:
-                t = _DOT_(pack, mod)
-                v =  import_module(t, parent)
-            except ImportError:
-                # <https://GitHub.com/mrJean1/PyGeodesy/issues/76>
-                raise LazyImportError(_no_(_module_), txt=t)
-            t = getattr(v, _dunder_package_, None)
-            if t not in subpacks:  # invalid module package
+            v = _getmodule(_DOT_(pack, mod), parent)
+            t =  getattr(v, _dunder_package_, None)
+            if t not in sub_packages:  # invalid module package
                 raise LazyImportError(_DOT_(mod, _dunder_package_), t)
-            if attr:  # get the attribute
-                v = getattr(v, attr, MISSING)
-                if v is MISSING:  # PYCHOK no cover
-                    t = _DOT_(mod, attr)
-                    # <https://GitHub.com/mrJean1/PyGeodesy/issues/76>
-                    raise LazyAttributeError(_no_(_attribute_), txt=t)
+            if attr:  # get mod.attr
+                v = _getattribute(v, attr, mod)
 
         elif name in (_dunder_all_,):  # XXX _dunder_dir_, _dunder_members_?
             v = _ALL_INIT + tuple(imports.keys())
@@ -663,9 +698,9 @@ def _lazy_import2(pack):  # MCCABE 14
 
         setattr(package, name, v)  # package.__dict__[name] = val
         if isLazy > 1:
-            t = NN(_lazily_imported__, _DOT_(parent, name))
+            t = _SPACE_(_lazily_imported_, _DOT_(parent, name))
             if mod and _tailof(mod) != name:
-                t = NN(t, _from_DOT__, mod)
+                t = _SPACE_(t, _from_, _DOT_(NN, mod))
             if isLazy > 2:
                 try:  # see C{_caller3}
                     _, f, s = _caller3(2)
@@ -827,6 +862,8 @@ def _lazy_module(name):  # overwritten by _lazy_import2
 
 # del _i, _i0
 
+# _ = _ALL_MODS.errors  # force import pygeodesy.errors
+
 if _dunder_ismain(__name__):  # PYCHOK no cover
 
     from timeit import timeit

pygeodesy/lcc.py

@@ -41,14 +41,14 @@ from pygeodesy.namedTuples import EasNor3Tuple, LatLonDatum3Tuple, \
                                   LatLon2Tuple, _LL4Tuple, PhiLam2Tuple
 from pygeodesy.props import deprecated_method, Property, Property_RO, _update_all
 from pygeodesy.streprs import Fmt, _fstrENH2, _xzipairs
-from pygeodesy.units import Easting, Height, _heigHt,  Lam_, Northing, Phi_, \
+from pygeodesy.units import Easting, Height, _heigHt,  Lamd, Northing, Phid, \
                             Scalar_
 from pygeodesy.utily import atan1, degrees90, degrees180, sincos2, tanPI_2_2
 
 from math import atan, fabs, log, radians, sin, sqrt
 
 __all__ = _ALL_LAZY.lcc
-__version__ = '24.05.24'
+__version__ = '24.06.24'
 
 _E0_   = 'E0'
 _N0_   = 'N0'
@@ -107,8 +107,8 @@ class Conic(_NamedEnumItem):
             _xinstanceof(_LLEB, latlon0=latlon0)
             self._phi0, self._lam0 = latlon0.philam
 
-            self._par1 = Phi_(par1=par1)
-            self._par2 = self._par1 if par2 is None else Phi_(par2=par2)
+            self._par1 = Phid(par1=par1)
+            self._par2 = self._par1 if par2 is None else Phid(par2=par2)
 
             if k0 != 1:
                 self._k0 = Scalar_(k0=k0)
@@ -117,7 +117,7 @@ class Conic(_NamedEnumItem):
             if N0:
                 self._N0 = Easting(N0=N0, falsed=True)
             if opt3:
-                self._opt3 = Lam_(opt3=opt3)
+                self._opt3 = Lamd(opt3=opt3)
 
             self.toDatum(latlon0.datum)._dup2(self)
             self._register(Conics, name)
@@ -278,20 +278,19 @@ class Conic(_NamedEnumItem):
 
         return c
 
-    def toStr(self, prec=8, name=NN, **unused):  # PYCHOK expected
+    def toStr(self, prec=8, **name):  # PYCHOK expected
         '''Return this conic as a string.
 
            @kwarg prec: Number of (decimal) digits, unstripped (C{int}).
-           @kwarg name: Overriding name (C{str}) or C{None} to exclude
-                        this conic's name.
+           @kwarg name: Overriding C{B{name}=NN} (C{str}) or C{None} to
+                        exclude this conic's name.
 
            @return: Conic attributes (C{str}).
         '''
-        a = [name, prec, _lat0_, _lon0_, _par1_, _par2_,
-                         _E0_, _N0_, _k0_, _SP_]
+        a = [_lat0_, _lon0_, _par1_, _par2_, _E0_, _N0_, _k0_, _SP_]
         if self._SP == 1:
             _ = a.pop(a.index(_par2_))
-        return self._instr(datum=self.datum, *a)
+        return self._instr(datum=self.datum, prec=prec, *a, **name)
 
     def _dup2(self, c):
         '''(INTERNAL) Copy this conic to C{c}.
@@ -454,7 +453,7 @@ class Lcc(_NamedBase):
 #
 #       kwds = _xkwds(e_n_h_conic, e=self.easting, n=self.northing,
 #                                  h=self.height, conic=self.conic,
-#                                  name=name or self.name)
+#                                  name=self._name__(name))
 #       args, kwds = _args_kwds(**kwds)
 #       return self.__class__(*args, **kwds)  # .classof
 
@@ -537,22 +536,21 @@ class Lcc(_NamedBase):
     def toLatLon(self, LatLon=None, datum=None, height=None, **LatLon_kwds):
         '''Convert this L{Lcc} to an (ellipsoidal) geodetic point.
 
-           @kwarg LatLon: Optional, ellipsoidal class to return the
-                          geodetic point (C{LatLon}) or C{None}.
-           @kwarg datum: Optional datum to use, otherwise use this
-                         B{C{Lcc}}'s conic.datum (L{Datum}, L{Ellipsoid},
-                         L{Ellipsoid2} or L{a_f2Tuple}).
-           @kwarg height: Optional height for the point, overriding
-                          the default height (C{meter}).
-           @kwarg LatLon_kwds: Optional, additional B{C{LatLon}} keyword
-                               arguments, ignored if C{B{LatLon} is None}.
+           @kwarg LatLon: Optional, ellipsoidal class to return the geodetic
+                          point (C{LatLon}) or C{None}.
+           @kwarg datum: Optional datum to use, otherwise use this B{C{Lcc}}'s
+                         conic.datum (L{Datum}, L{Ellipsoid}, L{Ellipsoid2} or
+                         L{a_f2Tuple}).
+           @kwarg height: Optional height for the point, overriding the default height
+                          (C{meter}).
+           @kwarg LatLon_kwds: Optional, additional B{C{LatLon}} keyword arguments,
+                               ignored if C{B{LatLon} is None}.
 
-           @return: The point (B{C{LatLon}}) or a
-                    L{LatLon4Tuple}C{(lat, lon, height, datum)}
-                    if B{C{LatLon}} is C{None}.
+           @return: The point (B{C{LatLon}}) or if C{B{LatLon} is None}, a
+                    L{LatLon4Tuple}C{(lat, lon, height, datum)}.
 
-           @raise TypeError: If B{C{LatLon}} or B{C{datum}} is
-                             not ellipsoidal or not valid.
+           @raise TypeError: If B{C{LatLon}} or B{C{datum}} is not ellipsoidal or
+                             not valid.
         '''
         if LatLon:
             _xsubclassof(_LLEB, LatLon=LatLon)
@@ -622,13 +620,12 @@ def toLcc(latlon, conic=Conics.WRF_Lb, height=None, Lcc=Lcc,
        @kwarg height: Optional height for the point, overriding the
                       default height (C{meter}).
        @kwarg Lcc: Class to return the I{Lambert} location (L{Lcc}).
-       @kwarg name_Lcc_kwds: Optional C{B{name}=NN} (C{str}) for the
-                   location and optional, additional B{C{Lcc}} keyword
-                   arguments, ignored if B{C{Lcc}} is C{None}.
+       @kwarg name_Lcc_kwds: Optional C{B{name}=NN} (C{str}) and optional,
+                   additional B{C{Lcc}} keyword arguments, ignored if
+                   B{C{Lcc} is None}.
 
-       @return: The I{Lambert} location (L{Lcc}) or an
-                L{EasNor3Tuple}C{(easting, northing, height)} if
-                C{B{Lcc} is None}.
+       @return: The I{Lambert} location (L{Lcc}) or if C{B{Lcc} is None},
+                an L{EasNor3Tuple}C{(easting, northing, height)}.
 
        @raise TypeError: If B{C{latlon}} is not ellipsoidal.
     '''

pygeodesy/ltp.py

@@ -13,18 +13,20 @@ and L{ChLVe} and L{Ltp}, L{ChLV}, L{LocalError}, L{Attitude} and L{Frustum}.
 # make sure int/int division yields float quotient, see .basics
 from __future__ import division as _; del _  # PYCHOK semicolon
 
-from pygeodesy.basics import _args_kwds_names, map1, map2, _xsubclassof   # .datums
+from pygeodesy.basics import _args_kwds_names, map1, map2, _xinstanceof, \
+                             _xsubclassof   # .datums
 from pygeodesy.constants import EPS, INT0, _umod_360, _0_0, _0_01, _0_5, _1_0, \
                                _2_0, _60_0, _90_0, _100_0, _180_0, _3600_0, \
                                _N_1_0  # PYCHOK used!
-from pygeodesy.datums import _WGS84,  _xinstanceof
-from pygeodesy.ecef import _EcefBase, EcefKarney, _llhn4, _xyzn4
-from pygeodesy.errors import _NotImplementedError, _TypesError, _ValueError, \
-                             _xattr, _xkwds, _xkwds_get, _xkwds_pop2
+# from pygeodesy.datums import _WGS84  # from .ecef
+from pygeodesy.ecef import _EcefBase, EcefKarney, Ecef9Tuple, _llhn4, \
+                           _xyzn4,  _WGS84
+from pygeodesy.errors import _NotImplementedError, _ValueError, _xattr, \
+                             _xkwds, _xkwds_get, _xkwds_pop2
 from pygeodesy.fmath import fabs, fdot, Fhorner
 from pygeodesy.fsums import _floor, _Fsumf_, fsumf_, fsum1f_
 from pygeodesy.interns import _0_, _COMMASPACE_, _DOT_, _ecef_, _height_, _M_, \
-                              _invalid_, _lat0_, _lon0_, _ltp_, _name_, _too_
+                              _invalid_, _lat0_, _lon0_, _name_, _too_
 # from pygeodesy.lazily import _ALL_LAZY  # from vector3d
 from pygeodesy.ltpTuples import Attitude4Tuple, ChLVEN2Tuple, ChLV9Tuple, \
                                 ChLVYX2Tuple, Footprint5Tuple, Local9Tuple, \
@@ -42,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.05.31'
+__version__ = '24.06.11'
 
 _height0_ = _height_ + _0_
 _narrow_  = 'narrow'
@@ -152,7 +154,7 @@ class Attitude(_NamedBase):
                        additional B{C{Vector}} keyword arguments, ignored if
                        C{B{Vector} is None}.
 
-           @return: A named B{C{Vector}} instance or if B{C{Vector}} is C{None},
+           @return: A named B{C{Vector}} instance or if C{B{Vector} is None},
                     a named L{Vector3Tuple}C{(x, y, z)}.
 
            @raise AttitudeError: Invalid B{C{x_xyz}}, B{C{y}} or B{C{z}}.
@@ -417,13 +419,12 @@ class LocalCartesian(_NamedBase):
            @kwarg latlonh0: The (geodetic) origin (C{LatLon}, L{LatLon4Tuple}, L{Ltp}
                             L{LocalCartesian} or L{Ecef9Tuple}) or the C{scalar}
                             latitude of the (goedetic) origin (C{degrees}).
-           @kwarg lon0: Longitude of the (goedetic) origin (C{degrees}) for C{scalar}
-                        B{C{latlonh0}}, ignored otherwise.
+           @kwarg lon0: Longitude of the (goedetic) origin (C{degrees}), required if
+                        B{C{latlonh0}} is C{scalar}, ignored otherwise.
            @kwarg height0: Optional height (C{meter}, conventionally) at the (goedetic)
                            origin perpendicular to and above (or below) the ellipsoid's
-                           surface and for C{scalar} B{C{latlonh0}}, ignored otherwise.
-           @kwarg ecef: An ECEF converter (L{EcefKarney} I{only}) for C{scalar}
-                        B{C{latlonh0}}, ignored otherwise.
+                           surface, like B{C{lon0}}.
+           @kwarg ecef: An ECEF converter (L{EcefKarney} I{only}), like B{C{lon0}}.
            @kwarg lon00_name: Optional C{B{name}=NN} (C{str}) and keyword argument
                         C{B{lon00}=B{lon0}} for the arbitrary I{polar} longitude
                         (C{degrees}), see method C{reverse} and property C{lon00}
@@ -480,6 +481,7 @@ class LocalCartesian(_NamedBase):
 
            @raise TypeError: Invalid B{C{Xyz}} or B{C{name_Xyz_kwds}}.
         '''
+        _xinstanceof(Ecef9Tuple, ecef=ecef)
         ltp = self
         if ecef.datum != ltp.datum:
             ecef = ecef.toDatum(ltp.datum)
@@ -557,8 +559,9 @@ class LocalCartesian(_NamedBase):
 
            @return: A I{geocentric} 3-tuple C{(x, y, z)} or if C{B{nine}=True},
                     an L{Ecef9Tuple}C{(x, y, z, lat, lon, height, C, M, datum)},
-                    optionally including rotation matrix C{M} or C{None}.
+                    optionally including rotation matrix C{M} otherwise C{None}.
         '''
+        _xinstanceof(*_XyzLocals5, local=local)
         t = self.M.unrotate(local.xyz, *self._t0_xyz)
         if nine:
             t = self.ecef.reverse(*t, M=M)
@@ -1072,6 +1075,19 @@ def _fov_2(**fov):
     raise LocalError(txt=t, **fov)
 
 
+def _toLocal(inst, ltp, Xyz, Xyz_kwds):
+    '''(INTENRAL) Helper for C{CartesianBase.toLocal} and C{latLonBase.toLocal}.
+    '''
+    return _xLtp(ltp, inst._Ltp)._ecef2local(inst._ecef9, Xyz, Xyz_kwds)
+
+
+def _toLtp(inst, Ecef, ecef9, name):
+    '''(INTENRAL) Helper for C{CartesianBase.toLtp} and C{latLonBase.toLtp}.
+    '''
+    return inst._Ltp if Ecef in (None, inst.Ecef) and not name else \
+                 Ltp(ecef9, ecef=Ecef(inst.datum), name=inst._name__(name))
+
+
 def tyr3d(tilt=INT0, yaw=INT0, roll=INT0, Vector=Vector3d, **name_Vector_kwds):
     '''Convert an attitude pose into a (3-D) direction vector.
 
@@ -1087,7 +1103,7 @@ def tyr3d(tilt=INT0, yaw=INT0, roll=INT0, Vector=Vector3d, **name_Vector_kwds):
                    additional B{C{Vector}} keyword arguments, ignored if
                    C{B{Vector} is None}.
 
-       @return: A named B{C{Vector}} instance or if B{C{Vector}} is C{None},
+       @return: A named B{C{Vector}} instance or if C{B{Vector} is None},
                 a named L{Vector3Tuple}C{(x, y, z)}.
 
        @raise AttitudeError: Invalid B{C{tilt}}, B{C{yaw}} or B{C{roll}}.
@@ -1097,22 +1113,25 @@ def tyr3d(tilt=INT0, yaw=INT0, roll=INT0, Vector=Vector3d, **name_Vector_kwds):
        @see: U{Yaw, pitch, and roll rotations<http://MSL.CS.UIUC.edu/planning/node102.html>}
              and function L{pygeodesy.hartzell} argument C{los}, Line-Of-Sight.
     '''
-    d = Attitude4Tuple(_0_0, tilt, yaw, roll).tyr3d
-    if Vector is not type(d):
+    v = Attitude4Tuple(_0_0, tilt, yaw, roll).tyr3d
+    if Vector is not type(v):
         n, kwds = _name2__(name_Vector_kwds, name__=tyr3d)
-        d = Vector3Tuple(d.x, d.y, d.z, name=n) if Vector is None else \
-                  Vector(d.x, d.y, d.z, name=n, **kwds)
-    return d
+        v = Vector3Tuple(v.x, v.y, v.z, name=n) if Vector is None else \
+                  Vector(v.x, v.y, v.z, name=n, **kwds)
+    elif name_Vector_kwds:
+        n, _ = _name2__(name_Vector_kwds)
+        if n:
+            v = v.copy(name=n)
+    return v
 
 
 def _xLtp(ltp, *dflt):
-    '''(INTERNAL) Validate B{C{ltp}}.
+    '''(INTERNAL) Validate B{C{ltp}} or ist B{C{dflt}}.
     '''
     if dflt and ltp is None:
         ltp = dflt[0]
-    if isinstance(ltp, (LocalCartesian, Ltp)):
-        return ltp
-    raise _TypesError(_ltp_, ltp, Ltp, LocalCartesian)
+    _xinstanceof(Ltp, LocalCartesian, ltp=ltp)
+    return ltp
 
 # **) MIT License
 #