Coverage for pygeodesy/lazily.py: 97%

210 statements  

« prev     ^ index     » next       coverage.py v7.6.1, created at 2024-10-09 12:50 -0400

1 

2# -*- coding: utf-8 -*- 

3 

4u'''Lazily import C{pygeodesy} modules and attributes, based on 

5U{lazy_import<https://modutil.ReadTheDocs.io/en/latest/#lazy_import>} 

6from I{Brett Cannon}'s U{modutil<https://PyPI.org/project/modutil>}. 

7 

8C{Lazy import} is I{supported only for }U{Python 3.7+ 

9<https://Snarky.Ca/lazy-importing-in-python-3-7>} and is I{enabled by 

10default} in U{PyGeodesy 18.11.10<https://PyPI.org/project/PyGeodesy>} 

11I{and newer}. 

12 

13To I{enable} C{lazy import}, set C{env} variable C{PYGEODESY_LAZY_IMPORT} 

14to C{1}, C{2}, C{3} or higher prior to C{import pygeodesy}. To I{disable} 

15C{lazy import}, set C{env} variable C{PYGEODESY_LAZY_IMPORT} to C{0} or 

16an empty string. Use C{2} or higher to print a message for each lazily 

17imported module and attribute, similar to C{env} variable C{PYTHONVERBOSE} 

18showing imports. Using C{3} or higher also shows the importing file name 

19and line number. 

20 

21@note: C{Lazy import} applies only to top-level modules of C{pygeodesy}. 

22 The C{lazy import} of a top-level module invariably loads all 

23 sub-modules imported by that top-level module. 

24 

25@note: C{Lazy import} raises a L{LazyAttributeError} or L{LazyImportError} 

26 depending on the cause of the error and such errors can occur late, 

27 after all initial imports. 

28''' 

29 

30from pygeodesy import internals as _internals, interns as _interns, \ 

31 _isfrozen # DON'T _lazy_import2 

32# from pygeodesy.errors import _error_init, _xkwds_item2 # _ALL_MODS 

33from pygeodesy.internals import _caller3, _dunder_nameof, _dunder_ismain, \ 

34 _headof, printf, _Pythonarchine, _tailof # _Property_RO 

35from pygeodesy.interns import NN, _attribute_, _by_, _COLONSPACE_, _COMMASPACE_, \ 

36 _doesn_t_exist_, _DOT_, _EQUALSPACED_, _from_, \ 

37 _HASH_, _immutable_, _line_, _module_, _no_, _not_, \ 

38 _or_, _pygeodesy_abspath_, _pygeodesy_, _SPACE_, \ 

39 _SUB_PACKAGES, _UNDER_, _version_, _sys, \ 

40 _intern # function 

41# from pygeodesy.streprs import unstr # _ALL_MODS 

42 

43try: 

44 from importlib import import_module 

45except ImportError as x: # Python 2.6- 

46 raise ImportError(_COLONSPACE_(_Pythonarchine(sep=_SPACE_), x)) 

47from os import getenv as _getenv 

48# import sys as _sys # from .interns 

49 

50__as__ = ' as ' 

51_dunder_all_ = '__all__' # in .__main__ 

52_enabled_ = 'enabled' 

53_FOR_DOCS = _getenv('PYGEODESY_FOR_DOCS', NN) # for epydoc ... 

54_i0 = () # PYCHOK empty tuple 

55_init__all__ = _FOR_DOCS or _getenv('PYGEODESY_INIT__ALL__', _dunder_all_) == _dunder_all_ # PYCHOK exported 

56_lazily_ = 'lazily' 

57_lazily_imported_ = _SPACE_(_HASH_, _lazily_, 'imported') 

58_PYGEODESY_GEOCONVERT_ = 'PYGEODESY_GEOCONVERT' # PYCHOK .mgrs, test.bases 

59_PYGEODESY_GEODSOLVE_ = 'PYGEODESY_GEODSOLVE' # PYCHOK .geodsolve, test.bases 

60_PYGEODESY_INTERSECTTOOL_ = 'PYGEODESY_INTERSECTTOOL' # PYCHOK .intersectool, test.bases 

61_PYGEODESY_LAZY_IMPORT_ = 'PYGEODESY_LAZY_IMPORT' 

62_PYGEODESY_RHUMBSOLVE_ = 'PYGEODESY_RHUMBSOLVE' # PYCHOK .rhumb.solve, test.bases 

63_PYTHON_X_DEV = getattr(_sys, '_xoptions', {}).get('dev', # Python 3.2+ 

64 _getenv('PYTHONDEVMODE', NN)) # PYCHOK exported 

65_sys_version_info2 = _sys.version_info[:2] # in .basics, .fmath, ... 

66_unlazy = _unLazy0 = _isfrozen or _sys_version_info2 < (3, 7) # PYCHOK mod.__getattr__ 3.7+ 

67_WARNINGS_X_DEV = _getenv('PYGEODESY_WARNINGS', NN) and ( 

68 _PYTHON_X_DEV or bool(_sys.warnoptions)) # PYCHOK .props 

69# @module_property[_RO?] <https://GitHub.com/jtushman/proxy_tools/> 

70isLazy = None # see @var isLazy in .__init__ 

71 

72 

73class LazyAttributeError(AttributeError): 

74 '''Raised if a C{lazily imported} attribute is missing or invalid. 

75 ''' 

76 def __init__(self, *name_value, **txt): 

77 _ALL_MODS.errors._error_init(AttributeError, self, name_value, **txt) 

78 

79 

80class LazyImportError(ImportError): 

81 '''Raised if C{lazy import} is not supported, disabled or failed some other way. 

82 ''' 

83 def __init__(self, *name_value, **txt): 

84 _ALL_MODS.errors._error_init(ImportError, self, name_value, **txt) 

85 

86 

87class _Dict(dict): 

88 '''(INTERNAL) Imports C{dict}. 

89 ''' 

90 _name = NN 

91 

92 def __getattr__(self, attr): 

93 try: 

94 return self[attr] 

95 except KeyError: 

96 return dict.__getattr__(self, attr) 

97 

98# def __setattr__(self, attr, value): 

99# if attr in self: 

100# self[attr] = value 

101# else: 

102# dict.__setattr__(self, attr, value) 

103 

104 def add(self, name, mod_, *subs): 

105 '''Add a C{[name] = mod_} item. 

106 

107 @raise AssertionError: The B{C{name}} already exists 

108 with a different B{C{mod_}}. 

109 ''' 

110 if name in self: 

111 sub = self[name] # duplicate OK 

112 if sub != mod_ and sub not in subs: # PYCHOK no cover 

113 t = _DOT_(self._name, name) 

114 t = _COLONSPACE_(t, repr(sub)) 

115 t = _COMMASPACE_(t, _not_(repr(mod_))) 

116 raise AssertionError(t) 

117 else: 

118 self[name] = mod_ 

119 

120 def _NAME(self, which): 

