Question

If I have to wrap an existing method, let us say wrapee() from a new method, say wrapper(), and the wrapee() provides default values for some arguments, how do I preserve its semantics without introducing unnecessary dependencies and maintenance? Let us say, the goal is to be able to use wrapper() in place of wrapee() without having to change the client code. E.g., if wrapee() is defined as:

def wrapee(param1, param2="Some Value"):
  # Do something

Then, one way to define wrapper() is:

def wrapper(param1, param2="Some Value"):
  # Do something
  wrapee(param1, param2)
  # Do something else.

However, wrapper() has to make assumptions on the default value for param2 which I don’t like. If I have the control on wrapee(), I would define it like this:

def wrapee(param1, param2=None):
  param2 = param2 or "Some Value"
  # Do something

Then, wrapper() would change to:

def wrapper(param1, param2=None):
  # Do something
  wrapee(param1, param2)
  # Do something else.

If I don’t have control on how wrapee() is defined, how best to define wrapper()? One option that comes into mind is to use to create a dict with non-None arguments and pass it as dictionary arguments, but it seems unnecessarily tedious.

Update:

The solution is to use both the list and dictionary arguments like this:

def wrapper(param1, *args, **argv):
  # Do something
  wrapee(param1, *args, **argv)
  # Do something else.

All the following calls are then valid:

wrapper('test1')
wrapper('test1', 'test2')
wrapper('test1', param2='test2')
wrapper(param2='test2', param1='test1')

Answer 1

Check out argument lists in the Python docs.

>>> def wrapper(param1, *stuff, **kargs):
...  print(param1)
...  print(stuff)
...  print(args)
...
>>> wrapper(3, 4, 5, foo=2)
3
(4, 5)
{'foo': 2}

Then to pass the args along:

wrapee(param1, *stuff, **kargs)

The *stuff is a variable number of non-named arguments, and the **kargs is a variable number of named arguments.