Un décorateur Python peut-il rediriger le flux?

C'est l'histoire d'une façon unique de gérer les paramètres variables avec Python 3.9.1. (Voir aussi: cette histoire .)

J'ai rencontré un problème lors de l'utilisation de kwargs avec Python 3.9.1 et j'ai résolu ce problème avec un peu d'ingénierie unique et je suis ici pour m'en attribuer le mérite.

J'aime utiliser les décorateurs autant que possible car ils ont tendance à faciliter la programmation fonctionnelle et ce n'est pas une exception.

import sys
import traceback

class kwargs(object):
    
    def __init__(self, *args, **kwargs):
        self.__f__ = args[0]

    def __call__(self, f, *args, **kwargs):
        try:
            def wrapped_f(*args, **kwargs):
                get_kwargs = lambda a,k:a[0][-1] if (isinstance(a[0][-1], dict)) else k
                return self.__f__(**get_kwargs(args, kwargs))
            return wrapped_f
        except Exception as ex:
            extype, ex, tb = sys.exc_info()
            formatted = traceback.format_exception_only(extype, ex)[-1]
            print(formatted)

Voyons comment cela est utilisé

plugins_manager = PluginManager(plugins, debug=True)
service_runner = plugins_manager.get_runner()
    
api = service_runner.exec(twitter_verse, get_api, 
    **get_kwargs(
        consumer_key=consumer_key, 
        consumer_secret=consumer_secret, 
        access_token=access_token, 
        access_token_secret=access_token_secret, 
        logger=logger))

Comment cela pourrait-il être utile? Pensez à une boucle de longue durée qui traitait un enregistrement à la fois pour le Tweepy Twitter Bot sur lequel je travaille. Si la boucle force un module à se charger en haut de la boucle, alors l'intérieur de la boucle devient plus modifiable à l'exécution, ce qui signifie que je peux laisser le code s'exécuter pendant que je travaille sur le code car la boucle est exécutée en utilisant un intervalle, ce qui signifie le code dort au bas de chaque boucle. Cela permet de tweeter de temps en temps pour que tous mes tweets soient diffusés tous les jours, par exemple.

Encore une fois, je suis un peu non standard alors allons-y parce que tout le monde aime une idée folle quand cela fonctionne et que celle-ci fonctionne.

Donc, dans le code que nous venons de montrer, nous configurons l'appel de fonction avec les kwargs qui n'est en réalité qu'un dict.

Considérons maintenant un code non standard:

from vyperlogix.decorators import args


def __get_api(consumer_key=None, consumer_secret=None, access_token=None, access_token_secret=None, logger=None):
    try:
        auth = tweepy.OAuthHandler(consumer_key, consumer_secret)
        auth.set_access_token(access_token, access_token_secret)
        api = tweepy.API(auth)
    except:
        msg = 'Problem connecting to the twitter?'
        print(msg)
        if (logger):
            logger.error(msg)
        sys.exit()
    return api
    

@args.kwargs(__get_api)
def get_api(*args, **kwargs):
    pass

Le décorateur prend le pointeur de fonction réel comme paramètre, puis il utilise le pointeur de fonction réel pour rediriger le flux loin de la fonction décorée qui semble ne rien faire.

J'aime comment cela fonctionne et cela fonctionne pour moi. Je suppose qu'il y en aura qui n'aimeront pas du tout cela et ce n'est pas grave.

La morale de cette histoire est que vous pouvez obliger les décorateurs à faire à peu près tout, y compris ce qui a été fait ici. Vous pouvez voir le code ici , tôt ou tard.