121 self._name = _intern(_dunder_nameof(which).upper()) 

122 

123 

124class _NamedEnum_RO(dict): 

125 '''(INTERNAL) C{Read_Only} enum-like C{dict} sub-class. 

126 ''' 

127# _name = NN # also first kwd, __init__(_name=...) 

128 

129 def _DOT_(self, attr): # PYCHOK no cover 

130 return _DOT_(self._name, attr) # PYCHOK _name 

131 

132 def __getattr__(self, attr): 

133 try: 

134 return self[attr] 

135 except KeyError: 

136 t = self._DOT_(attr) 

137 raise LazyAttributeError(t, txt=_doesn_t_exist_) 

138 

139 def __setattr__(self, attr, value): # PYCHOK no cover 

140 t = _EQUALSPACED_(self._DOT_(attr), repr(value)) 

141 raise LazyAttributeError(_immutable_, txt=t) 

142 

143 def enums(self): 

144 # Yield all C{(mod_, tuple)} pairs 

145 for m, t in dict.items(self): 

146 n = m.replace(_UNDER_, _DOT_) 

147 if n != m: 

148 if m.startswith(_UNDER_): 

149 continue # skip _name= ... 

150 u = m.rstrip(_UNDER_) 

151 if u != m: 

152 u = len(u) 

153 n = n[:u] + m[u:] 

154 yield n, t 

155 

156 def fill_D(self, _D, which): 

157 # Fill C{_Dict _D}. 

158 _D._NAME(which) 

159 _a = _D.add 

160 for m, t in self.enums(): 

161 _a(m, _DOT_(m, NN, NN)) # import module 

162 for a in t: 

163 a, _, as_ = a.partition(__as__) 

164 if as_: # import attr as attr_ 

165 _a(as_, _DOT_(m, a, NN), *_SUB_PACKAGES) 

166 else: 

167 _a(a, m) 

168 return _D 

169 

170 

171def _i(*names): 

172 '''(INTERNAL) Intern all C{names}. 

173 ''' 

174 return tuple(map(_intern, names)) if names else _i0 

175 

176 

177def _ALL_ATTRS(*attrs): 

178 '''(INTERNAL) Unravel all exported module attributes. 

179 ''' 

180 t = () 

181 for attr in attrs: 

182 t += tuple(map(_getattrof, attr)) 

183 return t 

184 

185 

186_ALL_INIT = _i(_pygeodesy_abspath_, _version_) 

187 

188# __all__ value for most modules, accessible as _ALL_LAZY.<module> 

