Trait IntoPyObject 

pub trait IntoPyObject<'py>: Sized {
    type Target;
    type Output: BoundObject<'py, Self::Target>;
    type Error: Into<PyErr>;

    const OUTPUT_TYPE: TypeHint = _;

    // Required method
    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>;

    // Provided method
    fn type_output() -> TypeInfo { ... }
}

Defines a conversion from a Rust type to a Python object, which may fail.

This trait has #[derive(IntoPyObject)] to automatically implement it for simple types and #[derive(IntoPyObjectRef)] to implement the same for references.

It functions similarly to std’s TryInto trait, but requires a Python<'py> token as an argument.

The into_pyobject method is designed for maximum flexibility and efficiency; it

• allows for a concrete Python type to be returned (the Target associated type)
• allows for the smart pointer containing the Python object to be either Bound<'py, Self::Target> or Borrowed<'a, 'py, Self::Target> to avoid unnecessary reference counting overhead
• allows for a custom error type to be returned in the event of a conversion error to avoid unnecessarily creating a Python exception

See also

• The IntoPyObjectExt trait, which provides convenience methods for common usages of IntoPyObject which erase type information and convert errors to PyErr.

Provided Associated Constants

const OUTPUT_TYPE: TypeHint = _

Extracts the type hint information for this type when it appears as a return value.

For example, Vec<u32> would return List[int]. The default implementation returns Any, which is correct for any type.

For most types, the return value for this method will be identical to that of FromPyObject::INPUT_TYPE. It may be different for some types, such as Dict, to allow duck-typing: functions return Dict but take Mapping as argument.

Required Associated Types

type Target

The Python output type

type Output: BoundObject<'py, Self::Target>

The smart pointer type to use.

This will usually be Bound<'py, Target>, but in special cases Borrowed<'a, 'py, Target> can be used to minimize reference counting overhead.

type Error: Into<PyErr>

The type returned in the event of a conversion error.

Required Methods

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

Performs the conversion.

Provided Methods

fn type_output() -> TypeInfo

Extracts the type hint information for this type when it appears as a return value.

For example, Vec<u32> would return List[int]. The default implementation returns Any, which is correct for any type.

For most types, the return value for this method will be identical to that of FromPyObject::type_input. It may be different for some types, such as Dict, to allow duck-typing: functions return Dict but take Mapping as argument.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementations on Foreign Types

impl<'a, 'py, A> IntoPyObject<'py> for &'a SmallVec<A>

where A: Array, &'a A::Item: IntoPyObject<'py>,

type Target = PyAny

type Output = Bound<'py, <&'a SmallVec<A> as IntoPyObject<'py>>::Target>

type Error = PyErr

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

fn type_output() -> TypeInfo

impl<'a, 'py, K> IntoPyObject<'py> for &'a BTreeSet<K>

where &'a K: IntoPyObject<'py> + Ord, K: 'a,

const OUTPUT_TYPE: TypeHint

type Target = PySet

type Output = Bound<'py, <&'a BTreeSet<K> as IntoPyObject<'py>>::Target>

type Error = PyErr

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

fn type_output() -> TypeInfo

impl<'a, 'py, K, H> IntoPyObject<'py> for &'a HashSet<K, H>

where &'a K: IntoPyObject<'py> + Eq + Hash, H: BuildHasher,

const OUTPUT_TYPE: TypeHint

type Target = PySet

type Output = Bound<'py, <&'a HashSet<K, H> as IntoPyObject<'py>>::Target>

type Error = PyErr

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

fn type_output() -> TypeInfo

impl<'a, 'py, K, H> IntoPyObject<'py> for &'a HashSet<K, H>

where &'a K: IntoPyObject<'py> + Eq + Hash, H: BuildHasher,

type Target = PySet

type Output = Bound<'py, <&'a HashSet<K, H> as IntoPyObject<'py>>::Target>

type Error = PyErr

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

impl<'a, 'py, K, V> IntoPyObject<'py> for &'a BTreeMap<K, V>

where &'a K: IntoPyObject<'py> + Eq, &'a V: IntoPyObject<'py>, K: 'a, V: 'a,

const OUTPUT_TYPE: TypeHint

type Target = PyDict

type Output = Bound<'py, <&'a BTreeMap<K, V> as IntoPyObject<'py>>::Target>

type Error = PyErr

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

fn type_output() -> TypeInfo

impl<'a, 'py, K, V, H> IntoPyObject<'py> for &'a HashMap<K, V, H>

where &'a K: IntoPyObject<'py> + Eq + Hash, &'a V: IntoPyObject<'py>, H: BuildHasher,

const OUTPUT_TYPE: TypeHint

type Target = PyDict

type Output = Bound<'py, <&'a HashMap<K, V, H> as IntoPyObject<'py>>::Target>

type Error = PyErr

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

fn type_output() -> TypeInfo

impl<'a, 'py, K, V, H> IntoPyObject<'py> for &'a HashMap<K, V, H>

where &'a K: IntoPyObject<'py> + Eq + Hash, &'a V: IntoPyObject<'py>, H: BuildHasher,

type Target = PyDict

type Output = Bound<'py, <&'a HashMap<K, V, H> as IntoPyObject<'py>>::Target>

type Error = PyErr

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

impl<'a, 'py, K, V, H> IntoPyObject<'py> for &'a IndexMap<K, V, H>

where &'a K: IntoPyObject<'py> + Eq + Hash, &'a V: IntoPyObject<'py>, H: BuildHasher,

type Target = PyDict

type Output = Bound<'py, <&'a IndexMap<K, V, H> as IntoPyObject<'py>>::Target>

type Error = PyErr

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

impl<'a, 'py, L, R> IntoPyObject<'py> for &'a Either<L, R>

where &'a L: IntoPyObject<'py>, &'a R: IntoPyObject<'py>,

type Target = PyAny

type Output = Bound<'py, <&'a Either<L, R> as IntoPyObject<'py>>::Target>

type Error = PyErr

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

impl<'a, 'py, T0> IntoPyObject<'py> for &'a (T0,)

where &'a T0: IntoPyObject<'py>,

const OUTPUT_TYPE: TypeHint

type Target = PyTuple

type Output = Bound<'py, <&'a (T0,) as IntoPyObject<'py>>::Target>

type Error = PyErr

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

fn type_output() -> TypeInfo

impl<'a, 'py, T0, T1> IntoPyObject<'py> for &'a (T0, T1)

where &'a T0: IntoPyObject<'py>, &'a T1: IntoPyObject<'py>,

const OUTPUT_TYPE: TypeHint

type Target = PyTuple

type Output = Bound<'py, <&'a (T0, T1) as IntoPyObject<'py>>::Target>

type Error = PyErr

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

fn type_output() -> TypeInfo

impl<'a, 'py, T0, T1, T2> IntoPyObject<'py> for &'a (T0, T1, T2)

where &'a T0: IntoPyObject<'py>, &'a T1: IntoPyObject<'py>, &'a T2: IntoPyObject<'py>,

const OUTPUT_TYPE: TypeHint

type Target = PyTuple

type Output = Bound<'py, <&'a (T0, T1, T2) as IntoPyObject<'py>>::Target>

type Error = PyErr

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

fn type_output() -> TypeInfo

impl<'a, 'py, T0, T1, T2, T3> IntoPyObject<'py> for &'a (T0, T1, T2, T3)

where &'a T0: IntoPyObject<'py>, &'a T1: IntoPyObject<'py>, &'a T2: IntoPyObject<'py>, &'a T3: IntoPyObject<'py>,

const OUTPUT_TYPE: TypeHint

type Target = PyTuple

type Output = Bound<'py, <&'a (T0, T1, T2, T3) as IntoPyObject<'py>>::Target>

type Error = PyErr

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

fn type_output() -> TypeInfo

impl<'a, 'py, T0, T1, T2, T3, T4> IntoPyObject<'py> for &'a (T0, T1, T2, T3, T4)

where &'a T0: IntoPyObject<'py>, &'a T1: IntoPyObject<'py>, &'a T2: IntoPyObject<'py>, &'a T3: IntoPyObject<'py>, &'a T4: IntoPyObject<'py>,

const OUTPUT_TYPE: TypeHint

type Target = PyTuple

type Output = Bound<'py, <&'a (T0, T1, T2, T3, T4) as IntoPyObject<'py>>::Target>

type Error = PyErr

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

fn type_output() -> TypeInfo

impl<'a, 'py, T0, T1, T2, T3, T4, T5> IntoPyObject<'py> for &'a (T0, T1, T2, T3, T4, T5)

where &'a T0: IntoPyObject<'py>, &'a T1: IntoPyObject<'py>, &'a T2: IntoPyObject<'py>, &'a T3: IntoPyObject<'py>, &'a T4: IntoPyObject<'py>, &'a T5: IntoPyObject<'py>,

const OUTPUT_TYPE: TypeHint

type Target = PyTuple

type Output = Bound<'py, <&'a (T0, T1, T2, T3, T4, T5) as IntoPyObject<'py>>::Target>

type Error = PyErr

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

fn type_output() -> TypeInfo

impl<'a, 'py, T0, T1, T2, T3, T4, T5, T6> IntoPyObject<'py> for &'a (T0, T1, T2, T3, T4, T5, T6)

where &'a T0: IntoPyObject<'py>, &'a T1: IntoPyObject<'py>, &'a T2: IntoPyObject<'py>, &'a T3: IntoPyObject<'py>, &'a T4: IntoPyObject<'py>, &'a T5: IntoPyObject<'py>, &'a T6: IntoPyObject<'py>,

const OUTPUT_TYPE: TypeHint

type Target = PyTuple

type Output = Bound<'py, <&'a (T0, T1, T2, T3, T4, T5, T6) as IntoPyObject<'py>>::Target>

type Error = PyErr

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

fn type_output() -> TypeInfo

impl<'a, 'py, T0, T1, T2, T3, T4, T5, T6, T7> IntoPyObject<'py> for &'a (T0, T1, T2, T3, T4, T5, T6, T7)

where &'a T0: IntoPyObject<'py>, &'a T1: IntoPyObject<'py>, &'a T2: IntoPyObject<'py>, &'a T3: IntoPyObject<'py>, &'a T4: IntoPyObject<'py>, &'a T5: IntoPyObject<'py>, &'a T6: IntoPyObject<'py>, &'a T7: IntoPyObject<'py>,

