hiR`dZddlmZddlmZmZGddZGddZGdd Zy ) a Classes facilitating communication between PyInstaller and import hooks. PyInstaller passes instances of classes defined by this module to corresponding functions defined by external import hooks, which commonly modify the contents of these instances before returning. PyInstaller then detects and converts these modifications into appropriate operations on the current `PyiModuleGraph` instance, thus modifying which modules will be frozen into the executable. )format_binaries_and_datas) RuntimeModuleRuntimePackagecNeZdZdZdZedZedZdZdZ dZ dZ y ) PreSafeImportModuleAPIa* Metadata communicating changes made by the current **pre-safe import module hook** (i.e., hook run immediately _before_ a call to `ModuleGraph._safe_import_module()` recursively adding the hooked module, package, or C extension and all transitive imports thereof to the module graph) back to PyInstaller. Pre-safe import module hooks _must_ define a `pre_safe_import_module()` function accepting an instance of this class, whose attributes describe the subsequent `ModuleGraph._safe_import_module()` call creating the hooked module's graph node. Each pre-safe import module hook is run _only_ on the first attempt to create the hooked module's graph node and then subsequently ignored. If this hook successfully creates that graph node, the subsequent `ModuleGraph._safe_import_module()` call will observe this fact and silently return without attempting to recreate that graph node. Pre-safe import module hooks are typically used to create graph nodes for **runtime modules** (i.e., modules dynamically defined at runtime). Most modules are physically defined in external `.py`-suffixed scripts. Some modules, however, are dynamically defined at runtime (e.g., `six.moves`, dynamically defined by the physically defined `six.py` module). However, `ModuleGraph` only parses `import` statements residing in external scripts. `ModuleGraph` is _not_ a full-fledged, Turing-complete Python interpreter and hence has no means of parsing `import` statements performed by runtime modules existing only in-memory. 'With great power comes great responsibility.' Attributes (Immutable) ---------------------------- The following attributes are **immutable** (i.e., read-only). For safety, any attempts to change these attributes _will_ result in a raised exception: module_graph : PyiModuleGraph Current module graph. parent_package : Package Graph node for the package providing this module _or_ `None` if this module is a top-level module. Attributes (Mutable) ----------------------------- The following attributes are editable. module_basename : str Unqualified name of the module to be imported (e.g., `text`). module_name : str Fully-qualified name of this module (e.g., `email.mime.text`). c<||_||_||_||_yN) _module_graphmodule_basename module_name_parent_package)self module_graphr r parent_packages IC:\des-py\Monitor\venv\Lib\site-packages\PyInstaller/depend/imphookapi.py__init__zPreSafeImportModuleAPI.__init__Ds").&-c|jSz' Current module graph. r rs rrz#PreSafeImportModuleAPI.module_graphK !!!rc|jS)z. Parent Package of this node. )r rs rrz%PreSafeImportModuleAPI.parent_packageRs ###rcL|jjt|y)as Add a graph node representing a non-package Python module with the passed name dynamically defined at runtime. Most modules are statically defined on-disk as standard Python files. Some modules, however, are dynamically defined in-memory at runtime (e.g., `gi.repository.Gst`, dynamically defined by the statically defined `gi.repository.__init__` module). This method adds a graph node representing such a runtime module. Since this module is _not_ a package, all attempts to import submodules from this module in `from`-style import statements (e.g., the `queue` submodule in `from six.moves import queue`) will be silently ignored. To circumvent this, simply call `add_runtime_package()` instead. Parameters ---------- module_name : str Fully-qualified name of this module (e.g., `gi.repository.Gst`). Examples ---------- This method is typically called by `pre_safe_import_module()` hooks, e.g.: def pre_safe_import_module(api): api.add_runtime_module(api.module_name) N)r add_moduler)rr s radd_runtime_modulez)PreSafeImportModuleAPI.add_runtime_moduleYs4 %%mK&@ArcL|jjt|y)a: Add a graph node representing a non-namespace Python package with the passed name dynamically defined at runtime. Most packages are statically defined on-disk as standard subdirectories containing `__init__.py` files. Some packages, however, are dynamically defined in-memory at runtime (e.g., `six.moves`, dynamically defined by the statically defined `six` module). This method adds a graph node representing such a runtime package. All attributes imported from this package in `from`-style import statements that are submodules of this package (e.g., the `queue` submodule in `from six.moves import queue`) will be imported rather than ignored. Parameters ---------- package_name : str Fully-qualified name of this package (e.g., `six.moves`). Examples ---------- This method is typically called by `pre_safe_import_module()` hooks, e.g.: def pre_safe_import_module(api): api.add_runtime_package(api.module_name) N)r rr)r package_names radd_runtime_packagez*PreSafeImportModuleAPI.add_runtime_packageus4 %%n\&BCrc<|jj||y)a Alias the source module to the target module with the passed names. This method ensures that the next call to findNode() given the target module name will resolve this alias. This includes importing and adding a graph node for the source module if needed as well as adding a reference from the target to the source module. Parameters ---------- real_module_name : str Fully-qualified name of the **existing module** (i.e., the module being aliased). alias_module_name : str Fully-qualified name of the **non-existent module** (i.e., the alias to be created). N)r alias_module)rreal_module_namealias_module_names radd_alias_modulez'PreSafeImportModuleAPI.add_alias_modules ''(8:KLrcP|jj|j|y)a Modulegraph does a good job at simulating Python's, but it cannot handle packagepath `__path__` modifications packages make at runtime. Therefore there is a mechanism whereby you can register extra paths in this map for a package, and it will be honored. Parameters ---------- directory : str Absolute or relative path of the directory to be appended to this package's `__path__` attribute. N)r append_package_pathr )r directorys rr&z*PreSafeImportModuleAPI.append_package_paths  ..t/?/?KrN) __name__ __module__ __qualname____doc__rpropertyrrrrr$r&rrrrsM*V."" $$ B8D8M$Lrrc6eZdZdZdZedZedZy)PreFindModulePathAPIa Metadata communicating changes made by the current **pre-find module path hook** (i.e., hook run immediately _before_ a call to `ModuleGraph._find_module_path()` finding the hooked module's absolute path) back to PyInstaller. Pre-find module path hooks _must_ define a `pre_find_module_path()` function accepting an instance of this class, whose attributes describe the subsequent `ModuleGraph._find_module_path()` call to be performed. Pre-find module path hooks are typically used to change the absolute path from which a module will be subsequently imported and thus frozen into the executable. To do so, hooks may overwrite the default `search_dirs` list of the absolute paths of all directories to be searched for that module: e.g., def pre_find_module_path(api): api.search_dirs = ['/the/one/true/package/providing/this/module'] Each pre-find module path hook is run _only_ on the first call to `ModuleGraph._find_module_path()` for the corresponding module. Attributes ---------- The following attributes are **mutable** (i.e., modifiable). All changes to these attributes will be immediately respected by PyInstaller: search_dirs : list List of the absolute paths of all directories to be searched for this module (in order). Searching will halt at the first directory containing this module. Attributes (Immutable) ---------- The following attributes are **immutable** (i.e., read-only). For safety, any attempts to change these attributes _will_ result in a raised exception: module_name : str Fully-qualified name of this module. module_graph : PyiModuleGraph Current module graph. For efficiency, this attribute is technically mutable. To preserve graph integrity, this attribute should nonetheless _never_ be modified. While read-only `PyiModuleGraph` methods (e.g., `findNode()`) are safely callable from within pre-find module path hooks, methods modifying the graph are _not_. If graph modifications are required, consider an alternative type of hook (e.g., pre-import module hooks). c.||_||_||_yr ) search_dirsr _module_name)rrr r1s rrzPreFindModulePathAPI.__init__s'*'rc|jSrrrs rrz!PreFindModulePathAPI.module_graphrrc|jS)z6 Fully-qualified name of this module. )r2rs rr z PreFindModulePathAPI.module_names    rN)r(r)r*r+rr,rr r-rrr/r/s5'P ("" !!rr/ceZdZdZdZedZedZedZedZedZ edZ ed Z ed Z ed Z d Zd ZdZdZdZdZy) PostGraphAPIai Metadata communicating changes made by the current **post-graph hook** (i.e., hook run for a specific module transitively imported by the current application _after_ the module graph of all `import` statements performed by this application has been constructed) back to PyInstaller. Post-graph hooks may optionally define a `post_graph()` function accepting an instance of this class, whose attributes describe the current state of the module graph and the hooked module's graph node. Attributes (Mutable) ---------- The following attributes are **mutable** (i.e., modifiable). All changes to these attributes will be immediately respected by PyInstaller: module_graph : PyiModuleGraph Current module graph. module : Node Graph node for the currently hooked module. 'With great power comes great responsibility.' Attributes (Immutable) ---------- The following attributes are **immutable** (i.e., read-only). For safety, any attempts to change these attributes _will_ result in a raised exception: __name__ : str Fully-qualified name of this module (e.g., `six.moves.tkinter`). __file__ : str Absolute path of this module. If this module is: * A standard (rather than namespace) package, this is the absolute path of this package's directory. * A namespace (rather than standard) package, this is the abstract placeholder `-`. (Don't ask. Don't tell.) * A non-package module or C extension, this is the absolute path of the corresponding file. __path__ : list List of the absolute paths of all directories comprising this package if this module is a package _or_ `None` otherwise. If this module is a standard (rather than namespace) package, this list contains only the absolute path of this package's directory. co : code Code object compiled from the contents of `__file__` (e.g., via the `compile()` builtin). analysis: build_main.Analysis The Analysis that load the hook. Attributes (Private) ---------- The following attributes are technically mutable but private, and hence should _never_ be externally accessed or modified by hooks. Call the corresponding public methods instead: _added_datas : list List of the `(name, path)` 2-tuples or TOC objects of all external data files required by the current hook, defaulting to the empty list. This is equivalent to the global `datas` hook attribute. _added_imports : list List of the fully-qualified names of all modules imported by the current hook, defaulting to the empty list. This is equivalent to the global `hiddenimports` hook attribute. _added_binaries : list List of the `(name, path)` 2-tuples or TOC objects of all external C extensions imported by the current hook, defaulting to the empty list. This is equivalent to the global `binaries` hook attribute. _module_collection_mode : dict Dictionary of package/module names and their corresponding collection mode strings. This is equivalent to the global `module_collection_mode` hook attribute. _bindepend_symlink_suppression : set A set of paths or path patterns corresponding to shared libraries for which binary dependency analysis should not generate symbolic links into top-level application directory. c||_|j||_|jJ||_|jj|_|jj |_||_|jjt|jjnd|_ g|_ g|_ g|_g|_i|_t#|_yr )r find_nodemodule ___name__filename ___file__code_co _analysis packagepathtuple ___path___added_binaries _added_datas_added_imports_deleted_imports_module_collection_modeset_bindepend_symlink_suppression)rr ranalysiss rrzPostGraphAPI.__init__9s(",,[9 {{&&&%--;;##!{{&&2t{{6678<  "  "')$.1e+rc|jS)z6 Absolute path of this module's file. )r<rs r__file__zPostGraphAPI.__file__U ~~rc|jS)a List of the absolute paths of all directories comprising this package if this module is a package _or_ `None` otherwise. If this module is a standard (rather than namespace) package, this list contains only the absolute path of this package's directory. )rBrs r__path__zPostGraphAPI.__path__\~~rc|jS)zR Fully-qualified name of this module (e.g., `six.moves.tkinter`). r:rs rr(zPostGraphAPI.__name__erMrc|jS)zk Code object compiled from the contents of `__file__` (e.g., via the `compile()` builtin). )r>rs rcozPostGraphAPI.cols xxrc|jS)z: build_main.Analysis that calls the hook. )r?rs rrJzPostGraphAPI.analysissrMrc|jS)z Fully-qualified name of this module (e.g., `six.moves.tkinter`). **This property has been deprecated by the `__name__` property.** rRrs rnamezPostGraphAPI.name{rPrc|jS)zv Current module graph. **This property has been deprecated by the `module_graph` property.** )rrs rgraphzPostGraphAPI.graphs   rc|jS)z Graph node for the currently hooked module. **This property has been deprecated by the `module` property.** )r9rs rnodezPostGraphAPI.nodes{{rcN|jj|jS)zZ List of the graph nodes of all modules directly imported by this module. )start)r iter_graphr9rs rimportszPostGraphAPI.importss"   ++$+++>>rc:|jj|y)a Add all Python modules whose fully-qualified names are in the passed list as "hidden imports" upon which the current module depends. This is equivalent to appending such names to the hook-specific `hiddenimports` attribute. N)rEextendr module_namess r add_importszPostGraphAPI.add_importss ""<0rc:|jj|y)a Remove the named fully-qualified modules from the set of imports (either hidden or visible) upon which the current module depends. This is equivalent to appending such names to the hook-specific `excludedimports` attribute. N)rFrarbs r del_importszPostGraphAPI.del_importss $$\2rc|r4t|ddk(r#|jjd|Dy|jjt|y)aU Add all external dynamic libraries in the passed list of `(src_name, dest_name)` 2-tuples as dependencies of the current module. This is equivalent to adding to the global `binaries` hook attribute. For convenience, the `binaries` may also be a list of TOC-style 3-tuples `(dest_name, src_name, typecode)`. rc3&K|] }|dd ywNr-.0entrys r z,PostGraphAPI.add_binaries..s'Hebq 'HN)lenrCrar)rbinariess r add_binarieszPostGraphAPI.add_binariessM HQK(A-  ' ''Hx'H H  ' '(A((K Lrc|r4t|ddk(r#|jjd|Dy|jjt|y)aH Add all external data files in the passed list of `(src_name, dest_name)` 2-tuples as dependencies of the current module. This is equivalent to adding to the global `datas` hook attribute. For convenience, the `datas` may also be a list of TOC-style 3-tuples `(dest_name, src_name, typecode)`. rrhc3&K|] }|dd ywrjr-rls rroz)PostGraphAPI.add_datas..s$B5U2AY$BrpN)rqrDrar)rdatass r add_dataszPostGraphAPI.add_datassL Sq]a'    $ $$BE$B B    $ $%>u%E Frcz| |j}||jj|y||j|<y)ac" Set the package/module collection mode for the specified module name. If `name` is `None`, the hooked module/package name is used. `mode` can be one of valid mode strings (`'pyz'`, `'pyc'`, `'py'`, `'pyz+py'`, `'py+pyz'`) or `None`, which clears the setting for the module/package - but only within this hook's context! N)r(rGpop)rrWmodes rset_module_collection_modez'PostGraphAPI.set_module_collection_modes; <==D <  ( ( , ,T 215D ( ( .rc:|jj|y)z Add the given path or path pattern to the set of patterns that prevent binary dependency analysis from creating a symbolic link to the top-level application directory. N)rIadd)rpatterns r)add_bindepend_symlink_suppression_patternz6PostGraphAPI.add_bindepend_symlink_suppression_patterns ++//8rN)r(r)r*r+rr,rLrOrTrJrWrYr[r_rdrfrsrwr{rr-rrr6r6s=|48   !!?? 13M G 69rr6N) r+PyInstaller.building.utilsr'PyInstaller.lib.modulegraph.modulegraphrrrr/r6r-rrrs;ASYLYLxC!C!Ll9l9r