189_ALL_LAZY = _NamedEnum_RO(_name='_ALL_LAZY', 

190 albers=_i('AlbersEqualArea', 'AlbersEqualArea2', 'AlbersEqualArea4', 

191 'AlbersEqualAreaCylindrical', 'AlbersEqualAreaNorth', 'AlbersEqualAreaSouth', 

192 'AlbersError', 'Albers7Tuple'), 

193 auxilats=_i(), # module only 

194 azimuthal=_i('AzimuthalError', 'Azimuthal7Tuple', 

195 'Equidistant', 'EquidistantExact', 'EquidistantGeodSolve', 'EquidistantKarney', 

196 'Gnomonic', 'GnomonicExact', 'GnomonicGeodSolve', 'GnomonicKarney', 

197 'LambertEqualArea', 'Orthographic', 'Stereographic', 

198 'equidistant', 'gnomonic'), 

199 basics=_i('clips', 'copysign0', 'copytype', 'halfs2', 

200 'int1s', 'isbool', 'isCartesian', 'isclass', 'iscomplex', 'isDEPRECATED', 'isfloat', 

201 'isidentifier', 'isinstanceof', 'isint', 'isiterable', 'isiterablen', 'iskeyword', 

202 'isLatLon', 'islistuple', 'isNvector', 'isodd', 'isscalar', 'issequence', 'isstr', 

203 'issubclassof', 'itemsorted', 

204 'len2', 'map1', 'map2', 'neg', 'neg_', 

205 'signBit', 'signOf', 'splice', 'str2ub', 'ub2str', 'unsigned0'), 

206 booleans=_i('BooleanFHP', 'BooleanGH', 'LatLonFHP', 'LatLonGH', 

207 'isBoolean'), 

208 cartesianBase=_i('RadiusThetaPhi3Tuple', 'rtp2xyz', 'rtp2xyz_', 'xyz2rtp', 'xyz2rtp_'), 

209 clipy=_i('ClipCS4Tuple', 'ClipFHP4Tuple', 'ClipGH4Tuple', 'ClipLB6Tuple', 'ClipSH3Tuple', 

210 'clipCS4', 'clipFHP4', 'clipGH4', 'clipLB6', 'clipSH', 'clipSH3'), 

211 css=_i('CassiniSoldner', 'Css', 'CSSError', 'toCss', 

212 'EasNorAziRk4Tuple', 'EasNorAziRkEqu6Tuple', 'LatLonAziRk4Tuple'), 

213 constants=_i('DIG', 'EPS', 'EPS0', 'EPS02', 'EPS1', 'EPS2', 'EPS4', 'EPS_2', 

214 'INF', 'INT0', 'MANT_DIG', 'MAX', 'MAX_EXP', 'MIN', 'MIN_EXP', 'NAN', 'NEG0', 'NINF', 

215 'PI', 'PI2', 'PI_2', 'PI3', 'PI_3', 'PI3_2', 'PI4', 'PI_4', 

216 'R_FM', 'R_GM', 'R_KM', 'R_M', 'R_MA', 'R_MB', 'R_NM', 'R_QM', 'R_SM', 'R_VM', 

217 'float_', 'float0_', 'isclose', 'isfinite', 'isinf', 'isint0', 

218 'isnan', 'isnear0', 'isnear1', 'isnear90', 'isneg0', 'isninf', 'isnon0', 

219 'remainder'), 

220 datums=_i('Datum', 'Datums', 'Transform', 'Transforms'), 

221# deprecated=_i(), # module only 

222 dms=_i('F_D', 'F_DM', 'F_DMS', 'F_DEG', 'F_MIN', 'F_SEC', 'F_D60', 'F__E', 'F__F', 'F__G', 'F_RAD', 

223 'F_D_', 'F_DM_', 'F_DMS_', 'F_DEG_', 'F_MIN_', 'F_SEC_', 'F_D60_', 'F__E_', 'F__F_', 'F__G_', 'F_RAD_', 

224 'F_D__', 'F_DM__', 'F_DMS__', 'F_DEG__', 'F_MIN__', 'F_SEC__', 'F_D60__', 'F__E__', 'F__F__', 'F__G__', 'F_RAD__', 

225 'S_DEG', 'S_MIN', 'S_SEC', 'S_DMS', 'S_RAD', 'S_SEP', 

226 'bearingDMS', 'clipDegrees', 'clipRadians', 'compassDMS', 'compassPoint', 

227 'degDMS', 'latDMS', 'latlonDMS', 'latlonDMS_', 'lonDMS', 'normDMS', 

228 'parseDDDMMSS', 'parseDMS', 'parseDMS2', 'parse3llh', 'parseRad', 'precision', 'toDMS'), 

229 ecef=_i('EcefError', 'EcefFarrell21', 'EcefFarrell22', 'EcefKarney', 'EcefMatrix', 

230 'EcefSudano', 'Ecef9Tuple', 'EcefVeness', 'EcefYou'), 

231 elevations=_i('Elevation2Tuple', 'GeoidHeight2Tuple', 

232 'elevation2', 'geoidHeight2'), 

233 ellipsoidalBase=_i(), # module only 

234 ellipsoidalBaseDI=_i(), # module only 

235 ellipsoidalExact=_i(), # module only 

236 ellipsoidalGeodSolve=_i(), # module only 

237 ellipsoidalKarney=_i(), # module only 

238 ellipsoidalNvector=_i(), # module only 

239 ellipsoidalVincenty=_i('VincentyError',), # nothing else 

240 ellipsoids=_i('a_f2Tuple', 'Circle4Tuple', 'Curvature2Tuple', 

241 'Ellipsoid', 'Ellipsoid2', 'Ellipsoids', 

242 'a_b2e', 'a_b2e2', 'a_b2e22', 'a_b2e32', 'a_b2f', 'a_b2f_', 'a_b2f2', 'a_b2n', 

243 'a_f2b', 'a_f_2b', 'b_f2a', 'b_f_2a', 

244 'e2f', 'e22f', 

245 'f2e2', 'f2e22', 'f2e32', 'f_2f', 'f2f_', 'f2f2', 'f2n', 'n2e2', 'n2f', 'n2f_'), 

246 elliptic=_i('Elliptic', 'EllipticError', 'Elliptic3Tuple'), 

247 epsg=_i('Epsg', 'EPSGError'), 

248 errors=_i('AuxError', 'ClipError', 'CrossError', 'GeodesicError', 'IntersectionError', 

249 'NumPyError', 'LenError', 'LimitError', 'MGRSError', 

250 'ParseError', 'PointsError', 'RangeError', 'RhumbError', 

251 'SciPyError', 'SciPyWarning', 'TRFError', 'TriangleError', 'UnitError', 'VectorError', 

252 'crosserrors', 'exception_chaining', 'isError', 'limiterrors', 'rangerrors'), 

253 etm=_i('Etm', 'ETMError', 'ExactTransverseMercator', 

254 'parseETM5', 'toEtm8'), 

255 fmath=_i('Fdot', 'Fhorner', 'Fhypot', 'Fpolynomial', 'Fpowers', 'Fcbrt', 'Froot', 'Fsqrt', 

256 'bqrt', 'cbrt', 'cbrt2', 'euclid', 'euclid_', 

257 'facos1', 'fasin1', 'fatan', 'fatan1', 'fatan2', 'favg', 

258 'fdot', 'fdot3', 'fma', 'fmean', 'fmean_', 'fhorner', 'fidw', 'f2mul_', 'fpolynomial', 

259 'fpowers', 'fprod', 'frandoms', 'frange', 'freduce', 'fremainder', 

260 'hypot', 'hypot_', 'hypot1', 'hypot2', 'hypot2_', 

261 'norm2', 'norm_', 'sqrt0', 'sqrt3', 'sqrt_a', 'zcrt', 'zqrt'), 

262 formy=_i('Radical2Tuple', 

263 'antipode', 'antipode_', 'bearing', 'bearing_', 

264 'compassAngle', 'cosineForsytheAndoyerLambert', 'cosineForsytheAndoyerLambert_', 

265 'cosineAndoyerLambert', 'cosineAndoyerLambert_', 'cosineLaw', 'cosineLaw_', 

266 'equirectangular', 'equirectangular4', 'euclidean', 'euclidean_', 

267 'excessAbc_', 'excessCagnoli_', 'excessGirard_', 'excessLHuilier_', 

268 'excessKarney', 'excessKarney_', 'excessQuad', 'excessQuad_', 

269 'flatLocal', 'flatLocal_', 'flatPolar', 'flatPolar_', 

270 'hartzell', 'haversine', 'haversine_', 'heightOf', 'heightOrthometric', 'horizon', 'hubeny', 'hubeny_', 

271 'intersection2', 'intersections2', 'isantipode', 'isantipode_', 'isnormal', 'isnormal_', 

272 'latlon2n_xyz', 'normal', 'normal_', 'n_xyz2latlon', 'n_xyz2philam', 

273 'opposing', 'opposing_', 'philam2n_xyz', 'radical2', 

274 'thomas', 'thomas_', 'vincentys', 'vincentys_'), 

275 frechet=_i('Frechet', 'FrechetDegrees', 'FrechetError', 'FrechetRadians', 

276 'FrechetCosineAndoyerLambert', 'FrechetCosineForsytheAndoyerLambert', 

277 'FrechetCosineLaw', 'FrechetDistanceTo', 'FrechetEquirectangular', 

278 'FrechetEuclidean', 'FrechetExact', 'FrechetFlatLocal', 'FrechetFlatPolar', 

279 'FrechetHaversine', 'FrechetHubeny', 'FrechetKarney', 'FrechetThomas', 

280 'FrechetVincentys', 'Frechet6Tuple', 

281 'frechet_'), 

282 fstats=_i('Fcook', 'Flinear', 'Fwelford'), 

283 fsums=_i('Fsum', 'DivMod2Tuple', 'Fsum2Tuple', 'ResidualError', 

284 'f2product', 'fsum', 'fsum_', 'fsumf_', 'fsum1', 'fsum1_', 'fsum1f_', 'nonfiniterrors'), 

285 gars=_i('Garef', 'GARSError'), 

286 geodesici=_i('Intersectool', 'Intersectool5Tuple', 'Intersect7Tuple', 

287 'Intersector', 'Intersector5Tuple', 'Middle5Tuple', 'XDict'), 

288 geodesicw=_i('Geodesic', 'GeodesicLine', 'Geodesic_WGS84'), 

289 geodesicx=_i('gx', 'gxarea', 'gxbases', 'gxline', # modules 

290 'GeodesicAreaExact', 'GeodesicExact', 'GeodesicLineExact', 'PolygonArea'), 

291 geodsolve=_i('GeodesicSolve', 'GeodesicLineSolve', 'GeodSolve12Tuple'), 

292 geohash=_i('Geohash', 'Geohashed', 'GeohashError', 'Neighbors8Dict', 'Resolutions2Tuple', 'Sizes3Tuple'), 

293 geoids=_i('GeoidError', 'GeoidG2012B', 'GeoidKarney', 'GeoidPGM', 'egmGeoidHeights', 

294 'PGMError', 'GeoidHeight5Tuple'), 

295 hausdorff=_i('Hausdorff', 'HausdorffDegrees', 'HausdorffError', 'HausdorffRadians', 

296 'HausdorffCosineAndoyerLambert', 'HausdorffCosineForsytheAndoyerLambert', 

297 'HausdorffCosineLaw', 'HausdorffDistanceTo', 'HausdorffEquirectangular', 

298 'HausdorffEuclidean', 'HausdorffExact', 'HausdorffFlatLocal', 'HausdorffFlatPolar', 

299 'HausdorffHaversine', 'HausdorffHubeny', 'HausdorffKarney', 'HausdorffThomas', 

300 'HausdorffVincentys', 'Hausdorff6Tuple', 

301 'hausdorff_', 'randomrangenerator'), 

302 heights=_i('HeightCubic', 'HeightError', 

303 'HeightIDWcosineAndoyerLambert', 'HeightIDWcosineForsytheAndoyerLambert', 

304 'HeightIDWcosineLaw', 'HeightIDWdistanceTo', 'HeightIDWequirectangular', 

305 'HeightIDWeuclidean', 'HeightIDWexact', 'HeightIDWflatLocal', 'HeightIDWflatPolar', 

306 'HeightIDWhaversine', 'HeightIDWhubeny', 'HeightIDWkarney', 'HeightIDWthomas', 

307 'HeightIDWvincentys', 'HeightLinear', 'HeightLSQBiSpline', 'HeightSmoothBiSpline'), 

308 internals=_internals.__all__, 

309 interns=_interns.__all__, 

310 iters=_i('LatLon2PsxyIter', 'PointsIter', 'points2', 

311 'isNumpy2', 'isPoints2', 'isTuple2', 'iterNumpy2', 'iterNumpy2over'), 

312 karney=_i('Area3Tuple', 'Caps', 'Direct9Tuple', 'GDict', 'Inverse10Tuple', 'Rhumb8Tuple'), 

313 ktm=_i('KTMError', 'KTransverseMercator'), 

314 latlonBase=_i(), # module only 

315 lazily=_i('LazyAttributeError', 'LazyImportError', 'isLazy'), 

316 lcc=_i('Conic', 'Conics', 'Lcc', 'LCCError', 'toLcc'), 

317 ltp=_i('Attitude', 'AttitudeError', 'ChLV', 'ChLVa', 'ChLVe', 'Frustum', 

318 'LocalCartesian', 'LocalError', 'Ltp', 'tyr3d'), 

319 ltpTuples=_i('Aer', 'Aer4Tuple', 'Attitude4Tuple', 

320 'ChLVEN2Tuple', 'ChLV9Tuple', 'ChLVYX2Tuple', 'ChLVyx2Tuple', 

321 'Enu', 'Enu4Tuple', 'Footprint5Tuple', 'Local9Tuple', 'Los', 

322 'Ned', 'Ned4Tuple', 'Uvw', 'Uvw3Tuple', 'XyzLocal', 'Xyz4Tuple'), 

323 mgrs=_i('Mgrs', 'parseMGRS', 'toMgrs', 'Mgrs4Tuple', 'Mgrs6Tuple'), 

324 named=_i('ADict', 

325 'callername', 'classname', 'classnaming', 'modulename', 

326 'nameof', 'notImplemented', 'notOverloaded'), 

327 namedTuples=_i('Bearing2Tuple', 'Bounds2Tuple', 'Bounds4Tuple', 

328 'Destination2Tuple', 'Destination3Tuple', 

329 'Distance2Tuple', 'Distance3Tuple', 'Distance4Tuple', 

330 'EasNor2Tuple', 'EasNor3Tuple', 'Forward4Tuple', 'Intersection3Tuple', 

331 'LatLon2Tuple', 'LatLon3Tuple', 'LatLon4Tuple', 

332 'LatLonDatum3Tuple', 'LatLonDatum5Tuple', 

333 'LatLonPrec3Tuple', 'LatLonPrec5Tuple', 

334 'NearestOn2Tuple', 'NearestOn3Tuple', 'NearestOn6Tuple', 'NearestOn8Tuple', 

335 'PhiLam2Tuple', 'PhiLam3Tuple', 'PhiLam4Tuple', 'Point3Tuple', 'Points2Tuple', 

336 'Reverse4Tuple', 'Triangle7Tuple', 'Triangle8Tuple', 'Trilaterate5Tuple', 

337 'UtmUps2Tuple', 'UtmUps5Tuple', 'UtmUps8Tuple', 'UtmUpsLatLon5Tuple', 

338 'Vector2Tuple', 'Vector3Tuple', 'Vector4Tuple'), 

339 nvectorBase=_i('NorthPole', 'SouthPole'), 

340 osgr=_i('Osgr', 'OSGRError', 'parseOSGR', 'toOsgr'), 

341 points=_i('LatLon_', 'LatLon2psxy', 'Numpy2LatLon', 'Shape2Tuple', 'Tuple2LatLon', 

342 'areaOf', 'boundsOf', 'centroidOf', 'fractional', 

343 'isclockwise', 'isconvex', 'isconvex_', 'isenclosedBy', 'ispolar', 

344 'luneOf', 'nearestOn5', 'perimeterOf', 'quadOf'), 

345 props=_i('Property', 'Property_RO', 'property_doc_', 

346 'property_RO', 'property_ROnce', 'property_ROver', 

347 'deprecated_class', 'deprecated_function', 'deprecated_method', 

348 'deprecated_Property_RO', 'deprecated_property_RO', 'DeprecationWarnings'), 

349 resections=_i('Collins5Tuple', 'ResectionError', 'Survey3Tuple', 'Tienstra7Tuple', 

350 'TriAngle5Tuple', 'TriSide2Tuple', 'TriSide4Tuple', 

351 'cassini', 'collins5', 'pierlot', 'pierlotx', 'tienstra7', 

352 'snellius3', 'wildberger3', 

353 'triAngle', 'triAngle5', 'triArea', 'triSide', 'triSide2', 'triSide4'), 

354 rhumb=_i(), # module only 

355 rhumb_aux_=_i('RhumbAux', 'RhumbLineAux'), 

356 rhumb_ekx=_i('Rhumb', 'RhumbLine'), 

357 rhumb_solve=_i('RhumbSolve', 'RhumbLineSolve', 'RhumbSolve7Tuple'), 

358 sphericalBase=_i(), # module only 

359 sphericalNvector=_i(), # module only 

360 sphericalTrigonometry=_i(), # module only 

361 simplify=_i('simplify1', 'simplifyRDP', 'simplifyRDPm', 'simplifyRW', 'simplifyVW', 'simplifyVWm'), 

362 solveBase=_i(), # module only 

363 streprs=_i('anstr', 'attrs', 'enstr2', 'fstr', 'fstrzs', 'hstr', 'instr', 

364 'lrstrip', 'pairs', 'reprs', 'strs', 'unstr'), 

365 trf=_i('RefFrame', 'RefFrames', 'TransformXform', 'TRFXform', 'TRFXform7Tuple', 

366 'date2epoch', 'epoch2date', 'trfTransform0', 'trfTransforms', 'trfXform'), 

367 triaxials=_i('BetaOmega2Tuple', 'BetaOmega3Tuple', 'Jacobi2Tuple', 

368 'JacobiConformal', 'JacobiConformalSpherical', 

369 'Triaxial', 'Triaxial_', 'TriaxialError', 'Triaxials', 'hartzell4'), 

370 units=_i('Azimuth', 'Band', 'Bearing', 'Bearing_', 'Bool', 

371 'Degrees', 'Degrees_', 'Degrees2', 'Distance', 'Distance_', 'Easting', 'Epoch', 

372 'Feet', 'FIx', 'Float_', 'Height', 'Height_', 'HeightX', 'Int_', 

373 'Lam', 'Lamd', 'Lat', 'Lat_', 'Lon', 'Lon_', 

374 'Meter', 'Meter_', 'Meter2', 'Meter3', 'Northing', 'Number_', 

375 'Phi', 'Phid', 'Precision_', 'Radians', 'Radians_', 'Radians2', 

376 'Radius_', 'Scalar', 'Scalar_', 'Zone'), 

377 unitsBase=_i('Float', 'Int', 'Radius', 'Str'), 

378 ups=_i('Ups', 'UPSError', 'parseUPS5', 'toUps8', 'upsZoneBand5'), 

379 utily=_i('acos1', 'acre2ha', 'acre2m2', 'asin1', 'atan1', 'atan1d', 'atan2b', 'atan2d', 

380 'chain2m', 'circle4', 'cot', 'cot_', 'cotd', 'cotd_', 

381 'degrees', 'degrees90', 'degrees180', 'degrees360', 'degrees2grades', 'degrees2m', 

382# 'degrees2grades as degrees2gons', 

383 'fathom2m', 'ft2m', 'furlong2m', 

384 'grades', 'grades400', 'grades2degrees', 'grades2radians', 

385# 'grades as gons', 'grades400 as gons400', 'grades2degrees as gons2degrees', 'grades2radians as gons2radians', 

386 'km2m', 'm2chain', 'm2degrees', 'm2fathom', 'm2ft', 'm2furlong', 

387 'm2km', 'm2NM', 'm2radians', 'm2SM', 'm2toise', 'm2yard', 'NM2m', 

388 'radians', 'radiansPI', 'radiansPI2', 'radiansPI_2', 'radians2m', 

389 'sincos2', 'SinCos2', 'sincos2_', 'sincos2d', 'sincos2d_', 'sincostan3', 'SM2m', 

390 'tand', 'tand_', 'tan_2', 'tanPI_2_2', 'toise2m', 'truncate', 

391 'unroll180', 'unrollPI', 

392 'wrap90', 'wrap180', 'wrap360', 'wrapPI_2', 'wrapPI', 'wrapPI2', 'wrap_normal', 

393 'yard2m'), 

394 utm=_i('Utm', 'UTMError', 'parseUTM5', 'toUtm8', 'utmZoneBand5'), 

395 utmups=_i('UtmUps', 'UTMUPSError', 'parseUTMUPS5', 'toUtmUps8', 

396 'utmupsValidate', 'utmupsValidateOK', 'utmupsZoneBand5'), 

397 utmupsBase=_i(), # module only 

398 vector2d=_i('Circin6Tuple', 'Circum3Tuple', 'Circum4Tuple', 'Meeus2Tuple', 'Radii11Tuple', 'Soddy4Tuple', 'Triaxum5Tuple', 

399 'circin6', 'circum3', 'circum4', 'circum4_', 'meeus2', 'radii11', 'soddy4', 'triaxum5', 'trilaterate2d2'), 

400 vector3d=_i('Vector3d', 'intersection3d3', 'iscolinearWith', 'nearestOn', 'nearestOn6', 'parse3d', 

401 'trilaterate3d2'), 

402 vector3dBase=_i(), # module only 

403 webmercator=_i('Wm', 'WebMercatorError', 'parseWM', 'toWm', 'EasNorRadius3Tuple'), 

404 wgrs=_i('Georef', 'WGRSError'),) 

