anti-patterns in object oriented programming

anti_patterns.py

"""
This is a demonstration of an anti-pattern I have come across in other people's
code that frustrates me. This is only meant as a silly learning exercise and
nothing more.
"""
def bad_config(some_object):
    try:
        data = some_object.data_field.get_data()
    except NoDataError:
        some_object.has_data = False 
    some_object.has_data = True

class ValidatorClass(object):
    bound_data = None 
    def __init__(self, 
                max_length=None, 
                min_length=None, 
                required=False, 
                initial=None):
        self.max_length = max_length
        self.min_length = min_length
        self.required = required
        self._validators = self.construct_validators() 
        if initial:
            self.run_validators(initial)
            self.bound_data = initial 

    def set_data(self, data):
        self.run_validators(data)
        self.bound_data = data

    def get_data(self, default=None):
        if not self.bound_data:
            raise NoDataError
        else:
            return self.bound_data

    def run_validators(self, data):
        for validator in self._validators:
            if not validator(data):
                raise NotValidError

    def construct_validators(self):
        _validators = []
        if self.required:
            req_valid = lambda data : data
            _validators.append(req_valid)
        if self.max_length:
            max_valid = lambda data : data.len() < self.max_length
            _validators.append(max_valid)
        if self.min_length:
            min_valid = lambda data : data.len() > self.min_length
            _validators.append(min_valid)
        return _validators 

class NotValidError(Exception):
    pass

class NoDataError(Exception):
    pass

class SomeObjectToProcessData(object):
    data_field =  ValidatorClass(
            max_length=120,
            required=True
        )
  
    def __init__(self):
        # This is the anti-pattern
        # We are adding additional validation to this class by passing it off to another function
        # as opposed to encapsulating that additional config in a mixin or bound clean method.
        # I hate this. 
        bad_config(self)