o
|
ã @ s¾ d Z ddlZddlZddlZddlZddlZddlmZmZ ej ej
|
Z e e Z eeZejjr8ejr8dd Zndd Zdd ZG d d
|
d
|
ZG d d d ZG d d dZdd Zdd 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 ú(PyInstaller\loader\pyimod02_importers.pyÚtrace& s r c G s d S )Nr r r r r r + s c C sB ddl m} t | ¡j}||}tjddd}| | |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
|
r )Údetect_encodingNT)ÚdecoderÚ translate)Útokenizer ÚioÚBytesIOÚreadlineÚIncrementalNewlineDecoderÚdecode)Ú source_bytesr Úsource_bytes_readlineÚencodingÚnewline_decoderr r r Ú_decode_source/ s
|
r c @ s e Zd ZdZdd ZdS )ÚPyiFrozenImporterStatea
|
An object encapsulating extra information for PyiFrozenImporter, to be stored in `ModuleSpec.loader_state`. Having
|
a custom type allows us to verify that module spec indeed contains the original loader state data, as set by
|
`PyiFrozenImporter.find_spec`.
|
c C s
|
|| _ d S )N)Úpyz_entry_name)ÚselfÚ
|
entry_namer r r Ú__init__C s
|
z PyiFrozenImporterState.__init__N)Ú__name__Ú
|
__module__Ú __qualname__Ú__doc__r r r r r r = s r c @ s~ e Zd ZdZdd Zedd Zdd Zdd Zd
|
d Z d d Z
|
dd Z dd Z dd Z d ddZdd Zdd Zdd ZdS ) ÚPyiFrozenImportera8
|
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.
|
c C s t jD ](}zt|dd| _td| t j |¡ W n ty# Y q ty+ Y qw tdt | jj
|
¡ | _
|
t ¡ | _d| _dS )zY
|
Load, unzip and initialize the Zip archive bundled with the executable.
|
T)Ú check_pymagicz$# PyInstaller: PyiFrozenImporter(%s)zCannot load frozen modules.N)r Úpathr Ú _pyz_archiver ÚremoveÚIOErrorr Ú ImportErrorÚsetÚtocÚkeysÚ_threadÚRLockÚ_lockÚ _toc_tree)r Z pyz_filepathr r r r \ s
|
|
þ
|
|
zPyiFrozenImporter.__init__c C sD | j | jd u r| ¡ | _| jW d S 1 sw Y d S )N)r1 r2 Ú_build_pyz_prefix_tree©r r r r Útoc_tree s
|
|
|
$ýzPyiFrozenImporter.toc_treec C sr t }| jD ]0}| d¡}|}| j |¡r!|D ]}| |i ¡}qq|d d
D ]}| |i ¡}q'd||d < q|S )NÚ.éÿÿÿÿÚ )Údictr- Úsplitr( Ú
|
is_packageÚ
|
setdefault)r Útreer Zname_componentsÚcurrentZname_componentr r r r3 s
|
|
ÿz(PyiFrozenImporter._build_pyz_prefix_treec
|
C óP || j v r!z| j |¡W S ty } ztd||d }~ww td|)Nú'PyiFrozenImporter cannot handle module )r- r( Úis_pep420_namespace_packageÚ Exceptionr+ ©r ÚfullnameÚer r r Ú _is_pep420_namespace_package ó
|
ÿz.PyiFrozenImporter._is_pep420_namespace_packagec
|
C r? )Nr@ )r- r( r; rB r+ rC r r r r; ¤ rG z PyiFrozenImporter.is_packagec
|
C sN z|dkr t jd jW S | j |¡W S ty& } ztd||d}~ww )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( ÚextractrB r+ rC r r r Úget_code s ÿzPyiFrozenImporter.get_codec C s || j v rE| |¡r|d7 }tj t| dtj¡d ¡}z t|d }| ¡ }W d n1 s1w Y t
|
|W S t yD Y dS w t d| )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.
|
ú .__init__r6 z.pyÚrbNzNo module named ) r- r; Úosr' ÚjoinÚ
|
SYS_PREFIXÚreplaceÚsepÚopenÚreadr ÚFileNotFoundErrorr+ )r rD ÚfilenameÚfpr r r r Ú
|
get_source¿ s
|
|
|
ÿ
|
þ z PyiFrozenImporter.get_sourcec C s6 t |d }| ¡ W d S 1 sw Y 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.
|
|
The 'path' argument is a path that can be constructed by munging module.__file__ (or pkg.__path__ items).
|
|
This assumes that the file in question was collected into frozen application bundle as a file, and is available
|
on the filesystem. Older versions of PyInstaller also supported data embedded in the PYZ archive, but that has
|
been deprecated in v6.
|
rM N)rS rT )r r' rW r r r Úget_data× s $ÿzPyiFrozenImporter.get_datac C sL | |¡rtj t| dtjj¡d¡}|S 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.
|
r6 z __init__.pycú.pyc)r; rN r' rO rP rQ rR )r rD rV r r r Ú get_filenameç s
|
|
ÿz PyiFrozenImporter.get_filenameNc sl d}|durK| d¡d }|D ]9}| t¡sq|td
}| tj¡}|s&q|d s0|dd
}| |¡ d |¡}| j v rHt
|
d||| nqd}|du r[| j v r[|}t
|
d| |du rft
|
d| dS |¡rdd l m } tj|dd
|
d } ||tj |¡¡g fd d | _| S |¡}
|
|¡} tj| | |
|
t|d} d
|
| _| r´tj |¡¡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.
|
Nr6 r7 r é z9import %s as %s # PyInstaller PYZ (__path__ override: %s)zimport %s # PyInstaller PYZz# %s not found in PYZ)Ú_NamespacePathT)r; c s | |¡S )N)Ú find_spec)Únamer' r4 r r Ú<lambda>= s z-PyiFrozenImporter.find_spec.<locals>.<lambda>)r; ÚoriginÚ loader_state)ÚrsplitÚ
|
startswithrP Ú SYS_PREFIXLENr: rN rR ÚappendrO r- r rF Ú importlib._bootstrap_externalr] Ú_frozen_importlibÚ
|
ModuleSpecr' Údirnamer[ Úsubmodule_search_locationsr; r Ú has_location) r rD r' Útargetr ÚmodnameÚpÚpartsr] Úspecra Úis_pkgr r4 r r^ ö s`
|
|
|
|
þ
|
|
|
|
|
û
|
|
ú zPyiFrozenImporter.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 rq r r r Ú create_module[ s z PyiFrozenImporter.create_modulec C sð |j }t|jtr|jj}n;t|jtr?|j t¡s J |jt d
|
t j d¡}| d¡r3|dd
}| d¡r>|dd
}n
|
tdt|j | |¡}|du r[td|jd t|d
|
sbJ |jdurpt j |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.
|
Nr6 rZ éüÿÿÿrL i÷ÿÿÿz:Module's spec contains loader_state of incompatible type: z Failed to retrieve bytecode for ú!Ú__file__)Ú__spec__Ú
|
isinstancerb r r r9 ra rd rP re rQ rN rR ÚendswithÚ RuntimeErrorÚtyperK r_ Úhasattrrk r' rj rv Ú__path__ÚexecÚ__dict__)r Úmodulerq Ú module_nameÚbytecoder r r Ú exec_modulel s&
|
|
|
|
|
z PyiFrozenImporter.exec_modulec C s
|
t | |S )zG
|
Return importlib.resource-compatible resource reader.
|
)ÚPyiFrozenResourceReader)r rD r r r Úget_resource_reader¥ s
|
z%PyiFrozenImporter.get_resource_reader)NN)r! r" r# r$ r Úpropertyr5 r3 rF r; rK rX rY r[ r^ rs r r
r r r r r% H s $
|
|
e 9r% c @ s@ e Zd ZdZdd Zdd Zdd Zdd Zd
|
d Zd d Z dS )r a®
|
Resource reader for importlib.resources / importlib_resources support.
|
|
Supports only on-disk resources, which should cover the typical use cases, i.e., the access to data files;
|
PyInstaller collects data files onto filesystem, and as of v6.0.0, the embedded PYZ archive is guaranteed
|
to contain only .pyc modules.
|
|
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. ddl m} || _|tjj| d¡ | _d S )Nr )ÚPathr6 )Úpathlibr Úimporterr Ú_MEIPASSÚjoinpathr: r' )r r r_ r r r r r Ë s z PyiFrozenResourceReader.__init__c C s | ¡ |¡ d¡S )NrM )Úfilesr rS ©r Úresourcer r r Ú open_resourceÑ s z%PyiFrozenResourceReader.open_resourcec C s t | j |¡S )N)Ústrr' r r r r r Ú resource_pathÔ s z%PyiFrozenResourceReader.resource_pathc C s | ¡ |¡ ¡ S )N)r r Úis_file)r r' r r r Ú is_resource× s z#PyiFrozenResourceReader.is_resourcec C s dd | ¡ ¡ D S )Nc s s | ]}|j V qd S )N)r_ )Ú.0Úitemr r r Ú <genexpr>Û s z3PyiFrozenResourceReader.contents.<locals>.<genexpr>)r Úiterdirr4 r r r ÚcontentsÚ s z PyiFrozenResourceReader.contentsc C s | j S )N)r' r4 r r r r Ý s z PyiFrozenResourceReader.filesN)
|
r! r" r# r$ r r r r r r r r r r r ¬ s r c C sÐ t } tj | ¡ tjD ]}t|dr |jdkr tj |¡ nq g }ttjD ]}t|dddkrAtj |¡ ||vrA| |¡ q(tj t|¡ z| tj
|
d _ W n t y[ Y nw tj dkrft dS dS )a
|
Install PyiFrozenImporter class into the import machinery.
|
|
This function installs the PyiFrozenImporter 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
|
r! ÚWindowsRegistryFinderNÚ
|
PathFinderrH )é é )r% r Ú meta_pathrf r| r! r) ÚreversedÚgetattrÚextendrI Ú
|
__loader__rB Ú version_infoÚ_fixup_frozen_stdlib)r r Z path_findersr r r Úinstallá s.
|
|
ÿ
|
|
ÿr¤ c C sÖ dd l } tjsztjt_W n ty Y nw tj ¡ D ]L\}}| |¡s&q | |¡}|j j
|
}|j }|r8|d7 }t j jtjg| d¡¢R d }t|ds\z||_W n ty[ Y nw |jd u rh|dkrh||_q d S )Nr rL r6 rZ rv zimportlib._bootstrap)Ú_impr Z _stdlib_dirr ÚAttributeErrorrI ÚitemsÚ is_frozenÚis_frozen_packagerw rb ZorignamerN r' rO r: r| rv rV )r¥ r r rr rb Ú orig_namerV r r r r£ s4 ÿ
|
|
|
|
ÿår£ )r$ r rN r rh r/ Úpyimod01_archiver r r rR rP Úlenre r{ Zimp_new_moduleÚflagsÚverboser r r r r% r r¤ r£ r r r r Ú<module> s*
|
|
f5 7
|
