[−][src]Struct pyo3::PyErr

pub struct PyErr {
    pub ptype: Py<PyType>,
    pub pvalue: PyErrValue,
    pub ptraceback: Option<PyObject>,
}

Represents a Python exception that was raised.

Fields

ptype: Py<PyType>

The type of the exception. This should be either a PyClass or a PyType.

pvalue: PyErrValue

The value of the exception.

This can be either an instance of PyObject, a tuple of arguments to be passed to ptype's constructor, or a single argument to be passed to ptype's constructor. Call PyErr::to_object() to get the exception instance in all cases.

ptraceback: Option<PyObject>

The PyTraceBack object associated with the error.

Implementations

`impl PyErr`[src]

`pub fn new<T, V>(value: V) -> PyErr where T: PyTypeObject, V: ToPyObject + 'static,` [src]

Creates a new PyErr of type T.

value can be:

a tuple: the exception instance will be created using Python T(*tuple)
any other value: the exception instance will be created using Python T(value)

Panics if T is not a Python class derived from BaseException.

Example:

return Err(PyErr::new::<exceptions::TypeError, _>("Error message"));

In most cases, you can use a concrete exception's constructors instead: the example is equivalent to

return Err(exceptions::TypeError::py_err("Error message"));
return exceptions::TypeError::into("Error message");

`pub fn from_type<A>(exc: &PyType, args: A) -> PyErr where A: ToPyObject + 'static,` [src]

Constructs a new error, with the usual lazy initialization of Python exceptions.

exc is the exception type; usually one of the standard exceptions like exceptions::RuntimeError. args is the a tuple of arguments to pass to the exception constructor.

`pub fn from_value<T>(value: PyErrValue) -> PyErr where T: PyTypeObject,` [src]

Creates a new PyErr of type T.

`pub fn from_instance(obj: &PyAny) -> PyErr`[src]

Creates a new PyErr.

obj must be an Python exception instance, the PyErr will use that instance. If obj is a Python exception type object, the PyErr will (lazily) create a new instance of that type. Otherwise, a TypeError is created instead.

`pub fn occurred(_: Python<'_>) -> bool`[src]

Gets whether an error is present in the Python interpreter's global state.

`pub fn fetch(py: Python<'_>) -> PyErr`[src]

Retrieves the current error from the Python interpreter's global state.

The error is cleared from the Python interpreter. If no error is set, returns a SystemError.

If the error fetched is a PanicException (which would have originated from a panic in a pyo3 callback) then this function will resume the panic.

`pub fn new_type<'p>( _: Python<'p>, name: &str, base: Option<&PyType>, dict: Option<PyObject> ) -> NonNull<PyTypeObject>`[src]

Creates a new exception type with the given name, which must be of the form <module>.<ExceptionName>, as required by PyErr_NewException.

base can be an existing exception type to subclass, or a tuple of classes dict specifies an optional dictionary of class variables and methods

`pub fn print(self, py: Python<'_>)`[src]

Prints a standard traceback to sys.stderr.

`pub fn print_and_set_sys_last_vars(self, py: Python<'_>)`[src]

Prints a standard traceback to sys.stderr, and sets sys.last_{type,value,traceback} attributes to this exception's data.

`pub fn matches<T>(&self, py: Python<'_>, exc: T) -> bool where T: ToBorrowedObject,` [src]

Returns true if the current exception matches the exception in exc.

If exc is a class object, this also returns true when self is an instance of a subclass. If exc is a tuple, all exceptions in the tuple (and recursively in subtuples) are searched for a match.