405 

406_ALL_DEPRECATED = _NamedEnum_RO(_name='_ALL_DEPRECATED', 

407 deprecated=_i('bases', 'datum', 'nvector', # DEPRECATED modules and ... 

408 'rhumbaux', 'rhumbBase', 'rhumbsolve', 'rhumbx'), # ... names 

409 deprecated_bases=_i('LatLonHeightBase', 'points2'), 

410 deprecated_classes=_i('ClipCS3Tuple', 'EasNorExact4Tuple', 'EcefCartesian', 'Fn_rt', 

411 'HeightIDW', 'HeightIDW2', 'HeightIDW3', 'Helmert7Tuple', 

412 'Lam_', 'LatLonExact4Tuple', 'NearestOn4Tuple', 'Ned3Tuple', 

413 'Phi_', 'RefFrameError', 'Rhumb7Tuple', 'RhumbOrder2Tuple', 

414 'Transform7Tuple', 'TriAngle4Tuple', 'UtmUps4Tuple', 'XDist'), 

415 deprecated_consterns=_i('EPS1_2', 'MANTIS', 'OK'), 

416 deprecated_datum=_i('Curvature2Tuple', 'Datum', 'Ellipsoid', 'Transform', # assert 

417 'Datums', 'Ellipsoids', 'Transforms', 

418 'R_FM', 'R_KM', 'R_M', 'R_MA', 'R_MB', 'R_NM', 'R_SM', 'R_VM'), 

419 deprecated_functions=_i('anStr', 'areaof', 'atand', 'bounds', # most of the DEPRECATED functions, except ellipsoidal ... 

420 'clipCS3', 'clipDMS', 'clipStr', 'collins', 'copysign', # ... and spherical flavors 

421 'decodeEPSG2', 'encodeEPSG', 'enStr2', 'equirectangular_', 'equirectangular3', 

422 'excessAbc', 'excessGirard', 'excessLHuilier', 

423 'false2f', 'falsed2f', 'float0', 'fStr', 'fStrzs', 'Fsum2product', 

424 'hypot3', 'inStr', 'isenclosedby', 'istuplist', 

425 'joined', 'joined_', 'nearestOn3', 'nearestOn4', 

426 'parseUTM', 'perimeterof', 'polygon', 'scalar', 'simplify2', 

427 'tienstra', 'toUtm', 'triAngle4', 

428 'unsign0', 'unStr', 'utmZoneBand2'), 

429 deprecated_nvector=_i('LatLonNvectorBase', 'Nvector', 'sumOf', 'NorthPole', 'SouthPole'),) 

