1

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

3

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

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

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

7

8 C{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

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

11 I{and newer}.

12

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

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

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

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

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

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

19 and 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

30 from 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

33 from pygeodesy.internals import _caller3, _envPYGEODESY, _headof, printf, _tailof, \

34 typename, _versions # _getenv, _PYGEODESY_ENV, \

35# _MODS_Base, _MODS.sys_version_info2

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

37 _DMAIN_, _doesn_t_exist_, _DOT_, _EQUALSPACED_, _from_, \

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

39 _pygeodesy_, _pygeodesy_abspath_, _SPACE_, _SUB_PACKAGES, \

40 _or_, _UNDER_, _version_, _sys, _intern # function, _1_

41 try:

42 from importlib import import_module

43 except ImportError as x: # Python 2.6-

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

45# import sys as _sys # from .interns

46

47_a0 = () # PYCHOK empty tuple

48_asSPACED_ = ' as '

49_FOR_DOCS = _envPYGEODESY('FOR_DOCS') # for epydoc ...

50_imported_ = 'imported'

51_init__all__ = _FOR_DOCS or _envPYGEODESY('_init__all__', _DALL_) == _DALL_ # PYCHOK exported

52_lazily_ = 'lazily'

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

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

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

56

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

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

59

60

61 class LazyAttributeError(AttributeError):

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

63 '''

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

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

66

67

68 class LazyImportError(ImportError):

69 '''Raised if C{lazy import} is not supported, disabled or failed.

70 '''

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

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

73

74

75 class _Dict(dict):

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

77 '''

78 _name = NN

79

80 def __getattr__(self, attr):

81 try:

82 return self[attr]

83 except KeyError:

84 return dict.__getattr__(self, attr)

85

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

87# if attr in self:

88# self[attr] = value

89# else:

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

91

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

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

94

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

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

97 '''

98 try:

99 sub = self[name] # duplicate OK

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

101 t = _DOT_(self._name, name)

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

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

104 raise AssertionError(t)

105 except KeyError:

106 self[name] = mod_

107

108 def _NAME(self, which):

109 self._name = _intern(typename(which).upper())

110

111

112 class _NamedEnum_RO(dict):

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

114 '''

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

116

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

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

119

120 def __getattr__(self, attr):

121 try:

122 return self[attr]

123 except KeyError:

124 t = self._DOT_(attr)

125 raise LazyAttributeError(t, txt=_doesn_t_exist_)

126

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

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

129 raise LazyAttributeError(_immutable_, txt=t)

130

131 def enums(self):

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

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

134 n = m.replace(_UNDER_, _DOT_)

135 if n != m:

136 if m.startswith(_UNDER_):

137 continue # skip _name= ...

138 u = m.rstrip(_UNDER_)

139 if u != m:

140 u = len(u)

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

142 yield n, t

143

144 def fill_D(self, _D, which):

145 # Fill C{_Dict _D}.

146 _D._NAME(which)

147 _a = _D.add

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

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

150 for a in t:

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

152 if as_: # import attr as attr_

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

154 else:

155 _a(a, m)

156 return _D

157

158

159 def _a(*names):

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

161 '''

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

163

164

165 def _ALL_ATTRS(*attrs):

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

167 '''

168 t = ()

169 for attr in attrs:

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

171 return t

172

173

174_ALL_INIT = _a(_pygeodesy_abspath_, _version_)

175

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

177_ALL_LAZY = _NamedEnum_RO(_name='_ALL_LAZY',

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

179 'AlbersEqualAreaCylindrical', 'AlbersEqualAreaNorth', 'AlbersEqualAreaSouth',

180 'AlbersError', 'Albers7Tuple'),

181 auxilats=_a(), # module only

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

183 'Equidistant', 'EquidistantExact', 'EquidistantGeodSolve', 'EquidistantKarney',

184 'Gnomonic', 'GnomonicExact', 'GnomonicGeodSolve', 'GnomonicKarney',

185 'LambertEqualArea', 'Orthographic', 'Stereographic',

186 'equidistant', 'gnomonic'),

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

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

