U
|
X ±dsÕ ã @ sV d dl mZ d dlZd dlZd dlZd dlZd dlZd dlmZ d dl m
|
Z
|
d dl m Z d dl Z d dlmZmZ d dlmZ d dlmZ d d lmZ d d
|
lmZ d d lmZ e e¡Z e ej Z i Z dd dZ!dddZ"ddddZ#ddddZ$ddddZ%ej&ddddZ'ddd d d Z(ddd d!d"Z)ddd#d$d%Z*dd&d'd(Z+ej&ddd)d*Z,ddd+d,d-Z-dd.d/d0Z.dd2d3dd4d5d6Z/ddd7d8Z0dd.d9d:Z1ddd;d<d=Z2dd.d>d?Z3d@dA dBfddCddDdEdFZ4dGdH Z5dddIdJdKZ6dLdMdNgZ7de7fddOdPdQdRdSZ8dddUdVdWdWdXdYdZZ9dddVdUd[d\d]Z:dddUd^d_d`Z;dddadbdcZ<ddde Z=ddddfdgdhZ>ddidjdkZ?dldm Z@e@dndo ZAddpdqdrZBdddUdsdWdWddtdudvZCddwdxdyZDdzddd{d|d}ZEdddWdWd~ddZFdddZGejHr0d dlImJZK n"ejLrRd dlMmNZO e Pd
eO¡ [OdS )é )Ú annotationsN)ÚPath©Údeque)ÚCallable)ÚHOMEPATHÚcompat)Úlog)Ú PostGraphAPI)ÚExecCommandFailed)Ú!get_pywin32_module_file_attribute)ÚisolatedTc C s ddl m} |dkri }t tj¡}| |¡ tj |d t g ¡}d|krbtj |
|
d¡|g¡}||d< |rt j | d|i}| ¡ S t j| d|iS dS )zÑ
|
Executes an externally spawned Python interpreter. If capture_stdout is set to True, returns anything that was
|
emitted in the standard output as a single string. Otherwise, returns the exit code.
|
r )ÚCONFNZpathexÚ
|
PYTHONPATHÚenv)ZPyInstaller.configr ÚcopyÚdeepcopyÚosÚenvironÚupdateÚpathsepÚjoinr Úgetr Z exec_pythonÚstripZexec_python_rc)Úcmdr Úcapture_stdoutr Zpp_envÚppÚtxt© r úWd:\z\workplace\vscode\pyvenv\venv\Lib\site-packages\PyInstaller/utils/hooks/__init__.pyÚ__exec_python_cmd0 s
|
r c C s t | ¡} d| g}t||dS )Nz-c©r )ÚtextwrapÚdedentr )Ú statementr r r r r Ú__exec_statementL s
|
r% Ústr©r$ c C s t | ddS )a
|
Execute a single Python statement in an externally-spawned interpreter, and return the resulting standard output
|
as a string.
|
|
Examples::
|
|
tk_version = exec_statement("from _tkinter import TK_VERSION; print(TK_VERSION)")
|
|
mpl_data_dir = exec_statement("import matplotlib; print(matplotlib.get_data_path())")
|
datas = [ (mpl_data_dir, "") ]
|
|
Notes:
|
As of v5.0, usage of this function is discouraged in favour of the
|
new :mod:`PyInstaller.isolated` module.
|
|
Tr! ©r% r' r r r Úexec_statementR s r) c C s t | ddS )zf
|
Executes a Python statement in an externally spawned interpreter, and returns the exit code.
|
Fr! r( r' r r r Úexec_statement_rcf s r* c C s t | ¡ }|sdS t|S )aë
|
Execute a single Python statement in an externally-spawned interpreter, and :func:`eval` its output (if any).
|
|
Example::
|
|
databases = eval_statement('''
|
import sqlalchemy.databases
|
print(sqlalchemy.databases.__all__)
|
''')
|
for db in databases:
|
hiddenimports.append("sqlalchemy.databases." + db)
|
|
Notes:
|
As of v5.0, usage of this function is discouraged in favour of the
|
new :mod:`PyInstaller.isolated` module.
|
|
Ú )r) r Úeval)r$ r r r r Úeval_statementm s r- ©Ú module_namec C sD ddl }ddl}t|j ¡ }| | ¡ tt|j ¡ | | h S )aÇ
|
Return list of modules required by binary (C/C++) Python extension.
|
|
Python extension files ends with .so (Unix) or .pyd (Windows). It is almost impossible to analyze binary extension
|
and its dependencies.
|
|
Module cannot be imported directly.
|
|
Let's at least try import it in a subprocess and observe the difference in module list from sys.modules.
|
|
This function could be used for 'hiddenimports' in PyInstaller hooks files.
|
r N)ÚsysÚ importlibÚsetÚmodulesÚkeysÚ import_moduleÚlist)r/ r0 r1 Úoriginalr r r Úget_pyextension_imports s
|
|
r8 r+ )Úformulac C s¬ ddl }ddg}d}| r,| | ¡ d| }nd}z$| |¡ ¡ }t d||f ¡ W n@ tk
|
rr t d¡ Y n$ |jk
|
r t d | ¡ Y nX |r¤| d
|
¡S dS dS ) z§
|
Return the homebrew path to the requested formula, or the global prefix when called with no argument.
|
|
Returns the path as a string or None if not found.
|
r NZbrewz--prefixzhomebrew formula "%s"zhomebrew prefixzFound %s at "%s"z Detected homebrew not installedz#homebrew formula "%s" not installedÚutf8) Ú
|
subprocessÚappendÚ check_outputr ÚloggerÚdebugÚOSErrorÚCalledProcessErrorÚdecode)r9 r; ZbrewcmdÚpathZdbgstrr r r Úget_homebrew_path s"
|
|
|
rD ©ÚstringÚprefixc C s" | |¡r| t|d
S | S dS )z
|
This function removes the given prefix from a string, if the string does indeed begin with the prefix; otherwise,
|
it returns the original string.
|
N)Ú
|
startswithÚlenrE r r r Ú remove_prefix» s
|
rJ ©rF Úsuffixc C s( |r | |¡r | dt|
S | S dS )z
|
This function removes the given suffix from a string, if the string does indeed end with the suffix; otherwise,
|
it returns the original string.
|
N)ÚendswithrI rK r r r Ú remove_suffixÆ s rN )Úfilenamec C s< t jD ]$}| |¡r| d| |¡
S qtj | ¡d S )z
|
This function returns filename without its extension.
|
|
For Python C modules it removes even whole '.cpython-34m.so' etc.
|
r )r ÚEXTENSION_SUFFIXESrM Úrfindr rC Úsplitext)rO Úsuffr r r Úremove_file_extensionÓ s
|
|
rT c C s* zt | W dS tk
|
r$ Y dS X dS )a
|
Check if the specified module can be imported.
|
|
Intended as a silent module availability check, as it does not print ModuleNotFoundError traceback to stderr when
|
the module is unavailable.
|
|
Parameters
|
----------
|
module_name : str
|
Fully-qualified name of the module.
|
|
Returns
|
----------
|
bool
|
Boolean indicating whether the module can be imported or not.
|
TFN)Ú
|
__import__Ú Exceptionr. r r r Úcan_import_moduleà s
|
rW )r/ Ú attr_namec
|
C sX t jdd }z || |W S tk
|
rR } ztd| d| |W 5 d}~X Y nX dS )a·
|
Get the string value of the passed attribute from the passed module if this attribute is defined by this module
|
_or_ raise `AttributeError` otherwise.
|
|
Since modules cannot be directly imported during analysis, this function spawns a subprocess importing this module
|
and returning the string value of this attribute in this module.
|
|
Parameters
|
----------
|
module_name : str
|
Fully-qualified name of this module.
|
attr_name : str
|
Name of the attribute in this module to be retrieved.
|
|
Returns
|
----------
|
str
|
String value of this attribute.
|
|
Raises
|
----------
|
AttributeError
|
If this attribute is undefined.
|
c S s dd l }| | ¡}t||S ©Nr )r1 r5 Úgetattr)r/ rX r1 Úmoduler r r Ú_get_module_attribute s
|
z3get_module_attribute.<locals>._get_module_attributez Failed to retrieve attribute z from module N)r ÚdecoraterV ÚAttributeError)r/ rX r\ Úer r r Úget_module_attributeú s
|
r` ©Úpackagec
|
C s¤ d}d| krPz*ddl }| | ¡}| | ¡}|r4|W S W n ttfk
|
rN Y nX tjdd }z || }W n4 tk
|
r } ztd| d|W 5 d}~X Y nX |S )aù
|
Get the absolute path to the specified module or package.
|
|
Modules and packages *must not* be directly imported in the main process during the analysis. Therefore, to
|
avoid leaking the imports, this function uses an isolated subprocess when it needs to import the module and
|
obtain its ``__file__`` attribute.
|
|
Parameters
|
----------
|
package : str
|
Fully-qualified name of module or package.
|
|
Returns
|
----------
|
str
|
Absolute path of this module.
|
NÚ.r c S s\ z*dd l }| | ¡}| | ¡}|r(|W S W n ttfk
|
rB Y nX dd l}| | ¡}|jS rY )ÚpkgutilÚ find_loaderÚ get_filenamer^ Ú ImportErrorr1 r5 Ú__file__)rb rd ÚloaderrO r1 Úpr r r Ú_get_module_file_attributeC s
|
|
|
|
z=get_module_file_attribute.<locals>._get_module_file_attributez:Failed to obtain the __file__ attribute of package/module ú!)rd re rf r^ rg r r] rV )rb rO rd ri rk r_ r r r Úget_module_file_attribute s"
|
|
|
|
$rm Ú __version__z list | pkg_resources.Requirementz'str | pkg_resources.Distribution | None)Ú requirementsÚversionÚ version_attrc C s |dkrNzt | ¡ W n2 t jk
|
r, Y n" t jt jfk
|
rH Y dS X dS t j | ¡}|dkr|j}t|r|t ||}nd}|sdS ||kS dS )aD
|
|
Test if a :pep:`0440` requirement is installed.
|
|
Parameters
|
----------
|
requirements : str
|
Requirements in `pkg_resources.Requirements.parse()` format.
|
version : str
|
Optional PEP 0440-compliant version (e.g., `3.14-rc5`) to be used _instead_ of the current version of this
|
module. If non-`None`, this function ignores all `setuptools` distributions for this module and instead
|
compares this version against the version embedded in the passed requirements. This ignores the module name
|
embedded in the passed requirements, permitting arbitrary versions to be compared in a robust manner.
|
See examples below.
|
version_attr : str
|
Optional name of the version attribute defined by this module, defaulting to `__version__`. If a
|
`setuptools` distribution exists for this module (it usually does) _and_ the `version` parameter is `None`
|
(it usually is), this parameter is ignored.
|
|
Returns
|
----------
|
bool
|
Boolean result of the desired validation.
|
|
Raises
|
----------
|
AttributeError
|
If no `setuptools` distribution exists for this module _and_ this module defines no attribute whose name is the
|
passed `version_attr` parameter.
|
ValueError
|
If the passed specification does _not_ comply with `pkg_resources.Requirements`_ syntax.
|
|
Examples
|
--------
|
|
::
|
|
# Assume PIL 2.9.0, Sphinx 1.3.1, and SQLAlchemy 0.6 are all installed.
|
>>> from PyInstaller.utils.hooks import is_module_satisfies
|
>>> is_module_satisfies('sphinx >= 1.3.1')
|
True
|
>>> is_module_satisfies('sqlalchemy != 0.6')
|
False
|
|
>>> is_module_satisfies('sphinx >= 1.3.1; sqlalchemy != 0.6')
|
False
|
|
|
# Compare two arbitrary versions. In this case, the module name "sqlalchemy" is simply ignored.
|
>>> is_module_satisfies('sqlalchemy != 0.6', version='0.5')
|
True
|
|
# Since the "pillow" project providing PIL publishes its version via the custom "PILLOW_VERSION" attribute
|
# (rather than the standard "__version__" attribute), an attribute name is passed as a fallback to validate PIL
|
# when not installed by setuptools. As PIL is usually installed by setuptools, this optional parameter is
|
# usually ignored.
|
>>> is_module_satisfies('PIL == 2.9.0', version_attr='PILLOW_VERSION')
|
True
|
|
.. seealso::
|
|
`pkg_resources.Requirements`_ for the syntax details.
|
|
.. _`pkg_resources.Requirements`:
|
https://pythonhosted.org/setuptools/pkg_resources.html#id12
|
NFT)
|
Ú pkg_resourcesÚget_distributionÚDistributionNotFoundÚ UnknownExtraÚVersionConflictÚ RequirementÚparseÚ project_namerW r` )ro rp rq Zrequirements_parsedr/ r r r Úis_module_satisfies_ s" G rz c C s. dddd}d| kr || S t || ¡S dS )zû
|
Check if a Python module is really a module or is a package containing other modules, without importing anything
|
in the main process.
|
|
:param module_name: Module name to check.
|
:return: True if module is a package else otherwise.
|
r& r. c S s< z ddl }|j | ¡}t|jW S tk
|
r6 Y dS X dS )aD
|
Determines whether the given name represents a package or not. If the name represents a top-level module or
|
a package, it is not imported. If the name represents a sub-module or a sub-package, its parent is imported.
|
In such cases, this function should be called from an isolated suprocess.
|
r NF)Úimportlib.utilÚutilÚ find_specÚboolÚsubmodule_search_locationsrV )r/ r1 Úspecr r r Ú _is_packageÑ s z is_package.<locals>._is_packagerc N©r Úcall)r/ r r r r Ú
|
is_packageÉ s r c C s0 dddd}d| kr || }n t || ¡}|S )a
|
Given a package name, return all paths associated with the package. Typically, packages have a single location
|
path, but PEP 420 namespace packages may be split across multiple locations. Returns an empty list if the specified
|
package is not found or is not a package.
|
r& ra c S sT z6ddl }|j | ¡}|r |js&g W S dd |jD W S tk
|
rN g Y S X dS )aç
|
Retrieve package path(s), as advertised by submodule_search_paths attribute of the spec obtained via
|
importlib.util.find_spec(package). If the name represents a top-level package, the package is not imported.
|
If the name represents a sub-module or a sub-package, its parent is imported. In such cases, this function
|
should be called from an isolated suprocess. Returns an empty list if specified package is not found or is not
|
a package.
|
r Nc S s g | ] }t |qS r )r& )Ú.0rC r r r Ú
|
<listcomp>ù s zEget_all_package_paths.<locals>._get_package_paths.<locals>.<listcomp>)r{ r| r} r rV )rb r1 r r r r Ú_get_package_pathsì s
|
z1get_all_package_paths.<locals>._get_package_pathsrc r )rb r Ú pkg_pathsr r r Úget_all_package_pathsæ s
|
|
r ©Ú package_pathrb c C s t | | dtj¡S )a6
|
Given a package location path and package name, return the package base path, i.e., the directory in which the
|
top-level package is located. For example, given the path ``/abs/path/to/python/libs/pkg/subpkg`` and
|
package name ``pkg.subpkg``, the function returns ``/abs/path/to/python/libs``.
|
rc )rN Úreplacer Úsepr r r r Úpackage_base_path s r c C sP t | }|s td| dt|dkr6t d| |¡ |d }t|| }||fS )a£
|
Given a package, return the path to packages stored on this machine and also returns the path to this particular
|
package. For example, if pkg.subpkg lives in /abs/path/to/python/libs, then this function returns
|
``(/abs/path/to/python/libs, /abs/path/to/python/libs/pkg/subpkg)``.
|
|
NOTE: due to backwards compatibility, this function returns only one package path along with its base directory.
|
In case of PEP 420 namespace package with multiple location, only first location is returned. To obtain all
|
package paths, use the ``get_all_package_paths`` function and obtain corresponding base directories using the
|
``package_base_path`` helper.
|
z Package 'z%' does not exist or is not a package!é zQget_package_paths - package %s has multiple paths (%r); returning only first one!r )r Ú
|
ValueErrorrI r> Úwarningr )rb r Úpkg_dirÚpkg_baser r r Úget_package_paths s ÿ
|
r c C s dS )NTr ©Únamer r r Ú<lambda>, ó r ú warn oncezCallable[[str], bool])rb ÚfilterÚon_errorc
|
sð t | tstd|dkr*td| dt d| ¡ t| s\t d| ¡ t| rX| gS g S g }t }| | ¡ t
|
¡ Z}|rÎ| ¡ }| t||¡\}}}| fdd|D 7 }|D ]} | r´| | ¡ q´qzW 5 Q R X t|}t d |¡ |S )
|
a
|
List all submodules of a given package.
|
|
Arguments:
|
package:
|
An ``import``-able package.
|
filter:
|
Filter the submodules found: A callable that takes a submodule name and returns True if it should be
|
included.
|
on_error:
|
The action to take when a submodule fails to import. May be any of:
|
|
- raise: Errors are reraised and terminate the build.
|
- warn: Errors are downgraded to warnings.
|
- warn once: The first error issues a warning but all
|
subsequent errors are ignored to minimise *stderr pollution*. This
|
is the default.
|
- ignore: Skip all errors. Don't warn about anything.
|
Returns:
|
All submodules to be assigned to ``hiddenimports`` in a hook.
|
|
This function is intended to be used by hook scripts, not by main PyInstaller code.
|
|
Examples::
|
|
# Collect all submodules of Sphinx don't contain the word ``test``.
|
hiddenimports = collect_submodules(
|
"Sphinx", ``filter=lambda name: 'test' not in name)
|
|
.. versionchanged:: 4.5
|
Add the **on_error** parameter.
|
|
úpackage must be a str)Úignorer ÚwarnÚraisezInvalid on-error action 'z:': Must be one of ('ignore', 'warn once', 'warn', 'raise')z Collecting submodules for %sz)collect_submodules - %s is not a package.c s g | ]} |r|qS r r )r
r[ ©r r r r p s z&collect_submodules.<locals>.<listcomp>z)collect_submodules - found submodules: %s)Ú
|
isinstancer& Ú TypeErrorr r> r? r rW r r< r ÚPythonÚpopr Ú_collect_submodulesÚsorted)
|
rb r r Zpackage_submodulesÚtodoZisolated_pythonr r3 Ú subpackagesZsubpackage_namer r r Úcollect_submodules* s4 '
|
|
ÿ
|
|
r© c C s dd l }dd l}ddlm} ddlm} | d| ¡ g }g }z t| W n¢ tk
|
rê } z|dkrÀddl m} d
|
|t ||¡ ¡ }| d| d| d | ¡ |d
|
kr®d }|||f W Y ¢ S |d krÚtd | d|W 5 d }~X Y nX | |jkr|||fS t|j| dd pg } | s*|||fS | | ¡ | d| | ¡ | | | d ¡D ](\}
|
} } | sn| | ¡ n
|
| | ¡ qR|||fS )Nr )Úformat_exception_only)r> z-collect_submodules - scanning (sub)package %s)r r r+ z"Failed to collect submodules for 'z' because importing 'z
|
' raised: r r r zUnable to load subpackage 'ú'.Ú__path__z@collect_submodules - scanning (sub)package %s in location(s): %src )r0 rd Ú tracebackrª ÚPyInstaller.utils.hooksr> r? rU rV ZPyInstaller.logr Útyper r rg r3 rZ r< Ú iter_modules) r r r0 rd rª r> r3 r¨ ÚexÚpathsÚimporterÚispkgr r r r¥ ~ s> $
|
|
|
r¥ ©r Z mod_or_submodc C s | |d ¡p| |kS )a
|
This helper function is designed for use in the ``filter`` argument of :func:`collect_submodules`, by returning
|
``True`` if the given ``name`` is a module or a submodule of ``mod_or_submod``.
|
|
Examples:
|
|
The following excludes ``foo.test`` and ``foo.test.one`` but not ``foo.testifier``. ::
|
|
collect_submodules('foo', lambda name: not is_module_or_submodule(name, 'foo.test'))``
|
rc )rH rµ r r r Úis_module_or_submodule° s r¶ ú*.dllz*.dylibzlib*.soz
|
str | Nonez[str])rb ÚdestdirÚsearch_patternsc C s¼ t d| ¡ t| ts tdt| s8t d| ¡ g S t| }g }|D ]n}t|| }|D ]Z}t |
|
|¡}|D ]B} |r~|}
|
n | j |¡}
|
t d| |
|
f ¡ | t| t|
|
f¡ qpqZqH|S )a
|
This function produces a list of (source, dest) of dynamic library files that reside in package. Its output can be
|
directly assigned to ``binaries`` in a hook script. The package parameter must be a string which names the package.
|
|
:param destdir: Relative path to ./dist/APPNAME where the libraries should be put.
|
:param search_patterns: List of dynamic library filename patterns to collect.
|
z#Collecting dynamic libraries for %sr zZcollect_dynamic_libs - skipping library collection for module '%s' as it is not a package.z %s, %s)r> r? r¡ r& r¢ r r r r r ÚrglobÚparentÚ relative_tor< ) rb r¸ r¹ Úpkg_dirsZdylibsr r ÚpatternÚfilesÚsourceÚdestr r r Úcollect_dynamic_libsÆ s,
|
ÿ
|
r Fr~ zstr | os.PathLike | Nonez list | None)rb Úinclude_py_filesÚsubdirÚexcludesÚincludesc s t d| ¡ t| ts tdt| s8t d| ¡ g S |rDt|ng }t|}|sh|dd t j
|
D 7 }|sdt j
|
kr| d¡ |rt|ndg}t|}fd d
|
}g }t | } | D ]X}
|
t t|
|
| |rÜtj |
|
|¡}
|
||
|
||d ||
|
||d | fd dD 7 }q¶t d|¡ |S )aÔ
|
This function produces a list of ``(source, dest)`` non-Python (i.e., data) files that reside in ``package``.
|
Its output can be directly assigned to ``datas`` in a hook script; for example, see ``hook-sphinx.py``.
|
Parameters:
|
|
- The ``package`` parameter is a string which names the package.
|
- By default, all Python executable files (those ending in ``.py``, ``.pyc``, and so on) will NOT be collected;
|
setting the ``include_py_files`` argument to ``True`` collects these files as well. This is typically used with
|
Python functions (such as those in ``pkgutil``) that search a given directory for Python executable files and
|
load them as extensions or plugins.
|
- The ``subdir`` argument gives a subdirectory relative to ``package`` to search, which is helpful when submodules
|
are imported at run-time from a directory lacking ``__init__.py``.
|
- The ``excludes`` argument contains a sequence of strings or Paths. These provide a list of
|
`globs <https://docs.python.org/3/library/pathlib.html#pathlib.Path.glob>`_
|
to exclude from the collected data files; if a directory matches the provided glob, all files it contains will
|
be excluded as well. All elements must be relative paths, which are relative to the provided package's path
|
(/ ``subdir`` if provided).
|
|
Therefore, ``*.txt`` will exclude only ``.txt`` files in ``package``\ 's path, while ``**/*.txt`` will exclude
|
all ``.txt`` files in ``package``\ 's path and all its subdirectories. Likewise, ``**/__pycache__`` will exclude
|
all files contained in any subdirectory named ``__pycache__``.
|
- The ``includes`` function like ``excludes``, but only include matching paths. ``excludes`` override
|
``includes``: a file or directory in both lists will be excluded.
|
|
This function does not work on zipped Python eggs.
|
|
This function is intended to be used by hook scripts, not by main PyInstaller code.
|
z Collecting data files for %sr zUcollect_data_files - skipping data collection for module '%s' as it is not a package.c S s g | ] }d | qS )ú**/*r ©r
Úsr r r r % s z&collect_data_files.<locals>.<listcomp>z.pyoz**/*.pyorÇ c sl t |D ]^\}}t| |¡D ]F}| ¡ rL||k rd| t|d | ¡¡ q |rZ |¡n |¡ q qd S )NrÇ ) Ú enumerater ÚglobÚis_dirr< r& r¼ ÚaddÚdiscard)r ZcludesZ clude_lenZ
|
is_includeÚiÚcÚg)Úsourcesr r Ú clude_walker2 s
|
z(collect_data_files.<locals>.clude_walkerTFc s$ g | ] }t |t |j ¡fqS r ©r& r» r¼ rÈ ©r r r r W s z$collect_data_files - Found files: %s)r> r? r¡ r& r¢ r r r6 rI r Ú ALL_SUFFIXESr< r r2 r r rC r ) rb rà rÄ rÅ rÆ Z excludes_lenZ includes_lenrÓ Údatasr½ r r )r rÒ r Úcollect_data_filesð s6 #
|
|
|
rØ )rC r¸ rà c C s t | tstdg }t | ¡D ]t\}}}|D ]d}tj |¡d }|sN|tkr.tj ||¡} tt |
|
| ¡}
|
|dk rtj ||
|
¡}
|
| | |
|
f¡ q.q |S )a
|
This function produces a list of (source, dest) non-Python (i.e., data) files that reside somewhere on the system.
|
Its output can be directly assigned to ``datas`` in a hook script.
|
|
This function is intended to be used by hook scripts, not by main PyInstaller code.
|
zpath must be a strr N) r¡ r& r¢ r ÚwalkrC rR ÚPY_IGNORE_EXTENSIONSr r r¼ r< ) rC r¸ rà r× ÚdirpathÚdirnamesr¿ ÚfÚ extensionrÀ rÁ r r r Úcollect_system_data_files] s
|
rß )Ú package_nameÚ recursivec C sÊ ddl m} || g}t }g }|rÆ| ¡ } | |kr6q t | ¡}|jdk rjt|j|j}| |j|f¡ n0t
|
|}|dkrt d|j d| |df¡ |s¢|S | | ¡ | dd | ¡ D ¡ q |S ) a«
|
Collect distribution metadata so that ``pkg_resources.get_distribution()`` can find it.
|
|
This function returns a list to be assigned to the ``datas`` global variable. This list instructs PyInstaller to
|
copy the metadata for the given package to the frozen application's data directory.
|
|
Parameters
|
----------
|
package_name : str
|
Specifies the name of the package for which metadata should be copied.
|
recursive : bool
|
If true, collect metadata for the package's dependencies too. This enables use of
|
``pkg_resources.require('package')`` inside the frozen application.
|
|
Returns
|
-------
|
list
|
This should be assigned to ``datas``.
|
|
Examples
|
--------
|
>>> from PyInstaller.utils.hooks import copy_metadata
|
>>> copy_metadata('sphinx')
|
[('c:\python27\lib\site-packages\Sphinx-1.3.2.dist-info',
|
'Sphinx-1.3.2.dist-info')]
|
|
|
Some packages rely on metadata files accessed through the ``pkg_resources`` module. Normally PyInstaller does not
|
include these metadata files. If a package fails without them, you can use this function in a hook file to easily
|
add them to the frozen bundle. The tuples in the returned list have two strings. The first is the full pathname to a
|
folder in this system. The second is the folder name only. When these tuples are added to ``datas``\ , the folder
|
will be bundled at the top level.
|
|
.. versionchanged:: 4.3.1
|
|
Prevent ``dist-info`` metadata folders being renamed to ``egg-info`` which broke ``pkg_resources.require`` with
|
*extras* (see :issue:`#3033`).
|
|
.. versionchanged:: 4.4.0
|
|
Add the **recursive** option.
|
r r Nú)No metadata path found for distribution 'z"' (legacy fallback search failed).rc c s s | ] }|j V qd S )N)ry )r
rÏ r r r Ú <genexpr>À s z copy_metadata.<locals>.<genexpr>)Ú collectionsr r2 r¤ rr rs Úegg_infoÚ_copy_metadata_destry r< Ú _resolve_legacy_metadata_pathÚ RuntimeErrorrÍ ÚextendÚrequires) rà rá r r§ ÚdoneÚoutÚdistrÁ Zdist_srcr r r Ú copy_metadatax s. +
|
|
|
ÿ
|
rî )r Úreturnc C s | ¡ dd¡S )NÚ_ú-)Úlowerr r r r r Ú_normalise_distÅ s ró c C s¸ | ¡ d| j d| j d| j dd¡ d| j dg}dtjd dtjd }| ¡ |¡r| | ¡ dt|
d ¡ |D ](}t j
|
| j |¡}t j
|
|¡r| S qdS ) ai
|
Attempt to resolve the legacy metadata file for the given distribution.
|
The .egg-info file is commonly used by Debian/Ubuntu when packaging python packages.
|
|
Args:
|
dist:
|
The distribution information as returned by ``pkg_resources.get_distribution("xyz")``.
|
Returns:
|
The path to the distribution's metadata file.
|
z .egg-inforñ rð z-pyr rc r N)Úegg_namery rp r r0 Ú version_inforM r< rI r rC r ÚlocationÚisfile)rí Ú
|
candidatesZ pyxx_suffixÚ candidateZcandidate_pathr r r rç É s ù
|
rç )Úegg_pathry rï c C s | dkrt d| dt| } t|}t| j |¡r>| jS t| jdkrvt| jd |¡rvtjj | jdd
S t d| d| ddS ) a2
|
Choose an appropriate destination path for a distribution's metadata.
|
|
Args:
|
egg_path:
|
The output of ``pkg_resources.get_distribution("xyz").egg_info``: a full path to the source
|
``xyz-version.dist-info`` or ``xyz-version.egg-info`` folder containing package metadata.
|
project_name:
|
The distribution name given.
|
Returns:
|
The *dest* parameter: where in the bundle should this folder go.
|
Raises:
|
RuntimeError:
|
If **egg_path** is None, i.e., no metadata is found.
|
Nrâ r« é éþÿÿÿzUnknown metadata type 'z ' from the 'zT' distribution. Please report this at https://github/pyinstaller/pyinstaller/issues.)
|
rè r ró r rH rI Úpartsr rC r )rú ry Ú _project_namer r r ræ ì s ÿræ )r[ c
|
C sf t | }|d| d¡td
}t |¡}d}|D ]}| ¡ |jkr4|} qPq4t|d \}}tj
|
|d¡}tj |¡râtj |¡rât |dL} | ¡ }
|
|
|
d dkrØ|
|
d d¡} t d | | |¡¡ | W 5 Q R £ S W 5 Q R X tjrbz4t d d
|
|¡} d | kr t d | |¡¡ W d S W n tk
|
r4 Y nX tj |¡} d| krbt d | |¡¡ dS dS )z
|
Try to find which package manager installed a module.
|
|
:param module: Module to check
|
:return: Package manager or None
|
Nz site-packagesr Ú INSTALLERÚrr+ z
|
z<Found installer: '{0}' for module: '{1}' from package: '{2}'ÚportÚprovideszis provided byzAFound installer: 'macports' for module: '{0}' from package: '{1}'ZmacportsZCellarzAFound installer: 'homebrew' for module: '{0}' from package: '{1}'Zhomebrew)rm ÚindexrI rr Úfind_distributionsrò Úkeyrî r rC r ÚisdirÚexistsÚopenÚ readlinesÚrstripr> r? Úformatr Z is_darwinZexec_command_stdoutr Úrealpath)r[ Ú file_nameZsite_dirÚpkgsrb ÚpkgÚ metadata_dirÚdest_dirÚinstaller_fileZinstaller_file_objectÚlinesÚ installerÚoutputÚ real_pathr r r Ú get_installer sD
|
ÿ
|
|
ÿ
|
|
r c s g fdd}|S )Nc s s ¡ d S rY )r< r ©rÝ Úmemor r ÚhelperR s z_memoize.<locals>.helperr )rÝ r r r r Ú_memoizeO s r c
|
C s t d¡ i } tjD ]r}|s d}zt |¡}W n tk
|
rB Y qX |D ]<}zt |¡}W n tk
|
rn Y qHX | |j
|
g ¡ |¡ qHq| S )Nz5Determining a mapping of distributions to packages...rc ) r> Úinfor0 rC r ÚlistdirrV rr rs Ú
|
setdefaultr r< )Údist_to_packagesrj ZldsZldrí r r r Ú _map_distribution_to_packages[ s
|
|
r )rà c C s` g }t }t | ¡ ¡ D ]4}|j|kr<||j }| |¡ qt d|j| ¡ qt d| |¡ |S )Nz:Unable to find package for requirement %s from package %s.zPackages required by %s:
|
%s)
|
r rr rs rê r ré r> r ry r )rà Ú hiddenimportsr Ú requirementZrequired_packagesr r r Úrequirements_for_packagew s
|
|
ÿr# zCallable | None)rà rà Úfilter_submodulesÚ exclude_datasÚ include_datasr c
|
|
C sÊ g }z|t | 7 }W n0 tk
|
rD } zt d| |¡ W 5 d}~X Y nX |t| |||d7 }t| }|rvt| ||d} nt| } z| t| 7 } W n0 tk
|
r¾ } zt d| |¡ W 5 d}~X Y nX ||| fS )a°
|
Collect everything for a given package name.
|
|
Arguments:
|
package_name:
|
An ``import``-able package name.
|
include_py_files:
|
Forwarded to :func:`collect_data_files`.
|
filter_submodules:
|
Forwarded to :func:`collect_submodules`.
|
exclude_datas:
|
Forwarded to :func:`collect_data_files`.
|
include_datas:
|
Forwarded to :func:`collect_data_files`.
|
on_error:
|
Forwarded onto :func:`collect_submodules`.
|
|
Returns:
|
tuple: A ``(datas, binaries, hiddenimports)`` triplet containing:
|
|
- All data files, raw Python files (if **include_py_files**), and package metadata folders.
|
- All dynamic libraries as returned by :func:`collect_dynamic_libs`.
|
- All submodules of **packagename** and its dependencies.
|
|
Typical use::
|
|
datas, binaries, hiddenimports = collect_all('my_module_name')
|
z"Unable to copy metadata for %s: %sN)rÅ rÆ )r r z+Unable to determine requirements for %s: %s)rî rV r> r rØ r r© r# )
|
rà rà r$ r% r& r r× r_ Úbinariesr! r r r Ú collect_all s $ r( r c C sV ddl }g }g }| | ¡D ]2}|jdkr,dn|jj}|t|7 }| |j¡ q||fS )ai
|
Collect modules and metadata for all exporters of a given entry point.
|
|
Args:
|
name:
|
The name of the entry point. Check the documentation for the library that uses the entry point to find
|
its name.
|
Returns:
|
A ``(datas, hiddenimports)`` pair that should be assigned to the ``datas`` and ``hiddenimports``, respectively.
|
|
For libraries, such as ``pytest`` or ``keyring``, that rely on plugins to extend their behaviour.
|
|
Examples:
|
Pytest uses an entry point called ``'pytest11'`` for its extensions.
|
To collect all those extensions use::
|
|
datas, hiddenimports = collect_entry_point("pytest11")
|
|
These values may be used in a hook or added to the ``datas`` and ``hiddenimports`` arguments in the ``.spec``
|
file. See :ref:`using spec files`.
|
|
.. versionadded:: 4.3
|
r Nr+ )rr Úiter_entry_pointsrí ry rî r< r/ )r rr r× Zimportsrí ry r r r Úcollect_entry_point¿ s r* r
|
)Úhook_apir/ r c C s0 | j j}d}||kr,||| kr,|| | }|S )aÔ
|
Get user settings for hooks.
|
|
Args:
|
module_name:
|
The module/package for which the key setting belong to.
|
key:
|
A key for the config.
|
Returns:
|
The value for the config. ``None`` if not set.
|
|
The ``get_hook_config`` function will lookup settings in the ``Analysis.hooksconfig`` dict.
|
|
The hook settings can be added to ``.spec`` file in the form of::
|
|
a = Analysis(["my-app.py"],
|
...
|
hooksconfig = {
|
"gi": {
|
"icons": ["Adwaita"],
|
"themes": ["Adwaita"],
|
"languages": ["en_GB", "zh_CN"],
|
},
|
},
|
...
|
)
|
N)ZanalysisZ hooksconfig)r+ r/ r ÚconfigÚvaluer r r Úget_hook_configá s
|
r. )rO Ú include_listÚ exclude_listc C sN |dk r&|D ]}t | |¡r q&q dS |dk rJ|D ]}t | |¡r2 dS q2dS )a
|
Generic inclusion/exclusion decision function based on filename and list of include and exclude patterns.
|
|
Args:
|
filename:
|
Filename considered for inclusion.
|
include_list:
|
List of inclusion file patterns.
|
exclude_list:
|
List of exclusion file patterns.
|
|
Returns:
|
A boolean indicating whether the file should be included or not.
|
|
If ``include_list`` is provided, True is returned only if the filename matches one of include patterns (and does not
|
match any patterns in ``exclude_list``, if provided). If ``include_list`` is not provided, True is returned if
|
filename does not match any patterns in ``exclude list``, if provided. If neither list is provided, True is
|
returned for any filename.
|
NFT)Úfnmatch)rO r/ r0 r¾ r r r Úinclude_or_exclude_file s r2 c s |pg }|pg }|dkr | d }t js.||fS t| \ }t | }| ¡ sZ||fS | fdd| d¡D 7 }| fdd| d¡D 7 }||fS )a
|
Collect data files and binaries from the .libs directory of a delvewheel-enabled python wheel. Such wheels ship
|
their shared libraries in a .libs directory that is located next to the package directory, and therefore falls
|
outside the purview of the collect_dynamic_libs() utility function.
|
|
Args:
|
package_name:
|
Name of the package (e.g., scipy).
|
libdir_name:
|
Optional name of the .libs directory (e.g., scipy.libs). If not provided, ".libs" is added to
|
``package_name``.
|
datas:
|
Optional list of datas to which collected data file entries are added. The combined result is retuned
|
as part of the output tuple.
|
binaries:
|
Optional list of binaries to which collected binaries entries are added. The combined result is retuned
|
as part of the output tuple.
|
|
Returns:
|
tuple: A ``(datas, binaries)`` pair that should be assigned to the ``datas`` and ``binaries``, respectively.
|
|
Examples:
|
Collect the ``scipy.libs`` delvewheel directory belonging to the Windows ``scipy`` wheel::
|
|
datas, binaries = collect_delvewheel_libs_directory("scipy")
|
|
When the collected entries should be added to existing ``datas`` and ``binaries`` listst, the following form
|
can be used to avoid using intermediate temporary variables and merging those into existing lists::
|
|
datas, binaries = collect_delvewheel_libs_directory("scipy", datas=datas, binaries=binaries)
|
|
.. versionadded:: 5.6
|
Nz.libsc s$ g | ] }t |t |j ¡fqS r rÔ )r
Zdll_filerÕ r r r d s z5collect_delvewheel_libs_directory.<locals>.<listcomp>r· c s$ g | ] }t |t |j ¡fqS r rÔ )r
Zload_order_filerÕ r r r i s ÿz.load[-_]order*)r Zis_winr r rÌ rË )rà Z libdir_namer× r' r Zlibs_dirr rÕ r Ú!collect_delvewheel_libs_directory+ s # ÿr3 )Úconda)ÚCONDA_META_DIRz¨Assuming this is not an Anaconda environment or an additional venv/pipenv/... environment manager is being used on top, because the conda-meta folder %s does not exist.)NT)T)r+ )Nrn )FNNN)NF)F)TNNNr )NN)NNN)QÚ
|
__future__r r r r0 r" r1 Úpathlibr rä r Útypingr rr Z PyInstallerr r r ÚloggingZ PyInstaller.depend.imphookapir
|
ZPyInstaller.exceptionsr Z PyInstaller.utils.hooks.win32r r Ú getLoggerÚ__name__r> r2 rÖ rÚ Zhook_variablesr r% r) r* r- r] r8 rD rJ rN rT rW r` rm rz r r r r r© r¥ r¶ ZPY_DYLIB_PATTERNSr rØ rß rî ró rç ræ r r r r# r( r* r. r2 r3 Z is_pure_condar® r4 Z conda_supportZis_condaZ PyInstaller.utils.hooks.condar5 Z_tmpr r r r r Ú<module> s¬
|
|
|
|
&A ýj ! ýT2ý, ûmM#21
|
ú7"% ý'
|
D þ
|
