Using Metaclasses

Ideally, you would wantissubclass(EmlParser, InformalParserInterface) to returnFalse when the implementing class doesn’t define all of the interface’s abstract methods. To do this, you’ll create ametaclass calledParserMeta. You’ll be overriding twodunder methods:

1. .__instancecheck__()
2. .__subclasscheck__()

In the code block below, you create a class calledUpdatedInformalParserInterface that builds from theParserMeta metaclass:

classParserMeta(type):"""A Parser metaclass that will be used for parser class creation.    """def__instancecheck__(cls,instance):returncls.__subclasscheck__(type(instance))def__subclasscheck__(cls,subclass):return(hasattr(subclass,'load_data_source')andcallable(subclass.load_data_source)andhasattr(subclass,'extract_text')andcallable(subclass.extract_text))classUpdatedInformalParserInterface(metaclass=ParserMeta):"""This interface is used for concrete classes to inherit from.    There is no need to define the ParserMeta methods as any class    as they are implicitly made available via .__subclasscheck__().    """pass

Now thatParserMeta andUpdatedInformalParserInterface have been created, you can create your concrete implementations.

First, create a new class for parsing PDFs calledPdfParserNew:

classPdfParserNew:"""Extract text from a PDF."""defload_data_source(self,path:str,file_name:str)->str:"""Overrides UpdatedInformalParserInterface.load_data_source()"""passdefextract_text(self,full_file_path:str)->dict:"""Overrides UpdatedInformalParserInterface.extract_text()"""pass

Here,PdfParserNew overrides.load_data_source() and.extract_text(), soissubclass(PdfParserNew, UpdatedInformalParserInterface) should returnTrue.

In this next code block, you have a new implementation of the email parser calledEmlParserNew:

classEmlParserNew:"""Extract text from an email."""defload_data_source(self,path:str,file_name:str)->str:"""Overrides UpdatedInformalParserInterface.load_data_source()"""passdefextract_text_from_email(self,full_file_path:str)->dict:"""A method defined only in EmlParser.        Does not override UpdatedInformalParserInterface.extract_text()        """pass

Here, you have a metaclass that’s used to createUpdatedInformalParserInterface. By using a metaclass, you don’t need to explicitly define the subclasses. Instead, the subclass mustdefine the required methods. If it doesn’t, thenissubclass(EmlParserNew, UpdatedInformalParserInterface) will returnFalse.

Runningissubclass() on your concrete classes will produce the following:

>>>issubclass(PdfParserNew,UpdatedInformalParserInterface)True>>>issubclass(EmlParserNew,UpdatedInformalParserInterface)False

As expected,EmlParserNew is not a subclass ofUpdatedInformalParserInterface since.extract_text() wasn’t defined inEmlParserNew.

Now, let’s have a look at the MRO:

>>>PdfParserNew.__mro__(<class '__main__.PdfParserNew'>, <class 'object'>)

As you can see,UpdatedInformalParserInterface is a superclass ofPdfParserNew, but it doesn’t appear in the MRO. This unusual behavior is caused by the fact thatUpdatedInformalParserInterface is avirtual base class ofPdfParserNew.

Using Virtual Base Classes

In the previous example,issubclass(PdfParserNew, UpdatedInformalParserInterface) returnedTrue, even thoughUpdatedInformalParserInterface did not appear in thePdfParserNew MRO. That’s becauseUpdatedInformalParserInterface is avirtual base class ofPdfParserNew.

The key difference between these and standard subclasses is that virtual base classes use the.__subclasscheck__() dunder method to implicitly check if a class is a virtual subclass of the superclass. Additionally, virtual base classes don’t appear in the subclass MRO.

Take a look at this code block:

classPersonMeta(type):"""A person metaclass"""def__instancecheck__(cls,instance):returncls.__subclasscheck__(type(instance))def__subclasscheck__(cls,subclass):return(hasattr(subclass,'name')andcallable(subclass.name)andhasattr(subclass,'age')andcallable(subclass.age))classPersonSuper:"""A person superclass"""defname(self)->str:passdefage(self)->int:passclassPerson(metaclass=PersonMeta):"""Person interface built from PersonMeta metaclass."""pass

Here, you have the setup for creating your virtual base classes:

1. The metaclassPersonMeta
2. The base classPersonSuper
3. The Python interfacePerson

Now that the setup for creatingvirtual base classes is done you’ll define two concrete classes,Employee andFriend. TheEmployee class inherits fromPersonSuper, whileFriend implicitly inherits fromPerson:

# Inheriting subclassesclassEmployee(PersonSuper):"""Inherits from PersonSuper    PersonSuper will appear in Employee.__mro__    """passclassFriend:"""Built implicitly from Person    Friend is a virtual subclass of Person since    both required methods exist.    Person not in Friend.__mro__    """defname(self):passdefage(self):pass

AlthoughFriend does not explicitly inherit fromPerson, it implements.name() and.age(), soPerson becomes avirtual base class ofFriend. When you runissubclass(Friend, Person) it should returnTrue, meaning thatFriend is a subclass ofPerson.

