U
|
X ±d`' ã @ st d Z ddlZddlZddlZddlZddlZddlZddlZddlZddl Z ddl
|
m Z m Z ddl Z ddlmZ ddlmZ ddlmZ ddlmZ dd lmZmZmZmZ ej d
|
¡Z G d d d Z G d d dZ dZ dZ ej!d dkrîe ne Z"dd e #¡ D Z$e%e$dd ddZ&i Z'dZ(G dd de)Z*doddZ+e ,d ¡Z-d d Z.d d Z/d!d" Z0d#d$ Z1d%d& Z2d'd( Z3d)d* Z4i Z5d+d, Z6d-d. Z7G d/d0 d0e d0d1d2d3d4gZ8G d5d6 d6Z9G d7d8 d8e:Z;G d9d: d:e9Z<G d;d< d<e9Z=G d=d> d>e=Z>G d?d@ d@e=Z?G dAdB dBe=Z@G dCdD dDe9ZAG dEdF dFe9ZBG dGdH dHeBZCG dIdJ dJeBZDG dKdL dLeDZEG dMdN dNeBZFG dOdP dPeBZGG dQdR dReBZHG dSdT dTeBZIG dUdV dVeHeIZJG dWdX dXeIZKG dYdZ dZeBZLG d[d\ d\eIZMG d]d^ d^eBZNG d_d` d`eBZOdaaPdbaQdcaRddaSdeaTdfaUdgdh ZVdidj ZWej!d dkrJdZ"ndZ"G dkdl dlejXZYG dmdn dneZZdS )pa
|
Find modules used by a script, using bytecode analysis.
|
|
Based on the stdlib modulefinder by Thomas Heller and Just van Rossum,
|
but uses a graph data structure and 2.3 features
|
|
XXX: Verify all calls to _import_hook (and variants) to ensure that
|
imports are done in the right way.
|
é N)ÚdequeÚ
|
namedtuple)Ú ObjectGraph)Ú
|
GraphErroré )Úutil)Úzipio)ÚBytesIOÚStringIOÚ pathname2urlÚ
|
_READ_MODEzutf-8c @ s e Zd Zdd ZdS )ÚBUILTIN_MODULEc C s dS ©NF© )Úfqnamer r ú^d:\z\workplace\vscode\pyvenv\venv\Lib\site-packages\PyInstaller/lib/modulegraph/modulegraph.pyÚ
|
is_package) s zBUILTIN_MODULE.is_packageN)Ú__name__Ú
|
__module__Ú __qualname__r r r r r r ( s r c @ s e Zd Zdd Zdd ZdS )ÚNAMESPACE_PACKAGEc C s
|
|| _ d S ©N)Únamespace_dirs)Úselfr r r r Ú__init__. s zNAMESPACE_PACKAGE.__init__c C s dS ©NTr )r r r r r r 1 s z NAMESPACE_PACKAGE.is_packageN)r r r r r r r r r r - s r éÿÿÿÿé c C s i | ]\}}}||||fqS r r )Ú.0ZfiletypeZ open_modeZimp_typer r r Ú
|
<dictcomp>` s ÿ r c C s t | S r )Úlen)Úpr r r Ú<lambda>f ó r" T)ÚkeyÚreverse)ztimport sys, types, os;has_mfs = sys.version_info > (3, 5);p = os.path.join(sys._getframe(1).f_locals['sitedir'], *('zOimport sys,types,os; p = os.path.join(sys._getframe(1).f_locals['sitedir'], *('zMimport sys,new,os; p = os.path.join(sys._getframe(1).f_locals['sitedir'], *('zPimport sys, types, os;p = os.path.join(sys._getframe(1).f_locals['sitedir'], *('zsimport sys, types, os;pep420 = sys.version_info > (3, 3);p = os.path.join(sys._getframe(1).f_locals['sitedir'], *('c @ s e Zd ZdS )ÚInvalidRelativeImportErrorN©r r r r r r r r& ¦ s r& c C sl t |¡}t|}|D ]P}| d¡r| d¡ ¡ }| |krtjj|j f|
|
d¡ }||kr| |¡ q|S )z¶
|
Return the __path__ for the python package in *fqname*.
|
|
This function uses setuptools metadata to extract information
|
about namespace packages from installed eggs.
|
znamespace_packages.txtÚ.) Ú pkg_resourcesÚ
|
WorkingSetÚlistÚ has_metadataÚ get_metadataÚ
|
splitlinesÚosÚpathÚjoinÚlocationÚsplitÚappend)r Ú pathnamesr0 Ú working_setÚdistÚ
|
namespacesZnspathr r r Ú_namespace_package_pathª s
|
|
ÿ r9 z ^\s*["']([A-Za-z0-9_]+)["'],?\s*c C s~ | d¡r| d¡s t| | }| dd
} g }| rvt | ¡}|dkrNt|| | d¡¡ | t| d¡d
} q0t|S )z
|
Input is the repr of a tuple of strings, output
|
is that tuple.
|
|
This only works with a tuple where the members are
|
python identifiers.
|
ú(ú)r r Nr ) Ú
|
startswithÚendswithÚ
|
ValueErrorÚ_strsÚmatchr4 Úgroupr Útuple)ÚvalueZ
|
orig_valueÚresultÚmr r r Ú_eval_str_tupleà s
|
rF c C s& t dt| ¡}|d k r"| d¡S |S )Nz^No module named (\S+)$r )Úrer@ ÚstrrA )ÚexcÚdefaultrE r r r Ú_path_from_importerrorÝ s
|
rK c C s t dt¡ t | ¡S )z
|
Deprecated name
|
z'Use zipio.listdir instead of os_listdir)ÚwarningsÚwarnÚDeprecationWarningr Úlistdir)r0 r r r Ú
|
os_listdirç s
|
þrP c C sN t jdkrt ¡ d }n$t jdkr0t ¡ d }n t ¡ d }t|t | ¡ S )z+ Convert code object to a .pyc pseudo-file )é é s )rQ é s s )ÚsysÚ version_infoÚimpZ get_magicr ÚmarshalÚdumps)ÚcoÚheaderr r r Ú _code_to_fileñ s
|
|
r[ c C sF t ¡ D ]8\}}}| |¡rtj | ¡d t|
||f S qd S r )rV Ú get_suffixesr= r/ r0 Úbasenamer )r0 ÚextZreadmodeÚtypr r r ÚmoduleInfoForPathü s
|
&r` c C s t dt¡ t| | d S )Nz,Use addPackagePath instead of AddPackagePath)rL rM rN ÚaddPackagePath)Ú packagenamer0 r r r ÚAddPackagePath s
|
þrc c C s" t | g ¡}| |¡ |t | < d S r )Ú_packagePathMapÚgetr4 )rb r0 Úpathsr r r ra
|
s
|
ra c C s t dt¡ t| | d S )Nz,use replacePackage instead of ReplacePackage)rL rM rN ÚreplacePackage©ZoldnameÚnewnamer r r ÚReplacePackage s ÿrj c C s |t | < d S r )Ú_replacePackageMaprh r r r rg s rg c @ s e Zd ZdZdd ZdS )ÚDependencyInfor c C sp | j s| js| jr$|j s<|js<|js<tddd| jo6|jdS t| j pH|j | jpR|j| jp\|j| jof|jdS d S )NF)Ú conditionalÚfunctionÚ tryexceptÚfromlist)rm rn ro rl rp )r Úotherr r r Ú_merged) s& ÿÿÿ
|
ü
|
|
|
|
üzDependencyInfo._mergedN)r r r Ú __slots__rr r r r r rl % s rl rm rn ro rp c @ s¾ e Zd ZdZdddddddd d
|
g Zd d Zd d Zdd Zdd Zdd Z dd Z
|
dd Z dd Z dd Z d d Zd d Zd!d" Zd#d$ Zd%d& Zd'd( Zd)d* Zd+d, Zd-d. Zd/d0 Zd1S )2ÚNodea
|
Abstract base class (ABC) of all objects added to a `ModuleGraph`.
|
|
Attributes
|
----------
|
code : codeobject
|
Code object of the pure-Python module corresponding to this graph node
|
if any _or_ `None` otherwise.
|
graphident : str
|
Synonym of `identifier` required by the `ObjectGraph` superclass of the
|
`ModuleGraph` class. For readability, the `identifier` attribute should
|
typically be used instead.
|
filename : str
|
Absolute path of this graph node's corresponding module, package, or C
|
extension if any _or_ `None` otherwise.
|
identifier : str
|
Fully-qualified name of this graph node's corresponding module,
|
package, or C extension.
|
packagepath : str
|
List of the absolute paths of all directories comprising this graph
|
node's corresponding package. If this is a:
|
* Non-namespace package, this list contains exactly one path.
|
* Namespace package, this list contains one or more paths.
|
_deferred_imports : list
|
List of all target modules imported by the source module corresponding
|
to this graph node whole importations have been deferred for subsequent
|
processing in between calls to the `_ModuleGraph._scan_code()` and
|
`_ModuleGraph._process_imports()` methods for this source module _or_
|
`None` otherwise. Each element of this list is a 3-tuple
|
`(have_star, _safe_import_hook_args, _safe_import_hook_kwargs)`
|
collecting the importation of a target module from this source module
|
for subsequent processing, where:
|
* `have_star` is a boolean `True` only if this is a `from`-style star
|
import (e.g., resembling `from {target_module_name} import *`).
|
* `_safe_import_hook_args` is a (typically non-empty) sequence of all
|
positional arguments to be passed to the `_safe_import_hook()` method
|
to add this importation to the graph.
|
* `_safe_import_hook_kwargs` is a (typically empty) dictionary of all
|
keyword arguments to be passed to the `_safe_import_hook()` method
|
to add this importation to the graph.
|
Unlike functional languages, Python imposes a maximum depth on the
|
interpreter stack (and hence recursion). On breaching this depth,
|
Python raises a fatal `RuntimeError` exception. Since `ModuleGraph`
|
parses imports recursively rather than iteratively, this depth _was_
|
commonly breached before the introduction of this list. Python
|
environments installing a large number of modules (e.g., Anaconda) were
|
particularly susceptible. Why? Because `ModuleGraph` concurrently
|
descended through both the abstract syntax trees (ASTs) of all source
|
modules being parsed _and_ the graph of all target modules imported by
|
these source modules being built. The stack thus consisted of
|
alternating layers of AST and graph traversal. To unwind such
|
alternation and effectively halve the stack depth, `ModuleGraph` now
|
descends through the abstract syntax tree (AST) of each source module
|
being parsed and adds all importations originating within this module
|
to this list _before_ descending into the graph of these importations.
|
See pyinstaller/pyinstaller/#1289 for further details.
|
_global_attr_names : set
|
Set of the unqualified names of all global attributes (e.g., classes,
|
variables) defined in the pure-Python module corresponding to this
|
graph node if any _or_ the empty set otherwise. This includes the names
|
of all attributes imported via `from`-style star imports from other
|
existing modules (e.g., `from {target_module_name} import *`). This
|
set is principally used to differentiate the non-ignorable importation
|
of non-existent submodules in a package from the ignorable importation
|
of existing global attributes defined in that package's pure-Python
|
`__init__` submodule in `from`-style imports (e.g., `bar` in
|
`from foo import bar`, which may be either a submodule or attribute of
|
`foo`), as such imports ambiguously allow both. This set is _not_ used
|
to differentiate submodules from attributes in `import`-style imports
|
(e.g., `bar` in `import foo.bar`, which _must_ be a submodule of
|
`foo`), as such imports unambiguously allow only submodules.
|
_starimported_ignored_module_names : set
|
Set of the fully-qualified names of all existing unparsable modules
|
that the existing parsable module corresponding to this graph node
|
attempted to perform one or more "star imports" from. If this module
|
either does _not_ exist or does but is unparsable, this is the empty
|
set. Equivalently, this set contains each fully-qualified name
|
`{trg_module_name}` for which:
|
* This module contains an import statement of the form
|
`from {trg_module_name} import *`.
|
* The module whose name is `{trg_module_name}` exists but is _not_
|
parsable by `ModuleGraph` (e.g., due to _not_ being pure-Python).
|
**This set is currently defined but otherwise ignored.**
|
_submodule_basename_to_node : dict
|
Dictionary mapping from the unqualified name of each submodule
|
contained by the parent module corresponding to this graph node to that
|
submodule's graph node. If this dictionary is non-empty, this parent
|
module is typically but _not_ always a package (e.g., the non-package
|
`os` module containing the `os.path` submodule).
|
ÚcodeÚfilenameÚ
|
graphidentÚ
|
identifierÚ packagepathÚ_deferred_importsÚ_global_attr_namesÚ"_starimported_ignored_module_namesÚ_submodule_basename_to_nodec C s@ d| _ d| _|| _|| _d| _d| _t | _t | _t | _
|
dS )zÞ
|
Initialize this graph node.
|
|
Parameters
|
----------
|
identifier : str
|
Fully-qualified name of this graph node's corresponding module,
|
package, or C extension.
|
N) ru rv rw rx ry rz Úsetr{ r| Údictr} )r rx r r r r ¬ s z Node.__init__c C s
|
|| j kS )aÛ
|
`True` only if the pure-Python module corresponding to this graph node
|
defines a global attribute (e.g., class, variable) with the passed
|
name.
|
|
If this module is actually a package, this method instead returns
|
`True` only if this package's pure-Python `__init__` submodule defines
|
such a global attribute. In this case, note that this package may still
|
contain an importable submodule of the same name. Callers should
|
attempt to import this attribute as a submodule of this package
|
_before_ assuming this attribute to be an ignorable global. See
|
"Examples" below for further details.
|
|
Parameters
|
----------
|
attr_name : str
|
Unqualified name of the attribute to be tested.
|
|
Returns
|
----------
|
bool
|
`True` only if this module defines this global attribute.
|
|
Examples
|
----------
|
Consider a hypothetical module `foo` containing submodules `bar` and
|
`__init__` where the latter assigns `bar` to be a global variable
|
(possibly star-exported via the special `__all__` global variable):
|
|
>>> # In "foo.__init__":
|
>>> bar = 3.1415
|
|
Python 2 and 3 both permissively permit this. This method returns
|
`True` in this case (i.e., when called on the `foo` package's graph
|
node, passed the attribute name `bar`) despite the importability of the
|
`foo.bar` submodule.
|
)r{ ©r Ú attr_namer r r Úis_global_attr s 'zNode.is_global_attrc C s
|
|| j kS )a#
|
`True` only if the parent module corresponding to this graph node
|
contains the submodule with the passed name.
|
|
If `True`, this parent module is typically but _not_ always a package
|
(e.g., the non-package `os` module containing the `os.path` submodule).
|
|
Parameters
|
----------
|
submodule_basename : str
|
Unqualified name of the submodule to be tested.
|
|
Returns
|
----------
|
bool
|
`True` only if this parent module contains this submodule.
|
©r} ©r Úsubmodule_basenamer r r Ú is_submoduleì s zNode.is_submodulec C s | j |¡ dS )aÚ
|
Record the global attribute (e.g., class, variable) with the passed
|
name to be defined by the pure-Python module corresponding to this
|
graph node.
|
|
If this module is actually a package, this method instead records this
|
attribute to be defined by this package's pure-Python `__init__`
|
submodule.
|
|
Parameters
|
----------
|
attr_name : str
|
Unqualified name of the attribute to be added.
|
N)r{ Úaddr r r r Úadd_global_attr s zNode.add_global_attrc C s | j |j ¡ dS )a&
|
Record all global attributes (e.g., classes, variables) defined by the
|
target module corresponding to the passed graph node to also be defined
|
by the source module corresponding to this graph node.
|
|
If the source module is actually a package, this method instead records
|
these attributes to be defined by this package's pure-Python `__init__`
|
submodule.
|
|
Parameters
|
----------
|
target_module : Node
|
Graph node of the target module to import attributes from.
|
N)r{ Úupdate)r Ú target_moduler r r Ú add_global_attrs_from_module s z!Node.add_global_attrs_from_modulec C s || j |< dS )a
|
|
Add the submodule with the passed name and previously imported graph
|
node to the parent module corresponding to this graph node.
|
|
This parent module is typically but _not_ always a package (e.g., the
|
non-package `os` module containing the `os.path` submodule).
|
|
Parameters
|
----------
|
submodule_basename : str
|
Unqualified name of the submodule to add to this parent module.
|
submodule_node : Node
|
Graph node of this submodule.
|
Nr )r r
Zsubmodule_noder r r Ú add_submodule( s zNode.add_submodulec C s
|
| j | S )aW
|
Graph node of the submodule with the passed name in the parent module
|
corresponding to this graph node.
|
|
If this parent module does _not_ contain this submodule, an exception
|
is raised. Else, this parent module is typically but _not_ always a
|
package (e.g., the non-package `os` module containing the `os.path`
|
submodule).
|
|
Parameters
|
----------
|
module_basename : str
|
Unqualified name of the submodule to retrieve.
|
|
Returns
|
----------
|
Node
|
Graph node of this submodule.
|
r r r r r Ú get_submodule; s zNode.get_submodulec C s | j |¡S )a
|
Graph node of the submodule with the passed unqualified name in the
|
parent module corresponding to this graph node if this module contains
|
this submodule _or_ `None`.
|
|
This parent module is typically but _not_ always a package (e.g., the
|
non-package `os` module containing the `os.path` submodule).
|
|
Parameters
|
----------
|
submodule_basename : str
|
Unqualified name of the submodule to retrieve.
|
|
Returns
|
----------
|
Node
|
Graph node of this submodule if this parent module contains this
|
submodule _or_ `None`.
|
)r} re r r r r Úget_submodule_or_noneS s zNode.get_submodule_or_nonec C s | |¡r| j |¡ dS )a
|
Record the global attribute (e.g., class, variable) with the passed
|
name if previously recorded as defined by the pure-Python module
|
corresponding to this graph node to be subsequently undefined by the
|
same module.
|
|
If this module is actually a package, this method instead records this
|
attribute to be undefined by this package's pure-Python `__init__`
|
submodule.
|
|
This method is intended to be called on globals previously defined by
|
this module that are subsequently undefined via the `del` built-in by
|
this module, thus "forgetting" or "undoing" these globals.
|
|
For safety, there exists no corresponding `remove_global_attr()`
|
method. While defining this method is trivial, doing so would invite
|
`KeyError` exceptions on scanning valid Python that lexically deletes a
|
global in a scope under this module's top level (e.g., in a function)
|
_before_ defining this global at this top level. Since `ModuleGraph`
|
cannot and should not (re)implement a full-blown Python interpreter,
|
ignoring out-of-order deletions is the only sane policy.
|
|
Parameters
|
----------
|
attr_name : str
|
Unqualified name of the attribute to be removed.
|
N)r r{ Úremover r r r Úremove_global_attr_if_foundk s
|
z Node.remove_global_attr_if_foundc C s4 zt |d}W n tk
|
r& t Y S X t| j|S ©Nrw )ÚgetattrÚAttributeErrorÚNotImplementedÚcmprw ©r rq Z
|
otherIdentr r r Ú__cmp__ s
|
|
z Node.__cmp__c C s0 zt |d}W n tk
|
r$ Y dS X | j|kS )Nrw F©r r rw r r r r Ú__eq__ s
|
z Node.__eq__c C s0 zt |d}W n tk
|
r$ Y dS X | j|kS )Nrw Tr r r r r Ú__ne__ s
|
z Node.__ne__c C s2 zt |d}W n tk
|
r& t Y S X | j|k S r ©r r r rw r r r r Ú__lt__¤ s
|
|
z Node.__lt__c C s2 zt |d}W n tk
|
r& t Y S X | j|kS r r r r r r Ú__le__¬ s
|
|
z Node.__le__c C s2 zt |d}W n tk
|
r& t Y S X | j|kS r r r r r r Ú__gt__´ s
|
|
z Node.__gt__c C s2 zt |d}W n tk
|
r& t Y S X | j|kS r r r r r r Ú__ge__¼ s
|
|
z Node.__ge__c C s
|
t | jS r )Úhashrw ©r r r r Ú__hash__Ä s z Node.__hash__c C s | j fS r ©rx r¡ r r r Ú infoTupleÇ s zNode.infoTuplec C s dt | j| ¡ f S )Nz%s%r)Útyper r¤ r¡ r r r Ú__repr__Ê s z Node.__repr__N)r r r Ú__doc__rs r r r r r r r r r r r r r r r r r¢ r¤ r¦ r r r r rt D s< \÷ *!rt c @ s e Zd ZdZdS )ÚAliasa
|
Placeholder aliasing an existing source module to a non-existent target
|
module (i.e., the desired alias).
|
|
For obscure reasons, this class subclasses `str`. Each instance of this
|
class is the fully-qualified name of the existing source module being
|
aliased. Unlike the related `AliasNode` class, instances of this class are
|
_not_ actual nodes and hence _not_ added to the graph; they only facilitate
|
communication between the `ModuleGraph.alias_module()` and
|
`ModuleGraph.find_node()` methods.
|
N©r r r r§ r r r r r¨ Ò s r¨ c s( e Zd ZdZ fddZdd Z ZS )Ú AliasNodez
|
Graph node representing the aliasing of an existing source module under a
|
non-existent target module name (i.e., the desired alias).
|
c s: t t| |¡ dD ] }t||rt| |t|| qdS )aD
|
Initialize this alias.
|
|
Parameters
|
----------
|
name : str
|
Fully-qualified name of the non-existent target module to be
|
created (as an alias of the existing source module).
|
node : Node
|
Graph node of the existing source module being aliased.
|
)rx ry r{ r| r} N)Úsuperrª r ÚhasattrÚsetattrr )r ÚnameÚnoder ©Ú __class__r r r æ s
|
zAliasNode.__init__c C s | j | jfS r )rw rx r¡ r r r r¤ s zAliasNode.infoTuple)r r r r§ r r¤ Ú __classcell__r r r° r rª à s rª c @ s e Zd ZdS )Ú BadModuleNr' r r r r r³ s r³ c @ s e Zd ZdS )ÚExcludedModuleNr' r r r r r´ s r´ c @ s e Zd ZdS )Ú MissingModuleNr' r r r r rµ s rµ c s$ e Zd Z fddZdd Z ZS )ÚInvalidRelativeImportc sD |}| d¡r||7 }n |d| 7 }tt| |¡ || _|| _d S )Nr( )r= r« r¶ r Ú relative_pathÚ from_name)r r· r¸ rx r° r r r s
|
|
z InvalidRelativeImport.__init__c C s | j | jfS r )r· r¸ r¡ r r r r¤ s z InvalidRelativeImport.infoTuple©r r r r r¤ r² r r r° r r¶ s
|
r¶ c s$ e Zd Z fddZdd Z ZS )ÚScriptc s t t| |¡ || _d S r )r« rº r rv )r rv r° r r r ! s zScript.__init__c C s | j fS r )rv r¡ r r r r¤ % s zScript.infoTupler¹ r r r° r rº s rº c s& e Zd Zd fdd Zdd Z ZS )Ú
|
BaseModuleNc s t t| |¡ || _|| _d S r )r« r» r rv ry )r r® rv r0 r° r r r * s zBaseModule.__init__c C s t td | j| j| jfS r )rB Úfilterrx rv ry r¡ r r r r¤ / s zBaseModule.infoTuple)NNr¹ r r r° r r» ) s r» c @ s e Zd ZdS )Ú BuiltinModuleNr' r r r r r½ 3 s r½ c @ s e Zd ZdS )Ú SourceModuleNr' r r r r r¾ 7 s r¾ c @ s e Zd ZdS )ÚInvalidSourceModuleNr' r r r r r¿ ; s r¿ c @ s e Zd ZdS )ÚCompiledModuleNr' r r r r rÀ ? s rÀ c @ s e Zd ZdS )ÚInvalidCompiledModuleNr' r r r r rÁ C s rÁ c @ s e Zd ZdS )Ú ExtensionNr' r r r r r G s r c @ s e Zd ZdZdS )ÚPackagez:
|
Graph node representing a non-namespace package.
|
Nr© r r r r rà K s rà c @ s e Zd ZdZdS )ÚExtensionPackageza
|
Graph node representing a package where the __init__ module is an extension
|
module.
|
Nr© r r r r rÄ R s rÄ c @ s e Zd ZdZdS )ÚNamespacePackagez6
|
Graph node representing a namespace package.
|
Nr© r r r r rÅ Z s rÅ c @ s e Zd ZdZdS )Ú RuntimeModulea<
|
Graph node representing a non-package Python module 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 node represents such a runtime module. Since this 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 ensure that the parent package of this module if any is also imported
|
and added to the graph, this node is typically added to the graph by
|
calling the `ModuleGraph.add_module()` method.
|
Nr© r r r r rÆ a s rÆ c @ s e Zd ZdZdS )ÚRuntimePackageaQ
|
Graph node representing a non-namespace Python package 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 node represents 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.
|
|
To ensure that the parent package of this package if any is also imported
|
and added to the graph, this node is typically added to the graph by
|
calling the `ModuleGraph.add_module()` method.
|
Nr© r r r r rÇ w s rÇ c s e Zd Z fddZ ZS )Ú FlatPackagec s t dt¡ ttf|| d S ©Nz=This class will be removed in a future version of modulegraph©rL rM rN r« rÈ ©r ÚargsÚkwdsr° r r r s
|
þzFlatPackage.__init__©r r r r r² r r r° r rÈ s rÈ c s e Zd Z fddZ ZS )Ú ArchiveModulec s t dt¡ ttf|| d S rÉ rÊ rË r° r r r s
|
þzArchiveModule.__init__rÎ r r r° r rÏ s rÏ a
<!DOCTYPE html>
|
<html>
|
<head>
|
<meta charset="UTF-8">
|
<title>%(TITLE)s</title>
|
<style>
|
.node { padding: 0.5em 0 0.5em; border-top: thin grey dotted; }
|
.moduletype { font: smaller italic }
|
.node a { text-decoration: none; color: #006699; }
|
.node a:visited { text-decoration: none; color: #2f0099; }
|
</style>
|
</head>
|
<body>
|
<h1>%(TITLE)s</h1>zB
|
<div class="node">
|
<a name="%(NAME)s"></a>
|
%(CONTENT)s
|
</div>z:<tt>%(NAME)s</tt> <span class="moduletype">%(TYPE)s</span>zp<a target="code" href="%(URL)s" type="text/plain"><tt>%(NAME)s</tt></a>
|
<span class="moduletype">%(TYPE)s</span>z6 <div class="import">
|
%(HEAD)s:
|
%(LINKS)s
|
</div>
|
z
|
</body>
|
</html>c C sD g }| D ](}t |tjr&| |j¡ q| |¡ qdd |D }|S )Nc S s g | ]}|d kr|qS )Ú__main__r )r Úrr r r Ú
|
<listcomp>Í s z _ast_names.<locals>.<listcomp>)Ú
|
isinstanceÚastÚaliasr4 r® )ÚnamesrD Únmr r r Ú
|
_ast_namesÅ s rØ c s t j fdd| D S )z/Remove duplicates from a list, preserving orderc s g | ]}| ks|s|qS r r )r Úx©ÚseenZseen_addr r rÒ Ö s zuniq.<locals>.<listcomp>)r~ r )Úseqr rÚ r ÚuniqÑ s rÝ c @ sÀ e Zd Zdd Zedd Zedd Zedd Zd d
|
Zd d Z d d Z
|
dd Z dd Z e Z dd Zdd Zdd ZeZeZeZeZeZeZeZeZeZeZeZeZeZ eZ eZ eZ eZ dS )Ú_Visitorc C s. || _ || _t| _dg| _dg| _dg| _d S r )Z_graphÚ_moduleÚDEFAULT_IMPORT_LEVELÚ_levelÚ_in_ifÚ_in_defÚ _in_tryexcept)r ÚgraphÚmoduler r r r à s z_Visitor.__init__c C s
|
| j d S ©Nr )râ r¡ r r r Úin_ifè s z_Visitor.in_ifc C s
|
| j d S rç )rã r¡ r r r Úin_defì s z_Visitor.in_defc C s
|
| j d S rç )rä r¡ r r r Ú in_tryexceptð s z_Visitor.in_tryexceptc C s t jd dkr(|dkr(d|p dkr(d| _d}|d k rRt|}d|krR| d¡ d}| jj ||| j||fd t| j | j
|
| j dd
|
if¡ d S ) Nr r Ú
|
__future__Úabsolute_importr FÚ*TÚ edge_attr)rm ro rn rp ) rT rU rá rÝ r rß rz r4 rl rè rê ré )r r® rp ÚlevelÚ have_starr r r Ú_collect_importõ s(
|
üþÿz_Visitor._collect_importc C s$ t |jD ]}| |d | j¡ q
|
d S r )rØ rÖ rñ rá )r r¯ r× r r r Ú visit_Import s z_Visitor.visit_Importc C s4 |j dkr|j n| j}| |jp"dt|j|¡ d S )Nr Ú )rï rá rñ ræ rØ rÖ )r r¯ rï r r r Úvisit_ImportFrom s z_Visitor.visit_ImportFromc C s$ | j d¡ | |¡ | j ¡ d S r )râ r4 Ú generic_visitÚpop©r r¯ r r r Úvisit_If s
|
z_Visitor.visit_Ifc C s$ | j d¡ | |¡ | j ¡ d S r )rã r4 rõ rö r÷ r r r Úvisit_FunctionDef s
|
z_Visitor.visit_FunctionDefc C s$ | j d¡ | |¡ | j ¡ d S r ©rä r4 rõ rö r÷ r r r Ú visit_Try! s
|
z_Visitor.visit_Tryc C s$ | j d¡ | |¡ | j ¡ d S r rú r÷ r r r Úvisit_TryExcept& s
|
z_Visitor.visit_TryExceptc C s d S r r r÷ r r r Úvisit_Expression+ s z_Visitor.visit_ExpressionN) r r r r Úpropertyrè ré rê rñ rò rô rø rù Zvisit_AsyncFunctionDefrû rü rý Z visit_BoolOpZ visit_BinOpZ visit_UnaryOpZ visit_LambdaZ visit_IfExpZ
|
visit_DictZ visit_SetZvisit_ListCompZ visit_SetCompZvisit_GeneratorExpZ visit_CompareZ visit_YieldZvisit_YieldFromZ visit_AwaitZ
|
visit_Callr r r r rÞ ß sB
|
|
|
rÞ c s| e Zd ZdZ fddZdN fdd Zd d
|
Zd d ZdOd dZdd Z e Z
|
dPddZ e Z dd Z dd Zdd ZdQ fdd ZeZdR fd d ZeZejZdSd d Zddedfd!d"Zd#d$ Zefd%d&Zd'd( Z d)d* Z d+d, Z d-d. Z d/d0 Z d1d2 Z!d3d4 Z"edfd5d6Z#dTd7d8Z$d9d: Z%d;d< Z&d=d> Z'dUd?d@Z(dAdB Z)dVdCdDZ*dWdFdGZ+dXdHdIZ,dJdK Z-dLdM Z. Z/S )YÚ ModuleGraphzr
|
Directed graph whose nodes represent modules and edges represent
|
dependencies between these modules.
|
c s0 | |¡}|d kr,tt| j||f||}|S r )Ú find_noder« rÿ Ú
|
createNode)r Úclsr® rÌ ÚkwrE r° r r r L s
|
zModuleGraph.createNodeNr r c sj t t| j||d |d kr"tj}|| _i | _| j t|¡ |D ]}d | j|< qB|| _| ¡ t
|
| _ d S )N)rå Údebug) r« rÿ r rT r0 Ú lazynodesr r Ú replace_pathsÚset_setuptools_nspackagesrd Ú_package_path_map)r r0 Zexcludesr Zimpliesrå r rE r° r r r V s zModuleGraph.__init__c C s | ¡ | _d S r )Ú_calc_setuptools_nspackagesÚ
|
nspackagesr¡ r r r r g s z%ModuleGraph.set_setuptools_nspackagesc C sÄ i }zddl m} W n@ tk
|
rT zddlm} W n tk
|
rN tj}Y nX Y nX tjd d
dkrxdd l}|j j
|
}| j D ]>}t |¡}t ||r~zt |¡}W n tjk
|
rÀ Y q~Y nX |D ]ö}| d¡rÆttj ||¡tÎ}|D ]Â} tD ]¸}
|
| |
|
¡röz t|
|
d } | d| ¡d } W n tk
|
r> Y qöY nX t| | |
} d | ¡}tj j|f| }tj tj |d ¡¡rqö||kr || |¡ n
|
|g||< qîqöqîW 5 Q R X qÆq~|S )
|
Nr )Ú ImpImporterr )rQ rQ z
|
-nspkg.pthr; r r( z __init__.py) Úpkgutilr Ú ImportErrorZ_pkgutilr) Z
|
ImpWrapperrT rU Zimportlib.machineryÚ machineryÚ
|
FileFinderr0 Ú get_importerrÓ r/ rO Úerrorr= Úopenr1 r Ú _SETUPTOOLS_NAMESPACEPKG_PTHsr< r Úindexr> rF Úexistsr4 )r Zpkgmapr Ú importlibÚentryÚimporterZldirÚfnÚfpÚlnÚpfxÚstartÚstopÚpkgrx Úsubdirr r r r k sN
|
|
|
|
|
|
|
|
|
z'ModuleGraph._calc_setuptools_nspackagesc C sV t |tr| |||¡ n8t |tr,t|| ||d¡}|D ]}| |||¡ q>dS )aU
|
Create a reference from the passed source node to the passed other node,
|
implying the former to depend upon the latter.
|
|
While the source node _must_ be an existing graph node, the target node
|
may be either an existing graph node _or_ a fully-qualified module name.
|
In the latter case, the module with that name and all parent packages of
|
that module will be imported _without_ raising exceptions and for each
|
newly imported module or package:
|
|
* A new graph node will be created for that module or package.
|
* A reference from the passed source node to that module or package will
|
be created.
|
|
This method allows dependencies between Python objects _not_ importable
|
with standard techniques (e.g., module aliases, C extensions).
|
|
Parameters
|
----------
|
node : str
|
Graph node for this reference's source module or package.
|
other : {Node, str}
|
Either a graph node _or_ fully-qualified name for this reference's
|
target module or package.
|
N)rÓ rt Ú_updateReferencerB r> Ú_safe_import_hook)r r¯ rq Ú edge_dataZothersr r r ÚimplyNodeReferenceª s
|
|
z ModuleGraph.implyNodeReferencec C s | |¡}| |¡\}}|S )zt
|
Yield all nodes that `fromnode` dependes on (that is,
|
all modules that `fromnode` imports.
|
)r Ú get_edges)r Úfromnoder¯ Z out_edgesÚ_r r r ÚoutgoingÎ s
|
zModuleGraph.outgoingTc c sf | |¡}| |¡\}}|rR|D ].}t|trH| |d¡D ]
|
}|V q:q |V q n|D ]
|
}|V qVd S r )r r% rÓ rµ Úincoming)r ÚtonodeZcollapse_missing_modulesr¯ r' Zin_edgesÚnr r r r) Ú s
|
|
|
|
zModuleGraph.incomingc C s& | |¡}| |¡}| j ||¡dk S )z> Return True iff there is an edge from 'fromnode' to 'tonode' N)r rå Z edge_by_node)r r& r* r r r ÚhasEdgeí s
|
|
zModuleGraph.hasEdgec C sº | |¡}| ¡ D ]¢}|j |jd ¡s*q| |¡\}}|D ]2}|j |jd ¡rTq<| ||¡s<| ||d¡ q<|D ]2}|j |jd ¡rqt| ||¡st| ||d¡ qt| j |¡ qdS )zÁ
|
Create edges to/from `packagenode` based on the edges to/from all
|
submodules of that package _and_ then hide the graph nodes
|
corresponding to those submodules.
|
r( zpkg-internal-importz
|
pkg-importN) r Únodesrx r< r% r, r! rå Z hide_node)r Z packagenoder r+ Ziter_outZiter_incrq r r r ÚfoldReferencesô s
|
zModuleGraph.foldReferencesc C st z| ||¡}W n& ttfk
|
r6 | |||¡ Y S X t|trLt|ts\| |||¡ n| ||| |¡¡ d S r )ZedgeDataÚKeyErrorr Úadd_edgerÓ rl ZupdateEdgeDatarr )r r& r* r# Zedr r r r! s z ModuleGraph._updateReferenceÚdirectc s t t| j|||dS )z<
|
Create a reference from fromnode to tonode
|
©r# )r« rÿ ÚcreateReference)r r& r* r# r° r r r0 $ s zModuleGraph.add_edgec s
|
t t| |¡}|dk r |S || jkr¬| j |¡}|dkrH| t|¡}n`t|tr| |dd¡ ¡ }| t
|
||¡}| ||¡ n(| |dd¡ ¡ }|D ]}| ||¡ q|S || j kr|r| j |¡}| t |¡}d|_t||| j|_|j| j |g ¡ |_|S dS )aX
|
Graph node uniquely identified by the passed fully-qualified module
|
name if this module has been added to the graph _or_ `None` otherwise.
|
|
If (in order):
|
|
. A namespace package with this identifier exists _and_ the passed
|
`create_nspkg` parameter is `True`, this package will be
|
instantiated and returned.
|
. A lazy node with this identifier and:
|
* No dependencies exists, this node will be instantiated and
|
returned.
|
* Dependencies exists, this node and all transitive dependencies of
|
this node be instantiated and this node returned.
|
. A non-lazy node with this identifier exists, this node will be
|
returned as is.
|
|
Parameters
|
----------
|
name : str
|
Fully-qualified name of the module whose graph node is to be found.
|
create_nspkg : bool
|
Whether or not to implicitly instantiate namespace packages. If
|
`True` _and_ this name is that of a previously registered namespace
|
package (i.e., in `self.nspackages`) not already added to the
|
graph, this package will be added to the graph. Defaults to `True`.
|
|
Returns
|
----------
|
Node
|
Graph node of this module if added to the graph _or_ `None`
|
otherwise.
|
Nú-)r« rÿ ÚfindNoder rö r r´ rÓ r¨ r" rª r$ r
|
rÅ rv r9 r0 ry r re ) r r® Z create_nspkgÚdataÚdepsrE rq Údepr5 r° r r r , s. #
|
|
zModuleGraph.find_nodec
|
C s2 | dd|¡ tj |¡}| |¡}|dk r0|S tjd dkrt|d}t |¡}W 5 Q R X t|t
|
|d}| ¡ d }W 5 Q R X | t ¡r¾|dd
}n"t|t
|
}| ¡ d }W 5 Q R X t||d tjd
|
}t||d dd
|
}| t|¡}| ||d¡ | |||¡} | | ¡ ||_| jr.| |j¡|_|S ) z
|
Create a node by path (not module name). It is expected to be a Python
|
source file, and will be scanned for dependencies.
|
r Ú
|
run_scriptNr Úrb©ÚencodingÚ
|
r ÚexecT)Úmsgr/ r0 Úrealpathr rT rU r r Úguess_encodingr Úreadr< ÚBOMÚcompilerÔ Ú PyCF_ONLY_ASTr rº r! Ú
|
_scan_codeÚ_process_importsru r Ú_replace_paths_in_code)
|
r ÚpathnameÚcallerrE r r< ÚcontentsÚco_astrY r+ r r r Ú
|
add_scriptz s0
|
|
|
zModuleGraph.add_scriptc C s: | dd||||¡ | |¡}| |||¡\}}| dd||¡ |}|rÄ| d¡} | dk rbt|} |d|
|| d d
}
|
}d |j|
|
f } | |
|
| |¡}|dkrD| dd
|
| ¡ t d t
|
| qD| dd |¡ |} | g} |rt | t t fr| | |¡D ]}|| k rþ| |¡ qþ| D ]} | j|| |d q | S )a«
|
Import the module with the passed name, all parent packages of this
|
module, _and_ all submodules and attributes in this module with the
|
passed names from the previously imported caller module signified by
|
the passed graph node.
|
|
Unlike most import methods (e.g., `_safe_import_hook()`), this method
|
is designed to be publicly called by both external and internal
|
callers and hence is public.
|
|
Parameters
|
----------
|
target_module_partname : str
|
Partially-qualified name of the target module to be imported. See
|
`_safe_import_hook()` for further details.
|
source_module : Node
|
Graph node for the previously imported **source module** (i.e.,
|
module containing the `import` statement triggering the call to
|
this method) _or_ `None` if this module is to be imported in a
|
"disconnected" manner. **Passing `None` is _not_ recommended.**
|
Doing so produces a disconnected graph in which the graph node
|
created for the module to be imported will be disconnected and
|
hence unreachable from all other nodes -- which frequently causes
|
subtle issues in external callers (namely PyInstaller, which
|
silently ignores unreachable nodes).
|
target_attr_names : list
|
List of the unqualified names of all submodules and attributes to
|
be imported from the module to be imported if this is a "from"-
|
style import (e.g., `[encode_base64, encode_noop]` for the import
|
`from email.encoders import encode_base64, encode_noop`) _or_
|
`None` otherwise.
|
level : int
|
Whether to perform an absolute or relative import. See
|
`_safe_import_hook()` for further details.
|
|
Returns
|
----------
|
list
|
List of the graph nodes created for all modules explicitly imported
|
by this call, including the passed module and all submodules listed
|
in `target_attr_names` _but_ excluding all parent packages
|
implicitly imported by this call. If `target_attr_names` is `None`
|
or the empty list, this is guaranteed to be a list of one element:
|
the graph node created for the passed module.
|
|
Raises
|
----------
|
ImportError
|
If the target module to be imported is unimportable.
|
rQ Z _import_hookrS Z load_tailr( r Nr z%s.%sú"raise ImportError: No module namedúNo module named z load_tail ->r2 )r? Ú_determine_parentÚ_find_head_packageÚmsginÚfindr rx Ú_safe_import_moduleÚmsgoutr ÚreprrÓ rà rª Ú%_import_importable_package_submodulesr4 r! )r Útarget_module_partnameÚ source_moduleÚtarget_attr_namesrï rî Úsource_packageÚtarget_packageÚ submoduleÚiÚheadZmnamer Útarget_modulesÚtarget_submoduler r r Ú import_hook¤ sT :
|
ÿ
|
ÿÿ
|
ÿ ÿ
|
ÿ
|
zModuleGraph.import_hookc C st | dd|¡ d}|rb|j}t|tr,|}n6d|krR|d| d¡
}| |¡}n|jrb| |¡}| dd|¡ |S )z:
|
Determine the package containing a node.
|
rS Zdetermine_parentNr( zdetermine_parent ->)rR rx rÓ rà Úrfindr ry rU )r rJ ÚparentZpnamer r r rP s
|
|
z ModuleGraph._determine_parentc C s¼ | dd|||¡ d|kr,| dd¡\}}n|}d}|tkrV|rP|jd | }n|}nì|tkrh|}d}nÚ|dkr| dd¡ td |||f t|d D ]}d|jkrÆ| dd¡ td |||f |j dd¡d
|
}| |¡} | dkr
|
| dd¡ td |||f | |k s t
|
| |f| }q|r<|jd | }n|j}| |||¡}
|
|
|
dkrz|dk rz|}d}| |||¡}
|
|
|
dk r| dd |
|
|f¡ |
|
|fS | dd |¡ t d | dS )a&
|
Import the target package providing the target module with the passed
|
name to be subsequently imported from the previously imported source
|
package corresponding to the passed graph node.
|
|
Parameters
|
----------
|
source_package : Package
|
Graph node for the previously imported **source package** (i.e.,
|
package containing the module containing the `import` statement
|
triggering the call to this method) _or_ `None` if this module is
|
to be imported in a "disconnected" manner. **Passing `None` is
|
_not_ recommended.** See the `_import_hook()` method for further
|
details.
|
target_module_partname : str
|
Partially-qualified name of the target module to be imported. See
|
`_safe_import_hook()` for further details.
|
level : int
|
Whether to perform absolute or relative imports. See the
|
`_safe_import_hook()` method for further details.
|
|
Returns
|
----------
|
(target_package, target_module_tailname)
|
2-tuple describing the imported target package, where:
|
* `target_package` is the graph node created for this package.
|
* `target_module_tailname` is the unqualified name of the target
|
module to be subsequently imported (e.g., `text` when passed a
|
`target_module_partname` of `email.mime.text`).
|
|
Raises
|
----------
|
ImportError
|
If the package to be imported is unimportable.
|
rS Zfind_head_packager( r ró Nr z"Relative import outside of packagezARelative import outside of package (name=%r, parent=%r, level=%r)r zfind_head_package ->rN rO )rR r3 Ú!ABSOLUTE_OR_RELATIVE_IMPORT_LEVELrx ÚABSOLUTE_IMPORT_LEVELr? r& ÚrangeÚrsplitr ÚAssertionErrorrT rU r ) r r[ rX rï Ztarget_module_headnameZtarget_module_tailnameZtarget_package_namer^ Zp_fqdnZ
|
new_parentr\ r r r rQ / s (
|
ÿ ÿÿ
|
ÿÿ
|
|
ÿÿ ÿ ÿ ÿ ÿ
|
z ModuleGraph._find_head_packagec c s¼ t |}| dd||¡ d|kr:| | |¡¡ | d¡ |D ]l}| |¡}|dkr¤|jd | }| |||¡}|dkr¤| |¡r| dd|j|¡ q>n t
|
d| |V q>| dd¡ dS ) aÈ
|
Generator importing and yielding each importable submodule (of the
|
previously imported package corresponding to the passed graph node)
|
whose unqualified name is in the passed list.
|
|
Elements of this list that are _not_ importable submodules of this
|
package are either:
|
|
* Ignorable attributes (e.g., classes, globals) defined at the top
|
level of this package's `__init__` submodule, which will be ignored.
|
* Else, unignorable unimportable submodules, in which case an
|
exception is raised.
|
|
Parameters
|
----------
|
package : Package
|
Graph node of the previously imported package containing the
|
modules to be imported and yielded.
|
|
attr_names : list
|
List of the unqualified names of all attributes of this package to
|
attempt to import as submodules. This list will be internally
|
converted into a set, safely ignoring any duplicates in this list
|
(e.g., reducing the "from"-style import
|
`from foo import bar, car, far, bar, car, far` to merely
|
`from foo import bar, car, far`).
|
|
Yields
|
----------
|
Node
|
Graph node created for the currently imported submodule.
|
|
Raises
|
----------
|
ImportError
|
If any attribute whose name is in `attr_names` is neither:
|
* An importable submodule of this package.
|
* An ignorable global attribute (e.g., class, variable) defined at
|
the top level of this package's `__init__` submodule.
|
In this case, this attribute _must_ be an unimportable submodule of
|
this package.
|
rS rW rí Nr( zD_import_importable_package_submodules: ignoring from-imported globalrO z(_import_importable_package_submodules ->) r~ rR r Ú_find_all_submodulesr r rx rT r r? r )r ÚpackageZ
|
attr_namesr r] Zsubmodule_namer r r rW º s* -
|
|
ÿ?
|
z1ModuleGraph._import_importable_package_submodulesc
|
c s |j s
|
d S |j D ]t}zt |¡}W n, tjtfk
|
rN | dd|¡ Y qY nX dd |D D ]$}|d krlq^|d dkr^|d V q^qd S )Nr zcan't list directoryc s s | ]}t |V qd S r )r` )r r! r r r Ú <genexpr>_ s z3ModuleGraph._find_all_submodules.<locals>.<genexpr>r r )ry r rO r/ r ÚIOErrorr? )r rE r0 rÖ Úinfor r r rj S s
|
|
z ModuleGraph._find_all_submodulesc C s | dd||f ¡ t|ts.tdt| t|tsHtdt| | |¡}|dk r~t|trn|j|ks~td||f t|| j |< dS )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 source module.
|
|
Parameters
|
----------
|
src_module_name : str
|
Fully-qualified name of the existing **source module** (i.e., the
|
module being aliased).
|
trg_module_name : str
|
Fully-qualified name of the non-existent **target module** (i.e.,
|
the alias to be created).
|
rQ zalias_module "%s" -> "%s"z"%s" not a module name.Nz,Target module "%s" already imported as "%s".)
|
r? rÓ rH ri r rª rx r> r¨ r )r Zsrc_module_nameZtrg_module_nameZ
|
trg_moduler r r Ú alias_modulef s
|
ÿþ ÿÿzModuleGraph.alias_modulec C s | dd|¡ | |j¡}|dkr.| |¡ n||ksFtd||f |j d¡\}}}|r| |¡}|dkr~| dd|¡ n| ||¡ | ||¡ dS )a
|
Add the passed module node to the graph if not already added.
|
|
If that module has a parent module or package with a previously added
|
node, this method also adds a reference from this module node to its
|
parent node and adds this module node to its parent node's namespace.
|
|
This high-level method wraps the low-level `addNode()` method, but is
|
typically _only_ called by graph hooks adding runtime module nodes. For
|
all other node types, the `import_module()` method should be called.
|
|
Parameters
|
----------
|
module : BaseModule
|
Graph node of the module to be added.
|
rQ Ú
|
add_moduleNz New module %r != previous %r.r( rS z add_module parent not found:)r? r rx ZaddNoderi Ú
|
rpartitionr0 r )r ræ Z module_addedÚ parent_namer' Zmodule_basenamerd r r r rp s
|
zModuleGraph.add_modulec C s | j |g ¡}| |¡ dS )ax
|
Modulegraph does a good job at simulating Python's, but it can not
|
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.
|
|
NOTE: This method has to be called before a package is resolved by
|
modulegraph.
|
|
Parameters
|
----------
|
module : str
|
Fully-qualified module name.
|
directory : str
|
Absolute or relative path of the directory to append to the
|
'__path__' attribute.
|
N)r Ú
|
setdefaultr4 )r Ú package_nameÚ directoryrf r r r Úappend_package_path± s z ModuleGraph.append_package_pathc
|
C s¦ | dd|||¡ | |¡}|dkrPd}|dk rT|jdk rD|j}n| dd¡ dS z| |||¡\}}W n8 tk
|
r¢ } z| dd| ¡ W Y ¢dS d}~X Y nX | |||¡\}} | dk rPzZt| tj rä| }
|
t
|
|
|
|ddd} nd}
|
| || |
|
¡} | | ¡ | j r| | ¡} | |_W n4 tk
|
rN | d d
|
|¡ t} | | |¡}Y nX |dk r| d d |d |¡ | j||tdddddd | ||¡ | dd|¡ |S )a
|
Create a new graph node for the module with the passed name under the
|
parent package signified by the passed graph node _without_ raising
|
`ImportError` exceptions.
|
|
If this module has already been imported, this module's existing graph
|
node will be returned; else if this module is importable, a new graph
|
node will be added for this module and returned; else this module is
|
unimportable, in which case `None` will be returned. Like the
|
`_safe_import_hook()` method, this method does _not_ raise
|
`ImportError` exceptions when this module is unimportable.
|
|
Parameters
|
----------
|
module_partname : 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`).
|
parent_module : Package
|
Graph node of the previously imported parent module containing this
|
submodule _or_ `None` if this is a top-level module (i.e.,
|
`module_name` contains no `.` delimiters). This parent module is
|
typically but _not_ always a package (e.g., the `os.path` submodule
|
contained by the `os` module).
|
|
Returns
|
----------
|
Node
|
Graph node created for this module _or_ `None` if this module is
|
unimportable.
|
rQ Zsafe_import_moduleNz>safe_import_module -> None (parent_parent.packagepath is None)z safe_import_module -> None (%r)r> r Tr z#safe_import_module: SyntaxError in rS z#safe_import_module create referencez->F)rm rp rn ro r2 zsafe_import_module ->)rR r ry rU Ú _find_moduler Ú _load_modulerÓ rÔ ÚASTrD rF rG r rH ru Ú SyntaxErrorr? r¿ r r! rl r ) r Zmodule_partnameÚ module_nameÚ parent_moduleræ Ú search_dirsrI ÚloaderrI rY rL r+ r r r r rT É sj !
|
|
|
ÿ
|
|
|
|
ÿ
|
üÿ z ModuleGraph._safe_import_modulec C sô ddl m} | dd|||jj¡ | d¡d }| |¡r&t|t}|rZ|j d d
}ng }t
|
|¡}|rp|}t ||pzg | j } | s|r¨|r¨| t|¡}
|
d|
|
_| |
|
_nTt||rÀ| t|¡}
|
n | t|¡}
|
||
|
_tj |¡ d¡sèttj |¡g| |
|
_|
|
j| j |g ¡ |
|
_t|
|
tr&|
|
d fS d } |tkr<t} nt||rPt } n|z| |¡} W nr t t fk
|
rÐ } zNt|t rt|j t s | !dd | d
|
| d ¡ | "|¡}| #|¡} W 5 d }~X Y nX | d k rrz>t$| |d t%j&d } t'} t(j)d d
dkrt$| dd dd W nT t k
|
r8 d } t*} Y n8 t+k
|
rn } zt*} | !dd||¡ W 5 d }~X Y nX nZz | ,|¡} | d k rt-nt.} W n8 t+k
|
rÊ } z| !dd||¡ t.} W 5 d }~X Y nX | | |¡}
|
||
|
_| /dd|
|
¡ |
|
| fS )Nr )ÚExtensionFileLoaderr Ú load_moduler( r r4 z __init__.z)load_module: failed to obtain source for z: z&! Falling back to reading as raw data!r> T)rQ é z load_module: InvalidSourceModulez4load_module: InvalidCompiledModule, Cannot load codezload_module ->)0Z importlib._bootstrap_externalr rR r± r rq r rÓ r r rk re r9 r0 r rÅ rv ry rÄ rà r/ r] r< ri Údirnamer r r½ r Ú
|
get_sourceÚUnicodeDecodeErrorrz Ú __context__r? Ú get_filenameÚget_datarD rÔ rE r¾ rT rU r¿ Ú ExceptionÚget_coderÀ rÁ rU )r r rI r~ r ZpartnameZis_nspkgÚpkgpathri Z
|
ns_pkgpathrE rY r ÚsrcÚer0 rI r r r rx . s ÿ
|
|
ÿ
|
|
ÿ
|
|
|
ÿ
|
ÿ
|
ÿ ÿ zModuleGraph._load_modulec s dd ¡ fdd}fdd}d}d} zjd |d}W nr tk
|
rÀ d d
|
¡ g }
|
pd D ]4} td | ¡} j| |d |
|
| ¡ q|
|
Y S tk
|
rÆ } zè| rr dd f ¡ |} | rrgdd d d f ¡ zjd |d}W n6 tk
|
rp } z d dt | ¡ W 5 d} ~ X Y nX |dkr¶ d dt | ¡ t
|
t | ¡}j||d |g}W 5 d} ~ X Y nX t |dksät d |¡|d }t|t
|
r6| dkr6| r6|r6 |¡ jdd|d}|S t|trN|jdd}rt|ttfrD ]¦}| |¡r¶| |¡}|dk r¶||krhj||d | |¡ qh|jd | } |¡}|dkrÄz¨j|g |d |¡}|dkr<| |¡s"t d ||j¡ ddd|j|¡ W qh| r~ |¡rd d d||f ¡ n dd ||f ¡ ||_W nB tk
|
r } z" d dt | ¡ t
|
|¡}W 5 d} ~ X Y nX | ||¡ |dk rhj|||d j||d ||krh| |¡ qh|S ) a
|
Import the module with the passed name and all parent packages of this
|
module from the previously imported caller module signified by the
|
passed graph node _without_ raising `ImportError` exceptions.
|
|
This method wraps the lowel-level `_import_hook()` method. On catching
|
an `ImportError` exception raised by that method, this method creates
|
and adds a `MissingNode` instance describing the unimportable module to
|
the graph instead.
|
|
Parameters
|
----------
|
target_module_partname : str
|
Partially-qualified name of the module to be imported. If `level`
|
is:
|
* `ABSOLUTE_OR_RELATIVE_IMPORT_LEVEL` (e.g., the Python 2 default)
|
or a positive integer (e.g., an explicit relative import), the
|
fully-qualified name of this module is the concatenation of the
|
fully-qualified name of the caller module's package and this
|
parameter.
|
* `ABSOLUTE_IMPORT_LEVEL` (e.g., the Python 3 default), this name
|
is already fully-qualified.
|
* A non-negative integer (e.g., `1`), this name is typically the
|
empty string. In this case, this is a "from"-style relative
|
import (e.g., "from . import bar") and the fully-qualified name
|
of this module is dynamically resolved by import machinery.
|
source_module : Node
|
Graph node for the previously imported **caller module** (i.e.,
|
module containing the `import` statement triggering the call to
|
this method) _or_ `None` if this module is to be imported in a
|
"disconnected" manner. **Passing `None` is _not_ recommended.**
|
Doing so produces a disconnected graph in which the graph node
|
created for the module to be imported will be disconnected and
|
hence unreachable from all other nodes -- which frequently causes
|
subtle issues in external callers (e.g., PyInstaller, which
|
silently ignores unreachable nodes).
|
target_attr_names : list
|
List of the unqualified names of all submodules and attributes to
|
be imported via a `from`-style import statement from this target
|
module if any (e.g., the list `[encode_base64, encode_noop]` for
|
the import `from email.encoders import encode_base64, encode_noop`)
|
_or_ `None` otherwise. Ignored unless `source_module` is the graph
|
node of a package (i.e., is an instance of the `Package` class).
|
Why? Because:
|
* Consistency. The `_import_importable_package_submodules()`
|
method accepts a similar list applicable only to packages.
|
* Efficiency. Unlike packages, modules cannot physically contain
|
submodules. Hence, any target module imported via a `from`-style
|
import statement as an attribute from another target parent
|
module must itself have been imported in that target parent
|
module. The import statement responsible for that import must
|
already have been previously parsed by `ModuleGraph`, in which
|
case that target module will already be frozen by PyInstaller.
|
These imports are safely ignorable here.
|
level : int
|
Whether to perform an absolute or relative import. This parameter
|
corresponds exactly to the parameter of the same name accepted by
|
the `__import__()` built-in: "The default is -1 which indicates
|
both absolute and relative imports will be attempted. 0 means only
|
perform absolute imports. Positive values for level indicate the
|
number of parent directories to search relative to the directory of
|
the module calling `__import__()`." Defaults to -1 under Python 2
|
and 0 under Python 3. Since this default depends on the major
|
version of the current Python interpreter, depending on this
|
default can result in unpredictable and non-portable behaviour.
|
Callers are strongly recommended to explicitly pass this parameter
|
rather than implicitly accept this default.
|
|
Returns
|
----------
|
list
|
List of the graph nodes created for all modules explicitly imported
|
by this call, including the passed module and all submodules listed
|
in `target_attr_names` _but_ excluding all parent packages
|
implicitly imported by this call. If `target_attr_names` is either
|
`None` or the empty list, this is guaranteed to be a list of one
|
element: the graph node created for the passed module. As above,
|
`MissingNode` instances are created for all unimportable modules.
|
rQ r" c sJ d k oHd koH t koHttkoHdj d¡d koHtjd dkS )Nr' r( r r rQ )rf r¥ r¾ rx rq rT rU r )rï rY rZ rX r r Úis_swig_candidateõ s ÿþ
|
ýÿü úz8ModuleGraph._safe_import_hook.<locals>.is_swig_candidatec s^ t | jd}t |¡}W 5 Q R X t | jt|d}| ¡ }W 5 Q R X dd| ¡ d|kS )Nr: r; r z%SWIG wrapper candidate first line: %rz automatically generated by SWIG)r rv r rA r Úreadliner? )rY Zsource_module_filer< Ú
|
first_liner¡ r r Úis_swig_wrapperþ s z6ModuleGraph._safe_import_hook.<locals>.is_swig_wrapperN)rZ rï rî r zInvalid relative importrí r( r2 rS z4SWIG import candidate (name=%r, caller=%r, level=%r)ró r z.SWIG import (caller=%r, fromlist=%r, level=%r)zSWIG ImportError:z ImportError:z@Expected import_hook() toreturn only one module but received: {}r T)rp z!No global named {} in {}.__init__z#ignoring imported non-module globalz0SWIG import error: %r basename %r already existsz!SWIG import renamed from %r to %r) r? rb r& rU r r¶ r! r4 r rH rµ rK r ri ÚformatrÓ Z
|
removeNoder" rl Ú_replacerà rª r r rx r r r )r rX rY rZ rï rî r r r` Zis_swig_importrD ÚsubrE r? r Ztarget_submodule_partnamera Ztarget_submodule_namer )rï r rY rZ rX r r" ¡ sb R þ
|
ÿ
|
ÿ " ÿþÿÿ ü
|
$
|
þ ÿÿÿ ÿÿþ
|
þ
|
ÿ
|
ÿ
|
|
ý
|
ÿ
|
|
ü
|
|
ÿþþ þÿþþþÿ ÿ ÿ
|
ÿ ÿ
|
z ModuleGraph._safe_import_hookc C s@ g |_ |dk r,| ||¡ | j||dd n| j||dd |S )a¦
|
Parse and add all import statements from the passed code object of the
|
passed source module to this graph, recursively.
|
|
**This method is at the root of all `ModuleGraph` recursion.**
|
Recursion begins here and ends when all import statements in all code
|
objects of all modules transitively imported by the source module
|
passed to the first call to this method have been added to the graph.
|
Specifically, this method:
|
|
1. If the passed `module_code_object_ast` parameter is non-`None`,
|
parses all import statements from this object.
|
2. Else, parses all import statements from the passed
|
`module_code_object` parameter.
|
1. For each such import statement:
|
1. Adds to this `ModuleGraph` instance:
|
1. Nodes for all target modules of these imports.
|
1. Directed edges from this source module to these target
|
modules.
|
2. Recursively calls this method with these target modules.
|
|
Parameters
|
----------
|
module : Node
|
Graph node of the module to be parsed.
|
module_code_object : PyCodeObject
|
Code object providing this module's disassembled Python bytecode.
|
Ignored unless `module_code_object_ast` is `None`.
|
module_code_object_ast : optional[ast.AST]
|
Optional abstract syntax tree (AST) of this module if any or `None`
|
otherwise. Defaults to `None`, in which case the passed
|
`module_code_object` is parsed instead.
|
Returns
|
----------
|
module : Node
|
Graph node of the module to be parsed.
|
NF)Úis_scanning_importsT)rz Ú _scan_astÚ_scan_bytecode)r ræ Úmodule_code_objectÚmodule_code_object_astr r r rF 6
|
s 3 ÿ ÿzModuleGraph._scan_codec C s t | |}| |¡ dS )a
|
Parse and add all import statements from the passed abstract syntax
|
tree (AST) of the passed source module to this graph, non-recursively.
|
|
Parameters
|
----------
|
module : Node
|
Graph node of the module to be parsed.
|
module_code_object_ast : ast.AST
|
Abstract syntax tree (AST) of this module to be parsed.
|
N)rÞ Úvisit)r ræ r Zvisitorr r r r }
|
s
|
zModuleGraph._scan_astc C s d}d}t dd}t |¡D ]ø}|s&q |jdkrÒ|s6q |d jdksHt|d jdksZt|d j}|d j}|dkst|tkst|j}d} |dk r¶t|}d |kr¶| d ¡ d
|
} |j
|
| ||||fi f¡ n8|jd krî|j}
|
| |
|
¡ n |jd kr
|
|j}
|
| |
|
¡ | |¡ q dS ) aì
|
Parse and add all import statements from the passed code object of the
|
passed source module to this graph, non-recursively.
|
|
This method parses all reasonably parsable operations (i.e., operations
|
that are both syntactically and semantically parsable _without_
|
requiring Turing-complete interpretation) directly or indirectly
|
involving module importation from this code object. This includes:
|
|
* `IMPORT_NAME`, denoting an import statement. Ignored unless
|
the passed `is_scanning_imports` parameter is `True`.
|
* `STORE_NAME` and `STORE_GLOBAL`, denoting the
|
declaration of a global attribute (e.g., class, variable) in this
|
module. This method stores each such declaration for subsequent
|
lookup. While global attributes are usually irrelevant to import
|
parsing, they remain the only means of distinguishing erroneous
|
non-ignorable attempts to import non-existent submodules of a package
|
from successful ignorable attempts to import existing global
|
attributes of a package's `__init__` submodule (e.g., the `bar` in
|
`from foo import bar`, which is either a non-ignorable submodule of
|
`foo` or an ignorable global attribute of `foo.__init__`).
|
* `DELETE_NAME` and `DELETE_GLOBAL`, denoting the
|
undeclaration of a previously declared global attribute in this
|
module.
|
|
Since `ModuleGraph` is _not_ intended to replicate the behaviour of a
|
full-featured Turing-complete Python interpreter, this method ignores
|
operations that are _not_ reasonably parsable from this code object --
|
even those directly or indirectly involving module importation. This
|
includes:
|
|
* `STORE_ATTR(namei)`, implementing `TOS.name = TOS1`. If `TOS` is the
|
name of a target module currently imported into the namespace of the
|
passed source module, this opcode would ideally be parsed to add that
|
global attribute to that target module. Since this addition only
|
conditionally occurs on the importation of this source module and
|
execution of the code branch in this module performing this addition,
|
however, that global _cannot_ be unconditionally added to that target
|
module. In short, only Turing-complete behaviour suffices.
|
* `DELETE_ATTR(namei)`, implementing `del TOS.name`. If `TOS` is the
|
name of a target module currently imported into the namespace of the
|
passed source module, this opcode would ideally be parsed to remove
|
that global attribute from that target module. Again, however, only
|
Turing-complete behaviour suffices.
|
|
Parameters
|
----------
|
module : Node
|
Graph node of the module to be parsed.
|
module_code_object : PyCodeObject
|
Code object of the module to be parsed.
|
is_scanning_imports : bool
|
`True` only if this method is parsing import statements from
|
`IMPORT_NAME` opcodes. If `False`, no import statements will be
|
parsed. This parameter is typically:
|
* `True` when parsing this module's code object for such imports.
|
* `False` when parsing this module's abstract syntax tree (AST)
|
(rather than code object) for such imports. In this case, that
|
parsing will have already parsed import statements, which this
|
parsing must avoid repeating.
|
Nr )ÚmaxlenÚ IMPORT_NAMEéþÿÿÿÚ
|
LOAD_CONSTr Frí T)Ú
|
STORE_NAMEÚ STORE_GLOBAL)Ú DELETE_NAMEÚ DELETE_GLOBAL)r r Ziterate_instructionsÚopnameri Úargvalr¥ rB rÝ r rz r4 r r ) r ræ r r rï rp Z
|
prev_instsÚinstrX rð r® r r r r
|
sB ?
|
|
|
|
|
|
ý
|
|
zModuleGraph._scan_bytecodec C sz |j s
|
dS |j D ]^\}}}| j||}|s,q|d }|r| |¡ |j |j¡ |jdkr|d }|j |¡ qd|_ dS )aª
|
Graph all target modules whose importations were previously parsed from
|
the passed source module by a prior call to the `_scan_code()` method
|
and methods call by that method (e.g., `_scan_ast()`,
|
`_scan_bytecode()`, `_scan_bytecode_stores()`).
|
|
Parameters
|
----------
|
source_module : Node
|
Graph node of the source module to graph target imports for.
|
Nr )rz r" r r| r ru r )r rY rð Z import_infoÚkwargsr` r Ztarget_module_namer r r rG + s$
|
ÿ
|
ÿz ModuleGraph._process_importsc C sr |dk r|j d | }n|}| |¡}|dk rD| dd|¡ t||dkrd|tjkr^dtfS | j}| |||¡S )aý
|
3-tuple describing the physical location of the module with the passed
|
name if this module is physically findable _or_ raise `ImportError`.
|
|
This high-level method wraps the low-level `modulegraph.find_module()`
|
function with additional support for graph-based module caching.
|
|
Parameters
|
----------
|
name : str
|
Fully-qualified name of the Python module to be found.
|
path : list
|
List of the absolute paths of all directories to search for this
|
module _or_ `None` if the default path list `self.path` is to be
|
searched.
|
parent : Node
|
Package containing this module if this module is a submodule of a
|
package _or_ `None` if this is a top-level module.
|
|
Returns
|
----------
|
(filename, loader)
|
See `modulegraph._find_module()` for details.
|
|
Raises
|
----------
|
ImportError
|
If this module is _not_ found.
|
Nr( rQ z find_module: already included?) rx r r? r rT Úbuiltin_module_namesr r0 Ú_find_module_path)r r® r0 rd Úfullnamer¯ r r r rw k s
|
|
zModuleGraph._find_modulec
|
C s | dd||¡ d}g }zî|D ]Î}t |¡}|dkr6q t|drZ| |¡\}} | | ¡ n&t|drp| |¡}ntd||f |dkrq d}
|
t|dr¤| |¡}
|
n"t|dr¶|j }
|
ntd ||f |
|
dkrÞ|
|
dd
|
|
|
¡ q |
|
|f} qq |r|d t |f}W nd t k
|
r8 } z| d d | ¡ W 5 d} ~ X Y n4 tk
|
rj } z| dd| ¡ W 5 d} ~ X Y nX | dd|¡ |dkrtdt| |S )a¥
|
3-tuple describing the physical location of the module with the passed
|
name if this module is physically findable _or_ raise `ImportError`.
|
|
This low-level function is a variant on the standard `imp.find_module()`
|
function with additional support for:
|
|
* Multiple search paths. The passed list of absolute paths will be
|
iteratively searched for the first directory containing a file
|
corresponding to this module.
|
* Compressed (e.g., zipped) packages.
|
|
For efficiency, the higher level `ModuleGraph._find_module()` method
|
wraps this function with support for module caching.
|
|
Parameters
|
----------
|
module_name : str
|
Fully-qualified name of the module to be found.
|
search_dirs : list
|
List of the absolute paths of all directories to search for this
|
module (in order). Searching will halt at the first directory
|
containing this module.
|
|
Returns
|
----------
|
(filename, loader)
|
2-tuple describing the physical location of this module, where:
|
* `filename` is the absolute path of this file.
|
* `loader` is the import loader.
|
In case of a namespace package, this is a NAMESPACE_PACKAGE
|
instance
|
|
Raises
|
----------
|
ImportError
|
If this module is _not_ found.
|
rS z_find_module_path <-NÚ find_loaderÚ find_modulez)Module %r importer %r loader unobtainabler r0 z%Module %r loader %r path unobtainablez _find_module_path path not foundr r z"_find_module_path -> unicode errorz _find_module_path -> exceptionz_find_module_path ->rO )rR r r r¬ r© Úextendrª r r r0 r? r r rU r rV ) r r¨ r{ r} Z path_datar Z
|
search_dirr r~ Zloader_namespace_dirsrI rI r r r r§ s\ '
|
|
ÿ
|
|
ÿ
|
|
|
ÿÿ
|
z ModuleGraph._find_module_pathc C sä |d krt j}g }g }| ¡ D ]:}tj |j¡}t|trJ| ||f¡ q | ||f¡ q |
|
¡ |
|
¡ dd |D }| |¡ |}dd |¡ }t td|i |d dd }|D ] \}} d }
|
t| trÜt|d
|
d }
|
nDt| trüt|d | j d }
|
n$t| jpd } t|| | jjd }
|
t|| | ¡\} } | rxg }| D ]}| d||f ¡ qBd |¡}|
|
td|d 7 }
|
| r¼g }| D ]}| d||f ¡ qd |¡}|
|
td|d 7 }
|
t t||
|
d |d q´t t|d d S )Nc S s g | ] \}}|qS r r )r ZsnrE r r r rÒ . s z+ModuleGraph.create_xref.<locals>.<listcomp>z modulegraph cross reference for z, ZTITLE)Úfilec S s dd | D }| ¡ |S )Nc S s g | ]}|rt j |j¡qS r )r/ r0 r] rx )r Úmodr r r rÒ 6 s zDModuleGraph.create_xref.<locals>.sorted_namelist.<locals>.<listcomp>)Úsort)ÚmodsÚlstr r r Úsorted_namelist5 s z0ModuleGraph.create_xref.<locals>.sorted_namelistró z<i>(builtin module)</i>)ÚNAMEÚTYPEz <tt>%s</tt>)r² ÚURLr³ z <a href="#%s">%s</a>
|
z • Úimports)ÚHEADZLINKSz imported by)r² ZCONTENT) rT ÚstdoutÚ
|
iter_graphr/ r0 r] rx rÓ rº r4 r® r« r1 ÚprintrZ r½ Úcontplr rv r Ú contpl_linkedr± r Úmapr% rµ r Úfooter)r ÚoutÚscriptsr¯ r r® Ú scriptnamesÚtitler± rE ÚcontentÚurlZouteZinceÚlinksr+ r r r Ú create_xref s\
|
|
|
ÿ
|
|
ÿ
|
ÿ
|
|
zModuleGraph.create_xrefÚGc # st t t| jj| j | ¡}| jjt }t }i }i }i }t } t|}dd }
|
dd d|f V tddd} d | ¡ D ]} d
|
| f V q||D ]H\} }}}t
|
|d d || < t |t r| ||j < t| g|| < | | ¡ q|D ]À\} }}}fd d |D D ]}| |¡ qd| d fdd|
|
| ||| ¡ D ¡f V | | ¡}|d krft }|| < || }|d krzqä| |d | d¡
¡}|d k rä| |¡ qäg }i }|D ]}g ||< q²|rö| ¡ \}}}}||f| krêqÂ| ||f¡ || }|| |@ }|sl|rlt|} t| dks<| d |krl| |||| d f¡ | |d| d |f¡ qÂ|rà| ¡ }||kr| ||||f¡ nF||krº|| |d||f¡ n$| ||||f¡ | ||||f¡ n| ||||f¡ q fdd} | ¡ D ]D\} }d| f V d|| f V | |dD ] } | V q:d V q | |d D ] } | V q\d V d S ) Nc S s^ t |tsdt| iS dt|j }t| ¡ d d
dD ]\}}|d||f 7 }q:|ddS )NÚlabelz<f0> r z
|
| <f%d> %sÚrecord)rÇ Úshape)rÓ rt rH r¥ r Ú enumerater¤ )r¯ r6 r( r) Úsr^ Úvr r r Ú nodevisitori s
|
z0ModuleGraph.itergraphreport.<locals>.nodevisitorc S s$ |dkrddiS |dkr ddiS i S )NZorphanÚstyleZdashedÚpkgrefZdottedr )Úedger6 r_ Útailr r r Ú edgevisitort s
|
z0ModuleGraph.itergraphreport.<locals>.edgevisitorz digraph %s {
|
charset="UTF-8";
|
ZLRÚtrue)ZrankdirZ concentratez%s="%s"z %s;
|
rx c 3 s | ]} |V qd S r r )r r )Ú describe_edger r rl s z.ModuleGraph.itergraphreport.<locals>.<genexpr>z "%s" [%s];
|
ú,c s g | ] } | qS r r ©r Úitem©Úcpattr r rÒ s z/ModuleGraph.itergraphreport.<locals>.<listcomp>r( r r rÏ r c 3 sT |d }| D ]B\}}}}||||}|||d fdd| ¡ D ¡f V q d S )Nz"%s" -> "%s" [%s];
|
rÕ c s g | ] } | qS r r rÖ rØ r r rÒ Ë s zAModuleGraph.itergraphreport.<locals>.do_graph.<locals>.<listcomp>)r1 Úitems)ÚedgesÚtabsZedgestrrÐ r6 r_ rÑ Zattribs)rÙ rÒ r r Údo_graphà s ýz-ModuleGraph.itergraphreport.<locals>.do_graphz subgraph "cluster_%s" {
|
z label="%s";
|
z z }
|
ú z}
|
)r+ r¼ rå Z describe_nodeZiterdfsrÔ r r~ r rÚ r rÓ rà rx r r4 r1 re rc ÚpopleftÚsortedr rö ) r r® Ú flatpackagesr- rÛ Z packagenodesZ packageidentsZ nodetoidentZ
|
inpackagesZ mainedgesrÍ Úattrr× r¯ r6 r( r) rÐ ZinsideÚidentZpkgnoderå Z subgraphsr$ r_ rÑ ZtailpkgsÚcommonZusepkgsrÝ ÚgrË r )rÙ rÔ rÒ r Úitergraphreport[ s
|
|
þþ
|
|
|
|
|
|
|
|
zModuleGraph.itergraphreportc C s$ |d krt j}| | j|d¡ d S )N)rá )rT r· Ú
|
writelinesræ )r Úfileobjrá r r r Ú graphreportÚ s zModuleGraph.graphreportc C s\ t t dd t dd t| ¡ dd dD ]$}t dt|j|j|jpNdf q2dS ) zPrint a report to stdout, listing the found modules with their
|
paths, as well as modules that are missing, or seem to be missing.
|
z%-15s %-25s %s)ZClassÚNameÚFile)z-----ú----rì c S s | j S r r£ )r+ r r r r" æ r# z$ModuleGraph.report.<locals>.<lambda>)r$ ró N)r¹ rà r¸ r¥ r rx rv )r rE r r r Úreportß s
|
zModuleGraph.reportc C sX t j |j¡ }}| jD ]F\}}t j |d¡}t j |d¡}| |¡r||t|d
} qdq|S t|j }t
|
t|D ](}t || t |rz| || ¡||< qzt |}t|drÈ|jt||dS t|dr||j|j|j|j|j|jt||j|j||j|j|j|j |j S ||j|j|j|j|jt||j|j||j|j|j|j |j S d S )Nró Úreplace)Ú co_constsÚ co_filenameÚco_kwonlyargcount) r/ r0 Únormpathrð r r1 r< r r+ rï rg rÓ r¥ rH r¬ rî rB Ú co_argcountrñ Ú
|
co_nlocalsÚ co_stacksizeÚco_flagsÚco_codeÚco_namesÚ co_varnamesÚco_nameÚco_firstlinenoÚ co_lnotabÚ co_freevarsÚ co_cellvars) r rY Z new_filenameZoriginal_filenameÚfrÑ Zconstsr^ Z code_funcr r r rH é sf
|
|
|
|
ÿ û ûz"ModuleGraph._replace_paths_in_code)Nr r r Nr )N)T)r1 )T)N)N)N)N)rÆ r )Nr )0r r r r§ r r r r r$ r( Z getReferencesr) Z getReferersr, r. r! r0 r3 r r5 r Úflattenr¸ rM rà rb rP rQ rW rj ro rp rv rT rx r" rF r r rG rw r§ rÅ ræ ré rí rH r² r r r° r rÿ E sp
|
?
|
$
|
|
% K
|
-ú
|
q ü
|
%&eu þ
|
ü
|
G @
|
3
|
;
|
|
|
rÿ )N)[r§ r) rÔ ÚcodecsrV rW r/ r rT rG Ú collectionsr r rL Zaltgraph.ObjectGraphr Zaltgraphr ró r r Ú_compatr r
|
r r ÚBOM_UTF8ÚdecoderC r r re rf rU rà r\ Z _IMPORTABLE_FILETYPE_TO_METADATArà Z_IMPORTABLE_FILETYPE_EXTSrd r r r& r9 rD r? rF rK rP r[ r` rc ra rk rj rg rl rt rH r¨ rª r³ r´ rµ r¶ rº r» r½ r¾ r¿ rÀ rÁ r rà rÄ rÅ rÆ rÇ rÈ rÏ rZ r rº r» rµ r½ rØ rÝ Z NodeVisitorrÞ rÿ r r r r Ú<module> s® þþ ÿ'
|
|
|
|
|
ÿ %
|
|
f
|