const OUTPUT_TYPE: TypeHint

type Target = PyTuple

type Output = Bound<'py, <&'a (T0, T1, T2, T3, T4, T5, T6, T7) as IntoPyObject<'py>>::Target>

type Error = PyErr

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

fn type_output() -> TypeInfo

impl<'a, 'py, T0, T1, T2, T3, T4, T5, T6, T7, T8> IntoPyObject<'py> for &'a (T0, T1, T2, T3, T4, T5, T6, T7, T8)

where &'a T0: IntoPyObject<'py>, &'a T1: IntoPyObject<'py>, &'a T2: IntoPyObject<'py>, &'a T3: IntoPyObject<'py>, &'a T4: IntoPyObject<'py>, &'a T5: IntoPyObject<'py>, &'a T6: IntoPyObject<'py>, &'a T7: IntoPyObject<'py>, &'a T8: IntoPyObject<'py>,

const OUTPUT_TYPE: TypeHint

type Target = PyTuple

type Output = Bound<'py, <&'a (T0, T1, T2, T3, T4, T5, T6, T7, T8) as IntoPyObject<'py>>::Target>

type Error = PyErr

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

fn type_output() -> TypeInfo

impl<'a, 'py, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> IntoPyObject<'py> for &'a (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)

where &'a T0: IntoPyObject<'py>, &'a T1: IntoPyObject<'py>, &'a T2: IntoPyObject<'py>, &'a T3: IntoPyObject<'py>, &'a T4: IntoPyObject<'py>, &'a T5: IntoPyObject<'py>, &'a T6: IntoPyObject<'py>, &'a T7: IntoPyObject<'py>, &'a T8: IntoPyObject<'py>, &'a T9: IntoPyObject<'py>,

const OUTPUT_TYPE: TypeHint

type Target = PyTuple

type Output = Bound<'py, <&'a (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) as IntoPyObject<'py>>::Target>

type Error = PyErr

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

fn type_output() -> TypeInfo

impl<'a, 'py, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> IntoPyObject<'py> for &'a (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)

where &'a T0: IntoPyObject<'py>, &'a T1: IntoPyObject<'py>, &'a T2: IntoPyObject<'py>, &'a T3: IntoPyObject<'py>, &'a T4: IntoPyObject<'py>, &'a T5: IntoPyObject<'py>, &'a T6: IntoPyObject<'py>, &'a T7: IntoPyObject<'py>, &'a T8: IntoPyObject<'py>, &'a T9: IntoPyObject<'py>, &'a T10: IntoPyObject<'py>,

const OUTPUT_TYPE: TypeHint

type Target = PyTuple

type Output = Bound<'py, <&'a (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) as IntoPyObject<'py>>::Target>

type Error = PyErr

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

fn type_output() -> TypeInfo

impl<'a, 'py, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> IntoPyObject<'py> for &'a (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)

where &'a T0: IntoPyObject<'py>, &'a T1: IntoPyObject<'py>, &'a T2: IntoPyObject<'py>, &'a T3: IntoPyObject<'py>, &'a T4: IntoPyObject<'py>, &'a T5: IntoPyObject<'py>, &'a T6: IntoPyObject<'py>, &'a T7: IntoPyObject<'py>, &'a T8: IntoPyObject<'py>, &'a T9: IntoPyObject<'py>, &'a T10: IntoPyObject<'py>, &'a T11: IntoPyObject<'py>,

const OUTPUT_TYPE: TypeHint

type Target = PyTuple

type Output = Bound<'py, <&'a (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) as IntoPyObject<'py>>::Target>

type Error = PyErr

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

fn type_output() -> TypeInfo

impl<'a, 'py, T> IntoPyObject<'py> for &'a Option<T>

where &'a T: IntoPyObject<'py>,

const OUTPUT_TYPE: TypeHint = Option<&T>::OUTPUT_TYPE

type Target = PyAny

type Output = Bound<'py, <&'a Option<T> as IntoPyObject<'py>>::Target>

type Error = <&'a T as IntoPyObject<'py>>::Error

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

impl<'a, 'py, T> IntoPyObject<'py> for &'a [T]

where &'a T: IntoPyObject<'py>,

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

Turns &[u8] into PyBytes, all other Ts will be turned into a PyList

const OUTPUT_TYPE: TypeHint = <&T>::SEQUENCE_OUTPUT_TYPE

type Target = PyAny

type Output = Bound<'py, <&'a [T] as IntoPyObject<'py>>::Target>

type Error = PyErr

fn type_output() -> TypeInfo

impl<'a, 'py, T> IntoPyObject<'py> for &'a Vec<T>

where &'a T: IntoPyObject<'py>,

const OUTPUT_TYPE: TypeHint = <&[T]>::OUTPUT_TYPE

type Target = PyAny

type Output = Bound<'py, <&'a Vec<T> as IntoPyObject<'py>>::Target>

type Error = PyErr

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

fn type_output() -> TypeInfo

impl<'a, 'py, T> IntoPyObject<'py> for &&'a T

where &'a T: IntoPyObject<'py>,

const OUTPUT_TYPE: TypeHint

type Target = <&'a T as IntoPyObject<'py>>::Target

type Output = <&'a T as IntoPyObject<'py>>::Output

type Error = <&'a T as IntoPyObject<'py>>::Error

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

impl<'a, 'py, T, const N: usize> IntoPyObject<'py> for &'a [T; N]

where &'a T: IntoPyObject<'py>,

const OUTPUT_TYPE: TypeHint = <&[T]>::OUTPUT_TYPE

type Target = PyAny

type Output = Bound<'py, <&'a [T; N] as IntoPyObject<'py>>::Target>

type Error = PyErr

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

impl<'py> IntoPyObject<'py> for &&str

const OUTPUT_TYPE: TypeHint = String::OUTPUT_TYPE

type Target = PyString

type Output = Bound<'py, <&&str as IntoPyObject<'py>>::Target>

type Error = Infallible

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

fn type_output() -> TypeInfo

impl<'py> IntoPyObject<'py> for &&OsStr

const OUTPUT_TYPE: TypeHint = <&OsStr>::OUTPUT_TYPE

type Target = PyString

type Output = Bound<'py, <&&OsStr as IntoPyObject<'py>>::Target>

type Error = Infallible

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

impl<'py> IntoPyObject<'py> for &&Path

const OUTPUT_TYPE: TypeHint = <&Path>::OUTPUT_TYPE

type Target = PyAny

type Output = Bound<'py, <&&Path as IntoPyObject<'py>>::Target>

type Error = PyErr

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

impl<'py> IntoPyObject<'py> for &Cow<'_, str>

const OUTPUT_TYPE: TypeHint = String::OUTPUT_TYPE

type Target = PyString

type Output = Bound<'py, <&Cow<'_, str> as IntoPyObject<'py>>::Target>

type Error = Infallible

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

fn type_output() -> TypeInfo

impl<'py> IntoPyObject<'py> for &Cow<'_, CStr>

const OUTPUT_TYPE: TypeHint = <&CStr>::OUTPUT_TYPE

type Target = PyString

type Output = Bound<'py, <&Cow<'_, CStr> as IntoPyObject<'py>>::Target>

type Error = Utf8Error

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

impl<'py> IntoPyObject<'py> for &Cow<'_, OsStr>

const OUTPUT_TYPE: TypeHint = <&OsStr>::OUTPUT_TYPE

type Target = PyString

type Output = Bound<'py, <&Cow<'_, OsStr> as IntoPyObject<'py>>::Target>

type Error = Infallible

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

impl<'py> IntoPyObject<'py> for &Cow<'_, Path>

const OUTPUT_TYPE: TypeHint = <&Path>::OUTPUT_TYPE

type Target = PyAny

type Output = Bound<'py, <&Cow<'_, Path> as IntoPyObject<'py>>::Target>

type Error = PyErr

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

impl<'py> IntoPyObject<'py> for &IpAddr

const OUTPUT_TYPE: TypeHint = IpAddr::OUTPUT_TYPE

type Target = PyAny

type Output = Bound<'py, <&IpAddr as IntoPyObject<'py>>::Target>

type Error = PyErr

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

impl<'py> IntoPyObject<'py> for &bool

const OUTPUT_TYPE: TypeHint = bool::OUTPUT_TYPE

type Target = PyBool

type Output = Borrowed<'py, 'py, <&bool as IntoPyObject<'py>>::Target>

type Error = Infallible

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

fn type_output() -> TypeInfo

impl<'py> IntoPyObject<'py> for &char

const OUTPUT_TYPE: TypeHint = String::OUTPUT_TYPE

type Target = PyString

type Output = Bound<'py, <&char as IntoPyObject<'py>>::Target>

type Error = Infallible

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

fn type_output() -> TypeInfo

impl<'py> IntoPyObject<'py> for &f32

const OUTPUT_TYPE: TypeHint = f32::OUTPUT_TYPE

type Target = PyFloat

type Output = Bound<'py, <&f32 as IntoPyObject<'py>>::Target>

type Error = Infallible

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

fn type_output() -> TypeInfo

impl<'py> IntoPyObject<'py> for &f64

const OUTPUT_TYPE: TypeHint = f64::OUTPUT_TYPE

type Target = PyFloat

type Output = Bound<'py, <&f64 as IntoPyObject<'py>>::Target>

type Error = Infallible

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

fn type_output() -> TypeInfo

impl<'py> IntoPyObject<'py> for &i8

const OUTPUT_TYPE: TypeHint = i8::OUTPUT_TYPE

type Target = PyInt

type Output = Bound<'py, <&i8 as IntoPyObject<'py>>::Target>

type Error = Infallible

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

fn type_output() -> TypeInfo

impl<'py> IntoPyObject<'py> for &i16

const OUTPUT_TYPE: TypeHint = i16::OUTPUT_TYPE

type Target = PyInt

type Output = Bound<'py, <&i16 as IntoPyObject<'py>>::Target>

type Error = Infallible

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

fn type_output() -> TypeInfo

impl<'py> IntoPyObject<'py> for &i32

const OUTPUT_TYPE: TypeHint = i32::OUTPUT_TYPE

type Target = PyInt

type Output = Bound<'py, <&i32 as IntoPyObject<'py>>::Target>

type Error = Infallible

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

fn type_output() -> TypeInfo

impl<'py> IntoPyObject<'py> for &i64