The followingUML diagram shows what happens when you callissubclass() on theFriend class:

Taking a look atPersonMeta, you’ll notice that there’s another dunder method called.__instancecheck__(). This method is used to check if instances ofFriend are created from thePerson interface. Your code will call.__instancecheck__() when you useisinstance(Friend, Person).

Usingabc.ABCMeta

To enforce the subclass instantiation of abstract methods, you’ll utilize Python’s builtinABCMeta from theabc module. Going back to yourUpdatedInformalParserInterface interface, you created your own metaclass,ParserMeta, with the overridden dunder methods.__instancecheck__() and.__subclasscheck__().

Rather than create your own metaclass, you’ll useabc.ABCMeta as the metaclass. Then, you’ll overwrite.__subclasshook__() in place of.__instancecheck__() and.__subclasscheck__(), as it creates a more reliable implementation of these dunder methods.

Using.__subclasshook__()

Here’s the implementation ofFormalParserInterface usingabc.ABCMeta as your metaclass:

importabcclassFormalParserInterface(metaclass=abc.ABCMeta):@classmethoddef__subclasshook__(cls,subclass):return(hasattr(subclass,'load_data_source')andcallable(subclass.load_data_source)andhasattr(subclass,'extract_text')andcallable(subclass.extract_text))classPdfParserNew:"""Extract text from a PDF."""defload_data_source(self,path:str,file_name:str)->str:"""Overrides FormalParserInterface.load_data_source()"""passdefextract_text(self,full_file_path:str)->dict:"""Overrides FormalParserInterface.extract_text()"""passclassEmlParserNew:"""Extract text from an email."""defload_data_source(self,path:str,file_name:str)->str:"""Overrides FormalParserInterface.load_data_source()"""passdefextract_text_from_email(self,full_file_path:str)->dict:"""A method defined only in EmlParser.        Does not override FormalParserInterface.extract_text()        """pass

If you runissubclass() onPdfParserNew andEmlParserNew, thenissubclass() will returnTrue andFalse, respectively.

Usingabc to Register a Virtual Subclass

Once you’ve imported theabc module, you can directlyregister a virtual subclass by using the.register() metamethod. In the next example, you register the interfaceDouble as a virtual base class of the built-in__float__ class:

classDouble(metaclass=abc.ABCMeta):"""Double precision floating point number."""passDouble.register(float)

You can check out the effect of using.register():

>>>issubclass(float,Double)True>>>isinstance(1.2345,Double)True

By using the.register() meta method, you’ve successfully registeredDouble as a virtual subclass offloat.

Once you’ve registeredDouble, you can use it as classdecorator to set the decorated class as a virtual subclass:

@Double.registerclassDouble64:"""A 64-bit double-precision floating-point number."""passprint(issubclass(Double64,Double))# True

The decorator register method helps you to create a hierarchy of custom virtual class inheritance.

Using Subclass Detection With Registration

You must be careful when you’re combining.__subclasshook__() with.register(), as.__subclasshook__() takes precedence over virtual subclass registration. To ensure that the registered virtual subclasses are taken into consideration, you must addNotImplemented to the.__subclasshook__() dunder method. TheFormalParserInterface would be updated to the following:

classFormalParserInterface(metaclass=abc.ABCMeta):@classmethoddef__subclasshook__(cls,subclass):return(hasattr(subclass,'load_data_source')andcallable(subclass.load_data_source)andhasattr(subclass,'extract_text')andcallable(subclass.extract_text)orNotImplemented)classPdfParserNew:"""Extract text from a PDF."""defload_data_source(self,path:str,file_name:str)->str:"""Overrides FormalParserInterface.load_data_source()"""passdefextract_text(self,full_file_path:str)->dict:"""Overrides FormalParserInterface.extract_text()"""pass@FormalParserInterface.registerclassEmlParserNew:"""Extract text from an email."""defload_data_source(self,path:str,file_name:str)->str:"""Overrides FormalParserInterface.load_data_source()"""passdefextract_text_from_email(self,full_file_path:str)->dict:"""A method defined only in EmlParser.        Does not override FormalParserInterface.extract_text()        """passprint(issubclass(PdfParserNew,FormalParserInterface))# Trueprint(issubclass(EmlParserNew,FormalParserInterface))# True

Since you’ve used registration, you can see thatEmlParserNew is considered a virtual subclass of yourFormalParserInterface interface. This is not what you wanted sinceEmlParserNew doesn’t override.extract_text().Please use caution with virtual subclass registration!

Using Abstract Method Declaration

Anabstract method is a method that’s declared by the Python interface, but it may not have a useful implementation. The abstract method must be overridden by the concrete class that implements the interface in question.

To create abstract methods in Python, you add the@abc.abstractmethod decorator to the interface’s methods. In the next example, you update theFormalParserInterface to include the abstract methods.load_data_source() and.extract_text():

