ci dZdZddlZddlZddlmZmZmZmZm Z m Z m Z m Z m Z ddlmZmZmZmZmZddlmZddlmZddlmZmZmZmZmZmZmZdd l m!Z!dd l"m#Z#dd l$m%Z%m&Z&dd l'm(Z( ddl)Z)e+Z,ejZj]d rdZ/dZ0ndZ/dZ0 edZ1eZ2e3jiejjdZ6Gdde7Z8Gdde+Z9 dDde:deede;de!fdZ< dDdee:deede;dee!fdZ=dEd Z>de:d!ee:de?fd"Z@de:de:fd#ZAe(d$dFd%e:d&eee:e:fdee:fd'ZB dGd(ee:deed)ee:dee:fd*ZCdFde:d)ee:de:fd+ZDe%fd,e:d-e:d.ee:dee:fd/ZEe%fd-e:d.ee:dee:fd0ZFdHd%e:d1e?de:fd2ZGd3ZHd4ZId5ZJe1ffd6e:d7eee:ee:fde?fd8ZKd6e:d9e:de?fd:ZL dGd(ee:deed;ee:dee:fd<ZMd(ee:d=ee:ee#fdee+e:e:ffd>ZN ddlOZOd6e:de?fd?ZP dFd(ee:deee:deee;e+fee:ffd@ZQd%e:de?fdAZRdBe:dee:fdCZSy#e*$rdZ)YwxYw#e$rdZ1YwxYw#e*$rdZOYcwxYw)IaJPython modules manipulation utility functions. :type PY_SOURCE_EXTS: tuple(str) :var PY_SOURCE_EXTS: list of possible python source file extension :type STD_LIB_DIR: str :var STD_LIB_DIR: directory where standard modules are located :type BUILTIN_MODULES: dict :var BUILTIN_MODULES: dictionary with builtin module names as key zrestructuredtext enN) splitextjoinabspathisdirdirnameexists expandusernormcaserealpath) find_module load_module C_BUILTIN PY_COMPILED PKG_DIRECTORY)get_python_lib)DistutilsPlatformError)DictListOptionalAnyTupleUnionSequence) ModuleType) FileFinder) STD_BLACKLIST_handle_blacklist)callable_deprecatedwin)pypyw)dllpyd)r )soT) standard_libz//ceZdZdZy) NoSourceFilezaexception raised when we are not able to get a python source file for a precompiled file N)__name__ __module__ __qualname____doc__9/usr/lib/python3/dist-packages/logilab/common/modutils.pyr'r'Ysr-r'c4eZdZdZdZdZfdZdZxZS) LazyObjectak This class allows to lazyly declare a object (most likely only a callable according to the code) from a module without importing it. The import will be triggered when the user tries to access attributes of the object/callable or call it. Trying to set or delete attributes of the wrapped object/callable will not works as expected. c.||_||_d|_yN)moduleobj _imported)selfr3r4s r.__init__zLazyObject.__init__ks r-c|j.tt|j|j|_|jSr2)r5getattrload_module_from_namer3r4)r6s r._getobjzLazyObject._getobjps2 >> !$%:4;;%GRDN~~r-c~ tt| |S#t$rt |j |cYSwxYwr2)superr0__getattribute__AttributeErrorr9r;)r6attr __class__s r.r>zLazyObject.__getattribute__us< 1T;DA A 14<<>40 0 1s #<<c.|j|i|Sr2)r;)r6argskwargss r.__call__zLazyObject.__call__{st||~t.v..r-) r(r)r*r+r7r;r>rE __classcell__)rAs@r.r0r0_s   1 /r-r0 dotted_namepathuse_sysreturnc^t|jd||}|td|z|S)a"Load a Python module from its name. :type dotted_name: str :param dotted_name: python name of a module or package :type path: list or None :param path: optional list of path where the module or package should be searched (use sys.path if nothing or None is given) :type use_sys: bool :param use_sys: boolean indicating whether the sys.modules dictionary should be used or not :raise ImportError: if the module or package is not found :rtype: module :return: the loaded module .zmodule %s doesn't exist)load_module_from_modpathsplit ImportError)rGrHrIr3s r.r:r:s80&k&7&7&,7d,C )G[' $%Wg{GL&MMO  Jf - B/ w/ WU3/#((5W;P2QQR R9 : MC   ,&MMO's!E?E/ E,+E,/Fc4t||}t|||S)aLoad a Python module from it's path. :type filepath: str :param filepath: path to the python module or package :type path: list or None :param path: optional list of path where the module or package should be searched (use sys.path if nothing or None is given) :type use_sys: bool :param use_sys: boolean indicating whether the sys.modules dictionary should be used or not :raise ImportError: if the module or package is not found :rtype: module :return: the loaded module )modpath_from_filerM)filepathrHrI extrapathr]s r.load_module_from_fileris, )4G #GT7 ;;r-mod_pathcg}|D]G}|j|t||}tdj|r;t|rGyy)z2check there are some __init__.py all along the wayrLFT)rWrr\ _has_init)rHrjr]r_s r. _check_initrmsMGtD$SXXg./ $  r-c*tt|Sr2)r r )rHs r._canonicalize_pathros Jt$ %%r-z*you should avoid using modpath_from_file()filenamerhcBt|}tjj|d}|t t|D]}t |}|st |dt|t |k(s5|t|djtjDcgc]}|s| }}t||dds||jd|zcSt ttjD]n}|st |j|s!|t|djtjDcgc]}|s| }}t||ddsl|cStd|ddjtjcc}wcc}w)aDEPRECATED: doens't play well with symlinks and sys.meta_path Given a file path return the corresponding splitted module's name (i.e name of a module or package splitted on '.') :type filename: str :param filename: file's path for which we want the module's name :type extrapath: dict :param extrapath: optional extra search path, with path as key and package name for the path as value. This is usually useful to handle package splitted in multiple directories using __path__ trick. :raise ImportError: if the corresponding module's name has not been found :rtype: list(str) :return: the corresponding splitted module's name rNrLzUnable to find module for  in z, )roosrHrmaprr rXrNseprmrT startswithrOr)rprhbasepath_rHpkg submodpathr]s r.rfrfsk."(+H 77  H %a (D+Y7 DE5>DkD !23x~E-1#d)+->-D-DRVV-LTcPScT TtZ_5$U+11#6CC  D&1 HTN--d3&*3t9;&7&=&=bff&EMssMGM4".  h TWT\T\H]^ __U Ns"F*FFFr] context_filec| t|}n|}|ddk(r tdg|ddz||S|ddgk(rtjj St|||S#t$rt|||cYSwxYw)agiven a mod path (i.e. splitted module / package name), return the corresponding file, giving priority to source file over precompiled file if it exists :type modpath: list or tuple :param modpath: splitted module's name (i.e name of a module or package splitted on '.') (this means explicit relative imports that start with dots have empty strings in this list!) :type path: list or None :param path: optional list of path where the module or package should be searched (use sys.path if nothing or None is given) :type context_file: str or None :param context_file: context file to consider, necessary if the identifier has been introduced using a relative import unresolvable in the actual context (i.e. modutils) :raise ImportError: if there is no such module in the directory :rtype: str or None :return: the path to the module's file or None if it's an integrated builtin module such as 'sys' Nrxml_xmlplusrtrH)r_file_from_modpathrOrtrHrR)r]rHr|contexts r.file_from_modpathr/sB,'qzU >%zlWQR[&@$P P T6N "ww gtW 55  >%gtW= = >sAA54A5c |jdry|jd}|)|dtvrt|dkDr t ||dSd}d}|ddk(r |Jdg}d}||dk(r|dz }|Jt |}||dk(rt |t|D]} t|||dz|| |S#t$r5|tdt|dz k\sdj|d|cYcSwxYw) agiven a dotted name return the module part of the name : >>> get_module_part('logilab.common.modutils.get_module_part') 'logilab.common.modutils' :type dotted_name: str :param dotted_name: full name of the identifier we are interested in :type context_file: str or None :param context_file: context file to consider, necessary if the identifier has been introduced using a relative import unresolvable in the actual context (i.e. modutils) :raise ImportError: if there is no such module in the directory :rtype: str or None :return: the module part of the name or None if we have not been able at all to import the given name XXX: deprecated, since it doesn't handle package precedence over module (see #10066) zos.pathrLNrrSz.explicit relative import, but no context_file?r)rHr|) rwrNBUILTIN_MODULESrXrOrrangermaxr)rGr|rPrHstartiis r.get_module_partr`sB6i(   c "E 8 &5zA~!+..8OD F Qx2~'Y)YY' -2 ! '''|,  -2 63u: &' ' eFQU3$\ Z'   'As5zA~..88E"1I& & 's&B>>9C<;C<package src_directory blacklistcg}tj|D]\}}}t|||d|vrd|dd||k7r@|t|dj tj d}|j ||z|D]`}t|s|dk7st||} || t|dz} |j | j tj db|S)aSgiven a package directory return a list of all available python modules in the package and its subpackages :type package: str :param package: the python name for the package :type src_directory: str :param src_directory: path of the directory corresponding to the package :type blacklist: list or tuple :param blacklist: optional list of files or directory to ignore, default to the value of `logilab.common.STD_BLACKLIST` :rtype: list :return: the list of all available python modules in the package and its subpackages __init__.pyr,NrL) rtwalkrrXreplacervrW_is_python_filer) rrrrU directorydirnames filenames dir_packagerpsrcr3s r. get_modulesrs.G*,''-*@ <& 8Y)Xy9  )HQK   %#C $6$89AA"&&#NK NN7[0 1! }|D]7}|j |stj|=|j |>@|S)zDremove submodules starting with name from `names` from `sys.modules`)setrrTrUrwadd)namesrrnames r.clean_sys_modulesr s`eG $ D!!$'KK( G$   Nr-c0t|dddtvS)zN rtype: bool return: True if the filename is a python source file rN)rr)rps r.is_python_sourcers H a  $ 66r-rstd_pathc|jdd} t|g}| t| St |}|j t ry|D]}|j t |syy#t$rYywxYw)aOtry to guess if a module is a standard python module (by default, see `std_path` parameter's description) :type modname: str :param modname: name of the module we are interested in :type std_path: list(str) or tuple(str) :param std_path: list of path considered as standard :rtype: bool :return: true if the module: - is located on the path listed in one of the directory in `std_path` - is a built-in module Note: this function is known to return wrong values when inside virtualenv. See https://www.logilab.org/ticket/294756. rLrFT)rNrrOr\rrw EXT_LIB_DIR)rrrprHs r.is_standard_modulers,mmC #G$gY/ )))x H;'   wt} -  s A55 BB from_filect|s t|}|tjvry t |j dd|gy#t $rYywxYw)avreturn true if the given module name is relative to the given file name :type modname: str :param modname: name of the module we are interested in :type from_file: str :param from_file: path of the module from which modname has been imported :rtype: bool :return: true if the module has been imported relatively to `from_file` FrLrT)rrrTrHr rNrO)rrs r. is_relativerHsY  I& CHHGMM#&q)I;7 sA AArc@t|dkDsJ| t||g\}}nt||\}}|tk(r |Jt |S|t k(ry|tk(r|Jt|}|S#t$rt||\}}YWwxYw#t $r|cYSwxYw)zgiven a mod path (i.e. splitted module / package name), return the corresponding file this function is used internally, see `file_from_modpath`'s documentation for more information rN) rX _module_filerOrrr'rrrl)r]rHrmtyperbs r.rres w%9<'!"+9NPXZab 1C 7#((7:K KXUUV *SXXg->> ??r-c:tduxr|tjvSr2) pkg_resources_namespace_packages)rs r.r\r\s! T!Rg1R1R&Rr-c \ tj}||ntj}|D] }||vs tj|||<"d}t|drV|dtjvrAtj|jd}t|j}|stdfSg}|r_|d} t||\} } } |rj| rhD cgc] } t| } } | jt!t| }t#|\}}}||j|kDr||fS d} |j)|jd| d}|r|t*k7r/t'ddj-|ddj-| t/t-| d 5}|j1d }dddd vrBd |vr>tjDcgc]$}t3t-|g|st-|g|&}}n| g} |r_ fS#tj $r d||<Y wxYw#t $rd}YwxYwcc} w#t$$rY&t&$rY1wxYw#t&$r|rt#|ddcYSwxYw#1swYxYwcc}w#t4$r| g}YwxYw) aget a module type / file path :type modpath: list or tuple :param modpath: splitted module's name (i.e name of a module or package splitted on '.'), with leading empty strings for explicit relative import :type path: list or None :param path: optional list of path where the module or package should be searched (use sys.path if nothing or None is given) :rtype: tuple(int, str) :return: the module type flag and the file path for a module NTFrrz No module rLrsripkgutil extend_path)rTpath_importer_cacherH zipimport zipimporterZipImportErrorr?r\rUpopr__path__rr rindexrr ValueErrorrOrWrropenreadrIOError)r]rHr_path__path checkeggsr3importedr_rbrcx fullabspath pathindexemtype emp_filenamezippathrstreamdataps r.rrs( %%(chh 'FS '"+"7"7"?CK '  WQZ WQZ3;;%>W[[^, FOO$d? "H !* "&1'4&@ #A{G [389awqz9 9  + 1 1''+:N2O PI4?4M1FL' 5;;w#77%|338"  A'   %!#((7:KSXXV^M_"`aa )${M:;-v!;;t,D- $$)>9<^1E$qJ\S[J\D]D.X.^D^'=De f + O!//'"&CK'  H:""! "7C0!44  6--_  %#} %s-H8H H8<I*I )A IJ-J ?J!J<JH51H84H55H88 II I'I'&I'*JJ JJ J+*J+c8dD]}|j|syy)zkreturn true if the given filename should be considered as a python file .pyc and .pyo are ignored )z.pyz.soz.pydz.pywTF)endswith)rprs r.rrs) .   S ! r-rcnt|d}tdzD]}t|dz|zs|dz|zcSy)z\if the given directory has a valid __init__ file, return its path, else return None r7)pycpyorLN)rrr)r mod_or_packrs r.rlrlsKy*-K.+ +#c) *$s* *+ r-)NT)NTNr2)NN)F)Tr+ __docformat__rTrtos.pathrrrrrrr r r impr r rrrdistutils.sysconfigrdistutils.errorsrtypingrrrrrrrtypesr_frozen_importlib_externalrlogilab.commonrrlogilab.common.deprecationrrrOobjectrplatformrwrPY_COMPILED_EXTS STD_LIB_DIRrdictfromkeysbuiltin_module_namesr Exceptionr'r0strintr:rMriboolrmrorfrrrrrrrrrrrrrr\rrrlr,r-r.rsC$ &    PO.3DDD1;: (<<5!"N%N d3K  -- 8 8$?9 //BBF$SM;>>BF; 9;$SM;;>; j;|<4cT#Y4&S&S&AB'`'`c3h0H'`TXY\T]'`C'`VSW.6 #Y.6&sm.6BJ3-.6 c].6b77HSM7S7vBO& &!$&19#& #Y&RERCHSMVZ[^V_@!c!4!C!0  7=H>( (!$s)U3Z"78( (V<NR #Y&sm=Ec] c]@ @ #Y @!#x ';";< @ 63  @3459b #Yb&tCy1b 5f x} ,-bJcd  # uI0KHMs6*H: I8I:IIIII I