Início / coding / Perguntas / 79289546
Accepted
Charles Duffy
Asked: 2024-12-18 06:40:41 +0800 CST

Dicas de tipo perdidas quando um decorador é encapsulado como um método de classe?

  • 772

Considere o seguinte código:

from typing import Any, Callable, Coroutine

class Cache[**P, R]:
    @classmethod
    def decorate(cls, **params):
        def decorator(f: Callable[P, Coroutine[Any, Any, R]]) -> Callable[P, Coroutine[Any, Any, R]]:
            return f # in the real world, we instantiate a Cache here
        return decorator

@Cache.decorate()
async def some_function(i: int) -> int:
    return i + 1

cached_function = Cache.decorate()(some_function)

Se eu perguntar ao pyright o tipo de Cache.decorate antes do @classmethodwrapper (inspecionando a palavra decorateno código acima), ele retorna:

(method) def decorate(
    cls: type[Self@Cache[P@Cache, R@Cache]],
    **params: Unknown
) -> ((f: ((**P@Cache) -> (Coroutine[Any, Any, R@Cache])) -> ((**P@Cache) -> Coroutine[Any, Any, R@Cache]))

Parece-me que ele entende que P(os tipos de argumento) e R(os tipos de retorno) estão analisados ​​corretamente.

Entretanto, se eu pedir para ele fazer uma introspecção Cache.decorateno contexto em que está sendo usado como decorador, ele retorna:

(method) def decorate(**params: Unknown) -> ((f: ((...) -> Coroutine[Any, Any, Unknown])) -> ((...) -> Coroutine[Any, Any, Unknown]))

...ou seja, a relação entre tipos de entrada e tipos de saída foi totalmente descartada!

python

1 respostas

  1. Best Answer

    decoratordepende de duas variáveis ​​contextuais de tipo: Pe R. No contexto da Cacheclasse, elas não são conhecidas, mas presume-se que sejam conhecidas pelo Pyright no momento da chamada.

    Entretanto, quando Cache.decorate()é chamado, o Pyright não obtém informações suficientes para resolver Pe R(nenhum argumento de tipo explícito e nenhum argumento), então esses dois são resolvidos como Unknown.

    Uma solução simples é parametrizar Cacheexplicitamente:

    ( parque infantil )

    @Cache[[int], int].decorate()
async def some_function(i: int) -> int:
    return i + 1

    reveal_type(some_function)  # (int) -> Coroutine[Any, Any, int]

    No entanto, isso não leva você à raiz do problema, que é que você não está especificando corretamente o que deseja.

    Cacheé genérico sobre Pe R, então deve existir uma maneira pela qual Pyright pode inferir que os tipos correspondem a esses parâmetros. Normalmente, eles são manipulados passando argumentos para a função que cria essa classe, comumente __new__/ __init__e factory @classmethods.

    # Hypothetical usages
Cache(return_value, *args, **kwargs)
Cache.factory(return_value, *args, **kwargs)

# This is also possible, as shown, but rarer
Cache[[int], int]()

    decorate()é um método de fábrica, mas não cria instâncias de Cachepor si só. Ele recebe alguns argumentos, mas estes não afetam o tipo do decorado some_function()nem o tipo do a-ser-criado Cache.

    Em vez disso, decorate()é destinado a criar decoradores que eles mesmos criam instâncias de Cache. São esses decoradores que você quer parametrizar , porque eles são os que recebem as funções decoradas e são responsáveis ​​por criar Caches.

    ( parque infantil )

    class Cache[**P, R]:

    @classmethod
    def decorate(cls, **params: Any):
        def decorator[**P2, R2](f: Callable[P2, Coroutine[Any, Any, R2]]) -> ...:
            #        ^^^^^^^^^^
            return f
        
        return decorator

    reveal_type(Cache.decorate())
# (f: (**P2@decorator) -> Coroutine[Any, Any, R2@decorator]) -> ((**P2@decorator) -> Coroutine[Any, Any, R2@decorator])

reveal_type(some_function)
# (i: int) -> Coroutine[Any, Any, int]
    • 2

relate perguntas