Intfprgm helps separate interface from implementation.
Intfprgm offers a set of decorators to clearly mark and enforce a class to be an interface, an abstract class, or a concrete class, and a function to be abstract.
To define an abstract function, we can use abstract decorator:
@abstract def func(): pass
Or raise NotImplementedError in the very first line:
def func(): raise NotImplementedError()
An interface can be defined with interface decorator:
@interface class Interface(object): def method_1(self): raise NotImplementedError() @abstract def method_2(self): pass
An abstract class is defined with the same abstract decorator:
@abstract class BaseClass(Interface): def method_1(self): pass # method_2 is inherited from Interface and is still undefined
A concrete class is defined with concrete decorator:
@concrete class ConcreteClass(BaseClass): def method_2(self): pass
When you need to ensure that your derived classes correctly override a method in their bases, you can use overrides decorator. This decorator must be applied on both the derived class, and its overriden methods:
class Base(object): def to_be_overriden(self): pass @overrides class Derived(Base): @overrides def to_be_overriden(self): pass