Coverage for pygeodesy/lazily.py: 97%

198 statements  

« prev     ^ index     » next       coverage.py v7.6.1, created at 2024-11-12 16:17 -0500

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, _getPYGEODESY, _headof, \ 

34 _is_DUNDER_main, printf, _tailof, _versions 

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

36 _doesn_t_exist_, _DOT_, _DUNDER_all_, _EQUALSPACED_, \ 

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

38 _not_, _or_, _pygeodesy_abspath_, _pygeodesy_, _sys, \ 

39 _SUB_PACKAGES, _UNDER_, _version_, _intern # function 

40try: 

41 from importlib import import_module 

42except ImportError as x: # Python 2.6- 

43 raise ImportError(_COLONSPACE_(x, _versions())) 

44# import sys as _sys # from .interns 

45 

46_a0 = () # PYCHOK empty tuple 

47_asSPACED_ = ' as ' 

48_FOR_DOCS = _getPYGEODESY('_FOR_DOCS') # for epydoc ... 

49_init__all__ = _FOR_DOCS or _getPYGEODESY('_init__all__', _DUNDER_all_) == _DUNDER_all_ # PYCHOK exported 

50_lazily_ = 'lazily' 

51_PYTHON_X_DEV = getattr(_sys.flags, 'dev_mode', False) # PYCHOK Python 3.2+ 

52_unlazy = _unLazy0 = _isfrozen or _internals._MODS.sys_version_info2 < (3, 7) # PYCHOK mod.__getattr__ 3.7+ 

53_WARNINGS_X_DEV = _getPYGEODESY('WARNINGS') and (_PYTHON_X_DEV or bool(_sys.warnoptions)) # PYCHOK .props 

54 

55# @module_property[_RO?] <https://GitHub.com/jtushman/proxy_tools/> <https://discuss.Python.org/t/47379> 

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

57 

58 

59class LazyAttributeError(AttributeError): 

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

61 ''' 

62 def __init__(self, *args, **kwds): 

63 _ALL_MODS.errors._error_init(AttributeError, self, args, **kwds) 

64 

65 

66class LazyImportError(ImportError): 

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

68 ''' 

69 def __init__(self, *args, **kwds): 

70 _ALL_MODS.errors._error_init(ImportError, self, args, **kwds) 

71 

72 

73class _Dict(dict): 

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

75 ''' 

76 _name = NN 

77 

78 def __getattr__(self, attr): 

79 try: 

80 return self[attr] 

81 except KeyError: 

82 return dict.__getattr__(self, attr) 

83 

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

85# if attr in self: 

86# self[attr] = value 

87# else: 

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

89 

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

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

92 

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

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

95 ''' 

96 if name in self: # PYCHOK no cover 

97 sub = self[name] # duplicate OK 

98 if sub != mod_ and sub not in subs: 

99 t = _DOT_(self._name, name) 

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

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

102 raise AssertionError(t) 

103 else: 

104 self[name] = mod_ 

105 

106 def _NAME(self, which): 

107 self._name = _intern(_DUNDER_nameof(which).upper()) 

108 

109 

110class _NamedEnum_RO(dict): 

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

112 ''' 

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

114 

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

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

117 

118 def __getattr__(self, attr): 

119 try: 

120 return self[attr] 

121 except KeyError: 

122 t = self._DOT_(attr) 

123 raise LazyAttributeError(t, txt=_doesn_t_exist_) 

124 

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

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

127 raise LazyAttributeError(_immutable_, txt=t) 

128 

129 def enums(self): 

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

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

132 n = m.replace(_UNDER_, _DOT_) 

133 if n != m: 

134 if m.startswith(_UNDER_): 

135 continue # skip _name= ... 

136 u = m.rstrip(_UNDER_) 

137 if u != m: 

138 u = len(u) 

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

140 yield n, t 

141 

142 def fill_D(self, _D, which): 

143 # Fill C{_Dict _D}. 

144 _D._NAME(which) 

145 _a = _D.add 

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

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

148 for a in t: 

149 a, _, as_ = a.partition(_asSPACED_) 

150 if as_: # import attr as attr_ 

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

152 else: 

153 _a(a, m) 

154 return _D 

155 

156 

157def _a(*names): 

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

159 ''' 

160 return tuple(map(_intern, names)) if names else _a0 

161 

162 

163def _ALL_ATTRS(*attrs): 

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

