Python实现Plugin

1. Plugin与Python

插件的历史最早可追溯至1970年代，它是一种程序组件，通过和应用程序的互动，为应用程序增加一些所需要的特定的功能[维基]。插件允许第三方开发者对已有的程序功能进行扩展和完善，具体的例子包括音频播放软件的解码器、浏览器的视频播放插件等。插件需要按照一定的接口规范与应用程序互动，这个规范是调用它的应用程序定义的。

为了在实践上应用，我看了两篇搜索比较靠前的博客文章，它们的代码比较精简，都是通过python package来实现的。

本文组织如下。第二部分介绍python package；第三部分介绍上面两篇博客中实现插件的方法。

2. Python packages

Package是python用名字空间组织module的一种方法，通过"."将各级路径连接起来，以"A.B.C"的形式组成层次结构。每一个python文件是一个module，包含module的目录可以组成一个package，包含package的目录又可以进一步组成更高级的package。

2.1 package的基本结构

不是所有的目录都会被解释为package，其充要条件是目录内包含一个名为__init.py的文件，这个文件可以是空文件，也可以包含一些定义和初始化代码，包含该文件的目录可以被import。如下目录可以被作为package使用，本例中除了__init.py文件外，还包含三个module。

myprint/
|---__init__.py
|---print_int.py
|---print_float.py
|---print_complex.py

因为myprint目录下有__init__.py文件，myprint是一个package，可以在python代码或命令行中import它及它包含的module。

import myprint   # import了一个package

或

import myprint.print_int   #  import了package下的一个module

或

from myprint import print_int  # import了package下的一个module，引用时可以不带package name

2.2 subpackage

Packages可以形成多层嵌套的结构，tensorflow代码中经常看到import多层的情况。下例中tensorflow、python、framework都是上一层namespace中的package，只有ops是module。

import tensorflow.python.framework.ops

如果有import A.B.C.D，只有D可以是module，A、B、C都必须是package。

2.3 __init__.py文件

文件__init.py让python将其所属目录视为package，该文件可以是空文件，也可以包含python代码，文件内的代码在package第一次被进程import时执行一次。文件__init__.py中定义的函数、变量，可以通过package name被外部引用。如果上面例子中myprint/__init.py包含如下代码，则default_int和default_float两个名字可以通过myprint.default_int和myprint.default_float访问。

__all__ = ['print_int', 'print_float']
default_int = 0
default_float = 0.0

import myprint
myprint.print_int
myprint.print_float

如果import的是一个subpackage，则路径上所有package的__init__.py文件会被依次执行。例如，当import A.B.C.D时，A package、B package、C package会被先后初始化，如果D也是package，则D package也会被初始化。

__init__.py文件中还可以定义__all__变量，如上面代码中有__all__ = ['print_int', 'print_float']，当通过代码from myprint import *导入package时，只有__all__中定义的所有name会被导入，而不是把myprint/目录下的所有东西都导入。__all__中定义的name是package下的module或subpackage。

下面介绍的两种实现插件的方法，都用到了__init__.py文件的__all__变量。

3. Python实现的Plugin

下面两篇博客都各自实现了插件结构，都是通过python的package实现，插件被实现为一个module，并列放置在package内，插件的作者需要修改package的__init__.py文件中的__all__变量。

不同之处在于。第一篇博客只是将所有plugin import进来，使用时需要提供plugin的module name，然后通过eval方式引用。第二篇博客有一个反向注册的机制，在插件module被import时，将plugin及其名字注册到一个公共变量中。

我在实际工作中，需要实现一个清理字符串的package，需要的功能可能随着遇到的CASE逐渐完善。因此考虑将所有字符串清理函数串成一个序列结构，依次执行其中的每个功能。我仿照第二篇博客实现，稍微做了一些改动，因为我既需要插件按顺序全部执行，也需要能指定只执行某插件。

3.1 字符串清理Plugin

目录结构如下，package名为text_processor，这是使用方需要import的那个package。具体的处理逻辑在plugins目录下，因为plugins目录下有一个__init__.py文件，所以它也是一个package。

text_processor
    |---__init__.py
    |---text_processor.py
    |---plugins
            |---__init__.py
            |---clean_dupspace.py
            |---clean_htmltag.py
            |---clean_punctuation.py
            |---clean_q2b.py

从上到下依次看每个文件的内容，首先是text_processor/__init__.py文件。这个文件只有一行语句，从当前目录下的plugins package导入所有模块。所以，当我们通过import text_processor导入text_processor时，就会执行下面这条语句，plugins下的模块也会被导入。

from .plugins import *

接下来是text_processor/text_processor.py文件。这个module是用户需要使用的唯一接口，它有一个普通方法，一个类方法。类方法返回一个闭包，该闭包可以作为类的decorator，来修饰每个plugin module内定义的类。普通方法是用户调用的，用来处理字符串。

class TextProcessor(object):
    PLUGIN_NAMES = []
    PLUGINS = {}

    def process(self, text, plugins=()):
        if plugins is ():
            for plugin_name in self.PLUGIN_NAMES:
                text = self.PLUGINS[plugin_name]().process(text)
        else:
            for plugin_name in plugins:
                text = self.PLUGINS[plugin_name]().process(text)
        return text

    @classmethod
    def plugin_register(cls, plugin_name):
        def wrapper(plugin):
            cls.PLUGINS.update({plugin_name:plugin})
            cls.PLUGIN_NAMES.append(plugin_name)
            return plugin
        return wrapper

接下来是text_processor/plugins/__init__.py文件。这个文件只是定义__all__变量，指示了plugins这个package，当通过from plugins import *导入时，都具体导入哪些module。text_processor/plugins/__init__.py文件中的__all__变量，与text_processor/__init__.py文件中的from .plugins import *协作，共同完成对所有插件的导入。

__all__ = ['clean_q2b', 'clean_nbsp, 'clean_htmltag, 'clean_dupspace, 'clean_punctuation']

然后我们以text_processor/plugins/plugins/clean_dupspace.py为例，说明插件是如何与上层package互动的。第一句导入上层的TextProcessor，是为了调用该类的类方法plugin_register。

from ..textProcessor import TextProcessor
import re

re_space = re.compile(u'\s+')

@TextProcessor.plugin_register('cleanDupSpace')
class CleanDupSpace(object):
    def process(self, text):
        cleanText = re_space.sub(u' ', text)
        cleanText = cleanText.replace(u"\u3000", ' ')
        cleanText = cleanText.strip()
        return cleanText

这个文件重点需要关注的是用@TextProcessor.plugin_register('cleanDupSpace')修饰了类CleanDupSpace的定义。decorator是Python的一个语法特性，相当于做了下面的事情。

class CleanDupSpace(object):
    def process(self, text):
        cleanText = re_space.sub(u' ', text)
        cleanText = cleanText.replace(u"\u3000", ' ')
        cleanText = cleanText.strip()
        return cleanText

 CleanDupSpace = TextProcessor.plugin_register('cleanDupSpace')(CleanDupSpace)

@符号后面的字符串TextProcessor.plugin_register('cleanDupSpace'),eval后应该是个wrapper函数。该wrapper只有一个参数，就是修饰符后定义的东西，并将修饰后的东西（类、函数）赋给原来那个变量CleanDupSpace。这个逻辑是在类定义，也就是import当前module时完成的。

最后，使用该package的方法如下。

from text_processor.text_processor import TextProcessor
tp = TextProcessor()
cleanText = tp.process(rawText)

3.2 其他实现

在Github上还找到一个更复杂的plugin实现，pluginbase。这个代码实现我没有仔细看。