classFormalParserInterface(metaclass=abc.ABCMeta):@classmethoddef__subclasshook__(cls,subclass):return(hasattr(subclass,'load_data_source')andcallable(subclass.load_data_source)andhasattr(subclass,'extract_text')andcallable(subclass.extract_text)orNotImplemented)@abc.abstractmethoddefload_data_source(self,path:str,file_name:str):"""Load in the data set"""raiseNotImplementedError@abc.abstractmethoddefextract_text(self,full_file_path:str):"""Extract text from the data set"""raiseNotImplementedErrorclassPdfParserNew(FormalParserInterface):"""Extract text from a PDF."""defload_data_source(self,path:str,file_name:str)->str:"""Overrides FormalParserInterface.load_data_source()"""passdefextract_text(self,full_file_path:str)->dict:"""Overrides FormalParserInterface.extract_text()"""passclassEmlParserNew(FormalParserInterface):"""Extract text from an email."""defload_data_source(self,path:str,file_name:str)->str:"""Overrides FormalParserInterface.load_data_source()"""passdefextract_text_from_email(self,full_file_path:str)->dict:"""A method defined only in EmlParser.        Does not override FormalParserInterface.extract_text()        """pass

In the above example, you’ve finally created a formal interface that will raise errors when the abstract methods aren’t overridden. ThePdfParserNew instance,pdf_parser, won’t raise any errors, asPdfParserNew is correctly overriding theFormalParserInterface abstract methods. However,EmlParserNew will raise an error:

>>>pdf_parser=PdfParserNew()>>>eml_parser=EmlParserNew()Traceback (most recent call last):...TypeError:Can't instantiate abstract class EmlParserNew with abstract methods extract_text

As you can see, thetraceback message tells you that you haven’t overridden all the abstract methods. This is the behavior you expect when building a formal Python interface.

Java

Unlike Python,Java contains aninterface keyword. Keeping with the file parser example, you declare an interface in Java like so:

publicinterfaceFileParserInterface{// Static fields, and abstract methods go here ...publicvoidloadDataSource();publicvoidextractText();}

Now you’ll create two concrete classes,PdfParser andEmlParser, to implement theFileParserInterface. To do so, you must use theimplements keyword in the class definition, like so:

publicclassEmlParserimplementsFileParserInterface{publicvoidloadDataSource(){// Code to load the data set}publicvoidextractText(){// Code to extract the text}}

Continuing with your file parsing example, a fully-functional Java interface would look something like this:

importjava.util.*;importjava.io.*;publicclassFileParser{publicstaticvoidmain(String[]args)throwsIOException{// The main entry point}publicinterfaceFileParserInterface{HashMap<String,ArrayList<String>>file_contents=null;publicvoidloadDataSource();publicvoidextractText();}publicclassPdfParserimplementsFileParserInterface{publicvoidloadDataSource(){// Code to load the data set}publicvoidextractText(){// Code to extract the text}}publicclassEmlParserimplementsFileParserInterface{publicvoidloadDataSource(){// Code to load the data set}publicvoidextractText(){// Code to extract the text}}}

As you can see, a Python interface gives you much more flexibility during creation than a Java interface does.

C++

Like Python, C++ uses abstract base classes to create interfaces. When defining an interface in C++, you use the keywordvirtual to describe a method that should be overwritten in the concrete class:

classFileParserInterface{public:virtualvoidloadDataSource(std::stringpath,std::stringfile_name);virtualvoidextractText(std::stringfull_file_name);};

When you want to implement the interface, you’ll give the concrete class name, followed by a colon (:), and then the name of the interface. The following example demonstrates C++ interface implementation:

classPdfParser:FileParserInterface{public:voidloadDataSource(std::stringpath,std::stringfile_name);voidextractText(std::stringfull_file_name);};classEmlParser:FileParserInterface{public:voidloadDataSource(std::stringpath,std::stringfile_name);voidextractText(std::stringfull_file_name);};

A Python interface and a C++ interface have some similarities in that they both make use of abstract base classes to simulate interfaces.

Go

Although Go’s syntax is reminiscent of Python, the Go programming language contains aninterface keyword, like Java. Let’s create thefileParserInterface in Go:

typefileParserInterfaceinterface{loadDataSet(pathstring,filenamestring)extractText(full_file_pathstring)}

A big difference between Python and Go is that Go doesn’t have classes. Rather, Go is similar toC in that it uses thestruct keyword to create structures. Astructure is similar to a class in that a structure contains data and methods. However, unlike a class, all of the data and methods are publicly accessed. The concrete structs in Go will be used to implement thefileParserInterface.

Here’s an example of how Go uses interfaces:

packagemaintypefileParserInterfaceinterface{loadDataSet(pathstring,filenamestring)extractText(full_file_pathstring)}typepdfParserstruct{// Data goes here ...}typeemlParserstruct{// Data goes here ...}func(ppdfParser)loadDataSet(){// Method definition ...}func(ppdfParser)extractText(){// Method definition ...}func(eemlParser)loadDataSet(){// Method definition ...}func(eemlParser)extractText(){// Method definition ...}funcmain(){// Main entrypoint}

Unlike a Python interface, a Go interface is created using structs and the explicit keywordinterface.