Discussion :

[taxodium]

Bonjour

Je travaille actuellement sur un programme Python utilisant des décorateurs.
L'un de ces décorateurs me permet d'effectuer un "try" sur une méthode, afin d'agir en cas d'erreur (générée par mes soins) :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
def dec_erreur(fonction_erreur):
    def decorateur(fonction_in):
        def fonction_out(*args, **kwargs):
            try:
                # Essai la fonction en entrée
                result = fonction_in(*args, **kwargs)
            except AbortError:
                # Appelle la fonction agissant en cas d'erreur
                return fonction_erreur()
            else:
                # Envoi du résultat de la fonction initiale
                return result
        return fonction_out
    return decorateur

Ce décorateur est placé avant la méthode d'une classe :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
 
class MaClasse:
    @dec_erreur(fonction_erreur)
    def maMethode(self):
        ...

Le faite de créer ce décorateur me permet de réduire le code au maximum. Je n'ai qu'à spécifier la fonction à effectuer en cas d'erreur, ce qui peut me permettre d'effectuer certaines choses en cas de plantage.

Placer une fonction sans argument en paramètre du décorateur n'est pas compliqué. Mais j'aimerais pouvoir appeler une méthode en cas d'erreur, ce qui me permettrait d'accéder à toutes mes variables utiles (connexions à des DB, objets...).

Comment pouvoir envoyer en paramètre du décorateur une référence à la méthode d'une classe?

Merci

[wiztricks]

Salut,

Je ne comprends pas trop la construction que vous cherchez à faire.
Ecrire:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
class MaClasse:
    @dec_erreur(fonction_erreur)
    def maMethode(self):
        ...

équivaut à:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
class MaClasse:
    def maMethode(self):
        ...
    maMethode = dec_erreur(fonction_erreur)(maMethode)

A partir de là, si m1 est une méthode de MaClasse à passer dans dec_erreur,
pa de problème pour construire:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
    maMethode = dec_erreur(fonction_erreur, m1)(maMethode)
    maMethode = dec_erreur(fonction_erreur)(maMethode, m1)

Dans tous les cas, les m1 et maMethode récupérés dans dec_erreur seront "unbound" => çà fonctionne parce qu'on "binde" à la main la fonction à self qui sera le premier des arguments passés dans *args.
- W

[tyrtamos]

Bonjour,

Le problème me semblait facile à résoudre, mais ce n'est pas le cas.

Faire appeler une méthode par un décorateur nécessite pour celui-ci de trouver l'adresse de l'instance (=self), mais celle-ci est inconnue au moment de l'initialisation du décorateur, puisqu'il n'y a pas encore eu d'instanciation de la classe.

La solution que j'ai trouvée est celle-ci:

1- la méthode à appeler en cas d'erreur est transmise en argument au décorateur sous forme de str.

2- lors de l'appel de la méthode décorée, on retrouve le self comme 1er argument (=> args[0]). On peut alors retrouver la méthode à appeler en cas d'erreur grâce à getattr(args[0], "fonction_erreur").

Exemple (Python 2.7):

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
import functools
 
############################################################################# 
def dec_erreur(fonction_erreur=""):
    """ decorateur avec passage d'arguments """
    def _decorateur(fonc):
        @functools.wraps(fonc)
        def appelfonc(*args, **kwargs):
            try:
                result = fonc(*args, **kwargs)
            except Exception:
                result = None
                if hasattr(args[0], fonction_erreur):
                    result = getattr(args[0], fonction_erreur)()
            return result    
        return appelfonc
    return _decorateur
 
############################################################################# 
class MaClasse(object):
 
    @dec_erreur("fonction_erreur")
    def maMethode(self):
        x = 5/0
 
    def fonction_erreur(self):
        """méthode appelée par le décorateur 'dec_erreur' en cas d'erreur"""
        print u"erreur!"
 
############################################################################# 
if __name__ == "__main__":
    x = MaClasse()
    x.maMethode()

Ici, l'appel à maMethode déclenche l'exception (à cause de la division par zéro) qui appelle la méthode fonction_erreur, qui affiche "erreur!"

[taxodium]

Merci tyrtamos

Cela répond parfaitement à ce que je voulais faire. J'ai juste poussé un peu la réflexion pour que le décorateur puisse appeler une méthode, une fonction ou la méthode d'une autre classe.

[wiztricks]

Cela répond parfaitement à ce que je voulais faire. J'ai juste poussé un peu la réflexion pour que le décorateur puisse appeler une méthode, une fonction ou la méthode d'une autre classe.

Python autorisant l'héritage multiple, les mixins méritent d'être regardés:

On part de la classe originale:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
class A:
 
    def m1(self, *a, **k):
        print ('A.m1')
        raise Exception()
 
    def m2(self):
        print ('A.error')

Puis on crée un class M qui tricotera les méthodes de A:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
class M:
 
    def m1(self, *a, **k):
        print ('M.m1')
        try:
           return super().m1(*a, **k)
        except:
           return self.error()
 
    def error(self):
        raise Exception('not implemented')

Puis on colle les deux:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
class C(M, A): 
    error = A.m2

L'héritage multiple permet de respecter le chaînage apporté par le décorateur (appel du décorateur puis appel de la fonction décorée) sans passer par des fonctions emboîtées.
Et dans ce cas précis c'est quand même plus lisible, enfin je crois.
- W

[dividee]

La méthode de wiztricks est effectivement plus claire, mais elle nécessite de créer une nouvelle classe mixin pour chaque méthode que l'on désire instrumenter de la sorte...

Le méthode de tyrtamos peut fonctionner sans devoir passer par une string, du moment qu'on déclare la méthode qui traite l'erreur avant de l'utiliser:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
import functools
 
############################################################################# 
def dec_erreur(fonction_erreur):
    """ decorateur avec passage d'arguments """
    def _decorateur(fonc):
        @functools.wraps(fonc)
        def appelfonc(self, *args, **kwargs):
            try:
                result = fonc(self, *args, **kwargs)
            except Exception:
                result = fonction_erreur(self)
            return result    
        return appelfonc
    return _decorateur
 
############################################################################# 
class MaClasse(object):
 
    def fonction_erreur(self):
        """méthode appelée par le décorateur 'dec_erreur' en cas d'erreur"""
        print u"erreur!"
 
    @dec_erreur(fonction_erreur)
    def maMethode(self):
        x = 5/0
 
############################################################################# 
if __name__ == "__main__":
    x = MaClasse()
    x.maMethode()

[taxodium]

Merci à tous pour votre aide, mais je m'en tient à le méthode de tyrtamos pour le moment.
Dans mon service, nous devons réaliser un grand nombre d'applications en peu de temps, c'est ce qui nous a poussé à créer une bibliothèque de fonctions et classes que nous utilisons régulièrement. Ainsi, pour chaque chose réalisée, nous devons essayé de généraliser au maximum afin de pouvoir l'intégrer à notre bibliothèque.
Le but est de pouvoir réutiliser ces fonctionnalités de façon simple et rapide dans nos futures applications. Voilà pourquoi elles doivent être le plus souple possible.