189 'isidentifier', 'isinstanceof', 'isint', 'isiterable', 'isiterablen', 'isiterabletype',

190 'iskeyword', 'isLatLon', 'islistuple', 'isNvector', 'isodd',

191 'isscalar', 'issequence', 'isstr', 'issubclassof', 'itemsorted',

192 'len2', 'map1', 'map2', 'max2', 'min2', 'neg', 'neg_',

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

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

195 'isBoolean'),

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

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

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

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

200 'EasNorAziRk4Tuple', 'EasNorAziRkEqu6Tuple', 'LatLonAziRk4Tuple'),

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

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

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

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

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

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

207 'remainder'),

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

209# deprecated=_a(), # module only

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

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

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

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

214 'bearingDMS', 'clipDegrees', 'clipRadians', 'compassDMS', 'compassPoint',

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

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

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

218 'EcefSudano', 'Ecef9Tuple', 'EcefVeness', 'EcefYou'),

219 ecefLocals=_a(), # module only

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

221 'elevation2', 'geoidHeight2'),

222 ellipsoidalBase=_a(), # module only

223 ellipsoidalBaseDI=_a(), # module only

224 ellipsoidalExact=_a(), # module only

225 ellipsoidalGeodSolve=_a(), # module only

226 ellipsoidalKarney=_a(), # module only

227 ellipsoidalNvector=_a(), # module only

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

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

230 'Ellipsoid', 'Ellipsoid2', 'Ellipsoids',

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

232 'a_f2b', 'a_f_2b', 'b_f2a', 'b_f_2a',

233 'e2f', 'e22f',

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

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

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

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

238 'NumPyError', 'LenError', 'LimitError', 'MGRSError',

239 'ParseError', 'PointsError', 'RangeError', 'RhumbError',

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

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

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

243 'parseETM5', 'toEtm8'),

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

245 'bqrt', 'cbrt', 'cbrt2', 'euclid', 'euclid_',

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

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

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

249 'hypot', 'hypot_', 'hypot1', 'hypot2', 'hypot2_',

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

251 formy=_a('Radical2Tuple',

252 'angle2chord', 'antipode', 'antipode_', 'bearing', 'bearing_',

253 'chord2angle', 'compassAngle', 'cosineLaw', 'cosineLaw_',

254 'equirectangular', 'equirectangular4', 'euclidean', 'euclidean_',

255 'excessAbc_', 'excessCagnoli_', 'excessGirard_', 'excessLHuilier_',

256 'excessKarney', 'excessKarney_', 'excessQuad', 'excessQuad_',

257 'flatLocal', 'flatLocal_', 'flatPolar', 'flatPolar_',

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

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

260 'normal', 'normal_', 'opposing', 'opposing_', 'radical2',

261 'thomas', 'thomas_', 'vincentys', 'vincentys_'),

262 frechet=_a('Frechet', 'FrechetDegrees', 'FrechetError', 'FrechetRadians', 'FrechetCosineLaw',

263 'FrechetDistanceTo', 'FrechetEquirectangular', 'FrechetEuclidean', 'FrechetExact',

264 'FrechetFlatLocal', 'FrechetFlatPolar', 'FrechetHaversine', 'FrechetHubeny', 'FrechetKarney',

265 'FrechetThomas', 'FrechetVincentys', 'Frechet6Tuple',

266 'frechet_'),

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

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

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

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

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

272 'Intersector', 'Intersector5Tuple', 'Middle5Tuple', 'XDict'),

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

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

275 'GeodesicAreaExact', 'GeodesicExact', 'GeodesicLineExact', 'PolygonArea'),

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

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

