1 pluggy 简介
- pluggy 作用：提供了一个简易便捷的插件系统，可以做到插件与主题功能松耦合
- pluggy 是pytest，tox，devpi的核心框架
2 安装
执行如下命令即可
|
1
|
pip install pluggy |
3 使用初体验
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
|
import pluggy# HookspecMarker 和 HookimplMarker 实质上是一个装饰器带参数的装饰器类，作用是给函数增加额外的属性设置hookspec = pluggy.HookspecMarker("myproject")hookimpl = pluggy.HookimplMarker("myproject")# 定义自己的Spec，这里可以理解为定义接口类class MySpec: # hookspec 是一个装饰类中的方法的装饰器，为此方法增额外的属性设置，这里myhook可以理解为定义了一个接口 @hookspec def myhook(self, arg1, arg2): pass# 定义了一个插件class Plugin_1: # 插件中实现了上面定义的接口，同样这个实现接口的方法用 hookimpl装饰器装饰，功能是返回两个参数的和 @hookimpl def myhook(self, arg1, arg2): print("inside Plugin_1.myhook()") return arg1 + arg2# 定义第二个插件class Plugin_2: # 插件中实现了上面定义的接口，同样这个实现接口的方法用 hookimpl装饰器装饰，功能是返回两个参数的差 @hookimpl def myhook(self, arg1, arg2): print("inside Plugin_2.myhook()") return arg1 - arg2# 实例化一个插件管理的对象，注意这里的名称要与文件开头定义装饰器的时候的名称一致pm = pluggy.PluginManager("myproject")# 将自定义的接口类加到钩子定义中去pm.add_hookspecs(MySpec)# 注册定义的两个插件pm.register(Plugin_1())pm.register(Plugin_2())# 通过插件管理对象的钩子调用方法，这时候两个插件中的这个方法都会执行，而且遵循后注册先执行即LIFO的原则，两个插件的结果讲义列表的形式返回results = pm.hook.myhook(arg1=1, arg2=2)print(results) |
执行结果如下：
inside Plugin_2.myhook()
inside Plugin_1.myhook()
[-1, 3]
4 详解解释
从代码上看比较绕，其实通俗一点理解，其实挺简单的，可以理解为首先定义一个接口类，然后定义很多插件类，插件类想要多少就定义多少， 接口类中要定义接口，上面的例子值定义了一个接口，其实可以定义很多接口，在每个插件类中需要选择接口类中的接口去实现，当然也不需要每个 都需要去实现，可以根据自己的需要有选择的去实现。
举个例子：
比如定义了一个接口类，接口类中定义了10个接口，同时定义了3个类，这三个类分别实现了接口类中3个接口，6个接口和10个接口，然后实例化一个插件管理的对象，实例化对象将接口类加入定义模板中，然后去注册这三个类，注册之后，就可以通过插件管理对象的钩子去调用接口类中的每个方法了，比如调用头三个方法，因为每个插件中都实现了，所以就会有三个结果，调用后面4-6的接口时，因为只有两个插件实现了，所以只会有两个结果返回，调用7-10的接口因为只有一个插件类实现了，所以就会只有一个结果返回，这样插件使用起来就非常灵活，可以真正做到“热插拔”
下面用代码示例演示：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
|
import pluggy# HookspecMarker 和 HookimplMarker 实质上是一个装饰器带参数的装饰器类，作用是给函数增加额外的属性设置hookspec = pluggy.HookspecMarker("myproject")hookimpl = pluggy.HookimplMarker("myproject")# 定义自己的Spec，这里可以理解为定义接口类class MySpec: # hookspec 是一个装饰类中的方法的装饰器，为此方法增额外的属性设置，这里myhook可以理解为定义了3个接口 @hookspec def myhook1(self, arg1, arg2): pass @hookspec def myhook2(self, arg1, arg2): pass @hookspec def myhook3(self, arg1, arg2): pass# 定义了一个插件class Plugin_1: # 插件中实现了上面定义的接口，同样这个实现接口的方法用 hookimpl装饰器装饰，功能是返回两个参数的和 @hookimpl def myhook1(self, arg1, arg2): print("inside Plugin_1.myhook1()") return arg1 + arg2 @hookimpl def myhook2(self, arg1, arg2): print("inside Plugin_1.myhook2()") return arg1 + arg2 +1 @hookimpl def myhook4(self, arg1, arg2): print("inside Plugin_1.myhook4()") return arg1 + arg2 + 2# 定义第二个插件class Plugin_2: # 插件中实现了上面定义的接口，同样这个实现接口的方法用 hookimpl装饰器装饰，功能是返回两个参数的差 @hookimpl def myhook1(self, arg1, arg2): print("inside Plugin_2.myhook1()") return arg1 - arg2 @hookimpl def myhook2(self, arg1, arg2): print("inside Plugin_2.myhook2()") return arg1 - arg2 -1 @hookimpl def myhook3(self, arg1, arg2): print("inside Plugin_2.myhook3()") return arg1 - arg2 -2# 实例化一个插件管理的对象，注意这里的名称要与文件开头定义装饰器的时候的名称一致pm = pluggy.PluginManager("myproject")# 将自定义的接口类加到钩子定义中去pm.add_hookspecs(MySpec)# 注册定义的两个插件pm.register(Plugin_1())pm.register(Plugin_2())# 通过插件管理对象的钩子调用方法，这时候两个插件中的这个方法都会执行，而且遵循后注册先执行即LIFO的原则，两个插件的结果讲义列表的形式返回results = pm.hook.myhook1(arg1=1, arg2=2)print(results)results = pm.hook.myhook2(arg1=1, arg2=2)print(results)results = pm.hook.myhook3(arg1=1, arg2=2)print(results)results = pm.hook.myhook4(arg1=1, arg2=2)print(results) |
执行结果如下：
inside Plugin_2.myhook1()
inside Plugin_1.myhook1()
[-1, 3]
inside Plugin_2.myhook2()
inside Plugin_1.myhook2()
[-2, 4]
inside Plugin_2.myhook3()
[-3]
inside Plugin_1.myhook4()
[5]
从上面的代码示例可以看出：
- 1）myhook1 和 myhook2 因为两个插件都实现了，所有返回两个结果，而且是倒序的
- 2）myhook3 因为只有插件2实现了，所以只有一个返回结果
- 3）myhook4 在spec中未定义，这里却也有结果，目前理解可能是pluggy的bug，待后续看源码后解释
5 HookspeckMarker装饰器支持传入一些特定的参数
当传入firstresult=True时，获取第一个plugin执行结果后就停止继续执行
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
|
import pluggy# HookspecMarker 和 HookimplMarker 实质上是一个装饰器带参数的装饰器类，作用是给函数增加额外的属性设置hookspec = pluggy.HookspecMarker("myproject")hookimpl = pluggy.HookimplMarker("myproject")# 定义自己的Spec，这里可以理解为定义接口类class MySpec: # hookspec 是一个装饰类中的方法的装饰器，为此方法增额外的属性设置，这里myhook可以理解为定义了一个接口 @hookspec(firstresult=True) def myhook(self, arg1, arg2): pass# 定义了一个插件class Plugin_1: # 插件中实现了上面定义的接口，同样这个实现接口的方法用 hookimpl装饰器装饰，功能是返回两个参数的和 @hookimpl def myhook(self, arg1, arg2): print("inside Plugin_1.myhook()") return arg1 + arg2# 定义第二个插件class Plugin_2: # 插件中实现了上面定义的接口，同样这个实现接口的方法用 hookimpl装饰器装饰，功能是返回两个参数的差 @hookimpl def myhook(self, arg1, arg2): print("inside Plugin_2.myhook()") return arg1 - arg2# 实例化一个插件管理的对象，注意这里的名称要与文件开头定义装饰器的时候的名称一致pm = pluggy.PluginManager("myproject")# 将自定义的接口类加到钩子定义中去pm.add_hookspecs(MySpec)# 注册定义的两个插件pm.register(Plugin_1())pm.register(Plugin_2())# 通过插件管理对象的钩子调用方法，这时候两个插件中的这个方法都会执行，而且遵循后注册先执行即LIFO的原则，两个插件的结果讲义列表的形式返回results = pm.hook.myhook(arg1=1, arg2=2)print(results) |
执行结果如下：
inside Plugin_2.myhook()
-1
6 HookImplMarker装饰器也支持传入一些特定的参数
常用的有tryfirst和trylast以及hookwrapper
- 当传入tryfirst=True时，表示这个类的hook函数会优先执行，其他的仍然按照后进先出的顺序执行
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
|
import pluggy# HookspecMarker 和 HookimplMarker 实质上是一个装饰器带参数的装饰器类，作用是给函数增加额外的属性设置hookspec = pluggy.HookspecMarker("myproject")hookimpl = pluggy.HookimplMarker("myproject")# 定义自己的Spec，这里可以理解为定义接口类class MySpec: # hookspec 是一个装饰类中的方法的装饰器，为此方法增额外的属性设置，这里myhook可以理解为定义了一个接口 @hookspec def myhook(self, arg1, arg2): pass# 定义了一个插件class Plugin_1: # 插件中实现了上面定义的接口，同样这个实现接口的方法用 hookimpl装饰器装饰，功能是返回两个参数的和 @hookimpl(tryfirst=True) def myhook(self, arg1, arg2): print("inside Plugin_1.myhook()") return arg1 + arg2# 定义第二个插件class Plugin_2: # 插件中实现了上面定义的接口，同样这个实现接口的方法用 hookimpl装饰器装饰，功能是返回两个参数的差 @hookimpl def myhook(self, arg1, arg2): print("inside Plugin_2.myhook()") return arg1 - arg2# 定义第三个插件class Plugin_3: # 插件中实现了上面定义的接口，同样这个实现接口的方法用 hookimpl装饰器装饰，功能是返回两个参数的差 @hookimpl def myhook(self, arg1, arg2): print("inside Plugin_3.myhook()") return arg1 - arg2+10# 实例化一个插件管理的对象，注意这里的名称要与文件开头定义装饰器的时候的名称一致pm = pluggy.PluginManager("myproject")# 将自定义的接口类加到钩子定义中去pm.add_hookspecs(MySpec)# 注册定义的两个插件pm.register(Plugin_1())pm.register(Plugin_2())pm.register(Plugin_3())# 通过插件管理对象的钩子调用方法，这时候两个插件中的这个方法都会执行，而且遵循后注册先执行即LIFO的原则，两个插件的结果讲义列表的形式返回results = pm.hook.myhook(arg1=1, arg2=2)print(results) |
执行结果让如下：
inside Plugin_1.myhook()
inside Plugin_3.myhook()
inside Plugin_2.myhook()
[3, 9, -1]
- 当传入trylast=True，表示当前插件的hook函数会尽可能晚的执行，其他的仍然按照后进先出的顺序执行
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
|
import pluggy# HookspecMarker 和 HookimplMarker 实质上是一个装饰器带参数的装饰器类，作用是给函数增加额外的属性设置hookspec = pluggy.HookspecMarker("myproject")hookimpl = pluggy.HookimplMarker("myproject")# 定义自己的Spec，这里可以理解为定义接口类class MySpec: # hookspec 是一个装饰类中的方法的装饰器，为此方法增额外的属性设置，这里myhook可以理解为定义了一个接口 @hookspec def myhook(self, arg1, arg2): pass# 定义了一个插件class Plugin_1: # 插件中实现了上面定义的接口，同样这个实现接口的方法用 hookimpl装饰器装饰，功能是返回两个参数的和 @hookimpl() def myhook(self, arg1, arg2): print("inside Plugin_1.myhook()") return arg1 + arg2# 定义第二个插件class Plugin_2: # 插件中实现了上面定义的接口，同样这个实现接口的方法用 hookimpl装饰器装饰，功能是返回两个参数的差 @hookimpl(trylast=True) def myhook(self, arg1, arg2): print("inside Plugin_2.myhook()") return arg1 - arg2# 定义第三个插件class Plugin_3: # 插件中实现了上面定义的接口，同样这个实现接口的方法用 hookimpl装饰器装饰，功能是返回两个参数的差 @hookimpl def myhook(self, arg1, arg2): print("inside Plugin_3.myhook()") return arg1 - arg2+10# 实例化一个插件管理的对象，注意这里的名称要与文件开头定义装饰器的时候的名称一致pm = pluggy.PluginManager("myproject")# 将自定义的接口类加到钩子定义中去pm.add_hookspecs(MySpec)# 注册定义的两个插件pm.register(Plugin_1())pm.register(Plugin_2())pm.register(Plugin_3())# 通过插件管理对象的钩子调用方法，这时候两个插件中的这个方法都会执行，而且遵循后注册先执行即LIFO的原则，两个插件的结果讲义列表的形式返回results = pm.hook.myhook(arg1=1, arg2=2)print(results) |
执行结果如下：
inside Plugin_3.myhook()
inside Plugin_1.myhook()
inside Plugin_2.myhook()
[9, 3, -1]
- 当传入hookwrapper=True时，需要在这个plugin中实现一个yield，plugin先执行yield
之前的代码，然后去执行其他的pluggin，然后再回来执行yield之后的代码,同时通过yield可以 获取到其他插件执行的结果
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
|
import pluggy# HookspecMarker 和 HookimplMarker 实质上是一个装饰器带参数的装饰器类，作用是给函数增加额外的属性设置hookspec = pluggy.HookspecMarker("myproject")hookimpl = pluggy.HookimplMarker("myproject")# 定义自己的Spec，这里可以理解为定义接口类class MySpec: # hookspec 是一个装饰类中的方法的装饰器，为此方法增额外的属性设置，这里myhook可以理解为定义了一个接口 @hookspec def myhook(self, arg1, arg2): pass# 定义了一个插件class Plugin_1: # 插件中实现了上面定义的接口，同样这个实现接口的方法用 hookimpl装饰器装饰，功能是返回两个参数的和 @hookimpl() def myhook(self, arg1, arg2): print("inside Plugin_1.myhook()") return arg1 + arg2# 定义第二个插件class Plugin_2: # 插件中实现了上面定义的接口，同样这个实现接口的方法用 hookimpl装饰器装饰，功能是返回两个参数的差 @hookimpl(hookwrapper=True) def myhook(self, arg1, arg2): print("inside Plugin_2.myhook() before yield...") output=yield result=output.get_result() print(result) print("inside Plugin_2.myhook() after yield...")# 定义第三个插件class Plugin_3: # 插件中实现了上面定义的接口，同样这个实现接口的方法用 hookimpl装饰器装饰，功能是返回两个参数的差 @hookimpl def myhook(self, arg1, arg2): print("inside Plugin_3.myhook()") return arg1 - arg2+10# 实例化一个插件管理的对象，注意这里的名称要与文件开头定义装饰器的时候的名称一致pm = pluggy.PluginManager("myproject")# 将自定义的接口类加到钩子定义中去pm.add_hookspecs(MySpec)# 注册定义的两个插件pm.register(Plugin_1())pm.register(Plugin_2())pm.register(Plugin_3())# 通过插件管理对象的钩子调用方法，这时候两个插件中的这个方法都会执行，而且遵循后注册先执行即LIFO的原则，两个插件的结果讲义列表的形式返回results = pm.hook.myhook(arg1=1, arg2=2)print(results) |
执行结果如下：
inside Plugin_2.myhook() before yield...
inside Plugin_3.myhook()
inside Plugin_1.myhook()
[9, 3]
inside Plugin_2.myhook() after yield...
[9, 3]
到此这篇关于Python pluggy模块的用法的文章就介绍到这了,更多相关Python pluggy模块内容请搜索服务器之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持服务器之家！
原文链接：https://juejin.cn/post/7096346688188579847
