Java abstract/interface design in Python

May be you can use something like this. This will act as an abstract class. Every subclass is thus forced to implement func1()

class Abstract:

    def func1(self):
        raise NotImplementedError("The method not implemented")

I’m not that familiar with Python, but I would hazard a guess that it doesn’t.

The reason why interfaces exist in Java is that they specify a contract. Something that implements java.util.List, for example, is guaranteed to have an add() method to conforms to the general behaviour as defined on the interface. You could drop in any (sane) implementation of List without knowing its specific class, call a sequence of methods defined on the interface and get the same general behaviour.

Moreover, both the developer and compiler can know that such a method exists and is callable on the object in question, even if they don’t know its exact class. It’s a form of polymorphism that’s needed with static typing to allow different implementation classes yet still know that they’re all legal.

This doesn’t really make sense in Python, because it’s not statically typed. You don’t need to declare the class of an object, nor convince the compiler that methods you’re calling on it definitely exist. “Interfaces” in a duck-typing world are as simple as invoking the method and trusting that the object can handle that message appropriately.

Note – edits from more knowledgeable Pythonistas are welcome.

I wrote a library in 3.5+ the allows for writing interfaces in Python.

The gist is to write a class decorator with the help of inspect.

import inspect


def implements(interface_cls):
    def _decorator(cls):
        verify_methods(interface_cls, cls)
        verify_properties(interface_cls, cls)
        verify_attributes(interface_cls, cls)
        return cls

    return _decorator


def verify_methods(interface_cls, cls):
    methods_predicate = lambda m: inspect.isfunction(m) or inspect.ismethod(m)
    for name, method in inspect.getmembers(interface_cls, methods_predicate):
        signature = inspect.signature(method)
        cls_method = getattr(cls, name, None)
        cls_signature = inspect.signature(cls_method) if cls_method else None
        if cls_signature != signature:
            raise NotImplementedError(
                "'{}' must implement method '{}({})' defined in interface '{}'"
                .format(cls.__name__, name, signature, interface_cls.__name__)
            )


def verify_properties(interface_cls, cls):
    prop_attrs = dict(fget='getter', fset='setter', fdel='deleter')
    for name, prop in inspect.getmembers(interface_cls, inspect.isdatadescriptor):
        cls_prop = getattr(cls, name, None)
        for attr in prop_attrs:
            # instanceof doesn't work for class function comparison
            if type(getattr(prop, attr, None)) != type(getattr(cls_prop, attr, None)):
                raise NotImplementedError(
                    "'{}' must implement a {} for property '{}' defined in interface '{}'"  # flake8: noqa
                    .format(cls.__name__, prop_attrs[attr], name, interface_cls.__name__)
                )


def verify_attributes(interface_cls, cls):
    interface_attributes = get_attributes(interface_cls)
    cls_attributes = get_attributes(cls)
    for missing_attr in (interface_attributes - cls_attributes):
        raise NotImplementedError(
            "'{}' must have class attribute '{}' defined in interface '{}'"
            .format(cls.__name__, missing_attr, interface_cls.__name__)
        )


def get_attributes(cls):
    boring = dir(type('dummy', (object,), {}))
    return set(item[0] for item in inspect.getmembers(cls)
               if item[0] not in boring and not callable(item[1]))

You can then write classes like this:

class Quackable:
    def quack(self) -> bool:
        pass


@implements(Quackable)
class MallardDuck:    
    def quack(self) -> bool:
        pass

Below would give you an error though:

@implements(Quackable)
class RubberDuck:    
    def quack(self) -> str:
        pass

NotImplementedError: 'RubberdDuck' must implement method 'quack((self) -> bool)' defined in interface 'Quackable'

according this articule https://realpython.com/python-interface/ , this is how you can do formal interface:

import abc

class CRUDInterface(metaclass=abc.ABCMeta):
    @abc.abstractmethod
    def create(self, *args, **kwargs):
        """Load in the data set"""
        raise NotImplementedError
    
    @abc.abstractmethod
    def read(self, *args, **kwargs):
        """Load in the data set"""
        raise NotImplementedError
    
    @abc.abstractmethod
    def update(self, *args, **kwargs):
        """Load in the data set"""
        raise NotImplementedError
    
    @abc.abstractmethod
    def delete(self, *args, **kwargs):
        """Load in the data set"""
        raise NotImplementedError



class ModelTest1(CRUDInterface):
    def create(self, *args, **kwargs):
        pass
    def read(self, *args, **kwargs):
        pass
    def update(self, *args, **kwargs):
        pass
    def delete(self, *args, **kwargs):
        pass
    
class ModelTest2(CRUDInterface):
        pass
    

formal interface that will raise errors when the abstract methods aren’t overridden.

>>> t1 = ModelTest1()
>>> t2 = ModelTest2()
Traceback (most recent call last):
  File "../abstractmodel.py", line 46, in <module>
    t2 = ModelTest2()
TypeError: Can't instantiate abstract class ModelTest2 with abstract methods create, delete, read, update