278 geoids=_a('GeoidError', 'GeoidEGM96', 'GeoidG2012B', 'GeoidKarney', 'GeoidPGM', 'egmGeoidHeights',

279 'PGMError', 'GeoidHeight5Tuple'),

280 hausdorff=_a('Hausdorff', 'HausdorffDegrees', 'HausdorffError', 'HausdorffRadians', 'HausdorffCosineLaw',

281 'HausdorffDistanceTo', 'HausdorffEquirectangular', 'HausdorffEuclidean', 'HausdorffExact',

282 'HausdorffFlatLocal', 'HausdorffFlatPolar', 'HausdorffHaversine', 'HausdorffHubeny',

283 'HausdorffKarney', 'HausdorffThomas', 'HausdorffVincentys', 'Hausdorff6Tuple',

284 'hausdorff_', 'randomrangenerator'),

285 heights=_a('HeightCubic', 'HeightError', 'HeightIDWcosineLaw', 'HeightIDWdistanceTo',

286 'HeightIDWequirectangular', 'HeightIDWeuclidean', 'HeightIDWexact', 'HeightIDWflatLocal',

287 'HeightIDWflatPolar', 'HeightIDWhaversine', 'HeightIDWhubeny', 'HeightIDWkarney', 'HeightIDWthomas',

288 'HeightIDWvincentys', 'HeightLinear', 'HeightLSQBiSpline', 'HeightSmoothBiSpline'),

289 internals=_internals.__all__,

290 interns=_interns.__all__,

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

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

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

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

295 latlonBase=_a('latlon2n_xyz', 'philam2n_xyz'),

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

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

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

299 'LocalCartesian', 'LocalError', 'Ltp', 'tyr3d'),

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

301 'ChLVEN2Tuple', 'ChLV9Tuple', 'ChLVYX2Tuple', 'ChLVyx2Tuple',

302 'Enu', 'Enu4Tuple', 'Footprint5Tuple', 'Local9Tuple', 'Los',

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

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

305 named=_a('ADict',

306 'callername', 'classname', 'classnaming', 'modulename',

307 'nameof', 'notImplemented', 'notOverloaded'),

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

309 'Destination2Tuple', 'Destination3Tuple',

310 'Distance2Tuple', 'Distance3Tuple', 'Distance4Tuple',

311 'EasNor2Tuple', 'EasNor3Tuple', 'Forward4Tuple', 'Intersection3Tuple',

312 'LatLon2Tuple', 'LatLon3Tuple', 'LatLon4Tuple',

313 'LatLonDatum3Tuple', 'LatLonDatum5Tuple',

314 'LatLonPrec3Tuple', 'LatLonPrec5Tuple',

315 'NearestOn2Tuple', 'NearestOn3Tuple', 'NearestOn6Tuple', 'NearestOn8Tuple',

316 'PhiLam2Tuple', 'PhiLam3Tuple', 'PhiLam4Tuple', 'Point3Tuple', 'Points2Tuple',

317 'Reverse4Tuple', 'Triangle7Tuple', 'Triangle8Tuple', 'Trilaterate5Tuple',

318 'UtmUps2Tuple', 'UtmUps5Tuple', 'UtmUps8Tuple', 'UtmUpsLatLon5Tuple',

319 'Vector2Tuple', 'Vector3Tuple', 'Vector4Tuple'),

320 nvectorBase=_a('NorthPole', 'SouthPole', 'n_xyz2latlon', 'n_xyz2philam'),

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

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

323 'areaOf', 'boundsOf', 'centroidOf', 'fractional',

324 'isclockwise', 'isconvex', 'isconvex_', 'isenclosedBy', 'ispolar',

325 'luneOf', 'nearestOn5', 'perimeterOf', 'quadOf'),

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

327 'property_RO', 'property_ROnce', 'property_ROver',

328 'deprecated_class', 'deprecated_function', 'deprecated_method',

329 'deprecated_Property_RO', 'deprecated_property_RO', 'DeprecationWarnings'),

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

