Question about read-only types

[maufl]

Hi, I'm currently trying to find out whether it's possible to have a generic type that works like Readonly in Typescript. While it's built into Typescript, you could also define it yourself using Mapped Types.

So far I did not find a way of doing this. If it's possible at all, then probably using a generic class with a fancy __getattribute__ implementation?

A use case for this would be typing the returned values of libraries like gelidum for example.
I specifically would want to have this to type returned objects from SQLAlchemy sessions that have been expunged. The properties of these objects can still be read, but if you try to set one of them, the change will not be persisted if you commit the session, since the object is not attached to the session. Marking them as read-only would prevent someone from accidentally trying to change them.
An added benefit is that, if you can make a function argument Readonly[User], you also communicate that you will not change the passed argument.

Example of what this could look like:

class User:
    name: str
    age: int

    def __init__(self, name: str, age: int) -> None:
        self.name = name
        self.age = age

felix = User(name="Felix", age=33)

felix.age = 34 # this is allowed

def print_user(user: Readonly[User]) -> None:
    print(f"User(name={user.name}, age={user.age}") # reading attributes is allowed
    user.age = user.age + 1 # this is not allowed, user is readonly

Is it possible to define Readonly? Maybe the only way is to write a mypy plugin similar to the one for dataclasses?

[hauntsaninja]

You can use @property. This is a particularly useful trick when combined with Protocols (substructural typing)

from typing import Protocol

class HasReadOnlyTitle(Protocol):
    @property
    def title(self) -> str: ...

[maufl]

Thanks for converting this to a discussion! 🙏 I didn't realize they are used.

How would I use this with a generic class/protocol, where I don't know the properties of the type I'm being generic over?

[hauntsaninja]

I'm not sure I understand the question. Protocols can be generic https://mypy.readthedocs.io/en/stable/generics.html#generic-protocols. This would e.g. let you have a generic return type from the property.

[maufl]

Sorry, I'll add an example.

[erictraut]

Python's type system has no equivalent of TypeScript's keyof operator, so there's no way to transform attributes of fields in a generic way, such as setting them all to "readonly".

[willstott101]

I am receiving large json objects which I am parsing into dicts/lists/strings/numbers and over time receiving patches to these objects. I apply the patch, and want to provide the new state of the object to my program. This is pure data these are not classes, just native types. To be safe I have to deepcopy this object when I hand it off to make sure future patches can't be corrupted by me or anyone else accidentally mutating the data.

What would be perfect is if I could return the internal data type marked as readonly, to avoid an expensive copy.

Perhaps this situation is more concrete, but similar enough to continue as a discussion.

[Daverball]

strings and numbers are already immutable, for dicts and lists you can use the abstract Mapping and Sequence classes where the type checker has to assume they can't be mutated, MutableMapping and MutableSequence would be the mutable versions of that. Mapping and Sequence are also covariant, since it's safe for them to be. list and dict will just autocast to Mapping and Sequence.

I do sometimes use a JSON_ro TypeAlias which can be quite useful sometimes on parameters since it's not quite as annoying as the invariant version of this type definition that uses lists and dicts: JSON_ro: TypeAlias = Mapping[str, JSON_ro] | Sequence[JSON_ro] | str | float | bool | None