Viewing File: /opt/alt/python311/lib64/python3.11/importlib/__pycache__/_bootstrap.cpython-311.pyc



f_dZdZdZdZdZdadZdZiZiZ	Gdde
ZGddZGd	d
Z
GddZd
ZdZdZdddZdZdZdZdZGddZddddZd>dZdddZdZd Zd!Zd"Zd#Zd$Z Gd%d&Z!Gd'd(Z"Gd)d*Z#d+Z$d,Z%d?d-Z&d.Z'd/Z(e(d0zZ)d1Z*e+Z,d2Z-d@d4Z.dd5d6Z/d7Z0dAd9Z1d:Z2d;Z3d<Z4d=Z5dS)BaSCore implementation of import.

This module is NOT meant to be directly imported! It has been designed such
that it can be bootstrapped into Python as the implementation of import. As
such it requires the injection of specific modules and attributes in order to
work. One should use importlib as the public-facing version of this module.

cZ	|jS#t$rt|jcYSwxYwN)__qualname__AttributeErrortype)objs ;/opt/alt/python311/lib64/python3.11/importlib/_bootstrap.py_object_namer	s@&&&&Cyy%%%%&s	**Nc	dD]1}t||rt||t||2|j|jdS)z/Simple substitute for functools.update_wrapper.)
__module____name__r__doc__N)hasattrsetattrgetattr__dict__update)newoldreplaces   r_wrapr(s^H993  	9C'#w"7"7888L%%%%%c<tt|Sr)rsysnames r_new_moduler0s499T??rceZdZdS)_DeadlockErrorN)rrrrrrr=sDrrc0eZdZdZdZdZdZdZdZdS)_ModuleLockzA recursive lock implementation which is able to detect deadlocks
    (e.g. thread 1 trying to take locks A then B, and thread 2 trying to
    take locks B then A).
    ct|_t|_||_d|_d|_d|_dSN)_thread
allocate_locklockwakeuprownercountwaitersselfrs  r__init__z_ModuleLock.__init__GsH))++	++--	

rct}|j}t}	t|}|dS|j}||krdS||vrdS||I)NTF)r%	get_identr)set_blocking_ongetadd)r-metidseenr's     rhas_deadlockz_ModuleLock.has_deadlockOs~



 
 juu	##C((D|u*Cbyytd{{uHHSMMM	rc0t}|t|<		|j5|jdks|j|kr-||_|xjdz
c_	dddt|=dS|rtd|z|j	dr|xj
dz
c_
dddn#1swxYwY|j	|j#t|=wxYw)z
        Acquire the module lock.  If a potential deadlock is detected,
        a _DeadlockError is raised.
        Otherwise, the lock is always acquired and True is returned.
        Tr$Nzdeadlock detected by %rF)r%r0r2r'r*r)r8rr(acquirer+releaser-r6s  rr;z_ModuleLock.acquireds}!! S	"
