Exception Handling¶

The functions described in this chapter will let you handle and raise Pythonexceptions. It is important to understand some of the basics of Pythonexception handling. It works somewhat like the Unixerrno variable:there is a global indicator (per thread) of the last error that occurred. Mostfunctions don’t clear this on success, but will set it to indicate the cause ofthe error on failure. Most functions also return an error indicator, usuallyNULL if they are supposed to return a pointer, or-1 if they return aninteger (exception: thePyArg_*() functions return1 for success and0 for failure).

When a function must fail because some function it called failed, it generallydoesn’t set the error indicator; the function it called already set it. It isresponsible for either handling the error and clearing the exception orreturning after cleaning up any resources it holds (such as object references ormemory allocations); it shouldnot continue normally if it is not prepared tohandle the error. If returning due to an error, it is important to indicate tothe caller that an error has been set. If the error is not handled or carefullypropagated, additional calls into the Python/C API may not behave as intendedand may fail in mysterious ways.

The error indicator consists of three Python objects corresponding to thePython variablessys.exc_type,sys.exc_value andsys.exc_traceback.API functions exist to interact with the error indicator in various ways. Thereis a separate error indicator for each thread.

voidPyErr_PrintEx(int set_sys_last_vars)¶

Print a standard traceback tosys.stderr and clear the error indicator.Unless the error is aSystemExit. In that case the no tracebackis printed and Python process will exit with the error code specified bytheSystemExit instance.

Call this functiononly when the error indicator is set. Otherwise itwill cause a fatal error!

Ifset_sys_last_vars is nonzero, the variablessys.last_type,sys.last_value andsys.last_traceback will be set to thetype, value and traceback of the printed exception, respectively.

voidPyErr_Print()¶

Alias forPyErr_PrintEx(1).

PyObject*PyErr_Occurred()¶

Return value: Borrowed reference.

Test whether the error indicator is set. If set, return the exceptiontype(the first argument to the last call to one of thePyErr_Set*()functions or toPyErr_Restore()). If not set, returnNULL. You do notown a reference to the return value, so you do not need toPy_DECREF()it.

Note

Do not compare the return value to a specific exception; usePyErr_ExceptionMatches() instead, shown below. (The comparison couldeasily fail since the exception may be an instance instead of a class, in thecase of a class exception, or it may be a subclass of the expected exception.)

intPyErr_ExceptionMatches(PyObject *exc)¶

Equivalent toPyErr_GivenExceptionMatches(PyErr_Occurred(),exc). Thisshould only be called when an exception is actually set; a memory accessviolation will occur if no exception has been raised.

intPyErr_GivenExceptionMatches(PyObject *given,PyObject *exc)¶

Return true if thegiven exception matches the exception inexc. Ifexc is a class object, this also returns true whengiven is an instanceof a subclass. Ifexc is a tuple, all exceptions in the tuple (andrecursively in subtuples) are searched for a match.

voidPyErr_NormalizeException(PyObject**exc,PyObject**val,PyObject**tb)¶

Under certain circumstances, the values returned byPyErr_Fetch() belowcan be “unnormalized”, meaning that*exc is a class object but*val isnot an instance of the same class. This function can be used to instantiatethe class in that case. If the values are already normalized, nothing happens.The delayed normalization is implemented to improve performance.

voidPyErr_Clear()¶

Clear the error indicator. If the error indicator is not set, there is noeffect.

voidPyErr_Fetch(PyObject **ptype,PyObject **pvalue,PyObject **ptraceback)¶

Retrieve the error indicator into three variables whose addresses are passed.If the error indicator is not set, set all three variables toNULL. If it isset, it will be cleared and you own a reference to each object retrieved. Thevalue and traceback object may beNULL even when the type object is not.

Note

This function is normally only used by code that needs to handle exceptions orby code that needs to save and restore the error indicator temporarily.

voidPyErr_Restore(PyObject *type,PyObject *value,PyObject *traceback)¶

Set the error indicator from the three objects. If the error indicator isalready set, it is cleared first. If the objects areNULL, the errorindicator is cleared. Do not pass aNULL type and non-NULL value ortraceback. The exception type should be a class. Do not pass an invalidexception type or value. (Violating these rules will cause subtle problemslater.) This call takes away a reference to each object: you must own areference to each object before the call and after the call you no longer ownthese references. (If you don’t understand this, don’t use this function. Iwarned you.)

Note

This function is normally only used by code that needs to save and restore theerror indicator temporarily; usePyErr_Fetch() to save the currentexception state.

voidPyErr_SetString(PyObject *type, const char *message)¶

