#----------------------------------------------------------------------------- # Copyright (c) 2013-2023, PyInstaller Development Team. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # # The full license is in the file COPYING.txt, distributed with this software. # # SPDX-License-Identifier: Apache-2.0 #----------------------------------------------------------------------------- # To make pkg_resources work with frozen modules, we need to set the 'Provider' class for PyiFrozenLoader. # This class decides where to look for resources and other stuff. # # 'pkg_resources.NullProvider' is dedicated to abitrary PEP302 loaders, such as our PyiFrozenLoader. It uses method # __loader__.get_data() in methods pkg_resources.resource_string() and pkg_resources.resource_stream(). # # We provide PyiFrozenProvider, which subclasses the NullProvider and implements _has(), _isdir(), and _listdir() # methods, which are needed for pkg_resources.resource_exists(), resource_isdir(), and resource_listdir() to work. We # cannot use the DefaultProvider, because it provides filesystem-only implementations (and overrides _get() with a # filesystem-only one), whereas our provider needs to also support embedded resources. # # The PyiFrozenProvider allows querying/listing both PYZ-embedded and on-filesystem resources in a frozen package. The # results are typically combined for both types of resources (e.g., when listing a directory or checking whether a # resource exists). When the order of precedence matters, the PYZ-embedded resources take precedence over the # on-filesystem ones, to keep the behavior consistent with the actual file content retrieval via _get() method (which in # turn uses PyiFrozenLoader's get_data() method). For example, when checking whether a resource is a directory via # _isdir(), a PYZ-embedded file will take precedence over a potential on-filesystem directory. Also, in contrast to # unfrozen packages, the frozen ones do not contain source .py files, which are therefore absent from content listings. def _pyi_rthook(): import os import pathlib import sys import warnings with warnings.catch_warnings(): warnings.filterwarnings( "ignore", category=UserWarning, message="pkg_resources is deprecated", ) import pkg_resources import pyimod02_importers # PyInstaller's bootstrap module SYS_PREFIX = pathlib.PurePath(sys._MEIPASS) class _TocFilesystem: """ A prefix tree implementation for embedded filesystem reconstruction. NOTE: as of PyInstaller 6.0, the embedded PYZ archive cannot contain data files anymore. Instead, it contains only .pyc modules - which are by design not returned by `PyiFrozenProvider`. So this implementation has been reduced to supporting only directories implied by collected packages. """ def __init__(self, tree_node): self._tree = tree_node def _get_tree_node(self, path): path = pathlib.PurePath(path) current = self._tree for component in path.parts: if component not in current: return None current = current[component] return current def path_exists(self, path): node = self._get_tree_node(path) return isinstance(node, dict) # Directory only def path_isdir(self, path): node = self._get_tree_node(path) return isinstance(node, dict) # Directory only def path_listdir(self, path): node = self._get_tree_node(path) if not isinstance(node, dict): return [] # Non-existent or file # Return only sub-directories return [entry_name for entry_name, entry_data in node.items() if isinstance(entry_data, dict)] class PyiFrozenProvider(pkg_resources.NullProvider): """ Custom pkg_resources provider for PyiFrozenLoader. """ def __init__(self, module): super().__init__(module) # Get top-level path; if "module" corresponds to a package, we need the path to the package itself. # If "module" is a submodule in a package, we need the path to the parent package. # # This is equivalent to `pkg_resources.NullProvider.module_path`, except we construct a `pathlib.PurePath` # for easier manipulation. # # NOTE: the path is NOT resolved for symbolic links, as neither are paths that are passed by `pkg_resources` # to `_has`, `_isdir`, `_listdir` (they are all anchored to `module_path`, which in turn is just # `os.path.dirname(module.__file__)`. As `__file__` returned by `PyiFrozenLoader` is always anchored to # `sys._MEIPASS`, we do not have to worry about cross-linked directories in macOS .app bundles, where the # resolved `__file__` could be either in the `Contents/Frameworks` directory (the "true" `sys._MEIPASS`), or # in the `Contents/Resources` directory due to cross-linking. self._pkg_path = pathlib.PurePath(module.__file__).parent # Construct _TocFilesystem on top of pre-computed prefix tree provided by pyimod02_importers. self.embedded_tree = _TocFilesystem(pyimod02_importers.get_pyz_toc_tree()) def _normalize_path(self, path): # Avoid using `Path.resolve`, because it resolves symlinks. This is undesirable, because the pure path in # `self._pkg_path` does not have symlinks resolved, so comparison between the two would be faulty. Instead, # use `os.path.normpath` to normalize the path and get rid of any '..' elements (the path itself should # already be absolute). return pathlib.Path(os.path.normpath(path)) def _is_relative_to_package(self, path): return path == self._pkg_path or self._pkg_path in path.parents def _has(self, path): # Prevent access outside the package. path = self._normalize_path(path) if not self._is_relative_to_package(path): return False # Check the filesystem first to avoid unnecessarily computing the relative path... if path.exists(): return True rel_path = path.relative_to(SYS_PREFIX) return self.embedded_tree.path_exists(rel_path) def _isdir(self, path): # Prevent access outside the package. path = self._normalize_path(path) if not self._is_relative_to_package(path): return False # Embedded resources have precedence over filesystem... rel_path = path.relative_to(SYS_PREFIX) node = self.embedded_tree._get_tree_node(rel_path) if node is None: return path.is_dir() # No match found; try the filesystem. else: # str = file, dict = directory return not isinstance(node, str) def _listdir(self, path): # Prevent access outside the package. path = self._normalize_path(path) if not self._is_relative_to_package(path): return [] # Relative path for searching embedded resources. rel_path = path.relative_to(SYS_PREFIX) # List content from embedded filesystem... content = self.embedded_tree.path_listdir(rel_path) # ... as well as the actual one. if path.is_dir(): # Use os.listdir() to avoid having to convert Path objects to strings... Also make sure to de-duplicate # the results. path = str(path) # not is_py36 content = list(set(content + os.listdir(path))) return content pkg_resources.register_loader_type(pyimod02_importers.PyiFrozenLoader, PyiFrozenProvider) # With our PyiFrozenFinder now being a path entry finder, it effectively replaces python's FileFinder. So we need # to register it with `pkg_resources.find_on_path` to allow metadata to be found on filesystem. pkg_resources.register_finder(pyimod02_importers.PyiFrozenFinder, pkg_resources.find_on_path) # For the above change to fully take effect, we need to re-initialize pkg_resources's master working set (since the # original one was built with assumption that sys.path entries are handled by python's FileFinder). # See https://github.com/pypa/setuptools/issues/373 if hasattr(pkg_resources, '_initialize_master_working_set'): pkg_resources._initialize_master_working_set() _pyi_rthook() del _pyi_rthook