Python autorise-t-il les appels aux usines d'usine de décoration?

Question

Sur Ian McCracken's blog, il a un article where he talks about decorator factory factories. Dans l'article, il donne un exemple de:

def decorator_factory_factory(method): 
    def decorator_factory(regex): 
     def decorator(f): 
      def inner(*args, **kwargs): 
       # do stuff with f(*args, **kwargs) 
       # and method and regex 
      return inner 
     return decorator 
    return decorator_factory 

Il donne alors un exemple de la façon dont il pourrait appeler le décorateur:

@decorator_factory_factory('GET')('^/.*$') 
def onGetAnything(self): 
    pass 

Cela a attiré mon attention. Je ne l'avais jamais essayé d'appeler une usine de décorateur de décorateur avant, donc j'ai décidé de voir comment le code se comporterait:

>>> def decorator_factory_factory(method): 
    def decorator_factory(regex): 
     def decorator(f): 
      def inner(*args, **kwargs): 
       print(args, kwargs) 
      return inner 
     return decorator 
    return decorator_factory 

>>> @decorator_factory_factory('GET')('^/.*$') 
def onGetAnything(self): 
    pass 
SyntaxError: invalid syntax 
>>> 

Comme vous pouvez le voir ci-dessus, Python déclenche une SyntaxError. Pourquoi donc? En plus du code qui semble fonctionner pour M. McCraken, il semble que le code devrait fonctionner parfaitement bien. N'est-ce pas fondamentalement la même syntaxe que l'enchaînement des appels de fonction, qui fonctionne? par exemple:

>>> def foo(): 
    def bar(): 
     return 2 
    return bar 

>>> foo()() 
2 
>>> 

Je pensais que peut-être qu'il utilisait une ancienne version de Python qui a permis à cette syntaxe, donc je regardais la grammaire pour la version Python qu'il était probablement en utilisant quand il a écrit l'article en 2009; 2.6.9. Mais the grammar ne semble pas encore pour permettre décorateur enchaînée appelle:

decorator: '@' dotted_name [ '(' [arglist] ')' ] NEWLINE 
decorators: decorator+ 
decorated: decorators (classdef | funcdef) 

a cette syntaxe jamais été autorisée dans une version Python. Si non, comment Ian a-t-il pu exécuter son code? At-il simplement fait une erreur?

Answer 1

Pour contourner ce problème, pour obtenir ce travail, vous pouvez faire un décorateur decorator_caller, qui fera les appels pour vous:

def decorator_caller(decorator, args_list): 
    d = decorator 
    for args in args_list: 
     d = d(*args) 
    return d 

utilisé comme ceci:

@decorator_caller(decorator_factory_factory, (('GET',), ('^/.*$',))) 
def onGetAnything(self): 
    pass 

Ou à l'aide de listes à la place (depuis tuples un seul article paraître confus):

@decorator_caller(decorator_factory_factory, (['GET'], ['^/.*$'])) 
def onGetAnything(self): 
    pass 

---

Notez que je ne crois pas qu'une telle usine d'usine est une chose utile à construire. Les usines d'usine ont du sens quand les usines extérieures vont vraiment affecter la logique de l'usine intérieure construite. Quand tout ce que vous faites est de créer une usine temporaire pour créer un seul objet juste pour jeter l'usine immédiatement, alors vous ne gagnez vraiment rien sauf de plus de complexité et une performance globale pire.

Ce serait une autre chose si vous avez réellement stocké l'usine autour de la réutilisation:

getFactory = decorator_factory_factory('GET') 

@getFactory('^/index.*$') 
def index(): 
    pass 

@getFactory('^/.*$') 
def x(): 
    pass 

Cela est logique et la syntaxe fonctionne aussi très bien. Mais si vous voulez juste enchaîner des appels d'usine pour ajouter un autre argument pour configurer le décorateur, alors vous devriez juste ajuster l'usine pour prendre ces deux arguments.