165 ''' 

166 t = () 

167 for attr in attrs: 

168 t += tuple(map(_getattras, attr)) 

169 return t 

170 

171 

172_ALL_INIT = _a(_pygeodesy_abspath_, _version_) 

173 

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

175_ALL_LAZY = _NamedEnum_RO(_name='_ALL_LAZY', 

176 albers=_a('AlbersEqualArea', 'AlbersEqualArea2', 'AlbersEqualArea4', 

177 'AlbersEqualAreaCylindrical', 'AlbersEqualAreaNorth', 'AlbersEqualAreaSouth', 

178 'AlbersError', 'Albers7Tuple'), 

179 auxilats=_a(), # module only 

180 azimuthal=_a('AzimuthalError', 'Azimuthal7Tuple', 

181 'Equidistant', 'EquidistantExact', 'EquidistantGeodSolve', 'EquidistantKarney', 

182 'Gnomonic', 'GnomonicExact', 'GnomonicGeodSolve', 'GnomonicKarney', 

183 'LambertEqualArea', 'Orthographic', 'Stereographic', 

184 'equidistant', 'gnomonic'), 

185 basics=_a('clips', 'copysign0', 'copytype', 'halfs2', 

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

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

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

189 'issubclassof', 'itemsorted', 

190 'len2', 'map1', 'map2', 'neg', 'neg_', 

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

192 booleans=_a('BooleanFHP', 'BooleanGH', 'LatLonFHP', 'LatLonGH', 

193 'isBoolean'), 

194 cartesianBase=_a('RadiusThetaPhi3Tuple', 'rtp2xyz', 'rtp2xyz_', 'xyz2rtp', 'xyz2rtp_'), 

195 clipy=_a('ClipCS4Tuple', 'ClipFHP4Tuple', 'ClipGH4Tuple', 'ClipLB6Tuple', 'ClipSH3Tuple', 

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

197 css=_a('CassiniSoldner', 'Css', 'CSSError', 'toCss', 

198 'EasNorAziRk4Tuple', 'EasNorAziRkEqu6Tuple', 'LatLonAziRk4Tuple'), 

199 constants=_a('DIG', 'EPS', 'EPS0', 'EPS02', 'EPS1', 'EPS2', 'EPS4', 'EPS_2', 

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

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

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

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

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

205 'remainder'), 

206 datums=_a('Datum', 'Datums', 'Transform', 'Transforms'), 

207# deprecated=_a(), # module only 

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

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

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

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

212 'bearingDMS', 'clipDegrees', 'clipRadians', 'compassDMS', 'compassPoint', 

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

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

215 ecef=_a('EcefError', 'EcefFarrell21', 'EcefFarrell22', 'EcefKarney', 'EcefMatrix', 

216 'EcefSudano', 'Ecef9Tuple', 'EcefVeness', 'EcefYou'), 

217 elevations=_a('Elevation2Tuple', 'GeoidHeight2Tuple', 

218 'elevation2', 'geoidHeight2'), 

219 ellipsoidalBase=_a(), # module only 

220 ellipsoidalBaseDI=_a(), # module only 

221 ellipsoidalExact=_a(), # module only 

222 ellipsoidalGeodSolve=_a(), # module only 

223 ellipsoidalKarney=_a(), # module only 

224 ellipsoidalNvector=_a(), # module only 

225 ellipsoidalVincenty=_a('VincentyError',), # nothing else 

226 ellipsoids=_a('a_f2Tuple', 'Circle4Tuple', 'Curvature2Tuple', 

227 'Ellipsoid', 'Ellipsoid2', 'Ellipsoids', 

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

229 'a_f2b', 'a_f_2b', 'b_f2a', 'b_f_2a', 

230 'e2f', 'e22f', 

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

232 elliptic=_a('Elliptic', 'EllipticError', 'Elliptic3Tuple'), 

233 epsg=_a('Epsg', 'EPSGError'), 

234 errors=_a('AuxError', 'ClipError', 'CrossError', 'GeodesicError', 'IntersectionError', 

235 'NumPyError', 'LenError', 'LimitError', 'MGRSError', 

236 'ParseError', 'PointsError', 'RangeError', 'RhumbError', 

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

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

239 etm=_a('Etm', 'ETMError', 'ExactTransverseMercator', 

240 'parseETM5', 'toEtm8'), 

241 fmath=_a('Fdot', 'Fhorner', 'Fhypot', 'Fpolynomial', 'Fpowers', 'Fcbrt', 'Froot', 'Fsqrt', 

242 'bqrt', 'cbrt', 'cbrt2', 'euclid', 'euclid_', 

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

244 'fdot', 'fdot_', 'fdot3', 'fma', 'fmean', 'fmean_', 'fhorner', 'fidw', 'f2mul_', 

245 'fpolynomial', 'fpowers', 'fprod', 'frandoms', 'frange', 'freduce', 'fremainder', 

246 'hypot', 'hypot_', 'hypot1', 'hypot2', 'hypot2_', 

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

248 formy=_a('Radical2Tuple', 

249 'antipode', 'antipode_', 'bearing', 'bearing_', 

250 'compassAngle', 'cosineForsytheAndoyerLambert', 'cosineForsytheAndoyerLambert_', 

251 'cosineAndoyerLambert', 'cosineAndoyerLambert_', 'cosineLaw', 'cosineLaw_', 

252 'equirectangular', 'equirectangular4', 'euclidean', 'euclidean_', 

253 'excessAbc_', 'excessCagnoli_', 'excessGirard_', 'excessLHuilier_', 

254 'excessKarney', 'excessKarney_', 'excessQuad', 'excessQuad_', 

255 'flatLocal', 'flatLocal_', 'flatPolar', 'flatPolar_', 

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

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

258 'latlon2n_xyz', 'normal', 'normal_', 'n_xyz2latlon', 'n_xyz2philam', 

259 'opposing', 'opposing_', 'philam2n_xyz', 'radical2', 

260 'thomas', 'thomas_', 'vincentys', 'vincentys_'), 

261 frechet=_a('Frechet', 'FrechetDegrees', 'FrechetError', 'FrechetRadians', 

262 'FrechetCosineAndoyerLambert', 'FrechetCosineForsytheAndoyerLambert', 

263 'FrechetCosineLaw', 'FrechetDistanceTo', 'FrechetEquirectangular', 

264 'FrechetEuclidean', 'FrechetExact', 'FrechetFlatLocal', 'FrechetFlatPolar', 

265 'FrechetHaversine', 'FrechetHubeny', 'FrechetKarney', 'FrechetThomas', 

266 'FrechetVincentys', 'Frechet6Tuple', 

267 'frechet_'), 

268 fstats=_a('Fcook', 'Flinear', 'Fwelford'), 

269 fsums=_a('Fsum', 'DivMod2Tuple', 'Fsum2Tuple', 'ResidualError', 

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

271 gars=_a('Garef', 'GARSError'), 

272 geodesici=_a('Intersectool', 'Intersectool5Tuple', 'Intersect7Tuple', 

273 'Intersector', 'Intersector5Tuple', 'Middle5Tuple', 'XDict'), 

274 geodesicw=_a('Geodesic', 'GeodesicLine', 'Geodesic_WGS84'), 

275 geodesicx=_a('gx', 'gxarea', 'gxbases', 'gxline', # modules 

276 'GeodesicAreaExact', 'GeodesicExact', 'GeodesicLineExact', 'PolygonArea'), 

277 geodsolve=_a('GeodesicSolve', 'GeodesicLineSolve', 'GeodSolve12Tuple'), 

278 geohash=_a('Geohash', 'Geohashed', 'GeohashError', 'Neighbors8Dict', 'Resolutions2Tuple', 'Sizes3Tuple'), 

279 geoids=_a('GeoidError', 'GeoidG2012B', 'GeoidKarney', 'GeoidPGM', 'egmGeoidHeights', 

280 'PGMError', 'GeoidHeight5Tuple'), 

281 hausdorff=_a('Hausdorff', 'HausdorffDegrees', 'HausdorffError', 'HausdorffRadians', 

282 'HausdorffCosineAndoyerLambert', 'HausdorffCosineForsytheAndoyerLambert', 

283 'HausdorffCosineLaw', 'HausdorffDistanceTo', 'HausdorffEquirectangular', 

284 'HausdorffEuclidean', 'HausdorffExact', 'HausdorffFlatLocal', 'HausdorffFlatPolar', 

285 'HausdorffHaversine', 'HausdorffHubeny', 'HausdorffKarney', 'HausdorffThomas', 

286 'HausdorffVincentys', 'Hausdorff6Tuple', 

287 'hausdorff_', 'randomrangenerator'), 

288 heights=_a('HeightCubic', 'HeightError', 

289 'HeightIDWcosineAndoyerLambert', 'HeightIDWcosineForsytheAndoyerLambert', 

290 'HeightIDWcosineLaw', 'HeightIDWdistanceTo', 'HeightIDWequirectangular', 

291 'HeightIDWeuclidean', 'HeightIDWexact', 'HeightIDWflatLocal', 'HeightIDWflatPolar', 

292 'HeightIDWhaversine', 'HeightIDWhubeny', 'HeightIDWkarney', 'HeightIDWthomas', 

293 'HeightIDWvincentys', 'HeightLinear', 'HeightLSQBiSpline', 'HeightSmoothBiSpline'), 

294 internals=_internals.__all__, 

295 interns=_interns.__all__, 

296 iters=_a('LatLon2PsxyIter', 'PointsIter', 'points2', 

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

298 karney=_a('Area3Tuple', 'Caps', 'Direct9Tuple', 'GDict', 'Inverse10Tuple', 'Rhumb8Tuple'), 

299 ktm=_a('KTMError', 'KTransverseMercator'), 

300 latlonBase=_a(), # module only 

301 lazily=_a('LazyAttributeError', 'LazyImportError', 'isLazy'), 

302 lcc=_a('Conic', 'Conics', 'Lcc', 'LCCError', 'toLcc'), 

303 ltp=_a('Attitude', 'AttitudeError', 'ChLV', 'ChLVa', 'ChLVe', 'Frustum', 

304 'LocalCartesian', 'LocalError', 'Ltp', 'tyr3d'), 

305 ltpTuples=_a('Aer', 'Aer4Tuple', 'Attitude4Tuple', 

306 'ChLVEN2Tuple', 'ChLV9Tuple', 'ChLVYX2Tuple', 'ChLVyx2Tuple', 

307 'Enu', 'Enu4Tuple', 'Footprint5Tuple', 'Local9Tuple', 'Los', 

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

309 mgrs=_a('Mgrs', 'parseMGRS', 'toMgrs', 'Mgrs4Tuple', 'Mgrs6Tuple'), 

310 named=_a('ADict', 

311 'callername', 'classname', 'classnaming', 'modulename', 

312 'nameof', 'notImplemented', 'notOverloaded'), 

313 namedTuples=_a('Bearing2Tuple', 'Bounds2Tuple', 'Bounds4Tuple', 

314 'Destination2Tuple', 'Destination3Tuple', 

315 'Distance2Tuple', 'Distance3Tuple', 'Distance4Tuple', 

316 'EasNor2Tuple', 'EasNor3Tuple', 'Forward4Tuple', 'Intersection3Tuple', 

317 'LatLon2Tuple', 'LatLon3Tuple', 'LatLon4Tuple', 

318 'LatLonDatum3Tuple', 'LatLonDatum5Tuple', 

319 'LatLonPrec3Tuple', 'LatLonPrec5Tuple', 

320 'NearestOn2Tuple', 'NearestOn3Tuple', 'NearestOn6Tuple', 'NearestOn8Tuple', 

321 'PhiLam2Tuple', 'PhiLam3Tuple', 'PhiLam4Tuple', 'Point3Tuple', 'Points2Tuple', 

322 'Reverse4Tuple', 'Triangle7Tuple', 'Triangle8Tuple', 'Trilaterate5Tuple', 

323 'UtmUps2Tuple', 'UtmUps5Tuple', 'UtmUps8Tuple', 'UtmUpsLatLon5Tuple', 

324 'Vector2Tuple', 'Vector3Tuple', 'Vector4Tuple'), 

325 nvectorBase=_a('NorthPole', 'SouthPole'), 

326 osgr=_a('Osgr', 'OSGRError', 'parseOSGR', 'toOsgr'), 

327 points=_a('LatLon_', 'LatLon2psxy', 'Numpy2LatLon', 'Shape2Tuple', 'Tuple2LatLon', 

328 'areaOf', 'boundsOf', 'centroidOf', 'fractional', 

329 'isclockwise', 'isconvex', 'isconvex_', 'isenclosedBy', 'ispolar', 

330 'luneOf', 'nearestOn5', 'perimeterOf', 'quadOf'), 

331 props=_a('Property', 'Property_RO', 'property_doc_', 

332 'property_RO', 'property_ROnce', 'property_ROver', 

333 'deprecated_class', 'deprecated_function', 'deprecated_method', 

334 'deprecated_Property_RO', 'deprecated_property_RO', 'DeprecationWarnings'), 

335 resections=_a('Collins5Tuple', 'ResectionError', 'Survey3Tuple', 'Tienstra7Tuple', 

336 'TriAngle5Tuple', 'TriSide2Tuple', 'TriSide4Tuple', 

337 'cassini', 'collins5', 'pierlot', 'pierlotx', 'tienstra7', 

338 'snellius3', 'wildberger3', 

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

340 rhumb=_a(), # module only 

341 rhumb_aux_=_a('RhumbAux', 'RhumbLineAux'), 

342 rhumb_ekx=_a('Rhumb', 'RhumbLine'), 

343 rhumb_solve=_a('RhumbSolve', 'RhumbLineSolve', 'RhumbSolve7Tuple'), 

344 sphericalBase=_a(), # module only 

345 sphericalNvector=_a(), # module only 

346 sphericalTrigonometry=_a(), # module only 

347 simplify=_a('simplify1', 'simplifyRDP', 'simplifyRDPm', 'simplifyRW', 'simplifyVW', 'simplifyVWm'), 

348 solveBase=_a(), # module only 

349 streprs=_a('anstr', 'attrs', 'enstr2', 'fstr', 'fstrzs', 'hstr', 'instr', 

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

351 trf=_a('RefFrame', 'RefFrames', 'TransformXform', 'TRFXform', 'TRFXform7Tuple', 

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

353 triaxials=_a('BetaOmega2Tuple', 'BetaOmega3Tuple', 'Jacobi2Tuple', 

354 'JacobiConformal', 'JacobiConformalSpherical', 

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

356 units=_a('Azimuth', 'Band', 'Bearing', 'Bearing_', 'Bool', 

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

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

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

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

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

362 'Radius_', 'Scalar', 'Scalar_', 'Zone'), 

363 unitsBase=_a('Float', 'Int', 'Radius', 'Str'), 

364 ups=_a('Ups', 'UPSError', 'parseUPS5', 'toUps8', 'upsZoneBand5'), 

365 utily=_a('acos1', 'acre2ha', 'acre2m2', 'asin1', 'atan1', 'atan1d', 'atan2b', 'atan2d', 

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

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

368# 'degrees2grades as degrees2gons', 

369 'fathom2m', 'ft2m', 'furlong2m', 

370 'grades', 'grades400', 'grades2degrees', 'grades2radians', 

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

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

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

374 'radians', 'radiansPI', 'radiansPI2', 'radiansPI_2', 'radians2m', 

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

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

377 'unroll180', 'unrollPI', 

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

379 'yard2m'), 

380 utm=_a('Utm', 'UTMError', 'parseUTM5', 'toUtm8', 'utmZoneBand5'), 

381 utmups=_a('UtmUps', 'UTMUPSError', 'parseUTMUPS5', 'toUtmUps8', 

382 'utmupsValidate', 'utmupsValidateOK', 'utmupsZoneBand5'), 

383 utmupsBase=_a(), # module only 

384 vector2d=_a('Circin6Tuple', 'Circum3Tuple', 'Circum4Tuple', 'Meeus2Tuple', 'Radii11Tuple', 'Soddy4Tuple', 'Triaxum5Tuple', 

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

386 vector3d=_a('Vector3d', 'intersection3d3', 'iscolinearWith', 'nearestOn', 'nearestOn6', 'parse3d', 

387 'trilaterate3d2'), 

388 vector3dBase=_a(), # module only 

389 webmercator=_a('Wm', 'WebMercatorError', 'parseWM', 'toWm', 'EasNorRadius3Tuple'), 

390 wgrs=_a('Georef', 'WGRSError'),) 

391 

392_ALL_DEPRECATED = _NamedEnum_RO(_name='_ALL_DEPRECATED', 

393 deprecated=_a('bases', 'datum', 'nvector', # DEPRECATED modules and ... 

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

395 deprecated_bases=_a('LatLonHeightBase', 'points2'), 

396 deprecated_classes=_a('ClipCS3Tuple', 'EasNorExact4Tuple', 'EcefCartesian', 'Fn_rt', 

397 'HeightIDW', 'HeightIDW2', 'HeightIDW3', 'Helmert7Tuple', 

398 'Lam_', 'LatLonExact4Tuple', 'NearestOn4Tuple', 'Ned3Tuple', 

399 'Phi_', 'RefFrameError', 'Rhumb7Tuple', 'RhumbOrder2Tuple', 

400 'Transform7Tuple', 'TriAngle4Tuple', 'UtmUps4Tuple', 'XDist'), 

401 deprecated_consterns=_a('EPS1_2', 'MANTIS', 'OK'), 

402 deprecated_datum=_a('Curvature2Tuple', 'Datum', 'Ellipsoid', 'Transform', # assert 

403 'Datums', 'Ellipsoids', 'Transforms', 

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

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

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

407 'decodeEPSG2', 'encodeEPSG', 'enStr2', 'equirectangular_', 'equirectangular3', 

408 'excessAbc', 'excessGirard', 'excessLHuilier', 

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

410 'hypot3', 'inStr', 'isenclosedby', 'istuplist', 

411 'joined', 'joined_', 'nearestOn3', 'nearestOn4', 

412 'parseUTM', 'perimeterof', 'polygon', 'scalar', 'simplify2', 

413 'tienstra', 'toUtm', 'triAngle4', 

414 'unsign0', 'unStr', 'utmZoneBand2'), 

415 deprecated_nvector=_a('LatLonNvectorBase', 'Nvector', 'sumOf', 'NorthPole', 'SouthPole'),) 

416 

417 

418class _ALL_MODS(_internals._MODS_Base): 

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

420 ''' 

