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