i SrSSKrSSKrSSKrSSKrSSKrSSKJrJrJ r SSK r SSK r SSK rSSKr\R S:aSSKJr OSSKr\ R("5 \ R*"S\SS9 SSKJr SS KJr SSS5 S S KJr "S S 5r"SS5rSrSr \ r!"SS\"5r#Sr$"SS\"S/SQ55r%"SS5r&"SS\'5r("SS\&5r)"SS\&5r*"SS \*5r+"S!S"\*5r,"S#S$\*5r-"S%S&\&5r."S'S(\&5r/"S)S*\/5r0"S+S,\/5r1"S-S.\15r2"S/S0\/5r3"S1S2\/5r4"S3S4\/5r5"S5S6\/5r6"S7S8\5\65r7"S9S:\65r8"S;S<\/5r9"S=S>\65r:"S?S@\/5r;"SASB\/5rSEq?SFq@SGqASHqBSIrCSJrDSr!"SKSL\R5rF"SMSN\5rGg!,(df  GN{=f)Oa 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) ignorezpkg_resources is deprecated)categorymessage) ObjectGraph) GraphError)utilc\rSrSrSrSrg)BUILTIN_MODULE1cgNF)fqnames TC:\des-py\RoboSAPF\venv\Lib\site-packages\PyInstaller\lib\modulegraph\modulegraph.py is_packageBUILTIN_MODULE.is_package2srN)__name__ __module__ __qualname____firstlineno__r__static_attributes__rrrrr1srrc \rSrSrSrSrSrg)NAMESPACE_PACKAGE6cXlgNnamespace_dirs)selfr%s r__init__NAMESPACE_PACKAGE.__init__7s,rcgNTr)r&rs rrNAMESPACE_PACKAGE.is_package:srr$N)rrrrr'rrrrrr r 6s -rr c\rSrSrSrg)InvalidRelativeImportError[rNrrrrrrrrr.r.[rr.cn[R"S[U55nUbURS5$U$)Nz^No module named (\S+)$r )rematchstrgroup)excdefaultms r_path_from_importerrorr:_s1 +SX6A}wwqz Nrc\rSrSrSrSrSrg)DependencyInfomrc UR(d"UR(dUR(a3UR(dKUR(d:UR(d)[SSSUR=(a URS9$[UR=(d URUR=(d URUR=(d URUR=(a URS9$)NF conditionalfunction tryexceptfromlist)r@rArBr<rC)r&others r_mergedDependencyInfo._mergedqs  t~~$$U^^EOO!!95>> ; ;" $ 0 0 EE4E4E!]]>> # 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. )rQr& attr_names ris_global_attrNode.is_global_attr sN3333rcXR;$)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. rSr&submodule_basenames r is_submoduleNode.is_submodule4s&"%E%EEErc:URRU5 g)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)rQaddrYs radd_global_attrNode.add_global_attrJs ##I.rcNURRUR5 g)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)rQupdate)r& target_modules radd_global_attrs_from_module!Node.add_global_attrs_from_module]s &&}'G'GHrc X RU'g)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`submodule_nodes r add_submoduleNode.add_submoduleps @N(();??r) rPrQrRrSrKrLrMrNrON)rrrr__doc__rGr'r[rarerjrnrqruryrrrrrrrrrrrrrrIrIsrYv I2,'4TF,/&I&N&D0H06@--,-,-%"@rrIc\rSrSrSrSrg)Aliasi a 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. rNrrrrrrrrrrr s rrc<^\rSrSrSrSU4SjjrSrSrSrU=r $) AliasNodeiz Graph node representing the aliasing of an existing source module under a non-existent target module name (i.e., the desired alias). cN>[[U] U5 URU5 g)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&namenode __class__s rr'AliasNode.__init__!s$ i'- ++D1rc dSH*n[X5(dM[X[X55 M, g)zX Copy a subset of attributes from referred node (source module) into this target alias. )rNrOrQrRrSN)hasattrsetattrr})r&rrZs rr(AliasNode.copyAttributesFromReferredNode4s*+It'')AB +rc2URUR4$r#)rMrNrs rrAliasNode.infoTupleBs11rrr#) rrrrrr'rrr __classcell__rs@rrrs 2& C22rrc\rSrSrSrg) BadModuleiFrNr0rrrrrFr1rrc\rSrSrSrg)ExcludedModuleiJrNr0rrrrrJr1rrc\rSrSrSrg) MissingModuleiNrNr0rrrrrNr1rrc.^\rSrSrU4SjrSrSrU=r$)InvalidRelativeImportiRc>UnURS5(aX2- nOUSU-- n[[U]U5 XlX lg)N.)endswithrrr' relative_path from_name)r&rrrNrs rr'InvalidRelativeImport.__init__SsJ"  ! !# & &  #J # / )J #T3J?*"rc2URUR4$r#)rrrs rrInvalidRelativeImport.infoTuple]s""DNN33r)rrrrrrr'rrrrs@rrrRs#44rrc.^\rSrSrU4SjrSrSrU=r$)Scriptiac8>[[U] U5 Xlgr#)rrr'rL)r&rLrs rr'Script.__init__bs fd$X. rcUR4$r#rLrs rrScript.infoTuplefs rrrrs@rrras!  rrc2^\rSrSrSU4SjjrSrSrU=r$) BaseModuleijcD>[[U] U5 X lX0lgr#)rrr'rLrO)r&rrLpathrs rr'BaseModule.__init__ks j$(. rcn[[SURURUR455$r#)tuplefilterrNrLrOrs rrBaseModule.infoTupleps)VD4??DMM4CSCS"TUVVr)rLrO)NNrrs@rrrjs WWrrc\rSrSrSrg) BuiltinModuleitrNr0rrrrrtr1rrc\rSrSrSrg) SourceModuleixrNr0rrrrrxr1rrc\rSrSrSrg)InvalidSourceModulei|rNr0rrrrr|r1rrc\rSrSrSrg)CompiledModuleirNr0rrrrrr1rrc\rSrSrSrg)InvalidCompiledModuleirNr0rrrrrr1rrc\rSrSrSrg) ExtensionirNr0rrrrrr1rrc\rSrSrSrSrg)Packageiz2 Graph node representing a non-namespace package. rNrrrrrr  rrc\rSrSrSrSrg)ExtensionPackageizU Graph node representing a package where the __init__ module is an extension module. rNrrrrrrs  rrc\rSrSrSrSrg)NamespacePackageiz. Graph node representing a namespace package. rNrrrrrrrrrc\rSrSrSrSrg) RuntimeModuleia 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. rNrrrrrr $ rrc\rSrSrSrSrg)RuntimePackageia 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. rNrrrrrrrrrc(^\rSrSrU4SjrSrU=r$) FlatPackageicb>[R"S[5 [[/UQ70UD6 gNz=This class will be removed in a future version of modulegraphwarningswarnDeprecationWarningrrr&argskwdsrs rr'FlatPackage.__init__) K   k)D)D)rrrrrrr'rrrs@rrr **rrc(^\rSrSrU4SjrSrU=r$) ArchiveModuleicb>[R"S[5 [[/UQ70UD6 grrrs rr'ArchiveModule.__init__rrrrrs@rrrrrra %(TITLE)s

%(TITLE)s

zB
%(CONTENT)s
z:%(NAME)s %(TYPE)szp%(NAME)s %(TYPE)sz6
%(HEAD)s: %(LINKS)s
z c/nUHPn[U[R5(aURUR5 M?URU5 MR UVs/sH o3S:wdM UPM nnU$s snf)N__main__) isinstanceastaliasappendr)namesresultnmrs r _ast_namesrsb F b#)) $ $ MM"'' " MM"    3A ?aF 3 M4s  A4*A4c[5nURnUVs/sHo3U;aM U"U5(aMUPM sn$s snf)z/Remove duplicates from a list, preserving order)rUrd)seqseenseen_addxs runiqrs8 5DxxH =s!9A As == =s A AAc\rSrSrSr\S5r\S5r\S5rSr Sr Sr S r S r \ rS rS rS r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r\r \rSr!g)_VisitoricbXlX l[UlS/UlS/UlS/Ulgr)_graph_moduleDEFAULT_IMPORT_LEVEL_level_in_if_in_def _in_tryexcept)r&graphmodules rr'_Visitor.__init__s/  * g w #Wrc URS$Nr,)rrs rin_if_Visitor.in_if&s{{2rc URS$r%)rrs rin_def_Visitor.in_def*s||Brc URS$r%)r rs r in_tryexcept_Visitor.in_tryexcept.s!!"%%rc SnUb$[U5nSU;aURS5 SnURRR UXRX#4S[ UR URURSS9045 g)NF*T edge_attr)r@rBrArC) rrxrrPr r<r&r,r))r&rrClevel have_stars r_collect_import_Visitor._collect_import3s  H~Hh$  &&-- LL( 2>!ZZ,,++ !" # $rcv[UR5H nURUSUR5 M" gr#)rr r3r)r&rrs r visit_Import_Visitor.visit_ImportGs+TZZ(B  T4;; 7)rcURS:wa URO URnURUR=(d S[ UR 5U5 g)Nr)r1rr3r"rr )r&rr1s rvisit_ImportFrom_Visitor.visit_ImportFromKs?"jjAo 4;; T[[.B 4::0FNrcURRS5 URU5 URR5 gr*)rr  generic_visitpopr&rs rvisit_If_Visitor.visit_IfOs0 4  4  rcURRS5 URU5 URR5 gr*)rr r=r>r?s rvisit_FunctionDef_Visitor.visit_FunctionDefTs2 D! 4  rcURRS5 URU5 URR5 gr*r r r=r>r?s r visit_Try_Visitor.visit_Try[6 !!$' 4   rcURRS5 URU5 URR5 gr*rFr?s rvisit_TryExcept_Visitor.visit_TryExcept`rIrcgr#rr?s rvisit_Expression_Visitor.visit_Expressiones r)rrrr rrN)"rrrrr'propertyr&r)r,r3r6r:r@rCvisit_AsyncFunctionDefrGrKrN 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_Callrrrrrrs%  &&$(8O  /! !  $L"K$M#L"K!J I%N$M%N)$M"K&O"K!J"Krrct^\rSrSrSrU4SjrS'U4SjjrSrS(SjrSr \ r S)S jr \ r S r S rS rS*U4S jjr\rS)U4Sjjr\r\R*rS(SjrSS\S4SjrSr\4SjrSrSrSrSrSr Sr!Sr"\S4Sjr#S(Sjr$Sr%Sr&Sr'S(Sjr(S r)S(S!jr*S+S"jr+S,S#jr,S$r-S%r.S&r/U=r0$)- ModuleGraphizf Directed graph whose nodes represent modules and edges represent dependencies between these modules. c`>URU5nUc[[U]"X/UQ70UD6nU$r#) find_noderrb createNode)r&clsrrkwr9rs rreModuleGraph.createNodes6 NN4  9k43CKKKArNc>[[U] XVS9 Uc[RnXl0UlUR R [U55 UHnSUR U'M X0l0Ul 0Ul g)N)r!debug) rrbr'sysr lazynodesrhrV replace_paths_package_path_map_legacy_ns_packages) r&rexcludesrmimpliesr!rjr9rs rr'ModuleGraph.__init__sw k4))C <88D  d7m,A $DNN1 *"$$& rc[S5n[R"5HnURS5nUcMUR 5n[ US5nUcM:UHYn[ RR"[UR5/URS5Q76nXRU5 M[ M UR5VVs0sHupWU[U5_M snnUlgs snnf)z Resolve extra package `__path__` entries for legacy setuptools-based namespace packages, by reading `namespace_packages.txt` from dist metadata. c[5$r#)rUrrr.srznamespace_packages.txtN_pathr)rimportlib_metadata distributions read_text splitlinesr}osrjoinr5parentsplitrditemslistro)r&legacy_ns_packagesdist ns_packages dist_path package_namerpathss rscan_legacy_namespace_packages*ModuleGraph.scan_legacy_namespace_packagess )7&446D..)ABK"%002Kg.I  + ww|| (()!'',#044T: !,7&(:'?'?'A$ 'A#  $u+ %'A$  $ sC4c[U[5(aURXU5 g[U[5(a [ U5eUR X!S5nUHnURXU5 M g)a 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)rrI_updateReferencer ValueError_safe_import_hook)r&rrD edge_dataotherss rimplyNodeReferenceModuleGraph.implyNodeReferencese6 eT " "  ! !$y 9%'' ''++E>F%%d9= rcNURU5nURU5up4U$)z\ Yield all nodes that `fromnode` dependes on (that is, all modules that `fromnode` imports. )rd get_edges)r&fromnoder out_edges_s routgoingModuleGraph.outgoings( ~~h'~~d+ rc## URU5nURU5upEU(aBUH;n[U[5(aUR US5HnUv M M7Uv M= gUHnUv M g7fr)rdrrrincoming)r&tonodecollapse_missing_modulesrrin_edgesns rrModuleGraph.incomingso~~f%nnT*  #a//!]]1e45G sAcURU5nURU5nURRX5SL$)z=Return True iff there is an edge from 'fromnode' to 'tonode' N)rdr! edge_by_node)r&rrs rhasEdgeModuleGraph.hasEdges8>>(+'zz&&x8DDrcURU5nUR5GH%nURRURS-5(dM3UR U5upEUH\nURRURS-5(aM2UR X&5(aMJUR X&S5 M^ UH\nURRURS-5(aM2UR Xb5(aMJUR XbS5 M^ URRU5 GM( g)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) rdnodesrN startswithrrrr! hide_node)r& packagenodepkgriter_outiter_incrDs rfoldReferencesModuleGraph.foldReferences snn[)A<<**3>>C+?@@!%!2 H!##..s~~/CDD||C//))#6KL ""##..s~~/CDD||E//))%lC " JJ  #+rc4URX5n[ U[ 5(a[ U[ 5(dUR XU5 gUR XURU55 g![[4a URXU5s$f=fr#)edgeDataKeyErrorr add_edgerr<updateEdgeDatarE)r&rrreds rrModuleGraph._updateReference0s >x0B2~..:i3X3X   ) <   "**Y2G H *% >==9= = >sA22"BBc(>[[U] XUS9$)z, Create a reference from fromnode to tonode r)rrbcreateReference)r&rrrrs rrModuleGraph.add_edge;s[$7T]7^^rc>[[U] U5nUbU$XR;aURR U5nUcUR [ U5nU$[U[5(a[UR [U5nURUSS5R 5nURU5 URXV5 U$URUSS5R 5nUHnURXW5 M U$g)ao 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) rrbfindNoderlr>rerrrrrrr) r&r create_nspkgdatadepsr9rDdeprs rrdModuleGraph.find_nodeCs@[$06  K >> !>>%%d+D|OOND92H1D%((OOIt4..tT4@DDF 007''1 H **4t<@@BC++A3 HrcURSSU5 [RRU5nUR U5nUbU$[ US5nUR 5nSSS5 [RRW5n[XQS[RS5n[XaSSS5nUR[U5nURX#S5 UR!X7U5nUR#U5 XslUR&(a UR)UR$5UlU$!,(df  N=f)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)msgr|rrealpathrdopenread importlibr decode_sourcecompiler  PyCF_ONLY_ASTrerr _scan_code_process_importsrKrm_replace_paths_in_code) r&pathnamecallerr9fpcontentsco_astcors r add_scriptModuleGraph.add_scripts L(+77##H- NN8 $ =H (D !RwwyH">>//9VS5F5FM Vvq$ 7 OOFH - f. OOA6 * a    008AF" !s D;; E cURSSXX$5 URU5nURXaU5upqURSSXq5 UnU(aUR S5n U S:a [ U5n USU XS-SpUR <SU <3n URXU5nUc*URSS U 5 [S [U 5-5eU(aMURSS U5 Un U /n U(aK[U [[45(a0URX5HnX;dM U RU5 M U Hn UR!X,US 9 M U $) aC 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 ->r)r_determine_parent_find_head_packagemsginfindlenrN_safe_import_modulemsgout ImportErrorreprrrr%_import_importable_package_submodulesr r)r&target_module_partname source_moduletarget_attr_namesr1r0source_packagetarget_package submoduleiheadmnameritarget_modulestarget_submodules r import_hookModuleGraph.import_hookst N$:=`// >151H1H E2;. 1k>J" $&++C0A1u./+A,+aCD1)(33T:E00iHI  ACUK!"4tE{"BCC%$ A~y1! ' M-4i,@"B"B$($N$N%2 #9"))*:;%2 ,M  ! !  " C,rcHURSSU5 SnU(arURn[U[5(aUnONSU;a&USUR S5nUR U5nO"UR (aUR U5nURSSU5 U$)z* Determine the package containing a node. rdetermine_parentNrzdetermine_parent ->)rrNrrrfindrdrOr)r&rr~pnames rrModuleGraph._determine_parents 1(&1 %%E&'**/u{{3/0.##. A,f5 rc URSSXU5 SU;aURSS5upEOUnSnU[:XaU(aURS-U-nGO!UnGOU[:XaUnSnGO Uc*UR SS5 [ S U<S U<S U<S 35e[US- 5HnSUR;a*UR SS5 [ S U<S U<S U<S 35eURRSS5S nURU5n U c*UR SS5 [ S U<S U<S U<S 35eXLdX45eU nM U(aURS-U-nO URnURXFU5n U c#Ub U[::aUnSnURXFU5n U bURSSX45 X4$URSSU5 [SU-5e)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_packagerr r9Nrz"Relative import outside of packagez)Relative import outside of package (name=z , parent=, level=)rzfind_head_package ->rr) rr!ABSOLUTE_OR_RELATIVE_IMPORT_LEVELrNABSOLUTE_IMPORT_LEVELrr.rangersplitrdrrr) r&rrr1target_module_headnametarget_module_tailnametarget_package_namerp_fqdn new_parentrs rrModuleGraph._find_head_package8sVP 1)>SXY ( (&,,S!4 ; "$:&< "%' " 5 5&4&?&?#&EH^&^#&<# + +"8 "N%@A0.GHH519%n777HHQ DE42NEKLL(2299#qA!D!^^F3 %HHQ DE42NEKLL"70:007!+%&(&"--36LL$'5&?&?#11 "I  !n&@UNcEc"8 !N"55&^MN  % KK1N3[ \!9 9 A;=PQ,/BBCCrc## [U5nURSSX5 SU;a1URURU55 UR S5 UHnUR U5nUckUR S-U-nURX5U5nUcDURU5(a URSSUR U5 Mt[SU-5eUv M URSS5 g7f) 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. rrr/NrzD_import_importable_package_submodules: ignoring from-imported globalrz(_import_importable_package_submodules ->) rUrrh_find_all_submodulesrxrurNrr[rr)r&package attr_namesrZrsubmodule_names rr1ModuleGraph._import_importable_package_submodulessZ_  1=wS *    d77@ A   c " $I  55i@I !(!3!3c!9I!E!44w8 $~--i88$jlsl~l~AJK **<~*MNNOu$x 1@AsC5C7c## UR(dgURHn[R"U5nUHzn[ RR5HGnURU5(dM[RRU5S[U5*n O MnUS:wdMvUv M| M g![R[4a UR SSU5 Mf=f7f)Nrzcan't list directoryr') rOr|listdirerrorIOErrorrr machinery all_suffixesrrbasenamer)r&r9rr rsuffixs rr  ModuleGraph._find_all_submodules[s}} MMD  4('11>>@F}}V,,!ww//5mF |DA :%J "HHg& 2D9 s3"C4C:C496C43 C4-C1-C40C11C4cURSSU<SU<S35 [U[5(dS[U5-5e[U[5(dS[U5-5eURU5nUb9[U[5(aUR U:Xd[ SU<SU<S 35e[U5URU'g) aI 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".) rrr5rdrrNrrrl)r&src_module_nametrg_module_name trg_modules r alias_moduleModuleGraph.alias_modulers$ ?OTU/3//a1JSQ`Ma1aa//3//a1JSQ`Ma1aa/^^O4  ! j) , ,  O 3#Z12 2 +0*@'rcURSSU5 URUR5nUcURU5 OX:XdSU<SU<S35eURR S5up4nU(aKURU5nUcURSSU5 gUR X5 UR XQ5 gg) 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:)rrdrNaddNode rpartitionrrn)r&r" module_added parent_namermodule_basenamer~s rrModuleGraph.add_modules" L&)~~f&7&78   LL ) cfVb+c c)+1*;*;*F*Fs*K'  ^^K0F~:KH f-$$_= rc^URRU/5nURU5 g)a 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)rn setdefaultr )r&r directoryrs rappend_package_pathModuleGraph.append_package_paths((&&11,C Yrc URSSXU5 URU5nUcSnUb-URb URnOURSS5 gUR XU5upgUR X&U5upIU b~[U [R5(aU n [XSSS5n OSn URXIU 5n URU 5 UR(aURU 5n XlUb@UR#S S US U5 UR)XC[+SSSSS9S9 UR-X5 URSSU5 U$![ anURSSU-5 SnAgSnAff=f![ a- UR#S S U5 [$n UR'X5nNf=f)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)rrTr z#safe_import_module: SyntaxError in rz#safe_import_module create referencez->F)r@rCrArBrzsafe_import_module ->)rrdrOr _find_moduler _load_modulerr ASTrrrrmrrK SyntaxErrorrrrerr<rn) r&module_partname module_name parent_moduler" search_dirsrloaderr7rrrrfs rrModuleGraph._safe_import_modulesB 1*O-X , >K(!,,8"/";";KKK#cd #'#4#4#-$A   ,,[FKLV~?!"cgg..!#$Vvq$G!%F;A))!,))!88<"$K  $ HHQ=vt] [  ! ! %""# 2 "   ' ' @ A.7 W  A@3FG $#?HH@(.C!__S>F ?s+EA=F  F'FF 4G?Gc SSKJn URSSXURR5 UR S5SnUR U5(GaJ[U[5(a2UR[U5nSUl URSSUl OURRU/5n[X45(aUR[ U5nOUR["U5nX&l [$R&R)U5R+S5(de[$R&R-U5/U-Ul URUR.RU/5-Ul [U[5(aUS4$SnU[0La[2n O|[X45(a[4n S n U "U5nOZUR7U5n U b$[EXS [FRHS5n[Jn O!URQU5nUb[RO[Tn URX5nX&l URWSSU5 Xh4$![8[:4azn [U [:5(a [U R<[85(deUR?SS US U S 35 URAU5n URCU 5n Sn A NSn A ff=f![:a Sn[Ln N[Na$n[Ln UR?SSUU5 SnANSnAff=f![Na$nUR?SSX.5 [Tn SnAGN'SnAff=f)Nr)ExtensionFileLoaderr load_modulerr,-z __init__.c"[RRU5n[RRU5R S5SnSHn[RR XU-5n[RR U5(dMK[US5nUR5nSSS5 [WUS[RS5nUs $ g!,(df  N2=f![a nSnAMSnAff=f)Nrr>.py.pyirrT) r|rdirnamerrr}isfilerrrr r Exception) extension_filenamerrext src_filenamersrcres r_co_from_accompanying_source>ModuleGraph._load_module.._co_from_accompanying_sourceksww'9:77++,>?EEcJ1M*C#%77<<n#EL77>>,77 !,5"$'')C6$S,@Q@QSWX! + 65%s* C9+C(<&C9( C6 2C99 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_externalr8rrrr!rrr rerrLr%rOrortrrr|rrrr>rnrrr get_sourceUnicodeDecodeErrorr0 __context__r get_filenameget_datarr rrrr@get_coderrr)r&rrr5r8partnamer9 ns_pkgpathsrrfrFrDrErr7s rr.ModuleGraph._load_module:sE 1mV##,, .$$S)"-   X & &&"344OO$4f=  & 5 5a 8 #66::62F f::(8&AA8A% ww''1<<[IIII!#!: ;k I MMD,B,B,F,F-AM!-..4y  ^ #C  4 4C ".h7B ,''1> " 8I8I4PB&C02B-/^> 5 OOC (  A'+wq' 4 ,&a--%amm5GHHG$:Rs+%%&**84ood+9 ,D#.B-C "-CHHQ BH """!0HHQ!019@/C0sOI."K, L0K)/A0K$$K),L- L- L((L-0 M:MMc ( ^^^^^TRSSTTTT5 UUUU4SjnU4SjnSnSn TRTTSTUS9n[U5S:XdSRU55eUSn[U[5(aBU c?U"5(a3U"T5(a&TRU5 TR!TTSSUS9nU$[U["5(aUR%SS9nT(Ga[U[&[(45(GaTGHnUR+U5(a>UR-U5nUb*UU;a"TR TUUS 9 URU5 MXUR.S -U-nTR1U5nUcTRTTU/TUS9 TR1U5nUcYUR3U5(d!SRUUR.55eTRS SSUR.U5 GMU (aSTR1U5(aTRSSU<SU<S35 O!TRS S U<S!U<35 UUlUR5UU5 UcGMrTR UUUS 9 TR TUUS 9 UU;dGMURU5 GM U$![al TRSSTTT5 /n T=(d S HAn TR [ S T-T-U 5n TR TXS 9 U RU 5 MC U s$[Gan U"5(aTRS S T<ST<ST<S35 U"T5n U (anT/mSmSmTRSST<ST<ST<S35 TRTTSTUS9nO3![a&n TRSS[U 55 Sn A OSn A ff=fUcOTRSS[W 55 TR [[U T55nTR TXS 9 U/nSn A GNSn A ff=f![a=n TRSS[U 55 TR [U5nSn A GN$Sn A ff=f)"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. rrc>TSL=(aW TSL=(aL T[:H=(a< [T5[L=(a$ TSTRR S5S-:H$)Nrrr)rrrrNr!)r1rrrsris_swig_candidate8ModuleGraph._safe_import_hook..is_swig_candidatesr!-H%-H22H'<7H+M44??DQGGH  Irc.>[URS5nUR5nSSS5 [RR W5nU(aUR 5SOSnTRSSU-5 SU;$!,(df  Nc=f)Nrrr9z%SWIG wrapper candidate first line: %rzautomatically generated by SWIG)rrLrrrrr{r)rrr first_liner&s ris_swig_wrapper6ModuleGraph._safe_import_hook..is_swig_wrappersxm,,d3r7794 ~~33H=H5=,,.q12J HHQ?:N O4 B B 43s B BN)rr1r0rzInvalid relative importr/rrrzSWIG import candidate (name=z , caller=rrr9r zSWIG import (caller=z , fromlist=zSWIG ImportError:z ImportError:z@Expected import_hook() toreturn only one module but received: {}rT)rCz!No global named {} in {}.__init__z#ignoring imported non-module globalzSWIG import error: z basename z already existszSWIG import renamed from z to )rrr.rrerrr rr5rr:rformatr removeNoderr<_replacerrrarqrNrdr[rn)r&rrrr1r0rTrYris_swig_importr subr9rritarget_submodule_partnamertarget_submodule_names````` rrModuleGraph._safe_import_hooksgd ')?Pachi I 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$* $~~.GHH $$%)>(A%C!D!%$%(=(A%C!D %>!1 ;++-/?A#/))%'79*N))%'79*N(~=&--.>?C.?He*  KK4e.0A CF(/C/OO$9$'%K2H$H#O%%mQ%L a 0 MJ 1D!"". uFG"1!?! *@(@%-/*EHHQ -/@%IJC)-)9)92M.2"'&/ *:*1 'C$7SBBC%NCH5!%!*30FG!I %%!=&G#0UJ 1l'BNCH=+/??)+@,B(BsoK A>Q 8Q !Q A3Q8 QA Q#N76Q7 O'O"Q"O''AQQ R2R  Rc/UlUb#URX5 URXSS9 U$URXSS9 U$)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)rP _scan_ast_scan_bytecode)r&r"module_code_objectmodule_code_object_asts rrModuleGraph._scan_codeI seZ$& " - NN6 :     G      F rc<[X5nURU5 g)a9 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&r"rhvisitors rreModuleGraph._scan_ast s4( ,-rc`SnSn[SS9n[R"U5GHnU(dM URS:XaU(dM&[R S:a+USRS;deUSRS ;deO*USRS :XdeUSRS :XdeUSR nUSR nUb[U5[LdeUR nS n Ub$[U5nS U;aURS 5 S n URRU XXT4045 O[URS;aUR n URU 5 O-URS;aUR n URU 5 URU5 GM g)a4 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,>rsrursFr/T) STORE_NAME STORE_GLOBAL) DELETE_NAME DELETE_GLOBAL)rriterate_instructionsopnamerk version_infoargvalrrrrxrPr rery) r&r"rgrdr1rC prev_instsinstrr2rs rrfModuleGraph._scan_bytecode s~!_ --.@AD{{m++##w.%b>004kkkk%b>004YYYY%b>00L@@@%b>00L@@@"2--%b>00'4>U+BBB)-&" '#H~Hh ,$( ((//+XE1  >>{{&&t, @@ {{2248   d #iBrc~UR(dgURHup#nUR"U0UD6nU(dM!USnU(dM/URU5 URR UR5 UR bMtUSnURR U5 M SUlg)ab 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)rPrrjrRrhrKrd)r&rr2 import_infokwargsrritarget_module_names rrModuleGraph._process_imports@ s.. /<.M.M *IF"33[KFKN! *1-My::=I@@GG!DDF !%%-)4Q&!DDHH*,O/NV+/ 'rcUbURS-U-nOUnURU5nUbURSSU5 [U5eUc(U[R ;aS[ 4$URnURXAU5$)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?) rNrdrrrkbuiltin_module_namesrr_find_module_path)r&rrr~fullnamers rr-ModuleGraph._find_module s>  ((3.5HH~~h'   HHQ8$ ?d# # <s///n--99D%%hd;;rcURSSX5 Sn/nUGH[n[R"U5nUcM[US5(aGSnUR U5n U b0U R nUR U R=(d /5 Om[US5(a%URU5upUR U 5 O7[US5(aURU5nO[SU<SU<S 35eUcMSn [US 5(aURU5n O2[US 5(a URn O[SU<S U<S 35eU cURSSU 5 GMYX4n O U(aUS[U54nUR!SSU5 Uc[S[%U5-5eU$![an UR!SSU 5 Sn A NQSn A f["an UR!SSU 5 eSn A ff=f)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 unobtainablerLrz loader z path unobtainablez _find_module_path path not foundrr z"_find_module_path -> unicode errorz_find_module_path -> exceptionz_find_module_path ->r)rpkgutil get_importerrrr5extendsubmodule_search_locationsrrrrLrrr rJrr@r) r&rr2r4 path_datar% search_dirimporterr5specloader_namespace_dirsrr7s rrModuleGraph._find_module_path s-N 1,hD Q ) "// ;#8[11!F#--k:D'!%&--d.M.M.SQSTX}554<4H4H#5%1F"))*?@X}55%11+>F&GRT\]__>   6>22%22;?HVV,,%{{H&CNPVWYY #HHQ BHM&. I*N"!/!2!2>!B!DI A-y9  04 3DDE E" F KK? E E  KK;S A  s*EG9G H  G## H 0HH c (Uc[Rn/n/nUR5Hgn[RR UR 5n[U[5(aURXT45 MUURXT45 Mi UR5 UR5 UVVs/sHupgUPM nnnURU5 UnSSRU5-n [[SU 0-US9 Sn UGHrupWSn [U[5(a [ USS.-n O[U["5(a[ US UR$-S.-n OR[&R(R+UR$=(d S5n [,X\UR.R0S .-n [3XR5U55upU (aE/nU HnURS U<S U<S 35 M SRU5nU [6SUS.-- n U(aE/nUHnURS U<S U<S 35 M SRU5nU [6SUS.-- n [[S.-US9 GMu [[:US9 gs snnf)Nz modulegraph cross reference for z, TITLE)filecUVs/sH4o(dM [RRUR5PM6 nnUR 5 U$s snfr#)r|rrrMsort)modsmodlsts rsorted_namelist0ModuleGraph.create_xref..sorted_namelistS sB?CKts3277##CNN3tCK HHJJLs A-Ar9z(builtin module))NAMETYPEz %s)rURLrz z z • imports)HEADLINKSz imported by)rCONTENT)rkstdout iter_graphr|rrrMrrr rrr}printheaderrcontplrrLurllibrequest pathname2url contpl_linkedrrmaprrentryfooter)r&outscriptsrrrsnr9 scriptnamestitlercontenturlouteincelinksrs r create_xrefModuleGraph.create_xref> s@ ;**C??$C77##CNN3D#v&&{+ TK( %   './webrw /t2TYY{5KK f''c2 GDG!]++ D,E$GGAy)) D,9AJJ,F$HHnn11!**2BC'434;;3G3G+II_nnQ.?@JDALL1a!HI $((/7i%%HHHALL1a!HI $((/7me%LLL %4<<3 G?@ f3W0s8Jc #^ ^!^"# [[URRURR U555nURR m![ 5n[5n0n0n0n[5n [U5nSn Sm"SU<S3v [SSS9n Sm U R5Hn S T U -<S 3v M UHZupnn[US S5X}'[U[5(dM-XUR'[U /5X'URU 5 M\ UHupnnU!4S jU5HnURU5 M S U <SSR!U "XUU5R5V s/sHn T U -PM sn 5<S3v UR#U 5nUc[5=nX'X}nUcMUR#USUR%S55nUcMURU5 M /n0nUHn/UU'M U(Ga>UR'5unnnnUU4U ;aM'U RUU45 UUnUUU-nU(d\U(aU[)U5n[+U5S:wd USU:wa2URUUUUS45 URUSUSU45 MU(avUR-5nUU:XaURUUUU45 O_UU:XaUURUSUU45 O@URUUUU45 URUUUU45 OURUUUU45 U(aGM>U U"4SjnUR5H3unnSU<S3v SUU<S3v U"US5HnUv M Sv M5 U"US 5HnUv M Sv gs sn f7f)Nc[U[5(d S[U50$S[U5R-n[ UR 5SSS5HupVUSXV4-- nM USS.$)Nlabelz r z | %srecord)rshape)rrIr5rr enumerater)rrrrsrvs r nodevisitor0ModuleGraph.itergraphreport..nodevisitor sqdD))T++$t*---A!$.."22A"6:\QF**;2 2rc.US:XaSS0$US:XaSS0$0$)Norphanstyledashedpkgrefdottedr)edgerrtails r edgevisitor0ModuleGraph.itergraphreport..edgevisitor s/x**!**Irzdigraph z { charset="UTF-8"; LRtrue)rankdir concentratez%s="%s" z; rMc34># UH nT"U5v M g7fr#r).0rE describe_edges r .ModuleGraph.itergraphreport.. s<8aq))8sz "z" [,z]; rr rrr,c 3># US-nUHJup4pVT "X4XV5nUUUSRUR5Vs/sHnT U-PM sn54-v ML gs snf7f)Nz"%s" -> "%s" [%s]; r)r}r) edgestabsedgestrrrrrattribsitemcpattrs rdo_graph-ModuleGraph.itergraphreport..do_graph so33G,1(T%d$=HHIut|IJ!-2 Js7AA Az subgraph "cluster_z" { z label="z"; z z } z} )rrr! describe_nodeiterdfsrrrUrVrr}rrrMrdr r}rtrpopleftsortedrr>)#r&r flatpackagesrr packagenodes packageidents nodetoident inpackages mainedgesrattrrrrrrrinsideidentpkgnoder! subgraphskeyrrtailpkgscommonusepkgsrgrrrrs# @@@ritergraphreportModuleGraph.itergraphreporty sS114::3E3Ed3KLM 00 u    E L)  3 59::Df5JJLD$t|- -!16 ,T8 'lD AK $((15doo.#&v;    & 1616 ,T8<8< T"= Hh?EEGG(,UT\G  ^^D)F~,/E1)%E}#''.?u{{3/?(@AG" 7#-160 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$561e4 ")HAu346 6)4Q9 9eV,-M *%&AG' Is(C1O :BO OAO 1E*O A,O cfUc[RnURURUS95 g)N)r)rkr writelinesr)r&fileobjrs r graphreportModuleGraph.graphreport s, ?jjG4//\/JKrc [5 [SS-5 [SS-5 [UR5SS9Hn[U[5(aA[[ U5R <SSUR<SSUR<35 MY[[ U5R <SSUR<SSUR=(d S <35 M g ) 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---------r cUR$r#)rM)rs rru$ModuleGraph.report.. sr)r15 25r9N) rrrrrrrrMrNrL)r&r9s rreportModuleGraph.report s  !::; !::;)/EFA!Y''$q'*:*:ALL!,,WX$q'*:*:ALL!**JZXZJZ[\ GrcL[RRUR5=p#URHmupE[RR US5n[RR US5nUR U5(dM]XS[U5S-n O U$[UR5n[[U55H6n[Xg[U55(dM!URXg5Xg'M8 UR[U5US9$)Nr9) co_consts co_filename)r|rnormpathrrmr}rrrrrrrrreplacer)r&r new_filenameoriginal_filenamefrconstsrs rr"ModuleGraph._replace_paths_in_code s+-77+;+;BNN+KK &&DA Q#A Q#A ++A.. SVW#==  'Ibll#s6{#A&)T"X.. 77 B $zzE&M|zLLr)rornrlrrm)NrrrNrr#)T)direct)Gr)Nr)1rrrrrrer'rrr getReferencesr getReferersrrrrrrdrr flattenrrrrrrrr rrr)rr.rrrerfrr-rrrrrrrrrs@rrbrbs$ && <">HM"KE$J I_ OENH$$JF" nb<# DTVBr."AJ#>L 0cJ~D#dLf $ ?B.4Y$x=/@0r,sX  66w3  - 1# %'!- + ?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+\"Mus G00 G?