421 def __getattr__(self, name): 

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

423 

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

425 

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

427 

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

429 ''' 

430 try: 

431 v = _lazy_dict[name] # package.__dict__ 

432 except KeyError: 

433 v = _lazy_module(name) # package.__getattr__ 

434 if _tailof(_DUNDER_nameof(v)) != name: 

435 try: 

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

437 except AttributeError: 

438 pass # XXX LazyAttributeError? 

439 return v 

440 

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

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

443 

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

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

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

447 

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

449 

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

451 

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

453 ''' 

454 v = self.getmodule(name) 

455 if attr_dflt: 

456 v = getattr(v, *attr_dflt) 

457 return v 

458 

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

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

461 

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

463 

464 @return: The C{pygeodesy} module. 

465 

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

467 ''' 

468 if _headof(name) != parent and not _is_DUNDER_main(name): 

469 name = _DOT_(parent, name) 

470 try: 

471 return _sys.modules[name] 

472 except KeyError: 

473 return _getmodule(name, parent) 

474 

475 def imported(self, name): 

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

477 ''' 

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

479 

480 def into(self, **mod_DUNDER_name): 

481 '''Lazily import module C{mod} into module C{DUNDER_name} 

482 and set C{DUNDER_name._mod} to module C{mod}, I{once}. 

483 ''' 

