【pytest框架源码分析四】pluggy源码分析之hook实行

pluggy的主要实行方法在_callers.py中，这里简单介绍下。

1. def _multicall(
2.     hook_name: str,
3.     hook_impls: Sequence[HookImpl],
4.     caller_kwargs: Mapping[str, object],
5.     firstresult: bool,
6. ) -> object | list[object]:
7.     """Execute a call into multiple python functions/methods and return the
8.     result(s).
10.     ``caller_kwargs`` comes from HookCaller.__call__().
11.     """
12.     __tracebackhide__ = True
13.     results: list[object] = []
14.     exception = None
15.     only_new_style_wrappers = True
16.     try:  # run impl and wrapper setup functions in a loop
17.         teardowns: list[Teardown] = []
18.         try:
19.             for hook_impl in reversed(hook_impls):
20.                 try:
21.                     args = [caller_kwargs[argname] for argname in hook_impl.argnames]
22.                 except KeyError:
23.                     for argname in hook_impl.argnames:
24.                         if argname not in caller_kwargs:
25.                             raise HookCallError(
26.                                 f"hook call must provide argument {argname!r}"
27.                             )
29.                 if hook_impl.hookwrapper:
30.                     only_new_style_wrappers = False
31.                     try:
32.                         # If this cast is not valid, a type error is raised below,
33.                         # which is the desired response.
34.                         res = hook_impl.function(*args)
35.                         wrapper_gen = cast(Generator[None, Result[object], None], res)
36.                         next(wrapper_gen)  # first yield
37.                         teardowns.append((wrapper_gen, hook_impl))
38.                     except StopIteration:
39.                         _raise_wrapfail(wrapper_gen, "did not yield")
40.                 elif hook_impl.wrapper:
41.                     try:
42.                         # If this cast is not valid, a type error is raised below,
43.                         # which is the desired response.
44.                         res = hook_impl.function(*args)
45.                         function_gen = cast(Generator[None, object, object], res)
46.                         next(function_gen)  # first yield
47.                         teardowns.append(function_gen)
48.                     except StopIteration:
49.                         _raise_wrapfail(function_gen, "did not yield")
50.                 else:
51.                     res = hook_impl.function(*args)
52.                     if res is not None:
53.                         results.append(res)
54.                         if firstresult:  # halt further impl calls
55.                             break
56.         except BaseException as exc:
57.             exception = exc
58.     finally:
59.         # Fast path - only new-style wrappers, no Result.
60.         if only_new_style_wrappers:
61.             if firstresult:  # first result hooks return a single value
62.                 result = results[0] if results else None
63.             else:
64.                 result = results
66.             # run all wrapper post-yield blocks
67.             for teardown in reversed(teardowns):
68.                 try:
69.                     if exception is not None:
70.                         teardown.throw(exception)  # type: ignore[union-attr]
71.                     else:
72.                         teardown.send(result)  # type: ignore[union-attr]
73.                     # Following is unreachable for a well behaved hook wrapper.
74.                     # Try to force finalizers otherwise postponed till GC action.
75.                     # Note: close() may raise if generator handles GeneratorExit.
76.                     teardown.close()  # type: ignore[union-attr]
77.                 except StopIteration as si:
78.                     result = si.value
79.                     exception = None
80.                     continue
81.                 except BaseException as e:
82.                     exception = e
83.                     continue
84.                 _raise_wrapfail(teardown, "has second yield")  # type: ignore[arg-type]
86.             if exception is not None:
87.                 raise exception.with_traceback(exception.__traceback__)
88.             else:
89.                 return result
91.         # Slow path - need to support old-style wrappers.
92.         else:
93.             if firstresult:  # first result hooks return a single value
94.                 outcome: Result[object | list[object]] = Result(
95.                     results[0] if results else None, exception
96.                 )
97.             else:
98.                 outcome = Result(results, exception)
100.             # run all wrapper post-yield blocks
101.             for teardown in reversed(teardowns):
102.                 if isinstance(teardown, tuple):
103.                     try:
104.                         teardown[0].send(outcome)
105.                     except StopIteration:
106.                         pass
107.                     except BaseException as e:
108.                         _warn_teardown_exception(hook_name, teardown[1], e)
109.                         raise
110.                     else:
111.                         _raise_wrapfail(teardown[0], "has second yield")
112.                 else:
113.                     try:
114.                         if outcome._exception is not None:
115.                             teardown.throw(outcome._exception)
116.                         else:
117.                             teardown.send(outcome._result)
118.                         # Following is unreachable for a well behaved hook wrapper.
119.                         # Try to force finalizers otherwise postponed till GC action.
120.                         # Note: close() may raise if generator handles GeneratorExit.
121.                         teardown.close()
122.                     except StopIteration as si:
123.                         outcome.force_result(si.value)
124.                         continue
125.                     except BaseException as e:
126.                         outcome.force_exception(e)
127.                         continue
128.                     _raise_wrapfail(teardown, "has second yield")
130.             return outcome.get_result()

复制代码

其前面的调用过程可参考前面几篇，这里主要介绍下_multicall方法自己。
其入参如下：
hook_name：hook的name，为我们所写方法的名称
hook_impls：hook的impl列表，impl中包括插件，插件的方法及其设置，一个方法一个impl
caller_kwargs：调用hook方法时的入参，即我们编写impl方法自己的入参
firstresult：是否只必要首次结果，bool类型
下面是方法中的正式流程
1.首先界说了个teardown的list，这个是teardown的界说。这里teardown主要是为了天生器函数预备的，在我们调用插件时，如果希望有些函数中某些步骤在所有方法最后实行，则在函数中加入yield，并且wrapper设置成true。则该函数yield前的步骤先按顺序实行，yield之后的在所有函数实行完成后实行。

1. Teardown = Union[
2.     Tuple[Generator[None, Result[object], None], HookImpl],
3.     Generator[None, object, object],
4. ]

复制代码

2.遍历hook_impls，留意这里reversed，将hook_impls反转了，这是为什么先添加的hook_impl后实行，后添加的先实行。
3.获取调用时的所有args，如果缺少参数，则报错。
4.接下来判断hookwrapper和wrapper参数是否为true，如果为true，这两个处置惩罚过程类似。都是先实行yield之前的内容，然后返回天生器函数放在teardowns里，留待所有函数实行完成再实行。如果不为true，则正常实行函数，并把返回值放到results中。如果只取第一次结果，则直接break跳出循环。
5.然后到finally，这里主要是处置惩罚天生器函数，即上方hookwrapper和wrapper参数为true的情况。
（1）如果是wrappers是true，先根据firstresult取result，然后再取teardowns中的内容。如果上面的实行有异常，则在这里抛出异常；如果没有异常，则继续实行send()方法，这一步大都会抛出异常，由于函数中只会有一个yield，如果这边不抛出异常，说明函数中有两个yeild，背面会提示报错"has second yield"。最后返回result（如果没有声明wrappers和hookwrapper参数，也是走该路径）–留意我们编写的方法中只能有一个yield。
（2）如果hookwrapper是true，也是先判断是否取firstresult，然后和上面的exception组成Result类型的outcome。接下来和上面类似，取teardowns中的内容，这里多个判断isinstance(teardown, tuple)，主要和上面的处置惩罚有关，团体是一致的，有异常抛出异常，无异常则继续实行。最后返回result。
这边wrappers路径的处置惩罚过程要比hookwrapper简单。我们背面可以用wrappers参数来处置惩罚天生器函数。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。