&Y**zQ$**;*;%(


a

#	******S!!!((**O,-F-MNNN{**511*)***************##%%%##%%%
&S!!!!!s;D/C
D1AC
D
CDC6D
Dcjt}|j5|j|krt	d|jdksJ|xjdzc_|jdkr7d|_|jr)|xjdzc_|jddddS#1swxYwYdS)Ncannot release un-acquired lockr$r:)	r%r0r'r)RuntimeErrorr*r+r(r<r=s  rr<z_ModuleLock.release}s!!
Y		*		*zS  "#DEEE:>>>>JJ!OJJzQ!
<*LLA%LLK'')))		*		*		*		*		*		*		*		*		*		*		*		*		*		*		*		*		*		*sA:B((B,/B,cRd|jt|S)Nz_ModuleLock({!r}) at {}formatridr-s r__repr__z_ModuleLock.__repr__s (//	2d88DDDrN)	rrrr
r.r8r;r<rFrrrr!r!Asn
*"""2***EEEEErr!c*eZdZdZdZdZdZdZdS)_DummyModuleLockzVA simple _ModuleLock equivalent for Python builds without
    multi-threading support.c"||_d|_dSr#)rr*r,s  rr.z_DummyModuleLock.__init__s	


rc&|xjdz
c_dS)Nr:T)r*rEs rr;z_DummyModuleLock.acquires

a

trcZ|jdkrtd|xjdzc_dS)Nr$r?r:)r*r@rEs rr<z_DummyModuleLock.releases/:??@AAA

a



rcRd|jt|S)Nz_DummyModuleLock({!r}) at {}rBrEs rrFz_DummyModuleLock.__repr__s -44TY4IIIrN)rrrr
r.r;r<rFrrrrHrHs_  
JJJJJrrHc eZdZdZdZdZdS)_ModuleLockManagerc"||_d|_dSr)_name_lockr,s  rr.z_ModuleLockManager.__init__s



rcjt|j|_|jdSr)_get_module_lockrPrQr;rEs r	__enter__z_ModuleLockManager.__enter__s-%dj11

rc8|jdSr)rQr<)r-argskwargss   r__exit__z_ModuleLockManager.__exit__s
rN)rrrr.rTrXrrrrNrNsArrNct		t|}n#t$rd}YnwxYw|Ntt|}nt
|}|fd}t||t|<t	n#t	wxYw|S)zGet or create the module lock for a given module name.

    Acquire/release internally the global import lock to protect
    _module_locks.Nct	t||urt|=tdS#twxYwr)_impacquire_lock
_module_locksr3release_lock)refrs  rcbz_get_module_lock.<locals>.cbsl!!###(%((..#55)$/%%'''''D%%''''s$AA5)
r[r\r]KeyErrorr%rHr!_weakrefr_r^)rr'r`s   rrSrSs		 &((DD			DDD	<'--"4((!	
(	
(	
(	
(#+,,tR"8"8M$Ks%1B-AB-AAB--Cct|}	||dS#t$rYdSwxYw)zAcquires then releases the module lock for a given module name.

    This is used to ensure a module is completely initialized, in the
    event it is being imported by another thread.
    N)rSr;r<r)rr's  r_lock_unlock_modulerds\D!!D	



	

s;
A	A	c||i|S)a.remove_importlib_frames in import.c will always remove sequences
    of importlib frames that end with a call to this function

    Use it instead of a normal call in places where including the importlib
    frames introduces unwanted noise into the traceback (e.g. when executing
    module code)
    r)frVkwdss   r_call_with_frames_removedrhs
1ddrr:)	verbosityctjj|kr?|dsd|z}t	|j|tjdSdS)z=Print the message to stderr if -v/PYTHONVERBOSE is turned on.)#zimport z# )fileN)rflagsverbose
startswithprintrCstderr)messagerirVs   r_verbose_messagerss^
yI%%!!"233	%WnG
ngnd##*555555&%rc2fd}t||S)z1Decorator to verify the named module is built-in.c|tjvr$td||||S)N{!r} is not a built-in moduler)rbuiltin_module_namesImportErrorrCr-fullnamefxns  r_requires_builtin_wrapperz4_requires_builtin.<locals>._requires_builtin_wrappersN3333=DDXNN#+---
-s4"""rr)r{r|s` r_requires_builtinr~s5#####


#S)))$$rc2fd}t||S)z/Decorator to verify the named module is frozen.ct|s$td||||S)Nz{!r} is not a frozen moduler)r[	is_frozenrxrCrys  r_requires_frozen_wrapperz2_requires_frozen.<locals>._requires_frozen_wrapper	sT~~h''	-;BB8LL#+---
-s4"""rr})r{rs` r_requires_frozenrs5#####


"C(((##rcd}t|tt||}|tjvr4tj|}t
||tj|St|S)zLoad the specified module into sys.modules and return it.

    This method is deprecated.  Use loader.exec_module() instead.

    zgthe load_module() method is deprecated and slated for removal in Python 3.12; use exec_module() instead)	_warningswarnDeprecationWarningspec_from_loaderrmodules_exec_load)r-rzmsgspecmodules     r_load_module_shimrso3C
