Coverage for pygeodesy/lazily.py: 93%

208 statements  

« prev     ^ index     » next       coverage.py v7.2.2, created at 2024-06-27 20:21 -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, _osversion2, printf, _Pythonarchine, \ 

35 _tailof # _Property_RO 

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

37 _doesn_t_exist_, _DOT_, _EQUALSPACED_, _from_, \ 

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

39 _or_, _pygeodesy_abspath_, _pygeodesy_, _SPACE_, \ 

40 _SUB_PACKAGES, _UNDER_, _version_, _sys, \ 

41 _intern # function 

42# from pygeodesy.streprs import unstr # _ALL_MODS 

43 

44try: 

45 from importlib import import_module 

46except ImportError as x: # Python 2.6- 

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

48from os import getenv as _getenv 

49# import sys as _sys # from .interns 

50 

51__as__ = ' as ' 

52_dunder_all_ = '__all__' # in .__main__ 

53_enabled_ = 'enabled' 

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

55_i0 = () # PYCHOK empty tuple 

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

57_lazily_ = 'lazily' 

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

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

60_PYGEODESY_GEODSOLVE_ = 'PYGEODESY_GEODSOLVE' # PYCHOK .geodsolve, 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', 'fmean', 'fmean_', 'fhorner', 'fidw', '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 'fsum', 'fsum_', 'fsumf_', 'fsum1', 'fsum1_', 'fsum1f_'), 

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

286 geodesici=_i('Intersector', 'Intersector5Tuple', 'XDist'), 

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

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

289 'GeodesicAreaExact', 'GeodesicExact', 'GeodesicLineExact', 'PolygonArea'), 

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

291 geohash=_i('Geohash', 'GeohashError', 'Neighbors8Dict', 'Resolutions2Tuple'), 

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

293 'PGMError', 'GeoidHeight5Tuple'), 

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

295 'HausdorffCosineAndoyerLambert', 'HausdorffCosineForsytheAndoyerLambert', 

296 'HausdorffCosineLaw', 'HausdorffDistanceTo', 'HausdorffEquirectangular', 

297 'HausdorffEuclidean', 'HausdorffExact', 'HausdorffFlatLocal', 'HausdorffFlatPolar', 

298 'HausdorffHaversine', 'HausdorffHubeny', 'HausdorffKarney', 'HausdorffThomas', 

299 'HausdorffVincentys', 'Hausdorff6Tuple', 

300 'hausdorff_', 'randomrangenerator'), 

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

302 'HeightIDWcosineAndoyerLambert', 'HeightIDWcosineForsytheAndoyerLambert', 

303 'HeightIDWcosineLaw', 'HeightIDWdistanceTo', 'HeightIDWequirectangular', 

304 'HeightIDWeuclidean', 'HeightIDWexact', 'HeightIDWflatLocal', 'HeightIDWflatPolar', 

305 'HeightIDWhaversine', 'HeightIDWhubeny', 'HeightIDWkarney', 'HeightIDWthomas', 

306 'HeightIDWvincentys', 'HeightLinear', 'HeightLSQBiSpline', 'HeightSmoothBiSpline'), 

307 internals=_internals.__all__, 

308 interns=_interns.__all__, 

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

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

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

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

313 latlonBase=_i(), # module only 

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

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

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

317 'LocalCartesian', 'LocalError', 'Ltp', 'tyr3d'), 

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

319 'ChLVEN2Tuple', 'ChLV9Tuple', 'ChLVYX2Tuple', 'ChLVyx2Tuple', 

320 'Enu', 'Enu4Tuple', 'Footprint5Tuple', 'Local9Tuple', 'Los', 

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

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

323 named=_i('ADict', 

324 'callername', 'classname', 'classnaming', 'modulename', 

325 'nameof', 'notImplemented', 'notOverloaded'), 

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

327 'Destination2Tuple', 'Destination3Tuple', 

328 'Distance2Tuple', 'Distance3Tuple', 'Distance4Tuple', 

329 'EasNor2Tuple', 'EasNor3Tuple', 'Forward4Tuple', 'Intersection3Tuple', 

330 'LatLon2Tuple', 'LatLon3Tuple', 'LatLon4Tuple', 

331 'LatLonDatum3Tuple', 'LatLonDatum5Tuple', 

332 'LatLonPrec3Tuple', 'LatLonPrec5Tuple', 

333 'NearestOn2Tuple', 'NearestOn3Tuple', 'NearestOn6Tuple', 'NearestOn8Tuple', 

334 'PhiLam2Tuple', 'PhiLam3Tuple', 'PhiLam4Tuple', 'Point3Tuple', 'Points2Tuple', 

