IR-e;dZddlZddlZddlZddlZddlZddlZddlmZddlm Z ddl m Z gdZ dgZ ejddd krdd lmZnd Zd Ze d ddddZddZdZddZdZdZdS)z2Functions related to Python runtime introspection.N)metadata)Version)deprecated_renamed_argument) resolve_name minversionfind_current_moduleisinstancemethodr) )packages_distributionsc"tjt}tjD]T}|dpdD](}|||jd)Ut|S)z Return a mapping of top-level packages to their distributions. Note: copied from https://github.com/python/importlib_metadata/pull/287. z top_level.txtName) collections defaultdictlistr distributions read_textsplitappenddict) pkg_to_distdistpkgs ;lib/python3.11/site-packages/astropy/utils/introspection.pyr r s "-d33 *,, ? ?D77=2DDFF ? ?C '' f(=>>>> ?K   c$d|}|r|dz|z}|d}t|dkrd}g}nt|dz }|dg}|d|}|dkr] td||}n7#t$r$|dkr|dz}|d|}||g}d}YnwxYw|dk]||dD]0} t ||}#t $rt |wxYw|S)a!Resolve a name like ``module.object`` to an object and return it. This ends up working like ``from module import object`` but is easier to deal with than the `__import__` builtin and supports digging into submodules. Parameters ---------- name : `str` A dotted path to a Python object--that is, the name of a function, class, or other object in a module with the full path to that module, including parent modules, separated by dots. Also known as the fully qualified name of the object. additional_parts : iterable, optional If more than one positional arguments are given, those arguments are automatically dotted together with ``name``. Examples -------- >>> resolve_name('astropy.utils.introspection.resolve_name') >>> resolve_name('astropy', 'utils', 'introspection', 'resolve_name') Raises ------ `ImportError` If the module or named object is not found. .Nr)fromlistr)joinrlen __import__ ImportErrorgetattrAttributeError)nameadditional_partspartscursorr" module_nameretparts rrr$si>xx 011-cz,, JJsOOE 5zzQUa"I;.K 1** SXXk22XFFFC    {{ aKF.Kf HCCC   1**fgg$$ $#t$$CC $ $ $d## # $ Js9$B+C  C "C33D  version_pathz5.0T __version__cVt|tjr|j}t |dd}nZt|t r&|}d} t |}n0#t$rYdSwxYwtdt||Y tj |}nC#tj $r1t}tj ||d}YnwxYw|r t|t|kSt|t|kS)aa Returns `True` if the specified Python module satisfies a minimum version requirement, and `False` if not. .. deprecated:: ``version_path`` is not used anymore and is deprecated in ``astropy`` 5.0. Parameters ---------- module : module or `str` An imported module of which to check the version, or the name of that module (in which case an import of that module is attempted-- if this fails `False` is returned). version : `str` The version as a string that this module must have at a minimum (e.g. ``'0.12'``). inclusive : `bool` The specified version meets the requirement inclusively (i.e. ``>=``) as opposed to strictly greater than (default: `True`). Examples -------- >>> import astropy >>> minversion(astropy, '0.4.4') True r1NFzYmodule argument must be an actual imported module, or the import name of the module; got r) isinstancetypes ModuleType__name__r'strrr& ValueErrorreprrversionPackageNotFoundErrorr r)moduler: inclusiver0r-module_version dist_namess rrris^>&%*++ o  == FC    !+..FF   55  "<< " "    J%-k::NN, J J J 011J%-j.Ea.HIINNN  J:~&&''*:*:::~&&)9)999s$A A,+A,B&&=C&%C&r Fc,tj}t|D]}|j}|dS|rt |}|dur|g}ng}|D]}tj|r||,t|tr(|tj |i|dur||td|r"|j}t |}||vr|S|}| dSdSt |S)a Determines the module/package from which this function is called. This function has two modes, determined by the ``finddiff`` option. it will either simply go the requested number of frames up the call stack (if ``finddiff`` is False), or it will go up the call stack until it reaches a module that is *not* in a specified set. Parameters ---------- depth : int Specifies how far back to go in the call stack (0-indexed, so that passing in 0 gives back `astropy.utils.misc`). finddiff : bool or list If False, the returned ``mod`` will just be ``depth`` frames up from the current frame. Otherwise, the function will start at a frame ``depth`` up from current, and continue up the call stack to the first module that is *different* from those in the provided list. In this case, ``finddiff`` can be a list of modules or modules names. Alternatively, it can be True, which will use the module ``depth`` call stack frames up as the module the returned module most be different from. Returns ------- mod : module or None The module object or None if the package cannot be found. The name of the module is available as the ``__name__`` attribute of the returned object (if it isn't None). Raises ------ ValueError If ``finddiff`` is a list with an invalid entry. Examples -------- The examples below assume that there are two modules in a package named ``pkg``. ``mod1.py``:: def find1(): from astropy.utils import find_current_module print find_current_module(1).__name__ def find2(): from astropy.utils import find_current_module cmod = find_current_module(2) if cmod is None: print 'None' else: print cmod.__name__ def find_diff(): from astropy.utils import find_current_module print find_current_module(0,True).__name__ ``mod2.py``:: def find(): from .mod1 import find2 find2() With these modules in place, the following occurs:: >>> from pkg import mod1, mod2 >>> from astropy.utils import find_current_module >>> mod1.find1() pkg.mod1 >>> mod1.find2() None >>> mod2.find() pkg.mod2 >>> find_current_module(0) >>> mod1.find_diff() pkg.mod1 NTzinvalid entry in finddiff) inspect currentframerangef_back_get_module_from_frameismodulerr3r7 importlib import_moduler8) depthfinddifffrmicurrmoddiffmodsfdfrmbmodbs rrrsiZ   C 5\\j ;44 +(-- t  yHHH B B#B''BOOB''''C((BOOI$;B$?$?@@@@4ZZOOG,,,,$%@AAA :D)$//D8## C      &c***rctj|}||Sd|jvrd|jvr|jd}|dddvr |dddz}tjtj|}|tjvr/tj tj|S|tjvrAtj tj|SdS)aUUses inspect.getmodule() to get the module that the current frame's code is running in. However, this does not work reliably for code imported from a zip file, so this provides a fallback mechanism for that case which is less reliable in general, but more reliable than inspect.getmodule() for this particular case. N__file__r6)z.pycz.pyoz.py) rA getmodule f_globalslowerospathrealpathabspath modulesbyfilesysmodulesget)rKmodfilenames rrErEs   C C  S]""zS]'B'B=, BCC=   $4 4 4}u,H7##BGOOH$=$=>> w, , ,;??7#8#BCC C >>  w4 4 4;??7#89I9I#JKK K 4rc t| t dr fd jD}n fdt D}tjfd|D}fd|D}g}t ||D]f\}}t|dr6t|dr&||jdz|j zK||dz|zgrfd ur|gfd |D fd t|D} fd t|D} fd t|D}|||fS)aReturns all the public attributes of a module referenced by name. .. note:: The returned list *not* include subpackages or modules of ``modname``, nor does it include private attributes (those that begin with '_' or are not in `__all__`). Parameters ---------- modname : str The name of the module to search. onlylocals : bool or list of str If `True`, only attributes that are either members of ``modname`` OR one of its modules or subpackages will be included. If it is a list of strings, those specify the possible packages that will be considered "local". Returns ------- localnames : list of str A list of the names of the attributes as they are named in the module ``modname`` . fqnames : list of str A list of the full qualified names of the attributes (e.g., ``astropy.utils.introspection.find_mod_objs``). For attributes that are simple variables, this is based on the local name, but for functions or classes it can be different if they are actually defined elsewhere and just referenced in ``modname``. objs : list of objects A list of the actual attributes themselves (in the same order as the other arguments) __all__c.g|]}|j|fS__dict__.0kr`s r z!find_mod_objs..es$>>>QQ Q(>>>rcFg|]}|ddk|j|fS)r_rfrhs rrkz!find_mod_objs..gs-JJJQadckkQ Q(kkkrc0g|]\}}||SrererirjvrFs rrkz!find_mod_objs..ks*<<<1 .ls* 6 6 6$!Q((1++ 6A 6 6 6r __module__r6rTcHg|]tfdDS)c3BK|]}|VdS)N) startswith)rinmfqns r z+find_mod_objs...ys/>>RcnnR((>>>>>>r)any)rirw onlylocalss @rrkz!find_mod_objs..ys7RRR3#>>>>:>>>>>RRRrc*g|]\}}| |SrererirLevalidss rrkz!find_mod_objs..zs&GGGDAqVAYGaGGGrc*g|]\}}| |Srerer|s rrkz!find_mod_objs..{s&AAAAvayA1AAArc*g|]\}}| |Srerer|s rrkz!find_mod_objs..|s&;;;da;;;;r) rhasattrrcdirrArFziprrrr6 enumerate) modnamerzpkgitems localnamesobjsfqnamesobjlnmrFr`r~s ` @@@r find_mod_objsr@sD w  CsIK>>>>#+>>>JJJJ#c((JJJH<<<<<<C/#,> ? ? ? ? NN7S=3. / / / /<   !JRRRR'RRRGGGGIj$9$9GGG AAAA7!3!3AAA;;;;ioo;;; w $$rc"t||S)a Returns `True` if the given object is an instance method of the class it is defined on (as opposed to a `staticmethod` or a `classmethod`). This requires both the class the object is a member of as well as the object itself in order to make this determination. Parameters ---------- cls : `type` The class on which this method was defined. obj : `object` A member of the provided class (the membership is not checked directly, but this function will always return `False` if the given object is not a member of the given class). Examples -------- >>> class MetaClass(type): ... def a_classmethod(cls): pass ... >>> class MyClass(metaclass=MetaClass): ... def an_instancemethod(self): pass ... ... @classmethod ... def another_classmethod(cls): pass ... ... @staticmethod ... def a_staticmethod(): pass ... >>> isinstancemethod(MyClass, MyClass.a_classmethod) False >>> isinstancemethod(MyClass, MyClass.another_classmethod) False >>> isinstancemethod(MyClass, MyClass.a_staticmethod) False >>> isinstancemethod(MyClass, MyClass.an_instancemethod) True )_isinstancemethod)clsrs rr r sP S# & &&rct|tjsdS|j}|D].}||jvr#t|j|t  cS/t|)NF)r3r4 FunctionTyper6mrorg staticmethodr()rrr)baseclss rrrs c5- . .u rsw88 %%%%%%@@@@@@ S S S)*BQB7""9999999 ! ! !BBBJ^T599=:=:=::9=:@j+j+j+j+Z&&&R>%>%>%>%F('('('Vr