NN3*+++Hd++D3;X&
dF{8$$T{{rct|dd}t|ddx}rt|St|dr&	||S#t$rYnwxYw	|j}n#t$rd}YnwxYw	|j}d||S#t$r2|d|cYSd||cYSwxYw)	z,The implementation of ModuleType.__repr__().
__loader__N__spec__module_repr?<module {!r} from {!r}>
<module {!r}><module {!r} ({!r})>)	r_module_repr_from_specrr	Exceptionrr__file__rC)rloaderrrfilenames     r_module_reprr&s4
V\4
0
0Fvz4000t%d+++		'	'	%%f---			D	@?)//h???
???>"))$/////)00v>>>>>	?s<A
A'&A'+A33BBB##!CCCceZdZdZdddddZdZdZedZej	dZed	Z
ed
Zej	dZdS)
ModuleSpecaThe specification for a module, used for loading.

    A module's spec is the source for information about the module.  For
    data associated with the module, including source, use the spec's
    loader.

    `name` is the absolute name of the module.  `loader` is the loader
    to use when loading the module.  `parent` is the name of the
    package the module is in.  The parent is derived from the name.

    `is_package` determines if the module is considered a package or
    not.  On modules this is reflected by the `__path__` attribute.

    `origin` is the specific location used by the loader from which to
    load the module, if that information is available.  When filename is
    set, origin will match.

    `has_location` indicates that a spec's "origin" reflects a location.
    When this is True, `__file__` attribute of the module is set.

    `cached` is the location of the cached bytecode file, if any.  It
    corresponds to the `__cached__` attribute.

    `submodule_search_locations` is the sequence of path entries to
    search when importing submodules.  If set, is_package should be
    True--and False otherwise.

    Packages are simply modules that (may) have submodules.  If a spec
    has a non-None value in `submodule_search_locations`, the import
    system will consider modules loaded from the spec as packages.

    Only finders (see importlib.abc.MetaPathFinder and
    importlib.abc.PathEntryFinder) should modify ModuleSpec instances.

    N)originloader_state
is_packagec~||_||_||_||_|rgnd|_g|_d|_d|_dSNF)rrrrsubmodule_search_locations_uninitialized_submodules
_set_fileattr_cached)r-rrrrrs      rr.zModuleSpec.__init__esM	(0:*D""')+&#rcd|jd|jg}|j-|d|j|j-|d|jd|jjd|S)Nz	name={!r}zloader={!r}zorigin={!r}zsubmodule_search_locations={}z{}({})z, )	rCrrrappendr	__class__rjoin)r-rVs  rrFzModuleSpec.__repr__rs""49--$$T[113;"KK
,,T[99:::*6KK7 ?@@
B
B
Bt~6		$HHHrc|j}	|j|jkoJ|j|jko:|j|jko*||jko|j|jko|j|jkS#t$r
tcYSwxYwr)rrrrcachedhas_locationrNotImplemented)r-othersmsls   r__eq__zModuleSpec.__eq__|s.	"I+<K5</<K5</<E<<<K5</	<
%);;
=	"	"	"!!!!	"sAA$$A87A8c|j@|j9|jr2ttt|j|_|jSr)rrr_bootstrap_externalNotImplementedError_get_cachedrEs rrzModuleSpec.cachedsE<{&4+=&&.--2>>t{KK|rc||_dSr)r)r-rs  rrzModuleSpec.cacheds
rc^|j |jddS|jS)z The name of the module's parent.N.r$)rr
rpartitionrEs rparentzModuleSpec.parents0*29'',,Q//9rc|jSr)rrEs rrzModuleSpec.has_locations!!rc.t||_dSr)boolr)r-values  rrzModuleSpec.has_locations!%[[r)rrrr
r.rFrpropertyrsetterrrrrrrr@s""H04$ III
"
"
"X]]X""X")))))rrrrcf|t|dd}|sMt|dr=tttj}|
|||S|rgnd}||||S|;t|dr)	||}n#t$rd}YnwxYwd}t||||S)	z5Return a module spec based on various loader methods.N_ORIGINget_filename)r)rrrFr)rrrrspec_from_file_locationrrxr)rrrrrsearchs      rrrs

