Struct pyo3::Py

#[repr(transparent)]
pub struct Py<T>(_, _);

A GIL-independent reference to an object allocated on the Python heap.

This type does not auto-dereference to the inner object because you must prove you hold the GIL to access it. Instead, call one of its methods to access the inner object:

• Py::as_ref, to borrow a GIL-bound reference to the contained object.
• Py::borrow, Py::try_borrow, Py::borrow_mut, or Py::try_borrow_mut, to get a (mutable) reference to a contained pyclass, using a scheme similar to std’s RefCell. See the PyCell guide entry for more information.
• You can call methods directly on Py with Py::call, Py::call_method and friends. These require passing in the Python<'py> token but are otherwise similar to the corresponding methods on PyAny.

Example: Storing Python objects in structs

As all the native Python objects only appear as references, storing them in structs doesn’t work well. For example, this won’t compile:

#[pyclass]
struct Foo<'py> {
    inner: &'py PyDict,
}

impl Foo {
    fn new() -> Foo {
        let foo = Python::with_gil(|py| {
            // `py` will only last for this scope.

            // `&PyDict` derives its lifetime from `py` and
            // so won't be able to outlive this closure.
            let dict: &PyDict = PyDict::new(py);

            // because `Foo` contains `dict` its lifetime
            // is now also tied to `py`.
            Foo { inner: dict }
        });
        // Foo is no longer valid.
        // Returning it from this function is a 💥 compiler error 💥
        foo
    }
}

Py<T> can be used to get around this by converting dict into a GIL-independent reference:

use pyo3::prelude::*;
use pyo3::types::PyDict;

#[pyclass]
struct Foo {
    inner: Py<PyDict>,
}

#[pymethods]
impl Foo {
    #[new]
    fn __new__() -> Foo {
        Python::with_gil(|py| {
            let dict: Py<PyDict> = PyDict::new(py).into();
            Foo { inner: dict }
        })
    }
}

This can also be done with other pyclasses:

use pyo3::prelude::*;

#[pyclass]
struct Bar {/* ... */}

#[pyclass]
struct Foo {
    inner: Py<Bar>,
}

#[pymethods]
impl Foo {
    #[new]
    fn __new__() -> PyResult<Foo> {
        Python::with_gil(|py| {
            let bar: Py<Bar> = Py::new(py, Bar {})?;
            Ok(Foo { inner: bar })
        })
    }
}

Example: Shared ownership of Python objects

Py<T> can be used to share ownership of a Python object, similar to std’s Rc<T>. As with Rc<T>, cloning it increases its reference count rather than duplicating the underlying object.

This can be done using either Py::clone_ref or Py<T>’s Clone trait implementation. Py::clone_ref will be faster if you happen to be already holding the GIL.

use pyo3::prelude::*;
use pyo3::types::PyDict;

Python::with_gil(|py| {
    let first: Py<PyDict> = PyDict::new(py).into();

    // All of these are valid syntax
    let second = Py::clone_ref(&first, py);
    let third = first.clone_ref(py);
    let fourth = Py::clone(&first);
    let fifth = first.clone();

    // Disposing of our original `Py<PyDict>` just decrements the reference count.
    drop(first);

    // They all point to the same object
    assert!(second.is(&third));
    assert!(fourth.is(&fifth));
    assert!(second.is(&fourth));
});

Preventing reference cycles

It is easy to accidentally create reference cycles using Py<T>. The Python interpreter can break these reference cycles within pyclasses if they integrate with the garbage collector. If your pyclass contains other Python objects you should implement it to avoid leaking memory.

A note on Python reference counts

Dropping a Py<T> will eventually decrease Python’s reference count of the pointed-to variable, allowing Python’s garbage collector to free the associated memory, but this may not happen immediately. This is because a Py<T> can be dropped at any time, but the Python reference count can only be modified when the GIL is held.

If a Py<T> is dropped while its thread happens to be holding the GIL then the Python reference count will be decreased immediately. Otherwise, the reference count will be decreased the next time the GIL is reacquired.

A note on Send and Sync

Accessing this object is threadsafe, since any access to its API requires a Python<'py> token. As you can only get this by acquiring the GIL, Py<...> “implements Send and Sync.

Implementations

impl<T> Py<T>where T: PyClass,

pub fn new( py: Python<'_>, value: impl Into<PyClassInitializer<T>> ) -> PyResult<Py<T>>

Creates a new instance Py<T> of a #[pyclass] on the Python heap.

Examples

use pyo3::prelude::*;

#[pyclass]
struct Foo {/* fields omitted */}

Python::with_gil(|py| -> PyResult<Py<Foo>> {
    let foo: Py<Foo> = Py::new(py, Foo {})?;
    Ok(foo)
})?;

impl<T> Py<T>where T: PyTypeInfo,

pub fn as_ref<'py>(&'py self, _py: Python<'py>) -> &'py T::AsRefTarget

Borrows a GIL-bound reference to the contained T.

By binding to the GIL lifetime, this allows the GIL-bound reference to not require Python<'py> for any of its methods, which makes calling methods on it more ergonomic.

For native types, this reference is &T. For pyclasses, this is &PyCell<T>.

Note that the lifetime of the returned reference is the shortest of &self and Python<'py>. Consider using Py::into_ref instead if this poses a problem.

Examples

Get access to &PyList from Py<PyList>:

Python::with_gil(|py| {
    let list: Py<PyList> = PyList::empty(py).into();
    let list: &PyList = list.as_ref(py);
    assert_eq!(list.len(), 0);
});

Get access to &PyCell<MyClass> from Py<MyClass>:

#[pyclass]
struct MyClass {}

Python::with_gil(|py| {
    let my_class: Py<MyClass> = Py::new(py, MyClass {}).unwrap();
    let my_class_cell: &PyCell<MyClass> = my_class.as_ref(py);
    assert!(my_class_cell.try_borrow().is_ok());
});

pub fn into_ref(self, py: Python<'_>) -> &T::AsRefTarget

Borrows a GIL-bound reference to the contained T independently of the lifetime of T.

This method is similar to as_ref but consumes self and registers the Python object reference in PyO3’s object storage. The reference count for the Python object will not be decreased until the GIL lifetime ends.

You should prefer using as_ref if you can as it’ll have less overhead.

Examples

Py::as_ref’s lifetime limitation forbids creating a function that references a variable created inside the function.

fn new_py_any<'py>(py: Python<'py>, value: impl IntoPy<Py<PyAny>>) -> &'py PyAny {
    let obj: Py<PyAny> = value.into_py(py);

    // The lifetime of the return value of this function is the shortest
    // of `obj` and `py`. As `obj` is owned by the current function,
    // Rust won't let the return value escape this function!
    obj.as_ref(py)
}

This can be solved by using Py::into_ref instead, which does not suffer from this issue. Note that the lifetime of the Python<'py> token is transferred to the returned reference.

fn new_py_any<'py>(py: Python<'py>, value: impl IntoPy<Py<PyAny>>) -> &'py PyAny {
    let obj: Py<PyAny> = value.into_py(py);

    // This reference's lifetime is determined by `py`'s lifetime.
    // Because that originates from outside this function,
    // this return value is allowed.
    obj.into_ref(py)
}

impl<T> Py<T>where T: PyClass,

pub fn borrow<'py>(&'py self, py: Python<'py>) -> PyRef<'py, T>

Immutably borrows the value T.

This borrow lasts while the returned PyRef exists. Multiple immutable borrows can be taken out at the same time.

For frozen classes, the simpler get is available.

Equivalent to self.as_ref(py).borrow() - see PyCell::borrow.

Examples

#[pyclass]
struct Foo {
    inner: u8,
}

Python::with_gil(|py| -> PyResult<()> {
    let foo: Py<Foo> = Py::new(py, Foo { inner: 73 })?;
    let inner: &u8 = &foo.borrow(py).inner;

    assert_eq!(*inner, 73);
    Ok(())
})?;

Panics

Panics if the value is currently mutably borrowed. For a non-panicking variant, use try_borrow.

pub fn borrow_mut<'py>(&'py self, py: Python<'py>) -> PyRefMut<'py, T>where T: PyClass<Frozen = False>,

Mutably borrows the value T.

This borrow lasts while the returned PyRefMut exists.

Equivalent to self.as_ref(py).borrow_mut() - see PyCell::borrow_mut.

Examples