484 class _Into(object): 

485 

486 def __getattr__(unused, name): 

487 mod, dun = self.errors._xkwds_item2(mod_DUNDER_name) 

488 _mod = _UNDER_(NN, mod) 

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

490 i = _getattribute(d, _mod, dun) 

491 assert isinstance(i, _Into) 

492 m = self.getmodule(mod) 

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

494 return getattr(m, name) 

495 

496 return _Into() 

497 

498# @_Property_RO 

499# def _isBoolean(self): 

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

501# ''' 

502# return self.booleans.isBoolean 

503 

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

505 '''Yield the modules imported so far. 

506 ''' 

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

508 if _headof(n) == _pygeodesy_: 

509 yield n, m 

510 

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

512 

513__all__ = _ALL_LAZY.lazily 

514__version__ = '24.11.09' 

515 

516 

517def _ALL_OTHER(*objs): 

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

519 ''' 

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

521 n = _tailof(_DUNDER_nameof(o)) 

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

523 return getattr(_interns, i, n) 

524 

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

526 

527 

528if _FOR_DOCS: # PYCHOK no cover 

529 _ALL_DOCS = _ALL_OTHER 

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

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

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

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

534 # too much internal documentation. 

535else: 

536 def _ALL_DOCS(*unused): 

537 return () 

538 

539 

540def _all_deprecates(): 

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

542 ''' 

