B `>W@sddlmZmZmZddlmZddlZddlmZdZ dZ Gddde Z Gd d d e Z Gd d d eZdddZdddZGddde ZGddde ZdS)) getmembersgetmroisclass) iter_modulesN) getFrameInfoZ__venusian_callbacks__Z__venusian_liftonly_callbacks__c@seZdZddZdddZdS)ScannercKs|j|dS)N)__dict__update)selfkwr Y/home/kop/projects/devel/pgwui/test_venv/lib/python3.7/site-packages/venusian/__init__.py__init__ szScanner.__init__Nc s|j|dk r*t|ts"t|ds*|g}n |dkr6g}dd|D}dd|Ddd|Ddd|Dfdd fd d }x t|D]\}}|||qWt|d rt|j|jd |d} x| D]\} } } | | } | dk rzt| dd}|dkr| j }y || }Wnt k rB|}YnXy t | Wn,t k r||dk rv|| nYnXt j| }|dk rx$t|dD]\}}|| ||qWWdt| drt| jdr| jXqWdS)aO Scan a Python package and any of its subpackages. All top-level objects will be considered; those marked with venusian callback attributes related to ``category`` will be processed. The ``package`` argument should be a reference to a Python package or module object. The ``categories`` argument should be sequence of Venusian callback categories (each category usually a string) or the special value ``None`` which means all Venusian callback categories. The default is ``None``. The ``onerror`` argument should either be ``None`` or a callback function which behaves the same way as the ``onerror`` callback function described in http://docs.python.org/library/pkgutil.html#pkgutil.walk_packages . By default, during a scan, Venusian will propagate all errors that happen during its code importing process, including :exc:`ImportError`. If you use a custom ``onerror`` callback, you can change this behavior. Here's an example ``onerror`` callback that ignores :exc:`ImportError`:: import sys def onerror(name): if not issubclass(sys.exc_info()[0], ImportError): raise # reraise the last exception The ``name`` passed to ``onerror`` is the module or package dotted name that could not be imported due to an exception. .. versionadded:: 1.0 the ``onerror`` callback The ``ignore`` argument allows you to ignore certain modules, packages, or global objects during a scan. It should be a sequence containing strings and/or callables that will be used to match against the full dotted name of each object encountered during a scan. The sequence can contain any of these three types of objects: - A string representing a full dotted name. To name an object by dotted name, use a string representing the full dotted name. For example, if you want to ignore the ``my.package`` package *and any of its subobjects or subpackages* during the scan, pass ``ignore=['my.package']``. - A string representing a relative dotted name. To name an object relative to the ``package`` passed to this method, use a string beginning with a dot. For example, if the ``package`` you've passed is imported as ``my.package``, and you pass ``ignore=['.mymodule']``, the ``my.package.mymodule`` mymodule *and any of its subobjects or subpackages* will be omitted during scan processing. - A callable that accepts a full dotted name string of an object as its single positional argument and returns ``True`` or ``False``. For example, if you want to skip all packages, modules, and global objects with a full dotted path that ends with the word "tests", you can use ``ignore=[re.compile('tests$').search]``. If the callable returns ``True`` (or anything else truthy), the object is ignored, if it returns ``False`` (or anything else falsy) the object is not ignored. *Note that unlike string matches, ignores that use a callable don't cause submodules and subobjects of a module or package represented by a dotted name to also be ignored, they match individual objects found during a scan, including packages, modules, and global objects*. You can mix and match the three types of strings in the list. For example, if the package being scanned is ``my``, ``ignore=['my.package', '.someothermodule', re.compile('tests$').search]`` would cause ``my.package`` (and all its submodules and subobjects) to be ignored, ``my.someothermodule`` to be ignored, and any modules, packages, or global objects found during the scan that have a full dotted name that ends with the word ``tests`` to be ignored. Note that packages and modules matched by any ignore in the list will not be imported, and their top-level code will not be run as a result. A string or callable alone can also be passed as ``ignore`` without a surrounding list. .. versionadded:: 1.0a3 the ``ignore`` argument N__iter__cSsg|]}t|tr|qSr ) isinstancestr).0ignr r r rsz Scanner.scan..cSsg|]}|dr|qS).) startswith)rrr r r rtscSsg|]}|ds|qS)r)r)rrr r r rvscSsg|]}t|r|qSr )callable)rrr r r rxscsZxD]}||rdSqWxD]}||r&dSq&WxD]}||rBdSqBWdS)NTF)r)fullnamer) abs_ignorescallable_ignorespkg_name rel_ignoresr r _ignorezs    zScanner.scan.._ignorec s|d|}|rdS}y t|t}||||s:dSWn dS|dkr~t|}y |Wntk r|dSXx`|D]X}||g}y0x*|D]"\}} } } | |krq|||qWWqtk rwYqXqWdS)Nr) getattr ATTACH_ATTR attached_tolistkeyssort TypeErrorget ValueError) mod_namenameobrZ category_keysattached_categoriescategory callbackscallbackZ cb_mod_nameliftidscope)r categoriesr r r invokes2      zScanner.scan..invoke__path__r)onerrorignore get_filenamefileclose)__name__rrhasattrr walk_packagesr2 find_modulerZ _get_filenamer$ __import__ Exceptionsysmodulesr%r6r7)r packager0r3r4Z str_ignoresr1r(r)resultsimportermodnameispkgloaderr5fnmoduler )rrrr0rrr r scansXY 7            z Scanner.scan)NNN)r8 __module__ __qualname__rrHr r r r r src@seZdZdZddZdS) AttachInfoa An instance of this class is returned by the :func:`venusian.attach` function. It has the following attributes: ``scope`` One of ``exec``, ``module``, ``class``, ``function call`` or ``unknown`` (each a string). This is the scope detected while executing the decorator which runs the attach function. ``module`` The module in which the decorated function was defined. ``locals`` A dictionary containing decorator frame's f_locals. ``globals`` A dictionary containing decorator frame's f_globals. ``category`` The ``category`` argument passed to ``attach`` (or ``None``, the default). ``codeinfo`` A tuple in the form ``(filename, lineno, function, sourceline)`` representing the context of the venusian decorator used. Eg. ``('/home/chrism/projects/venusian/tests/test_advice.py', 81, 'testCallInfo', 'add_handler(foo, bar)')`` cKs|j|dS)N)rr )r r r r r rszAttachInfo.__init__N)r8rIrJ__doc__rr r r r rKs$rKcs$eZdZfddZddZZS) Categoriescs4tt|t|tr ||_n t||_d|_dS)NF)superdictrrtuple attached_ididlifted)r r ) __class__r r rs   zCategories.__init__cCs(t|jtr|jt|kS|j||fkS)N)rrQintrR)r r'r(objr r r r s zCategories.attached_to)r8rIrJrr __classcell__r r )rTr rMs rMcCst|d}t|\}}}} } t|dd} t|dd} | d} d| |f}|dkr|td}|dksv|| | dst| | f}||t<||g}nBt|td}|dks|| | |st|}t |t|||g}| || ||ft |||| || dS)a Attach a callback to the wrapped object. It will be found later during a scan. This function returns an instance of the :class:`venusian.AttachInfo` class. ``category`` should be ``None`` or a string representing a decorator category name. ``name`` should be ``None`` or a string representing a subcategory within the category. This will be used by the ``lift`` class decorator to determine if decorations of a method should be inherited or overridden. rXr8Nz%s %sclass)r/rGlocalsglobalsr+codeinfo) r> _getframerrr%rr rM setdefaultsetattrappendrK)wrappedr-r+depthr(framer/rGf_locals f_globalsr] module_nameZ wrapped_name class_namer.r0r,r r r attach&s6             ric #sifddxt||D]\}}}|dk r4||r4q|ry t|Wn(tk rl|dk rf||nYqX|||fVttj|ddpg}fdd|D}x.t||d||D] }|VqWq|||fVqWdS)aYields (module_loader, name, ispkg) for all modules recursively on path, or, if path is None, all accessible modules. 'path' should be either None or a list of paths to look for modules in. 'prefix' is a string to output on the front of every module name on output. Note that this function must import all *packages* (NOT all modules!) on the given path, in order to access the __path__ attribute to find submodules. 'onerror' is a function which gets called with one argument (the name of the package which was being imported) if any exception occurs while trying to import a package. If no onerror function is supplied, any exception is exceptions propagated, terminating the search. 'ignore' is a function fed a fullly dotted name; if it returns True, the object is skipped and not returned in results (and if it's a package it's not imported). Examples: # list all modules python can access walk_packages() # list all submodules of ctypes walk_packages(ctypes.__path__, ctypes.__name__+'.') # NB: we can't just use pkgutils.walk_packages because we need to ignore # things cSs||kr dSd||<dS)NTr )pmr r r seen~szwalk_packages..seenNr2csg|]}|s|qSr r )rrk)rmr r rsz!walk_packages..r)rr<r=rr>r?r:)pathprefixr3r4rBr(rDitemr )rmr r:[s"#     r:c@s"eZdZdZdddZddZdS)lifta1 A class decorator which 'lifts' superclass venusian configuration decorations into subclasses. For example:: from venusian import lift from somepackage import venusian_decorator class Super(object): @venusian_decorator() def boo(self): pass @venusian_decorator() def hiss(self): pass @venusian_decorator() def jump(self): pass @lift() class Sub(Super): def boo(self): pass def hiss(self): pass @venusian_decorator() def smack(self): pass The above configuration will cause the callbacks of seven venusian decorators. The ones attached to Super.boo, Super.hiss, and Super.jump *plus* ones attached to Sub.boo, Sub.hiss, Sub.hump and Sub.smack. If a subclass overrides a decorator on a method, its superclass decorators will be ignored for the subclass. That means that in this configuration:: from venusian import lift from somepackage import venusian_decorator class Super(object): @venusian_decorator() def boo(self): pass @venusian_decorator() def hiss(self): pass @lift() class Sub(Super): def boo(self): pass @venusian_decorator() def hiss(self): pass Only four, not five decorator callbacks will be run: the ones attached to Super.boo and Super.hiss, the inherited one of Sub.boo and the non-inherited one of Sub.hiss. The inherited decorator on Super.hiss will be ignored for the subclass. The ``lift`` decorator takes a single argument named 'categories'. If supplied, it should be a tuple of category names. Only decorators in this category will be lifted if it is suppled. NcCs ||_dS)N)r0)r r0r r r rsz lift.__init__cCsdt|std|td}t|\}}}}}t|dd}t|} d| _xt|D]} | j t d} | dkr~| j t d} | dk rVx| D]\} } | |k r|jr| |jkrq| | g}g}xf| D]^\}}}}d}||||f}|dkrx(|D] \}}}}|dkr||krd}qW|r||qWt||}|| | <qW| jrVPqVW| r`t|t | |S)NzF"lift" only works as a class decorator; you tried to use it against %rrXr8TrZF)r RuntimeErrorr>r^rrrMrSrrr%r LIFTONLY_ATTRitemsr0rar!r`)r rbrdr/rGrerfr]rgZ newcategoriesclsr*cnamer+r,Z newcallbackscb_r.ZcscoperaZtoappendncbZnliftidZnscopeZ newcategoryr r r __call__sH        z lift.__call__)N)r8rIrJrLrrzr r r r rqs= rqc@seZdZdZddZdS)onlyliftedfroma A class decorator which marks a class as 'only lifted from'. Decorations made on methods of the class won't have their callbacks called directly, but classes which inherit from only-lifted-from classes which also use the ``lift`` class decorator will use the superclass decoration callbacks. For example:: from venusian import lift, onlyliftedfrom from somepackage import venusian_decorator @onlyliftedfrom() class Super(object): @venusian_decorator() def boo(self): pass @venusian_decorator() def hiss(self): pass @lift() class Sub(Super): def boo(self): pass def hiss(self): pass Only two decorator callbacks will be run: the ones attached to Sub.boo and Sub.hiss. The inherited decorators on Super.boo and Super.hiss will be not be registered. cCsft|std|t|td}|j}|j}|||f}|dksH|j|sLdSt|tt|t ||S)NzP"onlyliftedfrom" only works as a class decorator; you tried to use it against %r) rrrrrr8rIr delattrr`rs)r rbZcatsrhrgkeyr r r rz,s    zonlyliftedfrom.__call__N)r8rIrJrLrzr r r r r{ sr{)NrXN)NrjNN)inspectrrrpkgutilrr>Zvenusian.advicerrrsobjectrrKrOrMrir:rqr{r r r r s  c* 5 Gj