How to define a Protocol

Let’s create an example on how to create API where an Explainable protocol

from pydantic import BaseModel
from typing import List, Optional, Tuple
import numpy as np

import matplotlib.pyplot as plt
import matplotlib.figure
from abc import ABC

class BaseScorer(ABC, BaseModel):
    @abstractmethod
    def predict(self):
        ...

class MachineLearningScorer(BaseScorer):
    weights: np.ndarray
    learning_rate: float
    epochs: int
    batch_size: int
    loss_function: str
    optimizer: str
    accuracy: Optional[float] = None
    training_time: Optional[float] = None

    class Config:
        arbitrary_types_allowed = True
    
    def predict(self) -> float:
        # Not so smart
        return 1.0


class Explainable(Protocol):
    model: BaseScorer 
    
    def explain(self) -> Tuple[matplotlib.figure.Figure, plt.Axes] | str: 
        ...
        
class CreditEvaluator(BaseModel):
    model: BaseScorer
    
    def explain(self) -> Tuple[matplotlib.figure.Figure, plt.Axes] | str:
        print("Credit given due to several reasons")

We can now easily create a function that need Explainable models and asses their fairness:

def asses_fairness(model: Explainable):
    model.explain()

Note how all Scorers based on BaseScorer must implement a predict method. However they could be explainable or not

from abc import ABC, abstractmethod
from typing import Protocol

# Abstract Base Class
class Document(ABC):
    @abstractmethod
    def display(self):
        pass

# Mixin for search functionality
class SearchableMixin:
    def search(self, query):
        return f"Searching for '{query}' in {self.__class__.__name__}"

# Protocol for typing
class Displayable(Protocol):
    def display(self):
        pass

# Concrete implementation of a Document
class PdfDocument(Document, SearchableMixin):
    def display(self):
        return "Displaying PDF document content"

class WordDocument(Document, SearchableMixin):
    def display(self):
        return "Displaying Word document content"

def view_document(doc: Displayable):
    print(doc.display())

# Usage
pdf = PdfDocument()
word = WordDocument()

view_document(pdf)  # Works with PdfDocument
view_document(word) # Works with WordDocument

print(pdf.search("Python"))  # Utilizing mixin method

Composition of Protocols

Protocols can be mixed without a problem. But imagine that in our firs example, you have an Explainable protocol and you want also to create a Predictable protocol.

To refer those protocols on a single type, you can’t do it with an Union type alias, as that will match anything that satisfies at least one protocol, not both of them.

To achieve that functionality, you should make use of a composite protocol. Note that we need to subclass from Protocol, as subclassing from other Protocol do not automatically convert it in that.

from typing import runtime_checkable 

class Predictable(Protocol):
    def predict(self) -> list[int] | int | None:
        ...
    
@runtime_checkable
class ShapModel(Predictable, Explainable, Protocol):
    ...

You can use ShapModel anywhere a model should support predict and explain methods, without having to inherit from any base model. Remember that the especification of the protocol in the class declaration is optional class NewModel(ShapModel) or class NewModel.

For making it possible to check if an object satisfies a protocol with isinstance(), it is needed to use the runtime_checkable protocol. It is calling a __hasattr__ method of each of the expected variables and functions of the protocol.

´

Stay updated on Python tips

Hopefully, this post has helped familiarize you with Protocols in Python, how to use them and their main advantages and enabling you to enjoy their benefits.

If you want to stay updated…