Possible to define a generic property?

[martsa1]

Feature Request, or just a clarification of whats possible, using python 3.6.10, Mypy 0.761

Hi folks,

I have some code which uses a class decorator to mutate a collection of callables, into a collection of properties, which has recently lead me down a bit of a garden path with mypy.

I believe that I can refactor my work to make use of a generic property, and achieve a similar net goal. What I would quite like to create, would be something loosely like a Generic Protocol that describes a property. With that I'd be able to define something approximately like this (I may need to clarify a bit further):

class Foo:
    foo: Property[str] = property(lambda _: "Foo")
    foobar: Property[str] = property(lambda self: self.foo + "bar")

f = Foo()

def test(thing: str):
    print(thing)

test(f.foo)  # Mypy would be able to verify that Foo.foo returns a string

Whilst I believe that simple properties are now supported by mypy, I've been having a collection of issues with dynamically using the property() builtin.

I wonder whether I would be able to create a property Protocol that supports generics, to achieve something like the above?

Any advice much appreciated, and thanks for your time in advance!

Possibly related: #8083

[JukkaL]

Maybe you can get something like this to work by using a protocol with __get__ and __set__ (the stub for property would also need to modified, I believe)? I haven't thought about this carefully though.

[martsa1]

Hi JukkaL, thanks for coming back to me,

I managed to create a Prototype Generic subclass of the builtin property, which appears to work nicely, though it is slightly slower than the builtin property, so wouldn't be useful in some areas. For the area of my project where I'm using it that isn't an issue though:

from typing import Generic, TypeVar, Optional, Callable, Any

T = TypeVar("T")

class Property(property, Generic[T]):
    """Generic implementation of a property.

    Allows us to provide type annotations on top of builtin properties.
    """

    def __init__(
            self,
            fget: Optional[Callable[[Any], Any]] = None,
            fset: Optional[Callable[[Any, Any], None]] = None,
            fdel: Optional[Callable[[Any], None]] = None,
            doc: Optional[str] = None,
    ) -> None:
        super().__init__(fget, fset, fdel, doc)

    def __get__(self, obj: Any, objtype=None) -> T:
        return super().__get__(obj, objtype)

    def __set__(self, obj: Any, value: T) -> None:
        super().__set__(obj, value)

    def __delete__(self, obj: Any) -> None:
        super().__delete__(obj)

Are there any improvements you might suggest to the above? Otherwise I think I'm quite happy with this approach for now, so can close this. :)