430 

431 

432class _ALL_MODS(_internals._MODS_Base): 

433 '''(INTERNAL) Memoized import of any L{pygeodesy} module. 

434 ''' 

435 def __getattr__(self, name): 

436 '''Get a C{pygeodesy} module or attribute by B{C{name}}. 

437 

438 @arg name: Un/qualified module or qualified attribute name (C{str}). 

439 

440 @raise ImportError: Importing module B{C{name}} failed. 

441 

442 @raise AttributeError: No attribute named B{C{name}}. 

443 ''' 

444 try: 

445 v = _lazy_dict[name] # package.__dict__ 

446 except KeyError: 

447 v = _lazy_module(name) # package.__getattr__ 

448 if _tailof(_dunder_nameof(v)) != name: 

449 try: 

450 v = getattr(v, _tailof(name)) 

451 except AttributeError: 

452 pass # XXX LazyAttributeError? 

453 return v 

454 

455 def getattr(self, name, *attr_dflt): # , parent=_pygeodesy_ 

456 '''Get an attribute of/or a C{pygeodesy} module. 

457 

458 @arg name: Un/qualified module name (C{str}). 

459 @arg attr_dflt: Optional attribute name (C{str}) and 

460 optional default value (any C{type}). 

461 

462 @return: The C{pygeodesy} module's attribute value. 

463 

464 @raise ImportError: Importing module B{C{name}} failed. 

465 

466 @raise AttributeError: No attribute named B{C{attr}}. 

467 ''' 