const OUTPUT_TYPE: TypeHint = i64::OUTPUT_TYPE

type Target = PyInt

type Output = Bound<'py, <&i64 as IntoPyObject<'py>>::Target>

type Error = Infallible

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

fn type_output() -> TypeInfo

impl<'py> IntoPyObject<'py> for &i128

const OUTPUT_TYPE: TypeHint = i128::OUTPUT_TYPE

type Target = PyInt

type Output = Bound<'py, <&i128 as IntoPyObject<'py>>::Target>

type Error = Infallible

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

fn type_output() -> TypeInfo

impl<'py> IntoPyObject<'py> for &isize

const OUTPUT_TYPE: TypeHint = isize::OUTPUT_TYPE

type Target = PyInt

type Output = Bound<'py, <&isize as IntoPyObject<'py>>::Target>

type Error = Infallible

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

fn type_output() -> TypeInfo

impl<'py> IntoPyObject<'py> for &str

const OUTPUT_TYPE: TypeHint = String::OUTPUT_TYPE

type Target = PyString

type Output = Bound<'py, <&str as IntoPyObject<'py>>::Target>

type Error = Infallible

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

fn type_output() -> TypeInfo

impl<'py> IntoPyObject<'py> for &u8

const OUTPUT_TYPE: TypeHint = u8::OUTPUT_TYPE

type Target = PyInt

type Output = Bound<'py, <&u8 as IntoPyObject<'py>>::Target>

type Error = Infallible

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

fn type_output() -> TypeInfo

impl<'py> IntoPyObject<'py> for &u16

const OUTPUT_TYPE: TypeHint = u16::OUTPUT_TYPE

type Target = PyInt

type Output = Bound<'py, <&u16 as IntoPyObject<'py>>::Target>

type Error = Infallible

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

fn type_output() -> TypeInfo

impl<'py> IntoPyObject<'py> for &u32

const OUTPUT_TYPE: TypeHint = u32::OUTPUT_TYPE

type Target = PyInt

type Output = Bound<'py, <&u32 as IntoPyObject<'py>>::Target>

type Error = Infallible

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

fn type_output() -> TypeInfo

impl<'py> IntoPyObject<'py> for &u64

const OUTPUT_TYPE: TypeHint = u64::OUTPUT_TYPE

type Target = PyInt

type Output = Bound<'py, <&u64 as IntoPyObject<'py>>::Target>

type Error = Infallible

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

impl<'py> IntoPyObject<'py> for &u128

const OUTPUT_TYPE: TypeHint = u128::OUTPUT_TYPE

type Target = PyInt

type Output = Bound<'py, <&u128 as IntoPyObject<'py>>::Target>

type Error = Infallible

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

fn type_output() -> TypeInfo

impl<'py> IntoPyObject<'py> for &usize

const OUTPUT_TYPE: TypeHint = u64::OUTPUT_TYPE

type Target = PyInt

type Output = Bound<'py, <&usize as IntoPyObject<'py>>::Target>

type Error = Infallible

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

fn type_output() -> TypeInfo

impl<'py> IntoPyObject<'py> for &CString

const OUTPUT_TYPE: TypeHint = <&CStr>::OUTPUT_TYPE

type Target = PyString

type Output = Bound<'py, <&CString as IntoPyObject<'py>>::Target>

type Error = Utf8Error

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

impl<'py> IntoPyObject<'py> for &String

const OUTPUT_TYPE: TypeHint = String::OUTPUT_TYPE

type Target = PyString

type Output = Bound<'py, <&String as IntoPyObject<'py>>::Target>

type Error = Infallible

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

fn type_output() -> TypeInfo

impl<'py> IntoPyObject<'py> for &CStr

const OUTPUT_TYPE: TypeHint = <&str>::OUTPUT_TYPE

type Target = PyString

type Output = Bound<'py, <&CStr as IntoPyObject<'py>>::Target>

type Error = Utf8Error

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

impl<'py> IntoPyObject<'py> for &Ipv4Addr

const OUTPUT_TYPE: TypeHint = Ipv4Addr::OUTPUT_TYPE

type Target = PyAny

type Output = Bound<'py, <&Ipv4Addr as IntoPyObject<'py>>::Target>

type Error = PyErr

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

impl<'py> IntoPyObject<'py> for &Ipv6Addr

const OUTPUT_TYPE: TypeHint = Ipv6Addr::OUTPUT_TYPE

type Target = PyAny

type Output = Bound<'py, <&Ipv6Addr as IntoPyObject<'py>>::Target>

type Error = PyErr

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

impl<'py> IntoPyObject<'py> for &Duration

const OUTPUT_TYPE: TypeHint = Duration::OUTPUT_TYPE

type Target = PyDelta

type Output = Bound<'py, <&Duration as IntoPyObject<'py>>::Target>

type Error = PyErr

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

impl<'py> IntoPyObject<'py> for &OsStr

const OUTPUT_TYPE: TypeHint = PyString::TYPE_HINT

type Target = PyString

type Output = Bound<'py, <&OsStr as IntoPyObject<'py>>::Target>

type Error = Infallible

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

impl<'py> IntoPyObject<'py> for &OsString

const OUTPUT_TYPE: TypeHint = <&OsStr>::OUTPUT_TYPE

type Target = PyString

type Output = Bound<'py, <&OsString as IntoPyObject<'py>>::Target>

type Error = Infallible

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

impl<'py> IntoPyObject<'py> for &Path

const OUTPUT_TYPE: TypeHint

type Target = PyAny

type Output = Bound<'py, <&Path as IntoPyObject<'py>>::Target>

type Error = PyErr

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

impl<'py> IntoPyObject<'py> for &PathBuf

const OUTPUT_TYPE: TypeHint = <&Path>::OUTPUT_TYPE

type Target = PyAny

type Output = Bound<'py, <&PathBuf as IntoPyObject<'py>>::Target>

type Error = PyErr

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

impl<'py> IntoPyObject<'py> for &SystemTime

const OUTPUT_TYPE: TypeHint = SystemTime::OUTPUT_TYPE

type Target = PyDateTime

type Output = Bound<'py, <&SystemTime as IntoPyObject<'py>>::Target>

type Error = PyErr

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

impl<'py> IntoPyObject<'py> for &NaiveDate

const OUTPUT_TYPE: TypeHint = NaiveDate::OUTPUT_TYPE

type Target = PyDate

type Output = Bound<'py, <&NaiveDate as IntoPyObject<'py>>::Target>

type Error = PyErr

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

impl<'py> IntoPyObject<'py> for &NaiveDateTime

const OUTPUT_TYPE: TypeHint = NaiveDateTime::OUTPUT_TYPE

type Target = PyDateTime

type Output = Bound<'py, <&NaiveDateTime as IntoPyObject<'py>>::Target>

type Error = PyErr

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

impl<'py> IntoPyObject<'py> for &NaiveTime

const OUTPUT_TYPE: TypeHint = NaiveTime::OUTPUT_TYPE

type Target = PyTime

type Output = Bound<'py, <&NaiveTime as IntoPyObject<'py>>::Target>

type Error = PyErr

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

impl<'py> IntoPyObject<'py> for &FixedOffset

const OUTPUT_TYPE: TypeHint = FixedOffset::OUTPUT_TYPE

type Target = PyTzInfo

type Output = Bound<'py, <&FixedOffset as IntoPyObject<'py>>::Target>

type Error = PyErr

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

impl<'py> IntoPyObject<'py> for &Local

Available on crate feature chrono-local only.

const OUTPUT_TYPE: TypeHint = Local::OUTPUT_TYPE

type Target = PyTzInfo

type Output = Borrowed<'static, 'py, <&Local as IntoPyObject<'py>>::Target>

type Error = PyErr

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

impl<'py> IntoPyObject<'py> for &Utc

const OUTPUT_TYPE: TypeHint = Utc::OUTPUT_TYPE

type Target = PyTzInfo

type Output = Borrowed<'static, 'py, <&Utc as IntoPyObject<'py>>::Target>

type Error = PyErr

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

impl<'py> IntoPyObject<'py> for &BigInt

type Target = PyInt

type Output = Bound<'py, <&BigInt as IntoPyObject<'py>>::Target>

type Error = PyErr

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

impl<'py> IntoPyObject<'py> for &BigUint

type Target = PyInt

type Output = Bound<'py, <&BigUint as IntoPyObject<'py>>::Target>

type Error = PyErr

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

impl<'py> IntoPyObject<'py> for &Complex<f32>

type Target = PyComplex

type Output = Bound<'py, <&Complex<f32> as IntoPyObject<'py>>::Target>

type Error = Infallible

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

impl<'py> IntoPyObject<'py> for &Complex<f64>

type Target = PyComplex

type Output = Bound<'py, <&Complex<f64> as IntoPyObject<'py>>::Target>

type Error = Infallible

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

impl<'py> IntoPyObject<'py> for &Ratio<i8>

type Target = PyAny

type Output = Bound<'py, <&Ratio<i8> as IntoPyObject<'py>>::Target>

type Error = PyErr

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

impl<'py> IntoPyObject<'py> for &Ratio<i16>

type Target = PyAny

type Output = Bound<'py, <&Ratio<i16> as IntoPyObject<'py>>::Target>

type Error = PyErr

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

impl<'py> IntoPyObject<'py> for &Ratio<i32>

type Target = PyAny

type Output = Bound<'py, <&Ratio<i32> as IntoPyObject<'py>>::Target>

type Error = PyErr

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

impl<'py> IntoPyObject<'py> for &Ratio<i64>

type Target = PyAny

type Output = Bound<'py, <&Ratio<i64> as IntoPyObject<'py>>::Target>

type Error = PyErr

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

impl<'py> IntoPyObject<'py> for &Ratio<isize>

type Target = PyAny

type Output = Bound<'py, <&Ratio<isize> as IntoPyObject<'py>>::Target>

type Error = PyErr

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

impl<'py> IntoPyObject<'py> for &Ratio<BigInt>

type Target = PyAny

type Output = Bound<'py, <&Ratio<BigInt> as IntoPyObject<'py>>::Target>

type Error = PyErr

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

impl<'py> IntoPyObject<'py> for &Uuid

type Target = PyAny

type Output = Bound<'py, <&Uuid as IntoPyObject<'py>>::Target>

type Error = PyErr

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

impl<'py> IntoPyObject<'py> for &NonZeroI8

