Decorators with parameters

Question

I have a problem with the transfer of variable  insurance mode  by the decorator  I would do it by the following decorator statement   execute complete reservation True  def test booking gta object self       self test select gta object    but unfortunately  this statement does not work  Perhaps maybe there is better way to solve this problem  def execute complete reservation test case insurance mode       def inner function self  args   kwargs           self test create qsf query           test case self  args   kwargs          self test select room option           if insurance mode              self test accept insurance crosseling           else              self test decline insurance crosseling           self test configure pax details           self test configure payer details      return inner function

User · Answer

define this  decoratorize function  to generate customized decorator function   def decoratorize FUN    kw       def foo  args    kws           return FUN  args    kws    kw      return foo   use it this way        decoratorize FUN  arg1     arg2              def bar

User · Answer

Here is a slightly modified version of t dubrownik s answer  Why    As a general template  you should return the return value from the original function  This changes the name of the function  which could affect other decorators   code    So use  functools wraps     from functools import wraps  def decorator argument       def real decorator function            wraps function          def wrapper  args    kwargs               funny stuff               something with argument argument              retval   function  args    kwargs              more funny stuff               return retval         return wrapper     return real decorator

User · Answer

Here we ran display info twice with two different names and two different ages  Now every time we ran display info  our decorators also added the functionality of printing out a line before and a line after that wrapped function   def decorator function original function       def wrapper function  args    kwargs           print  Executed Before   original function   name            result   original function  args    kwargs          print  Executed After   original function   name      n           return result     return wrapper function    decorator function def display info name  age       print  display info ran with arguments           format name  age     display info  Mr Bean   66  display info  MC Jordan   57   output  Executed Before display info display info ran with arguments  Mr Bean  66  Executed After display info   Executed Before display info display info ran with arguments  MC Jordan  57  Executed After display info    So now let s go ahead and get our decorator function to accept arguments   For example let s say that I wanted a customizable prefix to all of these print statements within the wrapper   Now this would be a good candidate for an argument to the decorator   The argument that we pass in will be that prefix  Now in order to do  this we re just going to add another outer layer to our decorator  so I m going to call this a function a prefix decorator    def prefix decorator prefix       def decorator function original function           def wrapper function  args    kwargs               print prefix   Executed Before   original function   name                result   original function  args    kwargs              print prefix   Executed After   original function   name      n               return result         return wrapper function     return decorator function    prefix decorator  LOG    def display info name  age       print  display info ran with arguments           format name  age     display info  Mr Bean   66  display info  MC Jordan   57   output  LOG  Executed Before display info display info ran with arguments  Mr Bean  66  LOG  Executed After display info   LOG  Executed Before display info display info ran with arguments  MC Jordan  57  LOG  Executed After display info    Now we have that LOG  prefix before our print statements in our wrapper function and you can change this any time that you want

User · Answer

It is a decorator that can be called in a variety of ways  tested in python3 7   import functools   def my decorator  args or func    decorator kwargs        def  decorator func             functools wraps func          def wrapper  args    kwargs                if not args or func or callable args or func 0                      Here you can set default values for positional arguments                 decorator args                  else                  decorator args   args or func              print                   quot Available inside the wrapper  quot                   decorator args  decorator kwargs                                              result   func  args    kwargs                                 return result          return wrapper      return  decorator args or func 0             if args or func and callable args or func 0   else  decorator    my decorator def func 1 arg   print arg   func 1  quot test quot     Available inside the wrapper          test    my decorator   def func 2 arg   print arg   func 2  quot test quot     Available inside the wrapper          test    my decorator  quot any arg quot   def func 3 arg   print arg   func 3  quot test quot     Available inside the wrapper    any arg         test    my decorator  quot arg 1 quot   2   3  4  5   kwarg 1 1  kwarg 2  quot 2 quot   def func 4 arg   print arg   func 4  quot test quot     Available inside the wrapper    arg 1   2   3  4  5     kwarg 1   1   kwarg 2    2     test   PS thanks to user  norok2 - https   stackoverflow com a 57268935 5353484 UPD Decorator for validating arguments and or result of functions and methods of a class against annotations  Can be used in synchronous or asynchronous version  https   github com EvgeniyBurdin valdec

