Printing and clearing¶

voidPyErr_Clear()¶

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

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 no traceback isprinted and the 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).

voidPyErr_WriteUnraisable(PyObject *obj)¶

Callsys.unraisablehook() using the current exception andobjargument.

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.

An exception must be set when calling this function.

Raising exceptions¶

These functions help you set the current thread’s error indicator.For convenience, some of these functions will always return aNULL pointer for use in areturn statement.

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 decoded from'utf-8'.

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 inPyUnicode_FromFormat().format is an ASCII-encodedstring.

PyObject*PyErr_FormatV(PyObject *exception, const char *format, va_list vargs)¶

Return value: Always NULL.

Same asPyErr_Format(), but taking ava_list argument ratherthan a variable number of arguments.

New in version 3.5.

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)¶

Return value: Always NULL.

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

PyObject*PyErr_SetFromErrnoWithFilenameObjects(PyObject *type,PyObject *filenameObject,PyObject *filenameObject2)¶

Return value: Always NULL.

Similar toPyErr_SetFromErrnoWithFilenameObject(), but takes a secondfilename object, for raising errors when a function that takes two filenamesfails.

New in version 3.4.

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

Return value: Always NULL.

Similar toPyErr_SetFromErrnoWithFilenameObject(), but the filenameis given as a C string.filename is decoded from the filesystem encoding(os.fsdecode()).

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.

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

Return value: Always NULL.

Similar toPyErr_SetFromWindowsErrWithFilenameObject(), but thefilename is given as a C string.filename is decoded from the filesystemencoding (os.fsdecode()).

Availability: Windows.

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

Return value: Always NULL.

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

Availability: Windows.

PyObject*PyErr_SetExcFromWindowsErrWithFilenameObjects(PyObject *type, int ierr,PyObject *filename,PyObject *filename2)¶

Return value: Always NULL.

Similar toPyErr_SetExcFromWindowsErrWithFilenameObject(),but accepts a second filename object.

Availability: Windows.

New in version 3.4.

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.

PyObject*PyErr_SetImportError(PyObject *msg,PyObject *name,PyObject *path)¶

Return value: Always NULL.

This is a convenience function to raiseImportError.msg will beset as the exception’s message string.name andpath, both of which canbeNULL, will be set as theImportError’s respectivenameandpath attributes.

New in version 3.3.

PyObject*PyErr_SetImportErrorSubclass(PyObject *exception,PyObject *msg,PyObject *name,PyObject *path)¶

Return value: Always NULL.

Much likePyErr_SetImportError() but this function allows forspecifying a subclass ofImportError to raise.

New in version 3.6.

voidPyErr_SyntaxLocationObject(PyObject *filename, int lineno, int col_offset)¶

Set file, line, and offset information for the current exception. If thecurrent exception is not aSyntaxError, then it sets additionalattributes, which make the exception printing subsystem think the exceptionis aSyntaxError.

New in version 3.4.

voidPyErr_SyntaxLocationEx(const char *filename, int lineno, int col_offset)¶

LikePyErr_SyntaxLocationObject(), butfilename is a byte stringdecoded from the filesystem encoding (os.fsdecode()).

New in version 3.2.

voidPyErr_SyntaxLocation(const char *filename, int lineno)¶

LikePyErr_SyntaxLocationEx(), but thecol_offset parameter isomitted.

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.

Issuing warnings¶

Use these functions to issue warnings from C code. They mirror similarfunctions exported by the Pythonwarnings module. They normallyprint 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 they will raise an exception. It is also possible thatthe functions raise an exception because of a problem with the warning machinery.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).