~D11	Jgfn55	J&%%"5"M**4????!+t&&tFBHJJJ	J6<((	
"#..t44


"
"
"!



"JdF6jIIIIs6BBBc	|j}||Sn#t$rYnwxYw|j}|	|j}n#t$rYnwxYw	|j}n#t$rd}YnwxYw||t|dd}|s||}	|j}n#t$rd}YnwxYw	t|j}n#t$rd}YnwxYwt|||}|dn||k|_
||_||_|S)NrrF)
rrrrrr
__cached__list__path__rrrr)rrrrrlocationrrs        r_spec_from_modulersK



?D
~	&FF			D	?
~VY55F	(.F"*%)&/%:%:""***%)"""*dF6222D"*"289KDDK&@D#KsN
0
==A		AA7A??B
BB''B65B6FoverridecV|st|dd	|j|_n#t$rYnwxYw|st|ddr|j}|P|jItttj}|	|}|j|_
||_d|_	||_n#t$rYnwxYw|st|dd	|j
|_n#t$rYnwxYw	||_n#t$rYnwxYw|st|dd%|j	|j|_n#t$rYnwxYw|jri|st|dd	|j|_n#t$rYnwxYw|st|dd%|j	|j|_n#t$rYnwxYw|S)Nrr__package__rrr)rrrrrrrrNamespaceLoader__new___pathrrrrrrrrrr)rrrrrs     r_init_module_attrsrsn	GFJ55=	"iFOO			D	76<66>>.:&.--"5"E(00AA#>$#'	 &F			D	76=$77?	!%F			D	




76:t44<*6
"&"A!



	wvz488@
"&+!



	wv|T::B{&(,F%%%DMsx"
//B''
B43B4C
C%$C%)C11
C>=C>D))
D65D6E!!
E.-E.F
F&%F&cd}t|jdr|j|}n$t|jdrtd|t	|j}t
|||S)z+Create a module based on the provided spec.N
create_moduleexec_modulezBloaders that define exec_module() must also define create_module())rrrrxrrrrrs  rmodule_from_specr6sFt{O,,>**400	m	,	,>=>>	>
~TY''tV$$$Mrc"|jdn|j}|j7|jd|Sd||jS|jrd||jSd|j|jS)z&Return the repr to use for the module.Nrrrr<module {!r} ({})>)rrrrCr)rrs  rrrGs)#33D{;"))$///)00t{CCC	G,33D$+FFF'..ty$+FFFrct|j}t|5tj||ur&d|}t
||	|j0|jt
d|jt||dnt||dt|jdsRt|jd}t
|t|j|n|j|tj|j}|tj|j<n=#tj|j}|tj|j<wxYw	dddn#1swxYwY|S)	zFExecute the spec's specified module in an existing module's namespace.zmodule {!r} not in sys.modulesrNmissing loaderTrr7.exec_module() not found; falling back to load_module())rrNrrr3rCrxrrrrr	rr
ImportWarningload_modulerpop)rrrrs    rrrXs9D	D	!	!,,;??4  ..299$??Cc----	,{"2:%&6TYGGGG"4$?????"4$????t{M::4*4;77;;;CNN3
666K++D1111K++F333[__TY//F%+CK	""[__TY//F%+CK	"++++"/,,,,,,,,,,,,,,,0Ms+AF- C
E#*9F-#:FF--F14F1c	|j|jnQ#|jtjvr8tj|j}|tj|j<xYwtj|j}|tj|j<t
|dd	|j|_n#t$rYnwxYwt
|ddS	|j	|_
t|ds%|jdd|_
n#t$rYnwxYwt
|dd	||_
n#t$rYnwxYw|S)Nrrrrr$r)rrrrrrrrrrrrrrrs  r_load_backward_compatiblervs	****9##[__TY//F%+CK	"
[__TY
'
'F#CK	v|T**2	 $F			D	v}d++3	"(F6:..
B%)Y%9%9#%>%>q%A"			D	vz4((0	"FOO			D	MsA"AA0=C


CC,AD..
D;:D;E
E%$E%c|j[t|jdsFt|jd}t|t
t
|St|}d|_	|tj
|j<	|j|jtd|jn|j|n*#	tj
|j=n#t$rYnwxYwxYwtj
|j}|tj
|j<t#d|j|jd|_n#d|_wxYw|S)NrrTrrzimport {!r} # {!r}F)rrr	rrrrr
_initializingrrrrrxrrarrs)rrrs   r_load_unlockedrsr{t{M22	3"4;//444CNN3
...,T222
d
#
#F
D#!'DI	{"2:%&6TYGGGG;''///	
K	**




++!'DI-ty$+FFF"U""""MsI:E?CEC6C%$C6%
C2/C61C22C66AE	Ec|t|j5t|cdddS#1swxYwYdS)zReturn a new module object, loaded by the spec's loader.

    The module is not added to its parent.

    If a module is already in sys.modules, that existing module gets
    clobbered.

    N)rNrrrs rrrs
DI	&	&$$d##$$$$$$$$$$$$$$$$$$s155ceZdZdZdZedZeddZed
dZ	edZ
edZeed	Z
eed
ZeedZeeZdS)BuiltinImporterzMeta path import for built-in modules.

    All methods are either class or static methods to avoid the need to
    instantiate the class.

    zbuilt-incrtdtd|jdtjdS)sReturn repr for the module.

        The method is deprecated.  The import machinery does the job itself.

        zQBuiltinImporter.module_repr() is deprecated and slated for removal in Python 3.12z<module z (z)>)rrrrrrrs rrzBuiltinImporter.module_reprsC	;<N	P	P	PJ&/JJ/FJJJJrNcht|rt|||jSdS)Nr)r[
is_builtinrr)clsrzpathtargets    r	find_speczBuiltinImporter.find_specs2??8$$	#Hc#+FFFF4rctdt|||}||jndS)zFind the built-in module.

        If 'path' is ever specified then the search is considered a failure.

        This method is deprecated.  Use find_spec() instead.

        zjBuiltinImporter.find_module() is deprecated and slated for removal in Python 3.12; use find_spec() insteadN)rrrrr)rrzrrs    rfind_modulezBuiltinImporter.find_modulesI	T)	+	+	+}}Xt,,".t{{D8rc|jtjvr.td|j|jttj|S)zCreate a built-in modulervr)rrrwrxrCrhr[create_builtinrs rrzBuiltinImporter.create_modulesV9C444=DDTYOO#'9...