This is the most common way to set the error indicator. The first argumentspecifies the exception type; it is normally one of the standard exceptions,e.g.PyExc_RuntimeError. You need not increment its reference count.The second argument is an error message; it is converted to a string object.

voidPyErr_SetObject(PyObject *type,PyObject *value)¶

This function is similar toPyErr_SetString() but lets you specify anarbitrary Python object for the “value” of the exception.

PyObject*PyErr_Format(PyObject *exception, const char *format, ...)¶

Return value: Always NULL.

This function sets the error indicator and returnsNULL.exceptionshould be a Python exception class. Theformat and subsequentparameters help format the error message; they have the same meaning andvalues as inPyString_FromFormat().

voidPyErr_SetNone(PyObject *type)¶

This is a shorthand forPyErr_SetObject(type,Py_None).

intPyErr_BadArgument()¶

This is a shorthand forPyErr_SetString(PyExc_TypeError,message), wheremessage indicates that a built-in operation was invoked with an illegalargument. It is mostly for internal use.

PyObject*PyErr_NoMemory()¶

Return value: Always NULL.

This is a shorthand forPyErr_SetNone(PyExc_MemoryError); it returnsNULLso an object allocation function can writereturnPyErr_NoMemory(); when itruns out of memory.

PyObject*PyErr_SetFromErrno(PyObject *type)¶

Return value: Always NULL.

This is a convenience function to raise an exception when a C library functionhas returned an error and set the C variableerrno. It constructs atuple object whose first item is the integererrno value and whosesecond item is the corresponding error message (gotten fromstrerror()),and then callsPyErr_SetObject(type,object). On Unix, when theerrno value isEINTR, indicating an interrupted system call,this callsPyErr_CheckSignals(), and if that set the error indicator,leaves it set to that. The function always returnsNULL, so a wrapperfunction around a system call can writereturnPyErr_SetFromErrno(type);when the system call returns an error.

PyObject*PyErr_SetFromErrnoWithFilenameObject(PyObject *type,PyObject *filenameObject)¶

Similar toPyErr_SetFromErrno(), with the additional behavior that iffilenameObject is notNULL, it is passed to the constructor oftype asa third parameter. In the case of exceptions such asIOError andOSError, this is used to define thefilename attribute of theexception instance.

PyObject*PyErr_SetFromErrnoWithFilename(PyObject *type, const char *filename)¶

Return value: Always NULL.

Similar toPyErr_SetFromErrnoWithFilenameObject(), but the filenameis given as a C string.

PyObject*PyErr_SetFromWindowsErr(int ierr)¶

Return value: Always NULL.

This is a convenience function to raiseWindowsError. If called withierr of0, the error code returned by a call toGetLastError()is used instead. It calls the Win32 functionFormatMessage() to retrievethe Windows description of error code given byierr orGetLastError(),then it constructs a tuple object whose first item is theierr value and whosesecond item is the corresponding error message (gotten fromFormatMessage()), and then callsPyErr_SetObject(PyExc_WindowsError,object). This function always returnsNULL. Availability: Windows.

PyObject*PyErr_SetExcFromWindowsErr(PyObject *type, int ierr)¶

Return value: Always NULL.

Similar toPyErr_SetFromWindowsErr(), with an additional parameterspecifying the exception type to be raised. Availability: Windows.

New in version 2.3.

PyObject*PyErr_SetFromWindowsErrWithFilenameObject(int ierr,PyObject *filenameObject)¶

Similar toPyErr_SetFromWindowsErr(), with the additional behavior thatiffilenameObject is notNULL, it is passed to the constructor ofWindowsError as a third parameter. Availability: Windows.

PyObject*PyErr_SetFromWindowsErrWithFilename(int ierr, const char *filename)¶

Return value: Always NULL.

Similar toPyErr_SetFromWindowsErrWithFilenameObject(), but thefilename is given as a C string. Availability: Windows.

PyObject*PyErr_SetExcFromWindowsErrWithFilenameObject(PyObject *type, int ierr,PyObject *filename)¶

Similar toPyErr_SetFromWindowsErrWithFilenameObject(), with anadditional parameter specifying the exception type to be raised.Availability: Windows.

New in version 2.3.

PyObject*PyErr_SetExcFromWindowsErrWithFilename(PyObject *type, int ierr, const char *filename)¶

Return value: Always NULL.

Similar toPyErr_SetFromWindowsErrWithFilename(), with an additionalparameter specifying the exception type to be raised. Availability: Windows.

New in version 2.3.

voidPyErr_BadInternalCall()¶

This is a shorthand forPyErr_SetString(PyExc_SystemError,message),wheremessage indicates that an internal operation (e.g. a Python/C APIfunction) was invoked with an illegal argument. It is mostly for internaluse.

