Decorateur et registre

Version imprimable

Bonjour à tous,

j'essaye d'exploiter les @decorateur de python pour inscrire dans un registre ( un dict tout simplement ) une fonction.
Pour me simplifier la tache, décorateur et fonction ont des paramètres.

si dessous un code qui ne fonctionne pas
Code:

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 # mon registre registry_model = {} # ma class fake class Klass(object):pass # dans mon implémentation, j'utilise les metaclass pour enregistrer mon model registry_model["Klass"] = {} def register_io_write(model=None, _type="xml"): " Register io write function for the model in _type context" def decorated(func): @functools.wraps(func) def wrapper(*args, **kwargs): registry_model[model.__name__].update({("io","write", _type):func}) return func(*args, **kwargs) return wrapper def decorator(func): return decorated(func) return decorator @register_io_write(Klass, "xml") def write_model(*args, **kwargs): print args, kwargs print registry_model print "Done"
en faite, je ne passe jamais dans la fonction wrapper
et si je sort de cette fonction, je ne connait plus la fonction decorée

peut être n'est ce pas possible ? ou sinon je me perd dans mon raisonnement avec les décorateurs

une idée à me soumettre, une piste à suivre?

merci pour vos lumières

Kermit

Bonjour,

Petite correction du décorateur:

Code:

1
2
3
4
5
6
7
8
9
def register_io_write(model=None,  _type="xml"):
    " Register io write function for the model in _type context"
    def decorated(func):
        @functools.wraps(func)
        def wrapper(*args, **kwargs):
            registry_model[model.__name__].update({("io","write", _type):func})
            return func(*args, **kwargs)
        return wrapper
    return decorated # decorator

Et pour que le décorateur fasse son boulot, il faut appeler la fonction décorée:

Code:

1
2
3
write_model(1, 2, 3, a=4, b=5, c=6)
print registry_model
print "Done"

résultats:

Code:

1
2
3
(1, 2, 3) {'a': 4, 'c': 6, 'b': 5}
{'Klass': {('io', 'write', 'xml'): <function write_model at 0x02973C70>}}
Done

ça a l'air de marcher?

Salut,

C'est un sujet "compliqué", voir la discussion

Votre code marcherait mieux écrit ainsi:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 def register_io_write(model=None, type_="xml"): def decorated(func): registry_model[model.__name__].update({("io","write", type_):func}) def wrapper(*args, **kwargs): return func(*args, **kwargs) return functools.wraps(func)(wrapper) return decorated @register_io_write(Klass, "xml") def write_model(*args, **kwargs): print args, kwargs print registry_model print write_model(1,2,3) print "Done"
Après, pour essayer d'expliquer un peu, écrire:
Code:

1 2 3 @register_io_write(Klass, "xml") def write_model(*args, **kwargs): ...
équivalaut à écrire:

Code:

write_model = register_io_write(Klass, "xml")(write_model)

<=> remplacer la définition de la fonction
ce qui va:
1. exécuter la première fonction imbriquée (decorated) avec write_model en paramètre
2. et retourner une instance de "wrapper" avec son contexte "autour".
=> s'il faut faire des trucs à l'enregistrement de la fonction, c'est dans le corps de la fonction imbriquée, le "wrapper" n'étant appelé qu'à la place de la fonction wrappée, je suppose que c'est trop tard...

Une autre façon de dérouler cela est de passer par des classes:
Code:

1 2 3 4 5 6 7 8 9 10 11 class register_io_write(object): def __init__(model=None, type_="xml"): self.model = model self.type_ = type_ def __call__(self, func): registry_model[self.model.__name__].update( {("io","write", self.type_):func}) def wrapper(*args, **kwargs): return func(*args, **kwargs) return functools.wraps(func)(wrapper)
comme c'est plus verbeux, on voit mieux ce qu'il se passe (enfin peut être).

- W

18/04/2012, 10h54
3DKermit

Bonjour,

merci pour vos réponses.

Effectivement, mon inscription:

registry_model[model.__name__].update({("io","write", _type):func})
n' était pas au bonne endroit.