543 _D = _ALL_DEPRECATES 

544 if not _D: 

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

546 return _D 

547 

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

549 

550 

551def _all_imports(): 

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

553 ''' 

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

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

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

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

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

559 _D = _ALL_IMPORTS 

560 if not _D: 

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

562 return _D 

563 

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

565 

566 

567def _all_missing2(_all_): 

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

569 ''' 

570 def _diff(one, two): 

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

572 

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

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

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

576 (_DOT_(_pygeodesy_, _DUNDER_all_), _diff(_alzy.keys(), _all_))) 

577 

578 

579def _getattras(attr_as): # test/testDeprecated 

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

581 ''' 

582 a_, _, as_ = attr_as.partition(_asSPACED_) 

583 return as_ or a_.rstrip(_DOT_) 

584 

585 

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

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

588 ''' 

589 try: 

590 return getattr(m, name) 

591 except AttributeError: 

592 name = _DOT_(mod, name) 

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

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

595 

596 

597def _getmodule(name, *parent): 

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

599 ''' 

600 try: 

601 return import_module(name, parent) 

602 except ImportError: 

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

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

605 

606 

607# def _lazy_attributes(DUNDER_name): 

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

609# on lazily imported modules and sub-modules. 

610# ''' 

611# if _unlazy: 

612# raise AssertionError(_COMMASPACE_(DUNDER_name, _not_(_DEPRECATED_))) 

