Implementing a Plugin System in Python

I am writing an application (a server wrapper for Minecraft) that I wish to make extensible with plugins. I have a system in place that works, however I think that in the long run it could use improvement.

The way that I have it now, the application calls a "get_plugins" method in the server class that, first imports a file named pluginutils.py (pluginutils.py defines a BasePlugin class which all plugins subclass), and then loops through every .py file in the cmds directory, importing it and checking to see if it is a subclass of BasePlugin. If it is, it stores an instance of it in a dictionary, for which the key is a cmd class variable defined in the plugin. Whenever the application receives a command from the server it checks if it is a key in the dictionary and if so ru开发者_如何学JAVAns the start method of the instance stored in the dictionary, to which it passes the necessary arguments taken from the command.

While this works, I feel like this is a sloppy way to do it. Are there any better techniques for implementing a system similar to this? I want to write this myself (I don't want to use anything like zope.interface) as this is a learning experience. Thanks.

Having written quite a few different plugin architectures in different platforms and languages, I will say that you are pretty much on track with how most plugins systems are written.

Basically what it boils down to, is your host and your plugin need to have some kind of common contract to work with; in other words, your host needs to know enough about your plugin that it can pass along or share whatever common resources the plugin will need, and the plugin needs to know enough about the host to interact with those resources.

Implementing this using a base class and a derived class as you have done is a very common methodology.

I would suggest to use setuptools, because plugins are linked eventually to the management of the sys.path list:

http://peak.telecommunity.com/DevCenter/PkgResources

In the long run, a distribution/packaging based solution like setuptools would always be a solid choice since:

• you have to load plugins without conflicts or missing requirements,
• even if the plugins loaded depend themselves on other dynamic dependencies, and
• you have to keep the list of available plugins updated as packages are installed and removed.