Struct pyo3::exceptions::asyncio::LimitOverrunError
source · [−]#[repr(transparent)]pub struct LimitOverrunError(_);
Expand description
A Rust type representing an exception defined in Python code.
This type was created by the pyo3::import_exception!
macro - see its documentation
for more information.
Implementations
Methods from Deref<Target = PyAny>
sourcepub fn downcast<T>(&self) -> Result<&T, PyDowncastError<'_>>where
for<'py> T: PyTryFrom<'py>,
pub fn downcast<T>(&self) -> Result<&T, PyDowncastError<'_>>where
for<'py> T: PyTryFrom<'py>,
Converts this PyAny
to a concrete Python type.
Examples
use pyo3::prelude::*;
use pyo3::types::{PyAny, PyDict, PyList};
Python::with_gil(|py| {
let dict = PyDict::new(py);
assert!(dict.is_instance_of::<PyAny>().unwrap());
let any: &PyAny = dict.as_ref();
assert!(any.downcast::<PyDict>().is_ok());
assert!(any.downcast::<PyList>().is_err());
});
sourcepub fn is<T: AsPyPointer>(&self, other: &T) -> bool
pub fn is<T: AsPyPointer>(&self, other: &T) -> bool
Returns whether self
and other
point to the same object. To compare
the equality of two objects (the ==
operator), use eq
.
This is equivalent to the Python expression self is other
.
sourcepub fn hasattr<N>(&self, attr_name: N) -> PyResult<bool>where
N: IntoPy<Py<PyString>>,
pub fn hasattr<N>(&self, attr_name: N) -> PyResult<bool>where
N: IntoPy<Py<PyString>>,
Determines whether this object has the given attribute.
This is equivalent to the Python expression hasattr(self, attr_name)
.
To avoid repeated temporary allocations of Python strings, the intern!
macro can be used
to intern attr_name
.
sourcepub fn getattr<N>(&self, attr_name: N) -> PyResult<&PyAny>where
N: IntoPy<Py<PyString>>,
pub fn getattr<N>(&self, attr_name: N) -> PyResult<&PyAny>where
N: IntoPy<Py<PyString>>,
Retrieves an attribute value.
This is equivalent to the Python expression self.attr_name
.
To avoid repeated temporary allocations of Python strings, the intern!
macro can be used
to intern attr_name
.
Example: intern!
ing the attribute name
#[pyfunction]
fn version(sys: &PyModule) -> PyResult<&PyAny> {
sys.getattr(intern!(sys.py(), "version"))
}
sourcepub fn setattr<N, V>(&self, attr_name: N, value: V) -> PyResult<()>where
N: IntoPy<Py<PyString>>,
V: ToPyObject,
pub fn setattr<N, V>(&self, attr_name: N, value: V) -> PyResult<()>where
N: IntoPy<Py<PyString>>,
V: ToPyObject,
Sets an attribute value.
This is equivalent to the Python expression self.attr_name = value
.
To avoid repeated temporary allocations of Python strings, the intern!
macro can be used
to intern name
.
Example: intern!
ing the attribute name
#[pyfunction]
fn set_answer(ob: &PyAny) -> PyResult<()> {
ob.setattr(intern!(ob.py(), "answer"), 42)
}
sourcepub fn delattr<N>(&self, attr_name: N) -> PyResult<()>where
N: IntoPy<Py<PyString>>,
pub fn delattr<N>(&self, attr_name: N) -> PyResult<()>where
N: IntoPy<Py<PyString>>,
Deletes an attribute.
This is equivalent to the Python statement del self.attr_name
.
To avoid repeated temporary allocations of Python strings, the intern!
macro can be used
to intern attr_name
.
sourcepub fn compare<O>(&self, other: O) -> PyResult<Ordering>where
O: ToPyObject,
pub fn compare<O>(&self, other: O) -> PyResult<Ordering>where
O: ToPyObject,
Returns an Ordering
between self
and other
.
This is equivalent to the following Python code:
if self == other:
return Equal
elif a < b:
return Less
elif a > b:
return Greater
else:
raise TypeError("PyAny::compare(): All comparisons returned false")
Examples
use pyo3::prelude::*;
use pyo3::types::PyFloat;
use std::cmp::Ordering;
Python::with_gil(|py| -> PyResult<()> {
let a = PyFloat::new(py, 0_f64);
let b = PyFloat::new(py, 42_f64);
assert_eq!(a.compare(b)?, Ordering::Less);
Ok(())
})?;
It will return PyErr
for values that cannot be compared:
use pyo3::prelude::*;
use pyo3::types::{PyFloat, PyString};
Python::with_gil(|py| -> PyResult<()> {
let a = PyFloat::new(py, 0_f64);
let b = PyString::new(py, "zero");
assert!(a.compare(b).is_err());
Ok(())
})?;
sourcepub fn rich_compare<O>(&self, other: O, compare_op: CompareOp) -> PyResult<&PyAny>where
O: ToPyObject,
pub fn rich_compare<O>(&self, other: O, compare_op: CompareOp) -> PyResult<&PyAny>where
O: ToPyObject,
Tests whether two Python objects obey a given CompareOp
.
lt
, le
, eq
, ne
,
gt
and ge
are the specialized versions
of this function.
Depending on the value of compare_op
, this is equivalent to one of the
following Python expressions:
compare_op | Python expression |
---|---|
CompareOp::Eq | self == other |
CompareOp::Ne | self != other |
CompareOp::Lt | self < other |
CompareOp::Le | self <= other |
CompareOp::Gt | self > other |
CompareOp::Ge | self >= other |
Examples
use pyo3::class::basic::CompareOp;
use pyo3::prelude::*;
use pyo3::types::PyInt;
Python::with_gil(|py| -> PyResult<()> {
let a: &PyInt = 0_u8.into_py(py).into_ref(py).downcast()?;
let b: &PyInt = 42_u8.into_py(py).into_ref(py).downcast()?;
assert!(a.rich_compare(b, CompareOp::Le)?.is_true()?);
Ok(())
})?;
sourcepub fn lt<O>(&self, other: O) -> PyResult<bool>where
O: ToPyObject,
pub fn lt<O>(&self, other: O) -> PyResult<bool>where
O: ToPyObject,
Tests whether this object is less than another.
This is equivalent to the Python expression self < other
.
sourcepub fn le<O>(&self, other: O) -> PyResult<bool>where
O: ToPyObject,
pub fn le<O>(&self, other: O) -> PyResult<bool>where
O: ToPyObject,
Tests whether this object is less than or equal to another.
This is equivalent to the Python expression self <= other
.
sourcepub fn eq<O>(&self, other: O) -> PyResult<bool>where
O: ToPyObject,
pub fn eq<O>(&self, other: O) -> PyResult<bool>where
O: ToPyObject,
Tests whether this object is equal to another.
This is equivalent to the Python expression self == other
.
sourcepub fn ne<O>(&self, other: O) -> PyResult<bool>where
O: ToPyObject,
pub fn ne<O>(&self, other: O) -> PyResult<bool>where
O: ToPyObject,
Tests whether this object is not equal to another.
This is equivalent to the Python expression self != other
.
sourcepub fn gt<O>(&self, other: O) -> PyResult<bool>where
O: ToPyObject,
pub fn gt<O>(&self, other: O) -> PyResult<bool>where
O: ToPyObject,
Tests whether this object is greater than another.
This is equivalent to the Python expression self > other
.
sourcepub fn ge<O>(&self, other: O) -> PyResult<bool>where
O: ToPyObject,
pub fn ge<O>(&self, other: O) -> PyResult<bool>where
O: ToPyObject,
Tests whether this object is greater than or equal to another.
This is equivalent to the Python expression self >= other
.
sourcepub fn is_callable(&self) -> bool
pub fn is_callable(&self) -> bool
Determines whether this object appears callable.
This is equivalent to Python’s callable()
function.
Examples
use pyo3::prelude::*;
Python::with_gil(|py| -> PyResult<()> {
let builtins = PyModule::import(py, "builtins")?;
let print = builtins.getattr("print")?;
assert!(print.is_callable());
Ok(())
})?;
This is equivalent to the Python statement assert callable(print)
.
Note that unless an API needs to distinguish between callable and non-callable objects, there is no point in checking for callability. Instead, it is better to just do the call and handle potential exceptions.
sourcepub fn call(
&self,
args: impl IntoPy<Py<PyTuple>>,
kwargs: Option<&PyDict>
) -> PyResult<&PyAny>
pub fn call(
&self,
args: impl IntoPy<Py<PyTuple>>,
kwargs: Option<&PyDict>
) -> PyResult<&PyAny>
Calls the object.
This is equivalent to the Python expression self(*args, **kwargs)
.
Examples
use pyo3::prelude::*;
use pyo3::types::PyDict;
const CODE: &str = r#"
def function(*args, **kwargs):
assert args == ("hello",)
assert kwargs == {"cruel": "world"}
return "called with args and kwargs"
"#;
Python::with_gil(|py| {
let module = PyModule::from_code(py, CODE, "", "")?;
let fun = module.getattr("function")?;
let args = ("hello",);
let kwargs = PyDict::new(py);
kwargs.set_item("cruel", "world")?;
let result = fun.call(args, Some(kwargs))?;
assert_eq!(result.extract::<&str>()?, "called with args and kwargs");
Ok(())
})
sourcepub fn call0(&self) -> PyResult<&PyAny>
pub fn call0(&self) -> PyResult<&PyAny>
Calls the object without arguments.
This is equivalent to the Python expression self()
.
Examples
use pyo3::prelude::*;
Python::with_gil(|py| -> PyResult<()> {
let module = PyModule::import(py, "builtins")?;
let help = module.getattr("help")?;
help.call0()?;
Ok(())
})?;
This is equivalent to the Python expression help()
.
sourcepub fn call1(&self, args: impl IntoPy<Py<PyTuple>>) -> PyResult<&PyAny>
pub fn call1(&self, args: impl IntoPy<Py<PyTuple>>) -> PyResult<&PyAny>
Calls the object with only positional arguments.
This is equivalent to the Python expression self(*args)
.
Examples
use pyo3::prelude::*;
const CODE: &str = r#"
def function(*args, **kwargs):
assert args == ("hello",)
assert kwargs == {}
return "called with args"
"#;
Python::with_gil(|py| {
let module = PyModule::from_code(py, CODE, "", "")?;
let fun = module.getattr("function")?;
let args = ("hello",);
let result = fun.call1(args)?;
assert_eq!(result.extract::<&str>()?, "called with args");
Ok(())
})
sourcepub fn call_method<N, A>(
&self,
name: N,
args: A,
kwargs: Option<&PyDict>
) -> PyResult<&PyAny>where
N: IntoPy<Py<PyString>>,
A: IntoPy<Py<PyTuple>>,
pub fn call_method<N, A>(
&self,
name: N,
args: A,
kwargs: Option<&PyDict>
) -> PyResult<&PyAny>where
N: IntoPy<Py<PyString>>,
A: IntoPy<Py<PyTuple>>,
Calls a method on the object.
This is equivalent to the Python expression self.name(*args, **kwargs)
.
To avoid repeated temporary allocations of Python strings, the intern!
macro can be used
to intern name
.
Examples
use pyo3::prelude::*;
use pyo3::types::PyDict;
const CODE: &str = r#"
class A:
def method(self, *args, **kwargs):
assert args == ("hello",)
assert kwargs == {"cruel": "world"}
return "called with args and kwargs"
a = A()
"#;
Python::with_gil(|py| {
let module = PyModule::from_code(py, CODE, "", "")?;
let instance = module.getattr("a")?;
let args = ("hello",);
let kwargs = PyDict::new(py);
kwargs.set_item("cruel", "world")?;
let result = instance.call_method("method", args, Some(kwargs))?;
assert_eq!(result.extract::<&str>()?, "called with args and kwargs");
Ok(())
})
sourcepub fn call_method0<N>(&self, name: N) -> PyResult<&PyAny>where
N: IntoPy<Py<PyString>>,
pub fn call_method0<N>(&self, name: N) -> PyResult<&PyAny>where
N: IntoPy<Py<PyString>>,
Calls a method on the object without arguments.
This is equivalent to the Python expression self.name()
.
To avoid repeated temporary allocations of Python strings, the intern!
macro can be used
to intern name
.
Examples
use pyo3::prelude::*;
const CODE: &str = r#"
class A:
def method(self, *args, **kwargs):
assert args == ()
assert kwargs == {}
return "called with no arguments"
a = A()
"#;
Python::with_gil(|py| {
let module = PyModule::from_code(py, CODE, "", "")?;
let instance = module.getattr("a")?;
let result = instance.call_method0("method")?;
assert_eq!(result.extract::<&str>()?, "called with no arguments");
Ok(())
})
sourcepub fn call_method1<N, A>(&self, name: N, args: A) -> PyResult<&PyAny>where
N: IntoPy<Py<PyString>>,
A: IntoPy<Py<PyTuple>>,
pub fn call_method1<N, A>(&self, name: N, args: A) -> PyResult<&PyAny>where
N: IntoPy<Py<PyString>>,
A: IntoPy<Py<PyTuple>>,
Calls a method on the object with only positional arguments.
This is equivalent to the Python expression self.name(*args)
.
To avoid repeated temporary allocations of Python strings, the intern!
macro can be used
to intern name
.
Examples
use pyo3::prelude::*;
const CODE: &str = r#"
class A:
def method(self, *args, **kwargs):
assert args == ("hello",)
assert kwargs == {}
return "called with args"
a = A()
"#;
Python::with_gil(|py| {
let module = PyModule::from_code(py, CODE, "", "")?;
let instance = module.getattr("a")?;
let args = ("hello",);
let result = instance.call_method1("method", args)?;
assert_eq!(result.extract::<&str>()?, "called with args");
Ok(())
})
sourcepub fn is_true(&self) -> PyResult<bool>
pub fn is_true(&self) -> PyResult<bool>
Returns whether the object is considered to be true.
This is equivalent to the Python expression bool(self)
.
sourcepub fn is_none(&self) -> bool
pub fn is_none(&self) -> bool
Returns whether the object is considered to be None.
This is equivalent to the Python expression self is None
.
sourcepub fn is_empty(&self) -> PyResult<bool>
pub fn is_empty(&self) -> PyResult<bool>
Returns true if the sequence or mapping has a length of 0.
This is equivalent to the Python expression len(self) == 0
.
sourcepub fn get_item<K>(&self, key: K) -> PyResult<&PyAny>where
K: ToPyObject,
pub fn get_item<K>(&self, key: K) -> PyResult<&PyAny>where
K: ToPyObject,
Gets an item from the collection.
This is equivalent to the Python expression self[key]
.
sourcepub fn set_item<K, V>(&self, key: K, value: V) -> PyResult<()>where
K: ToPyObject,
V: ToPyObject,
pub fn set_item<K, V>(&self, key: K, value: V) -> PyResult<()>where
K: ToPyObject,
V: ToPyObject,
Sets a collection item value.
This is equivalent to the Python expression self[key] = value
.
sourcepub fn del_item<K>(&self, key: K) -> PyResult<()>where
K: ToPyObject,
pub fn del_item<K>(&self, key: K) -> PyResult<()>where
K: ToPyObject,
Deletes an item from the collection.
This is equivalent to the Python expression del self[key]
.
sourcepub fn iter(&self) -> PyResult<&PyIterator>
pub fn iter(&self) -> PyResult<&PyIterator>
Takes an object and returns an iterator for it.
This is typically a new iterator but if the argument is an iterator, this returns itself.
sourcepub fn get_type_ptr(&self) -> *mut PyTypeObject
pub fn get_type_ptr(&self) -> *mut PyTypeObject
Returns the Python type pointer for this object.
sourcepub fn cast_as<'a, D>(&'a self) -> Result<&'a D, PyDowncastError<'_>>where
D: PyTryFrom<'a>,
pub fn cast_as<'a, D>(&'a self) -> Result<&'a D, PyDowncastError<'_>>where
D: PyTryFrom<'a>,
Casts self
to a concrete Python object type.
This can cast only to native Python types, not types implemented in Rust.
sourcepub fn extract<'a, D>(&'a self) -> PyResult<D>where
D: FromPyObject<'a>,
pub fn extract<'a, D>(&'a self) -> PyResult<D>where
D: FromPyObject<'a>,
Extracts some type from the Python object.
This is a wrapper function around FromPyObject::extract()
.
sourcepub fn get_refcnt(&self) -> isize
pub fn get_refcnt(&self) -> isize
Returns the reference count for the Python object.
sourcepub fn repr(&self) -> PyResult<&PyString>
pub fn repr(&self) -> PyResult<&PyString>
Computes the “repr” representation of self.
This is equivalent to the Python expression repr(self)
.
sourcepub fn str(&self) -> PyResult<&PyString>
pub fn str(&self) -> PyResult<&PyString>
Computes the “str” representation of self.
This is equivalent to the Python expression str(self)
.
sourcepub fn hash(&self) -> PyResult<isize>
pub fn hash(&self) -> PyResult<isize>
Retrieves the hash code of self.
This is equivalent to the Python expression hash(self)
.
sourcepub fn len(&self) -> PyResult<usize>
pub fn len(&self) -> PyResult<usize>
Returns the length of the sequence or mapping.
This is equivalent to the Python expression len(self)
.
sourcepub fn dir(&self) -> &PyList
pub fn dir(&self) -> &PyList
Returns the list of attributes of this object.
This is equivalent to the Python expression dir(self)
.
sourcepub fn is_instance(&self, ty: &PyType) -> PyResult<bool>
pub fn is_instance(&self, ty: &PyType) -> PyResult<bool>
Checks whether this object is an instance of type ty
.
This is equivalent to the Python expression isinstance(self, ty)
.
sourcepub fn is_instance_of<T: PyTypeInfo>(&self) -> PyResult<bool>
pub fn is_instance_of<T: PyTypeInfo>(&self) -> PyResult<bool>
Checks whether this object is an instance of type T
.
This is equivalent to the Python expression isinstance(self, T)
,
if the type T
is known at compile time.
sourcepub fn contains<V>(&self, value: V) -> PyResult<bool>where
V: ToPyObject,
pub fn contains<V>(&self, value: V) -> PyResult<bool>where
V: ToPyObject,
Determines if self contains value
.
This is equivalent to the Python expression value in self
.
Trait Implementations
sourceimpl AsPyPointer for LimitOverrunError
impl AsPyPointer for LimitOverrunError
sourceimpl AsRef<PyAny> for LimitOverrunError
impl AsRef<PyAny> for LimitOverrunError
sourceimpl Debug for LimitOverrunError
impl Debug for LimitOverrunError
sourceimpl Deref for LimitOverrunError
impl Deref for LimitOverrunError
sourceimpl Display for LimitOverrunError
impl Display for LimitOverrunError
sourceimpl Error for LimitOverrunError
impl Error for LimitOverrunError
sourcefn source(&self) -> Option<&(dyn Error + 'static)>
fn source(&self) -> Option<&(dyn Error + 'static)>
1.0.0 · sourcefn description(&self) -> &str
fn description(&self) -> &str
sourceimpl<'a> From<&'a LimitOverrunError> for &'a PyAny
impl<'a> From<&'a LimitOverrunError> for &'a PyAny
sourcefn from(ob: &'a LimitOverrunError) -> Self
fn from(ob: &'a LimitOverrunError) -> Self
sourceimpl From<&LimitOverrunError> for Py<LimitOverrunError>
impl From<&LimitOverrunError> for Py<LimitOverrunError>
sourcefn from(other: &LimitOverrunError) -> Self
fn from(other: &LimitOverrunError) -> Self
sourceimpl From<&LimitOverrunError> for PyErr
impl From<&LimitOverrunError> for PyErr
sourcefn from(err: &LimitOverrunError) -> PyErr
fn from(err: &LimitOverrunError) -> PyErr
sourceimpl<'py> FromPyObject<'py> for &'py LimitOverrunError
impl<'py> FromPyObject<'py> for &'py LimitOverrunError
sourceimpl IntoPy<Py<LimitOverrunError>> for &LimitOverrunError
impl IntoPy<Py<LimitOverrunError>> for &LimitOverrunError
sourcefn into_py(self, py: Python<'_>) -> Py<LimitOverrunError>
fn into_py(self, py: Python<'_>) -> Py<LimitOverrunError>
sourceimpl PyNativeType for LimitOverrunError
impl PyNativeType for LimitOverrunError
sourceimpl PyTypeInfo for LimitOverrunError
impl PyTypeInfo for LimitOverrunError
type AsRefTarget = LimitOverrunError
type AsRefTarget = LimitOverrunError
sourcefn type_object_raw(_py: Python<'_>) -> *mut PyTypeObject
fn type_object_raw(_py: Python<'_>) -> *mut PyTypeObject
sourcefn type_object(py: Python<'_>) -> &PyType
fn type_object(py: Python<'_>) -> &PyType
sourcefn is_type_of(object: &PyAny) -> bool
fn is_type_of(object: &PyAny) -> bool
object
is an instance of this type or a subclass of this type.sourcefn is_exact_type_of(object: &PyAny) -> bool
fn is_exact_type_of(object: &PyAny) -> bool
object
is an instance of this type.sourceimpl ToPyObject for LimitOverrunError
impl ToPyObject for LimitOverrunError
Auto Trait Implementations
impl !RefUnwindSafe for LimitOverrunError
impl !Send for LimitOverrunError
impl !Sync for LimitOverrunError
impl Unpin for LimitOverrunError
impl UnwindSafe for LimitOverrunError
Blanket Implementations
sourceimpl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
const: unstable · sourcefn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
sourceimpl<'p, T> FromPyPointer<'p> for Twhere
T: 'p + PyNativeType,
impl<'p, T> FromPyPointer<'p> for Twhere
T: 'p + PyNativeType,
sourceunsafe fn from_owned_ptr_or_opt(
py: Python<'p>,
ptr: *mut PyObject
) -> Option<&'p T>
unsafe fn from_owned_ptr_or_opt(
py: Python<'p>,
ptr: *mut PyObject
) -> Option<&'p T>
PyObject
. Read moresourceunsafe fn from_borrowed_ptr_or_opt(
_py: Python<'p>,
ptr: *mut PyObject
) -> Option<&'p T>
unsafe fn from_borrowed_ptr_or_opt(
_py: Python<'p>,
ptr: *mut PyObject
) -> Option<&'p T>
PyObject
. Read moresourceunsafe fn from_owned_ptr_or_panic(py: Python<'p>, ptr: *mut PyObject) -> &'p Self
unsafe fn from_owned_ptr_or_panic(py: Python<'p>, ptr: *mut PyObject) -> &'p Self
PyObject
or panic. Read moresourceunsafe fn from_owned_ptr(py: Python<'p>, ptr: *mut PyObject) -> &'p Self
unsafe fn from_owned_ptr(py: Python<'p>, ptr: *mut PyObject) -> &'p Self
PyObject
or panic. Read moresourceunsafe fn from_owned_ptr_or_err(
py: Python<'p>,
ptr: *mut PyObject
) -> PyResult<&'p Self>
unsafe fn from_owned_ptr_or_err(
py: Python<'p>,
ptr: *mut PyObject
) -> PyResult<&'p Self>
PyObject
. Read moresourceunsafe fn from_borrowed_ptr_or_panic(
py: Python<'p>,
ptr: *mut PyObject
) -> &'p Self
unsafe fn from_borrowed_ptr_or_panic(
py: Python<'p>,
ptr: *mut PyObject
) -> &'p Self
PyObject
. Read more