const OUTPUT_TYPE: TypeHint = NonZeroI8::OUTPUT_TYPE

type Target = PyInt

type Output = Bound<'py, <&NonZero<i8> as IntoPyObject<'py>>::Target>

type Error = Infallible

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

fn type_output() -> TypeInfo

impl<'py> IntoPyObject<'py> for &NonZeroI16

const OUTPUT_TYPE: TypeHint = NonZeroI16::OUTPUT_TYPE

type Target = PyInt

type Output = Bound<'py, <&NonZero<i16> as IntoPyObject<'py>>::Target>

type Error = Infallible

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

fn type_output() -> TypeInfo

impl<'py> IntoPyObject<'py> for &NonZeroI32

const OUTPUT_TYPE: TypeHint = NonZeroI32::OUTPUT_TYPE

type Target = PyInt

type Output = Bound<'py, <&NonZero<i32> as IntoPyObject<'py>>::Target>

type Error = Infallible

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

fn type_output() -> TypeInfo

impl<'py> IntoPyObject<'py> for &NonZeroI64

const OUTPUT_TYPE: TypeHint = NonZeroI64::OUTPUT_TYPE

type Target = PyInt

type Output = Bound<'py, <&NonZero<i64> as IntoPyObject<'py>>::Target>

type Error = Infallible

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

fn type_output() -> TypeInfo

impl<'py> IntoPyObject<'py> for &NonZeroI128

const OUTPUT_TYPE: TypeHint = NonZeroI128::OUTPUT_TYPE

type Target = PyInt

type Output = Bound<'py, <&NonZero<i128> as IntoPyObject<'py>>::Target>

type Error = Infallible

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

fn type_output() -> TypeInfo

impl<'py> IntoPyObject<'py> for &NonZeroIsize

const OUTPUT_TYPE: TypeHint = NonZeroIsize::OUTPUT_TYPE

type Target = PyInt

type Output = Bound<'py, <&NonZero<isize> as IntoPyObject<'py>>::Target>

type Error = Infallible

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

fn type_output() -> TypeInfo

impl<'py> IntoPyObject<'py> for &NonZeroU8

const OUTPUT_TYPE: TypeHint = NonZeroU8::OUTPUT_TYPE

type Target = PyInt

type Output = Bound<'py, <&NonZero<u8> as IntoPyObject<'py>>::Target>

type Error = Infallible

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

fn type_output() -> TypeInfo

impl<'py> IntoPyObject<'py> for &NonZeroU16

const OUTPUT_TYPE: TypeHint = NonZeroU16::OUTPUT_TYPE

type Target = PyInt

type Output = Bound<'py, <&NonZero<u16> as IntoPyObject<'py>>::Target>

type Error = Infallible

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

fn type_output() -> TypeInfo

impl<'py> IntoPyObject<'py> for &NonZeroU32

const OUTPUT_TYPE: TypeHint = NonZeroU32::OUTPUT_TYPE

type Target = PyInt

type Output = Bound<'py, <&NonZero<u32> as IntoPyObject<'py>>::Target>

type Error = Infallible

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

fn type_output() -> TypeInfo

impl<'py> IntoPyObject<'py> for &NonZeroU64

const OUTPUT_TYPE: TypeHint = NonZeroU64::OUTPUT_TYPE

type Target = PyInt

type Output = Bound<'py, <&NonZero<u64> as IntoPyObject<'py>>::Target>

type Error = Infallible

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

fn type_output() -> TypeInfo

impl<'py> IntoPyObject<'py> for &NonZeroU128

const OUTPUT_TYPE: TypeHint = NonZeroU128::OUTPUT_TYPE

type Target = PyInt

type Output = Bound<'py, <&NonZero<u128> as IntoPyObject<'py>>::Target>

type Error = Infallible

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

fn type_output() -> TypeInfo

impl<'py> IntoPyObject<'py> for &NonZeroUsize

const OUTPUT_TYPE: TypeHint = NonZeroUsize::OUTPUT_TYPE

type Target = PyInt

type Output = Bound<'py, <&NonZero<usize> as IntoPyObject<'py>>::Target>

type Error = Infallible

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

fn type_output() -> TypeInfo

impl<'py> IntoPyObject<'py> for &Duration

const OUTPUT_TYPE: TypeHint = Duration::OUTPUT_TYPE

type Target = PyDelta

type Output = Bound<'py, <&TimeDelta as IntoPyObject<'py>>::Target>

type Error = PyErr

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

impl<'py> IntoPyObject<'py> for &Bytes

type Target = PyBytes

type Output = Bound<'py, <&Bytes as IntoPyObject<'py>>::Target>

type Error = PyErr

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

impl<'py> IntoPyObject<'py> for &Date

type Target = PyDate

type Output = Bound<'py, <&Date as IntoPyObject<'py>>::Target>

type Error = PyErr

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

impl<'py> IntoPyObject<'py> for &Date

type Target = PyDate

type Output = Bound<'py, <&Date as IntoPyObject<'py>>::Target>

type Error = PyErr

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

impl<'py> IntoPyObject<'py> for &DateTime

type Target = PyDateTime

type Output = Bound<'py, <&DateTime as IntoPyObject<'py>>::Target>

type Error = PyErr

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

impl<'py> IntoPyObject<'py> for &Decimal

type Target = PyAny

type Output = Bound<'py, <&Decimal as IntoPyObject<'py>>::Target>

type Error = PyErr

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

impl<'py> IntoPyObject<'py> for &Duration

type Target = PyDelta

type Output = Bound<'py, <&Duration as IntoPyObject<'py>>::Target>

type Error = PyErr

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

impl<'py> IntoPyObject<'py> for &ISOWeekDate

type Target = PyDate

type Output = Bound<'py, <&ISOWeekDate as IntoPyObject<'py>>::Target>

type Error = PyErr

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

impl<'py> IntoPyObject<'py> for &NotNan<f32>

type Target = PyFloat

type Output = Bound<'py, <&NotNan<f32> as IntoPyObject<'py>>::Target>

type Error = Infallible

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

impl<'py> IntoPyObject<'py> for &NotNan<f64>

type Target = PyFloat

type Output = Bound<'py, <&NotNan<f64> as IntoPyObject<'py>>::Target>

type Error = Infallible

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

impl<'py> IntoPyObject<'py> for &Offset

type Target = PyTzInfo

type Output = Bound<'py, <&Offset as IntoPyObject<'py>>::Target>

type Error = PyErr

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

impl<'py> IntoPyObject<'py> for &OffsetDateTime

type Target = PyDateTime

type Output = Bound<'py, <&OffsetDateTime as IntoPyObject<'py>>::Target>

type Error = PyErr

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

impl<'py> IntoPyObject<'py> for &OrderedFloat<f32>

type Target = PyFloat

type Output = Bound<'py, <&OrderedFloat<f32> as IntoPyObject<'py>>::Target>

type Error = Infallible

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

impl<'py> IntoPyObject<'py> for &OrderedFloat<f64>

type Target = PyFloat

type Output = Bound<'py, <&OrderedFloat<f64> as IntoPyObject<'py>>::Target>

type Error = Infallible

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

impl<'py> IntoPyObject<'py> for &PrimitiveDateTime

type Target = PyDateTime

type Output = Bound<'py, <&PrimitiveDateTime as IntoPyObject<'py>>::Target>

type Error = PyErr

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

impl<'py> IntoPyObject<'py> for &SignedDuration

type Target = PyDelta

type Output = Bound<'py, <&SignedDuration as IntoPyObject<'py>>::Target>

type Error = PyErr

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

impl<'py> IntoPyObject<'py> for &Time

type Target = PyTime

type Output = Bound<'py, <&Time as IntoPyObject<'py>>::Target>

type Error = PyErr

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

impl<'py> IntoPyObject<'py> for &Time

type Target = PyTime

type Output = Bound<'py, <&Time as IntoPyObject<'py>>::Target>

type Error = PyErr

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

impl<'py> IntoPyObject<'py> for &TimeZone

type Target = PyTzInfo

type Output = Bound<'py, <&TimeZone as IntoPyObject<'py>>::Target>

type Error = PyErr

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

impl<'py> IntoPyObject<'py> for &Timestamp

type Target = PyDateTime

type Output = Bound<'py, <&Timestamp as IntoPyObject<'py>>::Target>

type Error = PyErr

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

impl<'py> IntoPyObject<'py> for &Tz

const OUTPUT_TYPE: TypeHint = Tz::OUTPUT_TYPE

type Target = PyTzInfo

type Output = Bound<'py, <&Tz as IntoPyObject<'py>>::Target>

type Error = PyErr

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

impl<'py> IntoPyObject<'py> for &UtcDateTime

type Target = PyDateTime

type Output = Bound<'py, <&UtcDateTime as IntoPyObject<'py>>::Target>

type Error = PyErr

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

impl<'py> IntoPyObject<'py> for &UtcOffset

type Target = PyTzInfo

type Output = Bound<'py, <&UtcOffset as IntoPyObject<'py>>::Target>

type Error = PyErr

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

impl<'py> IntoPyObject<'py> for &Zoned

type Target = PyDateTime

type Output = Bound<'py, <&Zoned as IntoPyObject<'py>>::Target>

type Error = PyErr

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

impl<'py> IntoPyObject<'py> for Cow<'_, str>

const OUTPUT_TYPE: TypeHint = String::OUTPUT_TYPE

type Target = PyString

type Output = Bound<'py, <Cow<'_, str> as IntoPyObject<'py>>::Target>

type Error = Infallible

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

fn type_output() -> TypeInfo

impl<'py> IntoPyObject<'py> for Cow<'_, CStr>

const OUTPUT_TYPE: TypeHint = <&CStr>::OUTPUT_TYPE

type Target = PyString

type Output = Bound<'py, <Cow<'_, CStr> as IntoPyObject<'py>>::Target>

type Error = Utf8Error

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

impl<'py> IntoPyObject<'py> for Cow<'_, OsStr>

const OUTPUT_TYPE: TypeHint = <&OsStr>::OUTPUT_TYPE

type Target = PyString

type Output = Bound<'py, <Cow<'_, OsStr> as IntoPyObject<'py>>::Target>

type Error = Infallible

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

impl<'py> IntoPyObject<'py> for Cow<'_, Path>

const OUTPUT_TYPE: TypeHint = <&Path>::OUTPUT_TYPE

