Exception signature

Question

What's the signature for class Exception in python 2.x?

I wish to subclass it and add arguments of my own, while also correctly invoking super.

The following code works:

class FooError(Exception):
    def __init__(self, msg, x):
        super(FooError, self).__init__(msg)
        self.x = x

But, is there some documentation or reference? pydoc Exception is not helpful. Neither is the documentation: this or this.

Answer 1

This part of the Python documentation is not very explicit regarding method signatures, but there are some hints.

Quoting the Python Docs (6. Built-in Exceptions):

...Except where mentioned, they have an “associated value” indicating the detailed cause of the error. This may be a string or a tuple containing several items of information...

BaseException states the following:

args

The tuple of arguments given to the exception constructor.

And Exception:

Changed in version 2.5: Changed to inherit from BaseException.

The rest of the information can only be found in the sources (I think)

static int
BaseException_init(PyBaseExceptionObject *self, PyObject *args, PyObject *kwds) {
    if (!_PyArg_NoKeywords(Py_TYPE(self)->tp_name, kwds))
        return -1;

    Py_DECREF(self->args);
    self->args = args;
    Py_INCREF(self->args);

    if (PyTuple_GET_SIZE(self->args) == 1) {
        Py_CLEAR(self->message);
        self->message = PyTuple_GET_ITEM(self->args, 0);
        Py_INCREF(self->message);
    }
    return 0;
}

As you can see it allows no keyword arguments. args is initialized as a tuple in new.

So all in all the signature would be:

def __init__ ( self, *args )

And inheriting from Exception (without restricting the arguments)

class FooError ( Exception ):
    def __init__ ( self, x, *args ):
         Exception.__init__ ( self, *args )
         self.x = x

I always call the base class explicitly, I don't like super. But this is just a question of style.

Note that your code is correct. You just restrict Exception to receive only one argument, while it could handle a tuple.