Python way for object method chaining for class instance variables

Question

The use case :

I have a form object which receives instance variables (form fields). Now I like to validate there variables using method chaining. An example with arbitrary methods :

class Field(object):

    def __init__(self, form, name):
        self.form = form
        self.name = name

    def unspace(self):
        setattr(self.form, self.name, getattr(self.form, self.name).replace(' ',''))
        return self

    def len_valid(self, length):
        if len(getattr(self.form, self.name)) < length :
            setattr(self.form, self.name + '_invalid', True)
            self.form.valid = False
        return self

class Forms(object):                                                                                    

    def __init__(self):
        self.valid = True

    def validate(self, name):
        return Field(self,name)

f = Forms()         # create the form with some data
f.a = 'J o Hn '
f.b = ' Too   L o n g'

f.validate('a').unspace().len_valid(2)  
f.validate('b').unspace().len_valid(5)  

RESULT :
f.a : 'JoHn'
f.a_invalid : True
f.b : 'TooLong'
f.valid : False

Is this the Pythonic way to create method chaining on the Form instance variables.

Not a direct answer, but: is there a reason these things have to be attributes (instance variables) instead of just members of a dict, so you can drop all the setattr/getattr stuff and write simple, direct code? — abarnert
– abarnert, Commented Dec 12, 2012 at 18:28
You're making this way too complicated. Do what @abarnert says and just put everything in a dict. — Katriel
– Katriel, Commented Dec 12, 2012 at 18:29

abarnert · Accepted Answer · 2012-12-12 20:34:40Z

4

Yes and no.

The Pythonic way to chain method calls is exactly what you've written:

f.validate('a').unspace().len_valid(2)

But the Pythonic way to access attributes dynamically is to not do that unless you have to. If the form variables were stored in a dict instead of as instance variables of the object, everything would be much simpler and more readable.

Even if you really need the form variables to be accessible as f.a instead of f['a'] (e.g., because this is part of an interactive shell, or some third-party API requires that), it's actually easier to write all your code around a dict, and use your favorite AttrDict class (from PyPI or ActiveState) to provide the attribute-style access for your user/third-party API.

Also, if you further changed the Field object to be a trivial wrapper around a value with some methods, instead of (in effect) a reference to a parent and a key, it would be even simpler.

Also, if you generate new attributes on the fly like a_invalid, you probably want to always generate them, not only when they're true. Otherwise, checking whether a is valid looks something like this:

try:
    avalid = not f.a_invalid
except NameError:
    avalid = True

That's horribly convoluted, but if your caller wants to avoid that, the only way to do so is something like this:

avalid = not getattr(f, 'a_invalid', False)

Which seems to defeat the whole purpose of faking attributes for the caller in the first place.

Also, keep in mind that you have to make sure that there can never be a field whose name ends with _invalid. Since you can attach new attributes to almost anything in Python, so if you really do want to do everything this way, why use f.a_invalid instead of, say, f.a.invalid?

Since you asked in the comments, a trivial wrapper around a value looks like this:

class Field(object):

    def __init__(self, value):
        self.value = value
        self.valid = True

    def unspace(self):
        self.value = self.value.replace(' ', '')
        return self

    def len_valid(self, length):
        if len(self.value) < length:
            self.valid = False
        return self

Instead of making each field reach up to the Form to set its validity, just make the Form do it:

class Form(object):
    …
    def valid(self):
        return all(field.valid for field in self.fields)

And if you really need to make that valid look like a member variable rather than a method, just use @property.

edited Dec 12, 2012 at 20:34

answered Dec 12, 2012 at 18:32

abarnert

368k54 gold badges626 silver badges691 bronze badges

Sign up to request clarification or add additional context in comments.

12 Comments

Marcin Over a year ago

Or you could just use an existing form validation library.

voscausa Over a year ago

@Marcin : The form validation is part of a form wizzard. This is why i did not use a validation library.

voscausa Over a year ago

@abarnert. Thanks for your great comment. I use names with _invalid for my Jinja templates, because I can remove them easy. Can you give me an example of your "trivial wrapper". By the way : I switched from a dict to instance variables to make it more readable. With your suggestions like AttrDict I will give it another try.

Marcin Over a year ago

@voscausa I have no idea why that would be a reason not to use an existing library for this task.

abarnert Over a year ago

@Marcin: Except, of course, that you might want to use an existing form wizard library that had its own validation system, so then you wouldn't need a separate form validation library. :)

|

Collectives™ on Stack Overflow

Python way for object method chaining for class instance variables

1 Answer 1

12 Comments

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

1 Answer 1

12 Comments

Your Answer

Sign up or log in

Post as a guest

Linked

Related