613# 

614# def _getattr(attr, *dflt): 

615# try: # a module name 

616# return _ALL_MODS.getmodule(attr) 

617# except (AttributeError, ImportError): 

618# return _ALL_MODS.getattr(DUNDER_name, attr, *dflt) 

619# 

620# return _getattr 

621 

622 

623_lazy_dict = {} # PYCHOK overwritten by _lazy_import2 

624 

625 

626def _lazy_import2(pack): # MCCABE 14 

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

628 

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

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

631 

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

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

634 C{package.__getattr__}. 

635 

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

637 invalid or does not exist. 

638 

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

640 an import failed. 

641 

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

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

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

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

646 causing a C{ModuleNotFoundError}. 

647 

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

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

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

651 ''' 

652 _DOT_ = _interns._DOT_ 

653 _SPACE_ = _interns._SPACE_ 

654 

655 if pack != _pygeodesy_ or _unlazy: # Python 3.7+ # PYCHOK no cover 

656 t = _DOT_(pack, _DUNDER_nameof(_lazy_import2)) 

657 raise LazyImportError(_no_(t), txt=_versions()) 

658 

659 package, parent = _lazy_init2(pack) # _pygeodesy_ 

660 

661 _DUNDER_package_ = '__package__' 

662 _lazily_imported_ = _SPACE_(_HASH_, _lazily_, 'imported', parent) 

663 

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

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

666 imports = _all_imports() 

667 deprecates = _all_deprecates() 

668 

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

670 # only called once for each undefined pygeodesy attribute 

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

672 if mod: 

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

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

675 # note in the _lazy_import2.__doc__ above). 

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

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

678 else: # from mod import name 

679 attr = name 

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

681 t = getattr(v, _DUNDER_package_, None) 

682 if t not in sub_packages: # invalid module package 

683 raise LazyImportError(_DOT_(mod, _DUNDER_package_), t) 

684 if attr: # get mod.attr 

685 v = _getattribute(v, attr, mod) 

686 

687 elif name in (_DUNDER_all_,): # XXX _DUNDER_dir_, _DUNDER_members_? 

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

689 else: # PYCHOK no cover 

690 t = _no_(_module_, _or_, _attribute_) 

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

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

693 

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

695 if isLazy > 1: 

696 t = _DOT_(_lazily_imported_, name) 

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

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

699 if isLazy > 2: 

700 try: # see C{_caller3} 

701 _, f, s = _caller3(2) 

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

703 except ValueError: 

704 pass 

705 printf(t) # XXX print 

706 

707 return v # __getattr__ 

708 

709 global _lazy_dict, _lazy_module 

710 _lazy_dict = package.__dict__ 

711 _lazy_module = __getattr__ 

712 

713 return package, __getattr__ # _lazy_import2 

714 

715 

716# def _lazy_import_all(DUNDER_name): 

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

718# of all items, see .deprecated.__init__ 

719# ''' 

