Pass-through keyword arguments

Question

I've got a class function that needs to "pass through" a particular keyword argument:

def createOrOpenTable(self, tableName, schema, asType=Table):
    if self.tableExists(tableName):
        return self.openTable(tableName, asType=asType)
    else:
        return self.createTable(self, tableName, schema, asType=asType)

When I call it, I get an error like this:

TypeError: createTable() got multiple values for keyword argument 'asType'

Is there any way to "pass through" such a keyword argument?

I've thought of several answers, but none of them are optimal. From worst to best:

• I could change the keyword name on one or more of the functions, but I want to use the same keyword for all three functions, since the parameter carries the same meaning.

• I could pass the asType parameter by position instead of by keyword, but if I add other keyword parameters to openTable or createTable, I'd have to remember to change the calls. I'd rather it automatically adapt, as it would if I could use the keyword form.

• I could use the **args form here instead, to get a dictionary of keyword parameters rather than using a default parameter, but that seems like using a sledgehammer to swat a fly (because of the extra lines of code needed to properly parse it).

Is there a better solution?

Answer 1

You're doing it right... Just take out the self in the second function call :)

  return self.createTable(self, tableName, schema, asType=asType)

should be:

  return self.createTable(tableName, schema, asType=asType)

Answer 2

I have to say, that I first thought of a more complicated problem. But the answer of David Wolever is absolutely correct. It is just the duplicate self here, that creates the problem. This way, the positional parameters get out of line and asType is given a value as possitional parameter (once) and as keyword-parameter (second time!).

A much more interesting problem is, what to do, when you want to enhance the called routine (createTable in the example) without everytime enhancing the intermediate function. Here, the **args solution makes the trick:

For example:

def def createOrOpenTable(self, tableName, schema, **args):
    if self.tableExists(tableName):
        return self.openTable(tableName, **args)
    else:
        return self.createTable(self, tableName, schema, **args)

By this way, it is possible to enhance the signature of createTable and openTable without having to change createOrOpenTable any more.

When create and openTable can have different keyword-parameters, then of course both routines must be defined as follows:

def createTable(self, tableName, schema, asType=None, **others):
   ...

The others parameter eats up any keyword parameters unknown to the method -- it is also not needed to evaluate it.

Answer 3

I would have posted a comment to Juergen's post, but I need to write a code example. Here's a little bit more generic version:

def def createOrOpenTable(self, tableName, schema, *args, **argd):
    if self.tableExists(tableName):
        return self.openTable(tableName, *args, **argd)
    else:
        return self.createTable(self, tableName, schema, *args, **argd)

This will allow positional arguments to also be effective (which is important if you truly want this to be a "pass-through."