Simple way to make individual attributes immutable?

[njsmith]

I'm a bad functional programmer and want to mutate parts of my classes. But it'd be nice if there were still a way to mark the parts of my class that are immutable as being immutable in a few key strokes. I usually won't bother if I have to work for it (I'm also lazy), but might catch some bugs. It seems this fits into attrs' general style. attr.ib(readonly=True)? Could be implemented as either a __setattr__ hook like frozen, or with a property.

[hynek]

Well, hm. It would be frozen=True to mirror the main option but it really sounds like a lot of complexity/rewriting…

[offbyone]

This turns out to be super useful when retrofitting existing codebases to use attrs.

[njsmith]

I suggested readonly instead of frozen because I thought frozen might suggest that the object stored there was immutable? Either could work really. And I can't comment on the implementation complexity, I just thought I'd throw it out there as an idle wish :-)

[hynek]

Quoth @Lukasa: I’d merge a (good) PR. ;)

[offbyone]

Could you provide some pointers as to where one would start, and what a good PR might look like?

[hynek]

Maybe @Tinche can be more helpful but I'd guess that we could adapt _frozen_setattrs or something?

The reason for my handwavevey delegation is mostly b/c I dunno. :)

[Tinche]

I'm not really sure how you'd go about implementing this.

One way: for a field x, implement a shadow field _x and create a property without a setter. The equivalent of

class A:
    def __init__(self, x):
        self._x = x
    @property
    def x(self):
        return self._x

This is how it's normally done when using manual classes.

Another way would be to install a custom __setattr__ (and __delattr__) that basically looks like this:

class A:
    def __setattr__(self, name, value):
        if name in __frozen_attr_names__:
            raise FrozenAttributeError('{} is frozen'.format(name))
        else:
            object.__setattr__(self, name, value)

This will impose a penalty on every assignment and every __init__ (since you'd have to use object.__setattr__ in __init__ to set the initial value).

I think the first approach is a little better.

Inheritance needs to be taken into account as well.

Maybe there are more ingenious approaches, so comments welcome :)

[offbyone]

I was approaching it from the descriptor angle, to be honest. I'm not interested in blocking serious workaround, just making readonly properties relatively easy:

class Attribute:
    def __set__(self, obj, value):
        raise FrozenAttributeError()

Would that not be a direction to start in?

[manishtomar]

How about using having a frozen instance and use evolve for mutable attributes? Too much overhead?

[Tinche]

class FrozenAttribute:
    def __set__(self, obj, value):
        raise AttributeError


class A:
    x = FrozenAttribute()

    def __init__(self, x):
        self.__dict__['x'] = x

>>> a = A(1)
>>> a.x
1
>>> a.x = 2
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "tt.py", line 9, in __set__
    raise AttributeError
AttributeError

Something like this, you mean? It's an interesting approach, but it won't work with slot classes. Maybe it could be made to support slot classes with a little more investigation though.

[Tinche]

Gah, if I ever meet @gvanrossum at a conference, I will buy him a drink and then continue to complain for 10 minutes about how immutability sucks in Python.

[Tinche]

Alright, I've been poking at frozen attributes for slot classes for a few hours now.

Good news: I actually understand Python descriptors now! (I think.) 🤓
Bad news: I don't think we can have frozen attributes for slot classes without speed penalties. 😡
Mediocre news: With a bit of C code we could have perfectly immutable zero-overhead slot classes and attributes. 🤔

Let me elaborate.

Slot classes store their instance contents in a hidden array. As far as I can tell, this space is basically inaccessible directly from Python. This is different from normal classes, which use instance.__dict__, and we can poke at this from Python with no issues.

When a slot class is defined, this space is allocated somewhere and a descriptor is made for each attribute. This descriptor is the only way to actually access this space. The descriptors are then placed into the class __dict__ (descriptors are always placed there).

These descriptors are of type member_descriptor, and are defined in descobject.c. The member_descriptor class/struct is very limited though. I tried subclassing the type - they can't be subclassed. I can wrap them with a different descriptor, hiding the __set__ and __delete__ and proxying __get__, but I can't use their __get__ directly, so there's always the overhead of wrapping so attribute access becomes ~4x slower, which isn't really acceptable to me.

I don't really know how to write C extensions, nor am I sure attrs would allow C extensions. However writing a descriptor in C that duplicates __get__ from member_descriptor and throws exceptions in other methods would get us overhead-free frozen slot classes and attributes. Any takers? 👀

It's also possible I've made a mistake somewhere, this stuff isn't exactly the simplest.