User · Answer

It is well known that the following two pieces of code are nearly equivalent        dec def foo        pass    foo   dec foo                                                foo   dec foo    A common mistake is to think that   simply hides the leftmost argument    dec 1  2  3  def foo        pass                                                 foo   dec foo  1  2  3    It would be much easier to write decorators if the above is how   worked  Unfortunately  that   s not the way things are done     Consider a decorator Waitwhich haults  program execution for a few seconds  If you don t pass in a Wait-time then the default value is 1 seconds  Use-cases are shown below                                                       Wait def print something something       print something                                                       Wait 3  def print something else something else       print something else                                                       Wait delay 3  def print something else something else       print something else    When Wait has an argument  such as  Wait 3   then the call Wait 3  is executed before anything else happens   That is  the following two pieces of code are equivalent   Wait 3  def print something else something else       print something else                                                   return value   Wait 3   return value def print something else something else       print something else    This is a problem    if  Wait  has no arguments       Wait  is the decorator  else     Wait  receives arguments      Wait  is not the decorator itself      Instead   Wait     returns    the decorator     One solution is shown below            Let us begin by creating the following class  DelayedDecorator       class DelayedDecorator      def   init   i  cls   args    kwargs           print  Delayed Decorator   init     cls  args  kwargs          i  cls   cls         i  args   args         i  kwargs   kwargs     def   call   i  func           print  Delayed Decorator   call     func          if not  callable func                import io             with io StringIO   as ss                  print                       If only one input  input must be callable                        Instead  received                        repr func                       sep   n                       file ss                                   msg   ss getvalue               raise TypeError msg          return i  cls func   i  args    i  kwargs    Now we can write things like    dec   DelayedDecorator Wait  delay 4    dec  def delayed print something       print something    Note that           dec does not not accept multiple arguments  dec only accepts the function to be wrapped       import inspect class PolyArgDecoratorMeta type       def call Wait   args    kwargs           try              arg count   len args              if  arg count    1                   if callable args 0                        SuperClass   inspect getmro PolyArgDecoratorMeta  1                      r   SuperClass call Wait  args 0                   else                      r   DelayedDecorator Wait   args    kwargs              else                  r   DelayedDecorator Wait   args    kwargs          finally              pass         return r  import time class Wait metaclass PolyArgDecoratorMeta       def init i  func  delay   2           i  func   func         i  delay   delay  def   call   i   args    kwargs       time sleep i  delay      r   i  func  args    kwargs      return r     The following two pieces of code are equivalent    Wait def print something something        print  something                                                       def print something something       print something  print something   Wait print something    We can print  something  to the console very slowly  as follows   print something  something                                                       Wait delay 1  def print something else something else       print something else                                                      def print something else something else       print something else   dd   DelayedDecorator Wait  delay 1  print something else   dd print something else                                                       print something else  something       Final Notes  It may look like a lot of code  but you don t have to write the classes DelayedDecorator and PolyArgDecoratorMeta every-time  The only code you have to personally write something like as follows  which is fairly short   from PolyArgDecoratorMeta import PolyArgDecoratorMeta import time class Wait metaclass PolyArgDecoratorMeta    def   init   i  func  delay   2        i  func   func      i  delay   delay   def   call   i   args    kwargs        time sleep i  delay       r   i  func  args    kwargs       return r

User · Answer

In case both the function and the decorator have to take arguments you can follow the below approach   For example there is a decorator named decorator1 which takes an argument   decorator1 5  def func1 arg1  arg2       print  arg1  arg2   func1 1  2    Now if the decorator1 argument has to be dynamic  or passed while calling the function    def func1 arg1  arg2       print  arg1  arg2    a   1 b   2 seconds   10  decorator1 seconds  func1  a  b    In the above code    seconds is the argument for decorator1  a  b are the arguments of func1

User · Answer

I presume your problem is passing arguments to your decorator  This is a little tricky and not straightforward   Here s an example of how to do this   class MyDec object       def   init   self flag           self flag   flag     def   call   self  original func           decorator self   self         def wrappee   args    kwargs               print  in decorator before wrapee with flag   decorator self flag             original func  args   kwargs              print  in decorator after wrapee with flag   decorator self flag         return wrappee   MyDec  foo de fa fa   def bar a b c       print  in bar  a b c  bar  x   y   z     Prints   in decorator before wrapee with flag  foo de fa fa in bar x y z in decorator after wrapee with flag  foo de fa fa   See Bruce Eckel s article for more details