.()<dCCCrc:ttj|dS)zExec a built-in moduleN)rhr[exec_builtinrs rrzBuiltinImporter.exec_module
s	"$"3V<<<<<rcdS)z9Return None as built-in modules do not have code objects.Nrrrzs  rget_codezBuiltinImporter.get_code	trcdS)z8Return None as built-in modules do not have source code.Nrrs  r
get_sourcezBuiltinImporter.get_sourcerrcdS)z4Return False as built-in modules are never packages.Frrs  rrzBuiltinImporter.is_packages	urNNr)rrrr
rstaticmethodrclassmethodrrrrr~rrrrrrrrrrs8GKK\K[999[9DD\D==\=[[[+/00KKKrrc>eZdZdZdZedZedZeddZ	eddZ
edd	Zed
ZedZ
edZeed
ZeedZeedZdS)FrozenImporterzMeta path import for frozen modules.

    All methods are either class or static methods to avoid the need to
    instantiate the class.

    frozenctdtd|jt
jS)rzPFrozenImporter.module_repr() is deprecated and slated for removal in Python 3.12r)rrrrCrrr)ms rrzFrozenImporter.module_repr/s@	;<N	P	P	P#**1:~7MNNNrc|j}|j}|tt|dd}|s
Jdt	|d}t
|j|ks
J||||j	|\}}ttj|||_|j
}|r.|gks
J||r|j
d|n|
J|t	|drJ|j|r	||_n#t $rYnwxYw|r?|j|kr4|jgksJ|j|j|nu|j
}|du}t't|ddgks
J||jrk||j|j	|\}	}|j|	ksJ|j|	f|r||gksJ||fnA||rgndks
J|n,d}	|jJ|j||rgndks
J||	r/t	|dsJ|j|	ksJ|j|	fnt	|drJ|j|r/t	|dsJ|j|ksJ|j|fnt	|drJ|j|jrJdS)	N__origname__z'see PyImport_ImportFrozenModuleObject()rrorignamer$rrr)rrvarsrrr[is_frozen_packager_resolve_filenamerrrimplementationrinsertrrrextendsortedrrr)
rrrstaterispkgrpkgdirrrs
          r_fix_up_modulezFrozenImporter._fix_up_module:s!=F||''==HFFFFF8FJ//E))&/::eCCCUCCC"44Xty%PPHf 8S%7 8 8!!!!!D6H