#[pyclass]
struct Foo {
    inner: u8,
}

Python::with_gil(|py| -> PyResult<()> {
    let foo: Py<Foo> = Py::new(py, Foo { inner: 73 })?;
    foo.borrow_mut(py).inner = 35;

    assert_eq!(foo.borrow(py).inner, 35);
    Ok(())
})?;

Panics

Panics if the value is currently borrowed. For a non-panicking variant, use try_borrow_mut.

pub fn try_borrow<'py>( &'py self, py: Python<'py> ) -> Result<PyRef<'py, T>, PyBorrowError>

Attempts to immutably borrow the value T, returning an error if the value is currently mutably borrowed.

The borrow lasts while the returned PyRef exists.

This is the non-panicking variant of borrow.

For frozen classes, the simpler get is available.

Equivalent to self.as_ref(py).borrow_mut() - see PyCell::try_borrow.

pub fn try_borrow_mut<'py>( &'py self, py: Python<'py> ) -> Result<PyRefMut<'py, T>, PyBorrowMutError>where T: PyClass<Frozen = False>,

Attempts to mutably borrow the value T, returning an error if the value is currently borrowed.

The borrow lasts while the returned PyRefMut exists.

This is the non-panicking variant of borrow_mut.

Equivalent to self.as_ref(py).try_borrow_mut() - see PyCell::try_borrow_mut.

pub fn get(&self) -> &Twhere T: PyClass<Frozen = True> + Sync,

Provide an immutable borrow of the value T without acquiring the GIL.

This is available if the class is frozen and Sync.

Examples

use std::sync::atomic::{AtomicUsize, Ordering};

#[pyclass(frozen)]
struct FrozenCounter {
    value: AtomicUsize,
}

let cell  = Python::with_gil(|py| {
    let counter = FrozenCounter { value: AtomicUsize::new(0) };

    Py::new(py, counter).unwrap()
});

cell.get().value.fetch_add(1, Ordering::Relaxed);

impl<T> Py<T>

pub fn is<U: AsPyPointer>(&self, o: &U) -> 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.

