Trait IntoPyObject 

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

    const OUTPUT_TYPE: PyStaticExpr = _;

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

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: PyStaticExpr = _

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.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementations on Foreign Types

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

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

const OUTPUT_TYPE: PyStaticExpr = <&[A::Item]>::OUTPUT_TYPE

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>

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

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

const OUTPUT_TYPE: PyStaticExpr

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>

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

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

const OUTPUT_TYPE: PyStaticExpr

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, H> IntoPyObject<'py> for &'a HashSet<K, H>

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

const OUTPUT_TYPE: PyStaticExpr

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: PyStaticExpr

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>

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: PyStaticExpr

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 HashMap<K, V, H>

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

const OUTPUT_TYPE: PyStaticExpr

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,

const OUTPUT_TYPE: PyStaticExpr

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

const OUTPUT_TYPE: PyStaticExpr

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: PyStaticExpr

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>

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

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

const OUTPUT_TYPE: PyStaticExpr

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>

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: PyStaticExpr

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>

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: PyStaticExpr

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>

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: PyStaticExpr

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>

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: PyStaticExpr

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>

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: PyStaticExpr

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>

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: PyStaticExpr

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>

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: PyStaticExpr

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>

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: PyStaticExpr

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>

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: PyStaticExpr

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>

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: PyStaticExpr

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>

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

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

const OUTPUT_TYPE: PyStaticExpr = 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: PyStaticExpr = <&T>::SEQUENCE_OUTPUT_TYPE

type Target = PyAny

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

type Error = PyErr

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

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

