U
|
W ±dâ´ ã @ s8 d Z ddlZddlZddlZddlZddlZddlmZ ddlm Z ddl
|
m Z m Z ddl
|
m Z ddlmZ ddlmZmZmZmZmZmZmZmZ dd lmZ dd
|
l m Z m Z dd l m Z m!Z! dd l"m#Z# dd l$m%Z%m&Z&m'Z' ddl(m)Z)m*Z*m+Z+ ddl,m-Z-m.Z. e /e0¡Z1G dd de%Z2da3dddZ4dd Z5dS )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)Úadd_suffix_to_extension)ÚBAD_MODULE_TYPESÚBINARY_MODULE_TYPESÚMODULE_TYPES_TO_TOC_DICTÚPURE_PYTHON_MODULE_TYPESÚPY3_BASE_MODULESÚVALID_MODULE_TYPESÚimportlib_load_sourceÚis_win)Úbytecode)ÚAdditionalFilesCacheÚModuleHookCache)ÚPreFindModulePathAPIÚPreSafeImportModuleAPI)Ú get_implies)Ú ModuleGraphÚDEFAULT_IMPORT_LEVELÚABSOLUTE_IMPORT_LEVEL)ÚDEBUGÚINFOÚTRACE)Úcollect_submodulesÚ
|
is_packagec sR e Zd ZdZeeeeedZd? fdd Zdd Z dd Z
|
e d
|
d Z d d Z e Ze Zdd Zdd Zd@ fdd Zdd Zdd Zedf fdd Z fdd Z fd d Zd d ZdAd!d"Zd#d$ Zd%d& Z d'd( Z e dBd)d*Z d+d, Z d-d. Z d/d0 Z!d1d2 Z"d3d4 Z#e$e%d5d6d7Z&e'd8d9d:Z(dCe'd8d;d<Z)e*d8d=d>Z+ Z,S )DÚPyiModuleGraphaþ
|
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.
|
_base_modules: list
|
Dependencies for `base_library.zip` (which remain the same for every executable).
|
)r é é é é © c s> t jf d|i| || _d | _|| _| |¡ | ¡ d S )NÚexcludes)ÚsuperÚ__init__Z _homepathÚ_top_script_nodeÚ _excludesÚ_resetÚ_analyze_base_modules)ÚselfZ pyi_homepathÚuser_hook_dirsr$ Úkwargs©Ú __class__r# úRd:\z\workplace\vscode\pyvenv\venv\Lib\site-packages\PyInstaller/depend/analysis.pyr& b s
|
zPyiModuleGraph.__init__c C s& d| _ t | _t | _|tj td¡f| _ t
|
d¡ | d¡| _ | d¡| _| d¡| _tt| _| j D ]ª}tj tj |d¡¡}z,t|dd d
|
}t | ¡ ¡}W 5 Q R X W nT tk
|
rÈ Y qjY n> tk
|
r } z t
|
d ||f ¡ W Y ¢qjW 5 d}~X Y nX | |||¡ qjt| j| _dS ) zh
|
Reset for another set of scripts. This is primary required for running the test-suite.
|
NÚhooksz Caching module graph hooks...Ú Úpre_safe_import_moduleÚpre_find_module_pathz rthooks.datÚrzutf-8)Úencodingz)Unable to read run-time hooks from %r: %s) r' r Ú_additional_files_cacheÚdictÚ_module_collection_modeÚosÚpathÚjoinr Ú_user_hook_dirsÚloggerÚinfoÚ _cache_hooksÚ_hooksÚ _hooks_pre_safe_import_moduleÚ_hooks_pre_find_module_pathr ÚlistÚ_available_rthooksÚabspathÚopenÚastÚ literal_evalÚreadÚFileNotFoundErrorÚ ExceptionÚerrorÚ_merge_rthooks)r+ r, ÚuhdÚuhd_pathÚfÚrthooksÚer# r# r0 r) n s*
|
|
|
zPyiModuleGraph._resetc
|
C sì t |tstd| | ¡ D ]È\}}t |ts@td||f t |tsZtd||f || jkrt d||t j
|
|d¡¡ q |D ]`}t |ts¤td|||f t j
|
|d|¡}t j
|
|¡sÔtd||||f | j| |¡ qq dS ) a9
|
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=%s must be a dict whose keys are strings; %s is not a string.z&The value of %s key %s must be a list.ziRuntime hooks for %s have already been defined. Skipping the runtime hooks for %s that are defined in %s.rR z$%s key %s, item %r must be a string.zGIn %s, key %s, the file %r expected to be located at %r does not exist.N)Ú
|
isinstancer8 ÚAssertionErrorÚitemsÚstrrD rE r> Úwarningr: r; r< ÚexistsÚappend)r+ rR rO rP Ú module_nameZpython_file_name_listZpython_file_nameÚabs_pathr# r# r0 rN s6
|
ÿ
|
ÿ
|
þ ÿ
|
ÿÿz PyiModuleGraph._merge_rthooksc O s t j| |S ©N)r> Ú
|
findCaller)Úargsr- r# r# r0 Ú _findCaller¶ s zPyiModuleGraph._findCallerc
|
G s® z| j | }W n tk
|
r$ Y dS X t |¡s4dS d|d tt|¡f }z| ¡ \}}}}W n tk
|
r d\}}}}Y nX t tj
|
||||g d|d|¡
|
} t | ¡ dS )aÇ
|
Print a debug message with the given level.
|
|
1. Map the msg log level to a logger log level.
|
2. Generate the message format (the same format as ModuleGraph)
|
3. Find the caller, which findCaller expects three stack-frames above itself:
|
[3] caller -> [2] msg (here) -> [1] _findCaller -> [0] logger.findCaller
|
4. Create a logRecord with the caller's information.
|
5. Handle the logRecord.
|
Nz%s %sú )z(unknown file)r z(unknown function)N) ÚLOG_LEVEL_MAPPINGÚKeyErrorr> Ú isEnabledForr< ÚmapÚreprr` Ú
|
ValueErrorÚ
|
makeRecordÚnameÚhandle)
|
r+ ÚlevelÚsr_ ÚmsgÚfnÚlnoÚfuncÚsinfoÚrecordr# r# r0 rm ¼ s
|
zPyiModuleGraph.msgc C s> g }| j D ](}tj ||¡}tj |¡r
|
| |¡ q
|
t| |S )aó
|
Get a cache of all hooks of the passed 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., `post_create_package` for post-create package hooks).
|
)r= r: r; r< ÚisdirrZ r )r+ Z hook_typeZ hook_dirsZ user_hook_dirZuser_hook_type_dirr# r# r0 r@ Ü s
|
zPyiModuleGraph._cache_hooksc sP t d¡ g }tD ]$}t|r,|t|7 }q| |¡ q fdd|D _dS )zN
|
Analyze dependencies of the the modules in base_library.zip.
|
z Analyzing base_library.zip ...c s g | ]} |¡D ]}|qqS r# )Ú import_hook)Ú.0ÚreqÚmod©r+ r# r0 Ú
|
<listcomp> s z8PyiModuleGraph._analyze_base_modules.<locals>.<listcomp>N)r> r? r r r rZ Ú _base_modules)r+ Z required_modsÚmr# rx r0 r* ô s
|
z$PyiModuleGraph._analyze_base_modulesNc s° | j dkrzt |¡| _ W nT tk
|
rp td|tjd t ¡ d¡}t|dd
dtji t
|
d¡ Y nX | j D ]}| | j |¡ qx| j S |s| j }t j||dS dS ) a
|
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)ÚfileTéüÿÿÿr| r )Úcaller) r' r% Ú
|
add_scriptÚ SyntaxErrorÚprintÚsysÚstderrÚ tracebackÚ
|
format_excÚ
|
splitlinesÚexitrz Úadd_edge)r+ Úpathnamer~ Zformatted_linesÚnoder. r# r0 r s
|
|
zPyiModuleGraph.add_scriptc C s® t d¡ t }| j ¡ D ]z\}}| j|dd}|dkr:qt|jtkrT| |¡ q|D ]0}|
|
|¡ | j ||j |j ¡ | j |j¡ qX| |¡ q| jj| |s
|
qªq
|
dS )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
|
|
zProcessing module hooks...F)Z create_nspkgN)r> r? ÚsetrA rV Ú find_nodeÚtypeÚ__name__r ÚaddZ
|
post_graphr7 ZbinariesZdatasr9 ÚupdateZmodule_collection_modeZremove_modules)r+ ZanalysisZhooked_module_namesr[ Z module_hooksZ module_nodeÚ module_hookr# r# r0 Úprocess_post_graph_hooks s"
|
|
|
z'PyiModuleGraph.process_post_graph_hooksc C s> t }|r:| j |g ¡D ]}| |j¡ q| d¡d }q|S )ze
|
Collect excludedimports from the hooks of the specified module and all its parents.
|
Ú.r )r rA Úgetr ZexcludedimportsÚ
|
rpartition)r+ r[ Úexcluded_importsr r# r# r0 Ú_find_all_excluded_imports\ s z)PyiModuleGraph._find_all_excluded_importsc s |d k rì| |j¡}|rì|tkrb|r4|jd | }n|j}|dkrfd | d¡d |d
¡}n|}dd }|||} | rt d||j| |j¡ g S |rìg }
|
|D ]@} |d | } || |} | rØt d| |j| |j¡ q¢|
|
| ¡ q¢|
|
pêd }t |||||¡S )Nr r c S sB | d¡}|D ].}| d¡}|dt|
|k}|r| S qdS )zË
|
Helper for checking whether given module should be excluded.
|
Returns the name of exclusion rule if module should be excluded, None otherwise.
|
r N)ÚsplitÚlen)r[ r Zmodule_name_partsZexcluded_importZexcluded_import_partsÚmatchr# r# r0 Ú_exclude_module s
|
|
|
z9PyiModuleGraph._safe_import_hook.<locals>._exclude_modulezxSuppressing import of %r from module %r due to excluded import %r specified in a hook for %r (or its parent package(s)).)
|
r Ú
|
identifierr r< r r> ÚdebugrZ r% Ú_safe_import_hook) r+ Ztarget_module_partnameZ source_moduleZtarget_attr_namesrk Z edge_attrr Zbase_module_namer Zexcluded_import_ruleZfiltered_target_attr_namesZtarget_attr_nameZsubmodule_namer. r# r0 r i sJ
|
ý
|
ý z PyiModuleGraph._safe_import_hookc s || j kr| j | D ]l}t d||j¡ d| dd¡ }t||j}t| |||d}t|dsjtd| | |¡ |j
|
}|j }q| j |= t |||¡S )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.
|
z2Processing pre-safe import module hook %s from %r.Z)PyInstaller_hooks_pre_safe_import_module_r Ú_)Ú module_graphÚmodule_basenamer[ Úparent_packager3 z9pre_safe_import_module() function not defined by hook %r.)rB r> r? Ú hook_filenameÚreplacer r ÚhasattrÚ NameErrorr3 r¡ r[ r% Ú_safe_import_module)r+ r¡ r[ r¢ ÚhookZhook_module_nameÚ hook_moduleÚhook_apir. r# r0 r§ ² s$
|
ü
|
|
z"PyiModuleGraph._safe_import_modulec s || j kr| j | D ]d}t d||j¡ d| dd¡ }t||j}t| ||d}t|dshtd| | |¡ |j
|
}q| j |= t |||¡S )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.
|
z0Processing pre-find module path hook %s from %r.Z'PyInstaller_hooks_pre_find_module_path_r r )r r[ Ú search_dirsr4 z7pre_find_module_path() function not defined by hook %r.) rC r> r? r£ r¤ r r r¥ r¦ r4 r« r% Ú_find_module_path)r+ Úfullnamer[ r« r¨ Z hook_fullnamer© rª r. r# r0 r¬ á s
|
ý
|
|
z PyiModuleGraph._find_module_pathc C sD i }t }| j| jdD ](}t|j}||kr|jr|j||j< q|S )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' r r Úcoder )r+ Z code_dictZ mod_typesr Úmg_typer# r# r0 Úget_code_objects
|
s
|
z PyiModuleGraph.get_code_objectsc C sf dd t¡ d }t |¡}t }| j| jdD ]0}| |j¡rBq0| ||¡}|dk r0|
|
|¡ q0|S )ai
|
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().
|
ú(ú|z)(\.|$)r® N) r< r ÚreÚcompilerD r° r' r r Ú _node_to_tocrZ )r+ ÚtypecodeZ regex_strZ module_filterZtocr Úentryr# r# r0 Ú _make_toc s
|
zPyiModuleGraph._make_tocc C s
|
| t¡S )zB
|
Return all pure Python modules formatted as TOC.
|
)r» r rx r# r# r0 Ú make_pure_toc= s z PyiModuleGraph.make_pure_tocc C s
|
| t¡S )zD
|
Return all binary Python modules formatted as TOC.
|
)r» r rx r# r# r0 Úmake_binaries_tocD s z PyiModuleGraph.make_binaries_tocc C s
|
| t¡S )zE
|
Return all MISSING Python modules formatted as TOC.
|
)r» r rx r# r# r0 Úmake_missing_tocJ s z PyiModuleGraph.make_missing_tocc C s t | j}|d k st|r&||kr&d S |dkrNtj | j¡\}}tj |¡}n|dkrb| jd }n| j}| jd k rx| jnd}t |}t
|
| }|||fS )NÚScriptZExtensionPackagez .__init__r2 ) r r rU r: r; ÚsplitextÚfilenameÚbasenamer rW r
|
)r r¹ r² ri Úextr; Ztoc_typer# r# r0 r¸ P s
|
zPyiModuleGraph._node_to_tocc s fdd|D S )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.
|
c s g | ]} |¡qS r# )r¸ ©ru r rx r# r0 ry y s z/PyiModuleGraph.nodes_to_toc.<locals>.<listcomp>r# )r+ Únodesr# rx r0 Ú nodes_to_tocs s zPyiModuleGraph.nodes_to_tocc C s$ | |¡}|d krdS t|jdkS )NFZ BuiltinModule)r r r )r+ ri r r# r# r0 Ú is_a_builtin| s
|
zPyiModuleGraph.is_a_builtinc sR fdd ¡}|dkr$g S |¡\}}dd |D } fdd|D S )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.
|
|
c s& j | ¡}|d k r"j |¡S d S r] )ÚgraphZ edge_by_nodeZ edge_data)ÚimporterZedge)ri r+ r# r0 Úget_importer_edge_data s z<PyiModuleGraph.get_importers.<locals>.get_importer_edge_dataNc s s | ]}|d k r|j V qd S r] )r ©ru rÉ r# r# r0 Ú <genexpr> s z/PyiModuleGraph.get_importers.<locals>.<genexpr>c s g | ]}| |fqS r# r# rË )rÊ r# r0 ry s z0PyiModuleGraph.get_importers.<locals>.<listcomp>)r Z get_edges)r+ ri r r Ú importersr# )rÊ ri r+ r0 Ú get_importers s
|
z PyiModuleGraph.get_importersc C s g }t d¡ |rD|D ],}t d|¡ tj |¡}| | |¡¡ q| t¡}|D ]@\}}}|| j krR| j | D ] }t d|¡ | | |¡¡ qpqR|S )z
|
Analyze custom run-time hooks and run-time hooks implied by found modules.
|
|
:return : list of Graph nodes.
|
z Analyzing run-time hooks ...z!Including custom run-time hook %rzIncluding run-time hook %r)
|
r> r? r: r; rF rZ r r» r rE ) r+ Zcustom_runhooksZ rthooks_nodesZ hook_fileZtemp_tocÚmod_namer; r¹ r\ r# r# r0 Úanalyze_runtime_hooks£ s
|
|
|
z$PyiModuleGraph.analyze_runtime_hooksc C s¢ | j dk st|D ]}| |¡}|dk r6t d|¡ nXt d|¡ z&| |¡}t|dks^t|d }W n$ tk
|
r t d|¡ Y qY nX |
|
| j |¡ qdS )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).
|
Nz Hidden import %r already foundzAnalyzing hidden import %rr r zHidden import %r not found) r' rU r r> r r? rt r Ú ImportErrorrM r )r+ Z module_listZmodnmr rÅ r# r# r0 Úadd_hiddenimportsà s
|
|
|
z PyiModuleGraph.add_hiddenimports)ÚmoduleÚreturnc C s i }t dhB }| |¡}|r| |¡}|D ]T}|dkr8q*t|j|krHq*|j}||ks*| |d ¡rfq*|jdkrrq*|j||j< q*|S )z>
|
Find modules that import a given **module**.
|
r¿ Nr )r r Úincomingr r r Ú
|
startswithr± )r+ rÓ Zco_dictZpure_python_module_typesr Z referrersr5 r r# r# r0 Úget_code_usingÜ s& ÿ
|
|
|
z PyiModuleGraph.get_code_using)rÔ c
|
C sF t }|| ddgdg¡O }dD ] }|| |ddddd gg ¡O }q |S )
|
zK
|
Collect metadata for all packages that appear to need it.
|
Ú pkg_resourcesÚget_distributionÚrequire)zimportlib.metadataÚimportlib_metadataÚmetadataÚ distributionÚversionÚfilesÚrequires)r Ú_metadata_from)r+ ÚoutrÛ r# r# r0 Úmetadata_requiredú s ý ýz PyiModuleGraph.metadata_requiredc C s ddl m} ddlm} t }t }|D ] }| t |d | ¡¡ q(|D ] }| t |d | ¡¡ qJt } | |¡ ¡ D ]\}
|
} t
|
| ¡ ¡ D ]z} | D ]p\} }t |dkr°q|d }z6| |krÒ| ||¡ n| |krì| ||dd¡ W q |k
|
r Y qY qX qqq|| S )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 )ÚDistributionNotFound)Ú copy_metadatar r T)Ú recursive) rØ rä ÚPyInstaller.utils.hooksrå r r r Z any_aliasr× rV Zrecursive_function_callsÚvaluesr )r+ ÚpackageÚmethodsZrecursive_methodsrä rå Z need_metadataZneed_recursive_metadataÚmethodrâ ri r± ZcallsZ function_namer_ r# r# r0 rá s. z PyiModuleGraph._metadata_fromc C s dd | j | jdD S )z?
|
Return the list of collected python packages.
|
c S s$ g | ] }t |jd krt|jqS )ÚPackage)r r rW r rÄ r# r# r0 ry M s ÿz9PyiModuleGraph.get_collected_packages.<locals>.<listcomp>r® )r° r' rx r# r# r0 Úget_collected_packagesH s ÿz%PyiModuleGraph.get_collected_packages)r# r# )N)N)N)r# r# )-r Ú
|
__module__Ú __qualname__Ú__doc__r r r rb r& r) rN Ú staticmethodr` rm ZmsginZmsgoutr@ r* r r r r r r§ r¬ r³ r» r¼ r½ r¾ r¸ rÆ rÇ rÎ rÐ rÒ rW r8 r× r rã rá rD rí Ú __classcell__r# r# r. r0 r > sH ! #%
|
? ÿI / )
|
" ! 5r r# c C s |pd}| pd} t r>t j| kr>t d¡ tt }| |¡ |S t d¡ tt| t |d}t st d¡ t|a dt _ dt _
|
dt _ |S )a¦
|
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# z)Reusing cached module dependency graph...z'Initializing module dependency graph...)r$ Zimpliesr, z"Caching module dependency graph...N) Ú_cached_module_graph_r( r> r? r r) r r r rA rB rC )r$ r, rÈ r# r# r0 Úinitialize_modgraphV s*
|
|
|
û
|
rô c C s t d} t }tj tdd¡}dD ]\}t |}t|dr"tj |j¡}tj tj
|
|¡¡dkrltj d|¡}| t ||d¡ q"| dtj | j¡df¡ |d tj |d
|
¡dfd tj |d ¡dfd tj |d¡dfg7 }t rö| dtj |d¡df¡ | dtj |d¡df¡ |S )zf
|
Get TOC with the bootstrapping modules and their dependencies.
|
:return: TOC with modules
|
ÚstructÚ PyInstallerÚloader)Ú_structÚzlibÚ__file__z lib-dynloadZ EXTENSIONZPYMODULEZpyimod01_archivezpyimod01_archive.pyZpyimod02_importerszpyimod02_importers.pyZpyimod03_ctypeszpyimod03_ctypes.pyZpyimod04_pywin32zpyimod04_pywin32.pyZpyiboot01_bootstrapzpyiboot01_bootstrap.pyZPYSOURCE)Ú
|
__import__rD r: r; r< r r¥ rF rú r ÚdirnamerZ r r )Z
|
mod_structZ loader_modsZ
|
loaderpathrÏ rw Zmod_filer# r# r0 Úget_bootstrap_modules s(
|
ýrý )r# r# )6rð rH r: r¶ r r Ú collectionsr Úcopyr rö r r r ÚloggingZPyInstaller.building.utilsr ZPyInstaller.compatr r r
|
r r r r r ZPyInstaller.dependr ZPyInstaller.depend.imphookr r Z PyInstaller.depend.imphookapir r Z(PyInstaller.lib.modulegraph.find_modulesr Z'PyInstaller.lib.modulegraph.modulegraphr r r ZPyInstaller.logr r r rç r r Ú getLoggerr r> r ró rô rý r# r# r# r0 Ú<module> s: (
|
|
;
|