type Target = PyAny

type Output = Bound<'py, <Cow<'_, Path> as IntoPyObject<'py>>::Target>

type Error = PyErr

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

impl<'py> IntoPyObject<'py> for IpAddr

const OUTPUT_TYPE: TypeHint

type Target = PyAny

type Output = Bound<'py, <IpAddr as IntoPyObject<'py>>::Target>

type Error = PyErr

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

impl<'py> IntoPyObject<'py> for bool

const OUTPUT_TYPE: TypeHint = PyBool::TYPE_HINT

type Target = PyBool

type Output = Borrowed<'py, 'py, <bool as IntoPyObject<'py>>::Target>

type Error = Infallible

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

fn type_output() -> TypeInfo

impl<'py> IntoPyObject<'py> for char

const OUTPUT_TYPE: TypeHint = String::OUTPUT_TYPE

type Target = PyString

type Output = Bound<'py, <char as IntoPyObject<'py>>::Target>

type Error = Infallible

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

fn type_output() -> TypeInfo

impl<'py> IntoPyObject<'py> for f32

const OUTPUT_TYPE: TypeHint = PyFloat::TYPE_HINT

type Target = PyFloat

type Output = Bound<'py, <f32 as IntoPyObject<'py>>::Target>

type Error = Infallible

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

fn type_output() -> TypeInfo

impl<'py> IntoPyObject<'py> for f64

const OUTPUT_TYPE: TypeHint = PyFloat::TYPE_HINT

type Target = PyFloat

type Output = Bound<'py, <f64 as IntoPyObject<'py>>::Target>

type Error = Infallible

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

fn type_output() -> TypeInfo

impl<'py> IntoPyObject<'py> for i8

const OUTPUT_TYPE: TypeHint = PyInt::TYPE_HINT

type Target = PyInt

type Output = Bound<'py, <i8 as IntoPyObject<'py>>::Target>

type Error = Infallible

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

fn type_output() -> TypeInfo

impl<'py> IntoPyObject<'py> for i16

const OUTPUT_TYPE: TypeHint = PyInt::TYPE_HINT

type Target = PyInt

type Output = Bound<'py, <i16 as IntoPyObject<'py>>::Target>

type Error = Infallible

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

fn type_output() -> TypeInfo

impl<'py> IntoPyObject<'py> for i32

const OUTPUT_TYPE: TypeHint = PyInt::TYPE_HINT

type Target = PyInt

type Output = Bound<'py, <i32 as IntoPyObject<'py>>::Target>

type Error = Infallible

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

fn type_output() -> TypeInfo

impl<'py> IntoPyObject<'py> for i64

const OUTPUT_TYPE: TypeHint = PyInt::TYPE_HINT

type Target = PyInt

type Output = Bound<'py, <i64 as IntoPyObject<'py>>::Target>

type Error = Infallible

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

fn type_output() -> TypeInfo

impl<'py> IntoPyObject<'py> for i128

const OUTPUT_TYPE: TypeHint = PyInt::TYPE_HINT

type Target = PyInt

type Output = Bound<'py, <i128 as IntoPyObject<'py>>::Target>

type Error = Infallible

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

fn type_output() -> TypeInfo

impl<'py> IntoPyObject<'py> for isize

const OUTPUT_TYPE: TypeHint = PyInt::TYPE_HINT

type Target = PyInt

type Output = Bound<'py, <isize as IntoPyObject<'py>>::Target>

type Error = Infallible

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

fn type_output() -> TypeInfo

impl<'py> IntoPyObject<'py> for u8

const OUTPUT_TYPE: TypeHint = PyInt::TYPE_HINT

type Target = PyInt

type Output = Bound<'py, <u8 as IntoPyObject<'py>>::Target>

type Error = Infallible

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

fn type_output() -> TypeInfo

impl<'py> IntoPyObject<'py> for u16

const OUTPUT_TYPE: TypeHint = PyInt::TYPE_HINT

type Target = PyInt

type Output = Bound<'py, <u16 as IntoPyObject<'py>>::Target>

type Error = Infallible

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

fn type_output() -> TypeInfo

impl<'py> IntoPyObject<'py> for u32

const OUTPUT_TYPE: TypeHint = PyInt::TYPE_HINT

type Target = PyInt

type Output = Bound<'py, <u32 as IntoPyObject<'py>>::Target>

type Error = Infallible

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

fn type_output() -> TypeInfo

impl<'py> IntoPyObject<'py> for u64

const OUTPUT_TYPE: TypeHint = PyInt::TYPE_HINT

type Target = PyInt

type Output = Bound<'py, <u64 as IntoPyObject<'py>>::Target>

type Error = Infallible

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

fn type_output() -> TypeInfo

impl<'py> IntoPyObject<'py> for u128

const OUTPUT_TYPE: TypeHint = PyInt::TYPE_HINT

type Target = PyInt

type Output = Bound<'py, <u128 as IntoPyObject<'py>>::Target>

type Error = Infallible

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

fn type_output() -> TypeInfo

impl<'py> IntoPyObject<'py> for ()

type Target = PyTuple

type Output = Bound<'py, <() as IntoPyObject<'py>>::Target>

type Error = Infallible

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

impl<'py> IntoPyObject<'py> for usize

const OUTPUT_TYPE: TypeHint = u64::OUTPUT_TYPE

type Target = PyInt

type Output = Bound<'py, <usize as IntoPyObject<'py>>::Target>

type Error = Infallible

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

fn type_output() -> TypeInfo

impl<'py> IntoPyObject<'py> for CString

const OUTPUT_TYPE: TypeHint = <&CStr>::OUTPUT_TYPE

type Target = PyString

type Output = Bound<'py, <CString as IntoPyObject<'py>>::Target>

type Error = Utf8Error

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

impl<'py> IntoPyObject<'py> for String

const OUTPUT_TYPE: TypeHint = PyString::TYPE_HINT

type Target = PyString

type Output = Bound<'py, <String as IntoPyObject<'py>>::Target>

type Error = Infallible

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

fn type_output() -> TypeInfo

impl<'py> IntoPyObject<'py> for Ipv4Addr

const OUTPUT_TYPE: TypeHint

type Target = PyAny

type Output = Bound<'py, <Ipv4Addr as IntoPyObject<'py>>::Target>

type Error = PyErr

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

impl<'py> IntoPyObject<'py> for Ipv6Addr

const OUTPUT_TYPE: TypeHint

type Target = PyAny

type Output = Bound<'py, <Ipv6Addr as IntoPyObject<'py>>::Target>

type Error = PyErr

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

impl<'py> IntoPyObject<'py> for Duration

const OUTPUT_TYPE: TypeHint = PyDelta::TYPE_HINT

type Target = PyDelta

type Output = Bound<'py, <Duration as IntoPyObject<'py>>::Target>

type Error = PyErr

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

impl<'py> IntoPyObject<'py> for OsString

const OUTPUT_TYPE: TypeHint = <&OsStr>::OUTPUT_TYPE

type Target = PyString

type Output = Bound<'py, <OsString as IntoPyObject<'py>>::Target>

type Error = Infallible

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

impl<'py> IntoPyObject<'py> for PathBuf

const OUTPUT_TYPE: TypeHint = <&Path>::OUTPUT_TYPE

type Target = PyAny

type Output = Bound<'py, <PathBuf as IntoPyObject<'py>>::Target>

type Error = PyErr

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

impl<'py> IntoPyObject<'py> for SystemTime

const OUTPUT_TYPE: TypeHint = PyDateTime::TYPE_HINT

type Target = PyDateTime

type Output = Bound<'py, <SystemTime as IntoPyObject<'py>>::Target>

type Error = PyErr

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

impl<'py> IntoPyObject<'py> for NaiveDate

const OUTPUT_TYPE: TypeHint = PyDate::TYPE_HINT

type Target = PyDate

type Output = Bound<'py, <NaiveDate as IntoPyObject<'py>>::Target>

type Error = PyErr

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

impl<'py> IntoPyObject<'py> for NaiveDateTime

const OUTPUT_TYPE: TypeHint = PyDateTime::TYPE_HINT

type Target = PyDateTime

type Output = Bound<'py, <NaiveDateTime as IntoPyObject<'py>>::Target>

type Error = PyErr

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

impl<'py> IntoPyObject<'py> for NaiveTime

const OUTPUT_TYPE: TypeHint = PyTime::TYPE_HINT

type Target = PyTime

type Output = Bound<'py, <NaiveTime as IntoPyObject<'py>>::Target>

type Error = PyErr

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

impl<'py> IntoPyObject<'py> for FixedOffset

const OUTPUT_TYPE: TypeHint = PyTzInfo::TYPE_HINT

type Target = PyTzInfo

type Output = Bound<'py, <FixedOffset as IntoPyObject<'py>>::Target>

type Error = PyErr

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

impl<'py> IntoPyObject<'py> for Local

Available on crate feature chrono-local only.

const OUTPUT_TYPE: TypeHint = PyTzInfo::TYPE_HINT

type Target = PyTzInfo

type Output = Borrowed<'static, 'py, <Local as IntoPyObject<'py>>::Target>

type Error = PyErr

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

impl<'py> IntoPyObject<'py> for Utc

const OUTPUT_TYPE: TypeHint = PyTzInfo::TYPE_HINT

type Target = PyTzInfo

type Output = Borrowed<'static, 'py, <Utc as IntoPyObject<'py>>::Target>

type Error = PyErr

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

impl<'py> IntoPyObject<'py> for BigInt

type Target = PyInt

type Output = Bound<'py, <BigInt as IntoPyObject<'py>>::Target>

type Error = PyErr

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

impl<'py> IntoPyObject<'py> for BigUint

type Target = PyInt

type Output = Bound<'py, <BigUint as IntoPyObject<'py>>::Target>

type Error = PyErr

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

impl<'py> IntoPyObject<'py> for Complex<f32>

type Target = PyComplex

type Output = Bound<'py, <Complex<f32> as IntoPyObject<'py>>::Target>

type Error = Infallible

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

impl<'py> IntoPyObject<'py> for Complex<f64>

type Target = PyComplex

type Output = Bound<'py, <Complex<f64> as IntoPyObject<'py>>::Target>

type Error = Infallible

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

impl<'py> IntoPyObject<'py> for Ratio<i8>

type Target = PyAny