468 v = self.getmodule(name) 

469 if attr_dflt: 

470 v = getattr(v, *attr_dflt) 

471 return v 

472 

473 def getmodule(self, name, parent=_pygeodesy_): 

474 '''Get a C{pygeodesy} module or the C{__main__}. 

475 

476 @arg name: Un/qualified module name (C{str}). 

477 

478 @return: The C{pygeodesy} module. 

479 

480 @raise ImportError: Importing module B{C{name}} failed. 

481 ''' 

482 if _headof(name) != parent and not _dunder_ismain(name): 

483 name = _DOT_(parent, name) 

484 try: 

485 return _sys.modules[name] 

486 except KeyError: 

487 return _getmodule(name, parent) 

488 

489 def imported(self, name): 

490 '''Return module or package C{name} if already imported. 

491 ''' 

492 return _sys.modules.get(name, None) 

493 

494 def into(self, **mod_dunder_name_): 

495 '''Lazily import module C{mod} into module C{_dunder_name_} 

496 and set C{_dunder_name_._mod} to module C{mod}, I{once}. 

497 ''' 

498 class _Into(object): 

499 

500 def __getattr__(unused, name): 

501 mod, dun = self.errors._xkwds_item2(mod_dunder_name_) 

502 _mod = _UNDER_(NN, mod) 

503 d = self.getmodule(dun) # '__main__' OK 

504 i = _getattribute(d, _mod, dun) 

505 assert isinstance(i, _Into) 

506 m = self.getmodule(mod) 

507 setattr(d, _mod, m) # overwrite C{d._mod} 

508 return getattr(m, name) 

509 

510 return _Into() 

511 

512# @_Property_RO 

513# def _isBoolean(self): 

514# '''(INTERNAL) Get function C(.booleans.isBoolean}, I{once}. 

515# ''' 

516# return self.booleans.isBoolean 

517 

518 def items(self): # no module named 'items' 

519 '''Yield the modules imported so far. 

520 ''' 

521 _hd = _headof 

522 for n, m in _sys.modules.items(): 

523 if _hd(n) == _pygeodesy_: 

524 yield n, m 

525 

526_internals._MODS = _ALL_MODS = _ALL_MODS() # PYCHOK singleton 

527 

528__all__ = _ALL_LAZY.lazily 

529__version__ = '24.09.19' 

530 

531 

532def _ALL_OTHER(*objs): 

533 '''(INTERNAL) Get class and function B{C{objs}} for __all__. 

534 ''' 

535 def _interned(o): # intern'd base name 

536 n = _tailof(_dunder_nameof(o)) 

537 i = NN(_UNDER_, n, _UNDER_) # intern'd 

538 return getattr(_interns, i, n) 

539 

540 return tuple(map(_interned, objs)) # map2 

541 

542 

543if _FOR_DOCS: 

544 _ALL_DOCS = _ALL_OTHER 

545 # (INTERNAL) Only export B{C{objs.__name__}} when making the 

546 # docs to force C{epydoc} to include certain classes, methods, 

547 # functions and other names in the documentation. Using the 

548 # C{epydoc --private ...} command line option tends to include 

549 # too much internal documentation. 

550else: 

551 def _ALL_DOCS(*unused): 

552 return () 

553 

554 

555def _all_deprecates(): 

556 '''(INTERNAL) Build C{dict} of all deprecated imports. 

557 ''' 

558 _D = _ALL_DEPRECATES 

559 if not _D: 

560 _ALL_DEPRECATED.fill_D(_D, _all_deprecates) # see _all_imports() 

561 return _D 

562 

563_ALL_DEPRECATES = _Dict() # PYCHOK _ALL_DEPRECATED.imports() 

564 

565 

566def _all_imports(): 

567 '''(INTERNAL) Build C{dict} of all lazy imports. 

568 ''' 

569 # imports naming conventions stored below - [<key>] = <from>: 

570 # import <module> - [<module>] = <module> 

571 # from <module> import <attr> - [<attr>] = <module> 

572 # from pygeodesy import <attr> - [<attr>] = <attr> 

573 # from <module> import <attr> as <name> - [<name>] = <module>.<attr>. 

574 _D = _ALL_IMPORTS 

575 if not _D: 

576 _ALL_LAZY.fill_D(_D, _all_imports) # see _all_deprecates() 

577 return _D 

578 

579_ALL_IMPORTS = _Dict() # PYCHOK _ALL_LAZY.imports() 

580 

581 

582def _all_missing2(_all_): 

583 '''(INTERNAL) Get diffs between pygeodesy.__all__ and lazily._all_imports. 

584 ''' 

585 def _diff(one, two): 

586 return tuple(sorted(a for a in one if a not in two)) 

587 

588 _alzy = _Dict((a, a) for a in _ALL_INIT) 

589 _alzy.update(_all_imports()) # without _all_backups! 

590 return ((_DOT_(_lazily_, _all_imports.__name__), _diff(_all_, _alzy)), 

591 (_DOT_(_pygeodesy_, _dunder_all_), _diff(_alzy.keys(), _all_))) 

592 

593 

594def _getattribute(m, name, mod=_pygeodesy_): 

595 '''(INTERNAL) Get attr C{m.name}. 

596 ''' 

597 try: 

598 return getattr(m, name) 

599 except AttributeError: 

600 name = _DOT_(mod, name) 

601 # <https://GitHub.com/mrJean1/PyGeodesy/issues/76> 

602 raise LazyAttributeError(_no_(_attribute_), txt=name) 

603 

604 

605def _getattrof(attr_as): # .testDeprecated 

606 '''(INTERNAL) Get the C{"as name"} or C{"name"} of a lazy entry. 

607 ''' 

608 a_, _, as_ = attr_as.partition(__as__) 

609 return as_ or a_.rstrip(_DOT_) 

610 

611 

612def _getmodule(name, *parent): 

