pythonic way to expose user override hooks

Question

Note: although my particular use is Flask related, I think the question is more general.

I am building a Flask web application meant to be customized by the user. For example, the user is expected to provide a concrete subclass of a DatabaseInterface and may add to the list of certain ModelObjects that the application knows how to handle.

What is the best way to expose the various hooks to users, and indicate required and optional status? 'Best' here primarily means most 'pythonic', or "easiest for python users to grasp", but other criteria like not causing headaches down the road are certainly worth mentioning.

Some approaches I've considered:

• Rely solely on documentation

• Create a template file with documented overrides, much like default config files for many servers. E.g.

  app = mycode.get_app()
  ##Add your list of extra foo classes here
  #app.extra_foos = []
  

• Create a UserOverrides class with an attr/method for each of the hooks; possibly split into RequiredOverrides and OptionalOverrides

• Create an empty class with unimplemented methods that the user must subclass into a concrete instance

Answer 1

One method is by using abstract base classes (abc module). For example, you can define an ABC with abstract methods that must be overridden by child classes like this:

from abc import ABC


class MyClass(ABC):  # inherit from ABC

   def __init__(self):
      pass

    @abstractmethod
    def some_method(self, args):
        # must be overridden by child class
        pass

You would then implement a child class like:

class MyChild(MyClass):
    # uses parent's __init__ by default
    def some_method(self, args):
        # overrides the abstract method

You can specify what everything needs to do in the overridden methods with documentation. There are also decorators for abstract properties, class methods, and static methods. Attempting to instantiate an ABC that does not have all of its abstract methods/properties overridden will result in an error.

Answer 2

Inheritance. Is. Bad.

This is especially true in Python, which gives you a nice precedent to avoid the issue. Consider the following code:

len({1,2,3}) # set with length 3
len([1,2,3]) # list with length 3
len((1,2,3)) # tuple with length 3

Which is cool and all for the built-in data structures, but what if you want to make your own data structure and have it work with Python's len? Simple:

class Duple(object):
    def __init__(self, fst, snd):
        super(Duple, self).__init__()
        self.fst = fst
        self.snd = snd

    def __len__():
        return 2

A Duple is a two-element (only) data structure (calling it with more or fewer arguments raises) and now works with len:

len(Duple(1,2)) # 2

Which is exactly how you should do this:

def foo(arg):
    return arg.__foo__()

Any class that wants to work with your foo function just implements the __foo__ magic method, which is how len works under the hood.