@^Yc@sdZddlZddlZdZdddddgZejd d fkZdfd YZdfd YZd Z dfdYZ dfdYZ dZ dZ dfdYZe rddUndfdYZdefdYZdfdYZedZdfdYZdefd YZd!fd"YZdefd#YZdefd$YZeed%rd&Zn d'ZdS((s9 PluginManager, basic initialization and tracing. pluggy is the cristallized core of plugin management as used by some 150 plugins for pytest. Pluggy uses semantic versioning. Breaking changes are only foreseen for Major releases (incremented X in "X.Y.Z"). If you want to use pluggy in your project you should thus use a dependency restriction like "pluggy>=0.1.0,<1.0" to avoid surprises. pluggy is concerned with hook specification, hook implementations and hook calling. For any given hook specification a hook call invokes up to N implementations. A hook implementation can influence its position and type of execution: if attributed "tryfirst" or "trylast" it will be tried to execute first or last. However, if attributed "hookwrapper" an implementation can wrap all calls to non-hookwrapper implementations. A hookwrapper can thus execute some code ahead and after the execution of other hooks. Hook specification is done by way of a regular python function where both the function name and the names of all its arguments are significant. Each hook implementation function is verified against the original specification function, including the names of all its arguments. To allow for hook specifications to evolve over the livetime of a project, hook implementations can accept less arguments. One can thus add new arguments and semantics to a hook specification by adding another argument typically without breaking existing hook implementations. The chosen approach is meant to let a hook designer think carefuly about which objects are needed by an extension writer. By contrast, subclass-based extension mechanisms often expose a lot more state and behaviour than needed, thus restricting future developments. Pluggy currently consists of functionality for: - a way to register new hook specifications. Without a hook specification no hook calling can be performed. - a registry of plugins which contain hook implementation functions. It is possible to register plugins for which a hook specification is not yet known and validate all hooks when the system is in a more referentially consistent state. Setting an "optionalhook" attribution to a hook implementation will avoid PluginValidationError's if a specification is missing. This allows to have optional integration between plugins. - a "hook" relay object from which you can launch 1:N calls to registered hook implementation functions - a mechanism for ordering hook implementation functions - mechanisms for two different type of 1:N calls: "firstresult" for when the call should stop when the first implementation returns a non-None result. And the other (default) way of guaranteeing that all hook implementations will be called and their non-None result collected. - mechanisms for "historic" extension points such that all newly registered functions will receive all hook calls that happened before their registration. - a mechanism for discovering plugin objects which are based on setuptools based entry points. - a simple tracing mechanism, including tracing of plugin calls and their arguments. iNs0.4.0t PluginManagertPluginValidationErrort HookCallErrortHookspecMarkertHookimplMarkeriicBs)eZdZdZdeedZRS(s Decorator helper class for marking functions as hook specifications. You can instantiate it with a project_name to get a decorator. Calling PluginManager.add_hookspecs later will discover all marked functions if the PluginManager uses the same project_name. cCs ||_dS(N(t project_name(tselfR((s&/tmp/pip-build-UnxK1c/pluggy/pluggy.pyt__init__Vscs3fd}|dk r+||S|SdS(sA if passed a function, directly sets attributes on the function which will make it discoverable to add_hookspecs(). If passed no function, returns a decorator which can be applied to a function later using the attributes supplied. If firstresult is True the 1:N hook call (N being the number of registered hook implementation functions) will stop at I<=N when the I'th function returns a non-None result. If historic is True calls to a hook will be memorized and replayed on later registered plugins. csErrtdnt|jdtdd|S(Ns'cannot have a historic firstresult hookt_spect firstresultthistoric(t ValueErrortsetattrRtdict(tfunc(R R R(s&/tmp/pip-build-UnxK1c/pluggy/pluggy.pytsetattr_hookspec_optsgs  N(tNone(RtfunctionR R R((R R Rs&/tmp/pip-build-UnxK1c/pluggy/pluggy.pyt__call__Ys  N(t__name__t __module__t__doc__RRtFalseR(((s&/tmp/pip-build-UnxK1c/pluggy/pluggy.pyRNs cBs/eZdZdZdeeeedZRS(s  Decorator helper class for marking functions as hook implementations. You can instantiate with a project_name to get a decorator. Calling PluginManager.register later will discover all marked functions if the PluginManager uses the same project_name. cCs ||_dS(N(R(RR((s&/tmp/pip-build-UnxK1c/pluggy/pluggy.pyR{scs9fd}|dkr+|S||SdS(s if passed a function, directly sets attributes on the function which will make it discoverable to register(). If passed no function, returns a decorator which can be applied to a function later using the attributes supplied. If optionalhook is True a missing matching hook specification will not result in an error (by default it is an error if no matching spec is found). If tryfirst is True this hook implementation will run as early as possible in the chain of N hook implementations for a specfication. If trylast is True this hook implementation will run as late as possible in the chain of N hook implementations. If hookwrapper is True the hook implementations needs to execute exactly one "yield". The code before the yield is run early before any non-hookwrapper function is run. The code after the yield is run after all non-hookwrapper function have run. The yield receives an ``_CallOutcome`` object representing the exception or result outcome of the inner calls (including other hookwrapper calls). c s6t|jdtdddd|S(Nt_implt hookwrappert optionalhookttryfirstttrylast(R RR (R(RRRRR(s&/tmp/pip-build-UnxK1c/pluggy/pluggy.pytsetattr_hookimpl_optssN(R(RRRRRRR((RRRRRs&/tmp/pip-build-UnxK1c/pluggy/pluggy.pyR~s N(RRRRRRR(((s&/tmp/pip-build-UnxK1c/pluggy/pluggy.pyRts  cCsD|jdt|jdt|jdt|jdtdS(NRRRR(t setdefaultR(topts((s&/tmp/pip-build-UnxK1c/pluggy/pluggy.pytnormalize_hookimpl_optsst _TagTracercBs>eZdZdZdZdZdZdZRS(cCsi|_d|_d|_dS(Ni(t _tag2procRtwritertindent(R((s&/tmp/pip-build-UnxK1c/pluggy/pluggy.pyRs  cCst||fS(N(t _TagTracerSub(Rtname((s&/tmp/pip-build-UnxK1c/pluggy/pluggy.pytgetsc Cst|dtr*|d}|d }ni}djtt|}d|j}d||dj|fg}x4|jD]&\}}|jd|||fqW|S(Nit s s %s%s [%s] t:s %s %s: %s (t isinstanceR tjointmaptstrR#titemstappend( RttagstargstextratcontentR#tlinesR%tvalue((s&/tmp/pip-build-UnxK1c/pluggy/pluggy.pytformat_messages   cCsp|jdk r@|r@|j||}|jdj|ny|j|||Wntk rknXdS(Nt(R"RR5R*R!tKeyError(RR/R0R3((s&/tmp/pip-build-UnxK1c/pluggy/pluggy.pytprocessmessages cCs ||_dS(N(R"(RR"((s&/tmp/pip-build-UnxK1c/pluggy/pluggy.pyt setwriterscCsMt|tr't|jd}nt|ts<t||j|(((s&/tmp/pip-build-UnxK1c/pluggy/pluggy.pyR s     R$cBs,eZdZdZdZdZRS(cCs||_||_dS(N(trootR/(RR?R/((s&/tmp/pip-build-UnxK1c/pluggy/pluggy.pyRs cGs|jj|j|dS(N(R?R8R/(RR0((s&/tmp/pip-build-UnxK1c/pluggy/pluggy.pyRscCs|jj|j|dS(N(R?R>R/(RR=((s&/tmp/pip-build-UnxK1c/pluggy/pluggy.pytsetmyprocessorscCs|j|j|j|fS(N(t __class__R?R/(RR%((s&/tmp/pip-build-UnxK1c/pluggy/pluggy.pyR&s(RRRRR@R&(((s&/tmp/pip-build-UnxK1c/pluggy/pluggy.pyR$s   cCs2|j}td|j|j|j|fdS(Nswrap_controller at %r %s:%d %s(tgi_codet RuntimeErrortco_namet co_filenametco_firstlineno(twrap_controllertmsgtco((s&/tmp/pip-build-UnxK1c/pluggy/pluggy.pyt_raise_wrapfails cCswyt|Wntk r.t|dnXt|}y|j|t|dWntk rlnX|jS(s0 Wrap calling to a function with a generator which needs to yield exactly once. The yield point will trigger calling the wrapped function and return its _CallOutcome to the yield point. The generator then needs to finish (raise StopIteration) in order for the wrapped call to complete. s did not yieldshas second yield(tnextt StopIterationRJt _CallOutcometsendt get_result(RGRt call_outcome((s&/tmp/pip-build-UnxK1c/pluggy/pluggy.pyt _wrapped_calls    RMcBs/eZdZdZdZdZdZRS(s Outcome of a function call, either an exception or a proper result. Calling the ``get_result`` method will return the result or reraise the exception raised when the function was called. cCs7y||_Wn tk r2tj|_nXdS(N(tresultt BaseExceptiontsystexc_infotexcinfo(RR((s&/tmp/pip-build-UnxK1c/pluggy/pluggy.pyRs cCs||_d|_dS(N(RRRRV(RRR((s&/tmp/pip-build-UnxK1c/pluggy/pluggy.pyt force_result s cCsM|jdkr|jS|j}tr?|dj|dnt|dS(Nii(RVRRRt_py3twith_tracebackt_reraise(Rtex((s&/tmp/pip-build-UnxK1c/pluggy/pluggy.pyROs  N(RRRRRVRRWRO(((s&/tmp/pip-build-UnxK1c/pluggy/pluggy.pyRMs   s4 def _reraise(cls, val, tb): raise cls, val, tb t_TracedHookExecutioncBs#eZdZdZdZRS(cCsP||_||_||_|j|_t|jt s@t||j_dS(N(t pluginmanagertbeforetaftert_inner_hookexectoldcallR)R\R<(RR]R^R_((s&/tmp/pip-build-UnxK1c/pluggy/pluggy.pyR"s     csWjjtfd}j|j|jS(NcsjS(N(Ra((thookt hook_implstkwargsR(s&/tmp/pip-build-UnxK1c/pluggy/pluggy.pyt,s(R^R%RMR_RO(RRbRcRdtoutcome((RbRcRdRs&/tmp/pip-build-UnxK1c/pluggy/pluggy.pyR*scCs|j|j_dS(N(RaR]R`(R((s&/tmp/pip-build-UnxK1c/pluggy/pluggy.pytundo0s(RRRRRg(((s&/tmp/pip-build-UnxK1c/pluggy/pluggy.pyR\!s  cBseZdZddZdZddZdZdddZdZ dZ dZ d Z d Z d Zd Zd ZdZdZdZdZdZdZdZdZdZdZdZRS(s Core Pluginmanager class which manages registration of plugin objects and 1:N hook calling. You can register new hooks by calling ``add_hookspec(module_or_class)``. You can register plugin objects (which contain hooks) by calling ``register(plugin)``. The Pluginmanager is initialized with a prefix that is searched for in the names of the dict of registered plugin objects. An optional excludefunc allows to blacklist names which are not considered as hooks despite a matching prefix. For debugging purposes you can call ``enable_tracing()`` which will subsequently send debug information to the trace helper. cCsp||_i|_i|_g|_tjd|_t|jjjd|_ ||_ d|_ dS(sr if implprefix is given implementation functions will be recognized if their name matches the implprefix. t pluginmanageRbcSst|||jjS(N(t _MultiCallt spec_optstexecute(RbtmethodsRd((s&/tmp/pip-build-UnxK1c/pluggy/pluggy.pyReMsN( Rt _name2plugint_plugin2hookcallerst_plugin_distinfoR R&ttracet _HookRelayR?Rbt _implprefixR`(RRt implprefix((s&/tmp/pip-build-UnxK1c/pluggy/pluggy.pyRCs     cCs|j|||S(N(R`(RRbRlRd((s&/tmp/pip-build-UnxK1c/pluggy/pluggy.pyt _hookexecPsc Cs|p|j|}||jks3||jkrq|jj|ddkrRdStd|||jfn||j| Return name for registered plugin or None if not registered. N(RmR-(RRR%tval((s&/tmp/pip-build-UnxK1c/pluggy/pluggy.pyRs c Cs|jr4|jr4td|j|jfnx]|jD]R}||jkr>td|j|j|t|jdj|jfq>q>WdS(Ns6Plugin %r hook %r historic incompatible to hookwrappersXPlugin %r hook %r argument %r not available plugin definition: %s available hookargs: %ss, ( t is_historicRRRR%targnamest _formatdefRR*(RRbRtarg((s&/tmp/pip-build-UnxK1c/pluggy/pluggy.pyR|scCsx|jjD]z}|ddkr t|j|}|jsx@|j|jD]+}|jsRtd||jfqRqRWqq q WdS(s Verify that all hooks which have not been verified against a hook specification are optional, otherwise raise PluginValidationErrorit_sunknown hook %r in plugin %rN( Rbt__dict__RxR{RRRRR(RR%RbR((s&/tmp/pip-build-UnxK1c/pluggy/pluggy.pyt check_pendings  cCsddlm}m}m}x||D]}|j|js)|j|jrYq)ny|j}Wn?|k rq)n,|k r}td|j|fnX|j |d|j|j j ||j fq)Wt |j S(ss Load modules from querying the specified setuptools entrypoint name. Return the number of loaded plugins. i(titer_entry_pointstDistributionNotFoundtVersionConflicts"Plugin %r could not be loaded: %s!R%(t pkg_resourcesRRRRR%RtloadRRRoR.tdisttlen(Rtentrypoint_nameRRRtepRte((s&/tmp/pip-build-UnxK1c/pluggy/pluggy.pytload_setuptools_entrypointss$ cCs t|jS(sV return list of distinfo/plugin tuples for all setuptools registered plugins. (tlistRo(R((s&/tmp/pip-build-UnxK1c/pluggy/pluggy.pytlist_plugin_distinfoscCst|jjS(s# return list of name/plugin pairs. (RRmR-(R((s&/tmp/pip-build-UnxK1c/pluggy/pluggy.pytlist_name_plugin scCs|jj|S(s0 get all hook callers for the specified plugin. (RnR&(RR((s&/tmp/pip-build-UnxK1c/pluggy/pluggy.pytget_hookcallersscCst|||jS(sG 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:`_CallOutcome`` object which represents the result of the overall hook call. (R\Rg(RR^R_((s&/tmp/pip-build-UnxK1c/pluggy/pluggy.pytadd_hookcall_monitorings cs:|jjfd}fd}|j||S(s; enable tracing of hook calls and return an undo function. cs#jjd7_||dS(Ni(R?R#(t hook_nameRlRd(t hooktrace(s&/tmp/pip-build-UnxK1c/pluggy/pluggy.pyR^(scs>|jdkr(d|d|jnjjd8_dS(Ntfinishs-->i(RVRRRR?R#(RfRRlRd(R(s&/tmp/pip-build-UnxK1c/pluggy/pluggy.pyR_,s(Rbt_traceR(RR^R_((Rs&/tmp/pip-build-UnxK1c/pluggy/pluggy.pytenable_tracing$s c Cst|j|}g|D]}t||r|^q}|rt|j|j|j|j}xY|j|j D]G}|j }||krr|j ||j j |gj|qrqrW|S|S(s Return a new _HookCaller instance for the named method which manages calls to all registered plugins except the ones from remove_plugins. (RxRbthasattrRzR%Rtt_specmodule_or_classRjRRRR~RnRR.( RR%tremove_pluginstorigtplugtplugins_to_removeRRR((s&/tmp/pip-build-UnxK1c/pluggy/pluggy.pytsubset_hook_caller3s(    #N(RRRRRRtRRwRRRRRRRRuRRRR|RRRRRRRR(((s&/tmp/pip-build-UnxK1c/pluggy/pluggy.pyR4s2   #                  RicBs,eZdZidZdZdZRS(s8 execute a call into multiple python functions/methods. cCs,||_||_||jd<||_dS(Nt __multicall__(RcRdtspecopts(RRcRdR((s&/tmp/pip-build-UnxK1c/pluggy/pluggy.pyRPs   cCs|j}g|_}|jjd}x|jr |jj}y$g|jD]}||^qP}WnGtk rx7|jD](}||krtd|fqqWnX|j rt |j ||j S|j |}|dk r+|r|S|j|q+q+W|s|SdS(NR s"hook call must provide argument %r(RdtresultsRR&RcRRR7RRRQRRkRR.(Rt all_kwargsRR t hook_impltargnameR0R((s&/tmp/pip-build-UnxK1c/pluggy/pluggy.pyRkVs*   $    cCsPdt|jf}t|dr?dt|j|}nd||jfS(Ns%d methsRs %d results, s<_MultiCall %s, kwargs=%r>(RRcRRRd(Rtstatus((s&/tmp/pip-build-UnxK1c/pluggy/pluggy.pyt__repr__os(RRRRRkR(((s&/tmp/pip-build-UnxK1c/pluggy/pluggy.pyRiGs  cCszt|di}y |dSWntk r1nXtj|rly |j}Wntk rbdSXd}nrtj| rtj| ryt|d|}Wqtk rdSXn|dkrt tj|}ny |j }Wntk rdSXy|j ||j !}Wntk r0d }n$X|j}|rT|t| }ny||d(R%(R((s&/tmp/pip-build-UnxK1c/pluggy/pluggy.pyRscKs0|j st|j||j|j|S(N(RR<RtRR(RRd((s&/tmp/pip-build-UnxK1c/pluggy/pluggy.pyRscCs=|jj|pi|f|j||j|j|dS(N(RR.RtRR(RtprocRd((s&/tmp/pip-build-UnxK1c/pluggy/pluggy.pyt call_historicscCst|jt|jf}xK|D]C}tdtdtdt}tdd||}|j|q%Wz||SWd|\|_|_XdS(s} Call the hook with some additional temporarily participating methods using the specified kwargs as call parameters. RRRsN(RRRR RRyRR~(RRlRdtoldRRR((s&/tmp/pip-build-UnxK1c/pluggy/pluggy.pyt call_extras cCsh|jrdxU|jD]G\}}|j||g|}|r|dk r||dqqWndS(Ni(RRRtR(RRRdRR((s&/tmp/pip-build-UnxK1c/pluggy/pluggy.pyR}s  N(RRRRR{RRRR~RRRRR}(((s&/tmp/pip-build-UnxK1c/pluggy/pluggy.pyRzs      RycBseZdZRS(cCsJ||_t|j|_||_||_||_|jj|dS(N(RRRRRRRtupdate(RRRRthook_impl_opts((s&/tmp/pip-build-UnxK1c/pluggy/pluggy.pyRs     (RRR(((s&/tmp/pip-build-UnxK1c/pluggy/pluggy.pyRyscBseZdZRS(s plugin failed validation. (RRR(((s&/tmp/pip-build-UnxK1c/pluggy/pluggy.pyRscBseZdZRS(s Hook was called wrongly. (RRR(((s&/tmp/pip-build-UnxK1c/pluggy/pluggy.pyRst signaturecCs d|jttj|fS(Ns%s%s(RR,RR(R((s&/tmp/pip-build-UnxK1c/pluggy/pluggy.pyRscCs#d|jtjtj|fS(Ns%s%s(RRt formatargspect getargspec(R((s&/tmp/pip-build-UnxK1c/pluggy/pluggy.pyRs(RRTRt __version__t__all__t version_infoRXRRRR R$RJRQRMR\tobjectRRiRRRqRzRyRRRRR(((s&/tmp/pip-build-UnxK1c/pluggy/pluggy.pytBs:    &/ /   / . W