Using Python descriptors: How best to write a general validation getter-setter

Question

And by best, I mean both Pythonically and with as few lines of code as possible.

I am used to defining classes with attributes in Python like so.

class MyClass(object):

    def __init__(self):
        self.value = 5

Often, however, I find myself needing to ensure that self.value can only take a specific type of value. In the past (coming from a PHP OOP background) I've done this with a getter-setter method similar to this:

    def value(self, new_value = -1)
        if new_value == -1:
            return self.value
        if isinstance(new_value, int) and new_value > -1:
            self.value = new_value
        else:
            raise TypeError

I then access self.value with self.value(), and set it with self.value(67). Usually I'll name-mangle self.value to self.__value to discourage its direct access.

I've recently discovered (or am in the process of discovering) descriptors. Following closely the excellent discussion here I've written something that looks like this:

class ValidatedAttribute(object):

    def __init__(self, key, kind):
        self.key = key
        self.kind = kind

    def __get__(self, instance, owner):
        if self.key not in instance.__dict__:
            raise AttributeError, self.key
        return instance.__dict__[self.key]

    def __set__(self, instance, value):
        if not isinstance(value, self.kind):
            raise TypeError, self.kind
        instance.__dict__[self.key] = value     


class MyUsefulClass(object):

    a = ValidatedAttribute("a", int)

But I have a few questions!

Firstly, what exactly is MyUsefulClass().a? Is it an instance of a ValidatedAttribute class somehow bound to an instance of a MyUsefulClass class?

And secondly, what I'd really like is something like,

class MyUsefulClass(object):

    def __init__(self):
        self.value = Checker(int, 99)

    def Checker(self, kind, default):
        # Code for verifying that associated attribute is of type kind.

and somehow bind an attribute access to some sort of intercept method, without having to use a whole other descriptor class.

I'm sorry if my understanding is lacking - I'm still getting to grips with new-style Python classes. Any help or pointers in the right direction would be much appreciated.

Veedrac · Answer 1 · 2013-09-20T15:54:45.040

Please, please, please do not do isinstance(new_value, int).

You might possibly get away with

from numbers import Integral
isinstance(new_value, Integral)

but it's completely anathema to duck typing.

Firstly, what exactly is MyUsefulClass().a? Is it an instance of a ValidatedAttribute class somehow bound to an instance of a MyUsefulClass class?

In order to find MyUsefulClass().a, Python asks the class. The class tells it that it has a getter-setter for the attribute and tells Python to ask the attribute. The attribute says finds it and then that tells the class what the attribute is. The attribute isn't the getter-setter.

MyUsefulClass.a is the getter-setter (property), not MyUsefulClass().a.

And secondly, what I'd really like is something like [stuff]

AFAIK, you can only set properties on the class, not on instances, because how would you know whether you want to retrieve the property or the item the property shadows?

There are times when duck-typing will not do: interfacing with other languages, with the system, with databases, etc. That's why we have `isinstance`. And the code runs fine, you just have assign a value before trying to access it. — Ethan Furman, Sep 20 '13 at 15:28
"And the code runs fine, you just have assign a value before trying to access it." Teehee, you'd not believe what I messed up to get to my conlusion ;). Yeah, disregard that. — Veedrac, Sep 20 '13 at 15:53

score 1 · Accepted Answer · answered Sep 20 '13 at 15:24

Firstly, what exactly is MyUsefulClass().a? Is it an instance of a ValidatedAttribute class somehow bound to an instance of a MyUsefulClass class?

Yes, that is it exactly.

And secondly, what I'd really like is something like [...] and somehow bind an attribute access to some sort of intercept method, without having to use a whole other descriptor class.

Well, you could overwrite __getattribute__, as it does intecept every attribute lookup, but it is way more complicated than using descriptors.

Descriptors work for exactly what you are wanting to do (automatic validation). About the only improvement you could make is to also use a metaclass to automatically set the key for you, and then your class code look like this:

class MyUsefulClass(object):

    a = ValidatedAttribute(int)

But first get comfortable with descriptors, metaclasses are complex and can be tough to grok.

Oh, and one small change I would make to your ValidatedAttribute:

def __init__(self, key, default):

    self.key = key
    self.kind = type(default)
    self.default = default

def __get__(self, instance, owner):
    if self.key not in instance.__dict__:
        return self.default
    return instance.__dict__[self.key]

I chose this answer because it introduced me to `__getattribute__`, which I was unaware of before. I don't think that this is the most elegant solution, but overriding `__getattribute__` certainly would be the most general and least bloated solution to my problem, at least out of those solutions I've found so far. — snoopy91, Sep 23 '13 at 11:22

score 1 · Answer 3 · answered Sep 20 '13 at 19:10

Instead of writing this stuff yourself, use the traits library: https://pypi.python.org/pypi/traits. Using libraries is the pythonic approach to most problems.

However, in general, you should write code that is sufficiently generic that this sort of checking is largely unnecessary. It's easy to do in python.

score 0 · Answer 4 · edited May 23 '17 at 11:44

0

I think what you're looking for are python properties. Correct approach to validate attributes of an instance of class seems relevant to your qeustion. You might also look at Python descriptor vs property

edited May 23 '17 at 11:44

Community

1
1

answered Sep 20 '13 at 15:11

Greg Whittier

3,105
1
19
14

GP89 · Answer 5 · 2013-09-20T15:18:31.467

0

It sounds like you want to use properties

class MyUsefulClass(object):

    def __init__(self):
        self._value = 0

    @property
    def value(self):
        return self._value

    @value.setter
    def value(self, value):
        self._value = self.Checker(value, int, 99)

    def Checker(self, value, kind, default):
        return value if isinstance(value, kind) else default

edited Sep 20 '13 at 15:18

answered Sep 20 '13 at 15:12

GP89

6,600
4
36
64

Properties are something that I considered, but my problem with them is having to explicitly define getter and setter functions for each attribute to be validated in this way. It's more or less as verbose as writing a single getter-setter function for each "private" attribute, which is what I do at the moment. (That is, writing `def myattr(self, value)` to get and set `self.__myattr`, for example.) – snoopy91 Sep 23 '13 at 11:20

Using Python descriptors: How best to write a general validation getter-setter

5 Answers5