331 'TriAngle5Tuple', 'TriSide2Tuple', 'TriSide4Tuple',

332 'cassini', 'collins5', 'pierlot', 'pierlotx', 'tienstra7',

333 'snellius3', 'wildberger3',

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

335 rhumb=_a(), # module only

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

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

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

339 sphericalBase=_a(), # module only

340 sphericalNvector=_a(), # module only

341 sphericalTrigonometry=_a(), # module only

342 simplify=_a('simplify1', 'simplifyRDP', 'simplifyRW', 'simplifyVW'),

343 solveBase=_a(), # module only

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

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

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

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

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

349 'JacobiConformal', 'JacobiConformalSpherical',

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

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

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

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

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

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

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

357 'Radius_', 'Scalar', 'Scalar_', 'Zone'),

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

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

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

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

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

363 'fathom2m', 'ft2m', 'furlong2m', # 'degrees2grades as degrees2gons',

364 'grades', 'grades400', 'grades2degrees', 'grades2radians',

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

366 'ha2acre', 'ha2m2', 'hav', 'km2m',

367 'm2acre', 'm2chain', 'm2degrees', 'm2fathom', 'm2ft', 'm2furlong',

368 'm2ha', 'm2km', 'm2NM', 'm2radians', 'm2SM', 'm2toise', 'm2yard',

369 'NM2m', 'radians', 'radiansPI', 'radiansPI2', 'radiansPI_2', 'radians2m',

370 'sincos2', 'SinCos2', 'sincos2_', 'sincos2d', 'sincos2d_', 'sincostan3', 'sincostan3d', 'SM2m',

371 'tan', 'tan_', 'tand', 'tand_', 'tan_2', 'tanPI_2_2', 'toise2m', 'truncate',

372 'unroll180', 'unrollPI',

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

374 'yard2m'),

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

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

377 'utmupsValidate', 'utmupsValidateOK', 'utmupsZoneBand5'),

378 utmupsBase=_a(), # module only

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

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

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

382 'trilaterate3d2'),

383 vector3dBase=_a(), # module only

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

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

386

387_ALL_DEPRECATED = _NamedEnum_RO(_name='_ALL_DEPRECATED',

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

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

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

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

392 'FrechetCosineAndoyerLambert', 'FrechetCosineForsytheAndoyerLambert',

393 'HausdorffCosineAndoyerLambert', 'HausdorffCosineForsytheAndoyerLambert',

394 'HeightIDW', 'HeightIDW2', 'HeightIDW3', 'HeightIDWcosineAndoyerLambert',

395 'HeightIDWcosineForsytheAndoyerLambert', 'Helmert7Tuple',

396 'Lam_', 'LatLonExact4Tuple', 'NearestOn4Tuple', 'Ned3Tuple',

397 'Phi_', 'RefFrameError', 'Rhumb7Tuple', 'RhumbOrder2Tuple',

398 'Transform7Tuple', 'TriAngle4Tuple', 'UtmUps4Tuple', 'XDist'),

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

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

401 'Datums', 'Ellipsoids', 'Transforms',

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

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

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

405 'cosineAndoyerLambert', 'cosineAndoyerLambert_',

406 'cosineForsytheAndoyerLambert', 'cosineForsytheAndoyerLambert_',

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',

413 'scalar', 'simplify2', 'simplifyRDPm', 'simplifyVWm',

414 'tienstra', 'toUtm', 'triAngle4',

415 'unsign0', 'unStr', 'utmZoneBand2'),

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

417

418

419 class _ALL_MODS(_internals._MODS_Base):

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

421 '''

422 def __getattr__(self, name):

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

424

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

426

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

428

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

430 '''

431 try:

432 v = _lazy_dict[name] # package.__dict__

433 except KeyError:

434 v = _lazy_module(name) # package.__getattr__

435 if _tailof(typename(v)) != name:

436 try:

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

438 except AttributeError:

439 pass # XXX LazyAttributeError?

440 return v

441

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

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

444

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

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

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

448

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

450

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

452

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

454 '''

455 v = self.getmodule(name)

456 if attr_dflt:

457 v = getattr(v, *attr_dflt)

458 return v

459

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

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

462

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

464

465 @return: The C{pygeodesy} module.

466

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

468 '''

469 if _headof(name) != parent and name != _DMAIN_:

470 name = _DOT_(parent, name)

471 try:

472 return _sys.modules[name]

473 except KeyError:

474 return _getmodule(name, parent)

475

476 def imported(self, name):

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

478 '''

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

480

481 def into(self, **mod_DNAME):

482 '''Deferred import of module C{mod} into module C{_DNAME_}

483 and overwrite C{_DNAME_._mod} to module C{mod}, I{once}

484 at the first access of an attribute of module C{mod}.

485 '''

486 # assert len(mod_DNAME) == 1

487 # mod, dun = mod_DNAME.popitem()

488

489 class _Into(object):

490

491 def __getattr__(unused, name):

492 m = _getmodinto(mod_DNAME, _Into)

493 return getattr(m, name)

494

495 return _Into()

496

497# @_Property_RO

498# def _isBoolean(self):

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

500# '''

501# return self.booleans.isBoolean

502

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

504 '''Yield the modules imported so far.

505 '''

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

507 if _headof(n) == _pygeodesy_:

508 yield n, m

509

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

511

512__all__ = _ALL_LAZY.lazily

513__version__ = '25.04.30'

514

515

516 def _ALL_OTHER(*objs):

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

518 '''

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

520 n = _tailof(typename(o))

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

522 return getattr(_interns, i, n)

523

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

525

526

527 if _FOR_DOCS: # PYCHOK no cover

528 _ALL_DOCS = _ALL_OTHER

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

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

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

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

533 # too much internal documentation.

534 else:

535 def _ALL_DOCS(*unused):

536 return ()

537

538

539 def _all_deprecates():

540 '''(INTERNAL) Build C{dict} of all deprecated imports and attributes.

541 '''

542 D = _ALL_DEPRECATES

543 if not D:

544 _ALL_DEPRECATED.fill_D(D, _all_deprecates) # see _all_imports()

545 return D

546

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

548

549

550 def _all_enums():

551 '''(INTERNAL) Yield all C{(mod_, tuple)} pairs for C{__init__._all}.

552 '''

553 # assert _init__all__

554 for mod_t in _ALL_LAZY.enums():

555 yield mod_t

556 if _FOR_DOCS:

557 for mod_t in _ALL_DEPRECATED.enums():

558 yield mod_t

559

560

561 def _all_imports():

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

563 '''

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

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

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

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

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

569 D = _ALL_IMPORTS

570 if not D:

571 _ALL_LAZY.fill_D(D, _all_imports) # see _all_deprecates()

572 return D

573

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

575

576

577 def _all_missing2(_all_):

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

579 '''

580 def _diff(one, two):

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

582

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

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

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

586 (_DOT_(_pygeodesy_, _DALL_), _diff(_alzy.keys(), _all_)))

587

588

589 def _getattras(attr_as): # test/testDeprecated

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

591 '''

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

593 return as_ or a_.rstrip(_DOT_)

594

595

596 def _getmodattr(m, name, mod=_pygeodesy_):

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

598 '''

599 try:

600 return getattr(m, name)

601 except AttributeError:

602 name = _DOT_(typename(m, mod), name)

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

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

605

606

607 def _getmodinto(mod_DNAME, *Intos):

608 '''(INTERNAL) Core of C{_ALL_MODS.into}.