22~~~x~~~F3::1fEEE'''''vz22CCFOCC2
&.FOO%D
5?h..!?b000&/000O**84446HD(E$u++&&:z*BBBBEBBB~
E**5>49eLL6~111ENH3M111I#x///(F1C////#e(=>>>>>>>~--u~---%$9BBT:::H:::
Hvz22222(222V_h4O2222"6:66GGGG6
Hvz22222(222V_h4O2222"6:66GGGG6$$$$$$s+D33
E?ENFc|rttddsdS	|j}n+#t$rtjdkrdndx}|_YnwxYw||kr)|dr|dd}|s|d}nd	}|d
|}|rtj||}||d}nd}tj||d}||fS)
N_stdlib_dirrwin32\/<r:z	.__init__Frz__init__.pyz.py)rr_SEPrplatformrorr)rrzaliasrseprelfilerrs        rrz FrozenImporter._resolve_filenames/	wsM4@@	:	F(CC	F	F	F%(\W%<%<TT#EC#(((	Fu""3''
#ABB<6"*555H""3,,	=77g77F 2#222HHF/<3<<<<Hs$%AAc>ttj|}|dS|\}}}t|||j|}||||\}	}
t
tj|	||_	|
r|j
d|
|S)Nrrr$)rhr[find_frozenrrrrrrrrr)rrzrrinfo_rrrrrs           rrzFrozenImporter.find_specs()98DD<4"5(#'*{+0222008UKK&4D!344


	>+221f===rc~tdtt|r|ndS)z]Find a frozen module.

        This method is deprecated.  Use find_spec() instead.

        ziFrozenImporter.find_module() is deprecated and slated for removal in Python 3.12; use find_spec() insteadN)rrrr[r)rrzrs   rrzFrozenImporter.find_modules@	T)	+	+	+nnX..8ssD8rc|t|j}	|jj}|r||_n#t
$rYnwxYw|S)zSet __file__, if able.)rrrrrr)rrrs   rrzFrozenImporter.create_modules^TY''	+(1H
+"*				D	

s,
99c|j}|j}ttj|}t||jdSr)rrrhr[get_frozen_objectexecr)rrrcodes    rrzFrozenImporter.exec_modules:y()?FFT6?#####rct||}t|}|J|\}}}||_t	|dd|rg|_|||S)z_Load a frozen module.

        This method is deprecated.  Use exec_module() instead.

        Nr)rr[r'r
rrrr)rrzrr(r)rrs       rrzFrozenImporter.load_modules#311))!5(&VT***	! FO6"""
rc6t|S)z-Return the code object for the frozen module.)r[r-rs  rrzFrozenImporter.get_code%%h///rcdS)z6Return None as frozen modules do not have source code.Nrrs  rrzFrozenImporter.get_sourcerrc6t|S)z.Return True if the frozen module is a package.)r[rrs  rrzFrozenImporter.is_packager2rrrr)rrrr
rrrrrrrrrrrrrrrrrrrr$sGOO\OB%B%[B%H   [ 0[:	9	9	9[	9

\
$$\$[$00[0[00[000rrceZdZdZdZdZdS)_ImportLockContextz$Context manager for the import lock.c8tdS)zAcquire the import lock.N)r[r\rEs rrTz_ImportLockContext.__enter__rc8tdS)z<Release the import lock regardless of any raised exceptions.N)r[r^)r-exc_type	exc_value
exc_tracebacks    rrXz_ImportLockContext.__exit__r8rN)rrrr
rTrXrrrr6r6s8..rr6c|d|dz
}t||krtd|d}|rd||n|S)z2Resolve a relative module name to an absolute one.rr:z2attempted relative import beyond top-level packager${}.{})rsplitlenrxrC)rpackagelevelbitsbases     r
_resolve_namerEs`>>#uqy))D
4yy5NOOO7D)-77>>$%%%47rct|d}t|t|||}|dSt||S)Nz5.find_spec() not found; falling back to find_module())r	rrrrr)finderrrrrs     r_find_spec_legacyrHsa6"";;;C
NN3
&&&


d
+
+F
~tD&)))rctj}|td|s tdt
|tjv}|D]}t5	|j}||||}n0#t$r#t|||}|
YdddQYnwxYwdddn#1swxYwY|L|sF|tjvr8tj|}	|j}	|	|cS|	cS#t$r|cYcSwxYw|cSdS)zFind a module's spec.Nz5sys.meta_path is None, Python is likely shutting downzsys.meta_path is empty)r	meta_pathrxrrrrr6rrrHr)
rrrrJ	is_reloadrGrrrrs
          r
_find_specrLs
I*++	+@/???
#I

!
!	5	5
5",	!ytV44"


(t<<<
	5	5	5	5	5	5	5
 <
	5	5	5	5	5	5	5	5	5	5	5	5	5	5	5
!4!4T*(%H '#'&    KKKKK	 #&tsN B3"A7)B37B$B3!B3#B$$B33B7	:B7	#C44DDc`t|ts/tdt	||dkrtd|dkr5t|tstd|st
d|s|dkrtddSdS)zVerify arguments are "sane".zmodule name must be str, not {}r$zlevel must be >= 0z__package__ not set to a stringz6attempted relative import with no known parent packagezEmpty module nameN)
isinstancestr	TypeErrorrCr
ValueErrorrxrrArBs   r
_sanity_checkrSMsdC  N9@@dLLMMMqyy-...qyy'3''	)=>>>	)())
).EQJJ,---..JJrzNo module named z{!r}cd}|dd}d}|r|tjvrt|||tjvrtj|Stj|}	|j}n>#t
$r1tdz||}t||dwxYw|j	}|dd}t||}|)tt|||r|j|	t|}	|r|jn!#|r|jwwxYw|r]tj|}	t|||	n8#t
$r+d|d|}t |t$YnwxYw|	S)Nrr$z; {!r} is not a packagerzCannot set an attribute on z for child module )rrrrhrr_ERR_MSGrCModuleNotFoundErrorrrLrrrrrrrr)
rimport_rrparent_spec
parent_modulerchildrrs
          r_find_and_load_unlockedr\`sD
__S
!
!!
$FK

($$%gv6663;;t$$F+
	@ )DD	@	@	@77??fMMC%c5554?	@$,$$Q'dD!!D|!(//$"7"7dCCCC	@
188???	<#D))F
<599;;;
<599;;;;
<
/F+
	/M5&1111	/	/	/UUUEUUCNN3
.....	/Ms*3A;;;B63EE<F&&2GGctj|t}|tus t	t	|ddddrt|5tj|t}|turt
||cdddS	dddn#1swxYwYt||&d|}t|||S)zFind and load the module.rNrFz(import of {} halted; None in sys.modulesr)
rrr3_NEEDS_LOADINGrrNr\rdrCrW)rrXrrrs    r_find_and_loadr_sA
[__T>
2
2F.  
D11?EJJ	!

%
%	>	>[__T>::F''.tW==	>	>	>	>	>	>	>	>'	>	>	>	>	>	>	>	>	>	>	>	>	>	>	>	D!!!
~))/	!'5555Ms>B66B:=B:r$c|t||||dkrt|||}t|tS)a2Import and return the module based on its name, the package the call is
    being made from, and the level adjustment.

    This function represents the greatest common denominator of functionality
    between import_module and __import__. This includes setting __package__ if
    the loader did not.

    r$)rSrEr__gcd_importrRs   rraras@$'''qyyT7E22$,,,r	recursivec	|D]}t|ts6|r|jdz}nd}td|dt	|j|dkr+|s(t|drt
||j|dt||sud	|j|}	t||#t$r;}|j|kr*tj
|tYd
}~d
}~wwxYw|S)zFigure out what __import__ should return.

    The import_ parameter is a callable which takes the name of module to
    import. It is required to decouple the function from assuming importlib's
    import implementation is desired.

    z.__all__z