335 'Reverse4Tuple', 'Triangle7Tuple', 'Triangle8Tuple', 'Trilaterate5Tuple', 

336 'UtmUps2Tuple', 'UtmUps5Tuple', 'UtmUps8Tuple', 'UtmUpsLatLon5Tuple', 

337 'Vector2Tuple', 'Vector3Tuple', 'Vector4Tuple'), 

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

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

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

341 'areaOf', 'boundsOf', 'centroidOf', 'fractional', 

342 'isclockwise', 'isconvex', 'isconvex_', 'isenclosedBy', 'ispolar', 

343 'luneOf', 'nearestOn5', 'perimeterOf', 'quadOf'), 

344 props=_i('Property', 'Property_RO', 'property_RO', 'property_doc_', 

345 'deprecated_class', 'deprecated_function', 'deprecated_method', 

346 'deprecated_Property_RO', 'deprecated_property_RO', 'DeprecationWarnings'), 

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

348 'TriAngle5Tuple', 'TriSide2Tuple', 'TriSide4Tuple', 

349 'cassini', 'collins5', 'pierlot', 'pierlotx', 'tienstra7', 

350 'snellius3', 'wildberger3', 

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

352 rhumb=_i(), # module only 

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

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

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

356 sphericalBase=_i(), # module only 

357 sphericalNvector=_i(), # module only 

358 sphericalTrigonometry=_i(), # module only 

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

360 solveBase=_i(), # module only 

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

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

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

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

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

366 'JacobiConformal', 'JacobiConformalSpherical', 

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

368 units=_i('Band', 'Bearing', 'Bearing_', 'Bool', 

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

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

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

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

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

374 'Radius_', 'Scalar', 'Scalar_', 'Zone'), 

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

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

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

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

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

380# 'degrees2grades as degrees2gons', 

381 'fathom2m', 'ft2m', 'furlong2m', 

382 'grades', 'grades400', 'grades2degrees', 'grades2radians', 

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

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

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

386 'radians', 'radiansPI', 'radiansPI2', 'radiansPI_2', 'radians2m', 

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

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

389 'unroll180', 'unrollPI', 

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

391 'yard2m'), 

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

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

394 'utmupsValidate', 'utmupsValidateOK', 'utmupsZoneBand5'), 

395 utmupsBase=_i(), # module only 

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

397 'circin6', 'circum3', 'circum4_', 'meeus2', 'radii11', 'soddy4'), 

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

399 'trilaterate2d2', 'trilaterate3d2'), 

400 vector3dBase=_i(), # module only 

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

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

403 

404_ALL_DEPRECATED = _NamedEnum_RO(_name='_ALL_DEPRECATED', 

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

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

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

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

409 'HeightIDW', 'HeightIDW2', 'HeightIDW3', 'Helmert7Tuple', 

410 'Lam_', 'LatLonExact4Tuple', 'NearestOn4Tuple', 'Ned3Tuple', 

411 'Phi_', 'RefFrameError', 'Rhumb7Tuple', 'RhumbOrder2Tuple', 

412 'Transform7Tuple', 'TriAngle4Tuple', 'UtmUps4Tuple'), 

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

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

415 'Datums', 'Ellipsoids', 'Transforms', 

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

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

418 'clipCS3', 'clipDMS', 'clipStr', 'collins', 'copysign', # ... ellipsoidal, spherical flavors 

419 'decodeEPSG2', 'encodeEPSG', 'enStr2', 'equirectangular_', 'equirectangular3', 

420 'excessAbc', 'excessGirard', 'excessLHuilier', 

421 'false2f', 'falsed2f', 'float0', 'fStr', 'fStrzs', 'hypot3', 

422 'inStr', 'isenclosedby', 'istuplist', 

423 'joined', 'joined_', 'nearestOn3', 'nearestOn4', 

424 'parseUTM', 'perimeterof', 'polygon', 'scalar', 'simplify2', 

425 'tienstra', 'toUtm', 'triAngle4', 

426 'unsign0', 'unStr', 'utmZoneBand2'), 

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

428 

429 

430class _ALL_MODS(_internals._MODS_Base): 

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

432 ''' 

433 def __getattr__(self, name): 

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

435 

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

437 

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

439 

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

441 ''' 

442 try: 

443 v = _lazy_dict[name] # package.__dict__ 

444 except KeyError: 

445 v = _lazy_module(name) # package.__getattr__ 

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

447 try: 

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

449 except AttributeError: 

450 pass # XXX LazyAttributeError? 

451 return v 

452 

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

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

455 

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

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

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

459 

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

461 

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

463 

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