type Output = Bound<'py, <Ratio<i8> as IntoPyObject<'py>>::Target>

type Error = PyErr

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

impl<'py> IntoPyObject<'py> for Ratio<i16>

type Target = PyAny

type Output = Bound<'py, <Ratio<i16> as IntoPyObject<'py>>::Target>

type Error = PyErr

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

impl<'py> IntoPyObject<'py> for Ratio<i32>

type Target = PyAny

type Output = Bound<'py, <Ratio<i32> as IntoPyObject<'py>>::Target>

type Error = PyErr

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

impl<'py> IntoPyObject<'py> for Ratio<i64>

type Target = PyAny

type Output = Bound<'py, <Ratio<i64> as IntoPyObject<'py>>::Target>

type Error = PyErr

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

impl<'py> IntoPyObject<'py> for Ratio<isize>

type Target = PyAny

type Output = Bound<'py, <Ratio<isize> as IntoPyObject<'py>>::Target>

type Error = PyErr

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

impl<'py> IntoPyObject<'py> for Ratio<BigInt>

type Target = PyAny

type Output = Bound<'py, <Ratio<BigInt> as IntoPyObject<'py>>::Target>

type Error = PyErr

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

impl<'py> IntoPyObject<'py> for Uuid

type Target = PyAny

type Output = Bound<'py, <Uuid as IntoPyObject<'py>>::Target>

type Error = PyErr

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

impl<'py> IntoPyObject<'py> for NonZeroI8

const OUTPUT_TYPE: TypeHint = PyInt::TYPE_HINT

type Target = PyInt

type Output = Bound<'py, <NonZero<i8> as IntoPyObject<'py>>::Target>

type Error = Infallible

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

fn type_output() -> TypeInfo

impl<'py> IntoPyObject<'py> for NonZeroI16

const OUTPUT_TYPE: TypeHint = PyInt::TYPE_HINT

type Target = PyInt

type Output = Bound<'py, <NonZero<i16> as IntoPyObject<'py>>::Target>

type Error = Infallible

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

fn type_output() -> TypeInfo

impl<'py> IntoPyObject<'py> for NonZeroI32

const OUTPUT_TYPE: TypeHint = PyInt::TYPE_HINT

type Target = PyInt

type Output = Bound<'py, <NonZero<i32> as IntoPyObject<'py>>::Target>

type Error = Infallible

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

fn type_output() -> TypeInfo

impl<'py> IntoPyObject<'py> for NonZeroI64

const OUTPUT_TYPE: TypeHint = PyInt::TYPE_HINT

type Target = PyInt

type Output = Bound<'py, <NonZero<i64> as IntoPyObject<'py>>::Target>

type Error = Infallible

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

fn type_output() -> TypeInfo

impl<'py> IntoPyObject<'py> for NonZeroI128

const OUTPUT_TYPE: TypeHint = PyInt::TYPE_HINT

type Target = PyInt

type Output = Bound<'py, <NonZero<i128> as IntoPyObject<'py>>::Target>

type Error = Infallible

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

fn type_output() -> TypeInfo

impl<'py> IntoPyObject<'py> for NonZeroIsize

const OUTPUT_TYPE: TypeHint = PyInt::TYPE_HINT

type Target = PyInt

type Output = Bound<'py, <NonZero<isize> as IntoPyObject<'py>>::Target>

type Error = Infallible

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

fn type_output() -> TypeInfo

impl<'py> IntoPyObject<'py> for NonZeroU8

const OUTPUT_TYPE: TypeHint = PyInt::TYPE_HINT

type Target = PyInt

type Output = Bound<'py, <NonZero<u8> as IntoPyObject<'py>>::Target>

type Error = Infallible

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

fn type_output() -> TypeInfo

impl<'py> IntoPyObject<'py> for NonZeroU16

const OUTPUT_TYPE: TypeHint = PyInt::TYPE_HINT

type Target = PyInt

type Output = Bound<'py, <NonZero<u16> as IntoPyObject<'py>>::Target>

type Error = Infallible

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

fn type_output() -> TypeInfo

impl<'py> IntoPyObject<'py> for NonZeroU32

const OUTPUT_TYPE: TypeHint = PyInt::TYPE_HINT

type Target = PyInt

type Output = Bound<'py, <NonZero<u32> as IntoPyObject<'py>>::Target>

type Error = Infallible

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

fn type_output() -> TypeInfo

impl<'py> IntoPyObject<'py> for NonZeroU64

const OUTPUT_TYPE: TypeHint = PyInt::TYPE_HINT

type Target = PyInt

type Output = Bound<'py, <NonZero<u64> as IntoPyObject<'py>>::Target>

type Error = Infallible

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

fn type_output() -> TypeInfo

impl<'py> IntoPyObject<'py> for NonZeroU128

const OUTPUT_TYPE: TypeHint = PyInt::TYPE_HINT

type Target = PyInt

type Output = Bound<'py, <NonZero<u128> as IntoPyObject<'py>>::Target>

type Error = Infallible

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

fn type_output() -> TypeInfo

impl<'py> IntoPyObject<'py> for NonZeroUsize

const OUTPUT_TYPE: TypeHint = PyInt::TYPE_HINT

type Target = PyInt

type Output = Bound<'py, <NonZero<usize> as IntoPyObject<'py>>::Target>

type Error = Infallible

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

fn type_output() -> TypeInfo

impl<'py> IntoPyObject<'py> for Duration

const OUTPUT_TYPE: TypeHint = PyDelta::TYPE_HINT

type Target = PyDelta

type Output = Bound<'py, <TimeDelta as IntoPyObject<'py>>::Target>

type Error = PyErr

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

impl<'py> IntoPyObject<'py> for BigDecimal

type Target = PyAny

type Output = Bound<'py, <BigDecimal as IntoPyObject<'py>>::Target>

type Error = PyErr

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

impl<'py> IntoPyObject<'py> for Bytes

type Target = PyBytes

type Output = Bound<'py, <Bytes as IntoPyObject<'py>>::Target>

type Error = PyErr

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

impl<'py> IntoPyObject<'py> for Date

type Target = PyDate

type Output = Bound<'py, <Date as IntoPyObject<'py>>::Target>

type Error = PyErr

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

impl<'py> IntoPyObject<'py> for Date

type Target = PyDate

type Output = Bound<'py, <Date as IntoPyObject<'py>>::Target>

type Error = PyErr

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

impl<'py> IntoPyObject<'py> for DateTime

type Target = PyDateTime

type Output = Bound<'py, <DateTime as IntoPyObject<'py>>::Target>

type Error = PyErr

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

impl<'py> IntoPyObject<'py> for Decimal

type Target = PyAny

type Output = Bound<'py, <Decimal as IntoPyObject<'py>>::Target>

type Error = PyErr

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

impl<'py> IntoPyObject<'py> for Duration

type Target = PyDelta

type Output = Bound<'py, <Duration as IntoPyObject<'py>>::Target>

type Error = PyErr

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

impl<'py> IntoPyObject<'py> for ISOWeekDate

type Target = PyDate

type Output = Bound<'py, <ISOWeekDate as IntoPyObject<'py>>::Target>

type Error = PyErr

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

impl<'py> IntoPyObject<'py> for NotNan<f32>

type Target = PyFloat

type Output = Bound<'py, <NotNan<f32> as IntoPyObject<'py>>::Target>

type Error = Infallible

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

impl<'py> IntoPyObject<'py> for NotNan<f64>

type Target = PyFloat

type Output = Bound<'py, <NotNan<f64> as IntoPyObject<'py>>::Target>

type Error = Infallible

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

impl<'py> IntoPyObject<'py> for Offset

type Target = PyTzInfo

type Output = Bound<'py, <Offset as IntoPyObject<'py>>::Target>

type Error = PyErr

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

impl<'py> IntoPyObject<'py> for OffsetDateTime

type Target = PyDateTime

type Output = Bound<'py, <OffsetDateTime as IntoPyObject<'py>>::Target>

type Error = PyErr

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

impl<'py> IntoPyObject<'py> for OrderedFloat<f32>

type Target = PyFloat

type Output = Bound<'py, <OrderedFloat<f32> as IntoPyObject<'py>>::Target>

type Error = Infallible

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

impl<'py> IntoPyObject<'py> for OrderedFloat<f64>

type Target = PyFloat

type Output = Bound<'py, <OrderedFloat<f64> as IntoPyObject<'py>>::Target>

type Error = Infallible

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

impl<'py> IntoPyObject<'py> for PrimitiveDateTime

type Target = PyDateTime

type Output = Bound<'py, <PrimitiveDateTime as IntoPyObject<'py>>::Target>

type Error = PyErr

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

impl<'py> IntoPyObject<'py> for SignedDuration

type Target = PyDelta

type Output = Bound<'py, <SignedDuration as IntoPyObject<'py>>::Target>

type Error = PyErr

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

impl<'py> IntoPyObject<'py> for Time

type Target = PyTime

type Output = Bound<'py, <Time as IntoPyObject<'py>>::Target>

type Error = PyErr

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

impl<'py> IntoPyObject<'py> for Time

type Target = PyTime

type Output = Bound<'py, <Time as IntoPyObject<'py>>::Target>

type Error = PyErr

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

impl<'py> IntoPyObject<'py> for TimeZone

type Target = PyTzInfo

type Output = Bound<'py, <TimeZone as IntoPyObject<'py>>::Target>

type Error = PyErr

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

impl<'py> IntoPyObject<'py> for Timestamp

type Target = PyDateTime

type Output = Bound<'py, <Timestamp as IntoPyObject<'py>>::Target>

type Error = PyErr

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

impl<'py> IntoPyObject<'py> for Tz

const OUTPUT_TYPE: TypeHint = PyTzInfo::TYPE_HINT

type Target = PyTzInfo

type Output = Bound<'py, <Tz as IntoPyObject<'py>>::Target>

type Error = PyErr

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

impl<'py> IntoPyObject<'py> for UtcDateTime

type Target = PyDateTime

type Output = Bound<'py, <UtcDateTime as IntoPyObject<'py>>::Target>

type Error = PyErr

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

impl<'py> IntoPyObject<'py> for UtcOffset

type Target = PyTzInfo

type Output = Bound<'py, <UtcOffset as IntoPyObject<'py>>::Target>

type Error = PyErr

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

impl<'py> IntoPyObject<'py> for Zoned