const OUTPUT_TYPE: PyStaticExpr = <&[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>

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

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

const OUTPUT_TYPE: PyStaticExpr

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: PyStaticExpr = <&[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: PyStaticExpr = 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>

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

const OUTPUT_TYPE: PyStaticExpr = <&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: PyStaticExpr = <&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: PyStaticExpr = 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>

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

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

type Target = PyString

type Output = Bound<'py, <&Cow<'_, CStr> 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<'_, OsStr>

const OUTPUT_TYPE: PyStaticExpr = <&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: PyStaticExpr = <&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: PyStaticExpr = 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: PyStaticExpr = 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>

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

const OUTPUT_TYPE: PyStaticExpr = 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>

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

const OUTPUT_TYPE: PyStaticExpr = 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>

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

const OUTPUT_TYPE: PyStaticExpr = 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>

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

const OUTPUT_TYPE: PyStaticExpr = 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>

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

const OUTPUT_TYPE: PyStaticExpr = 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>

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

const OUTPUT_TYPE: PyStaticExpr = 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>

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

const OUTPUT_TYPE: PyStaticExpr = 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>

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

const OUTPUT_TYPE: PyStaticExpr = 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>

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

const OUTPUT_TYPE: PyStaticExpr = 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>

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

const OUTPUT_TYPE: PyStaticExpr = 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>

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

const OUTPUT_TYPE: PyStaticExpr = 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>

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

const OUTPUT_TYPE: PyStaticExpr = 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>

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

const OUTPUT_TYPE: PyStaticExpr = 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>

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

const OUTPUT_TYPE: PyStaticExpr = 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: PyStaticExpr = 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>

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

const OUTPUT_TYPE: PyStaticExpr = 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>

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

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

type Target = PyString

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

type Error = PyErr

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

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

const OUTPUT_TYPE: PyStaticExpr = 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>

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

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

type Target = PyString

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

type Error = PyErr

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

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

const OUTPUT_TYPE: PyStaticExpr = 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: PyStaticExpr = 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: PyStaticExpr = 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: PyStaticExpr = 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: PyStaticExpr = <&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: PyStaticExpr

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: PyStaticExpr = <&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: PyStaticExpr = 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: PyStaticExpr = 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: PyStaticExpr = 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: PyStaticExpr = 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: PyStaticExpr = 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: PyStaticExpr = 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: PyStaticExpr = 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

const OUTPUT_TYPE: PyStaticExpr = PyInt::TYPE_HINT

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

const OUTPUT_TYPE: PyStaticExpr = PyInt::TYPE_HINT

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>

const OUTPUT_TYPE: PyStaticExpr = Complex<f32>::OUTPUT_TYPE

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>

const OUTPUT_TYPE: PyStaticExpr = Complex<f64>::OUTPUT_TYPE

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>

const OUTPUT_TYPE: PyStaticExpr

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>

const OUTPUT_TYPE: PyStaticExpr

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>

const OUTPUT_TYPE: PyStaticExpr

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>

const OUTPUT_TYPE: PyStaticExpr

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>

const OUTPUT_TYPE: PyStaticExpr

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>

const OUTPUT_TYPE: PyStaticExpr

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 &NonNilUuid

const OUTPUT_TYPE: PyStaticExpr = NonNilUuid::OUTPUT_TYPE

type Target = PyAny

type Output = Bound<'py, <&NonNilUuid 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

const OUTPUT_TYPE: PyStaticExpr = Uuid::OUTPUT_TYPE

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: PyStaticExpr = 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>

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

const OUTPUT_TYPE: PyStaticExpr = 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>

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

const OUTPUT_TYPE: PyStaticExpr = 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>

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

const OUTPUT_TYPE: PyStaticExpr = 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>

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

const OUTPUT_TYPE: PyStaticExpr = 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>

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

const OUTPUT_TYPE: PyStaticExpr = 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>

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

const OUTPUT_TYPE: PyStaticExpr = 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>

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

const OUTPUT_TYPE: PyStaticExpr = 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>

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

const OUTPUT_TYPE: PyStaticExpr = 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>

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

const OUTPUT_TYPE: PyStaticExpr = 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>

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

const OUTPUT_TYPE: PyStaticExpr = 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>

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

const OUTPUT_TYPE: PyStaticExpr = 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>

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

const OUTPUT_TYPE: PyStaticExpr = 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

const OUTPUT_TYPE: PyStaticExpr = PyBytes::TYPE_HINT

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

const OUTPUT_TYPE: PyStaticExpr = Date::OUTPUT_TYPE

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

const OUTPUT_TYPE: PyStaticExpr = Date::OUTPUT_TYPE

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

const OUTPUT_TYPE: PyStaticExpr = DateTime::OUTPUT_TYPE

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

const OUTPUT_TYPE: PyStaticExpr = Decimal::OUTPUT_TYPE

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

const OUTPUT_TYPE: PyStaticExpr = 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 &ISOWeekDate

const OUTPUT_TYPE: PyStaticExpr = ISOWeekDate::OUTPUT_TYPE

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>

const OUTPUT_TYPE: PyStaticExpr = NotNan<f32>::OUTPUT_TYPE

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>

const OUTPUT_TYPE: PyStaticExpr = NotNan<f64>::OUTPUT_TYPE

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

const OUTPUT_TYPE: PyStaticExpr = Offset::OUTPUT_TYPE

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

const OUTPUT_TYPE: PyStaticExpr = OffsetDateTime::OUTPUT_TYPE

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>

const OUTPUT_TYPE: PyStaticExpr = OrderedFloat<f32>::OUTPUT_TYPE

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>

const OUTPUT_TYPE: PyStaticExpr = OrderedFloat<f64>::OUTPUT_TYPE

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

const OUTPUT_TYPE: PyStaticExpr = PrimitiveDateTime::OUTPUT_TYPE

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

const OUTPUT_TYPE: PyStaticExpr = SignedDuration::OUTPUT_TYPE

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

const OUTPUT_TYPE: PyStaticExpr = Time::OUTPUT_TYPE

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

const OUTPUT_TYPE: PyStaticExpr = Time::OUTPUT_TYPE

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

const OUTPUT_TYPE: PyStaticExpr = PyTzInfo::TYPE_HINT

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

const OUTPUT_TYPE: PyStaticExpr = Timestamp::OUTPUT_TYPE

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: PyStaticExpr = 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

const OUTPUT_TYPE: PyStaticExpr = UtcDateTime::OUTPUT_TYPE

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

const OUTPUT_TYPE: PyStaticExpr = UtcOffset::OUTPUT_TYPE

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

const OUTPUT_TYPE: PyStaticExpr = PyDateTime::TYPE_HINT

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: PyStaticExpr = 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>

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

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

type Target = PyString

type Output = Bound<'py, <Cow<'_, CStr> 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<'_, OsStr>

const OUTPUT_TYPE: PyStaticExpr = <&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: PyStaticExpr = <&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: PyStaticExpr

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: PyStaticExpr = 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>

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

const OUTPUT_TYPE: PyStaticExpr = 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>

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

const OUTPUT_TYPE: PyStaticExpr = 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>

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

const OUTPUT_TYPE: PyStaticExpr = 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>

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

const OUTPUT_TYPE: PyStaticExpr = 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>

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

const OUTPUT_TYPE: PyStaticExpr = 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>

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

const OUTPUT_TYPE: PyStaticExpr = 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>

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

const OUTPUT_TYPE: PyStaticExpr = 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>

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

const OUTPUT_TYPE: PyStaticExpr = 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>

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

const OUTPUT_TYPE: PyStaticExpr = 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>

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

const OUTPUT_TYPE: PyStaticExpr = 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>

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

const OUTPUT_TYPE: PyStaticExpr = 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>

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

const OUTPUT_TYPE: PyStaticExpr = 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>

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

const OUTPUT_TYPE: PyStaticExpr = 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>

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

const OUTPUT_TYPE: PyStaticExpr = 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>

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

const OUTPUT_TYPE: PyStaticExpr

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: PyStaticExpr = 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>

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

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

type Target = PyString

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

type Error = PyErr

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

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

const OUTPUT_TYPE: PyStaticExpr = 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>

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

const OUTPUT_TYPE: PyStaticExpr

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: PyStaticExpr

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: PyStaticExpr = 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: PyStaticExpr = <&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: PyStaticExpr = <&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: PyStaticExpr = 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: PyStaticExpr = 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: PyStaticExpr = 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: PyStaticExpr = 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: PyStaticExpr

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: PyStaticExpr

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: PyStaticExpr

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

const OUTPUT_TYPE: PyStaticExpr = <&BigInt>::OUTPUT_TYPE

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

const OUTPUT_TYPE: PyStaticExpr = <&BigUint>::OUTPUT_TYPE

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>

const OUTPUT_TYPE: PyStaticExpr

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>

const OUTPUT_TYPE: PyStaticExpr

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>

const OUTPUT_TYPE: PyStaticExpr = <&Ratio<i8>>::OUTPUT_TYPE

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>

const OUTPUT_TYPE: PyStaticExpr = <&Ratio<i16>>::OUTPUT_TYPE

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>

const OUTPUT_TYPE: PyStaticExpr = <&Ratio<i32>>::OUTPUT_TYPE

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>

const OUTPUT_TYPE: PyStaticExpr = <&Ratio<i64>>::OUTPUT_TYPE

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>

const OUTPUT_TYPE: PyStaticExpr = <&Ratio<isize>>::OUTPUT_TYPE

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>

const OUTPUT_TYPE: PyStaticExpr = <&Ratio<BigInt>>::OUTPUT_TYPE

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 NonNilUuid

const OUTPUT_TYPE: PyStaticExpr = Uuid::OUTPUT_TYPE

type Target = PyAny

type Output = Bound<'py, <NonNilUuid 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

const OUTPUT_TYPE: PyStaticExpr

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: PyStaticExpr = 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>

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

const OUTPUT_TYPE: PyStaticExpr = 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>

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

const OUTPUT_TYPE: PyStaticExpr = 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>

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

const OUTPUT_TYPE: PyStaticExpr = 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>

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

const OUTPUT_TYPE: PyStaticExpr = 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>

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

const OUTPUT_TYPE: PyStaticExpr = 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>

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

const OUTPUT_TYPE: PyStaticExpr = 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>

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

const OUTPUT_TYPE: PyStaticExpr = 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>

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

const OUTPUT_TYPE: PyStaticExpr = 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>

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

const OUTPUT_TYPE: PyStaticExpr = 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>

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

const OUTPUT_TYPE: PyStaticExpr = 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>

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

const OUTPUT_TYPE: PyStaticExpr = 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>

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

const OUTPUT_TYPE: PyStaticExpr = 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

const OUTPUT_TYPE: PyStaticExpr

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

const OUTPUT_TYPE: PyStaticExpr = PyBytes::TYPE_HINT

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

const OUTPUT_TYPE: PyStaticExpr = PyDate::TYPE_HINT

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

const OUTPUT_TYPE: PyStaticExpr = PyDate::TYPE_HINT

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

const OUTPUT_TYPE: PyStaticExpr = PyDateTime::TYPE_HINT

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

const OUTPUT_TYPE: PyStaticExpr

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

const OUTPUT_TYPE: PyStaticExpr = 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 ISOWeekDate

const OUTPUT_TYPE: PyStaticExpr = Date::OUTPUT_TYPE

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>

const OUTPUT_TYPE: PyStaticExpr = f32::OUTPUT_TYPE

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>

const OUTPUT_TYPE: PyStaticExpr = f64::OUTPUT_TYPE

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

const OUTPUT_TYPE: PyStaticExpr

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

const OUTPUT_TYPE: PyStaticExpr = PyDateTime::TYPE_HINT

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>

const OUTPUT_TYPE: PyStaticExpr = f32::OUTPUT_TYPE

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>

const OUTPUT_TYPE: PyStaticExpr = f64::OUTPUT_TYPE

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

const OUTPUT_TYPE: PyStaticExpr = PyDateTime::TYPE_HINT

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

const OUTPUT_TYPE: PyStaticExpr = PyDelta::TYPE_HINT

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

const OUTPUT_TYPE: PyStaticExpr = PyTime::TYPE_HINT

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

const OUTPUT_TYPE: PyStaticExpr = PyTime::TYPE_HINT

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

const OUTPUT_TYPE: PyStaticExpr = <&Self>::OUTPUT_TYPE

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

const OUTPUT_TYPE: PyStaticExpr = Zoned::OUTPUT_TYPE

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: PyStaticExpr

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

const OUTPUT_TYPE: PyStaticExpr = PyDateTime::TYPE_HINT

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

const OUTPUT_TYPE: PyStaticExpr

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

const OUTPUT_TYPE: PyStaticExpr = <&Self>::OUTPUT_TYPE

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: PyStaticExpr = <A::Item>::SEQUENCE_OUTPUT_TYPE

type Target = PyAny

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

type Error = PyErr

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

where K: IntoPyObject<'py> + Ord,

const OUTPUT_TYPE: PyStaticExpr

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>

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

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

const OUTPUT_TYPE: PyStaticExpr

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: PyStaticExpr

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>

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

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

const OUTPUT_TYPE: PyStaticExpr

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>

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: PyStaticExpr

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 HashMap<K, V, H>

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

const OUTPUT_TYPE: PyStaticExpr

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,

const OUTPUT_TYPE: PyStaticExpr

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

const OUTPUT_TYPE: PyStaticExpr

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: PyStaticExpr

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>

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

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

const OUTPUT_TYPE: PyStaticExpr

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>

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

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

const OUTPUT_TYPE: PyStaticExpr

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>

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: PyStaticExpr

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>

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: PyStaticExpr

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>

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: PyStaticExpr

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>

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: PyStaticExpr

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>

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: PyStaticExpr

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>

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: PyStaticExpr

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>

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: PyStaticExpr

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>

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: PyStaticExpr

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>

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: PyStaticExpr

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>

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: PyStaticExpr = <&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: PyStaticExpr

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: PyStaticExpr = T::SEQUENCE_OUTPUT_TYPE

type Target = PyAny

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

type Error = PyErr

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: PyStaticExpr = 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: PyStaticExpr = 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: PyStaticExpr = 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: PyStaticExpr = 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: PyStaticExpr = <&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: PyStaticExpr = 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: PyStaticExpr = 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: PyStaticExpr = 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: PyStaticExpr = 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: PyStaticExpr = 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: PyStaticExpr = 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: PyStaticExpr = 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: PyStaticExpr = 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: PyStaticExpr = 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: PyStaticExpr = 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: PyStaticExpr = 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: PyStaticExpr = 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: PyStaticExpr = 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: PyStaticExpr = 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: PyStaticExpr = <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: PyStaticExpr = 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: PyStaticExpr = 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: PyStaticExpr = 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: PyStaticExpr = 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: PyStaticExpr = 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: PyStaticExpr = 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: PyStaticExpr = 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: PyStaticExpr = T::TYPE_HINT

type Target = T

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

type Error = Infallible