intPyErr_WarnEx(PyObject *category, char *message, int stacklevel)¶

Issue a warning message. Thecategory argument is a warning category (seebelow) orNULL; themessage argument is a message string.stacklevel is apositive number giving a number of stack frames; the warning will be issued fromthe currently executing line of code in that stack frame. Astacklevel of 1is the function callingPyErr_WarnEx(), 2 is the function above that,and so forth.

This function normally prints a warning message tosys.stderr; however, it isalso possible that the user has specified that warnings are to be turned intoerrors, and in that case this will raise an exception. It is also possible thatthe function raises an exception because of a problem with the warning machinery(the implementation imports thewarnings module to do the heavy lifting).The return value is0 if no exception is raised, or-1 if an exceptionis raised. (It is not possible to determine whether a warning message isactually printed, nor what the reason is for the exception; this isintentional.) If an exception is raised, the caller should do its normalexception handling (for example,Py_DECREF() owned references and returnan error value).

Warning categories must be subclasses ofPyExc_Warning;PyExc_Warning is a subclass ofPyExc_Exception;the default warning category isPyExc_RuntimeWarning. The standardPython warning categories are available as global variables whose names areenumerated atStandard Warning Categories.

For information about warning control, see the documentation for thewarnings module and the-W option in the command linedocumentation. There is no C API for warning control.

intPyErr_Warn(PyObject *category, char *message)¶

Issue a warning message. Thecategory argument is a warning category (seebelow) orNULL; themessage argument is a message string. The warning willappear to be issued from the function callingPyErr_Warn(), equivalent tocallingPyErr_WarnEx() with astacklevel of 1.

Deprecated; usePyErr_WarnEx() instead.

intPyErr_WarnExplicit(PyObject *category, const char *message, const char *filename, int lineno, const char *module,PyObject *registry)¶

Issue a warning message with explicit control over all warning attributes. Thisis a straightforward wrapper around the Python functionwarnings.warn_explicit(), see there for more information. Themoduleandregistry arguments may be set toNULL to get the default effectdescribed there.

intPyErr_WarnPy3k(char *message, int stacklevel)¶

Issue aDeprecationWarning with the givenmessage andstacklevelif thePy_Py3kWarningFlag flag is enabled.

New in version 2.6.

intPyErr_CheckSignals()¶

This function interacts with Python’s signal handling. It checks whether asignal has been sent to the processes and if so, invokes the correspondingsignal handler. If thesignal module is supported, this can invoke asignal handler written in Python. In all cases, the default effect forSIGINT is to raise theKeyboardInterrupt exception. If anexception is raised the error indicator is set and the function returns-1;otherwise the function returns0. The error indicator may or may not becleared if it was previously set.

voidPyErr_SetInterrupt()¶

This function simulates the effect of aSIGINT signal arriving — thenext timePyErr_CheckSignals() is called,KeyboardInterrupt willbe raised. It may be called without holding the interpreter lock.

intPySignal_SetWakeupFd(int fd)¶

This utility function specifies a file descriptor to which a'\0' byte willbe written whenever a signal is received. It returns the previous such filedescriptor. The value-1 disables the feature; this is the initial state.This is equivalent tosignal.set_wakeup_fd() in Python, but without anyerror checking.fd should be a valid file descriptor. The function shouldonly be called from the main thread.

New in version 2.6.

PyObject*PyErr_NewException(char *name,PyObject *base,PyObject *dict)¶

Return value: New reference.

This utility function creates and returns a new exception class. Thenameargument must be the name of the new exception, a C string of the formmodule.classname. Thebase anddict arguments are normallyNULL.This creates a class object derived fromException (accessible in C asPyExc_Exception).

The__module__ attribute of the new class is set to the first part (upto the last dot) of thename argument, and the class name is set to the lastpart (after the last dot). Thebase argument can be used to specify alternatebase classes; it can either be only one class or a tuple of classes. Thedictargument can be used to specify a dictionary of class variables and methods.

PyObject*PyErr_NewExceptionWithDoc(char *name, char *doc,PyObject *base,PyObject *dict)¶

Return value: New reference.

Same asPyErr_NewException(), except that the new exception class caneasily be given a docstring: Ifdoc is non-NULL, it will be used as thedocstring for the exception class.

New in version 2.7.

voidPyErr_WriteUnraisable(PyObject *obj)¶

This utility function prints a warning message tosys.stderr when anexception has been set but it is impossible for the interpreter to actuallyraise the exception. It is used, for example, when an exception occurs in an__del__() method.

The function is called with a single argumentobj that identifies the contextin which the unraisable exception occurred. If possible,the repr ofobj will be printed in the warning message.