type Target = PyDateTime

type Output = Bound<'py, <Zoned as IntoPyObject<'py>>::Target>

type Error = PyErr

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

impl<'py, A> IntoPyObject<'py> for SmallVec<A>

where A: Array, A::Item: IntoPyObject<'py>,

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

Turns [SmallVec<u8>] into PyBytes, all other Ts will be turned into a PyList

const OUTPUT_TYPE: TypeHint = <A::Item>::SEQUENCE_OUTPUT_TYPE

type Target = PyAny

type Output = Bound<'py, <SmallVec<A> as IntoPyObject<'py>>::Target>

type Error = PyErr

fn type_output() -> TypeInfo

impl<'py, K> IntoPyObject<'py> for BTreeSet<K>

where K: IntoPyObject<'py> + Ord,

const OUTPUT_TYPE: TypeHint

type Target = PySet

type Output = Bound<'py, <BTreeSet<K> as IntoPyObject<'py>>::Target>

type Error = PyErr

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

fn type_output() -> TypeInfo

impl<'py, K, H> IntoPyObject<'py> for HashSet<K, H>

where K: IntoPyObject<'py> + Eq + Hash, H: BuildHasher,

type Target = PySet

type Output = Bound<'py, <HashSet<K, H> as IntoPyObject<'py>>::Target>

type Error = PyErr

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

impl<'py, K, S> IntoPyObject<'py> for HashSet<K, S>

where K: IntoPyObject<'py> + Eq + Hash, S: BuildHasher + Default,

const OUTPUT_TYPE: TypeHint

type Target = PySet

type Output = Bound<'py, <HashSet<K, S> as IntoPyObject<'py>>::Target>

type Error = PyErr

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

fn type_output() -> TypeInfo

impl<'py, K, V> IntoPyObject<'py> for BTreeMap<K, V>

where K: IntoPyObject<'py> + Eq, V: IntoPyObject<'py>,

const OUTPUT_TYPE: TypeHint

type Target = PyDict

type Output = Bound<'py, <BTreeMap<K, V> as IntoPyObject<'py>>::Target>

type Error = PyErr

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

fn type_output() -> TypeInfo

impl<'py, K, V, H> IntoPyObject<'py> for HashMap<K, V, H>

where K: IntoPyObject<'py> + Eq + Hash, V: IntoPyObject<'py>, H: BuildHasher,

const OUTPUT_TYPE: TypeHint

type Target = PyDict

type Output = Bound<'py, <HashMap<K, V, H> as IntoPyObject<'py>>::Target>

type Error = PyErr

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

fn type_output() -> TypeInfo

impl<'py, K, V, H> IntoPyObject<'py> for HashMap<K, V, H>

where K: IntoPyObject<'py> + Eq + Hash, V: IntoPyObject<'py>, H: BuildHasher,

type Target = PyDict

type Output = Bound<'py, <HashMap<K, V, H> as IntoPyObject<'py>>::Target>

type Error = PyErr

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

impl<'py, K, V, H> IntoPyObject<'py> for IndexMap<K, V, H>

where K: IntoPyObject<'py> + Eq + Hash, V: IntoPyObject<'py>, H: BuildHasher,

type Target = PyDict

type Output = Bound<'py, <IndexMap<K, V, H> as IntoPyObject<'py>>::Target>

type Error = PyErr

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

impl<'py, L, R> IntoPyObject<'py> for Either<L, R>

where L: IntoPyObject<'py>, R: IntoPyObject<'py>,

type Target = PyAny

type Output = Bound<'py, <Either<L, R> as IntoPyObject<'py>>::Target>

type Error = PyErr

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

impl<'py, T0> IntoPyObject<'py> for (T0,)

where T0: IntoPyObject<'py>,

const OUTPUT_TYPE: TypeHint

type Target = PyTuple

type Output = Bound<'py, <(T0,) as IntoPyObject<'py>>::Target>

type Error = PyErr

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

fn type_output() -> TypeInfo

impl<'py, T0, T1> IntoPyObject<'py> for (T0, T1)

where T0: IntoPyObject<'py>, T1: IntoPyObject<'py>,

const OUTPUT_TYPE: TypeHint

type Target = PyTuple

type Output = Bound<'py, <(T0, T1) as IntoPyObject<'py>>::Target>

type Error = PyErr

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

fn type_output() -> TypeInfo

impl<'py, T0, T1, T2> IntoPyObject<'py> for (T0, T1, T2)

where T0: IntoPyObject<'py>, T1: IntoPyObject<'py>, T2: IntoPyObject<'py>,

const OUTPUT_TYPE: TypeHint

type Target = PyTuple

type Output = Bound<'py, <(T0, T1, T2) as IntoPyObject<'py>>::Target>

type Error = PyErr

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

fn type_output() -> TypeInfo

impl<'py, T0, T1, T2, T3> IntoPyObject<'py> for (T0, T1, T2, T3)

where T0: IntoPyObject<'py>, T1: IntoPyObject<'py>, T2: IntoPyObject<'py>, T3: IntoPyObject<'py>,

const OUTPUT_TYPE: TypeHint

type Target = PyTuple

type Output = Bound<'py, <(T0, T1, T2, T3) as IntoPyObject<'py>>::Target>

type Error = PyErr

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

fn type_output() -> TypeInfo

impl<'py, T0, T1, T2, T3, T4> IntoPyObject<'py> for (T0, T1, T2, T3, T4)

where T0: IntoPyObject<'py>, T1: IntoPyObject<'py>, T2: IntoPyObject<'py>, T3: IntoPyObject<'py>, T4: IntoPyObject<'py>,

const OUTPUT_TYPE: TypeHint

type Target = PyTuple

type Output = Bound<'py, <(T0, T1, T2, T3, T4) as IntoPyObject<'py>>::Target>

type Error = PyErr

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

fn type_output() -> TypeInfo

impl<'py, T0, T1, T2, T3, T4, T5> IntoPyObject<'py> for (T0, T1, T2, T3, T4, T5)

where T0: IntoPyObject<'py>, T1: IntoPyObject<'py>, T2: IntoPyObject<'py>, T3: IntoPyObject<'py>, T4: IntoPyObject<'py>, T5: IntoPyObject<'py>,

const OUTPUT_TYPE: TypeHint

type Target = PyTuple

type Output = Bound<'py, <(T0, T1, T2, T3, T4, T5) as IntoPyObject<'py>>::Target>

type Error = PyErr

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

fn type_output() -> TypeInfo

impl<'py, T0, T1, T2, T3, T4, T5, T6> IntoPyObject<'py> for (T0, T1, T2, T3, T4, T5, T6)

where T0: IntoPyObject<'py>, T1: IntoPyObject<'py>, T2: IntoPyObject<'py>, T3: IntoPyObject<'py>, T4: IntoPyObject<'py>, T5: IntoPyObject<'py>, T6: IntoPyObject<'py>,

const OUTPUT_TYPE: TypeHint

type Target = PyTuple

type Output = Bound<'py, <(T0, T1, T2, T3, T4, T5, T6) as IntoPyObject<'py>>::Target>

type Error = PyErr

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

fn type_output() -> TypeInfo

impl<'py, T0, T1, T2, T3, T4, T5, T6, T7> IntoPyObject<'py> for (T0, T1, T2, T3, T4, T5, T6, T7)

where T0: IntoPyObject<'py>, T1: IntoPyObject<'py>, T2: IntoPyObject<'py>, T3: IntoPyObject<'py>, T4: IntoPyObject<'py>, T5: IntoPyObject<'py>, T6: IntoPyObject<'py>, T7: IntoPyObject<'py>,

const OUTPUT_TYPE: TypeHint

type Target = PyTuple

type Output = Bound<'py, <(T0, T1, T2, T3, T4, T5, T6, T7) as IntoPyObject<'py>>::Target>

type Error = PyErr

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

fn type_output() -> TypeInfo

impl<'py, T0, T1, T2, T3, T4, T5, T6, T7, T8> IntoPyObject<'py> for (T0, T1, T2, T3, T4, T5, T6, T7, T8)

where T0: IntoPyObject<'py>, T1: IntoPyObject<'py>, T2: IntoPyObject<'py>, T3: IntoPyObject<'py>, T4: IntoPyObject<'py>, T5: IntoPyObject<'py>, T6: IntoPyObject<'py>, T7: IntoPyObject<'py>, T8: IntoPyObject<'py>,

const OUTPUT_TYPE: TypeHint

type Target = PyTuple

type Output = Bound<'py, <(T0, T1, T2, T3, T4, T5, T6, T7, T8) as IntoPyObject<'py>>::Target>

type Error = PyErr

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

fn type_output() -> TypeInfo

impl<'py, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> IntoPyObject<'py> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)

where T0: IntoPyObject<'py>, T1: IntoPyObject<'py>, T2: IntoPyObject<'py>, T3: IntoPyObject<'py>, T4: IntoPyObject<'py>, T5: IntoPyObject<'py>, T6: IntoPyObject<'py>, T7: IntoPyObject<'py>, T8: IntoPyObject<'py>, T9: IntoPyObject<'py>,

const OUTPUT_TYPE: TypeHint

type Target = PyTuple

type Output = Bound<'py, <(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) as IntoPyObject<'py>>::Target>

type Error = PyErr

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

fn type_output() -> TypeInfo

impl<'py, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> IntoPyObject<'py> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)

where T0: IntoPyObject<'py>, T1: IntoPyObject<'py>, T2: IntoPyObject<'py>, T3: IntoPyObject<'py>, T4: IntoPyObject<'py>, T5: IntoPyObject<'py>, T6: IntoPyObject<'py>, T7: IntoPyObject<'py>, T8: IntoPyObject<'py>, T9: IntoPyObject<'py>, T10: IntoPyObject<'py>,

const OUTPUT_TYPE: TypeHint

type Target = PyTuple

type Output = Bound<'py, <(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) as IntoPyObject<'py>>::Target>

type Error = PyErr

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

fn type_output() -> TypeInfo

impl<'py, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> IntoPyObject<'py> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)

where T0: IntoPyObject<'py>, T1: IntoPyObject<'py>, T2: IntoPyObject<'py>, T3: IntoPyObject<'py>, T4: IntoPyObject<'py>, T5: IntoPyObject<'py>, T6: IntoPyObject<'py>, T7: IntoPyObject<'py>, T8: IntoPyObject<'py>, T9: IntoPyObject<'py>, T10: IntoPyObject<'py>, T11: IntoPyObject<'py>,