613 '''(INTERNAL) Wrapper for C{import_module}. 

614 ''' 

615 try: 

616 return import_module(name, parent) 

617 except ImportError: 

618 # <https://GitHub.com/mrJean1/PyGeodesy/issues/76> 

619 raise LazyImportError(_no_(_module_), txt=name) 

620 

621 

622# def _lazy_attributes(_dunder_name_): 

623# '''(INTERNAL) Return a function to C{B{__name__}.__getattr__(attr)} 

624# on lazily imported modules and sub-modules. 

625# ''' 

626# if _unlazy: 

627# raise AssertionError(_COMMASPACE_(_dunder_name_, _not_(_DEPRECATED_))) 

628# 

629# def _getattr(attr, *dflt): 

630# try: # a module name 

631# return _ALL_MODS.getmodule(attr) 

632# except (AttributeError, ImportError): 

633# return _ALL_MODS.getattr(_dunder_name_, attr, *dflt) 

634# 

635# return _getattr 

636 

637 

638_lazy_dict = {} # PYCHOK overwritten by _lazy_import2 

639 

640 

641def _lazy_import2(pack): # MCCABE 14 

642 '''Check for and set up C{lazy import}. 

643 

644 @arg pack: The name of the package (C{str}) performing the imports, 

645 to help resolving relative imports, usually C{__package__}. 

646 

647 @return: 2-Tuple C{(package, getattr)} of the importing package for 

648 easy reference within itself and the callable to be set to 

649 C{package.__getattr__}. 

650 

651 @raise LazyAttributeError: The package, module or attribute name is 

652 invalid or does not exist. 

653 

654 @raise LazyImportError: Lazy import not supported or not enabled or 

655 an import failed. 

656 

657 @note: This is I{Brett Cannon}'s function U{modutil.lazy_import 

658 <https://GitHub.com/brettcannon/modutil/blob/master/modutil.py>} 

659 modified to handle the C{__all__} and C{__dir__} attributes and 

660 call C{importlib.import_module(<module>.<name>, ...)} without 

661 causing a C{ModuleNotFoundError}. 

662 

663 @see: The original U{modutil<https://PyPI.org/project/modutil>}, 

664 U{PEP 562<https://www.Python.org/dev/peps/pep-0562>} and the 

665 U{new way<https://Snarky.Ca/lazy-importing-in-python-3-7/>}. 

666 ''' 

667 _DOT_ = _interns._DOT_ 

668 _SPACE_ = _interns._SPACE_ 

669 

670 if pack != _pygeodesy_ or _unlazy: # Python 3.7+ 

671 t = _no_(_DOT_(pack, _dunder_nameof(_lazy_import2))) # PYCHOK no cover 

672 raise LazyImportError(t, txt=_Pythonarchine(sep=_SPACE_)) 

673 

674 package, parent = _lazy_init2(pack) # _pygeodesy_ 

675 sub_packages = set((parent, NN) + tuple( 

676 _DOT_(parent, s) for s in _SUB_PACKAGES)) 

677 imports = _all_imports() 

678 deprecates = _all_deprecates() 

679 _dunder_package_ = '__package__' 

680 

681 def __getattr__(name): # __getattr__ only for Python 3.7+ 

682 # only called once for each undefined pygeodesy attribute 

683 mod = imports.get(name, NN) or deprecates.get(name, NN) 

684 if mod: 

685 # importlib.import_module() implicitly sets sub-modules 

686 # on this module as appropriate for direct imports (see 

687 # note in the _lazy_import2.__doc__ above). 

688 if mod.endswith(_DOT_): # import mod[.attr] as name 

689 mod, _, attr = mod[:-1].rpartition(_DOT_) 

690 else: # from mod import name 

691 attr = name 

692 v = _getmodule(_DOT_(pack, mod), parent) 

693 t = getattr(v, _dunder_package_, None) 

694 if t not in sub_packages: # invalid module package 

695 raise LazyImportError(_DOT_(mod, _dunder_package_), t) 

696 if attr: # get mod.attr 

697 v = _getattribute(v, attr, mod) 

698 

699 elif name in (_dunder_all_,): # XXX _dunder_dir_, _dunder_members_? 

700 v = _ALL_INIT + tuple(imports.keys()) 

701 else: # PYCHOK no cover 

702 t = _no_(_module_, _or_, _attribute_) 

703 # <https://GitHub.com/mrJean1/PyGeodesy/issues/76> 

704 raise LazyAttributeError(t, txt=_DOT_(parent, name)) 

705 

706 setattr(package, name, v) # package.__dict__[name] = val 

707 if isLazy > 1: 

708 t = _SPACE_(_lazily_imported_, _DOT_(parent, name)) 

709 if mod and _tailof(mod) != name: 

710 t = _SPACE_(t, _from_, _DOT_(NN, mod)) 

711 if isLazy > 2: 

712 try: # see C{_caller3} 

713 _, f, s = _caller3(2) 

714 t = _SPACE_(t, _by_, f, _line_, s) 

715 except ValueError: 

716 pass 

717 printf(t) # XXX print 

718 

719 return v # __getattr__ 

720 

721 global _lazy_dict, _lazy_module 

722 _lazy_dict = package.__dict__ 

723 _lazy_module = __getattr__ 

724 

725 return package, __getattr__ # _lazy_import2 

726 

727 

728# def _lazy_import_all(_dunder_name_): 

729# '''(INTERNAL) Return a function mimicking C{from B{__name__} import *}, 

730# of all items, see .deprecated.__init__ 

731# ''' 

732# if _unlazy: 

733# raise AssertionError(_COMMASPACE_(_dunder_name_, _not_(_DEPRECATED_))) 

734# 

735# _getattr = _lazy_attributes(_dunder_name_) # __name__.__getattr__ 

736# _import_start = _lazy_import_star(_dunder_name_, ALL_=_ALL_IMPORTS) 

737# 

738# def _import_all(attr, *dflt): 

739# return _import_star(_dunder_name_) if attr == _dunder_all_ else \ 

740# _getattr(attr, *dflt) 

741# 

742# return _import_all 

743 

744 

745def _lazy_import_as(_dunder_name_): 

746 '''(INTERNAL) Return a function to C{import B{__name__}.mod as mod} 

747 I{of modules only}, see .deprecated, .rhumb or get an attribute 

748 lazily exported by C{__name__}. 

749 ''' 

750 if _unlazy: 

751 return None 

752 

753 def _import_as(mod): 

754 try: 

755 return _ALL_MODS.getmodule(_DOT_(_dunder_name_, mod)) 

756 except ImportError: 

757 return _lazy_module(mod) 

758 

759 return _import_as 

760 

761 

762# def _lazy_import_star(_dunder_name_, ALL_=_ALL_DEPRECATES): 

763# '''(INTERNAL) Return a function to mimick C{from B{__name__} import *}, 

764# of all DEPRECATED items, see .deprecated, .testDeprecated 

765# ''' 