720# if _unlazy: 

721# raise AssertionError(_COMMASPACE_(DUNDER_name, _not_(_DEPRECATED_))) 

722# 

723# _getattr = _lazy_attributes(DUNDER_name) # __name__.__getattr__ 

724# _import_start = _lazy_import_star(DUNDER_name, ALL_=_ALL_IMPORTS) 

725# 

726# def _import_all(attr, *dflt): 

727# return _import_star(DUNDER_name) if attr == _DUNDER_all_ else \ 

728# _getattr(attr, *dflt) 

729# 

730# return _import_all 

731 

732 

733def _lazy_import_as(DUNDER_name): 

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

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

736 lazily exported by C{__name__}. 

737 ''' 

738 if _unlazy: 

739 return None 

740 

741 def _import_as(mod): 

742 try: 

743 return _ALL_MODS.getmodule(_DOT_(DUNDER_name, mod)) 

744 except ImportError: 

745 return _lazy_module(mod) 

746 

747 return _import_as 

748 

749 

750# def _lazy_import_star(DUNDER_name, ALL_=_ALL_DEPRECATES): 

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

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

753# ''' 

754# if _unlazy: 

755# raise AssertionError(_COMMASPACE_(DUNDER_name, _not_(_DEPRECATED_))) 

756# 

757# def _import_star(_into_): 

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

759# ''' 

760# d = dict() 

761# nm = _tailof(DUNDER_name) 

762# _g = _ALL_MODS.getattr # pygeodesy.__getattr__ 

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

