ibSrSSKrSSKrSSKrSSKrSSKJr SSKJr SSK J r J r SSK J r SSKJr SSKJrJrJrJrJrJrJrJr SS KJr SS KJrJr SS KJrJ r SS K!J"r" SS K#J$r$J%r%J&r&J'r' SSK(J)r)J*r*J+r+ SSK,J-r-J.r. \ R^"\05r1Sr2Sr3Sr4Sr5"SS\$5r6Sq7SSjr8Sr9g)at Define a modified ModuleGraph that can return its contents as a TOC and in other ways act like the old ImpTracker. TODO: This class, along with TOC and Tree, should be in a separate module. For reference, the ModuleGraph node types and their contents: nodetype identifier filename Script full path to .py full path to .py SourceModule basename full path to .py BuiltinModule basename None CompiledModule basename full path to .pyc Extension basename full path to .so MissingModule basename None Package basename full path to __init__.py packagepath is ['path to package'] globalnames is set of global names __init__.py defines ExtensionPackage basename full path to __init__.{so,dll} packagepath is ['path to package'] The main extension here over ModuleGraph is a method to extract nodes from the flattened graph and return them as a TOC, or added to a TOC. Other added methods look up nodes by identifier and return facts about them, replacing what the old ImpTracker list could do. N) defaultdict)deepcopy)HOMEPATH PACKAGEPATH)log)destination_name_for_extension)BAD_MODULE_TYPESBINARY_MODULE_TYPESMODULE_TYPES_TO_TOC_DICTPURE_PYTHON_MODULE_TYPESPY3_BASE_MODULESVALID_MODULE_TYPESimportlib_load_sourceis_win)bytecode)AdditionalFilesCacheModuleHookCache)PreFindModulePathAPIPreSafeImportModuleAPI) get_implies) ModuleGraphDEFAULT_IMPORT_LEVELABSOLUTE_IMPORT_LEVELPackage)DEBUGINFOTRACE)collect_submodules is_packagei0iicn^\rSrSrSr\\\\\S.rS&U4Sjjr Sr Sr \ S5r Sr\r\rS rS rS'U4S jjrS rSr\S 4U4SjjrU4SjrU4SjrSrS'SjrSrSrSr\ S'Sj5rSr Sr!Sr"Sr#Sr$S\%S\&4Sjr'S\(4S jr)S&S\(4S!jjr*S\+4S"jr,S\+4S#jr-S\+4S$jr.S%r/U=r0$)(PyiModuleGraphCai Directed graph whose nodes represent modules and edges represent dependencies between these modules. This high-level subclass wraps the lower-level `ModuleGraph` class with support for graph and runtime hooks. While each instance of `ModuleGraph` represents a set of disconnected trees, each instance of this class *only* represents a single connected tree whose root node is the Python script originally passed by the user on the command line. For that reason, while there may (and typically do) exist more than one `ModuleGraph` instance, there typically exists only a singleton instance of this class. Attributes ---------- _hooks : ModuleHookCache Dictionary mapping the fully-qualified names of all modules with normal (post-graph) hooks to the absolute paths of such hooks. See the the `_find_module_path()` method for details. _hooks_pre_find_module_path : ModuleHookCache Dictionary mapping the fully-qualified names of all modules with pre-find module path hooks to the absolute paths of such hooks. See the the `_find_module_path()` method for details. _hooks_pre_safe_import_module : ModuleHookCache Dictionary mapping the fully-qualified names of all modules with pre-safe import module hooks to the absolute paths of such hooks. See the `_safe_import_module()` method for details. _user_hook_dirs : list List of the absolute paths of all directories containing user-defined hooks for the current application. _excludes : list List of module names to be excluded when searching for dependencies. _additional_files_cache : AdditionalFilesCache Cache of all external dependencies (e.g., binaries, datas) listed in hook scripts for imported modules. _module_collection_mode : dict A dictionary of module/package collection mode settings set by hook scripts for their modules. _bindepend_symlink_suppression : set A set of paths or path patterns corresponding to shared libraries for which binary dependency analysis should not create symbolic links into top-level application directory. _base_modules: list Dependencies for `base_library.zip` (which remain the same for every executable). )rc >[TU]"SSU0UD6 XlSUlX0lUR U5 UR 5 g)Nexcludes)super__init__ _homepath_top_script_node _excludes_reset_analyze_base_modules)self pyi_homepathuser_hook_dirsr(kwargs __class__s HC:\des-py\RoboSAPF\venv\Lib\site-packages\PyInstaller\depend\analysis.pyr+PyiModuleGraph.__init__jsD 5(5f5% $" N# ""$cSUl[5Ul[5Ul[ 5Ul/UQ[RR[S5[4PUl [RS5 URS5UlURS5UlURS5Ul['[(5UlURHup#[RR-[RRUS55n[/USS S 9n[0R2"UR555nSSS5 UR=WX$5 M [UR*5Ulg!,(df  N?=f![6a M[8a(n[R;S U<S U<35 SnAMSnAff=f) zX Reset for another set of scripts. This is primary required for running the test-suite. Nhooksz(Initializing module graph hook caches...pre_safe_import_modulepre_find_module_pathz rthooks.datrzutf-8)encodingz#Unable to read run-time hooks from z: )r-r_additional_files_cachedict_module_collection_modeset_bindepend_symlink_suppressionospathjoinrHOOK_PRIORITY_BUILTIN_HOOKS_user_hook_dirsloggerinfo _cache_hooks_hooks_hooks_pre_safe_import_module_hooks_pre_find_module_pathrlist_available_rthooksabspathopenast literal_evalreadFileNotFoundError Exceptionerror_merge_rthooks)r1r3uhd_uhd_pathfrthookses r6r/PyiModuleGraph._resetvsr!%';'=$'+v$.1e+  WW\\+w /1L M   >?''+ -1->->?W-X*+/+<+<=S+T(#.d"3**FCwwrww||C'GHH (C':a!..qvvx8G;    7+#'t'>'>"?;:$   HVWXY s<" F-%F F F FF G) G2GGc [U[5(d SU-5eUR5GHAupE[U[5(dU<SU<S35e[U[5(dSU<SU<S35eX@R ;a7[ RSXD[RRUS55 MUHn[U[5(dU<SU<S U<S 35e[RRUSU5n[RRU5(dS U<S U<S U<SU<S3 5eUR URU5 M GMD g)a The expected data structure for a run-time hook file is a Python dictionary of type ``Dict[str, List[str]]``, where the dictionary keys are module names and the sequence strings are Python file names. Check then merge this data structure, updating the file names to be absolute. z&The root element in %s must be a dict.z( must be a dict whose keys are strings; z is not a string.z The value of z key z must be a list.ziRuntime hooks for %s have already been defined. Skipping the runtime hooks for %s that are defined in %s.r_z, item z must be a string.zIn z, key z , the file z expected to be located at z does not exist.N) isinstancerAitemsstrrPrQrJwarningrErFrGexistsappend)r1r_r[r] module_namepython_file_name_listpython_file_nameabs_paths r6rZPyiModuleGraph._merge_rthookssS'4((]*RU]*]](29--/ .Kk3// jS[]hi j/3T:: SF Uefg877<<Y8HIww~~h//H{, [2] msg (here) -> [1] _findCaller -> [0] logger.findCaller 4. Create a logRecord with the caller's information. 5. Handle the logRecord. N )z(unknown file)rz(unknown function)N) LOG_LEVEL_MAPPINGKeyErrorrJ isEnabledForrGmapreprrr ValueError makeRecordnamehandle) r1levelsrqmsgfnlnofuncsinforecords r6rPyiModuleGraph.msgs **51E""5)) CHHSt_56 S#'#3#3#5 BT""6;;3RtUY[`a f    S#R BT5 Ss#B&B6& B32B36CCc/nURH\up4[RRX15n[RR U5(dMJUR XT45 M^ [ X5$)a Create a cache of all hooks of the specified type. The cache will include all official hooks defined by the PyInstaller codebase _and_ all unofficial hooks defined for the current application. Parameters ---------- hook_type : str Type of hooks to be cached, equivalent to the basename of the subpackage of the `PyInstaller.hooks` package containing such hooks (e.g., empty string for standard hooks, `pre_safe_import_module` for pre-safe-import-module hooks, `pre_find_module_path` for pre-find-module-path hooks). )rIrErFrGisdirrhr)r1 hook_type hook_dirs user_hook_dirpriorityuser_hook_type_dirs r6rLPyiModuleGraph._cache_hookssd '+';'; #M"$m!G ww}}/00  "4!?@ (<t//r8c[RS5 /n[H4n[U5(aU[ U5- nM#UR U5 M6 UVVs/sHo0R U5HoDPM M snnUlgs snnf)z> Analyze dependencies of the the modules in base_library.zip. z*Analyzing modules for base_library.zip ...N)rJrKr rrrh import_hook _base_modules)r1 required_modsmreqmods r6r0$PyiModuleGraph._analyze_base_modulessv  @A !A!}}!3A!66 $$Q' " .;\]cFVFVWZF[scF[c]\\s#BNc>URcP[TU] U5UlURHnURURU5 M! UR$U(d URn[TU] XS9$![ar [ SU[ R S9 [R"5RS5n[ USSS[ R 06 [ R"S5 Nf=f) z Wrap the parent's 'run_script' method and create graph from the first script in the analysis, and save its node to use as the "caller" node for all others. This gives a connected graph rather than a collection of unrelated trees. Nz Syntax error in)fileTrr#)caller) r-r* add_script SyntaxErrorprintsysstderr traceback format_exc splitlinesexitradd_edge)r1pathnamerformatted_linesnoder5s r6rPyiModuleGraph.add_scripts  ( (-(:8(D%** d33T:+(( (..7%h%> > )8#**E"+"6"6"8"C"CD"Irs+=#**=  sA??A9C;:C;c[RS5 [5nURR 5Hup4UR USS9nUcM[ U5R[;aURU5 MJURU5 URRX4RUR5 URRUR 5 UR"RUR$5 URU5 M URR&"U6 U(dgGM2)z For each imported module, run this module's post-graph hooks if any. Parameters ---------- analysis: build_main.Analysis The Analysis that calls the hooks z-Processing module hooks (post-graph stage)...F) create_nspkgN)rJrKrCrMrd find_nodetype__name__radd post_graphr@binariesdatasrBupdatemodule_collection_moderDbindepend_symlink_suppressionremove_modules)r1analysishooked_module_namesri module_hook module_nodes r6process_post_graph_hooks'PyiModuleGraph.process_post_graph_hooks,s&  CD#&% -1KK,=,=,?( "nn[unM & $--5GG'++K8&&x0,,00>R>RT_TeTef,,33K4V4VW33::;;d;de$'' 49-@> KK & &(; <'Ur8c[5nU(a[URRUS5nU(aURUR5 UR S5SnU(aM[U$)zU Collect excludedimports from the hooks of the specified module and all its parents. N.r)rCrMgetrexcludedimports rpartition)r1riexcluded_importsrs r6_find_all_excluded_imports)PyiModuleGraph._find_all_excluded_importsls^5++//+tUGbURUR5nU(GabU[:a[U[5(a URnO-SR URR S5SS5nUS:a'SR UR S5SUS- *5nU(aUSU-- nOUnSnU"UUUR5n U (a.[RSXrRU UR5 /$U(aw/n UHdn US-U -n U"U UUR5n U (a-[RSXRXR5 MSU RU 5 Mf U =(d Sn[TU]-XX4U5n U H=n[U5R[;aM"URUR5 M? U $)Nrr#cURS5nUHrnURS5nUS[U5U:HnU(dM.URS5nUS[U5U:HnU(a[RSX@U5 MpUs $ g)z Helper for checking whether given module should be excluded. Returns the name of exclusion rule if module should be excluded, None otherwise. rNz^Deactivating suppression rule %r for module %r because it also applies to the referrer (%r)...)splitlenrJdebug) rir referrer_namemodule_name_partsexcluded_importexcluded_import_partsmatchreferrer_name_partsreferrer_matchs r6_exclude_module9PyiModuleGraph._safe_import_hook.._exclude_modules )4(9(9#(>%+;0?0E0Ec0J- 12M37L3M NRg g 53@2E2Ec2J/-@A\#F[B\-]av-vN- & %78GVc!"!)#22',<( r8zxSuppressing import of %r from module %r due to excluded import %r specified in a hook for %r (or its parent package(s)).)r identifierrrcrrGrrJrrhr*_safe_import_hookrrr)r1target_module_partname source_moduletarget_attr_namesr edge_attrrbase_module_namerexcluded_import_rulefiltered_target_attr_namestarget_attr_namesubmodule_name ret_modules ret_moduler5s r6r PyiModuleGraph._safe_import_hookzs  $ $>>}?W?WX  00!-99+8+C+C(,/88M4L4L4R4RSV4WX[Y[4\+](qy+.884D4J4J34OP]SX[\S\Q]4^+_(-(C2H,HH('=$ >(7$$!,,($ (LL67GIaIacw%00 I%13.,=()9C)?BR)R/>*,)440, 0"LL!EFTVnVn 46N6N 7==>NO->$)C(Jd%g/ "3DY &JJ((0BB  + +J,A,A B &r8c>URRUS5nUb[RR UR 5upV[ RSXe5 SURSS5-n[XtR 5n[UUUUS9n [US5(d[SU-5eURU 5 U RnU Rn[ T U]EXU5$) a Create a new graph node for the module with the passed name under the parent package signified by the passed graph node. This method wraps the superclass method with support for pre-import module hooks. If such a hook exists for this module (e.g., a script `PyInstaller.hooks.hook-{module_name}` containing a function `pre_safe_import_module()`), that hook will be run _before_ the superclass method is called. Pre-Safe-Import-Hooks are performed just *prior* to importing the module. When running the hook, the modules parent package has already been imported and ti's `__path__` is set up. But the module is just about to be imported. See the superclass method for description of parameters and return value. Nz1Processing pre-safe-import-module hook %r from %r)PyInstaller_hooks_pre_safe_import_module_rr\) module_graphmodule_basenameriparent_packager<z9pre_safe_import_module() function not defined by hook %r.)rNpoprErFr hook_filenamerJrKreplacerrhasattr NameErrorr<rrir*_safe_import_module) r1rrirhook hook_path hook_basenamehook_module_name hook_modulehook_apir5s r6r"PyiModuleGraph._safe_import_modules"1155k4H  ')ww}}T5G5G'H $I KKK] fJ[M`M`adfiMjj /0@BTBTUK.! /'- H;(@AA [^i ijj  . .x 8'66O"..Kw*?XXr8c>URRUS5nUb[RR UR 5upV[ RSXe5 SURSS5-n[XtR 5n[UUUS9n [US5(d[SU-5eURU 5 U Rn[T U]AXU5$) a Get a 3-tuple detailing the physical location of the module with the passed name if that module exists _or_ raise `ImportError` otherwise. This method wraps the superclass method with support for pre-find module path hooks. If such a hook exists for this module (e.g., a script `PyInstaller.hooks.hook-{module_name}` containing a function `pre_find_module_path()`), that hook will be run _before_ the superclass method is called. See superclass method for parameter and return value descriptions. Nz/Processing pre-find-module-path hook %r from %r'PyInstaller_hooks_pre_find_module_path_rr\)rri search_dirsr=z7pre_find_module_path() function not defined by hook %r.)rOrrErFrrrJrKrrrrrr=rr*_find_module_path) r1fullnamerirrrr hook_fullnamerrr5s r6r PyiModuleGraph._find_module_paths//33HdC  ')ww}}T5G5G'H $I KKI= dEHXHXY\^aHbbM/ ?Q?QRK,!$'H;(>?? Y\g ghh  , ,X 6#..Kw( LLr8c0n[nURURS9HJn[U5RnXB;dMUR (dM2UR XR 'ML U$)z Get code objects from ModuleGraph for pure Python modules. This allows to avoid writing .pyc/pyo files to hdd at later stage. :return: Dict with module name and code object. start)r iter_graphr-rrcoder)r1 code_dict mod_typesrmg_types r6get_code_objectsPyiModuleGraph.get_code_objectsDsb , OO$*?*?O@D 4j))G#99915Ioo.Ar8c[5nURURS9H*nURX15nUcMUR U5 M, U$)a1 Return the name, path and type of selected nodes as a TOC. The selection is determined by the given list of PyInstaller TOC typecodes. If that list is empty we return the complete flattened graph as a TOC with the ModuleGraph note types in place of typecodes -- meant for debugging only. Normally we return ModuleGraph nodes whose types map to the requested PyInstaller typecode(s) as indicated in the MODULE_TYPES_TO_TOC_DICT. We use the ModuleGraph (really, ObjectGraph) flatten() method to scan all the nodes. This is patterned after ModuleGraph.report(). r)rPrr- _node_to_tocrh)r1typecodetocrentrys r6 _make_tocPyiModuleGraph._make_tocYsRfOO$*?*?O@D%%d5E  5! A  r8c,UR[5$)z2 Return all pure Python modules formatted as TOC. )r r r1s r6 make_pure_tocPyiModuleGraph.make_pure_tocls ~~677r8c,UR[5$)z4 Return all binary Python modules formatted as TOC. )r r r s r6make_binaries_toc PyiModuleGraph.make_binaries_tocss~~122r8c,UR[5$)z5 Return all MISSING Python modules formatted as TOC. )r r r s r6make_missing_tocPyiModuleGraph.make_missing_tocys~~.//r8c[U5RnUceU(aX!;agUS:XaK[RR UR 5up4[RR U5nO"US:XaURS-nO URnUR b UR OSn[U5n[UnX5U4$)NScriptExtensionPackagez .__init__r;) rrrErFsplitextfilenamebasenamerrer )rrrr}extrFtoc_types r6rPyiModuleGraph._node_to_tocst*%%""" / h ''**4==9KT77##D)D * *??[0D??D $ 9t}}r 4y+G48##r8cNUVs/sHo RU5PM sn$s snf)a  Given a list of nodes, create a TOC representing those nodes. This is mainly used to initialize a TOC of scripts with the ones that are runtime hooks. The process is almost the same as _make_toc(), but the caller guarantees the nodes are valid, so minimal checking. )r)r1nodesrs r6 nodes_to_tocPyiModuleGraph.nodes_to_tocs% 5::ED!!$'E:::s"c\URU5nUcg[U5RS:H$)NF BuiltinModule)rrr)r1r}rs r6 is_a_builtinPyiModuleGraph.is_a_builtins-~~d# <Dz""o55r8c^^UU4SjnTRT5nUc/$TRU5upESU5nUVs/sH ofU"U54PM sn$s snf)a List all modules importing the module with the passed name. Returns a list of (identifier, DependencyIinfo)-tuples. If the names module has not yet been imported, this method returns an empty list. Parameters ---------- name : str Fully-qualified name of the module to be examined. Returns ---------- list List of (fully-qualified names, DependencyIinfo)-tuples of all modules importing the module with the passed fully-qualified name. cz>TRRUT5nUbTRRU5$gro)graph edge_by_node edge_data)importeredger}r1s r6get_importer_edge_data.get_importer_edge_datas9::**8T:Dzz++D11 r8c3B# UHocMURv M g7fro)r).0r,s r6 /PyiModuleGraph.get_importers..s[X(X((s)r get_edges)r1r}r.rr\ importersr,s`` r6 get_importersPyiModuleGraph.get_importerss]& 2 ~~d# <I~~d+ [[ MVWY1(;>"45*2 &XX222 $ 7 7 AH/1ww}}X/F,IKK Dm_!(()BC!B +3r8cURceUHnURU5nUb[RSU5 O>[R SU5 UR U5n[ U5S:XdeUSnURURU5 M g![a [RSU5 Mf=f)z Add hidden imports that are either supplied as CLI option --hidden-import=MODULENAME or as dependencies from some PyInstaller features when enabled (e.g., crypto feature). NzHidden import %r already foundzAnalyzing hidden import %rr#rzHidden import %r not found) r-rrJrrKrr ImportErrorrYr)r1 module_listmodnmrr s r6add_hiddenimports PyiModuleGraph.add_hiddenimportss $$000 E>>%(D =uE 8%@ ,,U3Eu:?*? 8D MM$// 6!!#LL!=uEs'B CCmodulereturnch0n[S1-nURU5nU(aURU5nUHvnUcM[U5RU;aM#UR nXq:XdUR US-5(aMOURcM^URX&R 'Mx U$)z. Find modules that import a given **module**. rr)r rincomingrrr startswithr)r1rFco_dictpure_python_module_typesr referrersr>rs r6get_code_usingPyiModuleGraph.get_code_using s#; ? $  ~~f%  d+I97##+CC\\ ':+@+@#+N+N66>() %!"r8c[5nXRSS/S/5-nSHnXRU/SQ/5-nM U$)z; Collect metadata for all packages that appear to need it. pkg_resourcesget_distributionrequire)zimportlib.metadataimportlib_metadata)metadata distributionversionfilesrequires)rC_metadata_from)r1outrTs r6metadata_required PyiModuleGraph.metadata_required*sb e ""   K  #O  &&"L C#O r8c SSKJn SSKJn [ 5n[ 5nUH.nUR [ R"US-U-55 M0 UH.nUR [ R"US-U-55 M0 [ 5n URU5R5Hup[ R"U 5R5H`n U HWup[U5S:waMUSnX;aU R U"U55 M:X;aU R U"USS95 MWMY Mb M U $!URa Mxf=f)a[ Collect metadata whose requirements are implied by given function names. Args: package: The module name that must be imported in a source file to trigger the search. methods: Function names from **package** which take a distribution name as an argument and imply that metadata is required for that distribution. recursive_methods: Like **methods** but also implies that a distribution's dependencies' metadata must be collected too. Returns: Required metadata in hook data ``(source, dest)`` format as returned by :func:`PyInstaller.utils.hooks.copy_metadata()`. Scan all source code to be included for usage of particular *key* functions which imply that that code will require metadata for some distribution (which may not be its own) at runtime. In the case of a match, collect the required metadata. r) copy_metadata)rTrr#T) recursive)PyInstaller.utils.hooksr_PyInstaller.compatrTrCrr any_aliasrNrdrecursive_function_callsvaluesrPackageNotFoundError)r1packagemethodsrecursive_methodsr_rT need_metadataneed_recursive_metadatamethodr[r}rcalls function_namerqs r6rZPyiModuleGraph._metadata_fromCs;( :9 "%%F  !3!3GcMF4J!K L'F # * *8+=+=gmf>T+U V(e--g6<<>JD!::4@GGI+0'M4yA~ "1gG!(9JJ}W'=>*EJJ}W'MNF,1J?" .BB! !s<EEE E cURURS9Vs/sH3n[U5RS:XdM[ UR 5PM5 sn$s snf)z/ Return the list of collected python packages. rr)rr-rrrer)r1rs r6get_collected_packages%PyiModuleGraph.get_collected_packageswsW .2__4CXCX_-Y -YTDz""i/ !C -Y   s AAc/nURURS9HOn[UR5nURR U5HupEUR XES45 M MQ U$)z6 Return the TOC list of binaries collected by hooks." rBINARY)rr-rerr@rrhr1rrri dest_namesrc_names r6make_hook_binaries_toc%PyiModuleGraph.make_hook_binaries_tocsjOO$*?*?O@Ddoo.K'+'C'C'L'L['Y#  I:;(ZA  r8c/nURURS9HOn[UR5nURR U5HupEUR XES45 M MQ U$)z8 Return the TOC list of data files collected by hooks." rDATA)rr-rerr@rrhrus r6make_hook_datas_toc"PyiModuleGraph.make_hook_datas_tocsjOO$*?*?O@Ddoo.K'+'C'C'I'I+'V#  I89(WA  r8) r@rQrrDr.r,rMrOrNrBr-rIr)r)ro)1r __module__ __qualname____firstlineno____doc__rrrrvr+r/rZ staticmethodrrrmsginmsgoutrLr0rrrrrrrrr rrrrr!r%r6r>rDrerArNrCr\rZrPrqrxr|__static_attributes__ __classcell__)r5s@r6r!r!Cs-!H!Uu5I %'@R#FJ22 : E F02 ]?4>@  Ocnrtl+YZ%MN*&83 0  $ $D;6 XBB72ST<32232h     T  r8r!cU=(d SnU=(d SnSU;aUS- n[(aK[RU:Xa7[RS5 [ [5nUR U5 U$[RS5 [ [U[5US9n[(dA[RS5 [ U5qS[l S[l S[l U$) aj Create the cached module graph. This function might appear weird but is necessary for speeding up test runtime because it allows caching basic ModuleGraph object that gets created for 'base_library.zip'. Parameters ---------- excludes : list List of the fully-qualified names of all modules to be "excluded" and hence _not_ frozen into the executable. user_hook_dirs : list List of the absolute paths of all directories containing user-defined hooks for the current application or `None` if no such directories were specified. Returns ---------- PyiModuleGraph Module graph with core dependencies. r)__main__)rz)Reusing cached module dependency graph...z'Initializing module dependency graph...)r(impliesr3z"Caching module dependency graph...N) _cached_module_graph_r.rJrKrr/r!rrrMrNrO)r(r3r)s r6initialize_modgraphrs*$)rN~2H!M! !6!@!@H!L ?@./ ^$  KK9:  %  E !  89 ((,$>B;<@9 Lr8c[S5n[5n[RR [ SS5nSHin[U5n[ US5(dM![RRUR5n[X5S5nURXeS45 Mk URS[RRUR5S45 US[RR US 5S4S [RR US 5S4S [RR US 5S4/- n[(a2URS[RR US5S45 URS[RR US5S45 U$)zZ Get TOC with the bootstrapping modules and their dependencies. :return: TOC with modules struct PyInstallerloader)_structzlib__file__ EXTENSIONPYMODULEpyimod01_archivezpyimod01_archive.pypyimod02_importerszpyimod02_importers.pypyimod03_ctypeszpyimod03_ctypes.pypyimod04_pywin32zpyimod04_pywin32.pypyiboot01_bootstrapzpyiboot01_bootstrap.pyPYSOURCE) __import__rPrErFrGrrrRrrrhr) mod_struct loader_mods loaderpathr=rmod_filemod_dests r6get_bootstrap_modulesrsj H%J&Kh x@J(" 3 # #wws||4H6h+VH   K@ A("''//*2E2E"F ST RWW\\*6KLjY rww||J8OPR\] BGGLL5IJJWK v. ZI^0_aklm-rww||JH`/acmno r8r~):rrTrErr collectionsrcopyrrrrrloggingPyInstaller.building.utilsrrbr r r r r rrrPyInstaller.dependrPyInstaller.depend.imphookrrPyInstaller.depend.imphookapirr(PyInstaller.lib.modulegraph.find_modulesr'PyInstaller.lib.modulegraph.modulegraphrrrrPyInstaller.logrrrrarr getLoggerrrJrHHOOK_PRIORITY_CONTRIBUTED_HOOKSHOOK_PRIORITY_UPSTREAM_HOOKSHOOK_PRIORITY_USER_HOOKSr!rrrr)r8r6rs2 #-&E(LX@uu..B   8 $$"' T [T n@F!r8