U Ha<@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)warningfunctionr2/tmp/pip-unpacked-wheel-xuf3ljf8/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||dSN)pluginsuper Exception__init__)selfrmessage __class__rrrszPluginValidationError.__init__)__name__ __module__ __qualname____doc__r __classcell__rrr"rrsrc@s6eZdZdZddZeddZd ddZd d ZdS) DistFacadez$Emulate a pkg_resources DistributioncCs ||_dSr)_dist)r distrrrr&szDistFacade.__init__cCs |jdS)Nnamer r rrr project_name)szDistFacade.project_nameNcCst|j||Sr)getattrr*)r attrdefaultrrr __getattr__-szDistFacade.__getattr__cCstt|jddgS)Nr*r.)sorteddirr*r-rrr__dir__0szDistFacade.__dir__)N) r$r%r&r'rpropertyr.r2r5rrrrr)#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)r:) multicallspecoptsget)hookmethodskwargsrrrTsz(PluginManager.__init__..)r. _name2plugin_plugin2hookcallers_plugin_distinforZ TagTracerr>tracerr?rwarnDeprecationWarning _implprefix_inner_hookexec)r r.Z implprefixrrrrCszPluginManager.__init__cCs||||SrrJ)r r?r@rArrr _hookexecZszPluginManager._hookexecc Cs|p ||}||jks"||jkrL|j|ddkr8dStd|||jf||j|<g|j|<}t|D]}|||}|dk rlt|t||}t ||||}t|j |d}|dkrt ||j }t |j ||n|r|||||||||ql|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_namerCrDr> ValueErrorr4parse_hookimpl_optsrr/rr?rrLsetattrhas_spec _verify_hookZ_maybe_apply_history _add_hookimplappend) r rr, plugin_nameZ hookcallersZ hookimpl_optsmethodhookimplr?rrrregister_s6          zPluginManager.registercCst||}t|sdSzt||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 isinstancedictrI startswithrrH)r rr,rWresrrrrPs$   z!PluginManager.parse_hookimpl_optscCsj|dkr"|dk std||}|dkr4||}|j|rH|j|=|j|gD]}||qV|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_pluginrCr>rDpopZ_remove_plugin)r rr,Z hookcallerrrr unregisters    zPluginManager.unregistercCs|j|dd|j|<dS)zJ block registrations of the given name, unregister if already registered. r,N)rerCr r,rrr set_blockeds zPluginManager.set_blockedcCs||jko|j|dkS)z6 return ``True`` if the given plugin name is blocked. N)rCrgrrr is_blockedszPluginManager.is_blockedcCsg}t|D]~}|||}|dk r t|j|d}|dkrZt||j||}t|j||n&||||D]}| ||qn| |q |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) r4parse_hookspec_optsr/r?rrLrQZset_specification get_hookimplsrSrUrOr.)r module_or_classnamesr,Z spec_optshcZ hookfunctionrrr add_hookspecss       zPluginManager.add_hookspecscCst||}t||jddS)N_spec)r/r.)r rlr,rWrrrrjs z!PluginManager.parse_hookspec_optscCs t|jS)z' return the set of registered plugins. )setrDr-rrr get_pluginsszPluginManager.get_pluginscCs ||jkS)z6 Return ``True`` if the plugin is already registered. )rDr rrrr 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/stridrsrrrrNsz PluginManager.get_canonical_namecCs |j|S)z1 Return a plugin or ``None`` for the given name. )rCr>rgrrrrcszPluginManager.get_plugincCs||dk S)z@ Return ``True`` if a plugin with the given name is registered. N)rcrgrrr has_pluginszPluginManager.has_plugincCs(|jD]\}}||kr |Sq dS)zB Return name for registered plugin or ``None`` if not registered. N)rCitems)r rr,valrrrrbszPluginManager.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 hookwrapperrrrVr,r<Z warn_on_implrrrqargnames _formatdef)r r?rXZ notinspecrrrrSs* zPluginManager._verify_hookcCs\|jjD]N}|ddkrt|j|}|s|D] }|js4t|jd||jfq4qdS)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/rRrkZ optionalhookrr)r r,r?rXrrr check_pending s    zPluginManager.check_pendingcCsd}tD]z}|jD]n}|j|ks|dk r6|j|ks||js||jrPq|}|j||jd|j |t |f|d7}qq |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. rNrfr) importlib_metadata distributions entry_pointsgroupr,rcriloadrYrErUr))r rr,countr+eprrrrload_setuptools_entrypointss&     z)PluginManager.load_setuptools_entrypointscCs t|jS)zV return list of distinfo/plugin tuples for all setuptools registered plugins. )listrEr-rrrlist_plugin_distinfo1sz"PluginManager.list_plugin_distinfocCst|jS)z# return list of name/plugin pairs. )rrCrxr-rrrlist_name_plugin6szPluginManager.list_name_plugincCs |j|S)z0 get all hook callers for the specified plugin. )rDr>rsrrrget_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 Srrr)r? hook_implsrAoldcallrrrBOzPPluginManager.add_hookcall_monitoring..traced_hookexec..)r,rZ from_call get_result)r?rrAoutcome)afterbeforer)r?rrArtraced_hookexecMsz>PluginManager.add_hookcall_monitoring..traced_hookexeccs _dSrrKr)rr rrundoUsz3PluginManager.add_hookcall_monitoring..undorK)r rrrrr)rrrr radd_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@rAZ hooktracerrr^sz,PluginManager.enable_tracing..beforecs0|jdkrd|d|jjd8_dS)Nfinishz-->r)excinforrr)rrr@rArrrrbs z+PluginManager.enable_tracing..after)rFrr>r)r rrrrrenable_tracingZs  zPluginManager.enable_tracingcs~t|j}fdd|D}|rzt|j|j|jj|jj}|D]0}|j }||krD| ||j |g |qD|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).0Zplugrfrr ns z4PluginManager.subset_hook_caller..)r/r?rr,rLr< namespacer=rkrrTrD setdefaultrU)r r,Zremove_pluginsorigZplugins_to_removernrXrrrfrsubset_hook_calleris    z PluginManager.subset_hook_caller)N)N)NN)N)r$r%r&r'rrLrYrPrerhrirorjrrrtrNrcrwrbrSr~rrrrrrrrrrrr74s2  %  r7 signaturecCsd|jtt|fSNz%s%s)r$rur[rfuncrrrr{sr{cCsd|jtjt|fSr)r$r[ formatargspec getargspecrrrrr{s)r[sysrcallersrhooksrrrrr version_info importlibr rrrrobjectr)r7rr{rrrrs"     L