``from list''zItem in z must be str, not *__all__Trbr>N)rNrOrrPrr_handle_fromlistrfrCrhrWrrrr3r^)rfromlistrXrcxwhere	from_nameexcs        rrgrgs[!S!!	
(*4'6u66#'77#36677
7
#XX
1!;!;
1 +/1111##	v::I	
)'9====&


H	))KOOI~>>JHHHH
		Ms.B??
D	0C?>C??Dc||d}|d}|=|9||jkr.td|d|jdtd|S||jStd	td|d
}d|vr|dd
}|S)zCalculate what __package__ should be.

    __package__ is not guaranteed to be defined or could be set to None
    to represent that its proper value is unknown.

    rrNz __package__ != __spec__.parent (z != ))
stacklevelzYcan't resolve package from __spec__ or __package__, falling back on __name__ and __path__rrrr$)r3rrrrr)globalsrArs   r_calc___package__rrskk-((G;;z""D4; 6 6NN?&??.2k???(Q

8
8
8	
	{?$		4	4	4*%W$$((--a0GNrrc
|dkrt|}n&||ni}t|}t|||}|s|dkr(t|ddS|s|St|t|ddz
}tj|jdt|j|z
St|drt||tS|S)aImport a module.

    The 'globals' argument is used to infer where the import is occurring from
    to handle relative imports. The 'locals' argument is ignored. The
    'fromlist' argument specifies what should exist as attributes on the module
    being imported (e.g. ``from module import <fromlist>``).  The 'level'
    argument represents the package location to import from in a relative
    import (e.g. ``from ..pkg import mod`` would have a 'level' of 2).

    r$Nrr)	rarr	partitionr@rrrrrg)	rrqlocalsrhrBrglobals_rAcut_offs	         r
