a ܌xd9@sddlZddlZddlZddlmZddlmZmZddlm Z m Z m Z m Z ej dkrdddlmZnddlZdd ZGd d d eZGd d d ZGdddZddZdS)N)_tracing)_Result _multicall)HookImpl _HookRelay _HookCallernormalize_hookimpl_opts)metadatacCs"tj|t||jj|jjddS)N)linenofilename)warnings warn_explicittype__code__co_firstlineno co_filename)warningfunctionrG/var/www/html/Ranjet/env/lib/python3.9/site-packages/pluggy/_manager.py_warn_for_functions rcs eZdZdZfddZZS)PluginValidationErrorzplugin 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__rrr szPluginValidationError.__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__1szDistFacade.__dir__)N) r%r&r'r(r propertyr/r3r6rrrrr*$s   r*c@seZdZdZddZddZd3ddZd d Zd4d d Zd dZ ddZ ddZ ddZ ddZ ddZddZddZddZdd Zd!d"Zd#d$Zd5d%d&Zd'd(Zd)d*Zd+d,Zd-d.Zd/d0Zd1d2ZdS)6 PluginManageraCore :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. cCs:||_i|_i|_g|_td|_t|_ t |_ dS)NZ pluginmanage) r/ _name2plugin_plugin2hookcallers_plugin_distinforZ TagTracergettracerhookr_inner_hookexec)r!r/rrrr DszPluginManager.__init__cCs|||||Srr?)r! hook_namemethodskwargs firstresultrrr _hookexecMszPluginManager._hookexecNc Cs|p ||}||jvs"||jvrL|j|ddur8dStd|||jf||j|<g|j|<}t|D]}|||}|durlt|t||}t ||||}|dp|}t|j |d}|durt ||j }t |j ||n |r|||||||||ql|S)zRegister 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 %sZspecname)get_canonical_namer9r:r< ValueErrorr5parse_hookimpl_optsr r0rr>rrEsetattrhas_spec _verify_hookZ_maybe_apply_history _add_hookimplappend) r!rr- plugin_nameZ hookcallersZ hookimpl_optsmethodhookimplr>rrrregisterRs8           zPluginManager.registercCs`t||}t|sdSzt||jdd}WntyDi}Yn0|dur\t|ts\d}|S)N_impl)r0inspect isroutiner/r isinstancedict)r!rr-rPresrrrrIxs    z!PluginManager.parse_hookimpl_optscCsj|dur"|dusJd||}|dur4||}|j|rH|j|=|j|gD]}||qV|S)zlunregister a plugin object and all its contained hook implementations from internal data structures.Nz+one of name or plugin needs to be specified)get_name get_pluginr9r<r:popZ_remove_plugin)r!rr-Z hookcallerrrr unregisters    zPluginManager.unregistercCs|j|dd|j|<dS)zHblock registrations of the given name, unregister if already registered.r-N)r\r9r!r-rrr set_blockeds zPluginManager.set_blockedcCs||jvo|j|duS)z4return ``True`` if the given plugin name is blocked.N)r9r^rrr is_blockedszPluginManager.is_blockedcCsg}t|D]~}|||}|dur t|j|d}|durZt||j||}t|j||n&||||D]}| ||qn| |q |st d|j d|dS)zadd new hook specifications defined in the given ``module_or_class``. Functions are recognized if they have been decorated accordingly.Nzdid not find any z hooks in ) r5parse_hookspec_optsr0r>rrErJZset_specification get_hookimplsrLrNrHr/)r!module_or_classnamesr-Z spec_optshcZ hookfunctionrrr add_hookspecss      zPluginManager.add_hookspecscCst||}t||jddS)N_spec)r0r/)r!rcr-rPrrrras z!PluginManager.parse_hookspec_optscCs t|jS)z%return the set of registered plugins.)setr:r.rrr get_pluginsszPluginManager.get_pluginscCs ||jvS)z4Return ``True`` if the plugin is already registered.)r:r!rrrr is_registeredszPluginManager.is_registeredcCst|ddptt|S)aVReturn 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)r0stridrjrrrrGsz PluginManager.get_canonical_namecCs |j|S)z/Return a plugin or ``None`` for the given name.)r9r<r^rrrrZszPluginManager.get_plugincCs||duS)z>Return ``True`` if a plugin with the given name is registered.N)rZr^rrr has_pluginszPluginManager.has_plugincCs(|jD]\}}||kr |Sq dS)z@Return name for registered plugin or ``None`` if not registered.N)r9items)r!rr-valrrrrYszPluginManager.get_namecCs|r&|jr&t|jd|j|jf|jjr>t|jj|j t |j t |jj }|rzt|jd|j|jt |j |f|jrt |j st|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 hookspeczsPlugin %r for hook %r hookimpl definition: %s Declared as hookwrapper=True but function is not a generator function)Z is_historicZ hookwrapperrrrOr-specZ warn_on_implrrrhargnames _formatdefrTisgeneratorfunction)r!r>rQZ notinspecrrrrLs8  zPluginManager._verify_hookcCs\|jjD]N}|ddkrt|j|}|s|D] }|js4t|jd||jfq4qdS)zVerify 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__r0rKrbZ optionalhookrr)r!r-r>rQrrr check_pendings    zPluginManager.check_pendingcCsd}ttD]z}|jD]n}|j|ks|dur:|j|ks||js||jrTq|}|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. rNr]r) listimportlib_metadata distributions entry_pointsgroupr-rZr`loadrRr;rNr*)r!r|r-countr,eprrrrload_setuptools_entrypoints s&    z)PluginManager.load_setuptools_entrypointscCs t|jS)zTreturn list of distinfo/plugin tuples for all setuptools registered plugins.)rxr;r.rrrlist_plugin_distinfo%sz"PluginManager.list_plugin_distinfocCst|jS)z!return list of name/plugin pairs.)rxr9ror.rrrlist_name_plugin*szPluginManager.list_name_plugincCs |j|S)z.get all hook callers for the specified plugin.)r:r<rjrrrget_hookcallers.szPluginManager.get_hookcallerscs.jfdd}|_fdd}|S)aPadd 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<tfdd}||S)NcsSrrr)rD hook_implsrArColdcallrrDzPPluginManager.add_hookcall_monitoring..traced_hookexec..)rZ from_call get_result)rArrCrDoutcome)afterbeforer)rDrrArCrtraced_hookexecAs  z>PluginManager.add_hookcall_monitoring..traced_hookexeccs _dSrr@r)rr!rrundoKsz3PluginManager.add_hookcall_monitoring..undor@)r!rrrrr)rrrr!radd_hookcall_monitoring2s z%PluginManager.add_hookcall_monitoringcs2|jjdfdd}fdd}|||S)z9enable tracing of hook calls and return an undo function.r>csjjd7_||dS)Nr)rootindent)rArBrCZ hooktracerrrTsz,PluginManager.enable_tracing..beforecs0|jdurd|d|jjd8_dS)Nfinishz-->r)excinforrr)rrArBrCrrrrXs z+PluginManager.enable_tracing..after)r=rr<r)r!rrrrrenable_tracingPs  zPluginManager.enable_tracingcs~t|j}fdd|D}|rzt|j|j|jj|jj}|D]0}|j }||vrD| ||j |g |qD|S|S)zReturn 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).0Zplugr]rr drz4PluginManager.subset_hook_caller..)r0r>rr-rErq namespaceoptsrbrrMr: setdefaultrN)r!r-Zremove_pluginsorigZplugins_to_removererQrrr]rsubset_hook_caller_s   z PluginManager.subset_hook_caller)N)NN)N)r%r&r'r(r rErRrIr\r_r`rfrarirkrGrZrnrYrLrwrrrrrrrrrrrr85s2  & # r8cCs|jt|Sr)r%rT signature)funcrrrrstsrs)rTsysrrZ_callersrrZ_hooksrrrr version_info importlibr ryrrrr*r8rsrrrrs    A