U
|
X ±dV ã @ s° d Z ddlZddlZddlZddlZddlZddlZddlmZm Z ej
|
ej Z e e ZeeZejjrxejrxdd Zndd Zdd ZG d d
|
d
|
ZG d d d Zd d ZdS )z8
|
PEP-302 and PEP-451 importers for frozen applications.
|
é N)ÚArchiveReadErrorÚZlibArchiveReaderc G s t j | | ¡ t j d¡ d S )NÚ
|
)ÚsysÚstderrÚwrite©ÚmsgÚa© r ú\d:\z\workplace\vscode\pyvenv\venv\Lib\site-packages\PyInstaller/loader/pyimod02_importers.pyÚtrace' s r c G s d S ©Nr r r r r r , s c C s8 t | ¡j}t |¡}t jddd}| | |d ¡¡S )a
|
Decode bytes representing source code and return the string. Universal newline support is used in the decoding.
|
Based on CPython's implementation of the same functionality:
|
https://github.com/python/cpython/blob/3.9/Lib/importlib/_bootstrap_external.py#L679-L688
|
NT)ÚdecoderÚ translater )ÚioÚBytesIOÚreadlineÚtokenizeÚdetect_encodingÚIncrementalNewlineDecoderÚdecode)Ú source_bytesÚsource_bytes_readlineÚencodingÚnewline_decoderr r r Ú_decode_source0 s
|
r c @ sj e Zd ZdZdd Zdd Zdd Zdd Zd
|
d Zd d Z dd Z
|
dddZ dd Z dd Z dd ZdS )ÚFrozenImportera{
|
Load bytecode of Python modules from the executable created by PyInstaller.
|
|
Python bytecode is zipped and appended to the executable.
|
|
NOTE: PYZ format cannot be replaced by zipimport module.
|
|
The problem is that we have no control over zipimport; for instance, it does not work if the zip file is embedded
|
into a PKG that is appended to an executable, like we create in one-file mode.
|
|
This used to be PEP-302 finder and loader class for the ``sys.meta_path`` hook. A PEP-302 finder requires method
|
find_module() to return loader class with method load_module(). However, both of these methods were deprecated in
|
python 3.4 by PEP-451 (see below). Therefore, this class now provides only optional extensions to the PEP-302
|
importer protocol.
|
|
This is also a PEP-451 finder and loader class for the ModuleSpec type import system. A PEP-451 finder requires
|
method find_spec(), a PEP-451 loader requires methods exec_module(), load_module() and (optionally) create_module().
|
All these methods are implemented in this one class.
|
|
To use this class just call:
|
FrozenImporter.install()
|
c C s t jD ]r}z>t|dd| _t j |¡ t| jj ¡ | _td| W dS t k
|
r` Y qY q t
|
k
|
rv Y qY qX qt ddS )zY
|
Load, unzip and initialize the Zip archive bundled with the executable.
|
T)Z check_pymagicz!# PyInstaller: FrozenImporter(%s)NzCannot load frozen modules.) r Úpathr Ú _pyz_archiveÚremoveÚsetÚtocÚkeysr ÚIOErrorr Ú ImportError)ÚselfZ pyz_filepathr r r Ú__init__S s
|
|
zFrozenImporter.__init__c
|
C s\ || j krLz| j |¡W S tk
|
rH } ztd| |W 5 d }~X Y qXX n td| d S ©Nú+Loader FrozenImporter cannot handle module )r" r Zis_pep420_namespace_packageÚ Exceptionr% ©r& ÚfullnameÚer r r Ú _is_pep420_namespace_packageu s
|
"z+FrozenImporter._is_pep420_namespace_packagec
|
C s\ || j krLz| j |¡W S tk
|
rH } ztd| |W 5 d }~X Y qXX n td| d S r( )r" r Ú
|
is_packager* r% r+ r r r r/ s
|
"zFrozenImporter.is_packagec
|
C sZ z$|dkrt jd jW S | j |¡W S tk
|
rT } ztd| |W 5 d}~X Y nX dS )z|
|
Get the code object associated with the module.
|
|
ImportError should be raised if module not found.
|
Ú__main__r) N)r ÚmodulesZ _pyi_main_cor Úextractr* r% r+ r r r Úget_code s zFrozenImporter.get_codec C s || j krz| |¡r |d7 }tj t| dtj¡d ¡}z(t|d}| ¡ }W 5 Q R X t
|
|W S t k
|
rt Y nX dS t d| dS )zò
|
Method should return the source code for the module as a string.
|
But frozen modules does not contain source code.
|
|
Return None, unless the corresponding source file was explicitly collected to the filesystem.
|
z .__init__Ú.z.pyÚrbNzNo module named ) r" r/ Úosr ÚjoinÚ
|
SYS_PREFIXÚreplaceÚsepÚopenÚreadr ÚFileNotFoundErrorr% )r& r, ÚfilenameÚfpr r r r Ú
|
get_source s
|
|
|
zFrozenImporter.get_sourcec
|
C sZ | t¡st|td
}|| jkr0| j |¡S t|d}| ¡ W 5 Q R £ S Q R X dS )a
|
Returns the data as a string, or raises IOError if the "file" was not found. The data is always returned as if
|
"binary" mode was used.
|
|
This method is useful for getting resources with 'pkg_resources' that are bundled with Python modules in the
|
PYZ archive.
|
|
The 'path' argument is a path that can be constructed by munging module.__file__ (or pkg.__path__ items).
|
Nr5 ) Ú
|
startswithr8 ÚAssertionErrorÚ SYS_PREFIXLENr" r r2 r; r< )r& r r, r? r r r Úget_data³ s
|
|
zFrozenImporter.get_datac C sJ | |¡r(tj t| dtjj¡d¡}n tj t| dtjj¡d ¡}|S )z¸
|
This method should return the value that __file__ would be set to if the named module was loaded. If the module
|
is not found, an ImportError should be raised.
|
r4 z __init__.pycz.pyc)r/ r6 r r7 r8 r9 r: )r& r, r> r r r Ú get_filenameÈ s
|
zFrozenImporter.get_filenameNc C sP d}|dk r| d¡d }|D ]r}| t¡s.q |td
}| tj¡}|sLq |d s`|dd
}| |¡ d |¡}|| j kr t
|
d||| qq d}|dkr¶|| j kr¶|}t
|
d| |dkrÌt
|
d| dS | |¡rt j |dd d
|
}tj | |¡¡g|_|S | |¡} | |¡}
|
t j || |
|
| |d }d |_|
|
rLtj | |¡¡g|_|S ) aì
|
PEP-451 finder.find_spec() method for the ``sys.meta_path`` hook.
|
|
fullname fully qualified name of the module
|
path None for a top-level module, or package.__path__ for
|
submodules or subpackages.
|
target unused by this Finder
|
|
Finders are still responsible for identifying, and typically creating, the loader that should be used to load a
|
module. That loader will now be stored in the module spec returned by find_spec() rather than returned directly.
|
As is currently the case without the PEP-452, if a loader would be costly to create, that loader can be designed
|
to defer the cost until later.
|
|
Finders must return ModuleSpec objects when find_spec() is called. This new method replaces find_module() and
|
find_loader() (in the PathEntryFinder case). If a loader does not have find_spec(), find_module() and
|
find_loader() are used instead, for backward-compatibility.
|
Nr4 éÿÿÿÿr é z9import %s as %s # PyInstaller PYZ (__path__ override: %s)zimport %s # PyInstaller PYZz# %s not found in PYZT)r/ )r/ ÚoriginÚ loader_state)ÚrsplitrA r8 rC Úsplitr6 r: Úappendr7 r" r r. Ú_frozen_importlibÚ
|
ModuleSpecr ÚdirnamerE Úsubmodule_search_locationsr/ Ú has_location) r& r, r ÚtargetZ
|
entry_nameÚmodnameÚpÚpartsÚspecrH Zis_pkgr r r Ú find_spec× sT
|
|
|
|
|
|
|
|
|
ú zFrozenImporter.find_specc C s dS )a
|
PEP-451 loader.create_module() method for the ``sys.meta_path`` hook.
|
|
Loaders may also implement create_module() that will return a new module to exec. It may return None to indicate
|
that the default module creation code should be used. One use case, though atypical, for create_module() is to
|
provide a module that is a subclass of the builtin module type. Most loaders will not need to implement
|
create_module().
|
|
create_module() should properly handle the case where it is called more than once for the same spec/module. This
|
may include returning None or raising ImportError.
|
Nr )r& rV r r r Ú create_module1 s z FrozenImporter.create_modulec C sL |j }| |j¡}t|ds t|jdk r<tj |j ¡g|_
|
t ||j dS )aô
|
PEP-451 loader.exec_module() method for the ``sys.meta_path`` hook.
|
|
Loaders will have a new method, exec_module(). Its only job is to "exec" the module and consequently populate
|
the module's namespace. It is not responsible for creating or preparing the module object, nor for any cleanup
|
afterward. It has no return value. exec_module() will be used during both loading and reloading.
|
|
exec_module() should properly handle the case where it is called more than once. For some kinds of modules this
|
may mean raising ImportError every time after the first time the method is called. This is particularly relevant
|
for reloading, where some kinds of modules do not support in-place reloading.
|
Ú__file__N) Ú__spec__r3 rI ÚhasattrrB rP r6 r rO rY Ú__path__ÚexecÚ__dict__)r& ÚmodulerV Úbytecoder r r Ú exec_moduleB s
|
zFrozenImporter.exec_modulec C s
|
t | |S )zG
|
Return importlib.resource-compatible resource reader.
|
)ÚFrozenResourceReader)r& r, r r r Úget_resource_readerb s z"FrozenImporter.get_resource_reader)NN)Ú__name__Ú
|
__module__Ú __qualname__Ú__doc__r' r. r/ r3 r@ rD rE rW rX ra rc r r r r r < s "
|
Z r c @ s@ e Zd ZdZdd Zdd Zdd Zdd Zd
|
d Zd d Z dS )rb ag
|
Resource reader for importlib.resources / importlib_resources support.
|
|
Currently supports only on-disk resources (support for resources from the embedded archive is missing).
|
However, this should cover the typical use cases (access to data files), as PyInstaller collects data files onto
|
filesystem, and only .pyc modules are collected into embedded archive. One exception are resources collected from
|
zipped eggs (which end up collected into embedded archive), but those should be rare anyway.
|
|
When listing resources, source .py files will not be listed as they are not collected by default. Similarly,
|
sub-directories that contained only .py files are not reconstructed on filesystem, so they will not be listed,
|
either. If access to .py files is required for whatever reason, they need to be explicitly collected as data files
|
anyway, which will place them on filesystem and make them appear as resources.
|
|
For on-disk resources, we *must* return path compatible with pathlib.Path() in order to avoid copy to a temporary
|
file, which might break under some circumstances, e.g., metpy with importlib_resources back-port, due to:
|
https://github.com/Unidata/MetPy/blob/a3424de66a44bf3a92b0dcacf4dff82ad7b86712/src/metpy/plots/wx_symbols.py#L24-L25
|
(importlib_resources tries to use 'fonts/wx_symbols.ttf' as a temporary filename suffix, which fails as it contains
|
a separator).
|
|
Furthermore, some packages expect files() to return either pathlib.Path or zipfile.Path, e.g.,
|
https://github.com/tensorflow/datasets/blob/master/tensorflow_datasets/core/utils/resource_utils.py#L81-L97
|
This makes implementation of mixed support for on-disk and embedded resources using importlib.abc.Traversable
|
protocol rather difficult.
|
|
So in order to maximize compatibility with unfrozen behavior, the below implementation is basically equivalent of
|
importlib.readers.FileReader from python 3.10:
|
https://github.com/python/cpython/blob/839d7893943782ee803536a47f1d4de160314f85/Lib/importlib/readers.py#L11
|
and its underlying classes, importlib.abc.TraversableResources and importlib.abc.ResourceReader:
|
https://github.com/python/cpython/blob/839d7893943782ee803536a47f1d4de160314f85/Lib/importlib/abc.py#L422
|
https://github.com/python/cpython/blob/839d7893943782ee803536a47f1d4de160314f85/Lib/importlib/abc.py#L312
|
c C s$ || _ t tj¡j| d¡ | _d S )Nr4 )ÚimporterÚpathlibÚPathr Ú_MEIPASSÚjoinpathrK r )r& rh Únamer r r r' s z FrozenResourceReader.__init__c C s | ¡ |¡ d¡S )Nr5 )Úfilesrl r; ©r& Úresourcer r r Ú open_resource s z"FrozenResourceReader.open_resourcec C s t | j |¡S r )Ústrr rl ro r r r Ú resource_path s z"FrozenResourceReader.resource_pathc C s | ¡ |¡ ¡ S r )rn rl Úis_file)r& r r r r Ú is_resource s z FrozenResourceReader.is_resourcec C s dd | ¡ ¡ D S )Nc s s | ] }|j V qd S r )rm )Ú.0Úitemr r r Ú <genexpr> s z0FrozenResourceReader.contents.<locals>.<genexpr>)rn Úiterdir©r& r r r Úcontents s z FrozenResourceReader.contentsc C s | j S r )r rz r r r rn s zFrozenResourceReader.filesN)
|
rd re rf rg r' rq rs ru r{ rn r r r r rb i s rb c C s¾ t } tj | ¡ tjD ](}t|dr|jdkrtj |¡ qBqg }ttjD ]2}t|dddkrPtj |¡ ||krP| |¡ qPtj t|¡ z| tj
|
d _ W n t k
|
r¸ Y nX dS )a
|
Install FrozenImporter class and other classes into the import machinery.
|
|
This function installs the FrozenImporter class into the import machinery of the running process. The importer is
|
added to sys.meta_path. It could be added to sys.path_hooks, but sys.meta_path is processed by Python before
|
looking at sys.path!
|
|
The order of processing import hooks in sys.meta_path:
|
|
1. built-in modules
|
2. modules from the bundled ZIP archive
|
3. C extension modules
|
4. Modules from sys.path
|
rd ÚWindowsRegistryFinderNÚ
|
PathFinderr0 ) r r Ú meta_pathrL r[ rd r ÚreversedÚgetattrÚextendr1 Ú
|
__loader__r* )Zfimprw Z pathFindersr r r Úinstall s"
|
r )rg r r6 ri r r rM Zpyimod01_archiver r rk r: r8 ÚlenrC ÚtypeZimp_new_moduleÚflagsÚverboser r r r rb r r r r r Ú<module> s&
|
/4
|
