Best Way to Check for Required Arguments in Python Class

Question

I have a class which can be built with different combinations of arguments, but I have a list of arguments that are required. Here is how I currently check:

    # check for the required arguments
    rqrd_args = ['a', 'b', 'c']  # required arguments
    mssing_args = set(rqrd_args)-set(kwargs.keys())
    if mssing_args:
        error_lines = ['The following required arguments are missing:']
        error_lines.extend(['\t%s'%x for x in mssing_args])
        sys.exit('\n'.join(error_lines))

    # pull from kwargs
    self.a = kwargs['a']
    self.b = kwargs['b']
    self.c = kwargs['c']

I tend to re-use this code a lot. My question is, can I somehow replace the "#pull from kwargs" section with a loop that goes through the required argument list that way the code is more universal? Is there a reason why I wouldn't want to do this?

Answer 1

This should do the trick:

for attr_name in rqrd_args:
    setattr(self, attr_name, kwargs[attr_name])

Answer 2

If they're required, make them regular arguments:

def __init__(a, b, c, **kwargs):
    self.a = a
    self.b = b
    self.c = c
    # ... then the rest in kwargs

Answer 3

I tend to agree with other comments and answers that it's probably best to make these regular arguments and allow whatever Python errors may ensue to percolate up if wrong args are passed.

However, there could be times when you want to do some special validation process. I'm not endorsing that as a good design choice, but perhaps it could happen.

In that case, I'd say to create a decorator that contains your validation logic:

def arg_validator(*arg_names):
    from functools import wraps
    def decorator(func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            for arg in arg_names:
                if arg not in kwargs:
                    # Do some handling here for missing arg
            return func(*args, **kwargs)
        return wrapper
    return decorator

Then make a decorated helper function that constructs your class with the validation logic applied.

@arg_validator('a', 'b', 'c')
def my_class_maker(*args, **kwargs):
    return MyClass(*args, **kwargs)

Now if you call my_class_maker(...), the validation logic will be executed when the keyword arguments are checked by the decorated function. If all the needed args are there, you'll just get back the created instance.

This has the extra benefit that the validation logic is modular and kept separate from the logic of the class itself, since the idea of validating might be applied to many unrelated classes, each of which has no real reason to care about why external users of the class might need validation.

You could even extend the the decorator that I wrote and allow a callable to be passed into the decorator maker, and then that callable could encapsulate the validation behavior to execute if an argument is not found. Then, not even the specific validation behavior has to be fixed.