Struct NullGraph

pub struct NullGraph(/* private fields */);

Implementations

impl NullGraph

pub fn new_err<A>(args: A) -> PyErr

where A: PyErrArguments + Send + Sync + 'static,

Methods from Deref<Target = PyAny>

pub fn downcast<T>(&self) -> Result<&T, PyDowncastError<'_>>

where T: for<'py> PyTryFrom<'py>,

Convert this PyAny to a concrete Python type.

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

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.

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.

pub fn delattr<N>(&self, attr_name: N) -> Result<(), PyErr>

where N: ToPyObject,

Deletes an attribute.

This is equivalent to the Python expression del self.attr_name.

pub fn compare<O>(&self, other: O) -> Result<Ordering, PyErr>

where O: ToPyObject,

Compares two Python objects.

This is equivalent to:

if self == other:
    return Equal
elif a < b:
    return Less
elif a > b:
    return Greater
else:
    raise TypeError("PyAny::compare(): All comparisons returned false")

pub fn rich_compare<O>( &self, other: O, compare_op: CompareOp, ) -> Result<&PyAny, PyErr>

where O: ToPyObject,

Compares two Python objects.

Depending on the value of compare_op, this is equivalent to one of the following Python expressions:

• CompareOp::Eq: self == other
• CompareOp::Ne: self != other
• CompareOp::Lt: self < other
• CompareOp::Le: self <= other
• CompareOp::Gt: self > other
• CompareOp::Ge: self >= other

pub fn is_callable(&self) -> bool

Determines whether this object is callable.

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

pub fn call0(&self) -> Result<&PyAny, PyErr>

Calls the object without arguments.

This is equivalent to the Python expression self().

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

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

Example

use pyo3::types::IntoPyDict;

let gil = Python::acquire_gil();
let py = gil.python();
let list = vec![3, 6, 5, 4, 7].to_object(py);
let dict = vec![("reverse", true)].into_py_dict(py);
list.call_method(py, "sort", (), Some(dict)).unwrap();
assert_eq!(list.extract::<Vec<i32>>(py).unwrap(), vec![7, 6, 5, 4, 3]);

let new_element = 1.to_object(py);
list.call_method(py, "append", (new_element,), None).unwrap();
assert_eq!(list.extract::<Vec<i32>>(py).unwrap(), vec![7, 6, 5, 4, 3, 1]);

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

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

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: ToBorrowedObject,

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: ToBorrowedObject, V: ToBorrowedObject,

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: ToBorrowedObject,

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 the PyObject 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(obi).

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

Trait Implementations

impl AsPyPointer for NullGraph

fn as_ptr(&self) -> *mut PyObject

Gets the underlying FFI pointer, returns a borrowed pointer.

impl AsRef<PyAny> for NullGraph

fn as_ref(&self) -> &PyAny

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

impl Debug for NullGraph

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

Formats the value using the given formatter.

impl Deref for NullGraph

type Target = PyAny

The resulting type after dereferencing.

fn deref(&self) -> &PyAny

Dereferences the value.

impl Display for NullGraph

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

Formats the value using the given formatter.

impl Error for NullGraph

fn source(&self) -> Option<&(dyn Error + 'static)>

Returns the lower-level source of this error, if any.

fn description(&self) -> &str

👎Deprecated since 1.42.0: use the Display impl or to_string()

fn cause(&self) -> Option<&dyn Error>

👎Deprecated since 1.33.0: replaced by Error::source, which can support downcasting

fn provide<'a>(&'a self, request: &mut Request<'a>)

🔬This is a nightly-only experimental API. (error_generic_member_access)

Provides type-based access to context intended for error reports.

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

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

Converts to this type from the input type.

impl From<&NullGraph> for Py<NullGraph>

fn from(other: &NullGraph) -> Self

Converts to this type from the input type.

impl From<&NullGraph> for PyErr

fn from(err: &NullGraph) -> PyErr

Converts to this type from the input type.

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

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

Extracts Self from the source PyObject.

impl IntoPy<Py<NullGraph>> for &NullGraph

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

Performs the conversion.

impl PartialEq for NullGraph

fn eq(&self, o: &NullGraph) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PyLayout<NullGraph> for PyBaseExceptionObject

const IS_NATIVE_TYPE: bool = true

fn get_super(&mut self) -> Option<&mut <T as PyTypeInfo>::BaseLayout>

unsafe fn py_init(&mut self, _value: T)

unsafe fn py_drop(&mut self, _py: Python<'_>)

impl PyNativeType for NullGraph

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

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

Cast &PyAny to &Self without no type checking.

impl PyTypeInfo for NullGraph

const NAME: &'static str = "NullGraph"

Class name

const MODULE: Option<&'static str>

Module name, if any

type Type = ()

Type of objects to store in PyObject struct

type BaseType = PyAny

Base class

type Layout = PyBaseExceptionObject

Layout

type BaseLayout = PyObject

Layout of Basetype.

type Initializer = PyNativeTypeInitializer<NullGraph>

Initializer for layout

type AsRefTarget = NullGraph

Utility type to make Py::as_ref work

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

PyTypeObject instance for this type.

fn is_instance(ptr: &PyAny) -> bool

Check if *mut ffi::PyObject is instance of this type

const DESCRIPTION: &'static str = "\0"

Class doc string

const FLAGS: usize = 0usize

Type flags (ie PY_TYPE_FLAG_GC, PY_TYPE_FLAG_WEAKREF)

fn is_exact_instance(object: &PyAny) -> bool

Check if *mut ffi::PyObject is exact instance of this type

impl ToPyObject for NullGraph

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

Converts self into a Python object.