Merci pour les explications car je n'avais pas compris toutes les subtilités ( surtout avec la recombinaison du decorateur @functools.wraps(func) )

@wiztricks
j'aime beaucoup la version avec la class, plus clair de mon point de vue.
19/04/2012, 00h11
dividee
Bonsoir,

c'est un détail, mais créer un wrapper qui ne fait qu'appeler la fonction d'origine avec les mêmes arguments, ça n'a pas vraiment d'intérêt.

Plutôt que:
Code:

1 2 3 def wrapper(*args, **kwargs): return func(*args, **kwargs) return functools.wraps(func)(wrapper)
Autant écrire:

Code:

return func
19/04/2012, 10h43
wiztricks
Citation:

c'est un détail, mais créer un wrapper qui ne fait qu'appeler la fonction d'origine avec les mêmes arguments, ça n'a pas vraiment d'intérêt.

Si on se limite à la fonction "registry", cela est très juste. Mais dans ce cas, on pourrait même se débarrasser des decorators!
Pour réaliser la mise en registry de la fonction, il suffit d'écrire:
Code:

1 2 3 def write_model(...): ... register_io_write(Klass, "xml")(write_model)
Supporter une mise en forme:
Code:

1 2 3 @register_io_write(Klass, "xml") def write_model(...): ....
coûte au moins toutes les lignes de codes du décorator et la compréhension de ce qui se passe pour le faire tomber en marche.
- W
19/04/2012, 14h39
3DKermit

mon intention était de me faciliter la vie pour l'enregistrement de module type "plugins"

en oubliant un peu cette histoire de décorateur, pour enregistrer de manière "automatique" un nouveau module, il vaut mieux utiliser les metaclass ?? avec une class callable ??

je sais, on dérive sur le sujet :)

il y a également un autre exemple dans 'Dive into Python', qui utilise global().
Mais je ne mis suis pas penché, car j'ai toujours entendu dire que, pour la programmation en général, les "global, c'est mal"
De plus, l'exemple exploite le nom de la fonction (FileInfo, MP3FileInfo, etc..) et je trouve cela dangereux

des fous furieux du C++ a coté de moi me dise que explicite et mieux que implicite, mais on perd un peu le charme de python et de son introspection.

Votre avis m’intéresse vivement, car c'est la première fois que j'attaque un développement "lourd" en python, qui de sur plus, pour le fun, aura des parties optimiser en C++

Merci

Kermit
19/04/2012, 19h15
wiztricks

Salut,

Citation:

en oubliant un peu cette histoire de décorateur, pour enregistrer de manière "automatique" un nouveau module, il vaut mieux utiliser les metaclass ?? avec une class callable ??

Désolé, je ne comprend pas la question.
module, class et fonction sont des objets de nature complètement différente.

Un module est, par défaut, associé à un fichier et un fichier est dans un file system. Class et metaclass (python) font partie d'un univers différent.
=> Il faudra construire avec d'autres outils!

Citation:

j'ai toujours entendu dire que, pour la programmation en général, les "global, c'est mal"

En Python globals() est le nom donné au dictionnaire associé au module/script "courant". Chaque module ayant son globals(), ils ne sont pas si "globaux". En fait le seul globals() global est celui du module builtins.

Un module est par défaut singleton.
Utiliser ce globals()/dictionnaire là plutôt que l'instance d'un autre dict promu "singleton", quelle importance? La forme ou la fonction?

Citation:

De plus, l'exemple exploite le nom de la fonction (FileInfo, MP3FileInfo, etc..) et je trouve cela dangereux

"register_io_write(Klass, "xml")(write_model)" s'interprête:
récupérer l'objet qui correspond à l'entrée "write_model" de globals() et...
Le nom de l'objet fonction est un objet de type str accessible via .__name__.

Citation:

des fous furieux du C++ a coté de moi me dise que explicite et mieux que implicite, mais on perd un peu le charme de python et de son introspection.

Le compilateur les a souvent rappelé à l'ordre lorsqu'ils ont osé oublié ce sage principe. Python étant interprêté et basé sur du "duck typing", il est clair que le programmeur d'un langage compilé mettra du temps à trouver ses repères.

Cordialement,
- W