Python?pluggy模块的用法示例演示

 更新时间:2022-05-13 14:12:32   作者:佚名   我要评论(0)

目录1 pluggy 简介2 安装3 使用初体验4 详解解释5 HookspeckMarker装饰器支持传入一些特定的参数6 HookImplMarker装饰器也支持传入一些特定的

1 pluggy 简介

  • pluggy 作用:提供了一个简易便捷的插件系统,可以做到插件与主题功能松耦合
  • pluggy 是pytest,tox,devpi的核心框架

2 安装

执行如下命令即可

pip install pluggy

3 使用初体验

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的接口因为只有一个插件类实现了,所以就会只有一个结果返回,这样插件使用起来就非常灵活,可以真正做到“热插拔”

下面用代码示例演示:

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执行结果后就停止继续执行

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函数会优先执行,其他的仍然按照后进先出的顺序执行
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函数会尽可能晚的执行,其他的仍然按照后进先出的顺序执行
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可以 获取到其他插件执行的结果

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模块内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家!

您可能感兴趣的文章:
  • Python?pluggy框架使用示例代码

相关文章

  • Python?pluggy模块的用法示例演示

    Python?pluggy模块的用法示例演示

    目录1 pluggy 简介2 安装3 使用初体验4 详解解释5 HookspeckMarker装饰器支持传入一些特定的参数6 HookImplMarker装饰器也支持传入一些特定的
    2022-05-13
  • go语言中如何使用select的实现示例

    go语言中如何使用select的实现示例

    目录1.基本语法2.select语句的实际应用在golang语言中,select语句 就是用来监听和channel有关的IO操作,当IO操作发生时,触发相应的case动作
    2022-05-13
  • 通过Golang编写一个AES加密解密工具

    通过Golang编写一个AES加密解密工具

    目录前言AES加密介绍及实现原理AES用在哪里AES加密是如何实现的AES加密模式Go实现AES加密工具scode前言 本文包含如下两个内容: AES加密介绍
    2022-05-13
  • python中列表添加的四种方法小结

    python中列表添加的四种方法小结

    目录列表的添加1)+ 添加2)append 追加3)extend 拉伸4)insert 插入在列表指定位置添加元素列表的添加 1)+ 添加 2)append 追加 一次只能
    2022-05-13
  • 深入理解Go语言实现多态?

    深入理解Go语言实现多态?

    目录多态是什么Go语言多态举例总结多态是什么 相信学过Java这种面向对象语言的同学对于多态来说都不陌生,在代码执行的时候,能够根据子类的
    2022-05-13
  • 图解AVL树数据结构输入与输出及实现示例

    图解AVL树数据结构输入与输出及实现示例

    目录AVL树(平衡二叉树):AVL树的作用:AVL树的基本操作:AVL树的插入,单旋转的第一种情况---右旋:AVL树的插入,单旋转的第二种情况---左旋
    2022-05-13
  • 分析讲解Java?Random类里的种子问题

    分析讲解Java?Random类里的种子问题

    可以说在现在的计算机语言里面,以及普通用户这里,都是没有办法获得真正的 随机数的。真正的随机数现在也只有在量子计算机当中才有获得。 所
    2022-05-13
  • 300行代码实现go语言即时通讯聊天室

    300行代码实现go语言即时通讯聊天室

    学了2年Java,因为工作原因需要转Golang,3天时间学习了下go的基本语法,做这样一个聊天室小项目来巩固串联一下语法。 实现的功能:公聊,私
    2022-05-13
  • SpringBoot整合Mongodb实现增删查改的方法

    SpringBoot整合Mongodb实现增删查改的方法

    目录一、什么是MongoDB二、在Window10上安装MongoDB三、配置MongoDB服务四、启动服务五、SpringBoot整合MongoDB一、什么是MongoDB MongoDB与
    2022-05-13
  • networkx库绘制带权图给无权图加权重输出

    networkx库绘制带权图给无权图加权重输出

    目录问题输出结果如何只输出权重输出结果问题 最近在研究图学习,在用networkx库绘图的时候发现问题。 ''' author:zheng time:2020.10.23
    2022-05-13

最新评论