Struct numpy::PyArrayDescr

#[repr(transparent)]
pub struct PyArrayDescr(_);

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

impl PyArrayDescr

pub fn new<'py, T: ToPyObject + ?Sized>(
    py: Python<'py>,
    ob: &T
) -> PyResult<&'py Self>

Creates a new type descriptor (“dtype”) object from an arbitrary object.

Equivalent to invoking the constructor of numpy.dtype.

pub fn as_dtype_ptr(&self) -> *mut PyArray_Descr

Returns self as *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.

pub fn object(py: Python<'_>) -> &Self

Shortcut for creating a type descriptor of object type.

pub fn of<T: Element>(py: Python<'_>) -> &Self

Returns the type descriptor for a registered type.

pub fn is_equiv_to(&self, other: &Self) -> bool

Returns true if two type descriptors are equivalent.

pub fn typeobj(&self) -> &PyType

Returns the array scalar corresponding to this type descriptor.

Equivalent to numpy.dtype.type.

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.

pub fn itemsize(&self) -> usize

Returns the element size of this type descriptor.

Equivalent to [numpy.dtype.itemsize][dtype-itemsize].

pub fn alignment(&self) -> usize

Returns the required alignment (bytes) of this type descriptor according to the compiler.

Equivalent to numpy.dtype.alignment.

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.

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.

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.

pub fn flags(&self) -> c_char

Returns bit-flags describing how this type descriptor is to be interpreted.

Equivalent to numpy.dtype.flags.

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.

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.

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.

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.

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.

pub fn has_subarray(&self) -> bool

Returns true if the type descriptor is a sub-array.

pub fn has_fields(&self) -> bool

Returns true if the type descriptor is a structured type.

pub fn is_native_byteorder(&self) -> Option<bool>

Returns true if type descriptor byteorder is native, or None if not applicable.

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.

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>

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());
});

pub fn is<T>(&self, other: &T) -> boolwhere
    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.

pub fn hasattr<N>(&self, attr_name: N) -> Result<bool, PyErr>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.

pub fn getattr<N>(&self, attr_name: N) -> Result<&PyAny, PyErr>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"))
}

pub fn setattr<N, V>(&self, attr_name: N, value: V) -> Result<(), PyErr>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)
}

pub fn delattr<N>(&self, attr_name: N) -> Result<(), PyErr>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.

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(())
})?;

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.

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(())
})?;

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.

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.

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.

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.

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.

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.

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.

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

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

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

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::*;

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

pub fn call_method<N, A>(
    &self,
    name: N,
    args: A,
    kwargs: Option<&PyDict>
) -> Result<&PyAny, PyErr>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(())
})

pub fn call_method0<N>(&self, name: N) -> Result<&PyAny, PyErr>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(())
})

pub fn call_method1<N, A>(&self, name: N, args: A) -> Result<&PyAny, PyErr>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(())
})

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

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.

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.

pub fn get_item<K>(&self, key: K) -> Result<&PyAny, PyErr>where
    K: ToPyObject,

Gets an item from the collection.

This is equivalent to the Python expression self[key].

pub fn set_item<K, V>(&self, key: K, value: V) -> Result<(), PyErr>where
    K: ToPyObject,
    V: ToPyObject,

Sets a collection item value.

This is equivalent to the Python expression self[key] = value.

pub fn del_item<K>(&self, key: K) -> Result<(), PyErr>where
    K: ToPyObject,

Deletes an item from the collection.

This is equivalent to the Python expression del self[key].

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.

pub fn get_type(&self) -> &PyType

Returns the Python type object for this object’s type.

pub fn get_type_ptr(&self) -> *mut PyTypeObject

Returns the Python type pointer for this object.

pub fn cast_as<'a, D>(&'a self) -> Result<&'a D, PyDowncastError<'a>>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.

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

pub fn get_refcnt(&self) -> isize

Returns the reference count for the Python object.

pub fn repr(&self) -> Result<&PyString, PyErr>

Computes the “repr” representation of self.

This is equivalent to the Python expression repr(self).

pub fn str(&self) -> Result<&PyString, PyErr>

Computes the “str” representation of self.

This is equivalent to the Python expression str(self).

pub fn hash(&self) -> Result<isize, PyErr>

Retrieves the hash code of self.

This is equivalent to the Python expression hash(self).

pub fn len(&self) -> Result<usize, PyErr>

Returns the length of the sequence or mapping.

This is equivalent to the Python expression len(self).

pub fn dir(&self) -> &PyList

Returns the list of attributes of this object.

This is equivalent to the Python expression dir(self).

pub fn is_instance(&self, ty: &PyType) -> Result<bool, PyErr>

Checks whether this object is an instance of type ty.

This is equivalent to the Python expression isinstance(self, ty).

pub fn is_instance_of<T>(&self) -> Result<bool, PyErr>where
    T: PyTypeInfo,

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.

pub fn contains<V>(&self, value: V) -> Result<bool, PyErr>where
    V: ToPyObject,

Determines if self contains value.

This is equivalent to the Python expression value in self.

pub fn py(&self) -> Python<'_>

Returns a GIL marker constrained to the lifetime of this type.

pub fn py_super(&self) -> Result<&PySuper, PyErr>

Return a proxy object that delegates method calls to a parent or sibling class of type.

This is equivalent to the Python expression super()

Trait Implementations

impl AsPyPointer for PyArrayDescr

fn as_ptr(&self) -> *mut PyObject

Gets the underlying FFI pointer, returns a borrowed pointer.

impl AsRef<PyAny> for PyArrayDescr

fn as_ref(&self) -> &PyAny

Converts this type into a shared reference of the (usually inferred) input type.

impl Debug for PyArrayDescr

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl Deref for PyArrayDescr

type Target = PyAny

The resulting type after dereferencing.

fn deref(&self) -> &PyAny

Dereferences the value.

impl Display for PyArrayDescr

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<'a> From<&'a PyArrayDescr> for &'a PyAny

fn from(ob: &'a PyArrayDescr) -> Self

Converts to this type from the input type.

impl From<&PyArrayDescr> for Py<PyArrayDescr>

fn from(other: &PyArrayDescr) -> Self

Converts to this type from the input type.

impl<'py> FromPyObject<'py> for &'py PyArrayDescr

fn extract(obj: &'py PyAny) -> PyResult<Self>

Extracts Self from the source PyObject.

impl IntoPy<Py<PyArrayDescr>> for &PyArrayDescr

fn into_py(self, py: Python<'_>) -> Py<PyArrayDescr>

Performs the conversion.

impl PyNativeType for PyArrayDescr

fn py(&self) -> Python<'_>

Returns a GIL marker constrained to the lifetime of this type.

unsafe fn unchecked_downcast(obj: &PyAny) -> &Self

Cast &PyAny to &Self without no type checking.

impl PyTypeInfo for PyArrayDescr

type AsRefTarget = PyArrayDescr

Utility type to make Py::as_ref work.

const NAME: &'static str = "PyArrayDescr"

Class name.

const MODULE: Option<&'static str> = _

Module name, if any.

fn type_object_raw(py: Python<'_>) -> *mut PyTypeObject

Returns the PyTypeObject instance for this type.

fn is_type_of(ob: &PyAny) -> bool

Checks if object is an instance of this type or a subclass of this type.

fn type_object(py: Python<'_>) -> &PyType

Returns the safe abstraction over the type object.

fn is_exact_type_of(object: &PyAny) -> bool

Checks if object is an instance of this type.

impl ToPyObject for PyArrayDescr

fn to_object(&self, py: Python<'_>) -> PyObject

Converts self into a Python object.