const OUTPUT_TYPE: TypeHint

type Target = PyTuple

type Output = Bound<'py, <(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) as IntoPyObject<'py>>::Target>

type Error = PyErr

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

fn type_output() -> TypeInfo

impl<'py, T> IntoPyObject<'py> for Cow<'_, [T]>

where T: Clone, for<'a> &'a T: IntoPyObject<'py>,

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

Turns Cow<[u8]> into PyBytes, all other Ts will be turned into a PyList

const OUTPUT_TYPE: TypeHint = <&T>::SEQUENCE_OUTPUT_TYPE

type Target = PyAny

type Output = Bound<'py, <Cow<'_, [T]> as IntoPyObject<'py>>::Target>

type Error = PyErr

impl<'py, T> IntoPyObject<'py> for Option<T>

where T: IntoPyObject<'py>,

const OUTPUT_TYPE: TypeHint

type Target = PyAny

type Output = Bound<'py, <Option<T> as IntoPyObject<'py>>::Target>

type Error = <T as IntoPyObject<'py>>::Error

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

impl<'py, T> IntoPyObject<'py> for Vec<T>

where T: IntoPyObject<'py>,

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

Turns Vec<u8> into PyBytes, all other Ts will be turned into a PyList

const OUTPUT_TYPE: TypeHint = T::SEQUENCE_OUTPUT_TYPE

type Target = PyAny

type Output = Bound<'py, <Vec<T> as IntoPyObject<'py>>::Target>

type Error = PyErr

fn type_output() -> TypeInfo

impl<'py, T, const N: usize> IntoPyObject<'py> for [T; N]

where T: IntoPyObject<'py>,

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

Turns [u8; N] into PyBytes, all other Ts will be turned into a PyList

const OUTPUT_TYPE: TypeHint = T::SEQUENCE_OUTPUT_TYPE

type Target = PyAny

type Output = Bound<'py, <[T; N] as IntoPyObject<'py>>::Target>

type Error = PyErr

impl<'py, T: Copy + IntoPyObject<'py>> IntoPyObject<'py> for &Cell<T>

const OUTPUT_TYPE: TypeHint = T::OUTPUT_TYPE

type Target = <T as IntoPyObject<'py>>::Target

type Output = <T as IntoPyObject<'py>>::Output

type Error = <T as IntoPyObject<'py>>::Error

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

impl<'py, T: Copy + IntoPyObject<'py>> IntoPyObject<'py> for Cell<T>

const OUTPUT_TYPE: TypeHint = T::OUTPUT_TYPE

type Target = <T as IntoPyObject<'py>>::Target

type Output = <T as IntoPyObject<'py>>::Output

type Error = <T as IntoPyObject<'py>>::Error

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

impl<'py, Tz> IntoPyObject<'py> for &DateTime<Tz>

where Tz: IntoPyObject<'py> + TimeZone,

const OUTPUT_TYPE: TypeHint = PyDateTime::TYPE_HINT

type Target = PyDateTime

type Output = Bound<'py, <&DateTime<Tz> as IntoPyObject<'py>>::Target>

type Error = PyErr

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

impl<'py, Tz> IntoPyObject<'py> for DateTime<Tz>

where Tz: IntoPyObject<'py> + TimeZone,

const OUTPUT_TYPE: TypeHint = <&DateTime<Tz>>::OUTPUT_TYPE

type Target = PyDateTime

type Output = Bound<'py, <DateTime<Tz> as IntoPyObject<'py>>::Target>

type Error = PyErr

fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error>

Implementors

impl<'a, 'py, T: PyClass> IntoPyObject<'py> for &'a PyRef<'py, T>

const OUTPUT_TYPE: TypeHint = T::TYPE_HINT

type Target = T

type Output = Borrowed<'a, 'py, T>

type Error = Infallible

impl<'a, 'py, T: PyClass> IntoPyObject<'py> for &PyClassGuard<'a, T>

const OUTPUT_TYPE: TypeHint = T::TYPE_HINT

type Target = T

type Output = Borrowed<'a, 'py, T>

type Error = Infallible

impl<'a, 'py, T: PyClass> IntoPyObject<'py> for PyClassGuard<'a, T>

const OUTPUT_TYPE: TypeHint = T::TYPE_HINT

type Target = T

type Output = Borrowed<'a, 'py, T>

type Error = Infallible

impl<'a, 'py, T: PyClass<Frozen = False>> IntoPyObject<'py> for &'a PyRefMut<'py, T>

const OUTPUT_TYPE: TypeHint = T::TYPE_HINT

type Target = T

type Output = Borrowed<'a, 'py, T>

type Error = Infallible

impl<'a, 'py, T: PyClass<Frozen = False>> IntoPyObject<'py> for &PyClassGuardMut<'a, T>

const OUTPUT_TYPE: TypeHint = T::TYPE_HINT

type Target = T

type Output = Borrowed<'a, 'py, T>

type Error = Infallible

impl<'a, 'py, T: PyClass<Frozen = False>> IntoPyObject<'py> for PyClassGuardMut<'a, T>

const OUTPUT_TYPE: TypeHint = T::TYPE_HINT

type Target = T

type Output = Borrowed<'a, 'py, T>

type Error = Infallible

impl<'a, 'py, T: PyTypeCheck> IntoPyObject<'py> for &'a Bound<'py, T>

const OUTPUT_TYPE: TypeHint = T::TYPE_HINT

type Target = T

type Output = Borrowed<'a, 'py, <&'a Bound<'py, T> as IntoPyObject<'py>>::Target>

type Error = Infallible

impl<'a, 'py, T: PyTypeCheck> IntoPyObject<'py> for &'a Py<T>

const OUTPUT_TYPE: TypeHint = T::TYPE_HINT

type Target = T

type Output = Borrowed<'a, 'py, <&'a Py<T> as IntoPyObject<'py>>::Target>

type Error = Infallible

impl<'a, 'py, T: PyTypeCheck> IntoPyObject<'py> for &Borrowed<'a, 'py, T>

const OUTPUT_TYPE: TypeHint = T::TYPE_HINT

type Target = T

type Output = Borrowed<'a, 'py, <&Borrowed<'a, 'py, T> as IntoPyObject<'py>>::Target>

type Error = Infallible

impl<'a, 'py, T: PyTypeCheck> IntoPyObject<'py> for Borrowed<'a, 'py, T>

const OUTPUT_TYPE: TypeHint = T::TYPE_HINT

type Target = T

type Output = Borrowed<'a, 'py, <Borrowed<'a, 'py, T> as IntoPyObject<'py>>::Target>

type Error = Infallible

impl<'py> IntoPyObject<'py> for &PyBackedBytes

const OUTPUT_TYPE: TypeHint = PyBytes::TYPE_HINT

type Target = PyBytes

type Output = Bound<'py, <&PyBackedBytes as IntoPyObject<'py>>::Target>

type Error = Infallible

impl<'py> IntoPyObject<'py> for &PyBackedStr

const OUTPUT_TYPE: TypeHint = PyString::TYPE_HINT

type Target = PyString

type Output = Bound<'py, <&PyBackedStr as IntoPyObject<'py>>::Target>

type Error = Infallible

impl<'py> IntoPyObject<'py> for &PyErr

const OUTPUT_TYPE: TypeHint = PyErr::OUTPUT_TYPE

type Target = PyBaseException

type Output = Bound<'py, <&PyErr as IntoPyObject<'py>>::Target>

type Error = Infallible

impl<'py> IntoPyObject<'py> for &PySliceIndices

const OUTPUT_TYPE: TypeHint = PySlice::TYPE_HINT

type Target = PySlice

type Output = Bound<'py, <&PySliceIndices as IntoPyObject<'py>>::Target>

type Error = Infallible

impl<'py> IntoPyObject<'py> for Coroutine

const OUTPUT_TYPE: TypeHint = <Coroutine as crate::PyTypeInfo>::TYPE_HINT

type Target = Coroutine

type Output = Bound<'py, <Coroutine as IntoPyObject<'py>>::Target>

type Error = PyErr

impl<'py> IntoPyObject<'py> for PyBackedBytes

const OUTPUT_TYPE: TypeHint = PyBytes::TYPE_HINT

type Target = PyBytes

type Output = Bound<'py, <PyBackedBytes as IntoPyObject<'py>>::Target>

type Error = Infallible

impl<'py> IntoPyObject<'py> for PyBackedStr

const OUTPUT_TYPE: TypeHint = PyString::TYPE_HINT

type Target = PyString

type Output = Bound<'py, <PyBackedStr as IntoPyObject<'py>>::Target>

type Error = Infallible

impl<'py> IntoPyObject<'py> for PyErr

const OUTPUT_TYPE: TypeHint = PyBaseException::TYPE_HINT

type Target = PyBaseException

type Output = Bound<'py, <PyErr as IntoPyObject<'py>>::Target>

type Error = Infallible

impl<'py> IntoPyObject<'py> for PySliceIndices

const OUTPUT_TYPE: TypeHint = PySlice::TYPE_HINT

type Target = PySlice

type Output = Bound<'py, <PySliceIndices as IntoPyObject<'py>>::Target>

type Error = Infallible

impl<'py, T: PyClass> IntoPyObject<'py> for PyRef<'py, T>

const OUTPUT_TYPE: TypeHint = T::TYPE_HINT

type Target = T

type Output = Bound<'py, T>

type Error = Infallible

impl<'py, T: PyClass<Frozen = False>> IntoPyObject<'py> for PyRefMut<'py, T>

const OUTPUT_TYPE: TypeHint = T::TYPE_HINT

type Target = T

type Output = Bound<'py, T>

type Error = Infallible

impl<'py, T: PyTypeCheck> IntoPyObject<'py> for Bound<'py, T>

const OUTPUT_TYPE: TypeHint = T::TYPE_HINT

type Target = T

type Output = Bound<'py, <Bound<'py, T> as IntoPyObject<'py>>::Target>

type Error = Infallible

impl<'py, T: PyTypeCheck> IntoPyObject<'py> for Py<T>

const OUTPUT_TYPE: TypeHint = T::TYPE_HINT

type Target = T

type Output = Bound<'py, <Py<T> as IntoPyObject<'py>>::Target>

type Error = Infallible