A powerful construct to parse class Meta blocks.

Parsing Meta Blocks using Python's dataclass

Class Meta is a ubiquitous Python pattern that's often used to define class-specific attributes in a framework.

For example, Django models use the Meta pattern 

This is a powerful pattern, but parsing options can get redundant. I was recently prototyping a system and found myself spending more type writing type-checks and option validation than I did actually solving the problem at hand. This inspired me to come up with a simple design pattern to reduce complexity. This pattern leverages Python’s new excellent 

class Model:
    @dataclass
    class MetaParser:
        quantity: int=0
        translations: field(default_factory=dict)

    class Meta:
        quantity = 123
        translations = { 'foo': 'bar' }

    def __init__(self):
        self.meta = None
        if hasattr(self, 'Meta'):
            data = {
                k: v for k, v in self.Meta.__dict__.items()
                if not k.startswith('__') and not callable(k)
            }
            self.meta = self.MetaParser(**data)

Ensures that valid arguments are passed and that they’re of the correct type. If, for example, 

 was a string, your program would throw a 

Ensures that no invalid options are passed. If, for example, we added an extraneous option in our 

 block, the program would also throw a 

All this in ~10 lines of code. This pattern is especially useful when dealing with tall inheritance chains and/or metaclasses.