Read-only Protocol attributes

[bryanforbes]

Is there a way to mark an attribute of a Protocol as read-only so that objects with read-write attributes as well as read-only properties can be assigned to that protocol. In TypeScript, I would do something like this:

interface Identifiable {
  readonly id: number;
}

class Person {
  id: number;
  name: string;

  constructor(id: number, name: string) {
    this.id = id;
    this.name = name;
  }
}

class Animal {
  readonly id: number;
  species: string;

  constructor(id: number, species: string) {
    this.id = id;
    this.species = species;
  }
}

function printID(object: Identifiable) {
  console.log(object.id);
  // object.id = 2 would error because of the readonly property
}

const person = new Person(1, 'John Doe');
const animal = new Animal(2, 'Dog');

printID(person); // OK
printID(animal); // OK

Using Protocol, I can only seemingly get so far:

from typing import Protocol

class Identifiable(Protocol):
    id: int    # how to mark this as read-only?

class Person:
    id: int
    name: str

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

class Animal:
    __id: int
    species: str

    def __init__(self, id: int, species: str) -> None:
        self.__id = id
        self.species = species

    @property
    def id(self) -> int:
        return self.__id

def print_id(object: Identifiable) -> None:
    print(object.id)
    # object.id = 2 will not error because id is declared read/write

person = Person(1, 'John Doe')
animal = Animal(2, 'Dog')

print_id(person)  # OK
print_id(animal)  # not OK because animal.id is not writable

[Akuli]

You can use a Protocol with a property that does not have a setter:

class Identifiable(Protocol):
    @property
    def id(self) -> int: ...

Now object.id = 2 fails with a readable mypy error: asd.py:29: error: Property "id" defined in "Identifiable" is read-only

As a side note, it's might not be a good idea to make a variable named id or object, as those are names of built-ins, and it's not clear whether object somewhere in the middle of the code refers to object the built-in class or some variable named object. This is worst with global variables, but I don't consider it good practice with local variables either.

[jonemo]

Don't inherit from the protocol.

Why is this the case? The section Explicitly declaring implementation of PEP 544 specifically allows for doing this:

To explicitly declare that a certain class implements a given protocol, it can be used as a regular base class. [...] while it’s possible to subclass a protocol explicitly, it’s not necessary to do so for the sake of type-checking.

I chose to do this because explicit is better than implicit and because it results in more actionable type checker errors when I inadvertently fail to implement a Protocol correctly. Case in point: Dropping the inheritance as you suggest does indeed make the exception go away, but I now have to put in extra effort to validate whether my type checker recognizes MyDataClass, MyNonDataClass, and MyPropClass as implementations of MyInterface or not.

[Kentzo]

Protocol is not an superficial interface it's a class that clashes with dataclass's logic to construct the final class under the hood.

It works best when not inherited. File a feature request against your IDE / typechecker for better support instead.

[hauntsaninja]

That section of PEP 544 also says:

the semantics of inheritance is not changed

The interaction with property here comes from the inheritance, e.g. the same thing happens with no Protocol in sight:

class A:
    @property
    def foo(self) -> int: ...

class B(A):
    def __init__(self):
        self.foo = 5

B()  # AttributeError: can't set attribute

Another common way to assert that a class implements a Protocol is a dummy assignment; I do this sometimes and it's useful, can even put it in a test file :-)

[jonemo]

Ok, fair enough, I understand why it happens now.

Circling back to the original question: Is there another way to define a read-only or read-write attribute in Protocol that is compatible with all the features of Protocol, including the explicit declaration of implementation?

[sigma67]

mypy kind of explicitly states to inherit from Protocol: https://mypy.readthedocs.io/en/stable/protocols.html