Ei1* SrSSKrSSKrSSKrSSKrSSKrSSKrSSKrSSKrSr /SQr \R"5r SSjr "SS\R5rSSSS .S jrS \S \4S jr"SS\R(5rS\S\4Sjrg)zU lazy_loader =========== Makes it easy to load subpackages and functions on demand. Nz0.5)attach attach_stubloadc^^^ ^ Uc0nTc [5mO [T5mUR5VVVs0sHup4UHoUU_M M snnnm [TT R5-5m U UU4SjnU 4Sjn[R R SS5S;nU(a+[T R55T-H nU"U5 M XgT R54$s snnnf)aAttach lazily loaded submodules, functions, or other attributes. Typically, modules import submodules and attributes as follows:: import mysubmodule import anothersubmodule from .foo import someattr The idea is to replace a package's `__getattr__`, `__dir__`, and `__all__`, such that all imports work exactly the way they would with normal imports, except that the import occurs upon first use. The typical way to call this function, replacing the above imports, is:: __getattr__, __dir__, __all__ = lazy.attach( __name__, ["mysubmodule", "anothersubmodule"], {"foo": ["someattr"]} ) Parameters ---------- package_name : str Typically use ``__name__``. submodules : set List of submodules to attach. submod_attrs : dict Dictionary of submodule -> list of attributes / functions. These attributes are imported as they are used. Returns ------- __getattr__, __dir__, __all__ c">UT;a"TSU35$UT;aWTSTU3n[R"U5n[X 5nUTU:Xa![RTnX4R U'U$[ STSU35e)N.zNo z attribute ) importlib import_modulegetattrsysmodules__dict__AttributeError)name submod_pathsubmodattrpkgattr_to_modules package_name submoduless Q/home/mande/repo/quber/.venv/lib/python3.13/site-packages/lazy_loader/__init__.py __getattr__attach..__getattr__Is : **l^1TF+CD D _ $)N!OD,A+BCK,,[9F6(D t,,kk,/%) T"K 3|nKv!FG Gc$>TR5$N)copy)__all__sr__dir__attach..__dir__\s||~r EAGER_IMPORT)0r#)setitemssortedkeysosenvirongetr) rr submod_attrsmodattrsrrr eager_importrrs `` @@rrrsF U _ %1$6$6$8$8jcUTc U$8OZ/"6"6"889GH&::>>."5YFL,,./*>XlX l[TU] "U0UD6 gr)%_DelayedImportErrorModule__frame_data"_DelayedImportErrorModule__messagesuper__init__)self frame_datamessageargskwargs __class__s rr7!DelayedImportErrorModule.__init__hs &  $)&)rcURn[URSUSSUSSUSSSRUS =(d S5R 53 5e) NzF This error is lazily reported, having originally occurred in File filenamez, line linenoz, in functionz ----> r# code_context)r4ModuleNotFoundErrorr5joinstrip)r8xfds rr$DelayedImportErrorModule.__getattr__msv   !~~n%WR\N%:?OPWWR/526<<>? A  r) __frame_data __message)__name__ __module__ __qualname____firstlineno__r7r__static_attributes__ __classcell__)r=s@rr1r1gs*   rr1F)requireerror_on_importsuppress_warningc[ [RRU5nUSLnU(aUc UsSSS5 $U(d#SU;aSn[R "U[ 5 SnU(d#[RRU5nUSLnU(dSUS3nOUb[U5nSUS3nU(dmU(a [W5eS SK n U R5S n U RU R U R"U R$S .n A ['U S WS 9sSSS5 $Ubl[RR)U5nU[RU'[RR+UR,5n U R/U5 SSS5 U$![an [SUS35U eSn A ff=f!,(df  W$=f)aReturn a lazily imported proxy for a module. We often see the following pattern:: def myfunc(): import numpy as np np.norm(...) .... Putting the import inside the function prevents, in this case, `numpy`, from being imported at function definition time. That saves time if `myfunc` ends up not being called. This `load` function returns a proxy module that, upon access, imports the actual module. So the idiom equivalent to the above example is:: np = lazy.load("numpy") def myfunc(): np.norm(...) .... The initial import time is fast because the actual import is delayed until the first attribute is requested. The overall import time may decrease as well for users that don't make use of large portions of your library. Warning ------- While lazily loading *sub*packages technically works, it causes the package (that contains the subpackage) to be eagerly loaded even if the package is already lazily loaded. So, you probably shouldn't use subpackages with this `load` feature. Instead you should encourage the package maintainers to use the `lazy_loader.attach` to make their subpackages load lazily. Parameters ---------- fullname : str The full name of the module or submodule to import. For example:: sp = lazy.load("scipy") # import scipy as sp require : str A dependency requirement as defined in PEP-508. For example:: "numpy >=1.24" If defined, the proxy module will raise an error if the installed version does not satisfy the requirement. error_on_import : bool Whether to postpone raising import errors until the module is accessed. If set to `True`, import errors are raised as soon as `load` is called. suppress_warning : bool Whether to prevent emitting a warning when loading subpackages. If set to `True`, no warning will occur. Returns ------- pm : importlib.util._LazyModule Proxy module. Can be used like any regularly imported module. Actual loading of the module occurs upon first attribute request. Nrzsubpackages can technically be lazily loaded, but it causes the package to be eagerly loaded even if it is already lazily loaded. So, you probably shouldn't use subpackages with this lazy feature.zNo module named ''zFound module 'zf' but cannot test requirement '{require}'. Requirements must match distribution name, not module name.z'No distribution can be found matching 'r)r@rArBrCr1)r:) threadlockr r r+warningswarnRuntimeWarningr util find_spec_check_requirementrD ValueErrorinspectstackr@rArBrCr1module_from_spec LazyLoaderloader exec_module)fullnamerRrSrTmodule have_modulemsgspecnot_found_messageer`parentr9rds rrrwsF *D(  7?  C8OU  MM#~ .>>++H5Dd*K"3H:Q ?    09 #J'RS T )*;<< ]]_Q'F"OO --"OO & 3 3 J +*)c n  ^^44T:F$*CKK !^^..t{{;F   v &y | MG'  $XJ/RR  7 | Ms>/GA'G( F&3A0G-A/G& G0GGG GrRreturncSSKnSSKnURRU5nURR UR RUR5SS9$)amVerify that a package requirement is satisfied If the package is required, a ``ModuleNotFoundError`` is raised by ``importlib.metadata``. Parameters ---------- require : str A dependency requirement as defined in PEP-508 Returns ------- satisfied : bool True if the installed version of the dependency matches the specified version, False otherwise. rNT) prereleases) importlib.metadatapackaging.requirements requirements Requirement specifiercontainsmetadataversionr)rRr packagingreqs rr^r^sW"!  , ,W 5C == ! !""388, " rc@\rSrSrSrSrS\R4SjrSr g) _StubVisitorizAAST visitor to parse a stub file for submodules and submod_attrs.c0[5Ul0Ulgr)r% _submodules _submod_attrs)r8s rr7_StubVisitor.__init__s5rnodecURS:wa [S5eUR(a|URR UR/5nUR Vs/sHo3R PM nnSU;a[SURS35eURU5 gURRSUR 55 gs snf)NrWz;Only within-module imports are supported (`from .* import`)*z4lazy stub loader does not support star import `from z import *`c38# UHoRv M g7fr)r).0aliass r 0_StubVisitor.visit_ImportFrom..-s#GJ5JJJs) levelr_rgr setdefaultnamesrextendr~update)r8rr.raliasess rvisit_ImportFrom_StubVisitor.visit_ImportFroms ::?M  ;;,,77 RHE/3zz:zezzzG:g~ ![[M5 LL !    # ##GDJJ#G G;s!C)rr~N) rLrMrNrO__doc__r7ast ImportFromrrPrrr|r|sK HS^^Hrr|rr@cURS5(aUO$[RRU5SS3n[RR U5(d[ SU<35e[ U5n[R"UR55nSSS5 [5nURW5 [XRUR5$!,(df  NI=f)aAttach lazily loaded submodules, functions from a type stub. This is a variant on ``attach`` that will parse a `.pyi` stub file to infer ``submodules`` and ``submod_attrs``. This allows static type checkers to find imports, while still providing lazy loading at runtime. Parameters ---------- package_name : str Typically use ``__name__``. filename : str Path to `.py` file which has an adjacent `.pyi` file. Typically use ``__file__``. Returns ------- __getattr__, __dir__, __all__ The same output as ``attach``. Raises ------ ValueError If a stub file is not found for `filename`, or if the stubfile is formmated incorrectly (e.g. if it contains an relative import from outside of the module) irz.pyiz+Cannot load imports from non-existent stub N)endswithr)pathsplitextexistsr_openrparsereadr|visitrr~r)rr@stubfilef stub_nodevisitors rrr0s6%%c**2773C3CH3Ma3P2QQU0V  77>>( # #FxlSTT h1IIaffh'  nG MM) , 3 3W5J5J KK s <%C$$ C2)NN)rrr importlib.utilr)r threadingtypesrY __version__rLockrXr ModuleTyper1rstrboolr^ NodeVisitorr|rrrrrs    +^^  L0^  u//  #EEAH8H3??H2&Lc&LS&Lr