What to do about setters of a different type than their property?

[sixolet]

Consider this code:

import typing
class A:
 @property
 def f(self) -> int:
 return 1
 @f.setter # Possible error for defining a setter that doesn't accept the type the @property returns
 def f(self, x: str) -> None:
 pass
a = A()
a.f = '' # Possibly not an error, but currently mypy gives an error
a.f = 1 # Certainly should be an error, unless we disallowed 
 # defining the setter this way in the first place.
reveal_type(a.f) # E: Revealed type is 'builtins.int'

Whatever we decide, I'm happy to build a PR; I have this code loaded into my head.

[sixolet]

In other words "with arbitrary setters, you can have an lvalue be of a different type than its corresponding rvalue"

[gvanrossum]

IIRC we debated a similar issues when descriptors were added and decided that it's a perverse style that we just won't support. If you really have this you can add # type: ignore.

[sixolet]

Right now, you have to # type: ignore the line that says a.f = '', but not the definition. Should you have to # type: ignore the setter definition too? My inclination is yes, but I'm not sure of this.

[gvanrossum]

What does a discrepancy between __get__ and __set__ (when using as a descriptor) do? I think that's the example to follow.

[srittau]

One real-life case where I encountered this a few times now is a normalizing property like this:

from typing import Set, Iterable


class Foo:

 def __init__(self) -> None:
 self._foo = set() # type: Set[int]

 @property
 def foo(self) -> Set[int]:
 return self._foo

 @foo.setter
 def foo(self, v: Iterable[int]) -> None:
 self._foo = set(v)


Foo().foo = [1, 2, 3]

I like this implementation, because it allows a user of the cleverly named class Foo not to care about the exact type of the property, while Foo can use the best representation internally, while also giving additional guarantees when accessing the property.

Using the same type in the getter and setter would complicate the life of its users.

[dacut]

I disagree that this is "perverse" -- contravariance in the setter is one example, e.g. where the getter returns Set[x] and the setter takes Collection[x]:

from typing import Collection, Set

class X():
 @property
 def hello(self) -> Set[str]:
 return {"x", "y"}
 
 @hello.setter
 def hello(self, value: Collection[str]) -> None:
 pass

x = X()
x.hello = ["1", "2", "3"]

% mypy --version
mypy 0.701
% mypy mypy3004.py
mypy3004.py:13: error: Incompatible types in assignment (expression has type "List[str]", variable has type "Set[str]")

In my current case, I'm being even stricter in the getter, returning FrozenSet[x] to prevent accidental misuse of the returned collection (thinking it will change the attribute in the object itself).

[ilevkivskyi]

What does a discrepancy between __get__ and __set__ (when using as a descriptor) do? I think that's the example to follow.

Descriptors actually support different types as one would expect. However, properties were implemented before descriptors (using some heavy special-casing) so they don't support this.

I think this is a valid feature to support. I have seen this a lot recently in internal code bases, mostly in context similar to example by @srittau (canonical representation). This however may be tricky to implement (because of the special-casing I mentioned). Maybe a better strategy would be to just make property a regular descriptor in mypy (I believe we already have an issue for that), then this will be supported automatically.

[ilevkivskyi]

FTR, the main issue about properties is #220