kadu/gotify-tray-customized
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 1 Wiki Activity

Remove hardcoded libpython binaries and add debug step
All checks were successful
build / build-linux (push) Successful in 16s
Details

Browse Source
This commit is contained in:
kdusek
2025-12-07 23:15:18 +01:00
parent 308ce7768e
commit 6a1fe63684
1807 changed files with 172293 additions and 1 deletions
Download Patch File Download Diff File Expand all files Collapse all files

781
venv/lib/python3.12/site-packages/PyInstaller/loader/pyimod02_importers.py Executable file
View File

@@ -0,0 +1,781 @@
#-----------------------------------------------------------------------------
# Copyright (c) 2005-2023, PyInstaller Development Team.
#
# Distributed under the terms of the GNU General Public License (version 2
# or later) with exception for distributing the bootloader.
#
# The full license is in the file COPYING.txt, distributed with this software.
#
# SPDX-License-Identifier: (GPL-2.0-or-later WITH Bootloader-exception)
#-----------------------------------------------------------------------------
"""
PEP-302 and PEP-451 importers for frozen applications.
"""
# **NOTE** This module is used during bootstrap.
# Import *ONLY* builtin modules or modules that are collected into the base_library.zip archive.
# List of built-in modules: sys.builtin_module_names
# List of modules collected into base_library.zip: PyInstaller.compat.PY3_BASE_MODULES
import sys
import os
import io
import _frozen_importlib
import _thread
import pyimod01_archive
if sys.flags.verbose and sys.stderr:
def trace(msg, *a):
sys.stderr.write(msg % a)
sys.stderr.write("\n")
else:
def trace(msg, *a):
pass
def _decode_source(source_bytes):
"""
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
"""
# Local import to avoid including `tokenize` and its dependencies in `base_library.zip`
from tokenize import detect_encoding
source_bytes_readline = io.BytesIO(source_bytes).readline
encoding = detect_encoding(source_bytes_readline)
newline_decoder = io.IncrementalNewlineDecoder(decoder=None, translate=True)
return newline_decoder.decode(source_bytes.decode(encoding[0]))
# Global instance of PYZ archive reader. Initialized by install().
pyz_archive = None
# Some runtime hooks might need to traverse available frozen package/module hierarchy to simulate filesystem.
# Such traversals can be efficiently implemented using a prefix tree (trie), whose computation we defer until first
# access.
_pyz_tree_lock = _thread.RLock()
_pyz_tree = None
def get_pyz_toc_tree():
global _pyz_tree
with _pyz_tree_lock:
if _pyz_tree is None:
_pyz_tree = _build_pyz_prefix_tree(pyz_archive)
return _pyz_tree
# Populate list of unresolved (original) and resolved paths to top-level directory, used when trying to determine
# relative path.
_TOP_LEVEL_DIRECTORY_PATHS = []
# Original sys._MEIPASS value; ensure separators are normalized (e.g., when using msys2 python).
_TOP_LEVEL_DIRECTORY = os.path.normpath(sys._MEIPASS)
_TOP_LEVEL_DIRECTORY_PATHS.append(_TOP_LEVEL_DIRECTORY)
# Fully resolve sys._MEIPASS in case its location is symlinked at some level; for example, system temporary directory
# (used by onefile builds) is usually a symbolic link under macOS.
_RESOLVED_TOP_LEVEL_DIRECTORY = os.path.realpath(_TOP_LEVEL_DIRECTORY)
if os.path.normcase(_RESOLVED_TOP_LEVEL_DIRECTORY) != os.path.normcase(_TOP_LEVEL_DIRECTORY):
_TOP_LEVEL_DIRECTORY_PATHS.append(_RESOLVED_TOP_LEVEL_DIRECTORY)
# If we are running as macOS .app bundle, compute the alternative top-level directory path as well.
_is_macos_app_bundle = False
if sys.platform == 'darwin' and _TOP_LEVEL_DIRECTORY.endswith("Contents/Frameworks"):
_is_macos_app_bundle = True
_ALTERNATIVE_TOP_LEVEL_DIRECTORY = os.path.join(
os.path.dirname(_TOP_LEVEL_DIRECTORY),
'Resources',
)
_TOP_LEVEL_DIRECTORY_PATHS.append(_ALTERNATIVE_TOP_LEVEL_DIRECTORY)
_RESOLVED_ALTERNATIVE_TOP_LEVEL_DIRECTORY = os.path.join(
os.path.dirname(_RESOLVED_TOP_LEVEL_DIRECTORY),
'Resources',
)
if _RESOLVED_ALTERNATIVE_TOP_LEVEL_DIRECTORY != _ALTERNATIVE_TOP_LEVEL_DIRECTORY:
_TOP_LEVEL_DIRECTORY_PATHS.append(_RESOLVED_ALTERNATIVE_TOP_LEVEL_DIRECTORY)
# Helper for computing PYZ prefix tree
def _build_pyz_prefix_tree(pyz_archive):
tree = dict()
for entry_name, entry_data in pyz_archive.toc.items():
name_components = entry_name.split('.')
typecode = entry_data[0]
current = tree
if typecode in {pyimod01_archive.PYZ_ITEM_PKG, pyimod01_archive.PYZ_ITEM_NSPKG}:
# Package; create new dictionary node for its modules
for name_component in name_components:
current = current.setdefault(name_component, {})
else:
# Module; create the leaf node (empty string)
for name_component in name_components[:-1]:
current = current.setdefault(name_component, {})
current[name_components[-1]] = ''
return tree
class PyiFrozenFinder:
"""
PyInstaller's frozen path entry finder for specific search path.
Per-path instances allow us to properly translate the given module name ("fullname") into full PYZ entry name.
For example, with search path being `sys._MEIPASS`, the module "mypackage.mod" would translate to "mypackage.mod"
in the PYZ archive. However, if search path was `sys._MEIPASS/myotherpackage/_vendored` (for example, if
`myotherpacakge` added this path to `sys.path`), then "mypackage.mod" would need to translate to
"myotherpackage._vendored.mypackage.mod" in the PYZ archive.
"""
def __repr__(self):
return f"{self.__class__.__name__}({self._path})"
@classmethod
def path_hook(cls, path):
trace(f"PyInstaller: running path finder hook for path: {path!r}")
try:
finder = cls(path)
trace("PyInstaller: hook succeeded")
return finder
except Exception as e:
trace(f"PyInstaller: hook failed: {e}")
raise
def __init__(self, path):
self._path = path # Store original path, as given.
self._pyz_archive = pyz_archive
# Compute relative path to the top-level application directory. Do not try to resolve the path itself, because
# it might contain symbolic links in parts other than the prefix that corresponds to the top-level application
# directory. See #8994 for an example (files symlinked from a common directory outside of the top-level
# application directory). Instead, try to compute relative path w.r.t. the original and the resolved top-level
# application directory.
for top_level_path in _TOP_LEVEL_DIRECTORY_PATHS:
try:
relative_path = os.path.relpath(path, top_level_path)
except ValueError:
continue # Failed to compute relative path w.r.t. the given top-level directory path.
if relative_path.startswith('..'):
continue # Relative path points outside of the given top-level directory.
break # Successful match; stop here.
else:
raise ImportError("Failed to determine relative path w.r.t. top-level application directory.")
# Ensure that path does not point to a file on filesystem. Strictly speaking, we should be checking that the
# given path is a valid directory, but that would need to check both PYZ and filesystem. So for now, limit the
# check to catch paths pointing to file, because that breaks `runpy.run_path()`, as per #8767.
if os.path.isfile(path):
raise ImportError("only directories are supported")
if relative_path == '.':
self._pyz_entry_prefix = ''
else:
self._pyz_entry_prefix = '.'.join(relative_path.split(os.path.sep))
def _compute_pyz_entry_name(self, fullname):
"""
Convert module fullname into PYZ entry name, subject to the prefix implied by this finder's search path.
"""
tail_module = fullname.rpartition('.')[2]
if self._pyz_entry_prefix:
return self._pyz_entry_prefix + "." + tail_module
else:
return tail_module
@property
def fallback_finder(self):
"""
Opportunistically create a *fallback finder* using `sys.path_hooks` entries that are located *after* our hook.
The main goal of this exercise is to obtain an instance of python's FileFinder, but in theory any other hook
that comes after ours is eligible to be a fallback.
Having this fallback allows our finder to "cooperate" with python's FileFinder, as if the two were a single
finder, which allows us to work around the python's PathFinder permitting only one finder instance per path
without subclassing FileFinder.
"""
if hasattr(self, '_fallback_finder'):
return self._fallback_finder
# Try to instantiate fallback finder
our_hook_found = False
self._fallback_finder = None
for idx, hook in enumerate(sys.path_hooks):
if hook == self.path_hook:
our_hook_found = True
continue # Our hook
if not our_hook_found:
continue # Skip hooks before our hook
try:
self._fallback_finder = hook(self._path)
break
except ImportError:
pass
return self._fallback_finder
def _find_fallback_spec(self, fullname, target):
"""
Attempt to find the spec using fallback finder, which is opportunistically created here. Typically, this would
be python's FileFinder, which can discover specs for on-filesystem modules, such as extension modules and
modules that are collected only as source .py files.
Having this fallback allows our finder to "cooperate" with python's FileFinder, as if the two were a single
finder, which allows us to work around the python's PathFinder permitting only one finder instance per path
without subclassing FileFinder.
"""
if not hasattr(self, '_fallback_finder'):
self._fallback_finder = self._get_fallback_finder()
if self._fallback_finder is None:
return None
return self._fallback_finder.find_spec(fullname, target)
#-- Core PEP451 finder functionality, modeled after importlib.abc.PathEntryFinder
# https://docs.python.org/3/library/importlib.html#importlib.abc.PathEntryFinder
def invalidate_caches(self):
"""
A method which, when called, should invalidate any internal cache used by the finder. Used by
importlib.invalidate_caches() when invalidating the caches of all finders on sys.meta_path.
https://docs.python.org/3/library/importlib.html#importlib.abc.MetaPathFinder.invalidate_caches
"""
# We do not use any caches, but if we have created a fallback finder, propagate the function call.
# NOTE: use getattr() with _fallback_finder attribute, in order to avoid unnecessary creation of the
# fallback finder in case when it does not exist yet.
fallback_finder = getattr(self, '_fallback_finder', None)
if fallback_finder is not None:
if hasattr(fallback_finder, 'invalidate_caches'):
fallback_finder.invalidate_caches()
def find_spec(self, fullname, target=None):
"""
A method for finding a spec for the specified module. The finder will search for the module only within the
path entry to which it is assigned. If a spec cannot be found, None is returned. When passed in, target is a
module object that the finder may use to make a more educated guess about what spec to return.
https://docs.python.org/3/library/importlib.html#importlib.abc.PathEntryFinder.find_spec
"""
trace(f"{self}: find_spec: called with fullname={fullname!r}, target={fullname!r}")
# Convert fullname to PYZ entry name.
pyz_entry_name = self._compute_pyz_entry_name(fullname)
# Try looking up the entry in the PYZ archive
entry_data = self._pyz_archive.toc.get(pyz_entry_name)
if entry_data is None:
# Entry not found - try using fallback finder (for example, python's own FileFinder) to resolve on-disk
# resources, such as extension modules and modules that are collected only as source .py files.
trace(f"{self}: find_spec: {fullname!r} not found in PYZ...")
if self.fallback_finder is not None:
trace(f"{self}: find_spec: attempting resolve using fallback finder {self.fallback_finder!r}.")
fallback_spec = self.fallback_finder.find_spec(fullname, target)
trace(f"{self}: find_spec: fallback finder returned spec: {fallback_spec!r}.")
return fallback_spec
else:
trace(f"{self}: find_spec: fallback finder is not available.")
return None
# Entry found
typecode = entry_data[0]
trace(f"{self}: find_spec: found {fullname!r} in PYZ as {pyz_entry_name!r}, typecode={typecode}")
if typecode == pyimod01_archive.PYZ_ITEM_NSPKG:
# PEP420 namespace package
# We can use regular list for submodule_search_locations; the caller (i.e., python's PathFinder) takes care
# of constructing _NamespacePath from it.
spec = _frozen_importlib.ModuleSpec(fullname, None)
spec.submodule_search_locations = [
# NOTE: since we are using sys._MEIPASS as prefix, we need to construct path from resolved PYZ entry
# name (equivalently, we could combine `self._path` and last part of `fullname`).
os.path.join(sys._MEIPASS, pyz_entry_name.replace('.', os.path.sep)),
]
return spec
is_package = typecode == pyimod01_archive.PYZ_ITEM_PKG
# Instantiate frozen loader for the module
loader = PyiFrozenLoader(
name=fullname,
pyz_archive=self._pyz_archive,
pyz_entry_name=pyz_entry_name,
is_package=is_package,
)
# Resolve full filename, as if the module/package was located on filesystem. This is done by the loader.
origin = loader.path
# Construct spec for module, using all collected information.
spec = _frozen_importlib.ModuleSpec(
fullname,
loader,
is_package=is_package,
origin=origin,
)
# Make the import machinery set __file__.
# PEP 451 says: "has_location" is true if the module is locatable. In that case the spec's origin is used
# as the location and __file__ is set to spec.origin. If additional location information is required
# (e.g., zipimport), that information may be stored in spec.loader_state.
spec.has_location = True
# Set submodule_search_locations for packages. Seems to be required for importlib_resources from 3.2.0;
# see issue #5395.
if is_package:
spec.submodule_search_locations = [os.path.dirname(origin)]
return spec
# The following methods are part of legacy PEP302 finder interface. They have been deprecated since python 3.4,
# and removed in python 3.12. Provide compatibility shims to accommodate code that might still be using them.
if sys.version_info[:2] < (3, 12):
def find_loader(self, fullname):
"""
A legacy method for finding a loader for the specified module. Returns a 2-tuple of (loader, portion) where
portion is a sequence of file system locations contributing to part of a namespace package. The loader may
be None while specifying portion to signify the contribution of the file system locations to a namespace
package. An empty list can be used for portion to signify the loader is not part of a namespace package. If
loader is None and portion is the empty list then no loader or location for a namespace package were found
(i.e. failure to find anything for the module).
Deprecated since python 3.4, removed in 3.12.
"""
# Based on:
# https://github.com/python/cpython/blob/v3.11.9/Lib/importlib/_bootstrap_external.py#L1587-L1600
spec = self.find_spec(fullname)
if spec is None:
return None, []
return spec.loader, spec.submodule_search_locations or []
def find_module(self, fullname):
"""
A concrete implementation of Finder.find_module() which is equivalent to self.find_loader(fullname)[0].
Deprecated since python 3.4, removed in 3.12.
"""
# Based on:
# https://github.com/python/cpython/blob/v3.11.9/Lib/importlib/_bootstrap_external.py#L1585
# https://github.com/python/cpython/blob/v3.11.9/Lib/importlib/_bootstrap_external.py#L622-L639
#
loader, portions = self.find_loader(fullname)
return loader
# Helper for enforcing module name in PyiFrozenLoader methods.
def _check_name(method):
def _check_name_wrapper(self, name, *args, **kwargs):
if self.name != name:
raise ImportError(f'loader for {self.name} cannot handle {name}', name=name)
return method(self, name, *args, **kwargs)
return _check_name_wrapper
class PyiFrozenLoader:
"""
PyInstaller's frozen loader for modules in the PYZ archive, which are discovered by PyiFrozenFinder.
Since this loader is instantiated only from PyiFrozenFinder and since each loader instance is tied to a specific
module, the fact that the loader was instantiated serves as the proof that the module exists in the PYZ archive.
Hence, we can avoid any additional validation in the implementation of the loader's methods.
"""
def __init__(self, name, pyz_archive, pyz_entry_name, is_package):
# Store the reference to PYZ archive (for code object retrieval), as well as full PYZ entry name
# and typecode, all of which are passed from the PyiFrozenFinder.
self._pyz_archive = pyz_archive
self._pyz_entry_name = pyz_entry_name
self._is_package = is_package
# Compute the module file path, as if module was located on filesystem.
#
# Rather than returning path to the .pyc file, return the path to .py file - which might actually exist, if it
# was explicitly collected into the frozen application). This improves compliance with
# https://docs.python.org/3/library/importlib.html#importlib.abc.ExecutionLoader.get_filename
# as well as general compatibility with 3rd party code that blindly assumes that module's file path points to
# the source .py file.
#
# NOTE: since we are using sys._MEIPASS as prefix, we need to construct path from full PYZ entry name
# (so that a module with `name`=`jaraco.text` and `pyz_entry_name`=`setuptools._vendor.jaraco.text`
# ends up with path set to `sys._MEIPASS/setuptools/_vendor/jaraco/text/__init__.pyc` instead of
# `sys._MEIPASS/jaraco/text/__init__.pyc`).
if is_package:
module_file = os.path.join(sys._MEIPASS, pyz_entry_name.replace('.', os.path.sep), '__init__.py')
else:
module_file = os.path.join(sys._MEIPASS, pyz_entry_name.replace('.', os.path.sep) + '.py')
# These properties are defined as part of importlib.abc.FileLoader. They are used by our implementation
# (e.g., module name validation, get_filename(), get_source(), get_resource_reader()), and might also be used
# by 3rd party code that naively expects to be dealing with a FileLoader instance.
self.name = name # The name of the module the loader can handle.
self.path = module_file # Path to the file of the module
#-- Core PEP451 loader functionality as defined by importlib.abc.Loader
# https://docs.python.org/3/library/importlib.html#importlib.abc.Loader
def create_module(self, spec):
"""
A method that returns the module object to use when importing a module. This method may return None, indicating
that default module creation semantics should take place.
https://docs.python.org/3/library/importlib.html#importlib.abc.Loader.create_module
"""
return None
def exec_module(self, module):
"""
A method that executes the module in its own namespace when a module is imported or reloaded. The module
should already be initialized when exec_module() is called. When this method exists, create_module()
must be defined.
https://docs.python.org/3/library/importlib.html#importlib.abc.Loader.exec_module
"""
spec = module.__spec__
bytecode = self.get_code(spec.name) # NOTE: get_code verifies that `spec.name` matches `self.name`!
if bytecode is None:
raise RuntimeError(f"Failed to retrieve bytecode for {spec.name!r}!")
# Set by the import machinery
assert hasattr(module, '__file__')
# If `submodule_search_locations` is not None, this is a package; set __path__.
if spec.submodule_search_locations is not None:
module.__path__ = spec.submodule_search_locations
exec(bytecode, module.__dict__)
# The following method is part of legacy PEP302 loader interface. It has been deprecated since python 3.4, and
# slated for removal in python 3.12, although that has not happened yet. Provide compatibility shim to accommodate
# code that might still be using it.
if True:
@_check_name
def load_module(self, fullname):
"""
A legacy method for loading a module. If the module cannot be loaded, ImportError is raised, otherwise the
loaded module is returned.
Deprecated since python 3.4, slated for removal in 3.12 (but still present in python's own FileLoader in
both v3.12.4 and v3.13.0rc1).
"""
# Based on:
# https://github.com/python/cpython/blob/v3.11.9/Lib/importlib/_bootstrap_external.py#L942-L945
import importlib._bootstrap as _bootstrap
return _bootstrap._load_module_shim(self, fullname)
#-- PEP302 protocol extensions as defined by importlib.abc.ExecutionLoader
# https://docs.python.org/3/library/importlib.html#importlib.abc.ExecutionLoader
@_check_name
def get_filename(self, fullname):
"""
A method that is to return the value of __file__ for the specified module. If no path is available, ImportError
is raised.
If source code is available, then the method should return the path to the source file, regardless of whether a
bytecode was used to load the module.
https://docs.python.org/3/library/importlib.html#importlib.abc.ExecutionLoader.get_filename
"""
return self.path
#-- PEP302 protocol extensions as defined by importlib.abc.InspectLoader
# https://docs.python.org/3/library/importlib.html#importlib.abc.InspectLoader
@_check_name
def get_code(self, fullname):
"""
Return the code object for a module, or None if the module does not have a code object (as would be the case,
for example, for a built-in module). Raise an ImportError if loader cannot find the requested module.
https://docs.python.org/3/library/importlib.html#importlib.abc.InspectLoader.get_code
"""
return self._pyz_archive.extract(self._pyz_entry_name)
@_check_name
def get_source(self, fullname):
"""
A method to return the source of a module. It is returned as a text string using universal newlines, translating
all recognized line separators into '\n' characters. Returns None if no source is available (e.g. a built-in
module). Raises ImportError if the loader cannot find the module specified.
https://docs.python.org/3/library/importlib.html#importlib.abc.InspectLoader.get_source
"""
# The `path` attribute (which is also returned from `get_filename()`) already points to where the source .py
# file should exist, if it is available.
filename = self.path
try:
# Read in binary mode, then decode
with open(filename, 'rb') as fp:
source_bytes = fp.read()
return _decode_source(source_bytes)
except FileNotFoundError:
pass
# Source code is unavailable.
return None
@_check_name
def is_package(self, fullname):
"""
A method to return a true value if the module is a package, a false value otherwise. ImportError is raised if
the loader cannot find the module.
https://docs.python.org/3/library/importlib.html#importlib.abc.InspectLoader.is_package
"""
return self._is_package
#-- PEP302 protocol extensions as dfined by importlib.abc.ResourceLoader
# https://docs.python.org/3/library/importlib.html#importlib.abc.ResourceLoader
def get_data(self, path):
"""
A method to return the bytes for the data located at path. Loaders that have a file-like storage back-end that
allows storing arbitrary data can implement this abstract method to give direct access to the data stored.
OSError is to be raised if the path cannot be found. The path is expected to be constructed using a module’s
__file__ attribute or an item from a package’s __path__.
https://docs.python.org/3/library/importlib.html#importlib.abc.ResourceLoader.get_data
"""
# Try to fetch the data from the filesystem. Since __file__ attribute works properly, just try to open the file
# and read it.
with open(path, 'rb') as fp:
return fp.read()
#-- Support for `importlib.resources`.
@_check_name
def get_resource_reader(self, fullname):
"""
Return resource reader compatible with `importlib.resources`.
"""
return PyiFrozenResourceReader(self)
class PyiFrozenResourceReader:
"""
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
"""
def __init__(self, loader):
# Local import to avoid including `pathlib` and its dependencies in `base_library.zip`
import pathlib
# This covers both modules and (regular) packages. Note that PEP-420 namespace packages are not handled by this
# resource reader (since they are not handled by PyiFrozenLoader, which uses this reader).
self.path = pathlib.Path(loader.path).parent
def open_resource(self, resource):
return self.files().joinpath(resource).open('rb')
def resource_path(self, resource):
return str(self.path.joinpath(resource))
def is_resource(self, path):
return self.files().joinpath(path).is_file()
def contents(self):
return (item.name for item in self.files().iterdir())
def files(self):
return self.path
class PyiFrozenEntryPointLoader:
"""
A special loader that enables retrieval of the code-object for the __main__ module.
"""
def __repr__(self):
return self.__class__.__name__
def get_code(self, fullname):
if fullname == '__main__':
# Special handling for __main__ module; the bootloader should store code object to _pyi_main_co
# attribute of the module.
return sys.modules['__main__']._pyi_main_co
raise ImportError(f'{self} cannot handle module {fullname!r}')
def install():
"""
Install PyInstaller's frozen finders/loaders/importers into python's import machinery.
"""
# Setup PYZ archive reader.
#
# The bootloader should store the path to PYZ archive (the path to the PKG archive and the offset within it; for
# executable-embedded archive, this is for example /path/executable_name?117568) into _pyinstaller_pyz
# attribute of the sys module.
global pyz_archive
if not hasattr(sys, '_pyinstaller_pyz'):
raise RuntimeError("Bootloader did not set sys._pyinstaller_pyz!")
try:
pyz_archive = pyimod01_archive.ZlibArchiveReader(sys._pyinstaller_pyz, check_pymagic=True)
except Exception as e:
raise RuntimeError("Failed to setup PYZ archive reader!") from e
delattr(sys, '_pyinstaller_pyz')
# On Windows, there is finder called `_frozen_importlib.WindowsRegistryFinder`, which looks for Python module
# locations in Windows registry. The frozen application should not look for those, so remove this finder
# from `sys.meta_path`.
for entry in sys.meta_path:
if getattr(entry, '__name__', None) == 'WindowsRegistryFinder':
sys.meta_path.remove(entry)
break
# Insert our hook for `PyiFrozenFinder` into `sys.path_hooks`. Place it after `zipimporter`, if available.
for idx, entry in enumerate(sys.path_hooks):
if getattr(entry, '__name__', None) == 'zipimporter':
trace(f"PyInstaller: inserting our finder hook at index {idx + 1} in sys.path_hooks.")
sys.path_hooks.insert(idx + 1, PyiFrozenFinder.path_hook)
break
else:
trace("PyInstaller: zipimporter hook not found in sys.path_hooks! Prepending our finder hook to the list.")
sys.path_hooks.insert(0, PyiFrozenFinder.path_hook)
# Monkey-patch `zipimporter.get_source` to allow loading out-of-zip source .py files for modules that are
# in `base_library.zip`.
_patch_zipimporter_get_source()
# Python might have already created a `FileFinder` for `sys._MEIPASS`. Remove the entry from path importer cache,
# so that next loading attempt creates `PyiFrozenFinder` instead. This could probably be avoided altogether if
# we refrained from adding `sys._MEIPASS` to `sys.path` until our importer hooks is in place.
sys.path_importer_cache.pop(sys._MEIPASS, None)
# Set the PyiFrozenEntryPointLoader as loader for __main__, in order for python to treat __main__ as a module
# instead of a built-in, and to allow its code object to be retrieved.
try:
sys.modules['__main__'].__loader__ = PyiFrozenEntryPointLoader()
except Exception:
pass
# Apply hack for python >= 3.11 and its frozen stdlib modules.
if sys.version_info >= (3, 11):
_fixup_frozen_stdlib()
# A hack for python >= 3.11 and its frozen stdlib modules. Unless `sys._stdlib_dir` is set, these modules end up
# missing __file__ attribute, which causes problems with 3rd party code. At the time of writing, python interpreter
# configuration API does not allow us to influence `sys._stdlib_dir` - it always resets it to `None`. Therefore,
# we manually set the path, and fix __file__ attribute on modules.
def _fixup_frozen_stdlib():
import _imp # built-in
# If sys._stdlib_dir is None or empty, override it with sys._MEIPASS
if not sys._stdlib_dir:
try:
sys._stdlib_dir = sys._MEIPASS
except AttributeError:
pass
# The sys._stdlib_dir set above should affect newly-imported python-frozen modules. However, most of them have
# been already imported during python initialization and our bootstrap, so we need to retroactively fix their
# __file__ attribute.
for module_name, module in sys.modules.items():
if not _imp.is_frozen(module_name):
continue
is_pkg = _imp.is_frozen_package(module_name)
# Determine "real" name from __spec__.loader_state.
loader_state = module.__spec__.loader_state
orig_name = loader_state.origname
if is_pkg:
orig_name += '.__init__'
# We set suffix to .pyc to be consistent with our PyiFrozenLoader.
filename = os.path.join(sys._MEIPASS, *orig_name.split('.')) + '.pyc'
# Fixup the __file__ attribute
if not hasattr(module, '__file__'):
try:
module.__file__ = filename
except AttributeError:
pass
# Fixup the loader_state.filename
# Except for _frozen_importlib (importlib._bootstrap), whose loader_state.filename appears to be left at
# None in python.
if loader_state.filename is None and orig_name != 'importlib._bootstrap':
loader_state.filename = filename
# Monkey-patch the `get_source` implementation of python's `zipimport.zipimporter` with our custom implementation that
# looks up for source files in top-level application directory instead of within the zip file. This allows us to collect
# source .py files for modules that are collected in the `base_library.zip` in the same way as for modules in the PYZ
# archive.
def _patch_zipimporter_get_source():
import zipimport
_orig_get_source = zipimport.zipimporter.get_source
def _get_source(self, fullname):
# Call original implementation first, in case we are dealing with a zip file other than `base_library.zip` (or
# if the source .py file is actually in there, for whatever reason). This also implicitly validates the module
# name, as it raises exception if module does not exist and returns None if module exists but the source code
# is not present in the archive.
source = _orig_get_source(self, fullname)
if source is not None:
return source
# Our override should apply only to `base_library.zip`.
if os.path.basename(self.archive) != 'base_library.zip':
return None
# Translate module/package name into .py filename in the top-level application directory.
if self.is_package(fullname):
filename = os.path.join(*fullname.split('.'), '__init__.py')
else:
filename = os.path.join(*fullname.split('.')) + '.py'
filename = os.path.join(_RESOLVED_TOP_LEVEL_DIRECTORY, filename)
try:
# Read in binary mode, then decode
with open(filename, 'rb') as fp:
source_bytes = fp.read()
return _decode_source(source_bytes)
except FileNotFoundError:
pass
# Source code is unavailable.
return None
zipimport.zipimporter.get_source = _get_source