User · Answer

In my instance  I decided to solve this via a one-line lambda to create a new decorator function   def finished message function  message  Finished          def wrapper  args    kwargs           output   function  args   kwargs          print message          return output      return wrapper   finished message def func        pass  my finished message   lambda f  finished message f   All Done      my finished message def my func        pass  if   name         main         func       my func     When executed  this prints   Finished  All Done    Perhaps not as extensible as other solutions  but worked for me

User · Answer

I d like to show an idea which is IMHO quite elegant  The solution proposed by t dubrownik shows a pattern which is always the same  you need the three-layered wrapper regardless of what the decorator does   So I thought this is a job for a meta-decorator  that is  a decorator for decorators  As a decorator is a function  it actually works as a regular decorator with arguments   def parametrized dec       def layer  args    kwargs           def repl f               return dec f   args    kwargs          return repl     return layer   This can be applied to a regular decorator in order to add parameters  So for instance  say we have the decorator which doubles the result of a function   def double f       def aux  xs    kws           return 2   f  xs    kws      return aux   double def function a       return 10   a  print function 3       Prints 26  namely 2    10   3    With  parametrized we can build a generic  multiply decorator having a parameter   parametrized def multiply f  n       def aux  xs    kws           return n   f  xs    kws      return aux   multiply 2  def function a       return 10   a  print function 3       Prints 26   multiply 3  def function again a       return 10   a  print function 3             Keeps printing 26 print function again 3       Prints 39  namely 3    10   3    Conventionally the first parameter of a parametrized decorator is the function  while the remaining arguments will correspond to the parameter of the parametrized decorator   An interesting usage example could be a type-safe assertive decorator   import itertools as it   parametrized def types f   types       def rep  args           for a  t  n in zip args  types  it count                 if type a  is not t                  raise TypeError  Value  d has not type  s   s instead                         n  t  type a                             return f  args      return rep   types str  int     arg1 is str  arg2 is int def string multiply text  times       return text   times  print string multiply  hello   3        Prints hellohellohello print string multiply 3  3              Fails miserably with TypeError   A final note  here I m not using functools wraps for the wrapper functions   but I would recommend using it all the times

User · Answer

Great answers above  This one also illustrates  wraps  which takes the doc string and function name from the original function and applies it to the new wrapped version   from functools import wraps  def decorator func with args arg1  arg2       def decorator f            wraps f          def wrapper  args    kwargs               print  Before orginal function with decorator args    arg1  arg2              result   f  args    kwargs              print  Ran after the orginal function               return result         return wrapper     return decorator   decorator func with args  foo    bar   def hello name          A function which prints a greeting to the name provided              print  hello    name      return 42  print  Starting script     x   hello  Bob   print  The value of x is    x  print  The wrapped functions docstring is    hello   doc    print  The wrapped functions name is    hello   name      Prints   Starting script   Before orginal function with decorator args  foo bar hello  Bob Ran after the orginal function The value of x is  42 The wrapped functions docstring is  A function which prints a greeting to the name provided  The wrapped functions name is  hello

User · Answer

The syntax for decorators with arguments is a bit different - the decorator with arguments should return a function that will take a function and return another function  So it should really return a normal decorator  A bit confusing  right  What I mean is   def decorator factory argument       def decorator function           def wrapper  args    kwargs               funny stuff               something with argument argument              result   function  args    kwargs              more funny stuff               return result         return wrapper     return decorator   Here you can read more on the subject - it s also possible to implement this using callable objects and that is also explained there

User · Answer

def decorator argument       def real decorator function           def wrapper  args               for arg in args                  assert type arg   int f  arg  is not an interger              result   function  args              result   result argument             return result         return wrapper     return real decorator   Usage of the decorator   decorator 2  def adder  args       sum 0     for i in args          sum  i     return sum   Then the  adder 2 3    produces  10   but   adder  hi  3    produces  --------------------------------------------------------------------------- AssertionError                            Traceback  most recent call last   lt ipython-input-143-242a8feb1cc4 gt  in  lt module gt  ---- gt  1 adder  hi  3    lt ipython-input-140-d3420c248ebd gt  in wrapper  args        3         def wrapper  args         4             for arg in args  ---- gt  5                 assert type arg   int f  arg  is not an interger        6             result   function  args        7             result   result argument  AssertionError  hi is not an interger

