!hi dZddlZddlZddlZddlZddlZddlZddlmZm Z m Z ddl Z ddl Z ddlZddlZej"dk\rddlmZnddlZ eZej.j1deZej4xej.d<Zde_ddlmZddlm Z eeureej.d<nej.d= d d l!m"Z"Gd d Z#Gd dZ$dZ% dZ& e&Z' Gdde(Z)dZ*Gdde dgdZ+GddZ,Gdde-Z.Gdde,Z/Gdde,Z0Gdde0Z1Gd d!e0Z2Gd"d#e0Z3Gd$d%e,Z4Gd&d'e,Z5Gd(d)e5Z6Gd*d+e5Z7Gd,d-e7Z8Gd.d/e5Z9Gd0d1e5Z:Gd2d3e5Z;Gd4d5e5Z<Gd6d7e;e<Z=Gd8d9e<Z>Gd:d;e5Z?Gd<d=e<Z@Gd>d?e5ZAGd@dAe5ZBdBaCdCaDdDaEdEaFdFaGdGaHdHZIdIZJdZ'GdJdKejZLGdLdMeZMy#eeureej.d<wej.d=wxYw)Na 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 defaultdict) pkg_resourcesc.tj|gSN)importlib_metadata distribution)names SC:\des-py\Monitor\venv\Lib\site-packages\PyInstaller/lib/modulegraph/modulegraph.pyr,s/A/N/Nt/T.U) ObjectGraph) GraphError)utilceZdZdZy)BUILTIN_MODULEcyNF)fqnames r is_packagezBUILTIN_MODULE.is_package:srN)__name__ __module__ __qualname__rrrrrr9srrceZdZdZdZy)NAMESPACE_PACKAGEc||_yr )namespace_dirs)selfr"s r__init__zNAMESPACE_PACKAGE.__init__?s ,rcyNTr)r#rs rrzNAMESPACE_PACKAGE.is_packageBsrN)rrrr$rrrrr r >s -rr c eZdZy)InvalidRelativeImportErrorNrrrrrrr)r)crr)cjtjdt|}||jdS|S)Nz^No module named (\S+)$r)rematchstrgroup)excdefaultms r_path_from_importerrorr4gs1 +SX6A}wwqz NrceZdZdZdZy)DependencyInforc|js|js |jr$|js?|js3|js'tddd|jxr |jSt|jxs |j|jxs |j|jxs |j|jxr |jS)NF conditionalfunction tryexceptfromlist)r9r:r;r6r<)r#others r_mergedzDependencyInfo._mergedys  t~~$$U^^EOO!!95>> ; ;" $ 0 0 EE4E4E!]]rrrr6r6us I?rr6r8ceZdZdZgdZdZdZdZdZdZ dZ d Z d Z d Z d Zd ZdZdZdZdZdZdZdZy)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). ) codefilename graphident identifier packagepath_deferred_imports_global_attr_names"_starimported_ignored_module_names_submodule_basename_to_nodecd|_d|_||_||_d|_d|_t |_t |_t|_ y)z Initialize this graph node. Parameters ---------- identifier : str Fully-qualified name of this graph node's corresponding module, package, or C extension. N) rBrCrDrErFrGsetrHrIdictrJ)r#rEs rr$z Node.__init__sN  $$!%"%%25%/+/6(rc||jvS)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. )rHr# attr_names ris_global_attrzNode.is_global_attrsND3333rc||jvS)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. rJr#submodule_basenames r is_submodulezNode.is_submodule<s&"T%E%EEErc:|jj|y)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)rHaddrOs radd_global_attrzNode.add_global_attrRs ##I.rcN|jj|jy)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)rHupdate)r# target_modules radd_global_attrs_from_modulez!Node.add_global_attrs_from_modulees &&}'G'GHrc"||j|<y)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. NrS)r#rUsubmodule_nodes r add_submodulezNode.add_submodulexs @N(();??rN)rrr__doc__r?r$rQrVrYr]r`rbrerhrorrrwr{r~rrrrrrrrArAsrYv I2,'4TF,/&I&N&D0H06@--,-,-%"@rrAceZdZdZy)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. Nrrrrrrrrrs rrc0eZdZdZdfd ZdZdZxZS) AliasNodez Graph node representing the aliasing of an existing source module under a non-existent target module name (i.e., the desired alias). cNtt| ||j|y)a 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. Optional; if not provided here, the attributes from referred node should be copied later using `copyAttributesFromReferredNode` method. N)superrr$copyAttributesFromReferredNode)r#r node __class__s rr$zAliasNode.__init__)s$ i'- ++D1rc ZdD]&}t||st||t||(y)zh Copy a subset of attributes from referred node (source module) into this target alias. )rErFrHrIrJN)hasattrsetattrrk)r#rrPs rrz(AliasNode.copyAttributesFromReferredNode<s4+ CItY'iy)AB  Crc2|j|jfSr )rDrErs rrzAliasNode.infoTupleJs11rr )rrrrr$rr __classcell__rs@rrr#s 2& C2rrc eZdZy) BadModuleNr*rrrrrNr+rrc eZdZy)ExcludedModuleNr*rrrrrRr+rrc eZdZy) MissingModuleNr*rrrrrVr+rrc$eZdZfdZdZxZS)InvalidRelativeImportc|}|jdr||z }n|d|zz }tt||||_||_y)N.)endswithrrr$ relative_path from_name)r#rrrErs rr$zInvalidRelativeImport.__init__[sM"  ! !# & ) #J # / )J #T3J?*"rc2|j|jfSr )rrrs rrzInvalidRelativeImport.infoTuplees""DNN33rrrrr$rrrs@rrrZs #4rrc$eZdZfdZdZxZS)Scriptc:tt| |||_yr )rrr$rC)r#rCrs rr$zScript.__init__js fd$X.  rc|jfSr )rCrs rrzScript.infoTuplens rrrs@rrris ! rrc&eZdZdfd ZdZxZS) BaseModulecHtt| |||_||_yr )rrr$rCrF)r#r rCpathrs rr$zBaseModule.__init__ss! j$(.  rcnttd|j|j|jfSr )tuplefilterrErCrFrs rrzBaseModule.infoTuplexs)VD4??DMM4CSCS"TUVVr)NNrrs@rrrrs Wrrc eZdZy) BuiltinModuleNr*rrrrr|r+rrc eZdZy) SourceModuleNr*rrrrrr+rrc eZdZy)InvalidSourceModuleNr*rrrrrr+rrc eZdZy)CompiledModuleNr*rrrrrr+rrc eZdZy)InvalidCompiledModuleNr*rrrrrr+rrc eZdZy) ExtensionNr*rrrrrr+rrceZdZdZy)Packagez: Graph node representing a non-namespace package. Nrrrrrr  rrceZdZdZy)ExtensionPackageza Graph node representing a package where the __init__ module is an extension module. Nrrrrrrs  rrceZdZdZy)NamespacePackagez6 Graph node representing a namespace package. NrrrrrrrrrceZdZdZy) 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. Nrrrrrr $ rrceZdZdZy)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. NrrrrrrrrrceZdZfdZxZS) FlatPackagec`tjdtttg|i|yNz=This class will be removed in a future version of modulegraphwarningswarnDeprecationWarningrrr#argskwdsrs rr$zFlatPackage.__init__) K   k)D)D)rrrrr$rrs@rrr **rrceZdZfdZxZS) ArchiveModulec`tjdtttg|i|yrrrs rr$zArchiveModule.__init__rrrrs@rrrrrra %(TITLE)s