766# if _unlazy: 

767# raise AssertionError(_COMMASPACE_(_dunder_name_, _not_(_DEPRECATED_))) 

768# 

769# def _import_star(_into_): 

770# '''Do C{from B{__name__} import *} inside module C{B{__into__}}. 

771# ''' 

772# d = dict() 

773# nm = _tailof(_dunder_name_) 

774# _g = _ALL_MODS.getattr # pygeodesy.__getattr__ 

775# _h = _headof 

776# for a, m in ALL_.items(): 

777# if _h(m) == nm: 

778# try: 

779# d[a] = _g(m, a) 

780# except (AttributeError, ImportError): 

781# pass 

782# _sys.modules[_into_].__dict__.update(d) 

783# return d.keys() # imported names 

784# 

785# return _import_star 

786 

787 

788def _lazy_init2(pack): 

789 '''(INTERNAL) Initialize lazy import and set globals C{isLazy} and C{_unLazy0}. 

790 

791 @arg pack: The name of the package (C{str}) performing the imports, 

792 to help resolving relative imports, usually C{__package__}. 

793 

794 @return: 2-Tuple C{(package, parent)} with the importing C{package} 

795 for easy reference within itself and its name aka the 

796 C{parent}, same as B{C{pack}}. 

797 

798 @raise LazyImportError: Lazy import not supported or not enabled, 

799 an import failed or the package name is 

800 invalid or does not exist. 

801 

802 @note: Global C{isLazy} is set accordingly. 

803 ''' 

804 global isLazy, _unLazy0 

805 

806 z = _getenv(_PYGEODESY_LAZY_IMPORT_, None) 

807 if z is None: # _PYGEODESY_LAZY_IMPORT_ not set 

808 isLazy = 1 # ... but only by default on 3.7 

809 else: 

810 z = z.strip() # like PYTHONVERBOSE et.al. 

811 isLazy = int(z) if z.isdigit() else (1 if z else 0) 

812 

813 _unLazy0 = _unlazy or not isLazy # pre-3.7 or w/o lazy import 

814 

815 if isLazy < 1: # not enabled 

816 raise LazyImportError(_PYGEODESY_LAZY_IMPORT_, repr(z), txt_not_=_enabled_) 

817 if _getenv('PYTHONVERBOSE', None): # PYCHOK no cover 

818 isLazy += 1 

819 

820 try: # to initialize in Python 3+ 

821 package = import_module(pack) 

822 parent = package.__spec__.parent # __spec__ only in Python 3.7+ 

823 if parent != pack: # assert 

824 t = _COMMASPACE_(parent, _not_(pack)) # PYCHOK no cover 

825 raise AttributeError(_EQUALSPACED_('parent', t)) 

826 

827 except (AttributeError, ImportError) as x: 

828 isLazy = False # failed 

829 raise LazyImportError(_lazy_init2.__name__, pack, cause=x) 

830 

831 return package, parent 

832 

833 

834def _lazy_module(name): # overwritten by _lazy_import2 

835 '''(INTERNAL) Get or import a C{pygeodesy} module. 

836 ''' 

837 try: # most likely ... module has been imported 

838 m = _ALL_MODS.getmodule(name) 

839 except (AttributeError, ImportError) as x: 

840 raise LazyImportError(name, cause=x) 

841 _lazy_dict[name] = m # cache 

842 return m 

843 

844 

845# def _lazy_subs(_dunder_name_, force=_FOR_DOCS, over=False): 

846# '''(INTERNAL) Return the names of a package's sub-packages and 

847# update the package's C{__dict__} accordingly. 

848# ''' 

849# sm = dict() 

850# if force and not _dunder_ismain(_dunder_name_): 

851# nm = _tailof(_dunder_name_) 

852# _a = _ALL_MODS.getattr 

853# _m = _ALL_MODS.getmodule 

854# d = _a(_dunder_name_, _dunder_dict_, {}) 

855# for n in _a(_dunder_name_, _dunder_all_, ()): 

856# try: # n is a class name, get its mod name 

857# m = _a(_dunder_name_, n).__module__ 

858# n, s = m.split(_DOT_)[-2:] 

859# if n == nm and s not in sm: 

860# # like import m as s 

861# m = _m(m) 

862# sm[s] = m if over else d.get(s, m) 

863# except (AttributeError, ImportError, ValueError) as x: 

864# pass 

865# d.update(sm) 

866# 

867# return _ALL_OTHER(*sm.values()) 

868 

869# del _i, _i0 

870 

871# _ = _ALL_MODS.errors # force import pygeodesy.errors 

872 

873if _dunder_ismain(__name__): # PYCHOK no cover 

874 

875 from pygeodesy.internals import _versions 

876 from timeit import timeit 

877 

878 def t1(): 

879 from pygeodesy.trf import RefFrame 

880 return RefFrame 

881 

882 def t2(): 

883 return _ALL_MODS.trf.RefFrame 

884 

885 assert t1() is t2() # prime each 

886 

887 t1 = timeit(t1, number=1000000) 

888 t2 = timeit(t2, number=1000000) 

889 printf('%.6f import vs %.6f _ALL_MODS: %.2fX, %s', t1, t2, t1 / t2, _versions()) 

890 

891# del t1, t2, timeit, v 

892 

893# % python3.13 -W ignore -m pygeodesy.lazily 

894# 0.102670 import vs 0.076113 _ALL_MODS: 1.35X, pygeodesy 24.8.4 Python 3.13.0b4 64bit arm64 macOS 14.5 

895 

896# % python3.12 -W ignore -m pygeodesy.lazily 

897# 0.132801 import vs 0.079125 _ALL_MODS: 1.68X, pygeodesy 24.8.4 Python 3.12.4 64bit arm64 macOS 14.5 

898 

899# % python3.11 -W ignore -m pygeodesy.lazily 

900# 0.381723 import vs 0.251589 _ALL_MODS: 1.52X, pygeodesy 24.8.4 Python 3.11.5 64bit arm64 macOS 14.4.1 

901 

902# % python3.8 -W ignore -m pygeodesy.lazily 

903# 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 

904 

905# % python2 -m pygeodesy.lazily 

906# 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 

907 

908# **) MIT License 

909# 

910# Copyright (C) 2018-2024 -- mrJean1 at Gmail -- All Rights Reserved. 

911# 

912# Permission is hereby granted, free of charge, to any person obtaining a 

913# copy of this software and associated documentation files (the "Software"), 

914# to deal in the Software without restriction, including without limitation 

915# the rights to use, copy, modify, merge, publish, distribute, sublicense, 

916# and/or sell copies of the Software, and to permit persons to whom the 

917# Software is furnished to do so, subject to the following conditions: 

918# 

919# The above copyright notice and this permission notice shall be included 

920# in all copies or substantial portions of the Software. 

921# 

922# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS 

923# OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 

924# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 

925# THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR 

926# OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 

927# ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR 

928# OTHER DEALINGS IN THE SOFTWARE.