Distribution EOLE » Commun » python-pyeole

Voici une classe trace permettant un appel sans les parenthèses si on ne passe aucun argument au décorateur :

#!/usr/bin/python

import logging

logger = logging.getLogger()
logger.addHandler(logging.StreamHandler())
logger.setLevel(logging.DEBUG)

class trace(object):
    """This is a decorator which can be used to trace functions calls

    It can replace some positional and/or keyword arguments with some
    'X' if they are present.
    """ 

    def __init__(self, f=None, hide_args=[], hide_kwargs=[]):
        """Initialize the trace decorator

        When no argument are passed to the decorator, it can be called without the braces.

        @param f: Function to decorate when there are no decorator arguments
        @type f: C{function}
        @param hide_args: List of positional argument indexes to replace if present
        @type hide_args: C{list}
        @param hide_kwargs: List of keyword argument names to replace if present
        @type hide_kwargs: C{list}
        """ 
        # func is used when using @trace decorator without braces
        if f is not None and not callable(f):
            raise TypeError('You must call trace decorator with keyword arguments')

        self.function = f
        self.hide_args = hide_args
        self.hide_kwargs = hide_kwargs

    def __log_call(self, f, *args, **kwargs):
        """Log function calls
        """ 
        # Do nothing if debug is not enabled
        if logger.isEnabledFor(logging.DEBUG):
            # Copy arguments
            args_list = list(args)
            args_dict = kwargs.copy()
            for index in self.hide_args:
                if index < len(args_list):
                    args_list[index] = 'X' * len( args_list[index] )
            for keyname in self.hide_kwargs:
                if keyname in args_dict:
                    args_dict[keyname] = 'X' * len( args_dict[keyname] )
            logger.debug( "-> entering %s(%s, %s)" % (f.__name__, str(args_list), str(args_dict)) )

    def __call_with_args(self, f):
        """Call decorator with parameters

        Return a wrapper since the call is done
        """ 
        def wrapped_f(*args, **kwargs):
            self.__log_call(f, *args, **kwargs)
            f(*args, **kwargs)
        return wrapped_f

    def __call_without_args(self, *args, **kwargs):
        """Call decorator without parameter

        The __call__ method of this object is not called until the decorated function is called itself.
        """ 
        self.__log_call(self.function, *args, **kwargs)
        self.function(*args, **kwargs)

    def __call__(self, f, *args, **kwargs):
        """Log function calls
        """ 
        if callable(f):
            return self.__call_with_args(f)
        else:
            argslist = [f]
            argslist.extend(args)
            return self.__call_without_args(*argslist, **kwargs)

@trace(hide_args=[2], hide_kwargs=['passwd'])
def machin(msg, name=None, passwd=None):
    print "Machin: %s" % msg

# Now braces are useless when no argument are passed to the decorator
@trace
def bidule(msg, name=None, passwd=None):
    print "Bidule: %s" % msg

machin("MSG: args", "user", "secret")
# -> entering machin(['MSG: args', 'user', 'XXXXXX'], {})

bidule("MSG: args", "user", "secret")
# -> entering bidule(['MSG: args', 'user', 'secret'], {})

machin("MSG: kwargs", "user", passwd="secret")
# -> entering machin(['MSG: kwargs', 'user'], {'passwd': 'XXXXXX'})

bidule("MSG: kwargs", "user", passwd="secret")
# -> entering bidule(['MSG: kwargs', 'user'], {'passwd': 'secret'})

Une petite documentation en 12 points pour comprender les décorateurs.

Un peu d’explication sur la différence entre les décorateurs avec et sans arguments.

Il serait pratique d'avoir également le "return" dans les logs.