intPyErr_WarnEx(PyObject *category, const char *message,Py_ssize_t stack_level)¶

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

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_WarnExplicitObject(PyObject *category,PyObject *message,PyObject *filename, int lineno,PyObject *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.

New in version 3.4.

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

Similar toPyErr_WarnExplicitObject() except thatmessage andmodule are UTF-8 encoded strings, andfilename is decoded from thefilesystem encoding (os.fsdecode()).

intPyErr_WarnFormat(PyObject *category,Py_ssize_t stack_level, const char *format, ...)¶

Function similar toPyErr_WarnEx(), but usePyUnicode_FromFormat() to format the warning message.format isan ASCII-encoded string.

New in version 3.2.

intPyErr_ResourceWarning(PyObject *source,Py_ssize_t stack_level, const char *format, ...)¶

Function similar toPyErr_WarnFormat(), butcategory isResourceWarning and it passessource towarnings.WarningMessage().

New in version 3.6.

Querying the error indicator¶

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.

The caller must hold the GIL.

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 type inexc. Ifexc is a class object, this also returns true whengiven is an instanceof a subclass. Ifexc is a tuple, all exception types in the tuple (andrecursively in subtuples) are searched for a match.

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 catch exceptions orby code that needs to save and restore the error indicator temporarily, e.g.:

{PyObject*type,*value,*traceback;PyErr_Fetch(&type,&value,&traceback);/* ... code that might produce other errors ... */PyErr_Restore(type,value,traceback);}

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 currenterror indicator.

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.

Note

This functiondoes not implicitly set the__traceback__attribute on the exception value. If setting the tracebackappropriately is desired, the following additional snippet is needed:

if(tb!=NULL){PyException_SetTraceback(val,tb);}

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

Retrieve the exception info, as known fromsys.exc_info(). This refersto an exception that wasalready caught, not to an exception that wasfreshly raised. Returns new references for the three objects, any of whichmay beNULL. Does not modify the exception info state.

Note

This function is not normally used by code that wants to handle exceptions.Rather, it can be used when code needs to save and restore the exceptionstate temporarily. UsePyErr_SetExcInfo() to restore or clear theexception state.

New in version 3.3.

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

Set the exception info, as known fromsys.exc_info(). This refersto an exception that wasalready caught, not to an exception that wasfreshly raised. This function steals the references of the arguments.To clear the exception state, passNULL for all three arguments.For general rules about the three arguments, seePyErr_Restore().

Note

This function is not normally used by code that wants to handle exceptions.Rather, it can be used when code needs to save and restore the exceptionstate temporarily. UsePyErr_GetExcInfo() to read the exceptionstate.

New in version 3.3.

Signal Handling¶

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()¶

Simulate the effect of aSIGINT signal arriving. The next timePyErr_CheckSignals() is called, the Python signal handler forSIGINT will be called.

IfSIGINT isn’t handled by Python (it was set tosignal.SIG_DFL orsignal.SIG_IGN), this function doesnothing.

intPySignal_SetWakeupFd(int fd)¶

This utility function specifies a file descriptor to which the signal numberis written as a single byte whenever a signal is received.fd must benon-blocking. It returns the previous such file descriptor.

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.

Changed in version 3.5:On Windows, the function now also supports socket handles.

Exception Classes¶

PyObject*PyErr_NewException(const 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(const char *name, const 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 3.2.

Exception Objects¶

PyObject*PyException_GetTraceback(PyObject *ex)¶

Return value: New reference.

Return the traceback associated with the exception as a new reference, asaccessible from Python through__traceback__. If there is notraceback associated, this returnsNULL.

intPyException_SetTraceback(PyObject *ex,PyObject *tb)¶

Set the traceback associated with the exception totb. UsePy_None toclear it.

PyObject*PyException_GetContext(PyObject *ex)¶

Return value: New reference.

Return the context (another exception instance during whose handlingex wasraised) associated with the exception as a new reference, as accessible fromPython through__context__. If there is no context associated, thisreturnsNULL.

voidPyException_SetContext(PyObject *ex,PyObject *ctx)¶

Set the context associated with the exception toctx. UseNULL to clearit. There is no type check to make sure thatctx is an exception instance.This steals a reference toctx.

PyObject*PyException_GetCause(PyObject *ex)¶

Return value: New reference.

Return the cause (either an exception instance, orNone,set byraise...from...) associated with the exception as a newreference, as accessible from Python through__cause__.

voidPyException_SetCause(PyObject *ex,PyObject *cause)¶

Set the cause associated with the exception tocause. UseNULL to clearit. There is no type check to make sure thatcause is either an exceptioninstance orNone. This steals a reference tocause.

__suppress_context__ is implicitly set toTrue by this function.

Unicode Exception Objects¶

The following functions are used to create and modify Unicode exceptions from C.

PyObject*PyUnicodeDecodeError_Create(const char *encoding, const char *object,Py_ssize_t length,Py_ssize_t start,Py_ssize_t end, const char *reason)¶

Return value: New reference.

Create aUnicodeDecodeError object with the attributesencoding,object,length,start,end andreason.encoding andreason areUTF-8 encoded strings.

PyObject*PyUnicodeEncodeError_Create(const char *encoding, constPy_UNICODE *object,Py_ssize_t length,Py_ssize_t start,Py_ssize_t end, const char *reason)¶

Return value: New reference.

Create aUnicodeEncodeError object with the attributesencoding,object,length,start,end andreason.encoding andreason areUTF-8 encoded strings.

Deprecated since version 3.3:3.11

Py_UNICODE is deprecated since Python 3.3. Please migrate toPyObject_CallFunction(PyExc_UnicodeEncodeError,"sOnns",...).

PyObject*PyUnicodeTranslateError_Create(constPy_UNICODE *object,Py_ssize_t length,Py_ssize_t start,Py_ssize_t end, const char *reason)¶

Return value: New reference.

Create aUnicodeTranslateError object with the attributesobject,length,start,end andreason.reason is a UTF-8 encoded string.

Deprecated since version 3.3:3.11

Py_UNICODE is deprecated since Python 3.3. Please migrate toPyObject_CallFunction(PyExc_UnicodeTranslateError,"Onns",...).

PyObject*PyUnicodeDecodeError_GetEncoding(PyObject *exc)¶

PyObject*PyUnicodeEncodeError_GetEncoding(PyObject *exc)¶

Return value: New reference.

Return theencoding attribute of the given exception object.

PyObject*PyUnicodeDecodeError_GetObject(PyObject *exc)¶

PyObject*PyUnicodeEncodeError_GetObject(PyObject *exc)¶

PyObject*PyUnicodeTranslateError_GetObject(PyObject *exc)¶

Return value: New reference.

Return theobject attribute of the given exception object.

intPyUnicodeDecodeError_GetStart(PyObject *exc,Py_ssize_t *start)¶

intPyUnicodeEncodeError_GetStart(PyObject *exc,Py_ssize_t *start)¶

intPyUnicodeTranslateError_GetStart(PyObject *exc,Py_ssize_t *start)¶

Get thestart attribute of the given exception object and place it into*start.start must not beNULL. Return0 on success,-1 onfailure.

intPyUnicodeDecodeError_SetStart(PyObject *exc,Py_ssize_t start)¶

intPyUnicodeEncodeError_SetStart(PyObject *exc,Py_ssize_t start)¶

intPyUnicodeTranslateError_SetStart(PyObject *exc,Py_ssize_t start)¶

Set thestart attribute of the given exception object tostart. Return0 on success,-1 on failure.

intPyUnicodeDecodeError_GetEnd(PyObject *exc,Py_ssize_t *end)¶

intPyUnicodeEncodeError_GetEnd(PyObject *exc,Py_ssize_t *end)¶

intPyUnicodeTranslateError_GetEnd(PyObject *exc,Py_ssize_t *end)¶

Get theend attribute of the given exception object and place it into*end.end must not beNULL. Return0 on success,-1 onfailure.

intPyUnicodeDecodeError_SetEnd(PyObject *exc,Py_ssize_t end)¶

intPyUnicodeEncodeError_SetEnd(PyObject *exc,Py_ssize_t end)¶

intPyUnicodeTranslateError_SetEnd(PyObject *exc,Py_ssize_t end)¶

Set theend attribute of the given exception object toend. Return0on success,-1 on failure.

PyObject*PyUnicodeDecodeError_GetReason(PyObject *exc)¶

PyObject*PyUnicodeEncodeError_GetReason(PyObject *exc)¶

PyObject*PyUnicodeTranslateError_GetReason(PyObject *exc)¶

Return value: New reference.

Return thereason attribute of the given exception object.

intPyUnicodeDecodeError_SetReason(PyObject *exc, const char *reason)¶

intPyUnicodeEncodeError_SetReason(PyObject *exc, const char *reason)¶

intPyUnicodeTranslateError_SetReason(PyObject *exc, const char *reason)¶

Set thereason attribute of the given exception object toreason. Return0 on success,-1 on failure.

Recursion Control¶

These two functions provide a way to perform safe recursive calls at the Clevel, both in the core and in extension modules. They are needed if therecursive code does not necessarily invoke Python code (which tracks itsrecursion depth automatically).They are also not needed fortp_call implementationsbecause thecall protocol takes care of recursion handling.

intPy_EnterRecursiveCall(const char *where)¶

Marks a point where a recursive C-level call is about to be performed.

IfUSE_STACKCHECK is defined, this function checks if the OSstack overflowed usingPyOS_CheckStack(). In this is the case, itsets aMemoryError and returns a nonzero value.

The function then checks if the recursion limit is reached. If this is thecase, aRecursionError is set and a nonzero value is returned.Otherwise, zero is returned.

where should be a UTF-8 encoded string such as"ininstancecheck" tobe concatenated to theRecursionError message caused by the recursiondepth limit.

Changed in version 3.9:This function is now also available in the limited API.

voidPy_LeaveRecursiveCall(void)¶

Ends aPy_EnterRecursiveCall(). Must be called once for eachsuccessful invocation ofPy_EnterRecursiveCall().

Changed in version 3.9:This function is now also available in the limited API.

Properly implementingtp_repr for container types requiresspecial recursion handling. In addition to protecting the stack,tp_repr also needs to track objects to prevent cycles. Thefollowing two functions facilitate this functionality. Effectively,these are the C equivalent toreprlib.recursive_repr().

intPy_ReprEnter(PyObject *object)¶

Called at the beginning of thetp_repr implementation todetect cycles.

If the object has already been processed, the function returns apositive integer. In that case thetp_repr implementationshould return a string object indicating a cycle. As examples,dict objects return{...} andlist objectsreturn[...].

The function will return a negative integer if the recursion limitis reached. In that case thetp_repr implementation shouldtypically returnNULL.

Otherwise, the function returns zero and thetp_reprimplementation can continue normally.

voidPy_ReprLeave(PyObject *object)¶

Ends aPy_ReprEnter(). Must be called once for eachinvocation ofPy_ReprEnter() that returns zero.

Standard Exceptions¶

All standard Python exceptions are available as global variables whose names arePyExc_ followed by the Python exception name. These have the typePyObject*; they are all class objects. For completeness, here are allthe variables:

These are compatibility aliases toPyExc_OSError:

Notes:

1(1,2,3,4,5)

This is a base class for other standard exceptions.

2

Only defined on Windows; protect code that uses this by testing that thepreprocessor macroMS_WINDOWS is defined.

Standard Warning Categories¶

All standard Python warning categories are available as global variables whosenames arePyExc_ followed by the Python exception name. These have the typePyObject*; they are all class objects. For completeness, here are allthe variables:

Notes:

3

This is a base class for other standard warning categories.