[Tutor] Tutor Digest, Vol 64, Issue 128

[Dave Angel]

Amit Sethi  wrote:

> <snip ... the top-posted portion>
> . On Mon, Jun 29, 2009 at 5:01 PM, Dave Angel <davea at ieee.org> wrote:
>> >
>> > Amit Sethi ?wrote:
>> >
>>     
>>> >> Well I want to implement plug-in like mechanism for an application . I want
>>> >> to define some minimum functions that any body writing a plugin has to
>>> >> implement. For that i thought an interface would be best because in a
>>> >> scenario where the function is not implemented some kind of error would
>>> >> occur. I would love to hear if you think their is a better way to achieve
>>> >> this
>>>       
>> >
>> > In Java, deriving a class from such an interface, but neglecting to implement those methods will cause a compile error (if I recall correctly, it's been several years). ?In Python, the error will happen at run time. ?But an existing runtime error will occur even without such an interface, so it wouldn't seem you gain much. ?In Python, the interface does two things:
>> >
>> > 1) it's a comment, a common place to look for certain behavior.
>> > 2) it's potentially a source for an IDE to provide tool-tips or code completion
>> > 3) it can generate a different error, which is perhaps more useful to the developer unsure of how the method is spelled or used. ?This way he/she knows whether to fix the caller or the implementation.
>> >
>> > #3 seems valid to me.
>> >
>> >
>> >
>> > However, for the particular use-case, you might want to stretch a bit further. ?Since you've got one "user" (your code), and many "providers" (the plug-in writers) ?perhaps you could arrange that when the plugin is first encountered, you validate that it has all the required methods and data members. ?Not by calling them, but by scanning the object for their existence.
>> >
>   
It'd sure be easier if you had a sample of what you're already expecting 
to do.  Then I could use similar names, and refer to things much more 
easily.  It also might matter which version/implementation of Python 
you're using.  I'm using CPython 2.6 on XP.

I'll guess that you're using __import__ to import a module based on its 
name or location.  Further, I'll guess that the class name the user is 
supposed to implement is called Doit, and that if you had used 
interfaces, they would derive from your interface.  So you have code 
something like:

#interfacemodule.py
class MyInterface(object):

    def __init__(self, modulename):
        for method in ["doSomething", "doSomethingElse"]:
            m = getattr(self, method, None)
            if not m:
                print "Missing attribute %s in module %s, class Doit" % 
(method, modulename)
                raise NotImplementedError
            else:
                print "Found :", method, m



and they have code like:

import interfacemodule
class  Doit(MyInterface):
    def doSomething(self, line):
        print "line=", line
    def doSomethingElse42(self, line):         #method name deliberately 
spelled wrong, to trigger the error
        print "line=", line


After doing the __import__, you instantiate the new class.   Something 
like (untested):

x = __import__(filename)
newobject = x.Doit(filename)

Instantiating that object will test the attributes, making sure 
everything in your list exists.  Once you're sure they do, add the 
newobject to your list of plugins.

There's lots of other choices, but I suspect most will be trickier than 
this.  You may need them, depending on how much you trust your plugin 
writers.  For example, this doesn't help if they neglect to derive from 
MyInterface.  That's no big deal, since you could use a regular function 
instead of __init__ method, and run it on the object.