B `<@sddlZddlZddlmZddlmZddlmZmZm Z m Z ddl Z ej dkr`ddl mZnddlZdd ZGd d d eZGd d d eZGdddeZeedrddZnddZdS)N)_tracing)_Result)HookImpl _HookRelay _HookCallernormalize_hookimpl_opts))metadatacCs"tj|t||jj|jjddS)N)linenofilename)warnings warn_explicittype__code__co_firstlineno co_filename)warningfunctionrV/home/kop/projects/devel/pgwui/test_venv/lib/python3.7/site-packages/pluggy/manager.py_warn_for_functions rcs eZdZdZfddZZS)PluginValidationErrorz plugin failed validation. :param object plugin: the plugin which failed validation, may be a module or an arbitrary object. cs||_tt||dS)N)pluginsuper Exception__init__)selfrmessage) __class__rrrszPluginValidationError.__init__)__name__ __module__ __qualname____doc__r __classcell__rr)r rrsrc@s6eZdZdZddZeddZd ddZd d ZdS) DistFacadez$Emulate a pkg_resources DistributioncCs ||_dS)N)_dist)rdistrrrr&szDistFacade.__init__cCs |jdS)Nname)r )rrrr project_name)szDistFacade.project_nameNcCst|j||S)N)getattrr')rattrdefaultrrr __getattr__-szDistFacade.__getattr__cCstt|jddgS)Nr'r*)sorteddirr')rrrr__dir__0szDistFacade.__dir__)N) r!r"r#r$rpropertyr*r.r1rrrrr&#s   r&c@seZdZdZd3ddZddZd4ddZd d Zd5d d Zd dZ ddZ ddZ ddZ ddZ ddZddZddZddZdd Zd!d"Zd#d$Zd6d%d&Zd'd(Zd)d*Zd+d,Zd-d.Zd/d0Zd1d2ZdS)7 PluginManagera Core :py:class:`.PluginManager` class which manages registration of plugin objects and 1:N hook calling. You can register new hooks by calling :py:meth:`add_hookspecs(module_or_class) <.PluginManager.add_hookspecs>`. You can register plugin objects (which contain hooks) by calling :py:meth:`register(plugin) <.PluginManager.register>`. The :py:class:`.PluginManager` is initialized with a prefix that is searched for in the names of the dict of registered plugin objects. For debugging purposes you can call :py:meth:`.PluginManager.enable_tracing` which will subsequently send debug information to the trace helper. NcCs\||_i|_i|_g|_td|_t|_ |dk rHt j dt dd||_ dd|_dS)zyIf ``implprefix`` is given implementation functions will be recognized if their name matches the ``implprefix``. Z pluginmanageNzySupport for the `implprefix` arg is now deprecated and will be removed in an upcoming release. Please use HookimplMarker.) stacklevelcSs$|j|||jr|jjdnddS)N firstresultF)r6) multicallspecoptsget)hookmethodskwargsrrrTsz(PluginManager.__init__..)r* _name2plugin_plugin2hookcallers_plugin_distinforZ TagTracerr:tracerr;rwarnDeprecationWarning _implprefix_inner_hookexec)rr*Z implprefixrrrrCszPluginManager.__init__cCs||||S)N)rF)rr;r<r=rrr _hookexecZszPluginManager._hookexecc Cs|p ||}||jks"||jkrL|j|ddkr8dStd|||jf||j|<g|j|<}xt|D]}|||}|dk rnt|t||}t ||||}t|j |d}|dkrt ||j }t |j ||n|r|||||||||qnW|S)z Register a plugin and return its canonical name or ``None`` if the name is blocked from registering. Raise a :py:class:`ValueError` if the plugin is already registered. Nz#Plugin already registered: %s=%s %s)get_canonical_namer?r@r: ValueErrorr0parse_hookimpl_optsrr+rr;rrGsetattrhas_spec _verify_hookZ_maybe_apply_history _add_hookimplappend) rrr) plugin_nameZ hookcallersZ hookimpl_optsmethodhookimplr;rrrregister_s2       zPluginManager.registercCst||}t|sdSyt||jdd}Wntk rFi}YnX|dk r`t|ts`d}n,|dkr|jr||jrt t d|i}|S)N_implzhThe `implprefix` system is deprecated please decorate this function using an instance of HookimplMarker.) r+inspect isroutiner*r isinstancedictrE startswithrrD)rrr)rRresrrrrKs    z!PluginManager.parse_hookimpl_optscCsn|dkr"|dk std||}|dkr4||}|j|rH|j|=x |j|gD]}||qXW|S)zn unregister a plugin object and all its contained hook implementations from internal data structures. Nz+one of name or plugin needs to be specified)AssertionErrorget_name get_pluginr?r:r@popZ_remove_plugin)rrr)Z hookcallerrrr unregisters   zPluginManager.unregistercCs|j|dd|j|<dS)zJ block registrations of the given name, unregister if already registered. )r)N)r`r?)rr)rrr set_blockeds zPluginManager.set_blockedcCs||jko|j|dkS)z6 return ``True`` if the given plugin name is blocked. N)r?)rr)rrr is_blockedszPluginManager.is_blockedcCsg}xt|D]}|||}|dk rt|j|d}|dkr\t||j||}t|j||n*|||x|D]}| ||qrW| |qW|st d|j |fdS)z add new hook specifications defined in the given ``module_or_class``. Functions are recognized if they have been decorated accordingly. Nzdid not find any %r hooks in %r) r0parse_hookspec_optsr+r;rrGrLZset_specification get_hookimplsrNrPrJr*)rmodule_or_classnamesr)Z spec_optshcZ hookfunctionrrr add_hookspecss  zPluginManager.add_hookspecscCst||}t||jddS)N_spec)r+r*)rrer)rRrrrrcs z!PluginManager.parse_hookspec_optscCs t|jS)z' return the set of registered plugins. )setr@)rrrr get_pluginsszPluginManager.get_pluginscCs ||jkS)z6 Return ``True`` if the plugin is already registered. )r@)rrrrr is_registeredszPluginManager.is_registeredcCst|ddptt|S)aW Return canonical name for a plugin object. Note that a plugin may be registered under a different name which was specified by the caller of :py:meth:`register(plugin, name) <.PluginManager.register>`. To obtain the name of an registered plugin use :py:meth:`get_name(plugin) <.PluginManager.get_name>` instead.r!N)r+strid)rrrrrrIsz PluginManager.get_canonical_namecCs |j|S)z1 Return a plugin or ``None`` for the given name. )r?r:)rr)rrrr^szPluginManager.get_plugincCs||dk S)z@ Return ``True`` if a plugin with the given name is registered. N)r^)rr)rrr has_pluginszPluginManager.has_plugincCs(x"|jD]\}}||kr |Sq WdS)zB Return name for registered plugin or ``None`` if not registered. N)r?items)rrr)valrrrr]szPluginManager.get_namecCs~|r&|jr&t|jd|j|jf|jjr>t|jj|j t |j t |jj }|rzt|jd|j|jt |j |fdS)Nz6Plugin %r hook %r historic incompatible to hookwrapperz~Plugin %r for hook %r hookimpl definition: %s Argument(s) %s are declared in the hookimpl but can not be found in the hookspec) Z is_historicZ hookwrapperrrrQr)r8Z warn_on_implrrrjargnames _formatdef)rr;rSZ notinspecrrrrNs zPluginManager._verify_hookcCsdx^|jjD]R}|ddkr t|j|}|s x,|D] }|js8t|jd||jfq8Wq WdS)z Verify that all hooks which have not been verified against a hook specification are optional, otherwise raise :py:class:`.PluginValidationError`.r_zunknown hook %r in plugin %rN)r;__dict__r+rMrdZ optionalhookrr)rr)r;rSrrr check_pending s  zPluginManager.check_pendingcCsd}xtD]~}xx|jD]n}|j|ks|dk r:|j|ks||js||jrTq|}|j||jd|j |t |f|d7}qWqW|S)a+ Load modules from querying the specified setuptools ``group``. :param str group: entry point group to load plugins :param str name: if given, loads only plugins with the given ``name``. :rtype: int :return: return the number of loaded plugins by this call. rN)r)r) importlib_metadata distributionsZ entry_pointsgroupr)r^rbloadrTrArPr&)rryr)countr(eprrrrload_setuptools_entrypointss    z)PluginManager.load_setuptools_entrypointscCs t|jS)zV return list of distinfo/plugin tuples for all setuptools registered plugins. )listrA)rrrrlist_plugin_distinfo1sz"PluginManager.list_plugin_distinfocCst|jS)z# return list of name/plugin pairs. )r~r?rp)rrrrlist_name_plugin6szPluginManager.list_name_plugincCs |j|S)z0 get all hook callers for the specified plugin. )r@r:)rrrrrget_hookcallers:szPluginManager.get_hookcallerscs.jfdd}|_fdd}|S)aP add before/after tracing functions for all hooks and return an undo function which, when called, will remove the added tracers. ``before(hook_name, hook_impls, kwargs)`` will be called ahead of all hook calls and receive a hookcaller instance, a list of HookImpl instances and the keyword arguments for the hook call. ``after(outcome, hook_name, hook_impls, kwargs)`` receives the same arguments as ``before`` but also a :py:class:`pluggy.callers._Result` object which represents the result of the overall hook call. cs>jtfdd}|j|S)Ncs S)Nrr)r; hook_implsr=oldcallrrr>OzPPluginManager.add_hookcall_monitoring..traced_hookexec..)r)rZ from_call get_result)r;rr=outcome)afterbeforer)r;rr=rtraced_hookexecMsz>PluginManager.add_hookcall_monitoring..traced_hookexeccs _dS)N)rFr)rrrrundoUsz3PluginManager.add_hookcall_monitoring..undo)rF)rrrrrr)rrrrradd_hookcall_monitoring>s z%PluginManager.add_hookcall_monitoringcs2|jjdfdd}fdd}|||S)z; enable tracing of hook calls and return an undo function. r;csjjd7_||dS)Nr)rootindent) hook_namer<r=) hooktracerrr^sz,PluginManager.enable_tracing..beforecs0|jdkrd|d|jjd8_dS)Nfinishz-->r)excinforrr)rrr<r=)rrrrbs z+PluginManager.enable_tracing..after)rBrr:r)rrrr)rrenable_tracingZs  zPluginManager.enable_tracingcst|j}fdd|D}|r~t|j|j|jj|jj}x<|D]0}|j }||krF| ||j |g |qFW|S|S)z Return a new :py:class:`.hooks._HookCaller` instance for the named method which manages calls to all registered plugins except the ones from remove_plugins. csg|]}t|r|qSr)hasattr).0Zplug)r)rr nsz4PluginManager.subset_hook_caller..)r+r;rr)rGr8 namespacer9rdrrOr@ setdefaultrP)rr)Zremove_pluginsorigZplugins_to_removergrSrr)r)rsubset_hook_calleris  z PluginManager.subset_hook_caller)N)N)NN)N)r!r"r#r$rrGrTrKr`rarbrhrcrkrlrIr^ror]rNrvr}rrrrrrrrrrr34s2   %  r3 signaturecCsd|jtt|fS)Nz%s%s)r!rmrVr)funcrrrrssrscCsd|jtjt|fS)Nz%s%s)r!rV formatargspec getargspec)rrrrrss)rVsysrcallersrhooksrrrrr version_info importlibr rwrrrobjectr&r3rrsrrrrs"     L