User · Answer

Writing a decorator that works with and without parameter is a challenge because Python expects completely different behavior in these two cases  Many answers have tried to work around this and below is an improvement of answer by  norok2  Specifically  this variation eliminates the use of locals      Following the same example as given by  norok2   import functools  def multiplying f py None  factor 1       assert callable f py  or f py is None     def  decorator func            functools wraps func          def wrapper  args    kwargs               return factor   func  args    kwargs          return wrapper     return  decorator f py  if callable f py  else  decorator    multiplying def summing x   return sum x   print summing range 10      45    multiplying   def summing x   return sum x   print summing range 10      45    multiplying factor 10  def summing x   return sum x   print summing range 10      450   Play with this code   The catch is that the user must supply key value pairs of parameters instead of positional parameters and the first parameter is reserved

User · Answer

This is a template for a function decorator that does not require    if no parameters are to be given   import functools   def decorator x or func None   decorator args    decorator kws       def  decorator func            functools wraps func          def wrapper  args    kws               if  x or func  not in locals                         or callable x or func                        or x or func is None                  x           lt -- default  x  value             else                  x   x or func             return func  args    kws           return wrapper      return  decorator x or func  if callable x or func  else  decorator   an example of this is given below   def multiplying factor or func None       def  decorator func            functools wraps func          def wrapper  args    kwargs               if  factor or func  not in locals                         or callable factor or func                        or factor or func is None                  factor   1             else                  factor   factor or func             return factor   func  args    kwargs          return wrapper     return  decorator factor or func  if callable factor or func  else  decorator    multiplying def summing x   return sum x   print summing range 10      45    multiplying   def summing x   return sum x   print summing range 10      45    multiplying 10  def summing x   return sum x   print summing range 10      450

User · Answer

Edit   for an in-depth understanding of the mental model of decorators  take a look at this awesome Pycon Talk  well worth the 30 minutes  One way of thinking about decorators with arguments is  decorator def foo  args    kwargs       pass  translates to foo   decorator foo   So if the decorator had arguments   decorator with args arg  def foo  args    kwargs       pass  translates to foo   decorator with args arg  foo   decorator with args is a function which accepts a custom argument and which returns the actual decorator  that will be applied to the decorated function   I use a simple trick with partials to make my decorators easy from functools import partial  def  pseudo decor fun  argument       def ret fun  args    kwargs            do stuff here  for eg          print   quot decorator arg is  s quot    str argument           return fun  args    kwargs      return ret fun  real decorator   partial  pseudo decor  argument arg    real decorator def foo  args    kwargs       pass  Update  Above  foo becomes real decorator foo  One effect of decorating a function is that the name foo is overridden upon decorator declaration  foo is  quot overridden quot  by whatever is returned by real decorator  In this case  a new function object  All of foo s metadata is overridden  notably docstring and function name   gt  gt  gt  print foo   lt function  pseudo decor  lt locals gt  ret fun at 0x10666a2f0 gt   functools wraps gives us a convenient method to  quot lift quot  the docstring and name to the returned function  from functools import partial  wraps  def  pseudo decor fun  argument         magic sauce to lift the name and doc of the function      wraps fun      def ret fun  args    kwargs             pre function execution stuff here  for eg          print  quot decorator argument is  s quot    str argument           returned value    fun  args    kwargs            post execution stuff here  for eg          print  quot returned value is  s quot    returned value          return returned value      return ret fun  real decorator1   partial  pseudo decor  argument  quot some arg quot   real decorator2   partial  pseudo decor  argument  quot some other arg quot     real decorator1 def bar  args    kwargs       pass   gt  gt  gt  print bar   lt function   main   bar  args    kwargs  gt    gt  gt  gt  bar 1 2 3  k  quot v quot   x  quot z quot   decorator argument is some arg returned value is None

[python] Decorators with parameters?

Examples related to python

Examples related to decorator