609 '''

610 _MODS = _ALL_MODS

611 mod, dun = _MODS.errors._xkwds_item2(mod_DNAME)

612 _mod = _UNDER_(NN, mod)

613 d = _MODS.getmodule(dun) # '__main__' OK

614 i = _getmodattr(d, _mod, dun)

615 assert isinstance(i, Intos)

616 m = _MODS.getmodule(mod)

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

618 if isLazy > 1:

619 t = _SPACE_(_HASH_, _imported_, m.__name__) # typename(m)

620 _hash_imported(t, _MODS.into.__name__)

621 assert getattr(d, _mod, None) is m

622 return m

623

624

625 def _getmodule(name, *parent):

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

627 '''

628 try:

629 return import_module(name, parent)

630 except ImportError:

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

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

633

634

635 def _hash_imported(t, by_into, up=3):

636 '''(INTERNAL) Helper for C{_lazy_import2} and C{_ALL_MODS.into}.

637 '''

638 if isLazy > 2:

639 try: # see C{internals._caller3}

640 _, f, s = _caller3(up)

641 t = _SPACE_(t, by_into, f, _line_, s)

642 except ValueError:

643 pass

644 printf(t) # XXX print

645

646

647# def _lazy_attributes(DUNDER_name):

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

649# on lazily imported modules and sub-modules.

650# '''

651# if _unlazy:

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

653#

654# def _getattr(attr, *dflt):

655# try: # a module name

656# return _ALL_MODS.getmodule(attr)

657# except (AttributeError, ImportError):

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

659#

660# return _getattr

661

662

663_lazy_dict = {} # PYCHOK overwritten by _lazy_import2

664

665

666 def _lazy_import2(pack): # MCCABE 14

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

668

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

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

671

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

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

674 C{package.__getattr__}.

675

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

677 invalid or does not exist.

678

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

680 an import failed.

681

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

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

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

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

686 causing a C{ModuleNotFoundError}.

687

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

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

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

691 '''

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

693 t = _DOT_(pack, typename(_lazy_import2))

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

695

696 package, parent = _lazy_init2(pack) # _pygeodesy_

697

698 _DPACKAGE_ = '__package__'

699 _lazily_imported_ = _SPACE_(_HASH_, _lazily_, _imported_, parent)

700

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

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

703 imports = _all_imports()

704 deprecates = _all_deprecates()

705

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

707 # only called once for each undefined pygeodesy attribute

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

709 if mod:

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

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

712 # note in the _lazy_import2.__doc__ above).

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

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

715 else: # from mod import name

716 attr = name

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

718 t = getattr(v, _DPACKAGE_, None)

719 if t not in sub_packages: # invalid module package

720 raise LazyImportError(_DOT_(mod, _DPACKAGE_), t)

721 if attr: # get mod.attr

722 v = _getmodattr(v, attr, mod)

723

724 elif name in (_DALL_,): # XXX _Ddir_, _Dmembers_?

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

726 else: # PYCHOK no cover

727 t = _no_(_module_, _or_, _attribute_)

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

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

730

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

732 if isLazy > 1:

733 t = _DOT_(_lazily_imported_, name)

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

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

736 _hash_imported(t, _by_)

737

738 return v # __getattr__

739

740 global _lazy_dict, _lazy_module

741 _lazy_dict = package.__dict__

742 _lazy_module = __getattr__

743

744 return package, __getattr__ # _lazy_import2

745

746

747# def _lazy_import_all(Dname):

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

749# of all items, see .deprecated.__init__

750# '''

751# if _unlazy:

752# raise AssertionError(_COMMASPACE_(Dname, _not_(_DEPRECATED_)))

753#

754# _getattr = _lazy_attributes(Dname) # __name__.__getattr__

755# _import_start = _lazy_import_star(Dname, ALL_=_ALL_IMPORTS)

756#

757# def _import_all(attr, *dflt):

758# return _import_star(Dname) if attr == _DALL_ else \

759# _getattr(attr, *dflt)

760#

761# return _import_all

762

763

764 def _lazy_import_as(DUNDER_name):

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

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

767 lazily exported by C{__name__}.

