[][src]Struct pyo3::types::PyBytes

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

Represents a Python bytes object.

This type is immutable.

Implementations

impl PyBytes[src]

pub fn new<'p>(py: Python<'p>, s: &[u8]) -> &'p PyBytes[src]

Creates a new Python bytestring object. The bytestring is initialized by copying the data from the &[u8].

Panics if out of memory.

pub fn new_with<F>(py: Python<'_>, len: usize, init: F) -> PyResult<&PyBytes> where
    F: FnOnce(&mut [u8]) -> PyResult<()>, 
[src]

Creates a new Python bytes object with an init closure to write its contents. Before calling init the bytes' contents are zero-initialised.

  • If Python raises a MemoryError on the allocation, new_with will return it inside Err.
  • If init returns Err(e), new_with will return Err(e).
  • If init returns Ok(()), new_with will return Ok(&PyBytes).

Example

use pyo3::{prelude::*, types::PyBytes};
Python::with_gil(|py| -> PyResult<()> {
    let py_bytes = PyBytes::new_with(py, 10, |bytes: &mut [u8]| {
        bytes.copy_from_slice(b"Hello Rust");
        Ok(())
    })?;
    let bytes: &[u8] = FromPyObject::extract(py_bytes)?;
    assert_eq!(bytes, b"Hello Rust");
    Ok(())
});

pub unsafe fn from_ptr(py: Python<'_>, ptr: *const u8, len: usize) -> &PyBytes[src]

Creates a new Python byte string object from a raw pointer and length.

Panics if out of memory.

pub fn as_bytes(&self) -> &[u8][src]

Gets the Python string as a byte slice.

Methods from Deref<Target = PyAny>

pub fn downcast<T>(&self) -> Result<&T, PyDowncastError<'_>> where
    T: PyTryFrom<'py>, 
[src]

Convert this PyAny to a concrete Python type.

pub fn hasattr<N>(&self, attr_name: N) -> PyResult<bool> where
    N: ToPyObject
[src]

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) -> PyResult<&PyAny> where
    N: ToPyObject
[src]

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) -> PyResult<()> where
    N: ToBorrowedObject,
    V: ToBorrowedObject
[src]

Sets an attribute value.

This is equivalent to the Python expression self.attr_name = value.

pub fn delattr<N>(&self, attr_name: N) -> PyResult<()> where
    N: ToPyObject
[src]

Deletes an attribute.

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

pub fn compare<O>(&self, other: O) -> PyResult<Ordering> where
    O: ToPyObject
[src]

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
) -> PyResult<&PyAny> where
    O: ToPyObject
[src]

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[src]

Determines whether this object is callable.

pub fn call(
    &self,
    args: impl IntoPy<Py<PyTuple>>,
    kwargs: Option<&PyDict>
) -> PyResult<&PyAny>
[src]

Calls the object.

This is equivalent to the Python expression self(*args, **kwargs).

pub fn call0(&self) -> PyResult<&PyAny>[src]

Calls the object without arguments.

This is equivalent to the Python expression self().

pub fn call1(&self, args: impl IntoPy<Py<PyTuple>>) -> PyResult<&PyAny>[src]

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>
) -> PyResult<&PyAny>
[src]

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) -> PyResult<&PyAny>[src]

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>>
) -> PyResult<&PyAny>
[src]

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) -> PyResult<bool>[src]

Returns whether the object is considered to be true.

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

pub fn is_none(&self) -> bool[src]

Returns whether the object is considered to be None.

This is equivalent to the Python expression self is None.

pub fn is_empty(&self) -> PyResult<bool>[src]

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) -> PyResult<&PyAny> where
    K: ToBorrowedObject
[src]

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) -> PyResult<()> where
    K: ToBorrowedObject,
    V: ToBorrowedObject
[src]

Sets a collection item value.

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

pub fn del_item<K>(&self, key: K) -> PyResult<()> where
    K: ToBorrowedObject
[src]

Deletes an item from the collection.

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

pub fn iter(&self) -> PyResult<PyIterator<'_>>[src]

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[src]

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

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

Returns the Python type pointer for this object.

pub fn cast_as<'a, D>(&'a self) -> Result<&'a D, PyDowncastError<'_>> where
    D: PyTryFrom<'a>, 
[src]

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) -> PyResult<D> where
    D: FromPyObject<'a>, 
[src]

Extracts some type from the Python object.

This is a wrapper function around FromPyObject::extract().

pub fn get_refcnt(&self) -> isize[src]

Returns the reference count for the Python object.

pub fn repr(&self) -> PyResult<&PyString>[src]

Computes the "repr" representation of self.

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

pub fn str(&self) -> PyResult<&PyString>[src]

Computes the "str" representation of self.

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

pub fn hash(&self) -> PyResult<isize>[src]

Retrieves the hash code of self.

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

pub fn len(&self) -> PyResult<usize>[src]

Returns the length of the sequence or mapping.

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

pub fn dir(&self) -> &PyList[src]

Returns the list of attributes of this object.

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

Trait Implementations

impl AsPyPointer for PyBytes[src]

pub fn as_ptr(&self) -> *mut PyObject[src]

Gets the underlying FFI pointer, returns a borrowed pointer.

impl AsRef<PyAny> for PyBytes[src]

impl Debug for PyBytes[src]

impl Deref for PyBytes[src]

type Target = PyAny

The resulting type after dereferencing.

impl Display for PyBytes[src]

impl<'_> From<&'_ PyBytes> for Py<PyBytes>[src]

impl<'a> From<&'a PyBytes> for &'a PyAny[src]

impl<'py> FromPyObject<'py> for &'py PyBytes[src]

impl<I: SliceIndex<[u8]>> Index<I> for PyBytes[src]

This is the same way Vec is indexed.

type Output = I::Output

The returned type after indexing.

impl<'_> IntoPy<Py<PyBytes>> for &'_ PyBytes[src]

impl PartialEq<PyBytes> for PyBytes[src]

impl PyLayout<PyBytes> for PyObject[src]

impl PyNativeType for PyBytes[src]

impl PyTypeInfo for PyBytes[src]

type Type = ()

Type of objects to store in PyObject struct

type BaseType = PyAny

Base class

type Layout = PyObject

Layout

type BaseLayout = PyObject

Layout of Basetype.

type Initializer = PyNativeTypeInitializer<Self>

Initializer for layout

type AsRefTarget = Self

Utility type to make Py::as_ref work

impl ToPyObject for PyBytes[src]

Auto Trait Implementations

impl !RefUnwindSafe for PyBytes

impl !Send for PyBytes

impl !Sync for PyBytes

impl Unpin for PyBytes

impl UnwindSafe for PyBytes

Blanket Implementations

impl<T> Any for T where
    T: 'static + ?Sized
[src]

impl<T> Borrow<T> for T where
    T: ?Sized
[src]

impl<T> BorrowMut<T> for T where
    T: ?Sized
[src]

impl<T> From<T> for T[src]

impl<'p, T> FromPyPointer<'p> for T where
    T: 'p + PyNativeType
[src]

impl<T, U> Into<U> for T where
    U: From<T>, 
[src]

impl<'v, T> PyTryFrom<'v> for T where
    T: PyTypeInfo + PyNativeType
[src]

impl<T> PyTypeObject for T where
    T: PyTypeInfo
[src]

impl<T> ToBorrowedObject for T where
    T: ToPyObject
[src]

impl<T> ToString for T where
    T: Display + ?Sized
[src]

impl<T, U> TryFrom<U> for T where
    U: Into<T>, 
[src]

type Error = Infallible

The type returned in the event of a conversion error.

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, 
[src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.