465 ''' 

466 v = self.getmodule(name) 

467 if attr_dflt: 

468 v = getattr(v, *attr_dflt) 

469 return v 

470 

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

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

473 

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

475 

476 @return: The C{pygeodesy} module. 

477 

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

479 ''' 

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

481 name = _DOT_(parent, name) 

482 try: 

483 return _sys.modules[name] 

484 except KeyError: 

485 return _getmodule(name, parent) 

486 

487 def into(self, **mod_dunder_name_): 

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

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

490 ''' 

491 class _Into(object): 

492 

493 def __getattr__(unused, name): 

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

495 _mod = _UNDER_(NN, mod) 

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

497 i = _getattribute(d, _mod, dun) 

498 assert isinstance(i, _Into) 

499 m = self.getmodule(mod) 

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

501 return getattr(m, name) 

502 

503 return _Into() 

504 

505# @_Property_RO 

506# def _isBoolean(self): 

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

508# ''' 

509# return self.booleans.isBoolean 

510 

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

512 '''Yield the modules imported so far. 

513 ''' 

514 _hd = _headof 

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

516 if _hd(n) == _pygeodesy_: 

517 yield n, m 

518 

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

520 

521__all__ = _ALL_LAZY.lazily 

522__version__ = '24.06.19' 

523 

524 

525def _ALL_OTHER(*objs): 

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

527 ''' 

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

529 n = _tailof(_dunder_nameof(o)) 

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

531 return getattr(_interns, i, n) 

532 

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

534 

535 

536if _FOR_DOCS: 

537 _ALL_DOCS = _ALL_OTHER 

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

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

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

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

542 # too much internal documentation. 

543else: 

544 def _ALL_DOCS(*unused): 

545 return () 

546 

547 

548def _all_deprecates(): 

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

550 ''' 

551 _D = _ALL_DEPRECATES 

552 if not _D: 

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

554 return _D 

555 

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

557 

558 

559def _all_imports(): 

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

561 ''' 

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

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

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

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

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

567 _D = _ALL_IMPORTS 

568 if not _D: 

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

570 return _D 

571 

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

573 

574 

575def _all_missing2(_all_): 

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

577 ''' 

578 def _diff(one, two): 

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

580 

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

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

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

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

585 

586 

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

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

589 ''' 

590 try: 

591 return getattr(m, name) 

592 except AttributeError: 

593 name = _DOT_(mod, name) 

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

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

596 

597 

598def _getattrof(attr_as): # .testDeprecated 

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

600 ''' 

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

602 return as_ or a_.rstrip(_DOT_) 

603 

604 

605def _getmodule(name, *parent): 

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

607 ''' 

608 try: 

609 return import_module(name, parent) 

610 except ImportError: 

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

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

613 

614 

615# def _lazy_attributes(_dunder_name_): 

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

617# on lazily imported modules and sub-modules. 

618# ''' 

619# if _unlazy: 

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

621# 

622# def _getattr(attr, *dflt): 

623# try: # a module name 

624# return _ALL_MODS.getmodule(attr) 

625# except (AttributeError, ImportError): 

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

627# 

628# return _getattr 

629 

630 

631_lazy_dict = {} # PYCHOK overwritten by _lazy_import2 

632 

633 

634def _lazy_import2(pack): # MCCABE 14 

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

636 

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

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

639 

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

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

642 C{package.__getattr__}. 

643 

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

645 invalid or does not exist. 

646 

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

648 an import failed. 

649 

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

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

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

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

654 causing a C{ModuleNotFoundError}. 

655 

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

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

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

659 ''' 

660 _DOT_ = _interns._DOT_ 

661 _SPACE_ = _interns._SPACE_ 

662 

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

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

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

666 

667 package, parent = _lazy_init2(pack) # _pygeodesy_ 

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

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

670 imports = _all_imports() 

671 deprecates = _all_deprecates() 

672 _dunder_package_ = '__package__' 

673 

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

675 # only called once for each undefined pygeodesy attribute 

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

677 if mod: 

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

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

680 # note in the _lazy_import2.__doc__ above). 

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

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

683 else: # from mod import name 

684 attr = name 

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

686 t = getattr(v, _dunder_package_, None) 

687 if t not in sub_packages: # invalid module package 

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

689 if attr: # get mod.attr 

690 v = _getattribute(v, attr, mod) 

691 

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

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

694 else: # PYCHOK no cover 

695 t = _no_(_module_, _or_, _attribute_) 

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

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

698 

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

700 if isLazy > 1: 

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

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

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

704 if isLazy > 2: 

705 try: # see C{_caller3} 

706 _, f, s = _caller3(2) 

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

708 except ValueError: 

709 pass 

710 printf(t) # XXX print 

711 

712 return v # __getattr__ 

713 

714 global _lazy_dict, _lazy_module 

715 _lazy_dict = package.__dict__ 

716 _lazy_module = __getattr__ 

717 

718 return package, __getattr__ # _lazy_import2 

719 

720 

721# def _lazy_import_all(_dunder_name_): 

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

723# of all items, see .deprecated.__init__ 

724# ''' 