pub fn get_refcnt(&self, _py: Python<'_>) -> isize

Gets the reference count of the ffi::PyObject pointer.

pub fn clone_ref(&self, py: Python<'_>) -> Py<T>

Makes a clone of self.

This creates another pointer to the same object, increasing its reference count.

You should prefer using this method over Clone if you happen to be holding the GIL already.

Examples

use pyo3::prelude::*;
use pyo3::types::PyDict;

Python::with_gil(|py| {
    let first: Py<PyDict> = PyDict::new(py).into();
    let second = Py::clone_ref(&first, py);

    // Both point to the same object
    assert!(first.is(&second));
});

pub fn is_none(&self, _py: Python<'_>) -> bool

Returns whether the object is considered to be None.

This is equivalent to the Python expression self is None.

pub fn is_ellipsis(&self) -> bool

Returns whether the object is Ellipsis, e.g. ....

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

pub fn is_true(&self, py: Python<'_>) -> PyResult<bool>

Returns whether the object is considered to be true.

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

pub fn extract<'p, D>(&'p self, py: Python<'p>) -> PyResult<D>where D: FromPyObject<'p>,

Extracts some type from the Python object.

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

pub fn getattr<N>(&self, py: Python<'_>, attr_name: N) -> PyResult<PyObject>where N: IntoPy<Py<PyString>>,

Retrieves an attribute value.

This is equivalent to the Python expression self.attr_name.

If calling this method becomes performance-critical, the intern! macro can be used to intern attr_name, thereby avoiding repeated temporary allocations of Python strings.

Example: intern!ing the attribute name

#[pyfunction]
fn version(sys: Py<PyModule>, py: Python<'_>) -> PyResult<PyObject> {
    sys.getattr(py, intern!(py, "version"))
}

pub fn setattr<N, V>( &self, py: Python<'_>, attr_name: N, value: V ) -> PyResult<()>where N: IntoPy<Py<PyString>>, V: IntoPy<Py<PyAny>>,

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

Example: intern!ing the attribute name

#[pyfunction]
fn set_answer(ob: PyObject, py: Python<'_>) -> PyResult<()> {
    ob.setattr(py, intern!(py, "answer"), 42)
}

pub fn call( &self, py: Python<'_>, args: impl IntoPy<Py<PyTuple>>, kwargs: Option<&PyDict> ) -> PyResult<PyObject>

Calls the object.

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

pub fn call1( &self, py: Python<'_>, args: impl IntoPy<Py<PyTuple>> ) -> PyResult<PyObject>

Calls the object with only positional arguments.

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

pub fn call0(&self, py: Python<'_>) -> PyResult<PyObject>

Calls the object without arguments.

This is equivalent to the Python expression self().

pub fn call_method<N, A>( &self, py: Python<'_>, name: N, args: A, kwargs: Option<&PyDict> ) -> PyResult<PyObject>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.

pub fn call_method1<N, A>( &self, py: Python<'_>, name: N, args: A ) -> PyResult<PyObject>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.

pub fn call_method0<N>(&self, py: Python<'_>, name: N) -> PyResult<PyObject>where N: IntoPy<Py<PyString>>,

Calls a method on the object with no 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.

pub unsafe fn from_owned_ptr(py: Python<'_>, ptr: *mut PyObject) -> Py<T>

Create a Py<T> instance by taking ownership of the given FFI pointer.

Safety

ptr must be a pointer to a Python object of type T.

Callers must own the object referred to by ptr, as this function implicitly takes ownership of that object.

Panics

Panics if ptr is null.

pub unsafe fn from_owned_ptr_or_err( py: Python<'_>, ptr: *mut PyObject ) -> PyResult<Py<T>>

Create a Py<T> instance by taking ownership of the given FFI pointer.

If ptr is null then the current Python exception is fetched as a PyErr.

Safety

If non-null, ptr must be a pointer to a Python object of type T.

pub unsafe fn from_owned_ptr_or_opt( _py: Python<'_>, ptr: *mut PyObject ) -> Option<Self>

Create a Py<T> instance by taking ownership of the given FFI pointer.

If ptr is null then None is returned.

Safety

If non-null, ptr must be a pointer to a Python object of type T.

pub unsafe fn from_borrowed_ptr(py: Python<'_>, ptr: *mut PyObject) -> Py<T>

Create a Py<T> instance by creating a new reference from the given FFI pointer.

Safety

ptr must be a pointer to a Python object of type T.

Panics

Panics if ptr is null.

pub unsafe fn from_borrowed_ptr_or_err( py: Python<'_>, ptr: *mut PyObject ) -> PyResult<Self>

Create a Py<T> instance by creating a new reference from the given FFI pointer.

If ptr is null then the current Python exception is fetched as a PyErr.

Safety

ptr must be a pointer to a Python object of type T.

pub unsafe fn from_borrowed_ptr_or_opt( _py: Python<'_>, ptr: *mut PyObject ) -> Option<Self>

Create a Py<T> instance by creating a new reference from the given FFI pointer.

If ptr is null then None is returned.

Safety

ptr must be a pointer to a Python object of type T.

impl Py<PyAny>

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

Downcast this PyObject to a concrete Python type or pyclass.

Note that you can often avoid downcasting yourself by just specifying the desired type in function or method signatures. However, manual downcasting is sometimes necessary.

For extracting a Rust-only type, see Py::extract.

Example: Downcasting to a specific Python object

use pyo3::prelude::*;
use pyo3::types::{PyDict, PyList};

Python::with_gil(|py| {
    let any: PyObject = PyDict::new(py).into();

    assert!(any.downcast::<PyDict>(py).is_ok());
    assert!(any.downcast::<PyList>(py).is_err());
});

Example: Getting a reference to a pyclass

This is useful if you want to mutate a PyObject that might actually be a pyclass.

use pyo3::prelude::*;

#[pyclass]
struct Class {
    i: i32,
}

Python::with_gil(|py| {
    let class: PyObject = Py::new(py, Class { i: 0 }).unwrap().into_py(py);

    let class_cell: &PyCell<Class> = class.downcast(py)?;

    class_cell.borrow_mut().i += 1;

    // Alternatively you can get a `PyRefMut` directly
    let class_ref: PyRefMut<'_, Class> = class.extract(py)?;
    assert_eq!(class_ref.i, 1);
    Ok(())
})

pub unsafe fn downcast_unchecked<'p, T>(&'p self, py: Python<'p>) -> &Twhere T: PyTryFrom<'p>,

Casts the PyObject to a concrete Python object type without checking validity.

Safety

Callers must ensure that the type is valid or risk type confusion.

pub fn cast_as<'p, D>( &'p self, py: Python<'p> ) -> Result<&'p D, PyDowncastError<'_>>where D: PyTryFrom<'p>,

👎Deprecated since 0.18.0: use downcast() instead

Casts the PyObject to a concrete Python object type.

impl Py<PyBytes>

pub fn as_bytes<'a>(&'a self, _py: Python<'_>) -> &'a [u8]

Gets the Python bytes as a byte slice. Because Python bytes are immutable, the result may be used for as long as the reference to self is held, including when the GIL is released.

impl Py<PyIterator>

pub fn as_ref<'py>(&'py self, _py: Python<'py>) -> &'py PyIterator

Borrows a GIL-bound reference to the PyIterator. By binding to the GIL lifetime, this allows the GIL-bound reference to not require Python for any of its methods.

pub fn into_ref(self, py: Python<'_>) -> &PyIterator

Similar to as_ref, and also consumes this Py and registers the Python object reference in PyO3’s object storage. The reference count for the Python object will not be decreased until the GIL lifetime ends.

impl Py<PyMapping>

pub fn as_ref<'py>(&'py self, _py: Python<'py>) -> &'py PyMapping

Borrows a GIL-bound reference to the PyMapping. By binding to the GIL lifetime, this allows the GIL-bound reference to not require Python for any of its methods.

pub fn into_ref(self, py: Python<'_>) -> &PyMapping

Similar to as_ref, and also consumes this Py and registers the Python object reference in PyO3’s object storage. The reference count for the Python object will not be decreased until the GIL lifetime ends.

impl Py<PySequence>

pub fn as_ref<'py>(&'py self, _py: Python<'py>) -> &'py PySequence

Borrows a GIL-bound reference to the PySequence. By binding to the GIL lifetime, this allows the GIL-bound reference to not require Python for any of its methods.

let seq: Py<PySequence> = PyList::empty(py).as_sequence().into();
let seq: &PySequence = seq.as_ref(py);
assert_eq!(seq.len().unwrap(), 0);

pub fn into_ref(self, py: Python<'_>) -> &PySequence

Similar to as_ref, and also consumes this Py and registers the Python object reference in PyO3’s object storage. The reference count for the Python object will not be decreased until the GIL lifetime ends.

Trait Implementations

impl<T> AsPyPointer for Py<T>

fn as_ptr(&self) -> *mut PyObject

Gets the underlying FFI pointer, returns a borrowed pointer.

impl<T> Clone for Py<T>

If the GIL is held this increments self’s reference count. Otherwise this registers the Py<T> instance to have its reference count incremented the next time PyO3 acquires the GIL.

fn clone(&self) -> Self

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T> Debug for Py<T>

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

Formats the value using the given formatter.

impl<'de, T> Deserialize<'de> for Py<T>where T: PyClass<BaseType = PyAny> + Deserialize<'de>,

Available on crate feature serde only.

fn deserialize<D>(deserializer: D) -> Result<Py<T>, D::Error>where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T> Display for Py<T>where T: PyTypeInfo, T::AsRefTarget: Display,

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

Formats the value using the given formatter.

impl<T> Drop for Py<T>

Dropping a Py instance decrements the reference count on the object by 1.

fn drop(&mut self)

Executes the destructor for this type.

impl<T> Error for Py<T>where T: Error + PyTypeInfo, T::AsRefTarget: Display,

Py<T> can be used as an error when T is an Error.

However for GIL lifetime reasons, cause() cannot be implemented for Py<T>. Use .as_ref() to get the GIL-scoped error if you need to inspect the cause.

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

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, demand: &mut Demand<'a>)

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

Provides type based access to context intended for error reports.

impl From<&CancelledError> for Py<CancelledError>

fn from(other: &CancelledError) -> Self

Converts to this type from the input type.

impl From<&IncompleteReadError> for Py<IncompleteReadError>

fn from(other: &IncompleteReadError) -> Self

Converts to this type from the input type.

impl From<&InvalidStateError> for Py<InvalidStateError>

fn from(other: &InvalidStateError) -> Self

Converts to this type from the input type.

impl From<&LimitOverrunError> for Py<LimitOverrunError>

fn from(other: &LimitOverrunError) -> Self

Converts to this type from the input type.

impl From<&PanicException> for Py<PanicException>

fn from(other: &PanicException) -> Self

Converts to this type from the input type.

impl From<&PyArithmeticError> for Py<PyArithmeticError>

fn from(other: &PyArithmeticError) -> Self

Converts to this type from the input type.

impl From<&PyAssertionError> for Py<PyAssertionError>

fn from(other: &PyAssertionError) -> Self

Converts to this type from the input type.

impl From<&PyAttributeError> for Py<PyAttributeError>

fn from(other: &PyAttributeError) -> Self

Converts to this type from the input type.

impl From<&PyBaseException> for Py<PyBaseException>

fn from(other: &PyBaseException) -> Self

Converts to this type from the input type.

impl From<&PyBlockingIOError> for Py<PyBlockingIOError>

fn from(other: &PyBlockingIOError) -> Self

Converts to this type from the input type.

impl From<&PyBool> for Py<PyBool>

fn from(other: &PyBool) -> Self

Converts to this type from the input type.

impl From<&PyBrokenPipeError> for Py<PyBrokenPipeError>

fn from(other: &PyBrokenPipeError) -> Self

Converts to this type from the input type.

impl From<&PyBufferError> for Py<PyBufferError>

fn from(other: &PyBufferError) -> Self

Converts to this type from the input type.

impl From<&PyByteArray> for Py<PyByteArray>

fn from(other: &PyByteArray) -> Self

Converts to this type from the input type.

impl From<&PyBytes> for Py<PyBytes>

fn from(other: &PyBytes) -> Self

Converts to this type from the input type.

impl From<&PyBytesWarning> for Py<PyBytesWarning>

fn from(other: &PyBytesWarning) -> Self

Converts to this type from the input type.

impl From<&PyCFunction> for Py<PyCFunction>

fn from(other: &PyCFunction) -> Self

Converts to this type from the input type.

impl From<&PyCapsule> for Py<PyCapsule>

fn from(other: &PyCapsule) -> Self

Converts to this type from the input type.

impl<T> From<&PyCell<T>> for Py<T>where T: PyClass,

fn from(cell: &PyCell<T>) -> Self

Converts to this type from the input type.

impl From<&PyChildProcessError> for Py<PyChildProcessError>

fn from(other: &PyChildProcessError) -> Self

Converts to this type from the input type.

impl From<&PyCode> for Py<PyCode>

Available on non-Py_LIMITED_API only.

fn from(other: &PyCode) -> Self

Converts to this type from the input type.

impl From<&PyComplex> for Py<PyComplex>

fn from(other: &PyComplex) -> Self

Converts to this type from the input type.

impl From<&PyConnectionAbortedError> for Py<PyConnectionAbortedError>

fn from(other: &PyConnectionAbortedError) -> Self

Converts to this type from the input type.

impl From<&PyConnectionError> for Py<PyConnectionError>

fn from(other: &PyConnectionError) -> Self

Converts to this type from the input type.

impl From<&PyConnectionRefusedError> for Py<PyConnectionRefusedError>

fn from(other: &PyConnectionRefusedError) -> Self

Converts to this type from the input type.

impl From<&PyConnectionResetError> for Py<PyConnectionResetError>

fn from(other: &PyConnectionResetError) -> Self

Converts to this type from the input type.

impl From<&PyDate> for Py<PyDate>

Available on non-Py_LIMITED_API only.

fn from(other: &PyDate) -> Self

Converts to this type from the input type.

impl From<&PyDateTime> for Py<PyDateTime>

Available on non-Py_LIMITED_API only.

fn from(other: &PyDateTime) -> Self

Converts to this type from the input type.

impl From<&PyDelta> for Py<PyDelta>

Available on non-Py_LIMITED_API only.

fn from(other: &PyDelta) -> Self

Converts to this type from the input type.

impl From<&PyDeprecationWarning> for Py<PyDeprecationWarning>

fn from(other: &PyDeprecationWarning) -> Self

Converts to this type from the input type.

impl From<&PyDict> for Py<PyDict>

fn from(other: &PyDict) -> Self

Converts to this type from the input type.

impl From<&PyDictItems> for Py<PyDictItems>

fn from(other: &PyDictItems) -> Self

Converts to this type from the input type.

impl From<&PyDictKeys> for Py<PyDictKeys>

fn from(other: &PyDictKeys) -> Self

Converts to this type from the input type.

impl From<&PyDictValues> for Py<PyDictValues>

fn from(other: &PyDictValues) -> Self

Converts to this type from the input type.

impl From<&PyEOFError> for Py<PyEOFError>

fn from(other: &PyEOFError) -> Self

Converts to this type from the input type.

impl From<&PyEncodingWarning> for Py<PyEncodingWarning>

fn from(other: &PyEncodingWarning) -> Self

Converts to this type from the input type.

impl From<&PyEnvironmentError> for Py<PyEnvironmentError>

fn from(other: &PyEnvironmentError) -> Self

Converts to this type from the input type.

impl From<&PyException> for Py<PyException>

fn from(other: &PyException) -> Self

Converts to this type from the input type.

impl From<&PyFileExistsError> for Py<PyFileExistsError>

fn from(other: &PyFileExistsError) -> Self

Converts to this type from the input type.

impl From<&PyFileNotFoundError> for Py<PyFileNotFoundError>

fn from(other: &PyFileNotFoundError) -> Self

Converts to this type from the input type.

impl From<&PyFloat> for Py<PyFloat>

fn from(other: &PyFloat) -> Self

Converts to this type from the input type.

impl From<&PyFloatingPointError> for Py<PyFloatingPointError>

fn from(other: &PyFloatingPointError) -> Self

Converts to this type from the input type.

impl From<&PyFrame> for Py<PyFrame>

Available on non-Py_LIMITED_API and non-PyPy only.

fn from(other: &PyFrame) -> Self

Converts to this type from the input type.

impl From<&PyFrozenSet> for Py<PyFrozenSet>

fn from(other: &PyFrozenSet) -> Self

Converts to this type from the input type.

impl From<&PyFunction> for Py<PyFunction>

fn from(other: &PyFunction) -> Self

Converts to this type from the input type.

impl From<&PyFutureWarning> for Py<PyFutureWarning>

fn from(other: &PyFutureWarning) -> Self

Converts to this type from the input type.

impl From<&PyGeneratorExit> for Py<PyGeneratorExit>

fn from(other: &PyGeneratorExit) -> Self

Converts to this type from the input type.

impl From<&PyIOError> for Py<PyIOError>

fn from(other: &PyIOError) -> Self

Converts to this type from the input type.

impl From<&PyImportError> for Py<PyImportError>

fn from(other: &PyImportError) -> Self

Converts to this type from the input type.

impl From<&PyImportWarning> for Py<PyImportWarning>

fn from(other: &PyImportWarning) -> Self

Converts to this type from the input type.

impl From<&PyIndexError> for Py<PyIndexError>

fn from(other: &PyIndexError) -> Self

Converts to this type from the input type.

impl From<&PyInterruptedError> for Py<PyInterruptedError>

fn from(other: &PyInterruptedError) -> Self

Converts to this type from the input type.

impl From<&PyIsADirectoryError> for Py<PyIsADirectoryError>

fn from(other: &PyIsADirectoryError) -> Self

Converts to this type from the input type.

impl From<&PyIterator> for Py<PyIterator>

fn from(other: &PyIterator) -> Self

Converts to this type from the input type.

impl From<&PyKeyError> for Py<PyKeyError>

fn from(other: &PyKeyError) -> Self

Converts to this type from the input type.

impl From<&PyKeyboardInterrupt> for Py<PyKeyboardInterrupt>

fn from(other: &PyKeyboardInterrupt) -> Self

Converts to this type from the input type.

impl From<&PyList> for Py<PyList>

fn from(other: &PyList) -> Self

Converts to this type from the input type.

impl From<&PyLong> for Py<PyLong>

fn from(other: &PyLong) -> Self

Converts to this type from the input type.

impl From<&PyLookupError> for Py<PyLookupError>

fn from(other: &PyLookupError) -> Self

Converts to this type from the input type.

impl From<&PyMapping> for Py<PyMapping>

fn from(other: &PyMapping) -> Self

Converts to this type from the input type.

impl From<&PyMemoryError> for Py<PyMemoryError>

fn from(other: &PyMemoryError) -> Self

Converts to this type from the input type.

impl From<&PyModule> for Py<PyModule>

fn from(other: &PyModule) -> Self

Converts to this type from the input type.

impl From<&PyModuleNotFoundError> for Py<PyModuleNotFoundError>

fn from(other: &PyModuleNotFoundError) -> Self

Converts to this type from the input type.

impl From<&PyNameError> for Py<PyNameError>

fn from(other: &PyNameError) -> Self

Converts to this type from the input type.

impl From<&PyNotADirectoryError> for Py<PyNotADirectoryError>

fn from(other: &PyNotADirectoryError) -> Self

Converts to this type from the input type.

impl From<&PyNotImplementedError> for Py<PyNotImplementedError>

fn from(other: &PyNotImplementedError) -> Self

Converts to this type from the input type.

impl From<&PyOSError> for Py<PyOSError>

fn from(other: &PyOSError) -> Self

Converts to this type from the input type.

impl From<&PyOverflowError> for Py<PyOverflowError>

fn from(other: &PyOverflowError) -> Self

Converts to this type from the input type.

impl From<&PyPendingDeprecationWarning> for Py<PyPendingDeprecationWarning>

fn from(other: &PyPendingDeprecationWarning) -> Self

Converts to this type from the input type.

impl From<&PyPermissionError> for Py<PyPermissionError>

fn from(other: &PyPermissionError) -> Self

Converts to this type from the input type.

impl From<&PyProcessLookupError> for Py<PyProcessLookupError>

fn from(other: &PyProcessLookupError) -> Self

Converts to this type from the input type.

impl From<&PyRecursionError> for Py<PyRecursionError>

fn from(other: &PyRecursionError) -> Self

Converts to this type from the input type.

impl From<&PyReferenceError> for Py<PyReferenceError>

fn from(other: &PyReferenceError) -> Self

Converts to this type from the input type.

impl From<&PyResourceWarning> for Py<PyResourceWarning>

fn from(other: &PyResourceWarning) -> Self

Converts to this type from the input type.

impl From<&PyRuntimeError> for Py<PyRuntimeError>

fn from(other: &PyRuntimeError) -> Self

Converts to this type from the input type.

impl From<&PyRuntimeWarning> for Py<PyRuntimeWarning>

fn from(other: &PyRuntimeWarning) -> Self

Converts to this type from the input type.

impl From<&PySequence> for Py<PySequence>

fn from(other: &PySequence) -> Self

Converts to this type from the input type.

impl From<&PySet> for Py<PySet>

fn from(other: &PySet) -> Self

Converts to this type from the input type.

impl From<&PySlice> for Py<PySlice>

fn from(other: &PySlice) -> Self

Converts to this type from the input type.

impl From<&PyStopAsyncIteration> for Py<PyStopAsyncIteration>

fn from(other: &PyStopAsyncIteration) -> Self

Converts to this type from the input type.

impl From<&PyStopIteration> for Py<PyStopIteration>

fn from(other: &PyStopIteration) -> Self

Converts to this type from the input type.

impl From<&PyString> for Py<PyString>

fn from(other: &PyString) -> Self

Converts to this type from the input type.

impl From<&PySuper> for Py<PySuper>

Available on non-PyPy only.

fn from(other: &PySuper) -> Self

Converts to this type from the input type.

impl From<&PySyntaxError> for Py<PySyntaxError>

fn from(other: &PySyntaxError) -> Self

Converts to this type from the input type.

impl From<&PySyntaxWarning> for Py<PySyntaxWarning>

fn from(other: &PySyntaxWarning) -> Self

Converts to this type from the input type.

impl From<&PySystemError> for Py<PySystemError>

fn from(other: &PySystemError) -> Self

Converts to this type from the input type.

impl From<&PySystemExit> for Py<PySystemExit>

fn from(other: &PySystemExit) -> Self

Converts to this type from the input type.

impl From<&PyTime> for Py<PyTime>

Available on non-Py_LIMITED_API only.

fn from(other: &PyTime) -> Self

Converts to this type from the input type.

impl From<&PyTimeoutError> for Py<PyTimeoutError>

fn from(other: &PyTimeoutError) -> Self

Converts to this type from the input type.

impl From<&PyTraceback> for Py<PyTraceback>

fn from(other: &PyTraceback) -> Self

Converts to this type from the input type.

impl From<&PyTuple> for Py<PyTuple>

fn from(other: &PyTuple) -> Self

Converts to this type from the input type.

impl From<&PyType> for Py<PyType>

fn from(other: &PyType) -> Self

Converts to this type from the input type.

impl From<&PyTypeError> for Py<PyTypeError>

fn from(other: &PyTypeError) -> Self

Converts to this type from the input type.

impl From<&PyTzInfo> for Py<PyTzInfo>

Available on non-Py_LIMITED_API only.

fn from(other: &PyTzInfo) -> Self

Converts to this type from the input type.

impl From<&PyUnboundLocalError> for Py<PyUnboundLocalError>

fn from(other: &PyUnboundLocalError) -> Self

Converts to this type from the input type.

impl From<&PyUnicodeDecodeError> for Py<PyUnicodeDecodeError>

fn from(other: &PyUnicodeDecodeError) -> Self

Converts to this type from the input type.

impl From<&PyUnicodeEncodeError> for Py<PyUnicodeEncodeError>

fn from(other: &PyUnicodeEncodeError) -> Self

Converts to this type from the input type.

impl From<&PyUnicodeError> for Py<PyUnicodeError>

fn from(other: &PyUnicodeError) -> Self

Converts to this type from the input type.

impl From<&PyUnicodeTranslateError> for Py<PyUnicodeTranslateError>

fn from(other: &PyUnicodeTranslateError) -> Self

Converts to this type from the input type.

impl From<&PyUnicodeWarning> for Py<PyUnicodeWarning>

fn from(other: &PyUnicodeWarning) -> Self

Converts to this type from the input type.

impl From<&PyUserWarning> for Py<PyUserWarning>

fn from(other: &PyUserWarning) -> Self

Converts to this type from the input type.

impl From<&PyValueError> for Py<PyValueError>

fn from(other: &PyValueError) -> Self

Converts to this type from the input type.

impl From<&PyWarning> for Py<PyWarning>

fn from(other: &PyWarning) -> Self

Converts to this type from the input type.

impl From<&PyZeroDivisionError> for Py<PyZeroDivisionError>

fn from(other: &PyZeroDivisionError) -> Self

Converts to this type from the input type.

impl From<&QueueEmpty> for Py<QueueEmpty>

fn from(other: &QueueEmpty) -> Self

Converts to this type from the input type.

impl From<&QueueFull> for Py<QueueFull>

fn from(other: &QueueFull) -> Self

Converts to this type from the input type.

impl From<&TimeoutError> for Py<TimeoutError>

fn from(other: &TimeoutError) -> Self

Converts to this type from the input type.

impl From<&gaierror> for Py<gaierror>

fn from(other: &gaierror) -> Self

Converts to this type from the input type.

impl From<&herror> for Py<herror>

fn from(other: &herror) -> Self

Converts to this type from the input type.

impl From<&timeout> for Py<timeout>

fn from(other: &timeout) -> Self

Converts to this type from the input type.

impl<T: PyClass> From<Py<T>> for PyClassInitializer<T>

fn from(value: Py<T>) -> PyClassInitializer<T>

Converts to this type from the input type.

impl<T> From<Py<T>> for PyObjectwhere T: AsRef<PyAny>,

fn from(other: Py<T>) -> Self

Converts to this type from the input type.

impl<'a, T> From<PyRef<'a, T>> for Py<T>where T: PyClass,

fn from(pyref: PyRef<'a, T>) -> Self

Converts to this type from the input type.

impl<'a, T> From<PyRefMut<'a, T>> for Py<T>where T: PyClass<Frozen = False>,

fn from(pyref: PyRefMut<'a, T>) -> Self

Converts to this type from the input type.

impl<'a, T> FromPyObject<'a> for Py<T>where T: PyTypeInfo, &'a T::AsRefTarget: FromPyObject<'a>, T::AsRefTarget: 'a + AsPyPointer,

fn extract(ob: &'a PyAny) -> PyResult<Self>

Extracts Self from the source PyObject.

impl IntoPy<Py<CancelledError>> for &CancelledError

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

Performs the conversion.

impl IntoPy<Py<IncompleteReadError>> for &IncompleteReadError

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

Performs the conversion.

impl IntoPy<Py<InvalidStateError>> for &InvalidStateError

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

Performs the conversion.

impl IntoPy<Py<LimitOverrunError>> for &LimitOverrunError

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

Performs the conversion.

impl IntoPy<Py<PanicException>> for &PanicException

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

Performs the conversion.

impl<'a> IntoPy<Py<PyAny>> for &'a [u8]

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

Performs the conversion.

impl<'a> IntoPy<Py<PyAny>> for &'a OsString

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

Performs the conversion.

impl<'a> IntoPy<Py<PyAny>> for &'a Path

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

Performs the conversion.

impl<'a> IntoPy<Py<PyAny>> for &'a PathBuf

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

Performs the conversion.

impl<'a> IntoPy<Py<PyAny>> for &'a PyErr

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

Performs the conversion.

impl<'a> IntoPy<Py<PyAny>> for &'a String

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

Performs the conversion.

impl<'a> IntoPy<Py<PyAny>> for &'a str

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

Performs the conversion.

impl IntoPy<Py<PyAny>> for &OsStr

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

Performs the conversion.

impl<T> IntoPy<Py<PyAny>> for &Twhere T: AsPyPointer,

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

Performs the conversion.

impl<T, const N: usize> IntoPy<Py<PyAny>> for [T; N]where T: IntoPy<PyObject>,

Available on min_const_generics only.

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

Performs the conversion.

impl IntoPy<Py<PyAny>> for ()

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

Performs the conversion.

impl<T0: IntoPy<PyObject>> IntoPy<Py<PyAny>> for (T0,)

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

Performs the conversion.

impl<T0: IntoPy<PyObject>, T1: IntoPy<PyObject>> IntoPy<Py<PyAny>> for (T0, T1)

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

Performs the conversion.

impl<T0: IntoPy<PyObject>, T1: IntoPy<PyObject>, T2: IntoPy<PyObject>> IntoPy<Py<PyAny>> for (T0, T1, T2)

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

Performs the conversion.

impl<T0: IntoPy<PyObject>, T1: IntoPy<PyObject>, T2: IntoPy<PyObject>, T3: IntoPy<PyObject>> IntoPy<Py<PyAny>> for (T0, T1, T2, T3)

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

Performs the conversion.

impl<T0: IntoPy<PyObject>, T1: IntoPy<PyObject>, T2: IntoPy<PyObject>, T3: IntoPy<PyObject>, T4: IntoPy<PyObject>> IntoPy<Py<PyAny>> for (T0, T1, T2, T3, T4)

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

Performs the conversion.

impl<T0: IntoPy<PyObject>, T1: IntoPy<PyObject>, T2: IntoPy<PyObject>, T3: IntoPy<PyObject>, T4: IntoPy<PyObject>, T5: IntoPy<PyObject>> IntoPy<Py<PyAny>> for (T0, T1, T2, T3, T4, T5)

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

Performs the conversion.

impl<T0: IntoPy<PyObject>, T1: IntoPy<PyObject>, T2: IntoPy<PyObject>, T3: IntoPy<PyObject>, T4: IntoPy<PyObject>, T5: IntoPy<PyObject>, T6: IntoPy<PyObject>> IntoPy<Py<PyAny>> for (T0, T1, T2, T3, T4, T5, T6)

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

Performs the conversion.

impl<T0: IntoPy<PyObject>, T1: IntoPy<PyObject>, T2: IntoPy<PyObject>, T3: IntoPy<PyObject>, T4: IntoPy<PyObject>, T5: IntoPy<PyObject>, T6: IntoPy<PyObject>, T7: IntoPy<PyObject>> IntoPy<Py<PyAny>> for (T0, T1, T2, T3, T4, T5, T6, T7)

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

Performs the conversion.

impl<T0: IntoPy<PyObject>, T1: IntoPy<PyObject>, T2: IntoPy<PyObject>, T3: IntoPy<PyObject>, T4: IntoPy<PyObject>, T5: IntoPy<PyObject>, T6: IntoPy<PyObject>, T7: IntoPy<PyObject>, T8: IntoPy<PyObject>> IntoPy<Py<PyAny>> for (T0, T1, T2, T3, T4, T5, T6, T7, T8)

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

Performs the conversion.

impl<T0: IntoPy<PyObject>, T1: IntoPy<PyObject>, T2: IntoPy<PyObject>, T3: IntoPy<PyObject>, T4: IntoPy<PyObject>, T5: IntoPy<PyObject>, T6: IntoPy<PyObject>, T7: IntoPy<PyObject>, T8: IntoPy<PyObject>, T9: IntoPy<PyObject>> IntoPy<Py<PyAny>> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)

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

Performs the conversion.

impl<T0: IntoPy<PyObject>, T1: IntoPy<PyObject>, T2: IntoPy<PyObject>, T3: IntoPy<PyObject>, T4: IntoPy<PyObject>, T5: IntoPy<PyObject>, T6: IntoPy<PyObject>, T7: IntoPy<PyObject>, T8: IntoPy<PyObject>, T9: IntoPy<PyObject>, T10: IntoPy<PyObject>> IntoPy<Py<PyAny>> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)

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

Performs the conversion.

impl<T0: IntoPy<PyObject>, T1: IntoPy<PyObject>, T2: IntoPy<PyObject>, T3: IntoPy<PyObject>, T4: IntoPy<PyObject>, T5: IntoPy<PyObject>, T6: IntoPy<PyObject>, T7: IntoPy<PyObject>, T8: IntoPy<PyObject>, T9: IntoPy<PyObject>, T10: IntoPy<PyObject>, T11: IntoPy<PyObject>> IntoPy<Py<PyAny>> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)

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

Performs the conversion.

impl<K, V> IntoPy<Py<PyAny>> for BTreeMap<K, V>where K: Eq + IntoPy<PyObject>, V: IntoPy<PyObject>,

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

Performs the conversion.

impl<K> IntoPy<Py<PyAny>> for BTreeSet<K>where K: IntoPy<PyObject> + Ord,

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

Performs the conversion.

impl IntoPy<Py<PyAny>> for BigInt

Available on crate feature num-bigint only.

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

Performs the conversion.

impl IntoPy<Py<PyAny>> for BigUint

Available on crate feature num-bigint only.

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

Performs the conversion.

impl<T: Copy + IntoPy<PyObject>> IntoPy<Py<PyAny>> for Cell<T>

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

Performs the conversion.

impl IntoPy<Py<PyAny>> for Complex<f32>

Available on crate feature num-complex only.

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

Performs the conversion.

impl IntoPy<Py<PyAny>> for Complex<f64>

Available on crate feature num-complex only.

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

Performs the conversion.

impl IntoPy<Py<PyAny>> for Cow<'_, [u8]>

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

Performs the conversion.

impl IntoPy<Py<PyAny>> for Cow<'_, OsStr>

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

Performs the conversion.

impl IntoPy<Py<PyAny>> for Cow<'_, str>

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

Performs the conversion.

impl<'a> IntoPy<Py<PyAny>> for Cow<'a, Path>

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

Performs the conversion.

impl<Tz: TimeZone> IntoPy<Py<PyAny>> for DateTime<Tz>

Available on crate feature chrono and non-Py_LIMITED_API only.

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

Performs the conversion.

impl IntoPy<Py<PyAny>> for Decimal

Available on crate feature rust_decimal only.

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

Performs the conversion.

impl IntoPy<Py<PyAny>> for Duration

Available on crate feature chrono and non-Py_LIMITED_API only.

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

Performs the conversion.

impl IntoPy<Py<PyAny>> for FixedOffset

Available on crate feature chrono and non-Py_LIMITED_API only.

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

Performs the conversion.

impl<K, V, H> IntoPy<Py<PyAny>> for HashMap<K, V, H>where K: Hash + Eq + IntoPy<PyObject>, V: IntoPy<PyObject>, H: BuildHasher,

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

Performs the conversion.

impl<K, V, H> IntoPy<Py<PyAny>> for HashMap<K, V, H>where K: Hash + Eq + IntoPy<PyObject>, V: IntoPy<PyObject>, H: BuildHasher,

Available on crate feature hashbrown only.

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

Performs the conversion.

impl<K, S> IntoPy<Py<PyAny>> for HashSet<K, S>where K: IntoPy<PyObject> + Eq + Hash, S: BuildHasher + Default,

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

Performs the conversion.

impl<K, S> IntoPy<Py<PyAny>> for HashSet<K, S>where K: IntoPy<PyObject> + Eq + Hash, S: BuildHasher + Default,

Available on crate feature hashbrown only.

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

Performs the conversion.

impl<K, V, H> IntoPy<Py<PyAny>> for IndexMap<K, V, H>where K: Hash + Eq + IntoPy<PyObject>, V: IntoPy<PyObject>, H: BuildHasher,

Available on crate feature indexmap only.

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

Performs the conversion.

impl IntoPy<Py<PyAny>> for IpAddr

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

Performs the conversion.

impl IntoPy<Py<PyAny>> for NaiveDate

Available on crate feature chrono and non-Py_LIMITED_API only.

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

Performs the conversion.

impl IntoPy<Py<PyAny>> for NaiveDateTime

Available on crate feature chrono and non-Py_LIMITED_API only.

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

Performs the conversion.

impl IntoPy<Py<PyAny>> for NaiveTime

Available on crate feature chrono and non-Py_LIMITED_API only.

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

Performs the conversion.

impl IntoPy<Py<PyAny>> for NonZeroI128

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

Performs the conversion.

impl IntoPy<Py<PyAny>> for NonZeroI16

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

Performs the conversion.

impl IntoPy<Py<PyAny>> for NonZeroI32

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

Performs the conversion.

impl IntoPy<Py<PyAny>> for NonZeroI64

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

Performs the conversion.

impl IntoPy<Py<PyAny>> for NonZeroI8

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

Performs the conversion.

impl IntoPy<Py<PyAny>> for NonZeroIsize

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

Performs the conversion.

impl IntoPy<Py<PyAny>> for NonZeroU128

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

Performs the conversion.

impl IntoPy<Py<PyAny>> for NonZeroU16

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

Performs the conversion.

impl IntoPy<Py<PyAny>> for NonZeroU32

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

Performs the conversion.

impl IntoPy<Py<PyAny>> for NonZeroU64

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

Performs the conversion.

impl IntoPy<Py<PyAny>> for NonZeroU8

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

Performs the conversion.

impl IntoPy<Py<PyAny>> for NonZeroUsize

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

Performs the conversion.

impl<T> IntoPy<Py<PyAny>> for Option<T>where T: IntoPy<PyObject>,

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

Performs the conversion.

impl IntoPy<Py<PyAny>> for OsString

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

Performs the conversion.

impl IntoPy<Py<PyAny>> for PathBuf

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

Performs the conversion.

impl<T> IntoPy<Py<PyAny>> for Py<T>

fn into_py(self, _py: Python<'_>) -> PyObject

Converts a Py instance to PyObject. Consumes self without calling Py_DECREF().

impl IntoPy<Py<PyAny>> for PyErr

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

Performs the conversion.

impl<T: PyClass> IntoPy<Py<PyAny>> for PyRef<'_, T>

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

Performs the conversion.

impl<T: PyClass<Frozen = False>> IntoPy<Py<PyAny>> for PyRefMut<'_, T>

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

Performs the conversion.

impl IntoPy<Py<PyAny>> for String

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

Performs the conversion.

impl IntoPy<Py<PyAny>> for Utc

Available on crate feature chrono and non-Py_LIMITED_API only.

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

Performs the conversion.

impl<T> IntoPy<Py<PyAny>> for Vec<T>where T: IntoPy<PyObject>,

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

Performs the conversion.

impl IntoPy<Py<PyAny>> for bool

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

Performs the conversion.

impl IntoPy<Py<PyAny>> for char

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

Performs the conversion.

impl IntoPy<Py<PyAny>> for f32

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

Performs the conversion.

impl IntoPy<Py<PyAny>> for f64

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

Performs the conversion.

impl IntoPy<Py<PyAny>> for i128

Available on non-Py_LIMITED_API only.

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

Performs the conversion.

impl IntoPy<Py<PyAny>> for i16

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

Performs the conversion.

impl IntoPy<Py<PyAny>> for i32

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

Performs the conversion.

impl IntoPy<Py<PyAny>> for i64

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

Performs the conversion.

impl IntoPy<Py<PyAny>> for i8

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

Performs the conversion.

impl IntoPy<Py<PyAny>> for isize

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

Performs the conversion.

impl IntoPy<Py<PyAny>> for u128

Available on non-Py_LIMITED_API only.

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

Performs the conversion.

impl IntoPy<Py<PyAny>> for u16

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

Performs the conversion.

impl IntoPy<Py<PyAny>> for u32

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

Performs the conversion.

impl IntoPy<Py<PyAny>> for u64

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

Performs the conversion.

impl IntoPy<Py<PyAny>> for u8

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

Performs the conversion.

impl IntoPy<Py<PyAny>> for usize

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

Performs the conversion.

impl IntoPy<Py<PyArithmeticError>> for &PyArithmeticError

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

Performs the conversion.

impl IntoPy<Py<PyAssertionError>> for &PyAssertionError

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

Performs the conversion.

impl IntoPy<Py<PyAttributeError>> for &PyAttributeError

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

Performs the conversion.

impl IntoPy<Py<PyBaseException>> for &PyBaseException

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

Performs the conversion.

impl IntoPy<Py<PyBlockingIOError>> for &PyBlockingIOError

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

Performs the conversion.

impl IntoPy<Py<PyBool>> for &PyBool

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

Performs the conversion.

impl IntoPy<Py<PyBrokenPipeError>> for &PyBrokenPipeError

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

Performs the conversion.

impl IntoPy<Py<PyBufferError>> for &PyBufferError

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

Performs the conversion.

impl IntoPy<Py<PyByteArray>> for &PyByteArray

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

Performs the conversion.

impl IntoPy<Py<PyBytes>> for &PyBytes

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

Performs the conversion.

impl IntoPy<Py<PyBytesWarning>> for &PyBytesWarning

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

Performs the conversion.

impl IntoPy<Py<PyCFunction>> for &PyCFunction

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

Performs the conversion.

impl IntoPy<Py<PyCapsule>> for &PyCapsule

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

Performs the conversion.

impl IntoPy<Py<PyChildProcessError>> for &PyChildProcessError

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

Performs the conversion.

impl IntoPy<Py<PyCode>> for &PyCode

Available on non-Py_LIMITED_API only.

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

Performs the conversion.

impl IntoPy<Py<PyComplex>> for &PyComplex

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

Performs the conversion.

impl IntoPy<Py<PyConnectionAbortedError>> for &PyConnectionAbortedError

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

Performs the conversion.

impl IntoPy<Py<PyConnectionError>> for &PyConnectionError

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

Performs the conversion.

impl IntoPy<Py<PyConnectionRefusedError>> for &PyConnectionRefusedError

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

Performs the conversion.

impl IntoPy<Py<PyConnectionResetError>> for &PyConnectionResetError

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

Performs the conversion.

impl IntoPy<Py<PyDate>> for &PyDate

Available on non-Py_LIMITED_API only.

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

Performs the conversion.

impl IntoPy<Py<PyDateTime>> for &PyDateTime

Available on non-Py_LIMITED_API only.

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

Performs the conversion.

impl IntoPy<Py<PyDelta>> for &PyDelta

Available on non-Py_LIMITED_API only.

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

Performs the conversion.

impl IntoPy<Py<PyDeprecationWarning>> for &PyDeprecationWarning

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

Performs the conversion.

impl IntoPy<Py<PyDict>> for &PyDict

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

Performs the conversion.

impl IntoPy<Py<PyDictItems>> for &PyDictItems

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

Performs the conversion.

impl IntoPy<Py<PyDictKeys>> for &PyDictKeys

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

Performs the conversion.

impl IntoPy<Py<PyDictValues>> for &PyDictValues

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

Performs the conversion.

impl IntoPy<Py<PyEOFError>> for &PyEOFError

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

Performs the conversion.

impl IntoPy<Py<PyEncodingWarning>> for &PyEncodingWarning

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

Performs the conversion.

impl IntoPy<Py<PyEnvironmentError>> for &PyEnvironmentError

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

Performs the conversion.

impl IntoPy<Py<PyException>> for &PyException

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

Performs the conversion.

impl IntoPy<Py<PyFileExistsError>> for &PyFileExistsError

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

Performs the conversion.

impl IntoPy<Py<PyFileNotFoundError>> for &PyFileNotFoundError

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

Performs the conversion.

impl IntoPy<Py<PyFloat>> for &PyFloat

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

Performs the conversion.

impl IntoPy<Py<PyFloatingPointError>> for &PyFloatingPointError

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

Performs the conversion.

impl IntoPy<Py<PyFrame>> for &PyFrame

Available on non-Py_LIMITED_API and non-PyPy only.

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

Performs the conversion.

impl IntoPy<Py<PyFrozenSet>> for &PyFrozenSet

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

Performs the conversion.

impl IntoPy<Py<PyFunction>> for &PyFunction

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

Performs the conversion.

impl IntoPy<Py<PyFutureWarning>> for &PyFutureWarning

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

Performs the conversion.

impl IntoPy<Py<PyGeneratorExit>> for &PyGeneratorExit

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

Performs the conversion.

impl IntoPy<Py<PyIOError>> for &PyIOError

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

Performs the conversion.

impl IntoPy<Py<PyImportError>> for &PyImportError

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

Performs the conversion.

impl IntoPy<Py<PyImportWarning>> for &PyImportWarning

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

Performs the conversion.

impl IntoPy<Py<PyIndexError>> for &PyIndexError

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

Performs the conversion.

impl IntoPy<Py<PyInterruptedError>> for &PyInterruptedError

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

Performs the conversion.

impl IntoPy<Py<PyIsADirectoryError>> for &PyIsADirectoryError

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

Performs the conversion.

impl IntoPy<Py<PyIterator>> for &PyIterator

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

Performs the conversion.

impl IntoPy<Py<PyKeyError>> for &PyKeyError

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

Performs the conversion.

impl IntoPy<Py<PyKeyboardInterrupt>> for &PyKeyboardInterrupt

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

Performs the conversion.

impl IntoPy<Py<PyList>> for &PyList

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

Performs the conversion.

impl IntoPy<Py<PyLong>> for &PyLong

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

Performs the conversion.

impl IntoPy<Py<PyLookupError>> for &PyLookupError

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

Performs the conversion.

impl IntoPy<Py<PyMapping>> for &PyMapping

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

Performs the conversion.

impl IntoPy<Py<PyMemoryError>> for &PyMemoryError

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

Performs the conversion.

impl IntoPy<Py<PyModule>> for &PyModule

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

Performs the conversion.

impl IntoPy<Py<PyModuleNotFoundError>> for &PyModuleNotFoundError

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

Performs the conversion.

impl IntoPy<Py<PyNameError>> for &PyNameError

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

Performs the conversion.

impl IntoPy<Py<PyNotADirectoryError>> for &PyNotADirectoryError

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

Performs the conversion.

impl IntoPy<Py<PyNotImplementedError>> for &PyNotImplementedError

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

Performs the conversion.

impl IntoPy<Py<PyOSError>> for &PyOSError

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

Performs the conversion.

impl IntoPy<Py<PyOverflowError>> for &PyOverflowError

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

Performs the conversion.

impl IntoPy<Py<PyPendingDeprecationWarning>> for &PyPendingDeprecationWarning

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

Performs the conversion.

impl IntoPy<Py<PyPermissionError>> for &PyPermissionError

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

Performs the conversion.

impl IntoPy<Py<PyProcessLookupError>> for &PyProcessLookupError

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

Performs the conversion.

impl IntoPy<Py<PyRecursionError>> for &PyRecursionError

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

Performs the conversion.

impl IntoPy<Py<PyReferenceError>> for &PyReferenceError

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

Performs the conversion.

impl IntoPy<Py<PyResourceWarning>> for &PyResourceWarning

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

Performs the conversion.

impl IntoPy<Py<PyRuntimeError>> for &PyRuntimeError

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

Performs the conversion.

impl IntoPy<Py<PyRuntimeWarning>> for &PyRuntimeWarning

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

Performs the conversion.

impl IntoPy<Py<PySequence>> for &PySequence

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

Performs the conversion.

impl IntoPy<Py<PySet>> for &PySet

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

Performs the conversion.

impl IntoPy<Py<PySlice>> for &PySlice

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

Performs the conversion.

impl IntoPy<Py<PyStopAsyncIteration>> for &PyStopAsyncIteration

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

Performs the conversion.

impl IntoPy<Py<PyStopIteration>> for &PyStopIteration

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

Performs the conversion.

impl<'a> IntoPy<Py<PyString>> for &'a str

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

Performs the conversion.

impl IntoPy<Py<PyString>> for &PyString

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

Performs the conversion.

impl IntoPy<Py<PySuper>> for &PySuper

Available on non-PyPy only.

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

Performs the conversion.

impl IntoPy<Py<PySyntaxError>> for &PySyntaxError

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

Performs the conversion.

impl IntoPy<Py<PySyntaxWarning>> for &PySyntaxWarning

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

Performs the conversion.

impl IntoPy<Py<PySystemError>> for &PySystemError

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

Performs the conversion.

impl IntoPy<Py<PySystemExit>> for &PySystemExit

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

Performs the conversion.

impl IntoPy<Py<PyTime>> for &PyTime

Available on non-Py_LIMITED_API only.

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

Performs the conversion.

impl IntoPy<Py<PyTimeoutError>> for &PyTimeoutError

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

Performs the conversion.

impl IntoPy<Py<PyTraceback>> for &PyTraceback

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

Performs the conversion.

impl IntoPy<Py<PyTuple>> for &PyTuple

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

Performs the conversion.

impl IntoPy<Py<PyTuple>> for ()

Converts () to an empty Python tuple.

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

Performs the conversion.

impl<T0: IntoPy<PyObject>> IntoPy<Py<PyTuple>> for (T0,)

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

Performs the conversion.

impl<T0: IntoPy<PyObject>, T1: IntoPy<PyObject>> IntoPy<Py<PyTuple>> for (T0, T1)

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

Performs the conversion.

impl<T0: IntoPy<PyObject>, T1: IntoPy<PyObject>, T2: IntoPy<PyObject>> IntoPy<Py<PyTuple>> for (T0, T1, T2)

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

Performs the conversion.

impl<T0: IntoPy<PyObject>, T1: IntoPy<PyObject>, T2: IntoPy<PyObject>, T3: IntoPy<PyObject>> IntoPy<Py<PyTuple>> for (T0, T1, T2, T3)

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

Performs the conversion.

impl<T0: IntoPy<PyObject>, T1: IntoPy<PyObject>, T2: IntoPy<PyObject>, T3: IntoPy<PyObject>, T4: IntoPy<PyObject>> IntoPy<Py<PyTuple>> for (T0, T1, T2, T3, T4)

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

Performs the conversion.

impl<T0: IntoPy<PyObject>, T1: IntoPy<PyObject>, T2: IntoPy<PyObject>, T3: IntoPy<PyObject>, T4: IntoPy<PyObject>, T5: IntoPy<PyObject>> IntoPy<Py<PyTuple>> for (T0, T1, T2, T3, T4, T5)

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

Performs the conversion.

impl<T0: IntoPy<PyObject>, T1: IntoPy<PyObject>, T2: IntoPy<PyObject>, T3: IntoPy<PyObject>, T4: IntoPy<PyObject>, T5: IntoPy<PyObject>, T6: IntoPy<PyObject>> IntoPy<Py<PyTuple>> for (T0, T1, T2, T3, T4, T5, T6)

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

Performs the conversion.

impl<T0: IntoPy<PyObject>, T1: IntoPy<PyObject>, T2: IntoPy<PyObject>, T3: IntoPy<PyObject>, T4: IntoPy<PyObject>, T5: IntoPy<PyObject>, T6: IntoPy<PyObject>, T7: IntoPy<PyObject>> IntoPy<Py<PyTuple>> for (T0, T1, T2, T3, T4, T5, T6, T7)

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

Performs the conversion.

impl<T0: IntoPy<PyObject>, T1: IntoPy<PyObject>, T2: IntoPy<PyObject>, T3: IntoPy<PyObject>, T4: IntoPy<PyObject>, T5: IntoPy<PyObject>, T6: IntoPy<PyObject>, T7: IntoPy<PyObject>, T8: IntoPy<PyObject>> IntoPy<Py<PyTuple>> for (T0, T1, T2, T3, T4, T5, T6, T7, T8)

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

Performs the conversion.

impl<T0: IntoPy<PyObject>, T1: IntoPy<PyObject>, T2: IntoPy<PyObject>, T3: IntoPy<PyObject>, T4: IntoPy<PyObject>, T5: IntoPy<PyObject>, T6: IntoPy<PyObject>, T7: IntoPy<PyObject>, T8: IntoPy<PyObject>, T9: IntoPy<PyObject>> IntoPy<Py<PyTuple>> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)

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

Performs the conversion.

impl<T0: IntoPy<PyObject>, T1: IntoPy<PyObject>, T2: IntoPy<PyObject>, T3: IntoPy<PyObject>, T4: IntoPy<PyObject>, T5: IntoPy<PyObject>, T6: IntoPy<PyObject>, T7: IntoPy<PyObject>, T8: IntoPy<PyObject>, T9: IntoPy<PyObject>, T10: IntoPy<PyObject>> IntoPy<Py<PyTuple>> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)

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

Performs the conversion.

impl<T0: IntoPy<PyObject>, T1: IntoPy<PyObject>, T2: IntoPy<PyObject>, T3: IntoPy<PyObject>, T4: IntoPy<PyObject>, T5: IntoPy<PyObject>, T6: IntoPy<PyObject>, T7: IntoPy<PyObject>, T8: IntoPy<PyObject>, T9: IntoPy<PyObject>, T10: IntoPy<PyObject>, T11: IntoPy<PyObject>> IntoPy<Py<PyTuple>> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)

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

Performs the conversion.

impl IntoPy<Py<PyType>> for &PyType

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

Performs the conversion.

impl IntoPy<Py<PyTypeError>> for &PyTypeError

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

Performs the conversion.

impl IntoPy<Py<PyTzInfo>> for &PyTzInfo

Available on non-Py_LIMITED_API only.

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

Performs the conversion.

impl IntoPy<Py<PyUnboundLocalError>> for &PyUnboundLocalError

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

Performs the conversion.

impl IntoPy<Py<PyUnicodeDecodeError>> for &PyUnicodeDecodeError

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

Performs the conversion.

impl IntoPy<Py<PyUnicodeEncodeError>> for &PyUnicodeEncodeError

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

Performs the conversion.

impl IntoPy<Py<PyUnicodeError>> for &PyUnicodeError

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

Performs the conversion.

impl IntoPy<Py<PyUnicodeTranslateError>> for &PyUnicodeTranslateError

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

Performs the conversion.

impl IntoPy<Py<PyUnicodeWarning>> for &PyUnicodeWarning

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

Performs the conversion.

impl IntoPy<Py<PyUserWarning>> for &PyUserWarning

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

Performs the conversion.

impl IntoPy<Py<PyValueError>> for &PyValueError

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

Performs the conversion.

impl IntoPy<Py<PyWarning>> for &PyWarning

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

Performs the conversion.

impl IntoPy<Py<PyZeroDivisionError>> for &PyZeroDivisionError

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

Performs the conversion.

impl IntoPy<Py<QueueEmpty>> for &QueueEmpty

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

Performs the conversion.

impl IntoPy<Py<QueueFull>> for &QueueFull

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

Performs the conversion.

impl IntoPy<Py<TimeoutError>> for &TimeoutError

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

Performs the conversion.

impl IntoPy<Py<gaierror>> for &gaierror

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

Performs the conversion.

impl IntoPy<Py<herror>> for &herror

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

Performs the conversion.

impl IntoPy<Py<timeout>> for &timeout

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

Performs the conversion.

impl<T> IntoPyPointer for Py<T>

fn into_ptr(self) -> *mut PyObject

Gets the underlying FFI pointer, returns a owned pointer.

impl<T> Serialize for Py<T>where T: Serialize + PyClass,

Available on crate feature serde only.

fn serialize<S>( &self, serializer: S ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where S: Serializer,

Serialize this value into the given Serde serializer.

impl<T> ToPyObject for Py<T>

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

Converts Py instance -> PyObject.

impl<T> Send for Py<T>

impl<T> Sync for Py<T>