768 '''

769 if _unlazy:

770 return None

771

772 def _import_as(mod):

773 try:

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

775 except ImportError:

776 return _lazy_module(mod)

777

778 return _import_as

779

780

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

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

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

784# '''

785# if _unlazy:

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

787#

788# def _import_star(_into_):

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

790# '''

791# d = dict()

792# nm = _tailof(DUNDER_name)

793# _g = _ALL_MODS.getattr # pygeodesy.__getattr__

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

795# if _headof(m) == nm:

796# try:

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

798# except (AttributeError, ImportError):

799# pass

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

801# return d.keys() # imported names

802#

803# return _import_star

804

805

806 def _lazy_init2(pack):

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

808

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

810 to resolve relative imports, usually C{__package__}.

811

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

813 for easy reference within itself and its name aka the

814 C(package)'s C{parent}, same as B{C{pack}}.

815

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

817 an import failed or the package name is

818 invalid or does not exist.

819

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

821 '''

822 global isLazy, _unLazy0

823

824 E = _internals._PYGEODESY_ENV('LAZY_IMPORT')

825 z = _internals._getenv(E, _interns._1_) # 1 default on 3.7+

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

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

828

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

830

831 if isLazy < 1: # invalid, not enabled

832 raise LazyImportError(E, repr(z), txt_not_='enabled')

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

834 isLazy += 1

835

836 try: # to initialize in Python 3+

837 package = import_module(pack)

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

839 if parent != pack: # assert

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

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

842

843 except (AttributeError, ImportError) as x:

844 isLazy = False # failed

845 z = typename(_lazy_init2)

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

847

848 return package, parent

849

850

851 def _lazy_module(name): # overwritten by _lazy_import2

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

853 '''

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

855 m = _ALL_MODS.getmodule(name)

856 except (AttributeError, ImportError) as x:

857 raise LazyImportError(name, cause=x)

858 _lazy_dict[name] = m # cache

859 return m

860

861

862# def _lazy_subs(__name__, force=_FOR_DOCS, over=False):

863# '''(INTERNAL) Return the names of a __name__ package's sub-packages

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

865# '''

866# sm = dict()

867# if force and __name__ != _DMAIN_:

868# nm = _tailof(__name__)

869# _a = _ALL_MODS.getattr

870# _m = _ALL_MODS.getmodule

871# d = _a(__name__, _DDICT_, {})

872# for n in _a(__name__, _DALL_, ()):

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

874# m = _a(__name__, n).__module__

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

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

877# m = _m(m) # == import m as s

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

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

880# pass

881# d.update(sm)

882#

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

884

885

886 if __name__ == _DMAIN_:

887

888 def _main():

889 from timeit import timeit

890

891 def t1():

892 from pygeodesy.trf import RefFrame

893 return RefFrame

894

895 def t2():

896 return _ALL_MODS.trf.RefFrame

897

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

899

900 t1 = timeit(t1, number=1000000)

901 t2 = timeit(t2, number=1000000)

902 A = typename(_ALL_MODS)

903 v = _versions()

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

905

906 _main()

907

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

909# 0.054235 import vs 0.052469 _ALL_MODS: 1.03X, pygeodesy 25.4.24 Python 3.13.3 64bit arm64 macOS 15.4

910

911# % python2 -m pygeodesy.lazily

912# 0.653715 import vs 0.321318 _ALL_MODS: 2.03X, pygeodesy 25.4.24 Python 2.7.18 64bit arm64_x86_64 macOS 10.16

913

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

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

916

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

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

919

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

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

922

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

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

925

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

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

928

929# % python2 -m pygeodesy.lazily

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

931

932# **) MIT License

933#

934# Copyright (C) 2018-2025 -- mrJean1 at Gmail -- All Rights Reserved.

935#

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

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

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

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

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

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

942#

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

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

945#

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

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

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

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

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

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

952# OTHER DEALINGS IN THE SOFTWARE.