725# if _unlazy: 

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

727# 

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

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

730# 

731# def _import_all(attr, *dflt): 

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

733# _getattr(attr, *dflt) 

734# 

735# return _import_all 

736 

737 

738def _lazy_import_as(_dunder_name_): 

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

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

741 lazily exported by C{__name__}. 

742 ''' 

743 if _unlazy: 

744 return None 

745 

746 def _import_as(mod): 

747 try: 

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

749 except ImportError: 

750 return _lazy_module(mod) 

751 

752 return _import_as 

753 

754 

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

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

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

758# ''' 

759# if _unlazy: 

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

761# 

762# def _import_star(_into_): 

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

764# ''' 

765# d = dict() 

766# nm = _tailof(_dunder_name_) 

767# _g = _ALL_MODS.getattr # pygeodesy.__getattr__ 

768# _h = _headof 

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

770# if _h(m) == nm: 

771# try: 

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

773# except (AttributeError, ImportError): 

774# pass 

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

776# return d.keys() # imported names 

777# 

778# return _import_star 

779 

780 

781def _lazy_init2(pack): 

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

783 

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

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

786 

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

788 for easy reference within itself and its name aka the 

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

790 

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

792 an import failed or the package name is 

793 invalid or does not exist. 

794 

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

796 ''' 

797 global isLazy, _unLazy0 

798 

799 z = _getenv(_PYGEODESY_LAZY_IMPORT_, None) 

800 if z is None: # _PYGEODESY_LAZY_IMPORT_ not set 

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

802 else: 

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

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

805 

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

807 

808 if isLazy < 1: # not enabled 

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

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

811 isLazy += 1 

812 

813 try: # to initialize in Python 3+ 

814 package = import_module(pack) 

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

816 if parent != pack: # assert 

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

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

819 

820 except (AttributeError, ImportError) as x: 

821 isLazy = False # failed 

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

823 

824 return package, parent 

825 

826 

827def _lazy_module(name): # overwritten by _lazy_import2 

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

829 ''' 

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

831 m = _ALL_MODS.getmodule(name) 

832 except (AttributeError, ImportError) as x: 

833 raise LazyImportError(name, cause=x) 

834 _lazy_dict[name] = m # cache 

835 return m 

836 

837 

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

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

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

841# ''' 

842# sm = dict() 

843# if force and not _dunder_ismain(_dunder_name_): 

844# nm = _tailof(_dunder_name_) 

845# _a = _ALL_MODS.getattr 

846# _m = _ALL_MODS.getmodule 

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

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

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

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

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

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

853# # like import m as s 

854# m = _m(m) 

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

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

857# pass 

858# d.update(sm) 

859# 

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

861 

862 

863# del _i, _i0 

864 

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

866 

867if _dunder_ismain(__name__): # PYCHOK no cover 

868 

869 from timeit import timeit 

870 

871 def t1(): 

872 from pygeodesy.trf import RefFrame 

873 return RefFrame 

874 

875 def t2(): 

876 return _ALL_MODS.trf.RefFrame 

877 

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

879 

880 t1 = timeit(t1, number=1000000) 

881 t2 = timeit(t2, number=1000000) 

882 v = _SPACE_.join(_Pythonarchine() + _osversion2()) 

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

884 

885# del t1, t2, timeit, v 

886 

887# python3.12 -W ignore -m pygeodesy.lazily 

888# 0.145177 import vs 0.075402 _ALL_MODS: 1.93X, Python 3.12.3 64bit arm64 macOS 14.4.1 

889 

890# python3.11 -W ignore -m pygeodesy.lazily 

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

892 

893# python3.10 -W ignore -m pygeodesy.lazily 

894# 0.378293 import vs 0.266507 _ALL_MODS: 1.42X, Python 3.10.8 64bit arm64 macOS 14.4.1 

895 

896# python2 -m pygeodesy.lazily 

897# 1.213805 import vs 0.474075 _ALL_MODS: 2.56X, Python 2.7.18 64bit arm64_x86_64 macOS 10.16 

898 

899# **) MIT License 

900# 

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

902# 

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

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

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

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

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

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

909# 

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

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

912# 

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

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

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

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

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

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

919# OTHER DEALINGS IN THE SOFTWARE.