764# if _headof(m) == nm: 

765# try: 

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

767# except (AttributeError, ImportError): 

768# pass 

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

770# return d.keys() # imported names 

771# 

772# return _import_star 

773 

774 

775def _lazy_init2(pack): 

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

777 

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

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

780 

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

782 for easy reference within itself and its name aka the 

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

784 

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

786 an import failed or the package name is 

787 invalid or does not exist. 

788 

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

790 ''' 

791 global isLazy, _unLazy0 

792 

793 z = _getPYGEODESY('LAZY_IMPORT', None) 

794 if z is None: # not set, but ... 

795 isLazy = 1 # ... default on 3.7+ 

796 else: 

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

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

799 

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

801 

802 if isLazy < 1: # invalid, not enabled 

803 e = _internals._PYGEODESY('LAZY_IMPORT') 

804 raise LazyImportError(e, repr(z), txt_not_='enabled') 

805 if _sys.flags.verbose: # PYCHOK no cover 

806 isLazy += 1 

807 

808 try: # to initialize in Python 3+ 

809 package = import_module(pack) 

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

811 if parent != pack: # assert 

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

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

814 

815 except (AttributeError, ImportError) as x: 

816 isLazy = False # failed 

817 z = _DUNDER_nameof(_lazy_init2) 

818 raise LazyImportError(z, pack, cause=x) 

819 

820 return package, parent 

821 

822 

823def _lazy_module(name): # overwritten by _lazy_import2 

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

825 ''' 

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

827 m = _ALL_MODS.getmodule(name) 

828 except (AttributeError, ImportError) as x: 

829 raise LazyImportError(name, cause=x) 

830 _lazy_dict[name] = m # cache 

831 return m 

832 

833 

834# def _lazy_subs(DUNDER_name, force=_FOR_DOCS, over=False): 

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

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

837# ''' 

838# sm = dict() 

839# if force and not _is_DUNDER_main(DUNDER_name): 

840# nm = _tailof(DUNDER_name) 

841# _a = _ALL_MODS.getattr 

842# _m = _ALL_MODS.getmodule 

843# d = _a(DUNDER_name, _DUNDER_dict_, {}) 

844# for n in _a(DUNDER_name, _DUNDER_all_, ()): 

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

846# m = _a(DUNDER_name, n).__module__ 

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

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

849# # like import m as s 

850# m = _m(m) 

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

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

853# pass 

854# d.update(sm) 

855# 

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

857 

858# del _a, _a0 

859 

860if _is_DUNDER_main(__name__): # PYCHOK no cover 

861 

862 def _main(): 

863 from timeit import timeit 

864 

865 def t1(): 

866 from pygeodesy.trf import RefFrame 

867 return RefFrame 

868 

869 def t2(): 

870 return _ALL_MODS.trf.RefFrame 

871 

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

873 

874 t1 = timeit(t1, number=1000000) 

875 t2 = timeit(t2, number=1000000) 

876 A = _DUNDER_nameof(_ALL_MODS.__class__) 

877 v = _versions() 

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

879 

880 _main() 

881 

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

883# 0.106602 import vs 0.078136 _ALL_MODS: 1.36X, pygeodesy 24.10.24 Python 3.13.0 64bit arm64 macOS 14.6.1 

884 

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

886# 0.138844 import vs 0.080458 _ALL_MODS: 1.73X, pygeodesy 24.10.24 Python 3.12.7 64bit arm64 macOS 14.6.1 

887 

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

889# 0.387520 import vs 0.254229 _ALL_MODS: 1.52X, pygeodesy 24.10.24 Python 3.11.5 64bit arm64 macOS 14.6.1 

890 

891# % python3.10 -W ignore -m pygeodesy.lazily 

892# 0.371269 import vs 0.272897 _ALL_MODS: 1.36X, pygeodesy 24.10.24 Python 3.10.8 64bit arm64 macOS 14.6.1 

893 

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

895# 0.555572 import vs 0.370304 _ALL_MODS: 1.50X, pygeodesy 24.10.24 Python 3.8.10 64bit arm64_x86_64 macOS 10.16 

896 

897# % python2 -m pygeodesy.lazily 

898# 1.160292 import vs 0.490279 _ALL_MODS: 2.37X, pygeodesy 24.10.24 Python 2.7.18 64bit arm64_x86_64 macOS 10.16 

899 

900# **) MIT License 

901# 

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

903# 

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

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

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

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

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

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

910# 

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

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

913# 

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

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

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

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

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

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

920# OTHER DEALINGS IN THE SOFTWARE.