__import__rxs
zzT""%177r#H--T7E22A::t~~c2215666	OM$ii#dnnS&9&9!&<"="==G;v/LFO0D0DW0L/LMNN		$	$+>>>
rc|t|}|td|zt|S)Nzno built-in module named )rrrxr)rrs  r_builtin_from_namerzs<$$T**D|5<===$rcF|a|att}tjD]\}}t||rw|tjvrt}n#t|rt}nNt||}t|||tur||tjt}dD]C}|tjvrt|}	ntj|}	t|||	DdS)zSetup importlib by importing needed built-in modules and injecting them
    into the global namespace.

    As sys is needed for sys.modules access and _imp is needed to load built-in
    modules, those two modules must be explicitly passed in.

    )r%rrbN)r[rrritemsrNrwrrrrrrrrzr)

sys_module_imp_modulemodule_typerrrrself_modulebuiltin_namebuiltin_modules
          r_setupr#s$D
Cs))K))++..ffk**
	.s///(%%
'$VV44DtV,,,''%%f---+h'K<;;s{**/==NN [6N\>::::;;rct||tjttjt
dS)z0Install importers for builtin and frozen modulesN)rrrJrrr)r}r~s  r_installrHsD
:{###M)))M(((((rcfddl}|a|tjt
dS)z9Install importers that require external filesystem accessr$N)_frozen_importlib_externalrrrrr)rs r_install_external_importersrPs7&%%%4''H(=>>>>>rrrr#)NNrr$)6r
r	r%rrbrrrr]r2r@rr!rHrNrSrdrhrsr~rrrrrrrrrrrrrrrr6rErHrLrS_ERR_MSG_PREFIXrVr\objectr^r_rargrrrxrzrrrrrr<module>rs=,&&&	&&&
					\			JEJEJEJEJEJEJEJEZJJJJJJJJ* """J"0166666%%%$$$&@@@4c)c)c)c)c)c)c)c)L.2dJJJJJ:''''T27FFFFFR"
G
G
G"<"""H)))Z
$
$
$K1K1K1K1K1K1K1K1\U0U0U0U0U0U0U0U0t







888***,,,,^
.
.
. %V#'''T6---->C"""""J6""""J   ";";";J)))?????r
Back to Directory File Manager