Décorateur Python entièrement typé avec paramètres

Le code présenté dans ce court article est tiré de mon petit projet open source conçu par contrat, qui met à disposition un décorateur typé. Les décorateurs sont un concept très utile et vous en trouverez certainement beaucoup à leur sujet en ligne. En termes simples, ils permettent d'exécuter du code à chaque fois (avant et après) que la fonction décorée est appelée. De cette façon, vous pouvez modifier les paramètres de fonction ou renvoyer des valeurs, mesurer les temps d'exécution, ajouter une journalisation, effectuer une vérification du type au moment de l'exécution, etc. Notez que les décorateurs peuvent également être écrits pour les classes, fournissant une autre approche de métaprogrammation (par exemple effectuée dans le package attrs)

Dans sa forme la plus simple, un décorateur est défini comme le code suivant :

def my_first_decorator(func):
 def wrapped(*args, **kwargs):
 # do something before
 result = func(*args, **kwargs)
 # do something after
 return result
 return wrapped
@my_first_decorator
def func(a):
 return a

Comme le code ci-dessus, car lorsqu'un Une fonction imbriquée encapsulée est définie, ses variables environnantes sont accessibles dans la fonction et conservées en mémoire tant que la fonction est utilisée quelque part (c'est ce qu'on appelle une fermeture dans les langages de programmation fonctionnels).

Très simple, mais cela présente quelques inconvénients. Le plus gros problème est que la fonction modifiée perdra son ancien nom de fonction (vous pouvez le voir avec inspect.signature), sa docstring et même son nom. Ce sont des problèmes avec les outils de documentation du code source (tels que sphinx), mais cela peut. être facilement résolu en utilisant le décorateur functools.wraps de la bibliothèque standard :

from functools import wraps
from typing import Any, Callable, TypeVar, ParamSpec
P = ParamSpec("P") # 需要python >= 3.10
R = TypeVar("R")
def my_second_decorator(func: Callable[P, R]) -> Callable[P, R]:
 @wraps(func)
 def wrapped(*args: Any, **kwargs: Any) -> R:
 # do something before
 result = func(*args, **kwargs)
 # do something after
 return result
 return wrapped
@my_second_decorator
def func2(a: int) -> int:
 """Does nothing"""
 return a
print(func2.__name__)
# 'func2'
print(func2.__doc__)
# 'Does nothing'

Dans cet exemple, j'ai ajouté des annotations de type, les annotations et les indices de type sont les ajouts les plus importants apportés à Python. Une meilleure lisibilité, la complétion du code dans l'EDI et la maintenabilité de bases de code plus volumineuses ne sont que quelques exemples. Le code ci-dessus devrait déjà couvrir la plupart des cas d'utilisation, mais le décorateur ne peut pas être paramétré. Pensez à écrire un décorateur qui enregistre le temps d'exécution d'une fonction, mais uniquement s'il dépasse un certain nombre de secondes. Ce numéro doit être configurable individuellement pour chaque fonction décorée. Si non spécifié, la valeur par défaut doit être utilisée et le décorateur doit être utilisé sans parenthèses pour le rendre plus facile à utiliser :

@time(threshold=2)
def func1(a):
...
# No paranthesis when using default threshold
@time
def func2(b):
...

Si vous pouvez utiliser des parenthèses dans le deuxième cas, ou ne fournissez pas de valeur par défaut pour le paramètre du tout, alors cette astuce suffira :

from functools import wraps
from typing import Any, Callable, TypeVar, ParamSpec
P = ParamSpec("P") # 需要python >= 3.10
R = TypeVar("R")
def my_third_decorator(threshold: int = 1) -> Callable[[Callable[P, R]], Callable[P, R]]:
 def decorator(func: Callable[P, R]) -> Callable[P, R]:
 @wraps(func)
 def wrapper(*args: Any, **kwargs: Any) -> R:
 # do something before you can use `threshold`
 result = func(*args, **kwargs)
 # do something after
 return result
 return wrapper
 return decorator
@my_third_decorator(threshold=2)
def func3a(a: int) -> None:
...
# works
@my_third_decorator()
def func3b(a: int) -> None:
...
# Does not work!
@my_third_decorator
def func3c(a: int) -> None:
...

Pour couvrir le troisième cas, il existe des packages, à savoir wraps et decorator, qui peuvent en fait faire plus que simplement ajouter des paramètres facultatifs. Bien que la qualité soit très élevée, ils introduisent un peu plus de complexité supplémentaire. En utilisant la fonction wrapt-decorated, j'ai en outre rencontré des problèmes de sérialisation lors de l'exécution de la fonction sur un cluster distant. Pour autant que je sache, ni l'un ni l'autre n'est entièrement typé, donc les vérificateurs/linters de type statique (tels que mypy) échouent en mode strict.

J'ai dû résoudre ces problèmes lorsque je travaillais sur mon propre package et j'ai décidé d'écrire ma propre solution. Cela devient un modèle facilement réutilisable mais difficile à convertir en bibliothèque.

Il utilise des décorateurs surchargés de la bibliothèque standard. De cette façon, le même décorateur peut être spécifié pour être utilisé avec notre décorateur sans paramètre. En dehors de cela, c'est une combinaison des deux extraits ci-dessus. Un inconvénient de cette approche est que tous les paramètres doivent être donnés sous forme d'arguments de mots-clés (cela augmente la lisibilité après tout)

from typing import Callable, TypeVar, ParamSpec
from functools import partial, wraps
P = ParamSpec("P") # requires python >= 3.10
R = TypeVar("R
@overload
def typed_decorator(func: Callable[P, R]) -> Callable[P, R]:
...
@overload
def typed_decorator(*, first: str = "x", second: bool = True) -> Callable[[Callable[P, R]], Callable[P, R]]:
...
def typed_decorator(
 func: Optional[Callable[P, R]] = None, *, first: str = "x", second: bool = True
) -> Union[Callable[[Callable[P, R]], Callable[P, R]], Callable[P, R]]:
 """
Describe what the decorator is supposed to do!
Parameters
----------
first : str, optional
First argument, by default "x".
This is a keyword-only argument!
second : bool, optional
Second argument, by default True.
This is a keyword-only argument!
"""
 def wrapper(func: Callable[P, R], *args: Any, **kw: Any) -> R:
 """The actual logic"""
 # Do something with first and second and produce a `result` of type `R`
 return result
 # Without arguments `func` is passed directly to the decorator
 if func is not None:
 if not callable(func):
 raise TypeError("Not a callable. Did you use a non-keyword argument?")
 return wraps(func)(partial(wrapper, func))
 # With arguments, we need to return a function that accepts the function
 def decorator(func: Callable[P, R]) -> Callable[P, R]:
 return wraps(func)(partial(wrapper, func))
 return decorator

Plus tard, nous pourrons utiliser notre décorateur sans paramètres séparément

@typed_decorator
def spam(a: int) -> int:
 return a
@typed_decorator(first = "y
def eggs(a: int) -> int:
 return a

Ce modèle a certainement des frais généraux, mais les avantages dépassent les coûts.

Texte original :​​https://www.php.cn/link/d0f82e1046ccbd597c7f2a7bfba9e7dd​​

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!