Read-only Protocol attributes (again)

[bryanforbes]

In my last question, I asked about how to mark a protocol attribute as read-only in order to accept either an object with a read-only attribute or a writable attribute. I have a similar question, but slightly different: How do I mark a Protocol attribute as read-only so that any object that the operation obj.prop is valid can be passed in. Here's a code sample:

from __future__ import annotations

from typing import Any, Protocol, TypeVar, overload


class Named(Protocol):
    # The answer from my last question
    @property
    def name(self) -> str:
        ...


class Person:
    name: str

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


class Animal:
    __name: str
    species: str

    def __init__(self, name: str, species: str) -> None:
        self.__name = name
        self.species = species

    @property
    def name(self) -> str:
        return self.__name


_D = TypeVar('_D', bound='AttrDescriptor')


class AttrDescriptor:
    attr: str

    def __init__(self, attr: str) -> None:
        self.attr = attr

    @overload
    def __get__(self: _D, instance: None, owner: Any) -> _D:
        ...

    @overload
    def __get__(self, instance: object, owner: Any) -> str:
        ...

    def __get__(self: _D, instance: Any, owner: Any) -> _D | str:
        if instance is None:
            return self

        return getattr(instance, self.attr, '')


class Unknown:
    name_storage: str
    name = AttrDescriptor('name_storage')

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


def print_name(obj: Named) -> None:
    print(obj.name)
    # obj.id = 2 will error because id is declared read/write


person = Person('John Doe')
animal = Animal('Pete', 'Dog')
unknown = Unknown('Monty Python')

reveal_type(Unknown.name)  # AttrDescriptor
reveal_type(unknown.name)  # str

print_name(person)  # OK
print_name(animal)  # OK because animal.id is not writable
print_name(unknown)  # not OK because it's expecting `name` to be `str` instead of `NameDescriptor`

In this example, all three objects can have the operation obj.name done on them and get a string value back, so it seems like they should match the Named protocol. However both mypy and pyright give an error that indicates unknown.name is an incompatible type. I can come up with a second protocol that has a descriptor protocol for name, but that will get incredibly complex if more attributes are needed. Should the convention of using @property in protocols for read-only attributes apply only to actual @property and standard attribute declarations, or should it apply to anything that can have the obj.name operation done on it?

[bryanforbes]

With the release of the SQLAlchemy 2.0 betas, this starts to become a lot more relevant. Here's a similar example to the above, but with SQLAlchemy:

from __future__ import annotations

from dataclasses import dataclass
from typing import Protocol

from sqlalchemy import Integer, String
from sqlalchemy.orm import DeclarativeBase, Mapped, MappedAsDataclass, mapped_column


class Base(MappedAsDataclass, DeclarativeBase):
    ...


class Named(Protocol):
    @property
    def name(self) -> str:
        ...


@dataclass
class Person:
    name: str


class Animal:
    __name: str

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

    @property
    def name(self) -> str:
        return self.__name


class Record(Base):
    __tablename__ = 'records'

    id: Mapped[int] = mapped_column(Integer, primary_key=True, init=False)
    name: Mapped[str] = mapped_column(String)


def print_name(obj: Named) -> None:
    print(obj.name)


person = Person('John Doe')
animal = Animal('Dog')
record = Record('thing')

print_name(person)  # OK
print_name(animal)  # OK
print_name(record)  # Error: Mapped[str] is incompatible with str