Pyinstaller seems to "execute" my files at build time

[igorbga]

I have a program that when running initializes some config information. This information is only available after runnning the program.
Some other modules of my program use that information and in case some of them tries to use the configuration before it is initialization it throws an exception. I have some modules that use that config just by the fact that they are imported.

We have noticed that during the build process of our ".exe" file the exception is thrown just after Pyinstaller prints "Looking for dynamic libraries".

Despite that exception Pyinstaller goes on and the ".exe" seems to be correctly generated.

But the thing is that this seems to imply that during build time Pyinstaller is in fact "running" the code in my modules, not just analyzing them.

That was unexpected for us and could potentially be an issue depending on the sideeffects this execution could have.

Just in case it matters the package that triggers the exception is imported in a modules "__init__". Maybe is just the __init__ files that Pyinstaller does run?

Are we right to assume that our code will be, at least partially, run also at build time ? Should we organize our code taking this into consideration?

[rokm]

On Windows, we import packages in an isolated sub-process prior to running binary dependency analysis ("Looking for dynamic libraries"), in order to catch dynamic changes to DLL search paths that are made by some packages during their initialization.

See:

pyinstaller/PyInstaller/building/build_main.py

Lines 173 to 273 in 3aa87b0

	# On Windows, packages' initialization code might register additional DLL search paths, either by modifying the
	# `PATH` environment variable, or by calling `os.add_dll_directory`. Therefore, we import all collected packages,
	# and track changes made to the environment.
	if compat.is_win:
	# Helper functions to be executed in isolated environment.
	def setup(suppressed_imports):
	"""
	Prepare environment for change tracking
	"""
	import os
	import sys
	os._added_dll_directories = []
	os._original_path_env = os.environ.get('PATH', '')
	_original_add_dll_directory = os.add_dll_directory
	def _pyi_add_dll_directory(path):
	os._added_dll_directories.append(path)
	return _original_add_dll_directory(path)
	os.add_dll_directory = _pyi_add_dll_directory
	# Suppress import of specified packages
	for name in suppressed_imports:
	sys.modules[name] = None
	def import_library(package):
	"""
	Import collected package to set up environment.
	"""
	try:
	__import__(package)
	except Exception:
	pass
	def process_search_paths():
	"""
	Obtain lists of added search paths.
	"""
	import os
	# `os.add_dll_directory` might be called with a `pathlib.Path`, which cannot be marhsalled out of the helper
	# process. So explicitly convert all entries to strings.
	dll_directories = [str(path) for path in os._added_dll_directories]
	orig_path = set(os._original_path_env.split(os.pathsep))
	modified_path = os.environ.get('PATH', '').split(os.pathsep)
	path_additions = [path for path in modified_path if path and path not in orig_path]
	return dll_directories, path_additions
	# Pre-process the list of packages to import.
	# Check for Qt bindings packages, and put them at the front of the packages list. This ensures that they are
	# always imported first, which should prevent packages that support multiple bindings (`qtypy`, `pyqtgraph`,
	# `matplotlib`, etc.) from trying to auto-select bindings.
	_QT_BINDINGS = ('PySide2', 'PyQt5', 'PySide6', 'PyQt6')
	qt_packages = []
	other_packages = []
	for package in import_packages:
	if package.startswith(_QT_BINDINGS):
	qt_packages.append(package)
	else:
	other_packages.append(package)
	import_packages = qt_packages + other_packages
	# Just in case, explicitly suppress imports of Qt bindings that we are *not* collecting - if multiple bindings
	# are available and some were excluded from our analysis, a package imported here might still try to import an
	# excluded bindings package (and succeed at doing so).
	suppressed_imports = [package for package in _QT_BINDINGS if package not in qt_packages]
	# If we suppressed PySide2 or PySide6, we must also suppress their corresponding shiboken package
	if "PySide2" in suppressed_imports:
	suppressed_imports += ["shiboken2"]
	if "PySide6" in suppressed_imports:
	suppressed_imports += ["shiboken6"]
	# Suppress import of `pyqtgraph.canvas`, which is known to crash python interpreter. See #7452 and #8322, as
	# well as https://github.com/pyqtgraph/pyqtgraph/issues/2838.
	suppressed_imports += ['pyqtgraph.canvas']
	# PySimpleGUI 5.x displays a "first-run" dialog when imported for the first time, which blocks the loop below.
	# This is a problem for building on CI, where the dialog cannot be closed, and where PySimpleGUI runs "for the
	# first time" every time. See #8396.
	suppressed_imports += ['PySimpleGUI']
	# Processing in isolated environment.
	with isolated.Python() as child:
	child.call(setup, suppressed_imports)
	for package in import_packages:
	try:
	child.call(import_library, package)
	except isolated.SubprocessDiedError as e:
	# Re-raise as `isolated.SubprocessDiedError` again, to trigger error-handling codepath in
	# `isolated.Python.__exit__()`.
	raise isolated.SubprocessDiedError(
	f"Isolated subprocess crashed while importing package {package!r}! "
	f"Package import list: {import_packages!r}"
	) from e
	added_dll_directories, added_path_directories = child.call(process_search_paths)

[igorbga]

A ok, so I guess the answer is YES, PyInstaller does import packages during build time so any "permanent" sideeffect that the import might have should be considered.

I might have missed it but I think that I didn't find this mentioned anywhere in the documentation and it might be worth doing so as a warning.

By the way, is there any sensible way to know when we are running in build time instead of runtime? That would allow us to just to check it and avoid unwanted sideeffects during build time.

In worst case I guess we could just set an environment variable before launching PyInstaller in order to flag that we are running PyInstaller or something like that, but if there is already an "official" way to do so I'd rather not reinvent the wheel.

Thanks a lot for you fast and accurate answer.

[bwoodsend]

The official way to do it would be to not build importable modules with side-effects.

[rokm]

I suppose using environment variable would be most deliberate and thus also most foolproof.