Package: interface-meta
InterfaceMetainterface_metaprovides a convenient way to expose an extensible API with
enforced method signatures and consistent documentation.Documentation:See below (full documentation will come at some point).Source:https://github.com/matthewwardrop/interface_metaBug reports:https://github.com/matthewwardrop/interface_meta/issuesOverviewThis library has been extracted (with some modifications) fromomniduct, a library also principally
written by this author, where it was central to the extensible plugin
architecture. It places an emphasis on the functionality required to create a
well-documented extensible plugin system, whereby the act of subclassing is
sufficient to register the plugin and ensure compliance to the parent API. As
such, this library boasts the following features:All subclasses of an interface must conform to the parent's API.Hierarchical runtime property existence and method signature checking. Methods
are permitted to add additionaloptionalarguments, but otherwise must
conform to the API of their parent class (which themselves may have extended
the API of the interface).Subclass definition time hooks (e.g. for registration of subclasses into a
library of plugins, etc).Optional requirement for methods in subclasses to explicity decorate methods
with anoverridedecorator when replacing methods on an interface, making
it clearer as to when a class is introducing new methods versus replacing
those that form the part of the interface API.Generation of clear docstrings on implementations that stitches together the
base interface documentation with any downstream extensions and quirks.Support for extracting the quirks documentation for a method from other method
docstrings, in the event that subclass implementations are done in an internal
method.Compatibility with ABCMeta from the standard library.Example codefromabcimportabstractmethod,abstractpropertyfrominterface_metaimportInterfaceMeta,override,quirk_docsclassMyInterface(metaclass=InterfaceMeta):"""An example interface."""INTERFACE_EXPLICIT_OVERRIDES=TrueINTERFACE_RAISE_ON_VIOLATION=FalseINTERFACE_SKIPPED_NAMES={'__init__'}def__init__(self):"""MyInterface constructor."""pass@abstractpropertydefname(self):"""The name of this interface."""pass@quirk_docs(method='_do_stuff')defdo_stuff(self,a,b,c=1):"""Do things with the parameters."""returnself._do_stuff(a,b,c)@abstractmethoddef_do_stuff(self,a,b,c):passclassMyImplementation(MyInterface):"""This implementation of the example interface works nicely."""@quirk_docs(method='_init',mro=False)def__init__(self,a):"""MyImplementation constructor."""self._init(a)def_init(self,a):"""In this instance, we do nothing with a."""pass@property@overridedefname(self):return"Peter"@overridedef_do_stuff(self,a,b,c):"""In this implementation, we sum the parameters."""returna+b+cRunninghelp(MyImplementation)reveals how the documentation is generated:classMyImplementation(MyInterface)|Thisimplementationoftheexampleinterfaceworksnicely.||Methodresolutionorder:|MyImplementation|MyInterface|builtins.object||Methodsdefinedhere:||__init__(self,a)|MyImplementationconstructor.||Inthisinstance,wedonothingwitha.||do_stuff(self,a,b,c=1)|Dothingswiththeparameters.||MyImplementationQuirks:|Inthisimplementation,wesumtheparameters....Related projects and prior artThis library is released into an already crowded space, and the author would
like to recognise some of the already wonderful work done by others. The primary
difference between this and other libraries is typically these other libraries
focus more on abstracting interface definitions and compliance, and less on the
documentation and plugin registration work. While this work overlaps with these
projects, its approach is sufficiently different (in the author's opinion)
to warrant a separate library.pure_interfacepython-interfacepython-interfacehas an emphasis on ensuring that implementations of various
interfacesstrictlyadhere to the methods and properties associated with
the interface, and that helpful errors are raised when this is violated.By
comparison this library focusses on functional comformance to parent classes,
whereby methods on subclasses are allowed to include additional parameters. It
also focusses on ensuring that documentation for such quirks in method signatures are correctly composed into the final documentation rendered for that method.