%(TITLE)s

zB
%(CONTENT)s
z:%(NAME)s %(TYPE)szp%(NAME)s %(TYPE)sz6
%(HEAD)s: %(LINKS)s
z cg}|D]I}t|tjr|j|j9|j|K|Dcgc] }|dk7s | }}|Scc}w)N__main__) isinstanceastaliasappendr )namesresultnmrs r _ast_namesrse F b#)) $ MM"'' " MM"    3A1 ?a 3F 3 M4s  A( A(ctt}|j}|Dcgc]}||vr||r|c}Scc}w)z/Remove duplicates from a list, preserving order)rLrX)seqseenseen_addxs runiqrs4 5DxxH =!19 A == =s 555ceZdZdZedZedZedZdZdZ dZ dZ d Z e Z d Zd Zd ZeZeZeZeZeZeZeZeZeZeZeZeZeZeZeZeZeZy )_Visitorcf||_||_t|_dg|_dg|_dg|_yr)_graph_moduleDEFAULT_IMPORT_LEVEL_level_in_if_in_def _in_tryexcept)r#graphmodules rr$z_Visitor.__init__&s3  * g w #Wrc |jdSNr')rrs rin_ifz_Visitor.in_if.s{{2rc |jdSr)rrs rin_defz_Visitor.in_def2s||Brc |jdSr)rrs r in_tryexceptz_Visitor.in_tryexcept6s!!"%%rc d}|"t|}d|vr|jdd}|jjj |||j||fdt |j |j|jdify)NF*T edge_attr)r9r;r:r<) rrgrrGrr6rrr)r#r r<level have_stars r_collect_importz_Visitor._collect_import;s  H~Hh$  &&-- DLL(E 2>!ZZ,,++ !" # $rcrt|jD]}|j|d|j!yr )rrrr)r#rrs r visit_Importz_Visitor.visit_ImportOs0TZZ( 8B  T4;; 7 8rc|jdk7r |jn |j}|j|jxsdt |j |y)Nr)rrrrrr)r#rrs rvisit_ImportFromz_Visitor.visit_ImportFromSs?"jjAo 4;; T[[.B 4::0FNrc|jjd|j||jjyr&)rr generic_visitpopr#rs rvisit_Ifz_Visitor.visit_IfWs0 4  4  rc|jjd|j||jjyr&)rrrrrs rvisit_FunctionDefz_Visitor.visit_FunctionDef\s2 D! 4  rc|jjd|j||jjyr&rrrrrs r visit_Tryz_Visitor.visit_Tryc6 !!$' 4   rc|jjd|j||jjyr&rrs rvisit_TryExceptz_Visitor.visit_TryExcepthrrcyr rrs rvisit_Expressionz_Visitor.visit_Expressionms rN) rrrr$propertyrrrrr r rrvisit_AsyncFunctionDefrrr visit_BoolOp visit_BinOp visit_UnaryOp visit_Lambda visit_IfExp visit_Dict visit_Setvisit_ListComp visit_SetCompvisit_GeneratorExp visit_Compare visit_Yieldvisit_YieldFrom visit_Await visit_Callrrrrr%s%  &&$(8O  /! !  $L"K$M#L"K!J I%N$M%N)$M"K&O"K!J"KrrcHeZdZdZfdZd%fd ZdZd&dZdZeZ d'dZ e Z d Z d Z d Zd(fd ZeZd'fd ZeZej(Zd&dZddedfdZdZefdZdZdZdZdZdZdZ dZ!edfdZ" d&dZ#dZ$dZ%dZ&d&dZ'dZ(d&d Z)d)d!Z*d*d"Z+d#Z,d$Z-xZ.S)+ ModuleGraphzr Directed graph whose nodes represent modules and edges represent dependencies between these modules. c^|j|}|tt|||g|i|}|Sr ) find_noderr. createNode)r#clsr rkwr3rs rr1zModuleGraph.createNodes8 NN4  9k43CKKKArNctt| |||tj}||_i|_|j j t||D]}d|j |<||_i|_ i|_ y)N)rdebug) rr.r$sysr lazynodesr[rM replace_paths_package_path_map_legacy_ns_packages) r#rexcludesr8impliesrr5r3rs rr$zModuleGraph.__init__s k4)U)C <88D  d7m, %A $DNN1  %*"$$& rctd}tjD]}|jd}||j }t |d}|6|D]X}t jjt|jg|jd}||j|Z|jDcic]\}}|t|c}}|_ycc}}w)z Resolve extra package `__path__` entries for legacy setuptools-based namespace packages, by reading `namespace_packages.txt` from dist metadata. ctSr )rLrrrrz.srznamespace_packages.txtN_pathr)rr distributions read_text splitlinesrkosrjoinr/parentsplitrXitemslistr:)r#legacy_ns_packagesdist ns_packages dist_path package_namerpathss rscan_legacy_namespace_packagesz*ModuleGraph.scan_legacy_namespace_packagess )7&446 ;D..)ABK"%002Kg.I  + ; ww|| (()!'',#<044T:  ; ;&(:'?'?'A$ # e $u+ %$  $ s C)ct|tr|j|||yt|tr t ||j ||d}|D]}|j|||y)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)rrA_updateReferencer ValueError_safe_import_hook)r#rr= edge_dataotherss rimplyNodeReferencezModuleGraph.implyNodeReferencesj6 eT "  ! !$y 9%' ''++E4>F >%%dE9= >rcP|j|}|j|\}}|S)zt Yield all nodes that `fromnode` dependes on (that is, all modules that `fromnode` imports. )r0 get_edges)r#fromnoder out_edges_s routgoingzModuleGraph.outgoings* ~~h'~~d+ 1rc#K|j|}|j|\}}|r8|D]2}t|tr|j |dD]}|/|4y|D]}|ywr)r0rXrrincoming)r#tonodecollapse_missing_modulesrr[in_edgesns rr^zModuleGraph.incomings~~~f%nnT* 8 # a/!]]1e4  G    sA,A.c|j|}|j|}|jj||duS)z> Return True iff there is an edge from 'fromnode' to 'tonode' N)r0r edge_by_node)r#rYr_s rhasEdgezModuleGraph.hasEdge s:>>(+'zz&&x8DDrc\|j|}|jD]}|jj|jdzs-|j |\}}|D]Q}|jj|jdzr,|j ||r?|j ||dS|D]Q}|jj|jdzr,|j ||r?|j ||dS|jj| y)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. rzpkg-internal-importz pkg-importN) r0nodesrE startswithrXrerQr hide_node)r# packagenodepkgrbiter_outiter_incr=s rfoldReferenceszModuleGraph.foldReferencessnn[) $A<<**3>>C+?@!%!2 Hh! M##..s~~/CD||C/))#u6KL  M" D##..s~~/CD||E3/))%lC  D JJ  #+ $rc& |j||}t |t rt |t s|j |||y|j |||j|y#ttf$r|j|||cYSwxYwr )edgeDataKeyErrorradd_edgerr6updateEdgeDatar>)r#rYr_rTeds rrQzModuleGraph._updateReference8s >x0B2~.:i3X   &) <   &"**Y2G H *% >==69= = >sA++"BBc0tt| |||S)z< Create a reference from fromnode to tonode rT)rr.createReference)r#rYr_rTrs rrrzModuleGraph.add_edgeCs[$7&T]7^^rc tt| |}||S||jvr|jj |}||j t |}|St|tr\|j t|}|j|ddj }|j||j|||S|j|ddj }|D]}|j|||Sy)a7 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 Ignored. Returns ---------- Node Graph node of this module if added to the graph _or_ `None` otherwise. N) rr.findNoder7rr1rrrrrSrrV) r#r create_nspkgdatadepsr3r=deprs rr0zModuleGraph.find_nodeKs @[$06  K 4>> !>>%%d+D|OOND92H1D%(OOIt4..tT4@DDF 007''51 H **4t<@@B4C++As34Hrc|jdd|tjj|}|j |}||St |d5}|j }dddtjj}t||dtjd}t||ddd}|jt|}|j||d|j!|||}|j#|||_|j&r |j)|j$|_|S#1swYxYw)z Create a node by path (not module name). It is expected to be a Python source file, and will be scanned for dependencies.  run_scriptNrbexecTr)msgrCrrealpathr0openread importlibr decode_sourcecompiler PyCF_ONLY_ASTr1rrQ _scan_code_process_importsrBr8_replace_paths_in_code) r#pathnamecallerr3fpcontentsco_astcorbs r add_scriptzModuleGraph.add_scripts L(+77##H- NN8 $ =H (D ! !RwwyH !>>//98VS5F5FM VXvq$ 7 OOFH - fa. OOAr6 * a    008AF ! !s D::Ec|jdd|||||j|}|j|||\}}|jdd|||}|r|j d} | dkr t |} |d| || dzd}} |j d| } |j| | |}|*|jdd | td t| z|r|jdd ||} | g} |rCt| ttfr-|j| |D]}|| vs| j|| D]} |j!|| | | 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. r _import_hook load_tailrrNr"raise ImportError: No module namedNo module named z load_tail ->rv)r_determine_parent_find_head_packagemsginfindlenrE_safe_import_modulemsgout ImportErrorreprrrr%_import_importable_package_submodulesrrQ)r#target_module_partname source_moduletarget_attr_namesrrsource_packagetarget_package submoduleiheadmnamer\target_modulestarget_submodules r import_hookzModuleGraph.import_hookst N$:M=Z_`// >151H1H 2E2;.. 1k>3IJ" $&++C0A1u./+A,+AaCD1)D(33T:E00uiHI  ACUK!"4tE{"BCC% A~y1! ' M-4i,@"B$($N$N0%2 < #>9"))*:; < , CM  ! !}  " C Crc&|jdd|d}|rf|j}t|tr|}nGd|vr&|d|j d}|j |}n|j r|j |}|jdd||S)z: Determine the package containing a node. rdetermine_parentNrzdetermine_parent ->)rrErrrfindr0rFr)r#rrEpnames rrzModuleGraph._determine_parent&s 1(&1 %%E&'*/u{{3/0.##. A,f5 rc |jdd|||d|vr|jdd\}}n|}d}|tk(r|r|jdz|z}n |}n|tk(r|}d}n|'|j ddt d |d |d |d t|dz D]}d|jvr'|j ddt d |d |d |d |jjddd }|j|} | '|j ddt d |d |d |d | |us J| |f| }|r|jdz|z}n |j}|j|||} | "| |tkr|}d}|j|||} | |jdd| |f| |fS|jdd|td|z)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. rfind_head_packagerrr Nrz"Relative import outside of packagez)Relative import outside of package (name=z , parent=, level=)rzfind_head_package ->rr) rrF!ABSOLUTE_OR_RELATIVE_IMPORT_LEVELrEABSOLUTE_IMPORT_LEVELrr)rangersplitr0rrr) r#rrrtarget_module_headnametarget_module_tailnametarget_package_namerp_fqdn new_parentrs rrzModuleGraph._find_head_package@snP 1)>;QSXY ( (&,,S!4 ; "$:&< "%' " 5 5&4&?&?#&EH^&^#&<# + +"8 "N%@A0.GHH519% ,n777HHQ DE42NEKLL(2299#qA!D!^^F3 %HHQ DE42NEKLL"70:007!+% ,(&"--36LL$'5&?&?#11 "$7I  !n&@UNcEc"8 !N"55&(;^MN  % KK1NDZ3[ \!#99 9 A;=PQ,/BBCCrc#Kt|}|jdd||d|vr1|j|j||j d|D]~}|j |}|e|j dz|z}|j|||}|>|j|r|jdd|j |mtd|z||jddyw) 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. rrrNrzD_import_importable_package_submodules: ignoring from-imported globalrz(_import_importable_package_submodules ->) rLrr[_find_all_submodulesrgrerErrQrr)r#package attr_namesrPrsubmodule_names rrz1ModuleGraph._import_importable_package_submodulessZ_  1=w S *    d77@ A   c " $Z I  55i@I !(!3!3c!9I!E!44~w8 $~--i8$jlsl~l~AJK **<~*MNNOuZ x 1@AsC+C-c#K|jsy|jD]} tj|}|D]o}t jjD]A}|j|stjj|dt| }nf|dk7sl|qy#tjtf$r|j dd|YwxYww)Nrzcan't list directoryr$) rFrClistdirerrorIOErrorrr machinery all_suffixesrrbasenamer)r#r3rrr suffixs rrz ModuleGraph._find_all_submodulescs}} MM D  4( '11>>@F}}V,!ww//5mF |D :%J   HHg& 2D9 s3CB,7C-5C# C,,CCCCcz|jdd|d|dt|tsJdt|zt|tsJdt|z|j|}|1t|tr|j |k(st d|d|d t||j|<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 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). rzalias_module "z" -> ""z"%s" not a module name.NzTarget module "z" already imported as "z".) rrr/r0rrErRrr7)r#src_module_nametrg_module_name trg_modules r alias_modulezModuleGraph.alias_modulezs$ ?OTU/3/a1JSQ`Ma1aa//3/a1JSQ`Ma1aa/^^O4  ! j) ,  O 3#Z12 2 +0*@'rc|jdd||j|j}||j|n||k(sJd|d|d|jj d\}}}|rL|j|}||jdd|y|j |||j ||yy) 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. r add_moduleNz New module z != previous rrzadd_module parent not found:)rr0rEaddNode rpartitionrrr`)r#r module_added parent_namer[module_basenamerEs rrzModuleGraph.add_modules" L&)~~f&7&78   LL \) cfVb+c c)+1*;*;*F*Fs*K' Q ^^K0F~:KH ff-$$_f= rc^|jj|g}|j|y)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)r9 setdefaultr)r#rM directoryrNs rappend_package_pathzModuleGraph.append_package_paths((&&11,C Yrc |jdd||||j|}|d}|,|j |j}n|jddy |j |||\}}|j |||\}} | w t| tjr| } t| |ddd} nd} |j|| | } |j| |jr|j| } | |_|H|j#d d |d ||j)||t+dddd|j-|||jdd||S#t $r}|jdd|zYd}~yd}~wwxYw#t $r.|j#d d |t$} |j'| |}YwxYw)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. rsafe_import_moduleNz>safe_import_module -> None (parent_parent.packagepath is None)zsafe_import_module -> None (%r)rrTrz#safe_import_module: SyntaxError in rz#safe_import_module create referencez->F)r9r<r:r;rvzsafe_import_module ->)rr0rFr _find_moduler _load_modulerrASTrrrr8rrB SyntaxErrorrrr1rQr6r`) r#module_partname module_name parent_moduler search_dirsrloaderr1rrrbr2s rrzModuleGraph._safe_import_modulesB 1*O[-X , >K(!,,8"/";";KKK#cd #'#4#4#[-$A &  ,,[(FKLVR~?!"cgg.!#$VXvq$G!%F;A))!,))!88<"$FK  $ HHQ=vt] [  ! !  %""# 2 "   ' ' @ A.7 W  A@3FG $#?HH@(.C!__S+>F ?s+E A6F  F'FF 4G?Gc vddlm}|jdd|||jj|j dd}|j |r8t|tr2|jt|}d|_ |jdd|_ n|jj|g}t||r|jt |}n|jt"|}||_ t$j&j)|j+dsJt$j&j-|g|z|_ |j|j.j|gz|_ t|tr|dfSd}|t0urt2} nwt||rt4} d } | |}nY |j7|} | % tE| |d tFjHd}tJ} n |jQ|}|tRntT} |j| |}||_ |jWdd|||fS#t8t:f$rp} t| t:rt| j<t8s|j?dd |d | d |jA|} |jC| } Yd} ~ d} ~ wwxYw#t:$r d}tL} YtN$r$}tL} |j?dd||Yd}~d}~wwxYw#tN$r%}|j?dd||tT} Yd}~d}~wwxYw)Nr)ExtensionFileLoaderr load_modulerr'-z __init__.ctjj|}tjj|j dd}dD]}tjj |||z}tjj |sF t|d5}|j}dddt|dtjd}|cSy#1swY,xYw#t$r }Yd}~d}~wwxYw)Nrr>.py.pyirrT) rCrdirnamerrFrDisfilerrrrr Exception) extension_filenamerrext src_filenamersrcres r_co_from_accompanying_sourcez>ModuleGraph._load_module.._co_from_accompanying_sourcessww'9:77++,>?EEcJ1M* C#%77<<hn#EL77>>,7 !,5,"$'')C,$S,@Q@QSWX!   ,,%s* C.&C"7&C."C+ 'C.. D<Dz)load_module: failed to obtain source for z: z&! Falling back to reading as raw data!rTz load_module: InvalidSourceModulez4load_module: InvalidCompiledModule, Cannot load codezload_module ->),importlib._bootstrap_externalrrrrrrrr r1rrCr"rFr:rdrrrCrrrhrr9rrr get_sourceUnicodeDecodeErrorr __context__r get_filenameget_datarrrrrrget_coderrr)r#rrrrpartnamer3 ns_pkgpathsrr2rrrrr1s rrzModuleGraph._load_moduleBsE 1mVX##,, .$$S)"-   X &&"34OO$4f=  & 5 5a 8 #66::62F f&9:(8&AA8A% ww''1<<[III!#!: ;k I MMD,B,B,F,F-AM!-.4y  ^ #C  3 4C ".h7B ,''1> " h8I8I4PB&C02B-/^> 5 OOC (  A'+2wq' 4 ,&a-%amm5GHG$:Rs+%%&**84ood+9 ,D#.B-C "-CHHQ BH """!0HHQ!0193@/C0sO>I#K7L KA&KKLL#LL L8L33L8c jddfd}fd}d}d} jd|}t|dk(sJdj||d}t|tr:| 8|r1|r)j|j!dd|}|St|t"r|j%d}rt|t&t(frD]}|j+|r=|j-|}|*||vr%j || |j|R|j.d z|z}j1|}| j|g|j1|}|R|j3|s!Jdj||j.jd dd|j.|| rJj1|rjdd|d|dnjd d |d!|||_|j5|||Vj ||| j || ||vs|j||S#t$rijddg} xsd D]D} j t d zz| } j | | | j| F| cYSt$r} |rjd d ddd|} | rmgddjddddd jd|}n2#t$r&} jddt| Yd} ~ nd} ~ wwxYw|Sjddt j tt| }j || |g}Yd} ~ d} ~ wwxYw#t$r=} jddt| j t|}Yd} ~ d} ~ wwxYw)"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. rrScduxrHduxrBtk(xr7ttuxr$djj ddzk(S)Nr[rr)rrrrEr)rrrrsris_swig_candidatez8ModuleGraph._safe_import_hook..is_swig_candidatesr!-H%-H22H'<7H+M44??DQGGH  Irct|jd5}|j}dddtjj }|r|j dnd}jdd|zd|vS#1swYXxYw)Nrrr z%SWIG wrapper candidate first line: %rzautomatically generated by SWIG)rrCrrrrrBr)rrr first_liner#s ris_swig_wrapperz6ModuleGraph._safe_import_hook..is_swig_wrappersm,,d3 %r779 % ~~33H=H5=,,.q12J HHQ?:N O4 B B  % %s BB N)rrrrzInvalid relative importrrrvrzSWIG import candidate (name=z , caller=rrr rzSWIG import (caller=z , fromlist=zSWIG ImportError:z ImportError:z@Expected import_hook() toreturn only one module but received: {}rT)r<z!No global named {} in {}.__init__z#ignoring imported non-module globalzSWIG import error: z basename z already existszSWIG import renamed from z to )rrr)rr1rrQrrr/rr4rformatr removeNoderSr6_replacerrrVrbrEr0rQr`)r#rrrrrrr ris_swig_importrsubr3rr\target_submodule_partnamertarget_submodule_names````` rrSzModuleGraph._safe_import_hooksPd ')?Pachi I C  Z 1!--& "&ey.JNx>"a' N 66A 11 - 0*325+112BC ",,s25NN&$(>>2G#H $+KB(((2M/H.I"'&/ )1,0>>:O+P( ,3#0#?#? 9$;? C J J$=$1$<$<!>?$;!HHQ(;=bdqd|d|XY$* $~~.GH $$%)>(A%C!D!%$%(=(A%C!D %>!1 ;++-/?A#/))%'79*N))%'79*N(~=&--.>?CA @He*  KK4e.0A CF(/C !OO$9$'%K2H$H#O%%mQ)%L a  ! MJ 1D!". uFG"1!?! *@(@%-/*EHHQ -/@%IJC)-)9)92M.2"'&/ *:*1 'C$7SBBC%NCH5!%!*30FG!I %%!=I&G#0UJ 1l'BNCH=+/??)+@,B(BsjJ-A;P)A PA/PPAO=M0/O=0 N9NO=NAO==P Q 2QQ cg|_|(|j|||j||d|S|j||d|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. F)is_scanning_importsT)rG _scan_ast_scan_bytecode)r#rmodule_code_objectmodule_code_object_asts rrzModuleGraph._scan_codeQ snZ$& " - NN6#9 :   *  G    *  F rc>t||}|j|y)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)rvisit)r#rrvisitors rrzModuleGraph._scan_ast s4( ,-rc(d}d}td}tj|D]i}|s|jdk(r|stj dk\r&|djdvsJ|djd vs*J|djd k(sJ|djd k(sJ|dj }|dj }|t|tusJ|j }d } |"t|}d |vr|jd d } |jj| ||||fifnW|jdvr|j } |j| n+|jdvr|j } |j| |j|ly)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)r> LOAD_CONSTLOAD_SMALL_INTLOAD_CONST_IMMORTALr'>r r"r FrT) STORE_NAME STORE_GLOBAL) DELETE_NAME DELETE_GLOBAL)rriterate_instructionsopnamer6 version_infoargvalrrrrgrGrrYrh) r#rrrrr< prev_instsinstrrr s rrzModuleGraph._scan_bytecode s~!_ --.@AT $D{{m++##w.%b>004kkkk%b>004YYYY%b>00L@@@%b>00L@@@"2--%b>00'4>U+BBB)-&" '#H~Hh ,$( ((//+VXuE1  >>{{&&t, @@ {{2248   d #iT $rcV|jsy|jD]\}}}|j|i|}|s|d}|s$|j||jj |j|j g|d}|jj |d|_y)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)rGrSr]rIr[rBrX)r#rr import_infokwargsrr\target_module_names rrzModuleGraph._process_importsH s.. /<.M.M( , *I{F4T33[KFKN! *1-M::=I@@GG!DDF !%%-)4Q&!DDHH*,O( ,V+/ 'rc||jdz|z}n|}|j|}||jdd|t||&|tj vrdt fS|j}|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. Nrrzfind_module: already included?) rEr0rrr6builtin_module_namesrr_find_module_path)r#r rrEfullnamers rrzModuleGraph._find_module s>  ((3.5HH~~h'   HHQ8$ ?d# # <s///n--99D%%hd;;rc|jdd||d}g} |D]3}tj|}|t|drAd}|j |} | | j }|j | jxsgnbt|dr&|j|\}} |j | n0t|dr|j|}ntd|d|d |d} t|d r|j|} n+t|d r |j} ntd|d |d | |jdd| 0| |f}n|r|dt|f}|j!dd||tdt%|z|S#t$r} |j!dd| Yd} ~ Od} ~ wt"$r} |j!dd| d} ~ wwxYw)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. rz_find_module_path <-N find_spec find_loader find_modulezModule z importer z loader unobtainablerrz loader z path unobtainablez _find_module_path path not foundrrz"_find_module_path -> unicode errorz_find_module_path -> exceptionz_find_module_path ->r)rpkgutil get_importerrr6rextendsubmodule_search_locationsr7r8rrrrr rrrr) r#r4rr path_datar" search_dirimporterrspecloader_namespace_dirsrr1s rr3zModuleGraph._find_module_path s-N 1,h D Q )I D "// ;#8[1!F#--k:D'!%&--d.M.M.SQSTX}54<4H4H#5%1F1"))*?@X}5%11+>F&GRT\]__>   6>2%22;?HVV,%{{H&CNPVWYY #HHQ BHM&v. II DN"!/!2!2>!B!DI A-y9  04 3DDE E" F KK? E E  KK;S A  s$E F GF44 GGGc |tj}g}g}|jD]b}tjj |j }t|tr|j||fP|j||fd|j|j|Dcgc]\}}| }}}|j||}ddj|z} ttd| iz|d} |D]X\}}d} t|tr t |ddz} nxt|t"rt |d |j$zdz} nNt&j(j+|j$xsd} t,|| |j.j0d z} t3| |j5|\} }| rAg}| D]}|jd |d |d dj|}| t6d|dzz } |rAg}|D]}|jd |d |d dj|}| t6d|dzz } tt8|| dz|[tt:|ycc}}w)Nz modulegraph cross reference for z, TITLE)filec|Dcgc].}|stjj|j0}}|j |Scc}wr )rCrrrDsort)modsmodlsts rsorted_namelistz0ModuleGraph.create_xref..sorted_namelist[ s>?CKs277##CNN3KCK HHJJLs A +A r z(builtin module))NAMETYPEz %s)rKURLrLz z z • imports)HEADLINKSz imported by)rKCONTENT)r6stdout iter_graphrCrrrDrrrrFr;rDprintheaderrcontplrrCurllibrequest pathname2url contpl_linkedrrmaprXrNentryfooter)r#outscriptsrGrHr snr3 scriptnamestitlerJcontenturlouteincelinksrbs r create_xrefzModuleGraph.create_xrefF s` ;**C??$ )C77##CNN3D#v&c{+ T3K(  )   './eb!r/ /t2TYY{5KK f''c2  HGD!G!]+ D,E$GGAy) D,9AJJ,F$HHnn11!**2BC'434;;3G3G+II_dnnQ.?@JD$JALL1a!HIJ $((/7i%%HHHJALL1a!HIJ $((/7me%LLL %4G<<3 G? H@ f3W0s1 I0c # !"Ktt|jj|jj |}|jj !t }t}i}i}i}t} t|}d} d"d|dtdd} d | jD] } d | zd |D]W\} }}}t|d d|| <t|ts)| ||j<t| g|| <|j| Y|D]\} }}}!fd |DD]}|j|d | ddj!| | |||jD cgc]} | z c} d|j#| }|tx}|| <|| }||j#|d|j%d}||j|g}i}|D]}g||< |r!|j'\}}}}||f| vr| j||f||}|||z}|sT|rRt)|}t+|dk7s|d|k7r1|j||||df|j|d|d|f|rt|j-}||k(r|j||||fn^||k(r||j|d||fn@|j||||f|j||||fn|j||||f|r! "fd}|jD].\}}d|dd||d||dD]}|d0||d D]}|dycc} ww)Nct|ts dt|iSdt|jz}t |j dddD]\}}|d||fzz }|ddS)Nlabelz rz | %srecord)rkshape)rrAr/rr enumerater)rr{r\r^srvs r nodevisitorz0ModuleGraph.itergraphreport..nodevisitor swdD)T++$t*---A!$.."22A"6: +1\QF** +2 2rc*|dk(rddiS|dk(rddiSiS)Norphanstyledashedpkgrefdottedr)edger{rtails r edgevisitorz0ModuleGraph.itergraphreport..edgevisitor s/x**!**Irzdigraph z { charset="UTF-8"; LRtrue)rankdir concentratez%s="%s" z; rDc3.K|] }|ywr r).0r describe_edges r z.ModuleGraph.itergraphreport.. s "%s" [%s]; r)rDrG) edgestabsedgestrrxr{rryattribsitemcpattrzs rdo_graphz-ModuleGraph.itergraphreport..do_graph sy33G,1 (tT4%dD$=HHIut|IJ!  Js;A A Az subgraph "cluster_z" { z label="z"; z z } z} )rHr[r describe_nodeiterdfsrrrLrMrGrkrrrDrXrrDrdrpopleftsortedrr)#r#r flatpackagesrgr packagenodes packageidents nodetoident inpackages mainedgesrqattrrrr{r\r^rxinsideidentpkgnoder subgraphskeyrrytailpkgscommonusepkgsrgrorrrzs# @@@ritergraphreportzModuleGraph.itergraphreport sS114::3E3Ed3KLM 00 u    E L)  3 59::Df5JJL .D$t|- - .16 ' ,T48 'lD AK $(15 doo.#&v; 4   &  '16 $ ,T48<8< # T" # dHh?EEG'+UT\  ^^D)F~,/E1D)%E}#''.?u{{3/?(@AG" 7#- $0  CIcN %*]]_ "D$dt * MM4, '!$'H%0Fh *w<1$ d(:LL$dGAJ!?@LL$'"+t!DE6>LL$dD!9:V^f%,,dHdD-IJLL$fd!;<LL$fd!;< dD$5614 ") HAu346 6)4Q9 9eV,  M  %& AG  Is(C/N 5BN ; NAN #EN *A#N cj|tj}|j|j|y)N)r)r6rR writelinesr)r#fileobjrs r graphreportzModuleGraph.graphreport s, ?jjG4//\/JKrc ttddztddzt|jdD]}t|tr=tt |j dd|jdd|jPtt |j dd|jdd|jxsd y ) 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)ClassNameFile)z---------rc|jSr )rD)rbs rrz$ModuleGraph.report.. s r)r15 25r N) rTrrSrrrrrDrErC)r#r3s rreportzModuleGraph.report s  !::; !::;)/EF ]A!Y'$q'*:*:ALL!,,WX$q'*:*:ALL!**JZXZJZ[\  ]rc@tjj|jx}}|jD]i\}}tjj |d}tjj |d}|j |sX||t|dz}n|St|j}tt|D]2}t||t|s|j||||<4|jt||S)Nr ) co_consts co_filename)rCrnormpathrr8rDrhrrHrrrrrreplacer)r#r new_filenameoriginal_filenamefrconstsrs rrz"ModuleGraph._replace_paths_in_code s+-77+;+;BNN+KK (&& DAq Q#A Q#A ++A. #4SVW#==   Ibll#s6{# CA&)T"X. 77q Bq  CzzE&M|zLLr)NrrrNrr )T)direct)Gr)Nr)/rrrrr1r$rOrVr\ getReferencesr^ getReferersrernrQrrrwr0ryrflattenrSrrrrrrrrrrrrrSrrrrrr3rhrrrrrrs@rr.r.s && <">HM"KE$J I_ OENH$$JF" nb<# DTVBr."AJ#>L 0cJ~D#dLf $ ?B.4Y$x=/@0rs  66w3 )"((:UV8M8M8M8OOCKK #5!U0#!<<'9 O$ KK ( %'!- + ?j!1JL?>~@~@B C (2(2V   Y  I  4Y 4 T WW J  :  ,  Z  J    j  y'  w  J , W 0****J*   J,     >_#s_#D\"M+\"Mm!<<'9 O$ KK (s AH55#I