Struct numpy::PyArrayDescr
source · [−]pub struct PyArrayDescr(_);
Expand description
Binding of numpy.dtype
.
Example
use numpy::{dtype, get_array_module, PyArrayDescr};
use numpy::pyo3::{types::IntoPyDict, Python};
Python::with_gil(|py| {
let locals = [("np", get_array_module(py).unwrap())].into_py_dict(py);
let dt: &PyArrayDescr = py
.eval("np.array([1, 2, 3.0]).dtype", Some(locals), None)
.unwrap()
.downcast()
.unwrap();
assert!(dt.is_equiv_to(dtype::<f64>(py)));
});
Implementations
sourceimpl PyArrayDescr
impl PyArrayDescr
sourcepub fn new<'py, T: ToPyObject + ?Sized>(
py: Python<'py>,
obj: &T
) -> PyResult<&'py Self>
pub fn new<'py, T: ToPyObject + ?Sized>(
py: Python<'py>,
obj: &T
) -> PyResult<&'py Self>
Creates a new type descriptor (“dtype”) object from an arbitrary object.
Equivalent to invoking the constructor of numpy.dtype
.
sourcepub fn as_dtype_ptr(&self) -> *mut PyArray_Descr
pub fn as_dtype_ptr(&self) -> *mut PyArray_Descr
Returns self
as *mut PyArray_Descr
.
sourcepub fn into_dtype_ptr(&self) -> *mut PyArray_Descr
pub fn into_dtype_ptr(&self) -> *mut PyArray_Descr
Returns self
as *mut PyArray_Descr
while increasing the reference count.
Useful in cases where the descriptor is stolen by the API.
sourcepub fn of<T: Element>(py: Python<'_>) -> &Self
pub fn of<T: Element>(py: Python<'_>) -> &Self
Returns the type descriptor for a registered type.
sourcepub fn is_equiv_to(&self, other: &Self) -> bool
pub fn is_equiv_to(&self, other: &Self) -> bool
Returns true if two type descriptors are equivalent.
sourcepub fn typeobj(&self) -> &PyType
pub fn typeobj(&self) -> &PyType
Returns the array scalar corresponding to this type descriptor.
Equivalent to numpy.dtype.type
.
sourcepub fn num(&self) -> c_int
pub fn num(&self) -> c_int
Returns a unique number for each of the 21 different built-in enumerated types.
These are roughly ordered from least-to-most precision.
Equivalent to numpy.dtype.num
.
sourcepub fn itemsize(&self) -> usize
pub fn itemsize(&self) -> usize
Returns the element size of this type descriptor.
Equivalent to [numpy.dtype.itemsize
][dtype-itemsize].
sourcepub fn alignment(&self) -> usize
pub fn alignment(&self) -> usize
Returns the required alignment (bytes) of this type descriptor according to the compiler.
Equivalent to numpy.dtype.alignment
.
sourcepub fn byteorder(&self) -> u8
pub fn byteorder(&self) -> u8
Returns an ASCII character indicating the byte-order of this type descriptor object.
All built-in data-type objects have byteorder either =
or |
.
Equivalent to numpy.dtype.byteorder
.
sourcepub fn char(&self) -> u8
pub fn char(&self) -> u8
Returns a unique ASCII character for each of the 21 different built-in types.
Note that structured data types are categorized as V
(void).
Equivalent to numpy.dtype.char
.
sourcepub fn kind(&self) -> u8
pub fn kind(&self) -> u8
Returns an ASCII character (one of biufcmMOSUV
) identifying the general kind of data.
Note that structured data types are categorized as V
(void).
Equivalent to numpy.dtype.kind
.
sourcepub fn flags(&self) -> c_char
pub fn flags(&self) -> c_char
Returns bit-flags describing how this type descriptor is to be interpreted.
Equivalent to numpy.dtype.flags
.
sourcepub fn ndim(&self) -> usize
pub fn ndim(&self) -> usize
Returns the number of dimensions if this type descriptor represents a sub-array, and zero otherwise.
Equivalent to numpy.dtype.ndim
.
sourcepub fn base(&self) -> &PyArrayDescr
pub fn base(&self) -> &PyArrayDescr
Returns the type descriptor for the base element of subarrays, regardless of their dimension or shape.
If the dtype is not a subarray, returns self.
Equivalent to numpy.dtype.base
.
sourcepub fn shape(&self) -> Vec<usize>
pub fn shape(&self) -> Vec<usize>
Returns the shape of the sub-array.
If the dtype is not a sub-array, an empty vector is returned.
Equivalent to numpy.dtype.shape
.
sourcepub fn has_object(&self) -> bool
pub fn has_object(&self) -> bool
Returns true if the type descriptor contains any reference-counted objects in any fields or sub-dtypes.
Equivalent to numpy.dtype.hasobject
.
sourcepub fn is_aligned_struct(&self) -> bool
pub fn is_aligned_struct(&self) -> bool
Returns true if the type descriptor is a struct which maintains field alignment.
This flag is sticky, so when combining multiple structs together, it is preserved and produces new dtypes which are also aligned.
Equivalent to numpy.dtype.isalignedstruct
.
sourcepub fn has_subarray(&self) -> bool
pub fn has_subarray(&self) -> bool
Returns true if the type descriptor is a sub-array.
sourcepub fn has_fields(&self) -> bool
pub fn has_fields(&self) -> bool
Returns true if the type descriptor is a structured type.
sourcepub fn is_native_byteorder(&self) -> Option<bool>
pub fn is_native_byteorder(&self) -> Option<bool>
Returns true if type descriptor byteorder is native, or None
if not applicable.
sourcepub fn names(&self) -> Option<Vec<&str>>
pub fn names(&self) -> Option<Vec<&str>>
Returns an ordered list of field names, or None
if there are no fields.
The names are ordered according to increasing byte offset.
Equivalent to numpy.dtype.names
.
sourcepub fn get_field(&self, name: &str) -> PyResult<(&PyArrayDescr, usize)>
pub fn get_field(&self, name: &str) -> PyResult<(&PyArrayDescr, usize)>
Returns the type descriptor and offset of the field with the given name.
This method will return an error if this type descriptor is not structured, or if it does not contain a field with a given name.
The list of all names can be found via PyArrayDescr::names
.
Equivalent to retrieving a single item from numpy.dtype.fields
.
Methods from Deref<Target = PyAny>
sourcepub fn downcast<T>(&self) -> Result<&T, PyDowncastError<'_>> where
T: for<'py> PyTryFrom<'py>,
pub fn downcast<T>(&self) -> Result<&T, PyDowncastError<'_>> where
T: for<'py> 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>(&self, other: &T) -> bool where
T: AsPyPointer,
pub fn is<T>(&self, other: &T) -> bool where
T: AsPyPointer,
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) -> Result<bool, PyErr> where
N: ToPyObject,
pub fn hasattr<N>(&self, attr_name: N) -> Result<bool, PyErr> where
N: ToPyObject,
Determines whether this object has the given attribute.
This is equivalent to the Python expression hasattr(self, attr_name)
.
sourcepub fn getattr<N>(&self, attr_name: N) -> Result<&PyAny, PyErr> where
N: ToPyObject,
pub fn getattr<N>(&self, attr_name: N) -> Result<&PyAny, PyErr> where
N: ToPyObject,
Retrieves an attribute value.
This is equivalent to the Python expression self.attr_name
.
sourcepub fn setattr<N, V>(&self, attr_name: N, value: V) -> Result<(), PyErr> where
N: ToBorrowedObject,
V: ToBorrowedObject,
pub fn setattr<N, V>(&self, attr_name: N, value: V) -> Result<(), PyErr> where
N: ToBorrowedObject,
V: ToBorrowedObject,
Sets an attribute value.
This is equivalent to the Python expression self.attr_name = value
.
sourcepub fn delattr<N>(&self, attr_name: N) -> Result<(), PyErr> where
N: ToPyObject,
pub fn delattr<N>(&self, attr_name: N) -> Result<(), PyErr> where
N: ToPyObject,
Deletes an attribute.
This is equivalent to the Python statement del self.attr_name
.
sourcepub fn compare<O>(&self, other: O) -> Result<Ordering, PyErr> where
O: ToPyObject,
pub fn compare<O>(&self, other: O) -> Result<Ordering, PyErr> 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
) -> Result<&PyAny, PyErr> where
O: ToPyObject,
pub fn rich_compare<O>(
&self,
other: O,
compare_op: CompareOp
) -> Result<&PyAny, PyErr> where
O: ToPyObject,
Tests whether two Python objects obey a given CompareOp
.
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) -> Result<bool, PyErr> where
O: ToPyObject,
pub fn lt<O>(&self, other: O) -> Result<bool, PyErr> 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) -> Result<bool, PyErr> where
O: ToPyObject,
pub fn le<O>(&self, other: O) -> Result<bool, PyErr> 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) -> Result<bool, PyErr> where
O: ToPyObject,
pub fn eq<O>(&self, other: O) -> Result<bool, PyErr> 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) -> Result<bool, PyErr> where
O: ToPyObject,
pub fn ne<O>(&self, other: O) -> Result<bool, PyErr> 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) -> Result<bool, PyErr> where
O: ToPyObject,
pub fn gt<O>(&self, other: O) -> Result<bool, PyErr> 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) -> Result<bool, PyErr> where
O: ToPyObject,
pub fn ge<O>(&self, other: O) -> Result<bool, PyErr> 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>
) -> Result<&PyAny, PyErr>
pub fn call(
&self,
args: impl IntoPy<Py<PyTuple>>,
kwargs: Option<&PyDict>
) -> Result<&PyAny, PyErr>
Calls the object.
This is equivalent to the Python expression self(*args, **kwargs)
.
sourcepub fn call0(&self) -> Result<&PyAny, PyErr>
pub fn call0(&self) -> Result<&PyAny, PyErr>
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>>) -> Result<&PyAny, PyErr>
pub fn call1(&self, args: impl IntoPy<Py<PyTuple>>) -> Result<&PyAny, PyErr>
Calls the object with only positional arguments.
This is equivalent to the Python expression self(*args)
.
Examples
use pyo3::prelude::*;
Python::with_gil(|py| -> PyResult<()> {
let module = PyModule::import(py, "operator")?;
let add = module.getattr("add")?;
let args = (1, 2);
let value = add.call1(args)?;
assert_eq!(value.extract::<i32>()?, 3);
Ok(())
})?;
This is equivalent to the following Python code:
from operator import add
value = add(1,2)
assert value == 3
sourcepub fn call_method(
&self,
name: &str,
args: impl IntoPy<Py<PyTuple>>,
kwargs: Option<&PyDict>
) -> Result<&PyAny, PyErr>
pub fn call_method(
&self,
name: &str,
args: impl IntoPy<Py<PyTuple>>,
kwargs: Option<&PyDict>
) -> Result<&PyAny, PyErr>
Calls a method on the object.
This is equivalent to the Python expression self.name(*args, **kwargs)
.
Examples
use pyo3::prelude::*;
use pyo3::types::{IntoPyDict, PyList};
Python::with_gil(|py| -> PyResult<()> {
let list = PyList::new(py, vec![3, 6, 5, 4, 7]);
let kwargs = vec![("reverse", true)].into_py_dict(py);
list.call_method("sort", (), Some(kwargs))?;
assert_eq!(list.extract::<Vec<i32>>()?, vec![7, 6, 5, 4, 3]);
Ok(())
})?;
This is equivalent to the following Python code:
my_list = [3, 6, 5, 4, 7]
my_list.sort(reverse = True)
assert my_list == [7, 6, 5, 4, 3]
sourcepub fn call_method0(&self, name: &str) -> Result<&PyAny, PyErr>
pub fn call_method0(&self, name: &str) -> Result<&PyAny, PyErr>
Calls a method on the object without arguments.
This is equivalent to the Python expression self.name()
.
Examples
use pyo3::prelude::*;
use pyo3::types::PyFloat;
use std::f64::consts::PI;
Python::with_gil(|py| -> PyResult<()> {
let pi = PyFloat::new(py, PI);
let ratio = pi.call_method0("as_integer_ratio")?;
let (a, b) = ratio.extract::<(u64, u64)>()?;
assert_eq!(a, 884_279_719_003_555);
assert_eq!(b, 281_474_976_710_656);
Ok(())
})?;
This is equivalent to the following Python code:
import math
a, b = math.pi.as_integer_ratio()
sourcepub fn call_method1(
&self,
name: &str,
args: impl IntoPy<Py<PyTuple>>
) -> Result<&PyAny, PyErr>
pub fn call_method1(
&self,
name: &str,
args: impl IntoPy<Py<PyTuple>>
) -> Result<&PyAny, PyErr>
Calls a method on the object with only positional arguments.
This is equivalent to the Python expression self.name(*args)
.
Examples
use pyo3::prelude::*;
use pyo3::types::PyList;
Python::with_gil(|py| -> PyResult<()> {
let list = PyList::new(py, vec![1, 3, 4]);
list.call_method1("insert", (1, 2))?;
assert_eq!(list.extract::<Vec<u8>>()?, [1, 2, 3, 4]);
Ok(())
})?;
This is equivalent to the following Python code:
list_ = [1,3,4]
list_.insert(1,2)
assert list_ == [1,2,3,4]
sourcepub fn is_true(&self) -> Result<bool, PyErr>
pub fn is_true(&self) -> Result<bool, PyErr>
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) -> Result<bool, PyErr>
pub fn is_empty(&self) -> Result<bool, PyErr>
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) -> Result<&PyAny, PyErr> where
K: ToBorrowedObject,
pub fn get_item<K>(&self, key: K) -> Result<&PyAny, PyErr> where
K: ToBorrowedObject,
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) -> Result<(), PyErr> where
K: ToBorrowedObject,
V: ToBorrowedObject,
pub fn set_item<K, V>(&self, key: K, value: V) -> Result<(), PyErr> where
K: ToBorrowedObject,
V: ToBorrowedObject,
Sets a collection item value.
This is equivalent to the Python expression self[key] = value
.
sourcepub fn del_item<K>(&self, key: K) -> Result<(), PyErr> where
K: ToBorrowedObject,
pub fn del_item<K>(&self, key: K) -> Result<(), PyErr> where
K: ToBorrowedObject,
Deletes an item from the collection.
This is equivalent to the Python expression del self[key]
.
sourcepub fn iter(&self) -> Result<&PyIterator, PyErr>
pub fn iter(&self) -> Result<&PyIterator, PyErr>
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<'a>> where
D: PyTryFrom<'a>,
pub fn cast_as<'a, D>(&'a self) -> Result<&'a D, PyDowncastError<'a>> where
D: PyTryFrom<'a>,
Casts the PyObject 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) -> Result<D, PyErr> where
D: FromPyObject<'a>,
pub fn extract<'a, D>(&'a self) -> Result<D, PyErr> 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) -> Result<&PyString, PyErr>
pub fn repr(&self) -> Result<&PyString, PyErr>
Computes the “repr” representation of self.
This is equivalent to the Python expression repr(self)
.
sourcepub fn str(&self) -> Result<&PyString, PyErr>
pub fn str(&self) -> Result<&PyString, PyErr>
Computes the “str” representation of self.
This is equivalent to the Python expression str(self)
.
sourcepub fn hash(&self) -> Result<isize, PyErr>
pub fn hash(&self) -> Result<isize, PyErr>
Retrieves the hash code of self.
This is equivalent to the Python expression hash(self)
.
sourcepub fn len(&self) -> Result<usize, PyErr>
pub fn len(&self) -> Result<usize, PyErr>
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, typ: &PyType) -> Result<bool, PyErr>
pub fn is_instance(&self, typ: &PyType) -> Result<bool, PyErr>
Checks whether this object is an instance of type typ
.
This is equivalent to the Python expression isinstance(self, typ)
.
sourcepub fn is_instance_of<T>(&self) -> Result<bool, PyErr> where
T: PyTypeObject,
pub fn is_instance_of<T>(&self) -> Result<bool, PyErr> where
T: PyTypeObject,
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.
Trait Implementations
sourceimpl AsPyPointer for PyArrayDescr
impl AsPyPointer for PyArrayDescr
sourceimpl Debug for PyArrayDescr
impl Debug for PyArrayDescr
sourceimpl Deref for PyArrayDescr
impl Deref for PyArrayDescr
sourceimpl Display for PyArrayDescr
impl Display for PyArrayDescr
sourceimpl From<&'_ PyArrayDescr> for Py<PyArrayDescr>
impl From<&'_ PyArrayDescr> for Py<PyArrayDescr>
sourcefn from(other: &PyArrayDescr) -> Self
fn from(other: &PyArrayDescr) -> Self
Performs the conversion.
sourceimpl<'a> From<&'a PyArrayDescr> for &'a PyAny
impl<'a> From<&'a PyArrayDescr> for &'a PyAny
sourcefn from(ob: &'a PyArrayDescr) -> Self
fn from(ob: &'a PyArrayDescr) -> Self
Performs the conversion.
sourceimpl<'py> FromPyObject<'py> for &'py PyArrayDescr
impl<'py> FromPyObject<'py> for &'py PyArrayDescr
sourceimpl IntoPy<Py<PyArrayDescr>> for &PyArrayDescr
impl IntoPy<Py<PyArrayDescr>> for &PyArrayDescr
sourcefn into_py(self, py: Python<'_>) -> Py<PyArrayDescr>
fn into_py(self, py: Python<'_>) -> Py<PyArrayDescr>
Performs the conversion.
sourceimpl PyNativeType for PyArrayDescr
impl PyNativeType for PyArrayDescr
sourceimpl PyTypeInfo for PyArrayDescr
impl PyTypeInfo for PyArrayDescr
type AsRefTarget = Self
type AsRefTarget = Self
Utility type to make Py::as_ref work.
sourcefn type_object_raw(py: Python<'_>) -> *mut PyTypeObject
fn type_object_raw(py: Python<'_>) -> *mut PyTypeObject
PyTypeObject instance for this type.
sourcefn is_type_of(ob: &PyAny) -> bool
fn is_type_of(ob: &PyAny) -> bool
Checks if 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
Checks if object
is an instance of this type.
sourceimpl ToPyObject for PyArrayDescr
impl ToPyObject for PyArrayDescr
Auto Trait Implementations
impl !RefUnwindSafe for PyArrayDescr
impl !Send for PyArrayDescr
impl !Sync for PyArrayDescr
impl Unpin for PyArrayDescr
impl UnwindSafe for PyArrayDescr
Blanket Implementations
sourceimpl<T> BorrowMut<T> for T where
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
const: unstable · sourcefn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more
sourceimpl<'p, T> FromPyPointer<'p> for T where
T: 'p + PyNativeType,
impl<'p, T> FromPyPointer<'p> for T where
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>
Convert from an arbitrary PyObject
. Read more
sourceunsafe 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>
Convert from an arbitrary borrowed PyObject
. Read more
sourceunsafe 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
Convert from an arbitrary PyObject
or panic. Read more
sourceunsafe 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
Convert from an arbitrary PyObject
or panic. Read more
sourceunsafe fn from_owned_ptr_or_err(
py: Python<'p>,
ptr: *mut PyObject
) -> Result<&'p Self, PyErr>
unsafe fn from_owned_ptr_or_err(
py: Python<'p>,
ptr: *mut PyObject
) -> Result<&'p Self, PyErr>
Convert from an arbitrary PyObject
. Read more
sourceunsafe 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
Convert from an arbitrary borrowed PyObject
. Read more
sourceimpl<'v, T> PyTryFrom<'v> for T where
T: PyTypeInfo + PyNativeType,
impl<'v, T> PyTryFrom<'v> for T where
T: PyTypeInfo + PyNativeType,
sourcefn try_from<V>(value: V) -> Result<&'v T, PyDowncastError<'v>> where
V: Into<&'v PyAny>,
fn try_from<V>(value: V) -> Result<&'v T, PyDowncastError<'v>> where
V: Into<&'v PyAny>,
Cast from a concrete Python object type to PyObject.
sourcefn try_from_exact<V>(value: V) -> Result<&'v T, PyDowncastError<'v>> where
V: Into<&'v PyAny>,
fn try_from_exact<V>(value: V) -> Result<&'v T, PyDowncastError<'v>> where
V: Into<&'v PyAny>,
Cast from a concrete Python object type to PyObject. With exact type check.
sourceimpl<T> PyTypeObject for T where
T: PyTypeInfo,
impl<T> PyTypeObject for T where
T: PyTypeInfo,
sourcefn type_object(py: Python<'_>) -> &PyType
fn type_object(py: Python<'_>) -> &PyType
Returns the safe abstraction over the type object.