[−][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::instance() to get the exception instance in all cases.

ptraceback: Option<PyObject>

The PyTraceBack object associated with the error.

Methods

`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"));

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

Construct 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(_: 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.

`pub fn new_type<'p>( _: Python<'p>, name: &str, base: Option<&PyType>, dict: Option<PyObject> ) -> *mut 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]

Print a standard traceback to sys.stderr.

`pub fn print_and_set_sys_last_vars(self, py: Python)`[src]

Print a standard traceback to sys.stderr.

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

Return 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.