fix more use of std

Author: Person-93

src/byteswriter.rs

@@ -212,7 +212,7 @@ impl std::io::Write for PyBytesWriter<'_> {
         self.buffer.write_all(buf)
     }
 
-    fn write_fmt(&mut self, args: std::fmt::Arguments<'_>) -> std::io::Result<()> {
+    fn write_fmt(&mut self, args: core::fmt::Arguments<'_>) -> std::io::Result<()> {
         self.buffer.write_fmt(args)
     }
 }

src/conversions/bigdecimal.rs

@@ -49,7 +49,7 @@
 //! assert d + 1 == value
 //! ```
 
-use std::str::FromStr;
+use core::str::FromStr;
 
 #[cfg(feature = "experimental-inspect")]
 use crate::inspect::PyStaticExpr;
@@ -121,7 +121,7 @@ mod test_bigdecimal {
     use super::*;
     use crate::types::dict::PyDictMethods;
     use crate::types::PyDict;
-    use std::ffi::CString;
+    use alloc::ffi::CString;
 
     use bigdecimal::{One, Zero};
     #[cfg(not(target_arch = "wasm32"))]

src/conversions/chrono.rs

@@ -635,7 +635,7 @@ fn warn_truncated_leap_second(obj: &Bound<'_, PyAny>) {
 
 #[cfg(not(Py_LIMITED_API))]
 fn py_date_to_naive_date(
-    py_date: impl std::ops::Deref<Target = impl PyDateAccess>,
+    py_date: impl core::ops::Deref<Target = impl PyDateAccess>,
 ) -> PyResult<NaiveDate> {
     NaiveDate::from_ymd_opt(
         py_date.get_year(),
@@ -657,7 +657,7 @@ fn py_date_to_naive_date(py_date: &Bound<'_, PyAny>) -> PyResult<NaiveDate> {
 
 #[cfg(not(Py_LIMITED_API))]
 fn py_time_to_naive_time(
-    py_time: impl std::ops::Deref<Target = impl PyTimeAccess>,
+    py_time: impl core::ops::Deref<Target = impl PyTimeAccess>,
 ) -> PyResult<NaiveTime> {
     NaiveTime::from_hms_micro_opt(
         py_time.get_hour().into(),
@@ -715,7 +715,8 @@ fn py_datetime_to_datetime_with_timezone<Tz: TimeZone>(
 mod tests {
     use super::*;
     use crate::{test_utils::assert_warnings, types::PyTuple, BoundObject};
-    use std::{cmp::Ordering, panic};
+    use core::cmp::Ordering;
+    use std::panic;
 
     #[test]
     // Only Python>=3.9 has the zoneinfo package
@@ -1312,8 +1313,8 @@ mod tests {
         use super::*;
         use crate::test_utils::CatchWarnings;
         use crate::types::IntoPyDict;
+        use alloc::ffi::CString;
         use proptest::prelude::*;
-        use std::ffi::CString;
 
         proptest! {
 

src/conversions/chrono_tz.rs

@@ -44,9 +44,9 @@ use crate::types::{any::PyAnyMethods, PyTzInfo};
 #[cfg(all(feature = "experimental-inspect", not(Py_3_9)))]
 use crate::PyTypeInfo;
 use crate::{intern, Borrowed, Bound, FromPyObject, PyAny, PyErr, Python};
+use alloc::borrow::Cow;
 use chrono_tz::Tz;
-use std::borrow::Cow;
-use std::str::FromStr;
+use core::str::FromStr;
 
 impl<'py> IntoPyObject<'py> for Tz {
     type Target = PyTzInfo;

src/conversions/either.rs

@@ -120,8 +120,8 @@ where
             // is not experimental, rather than the Rust type names.
             let err_msg = format!(
                 "failed to convert the value to 'Union[{}, {}]'",
-                std::any::type_name::<L>(),
-                std::any::type_name::<R>()
+                core::any::type_name::<L>(),
+                core::any::type_name::<R>()
             );
             Err(PyTypeError::new_err(err_msg))
         }
@@ -135,7 +135,7 @@ where
 
 #[cfg(test)]
 mod tests {
-    use std::borrow::Cow;
+    use alloc::borrow::Cow;
 
     use crate::exceptions::PyTypeError;
     use crate::{IntoPyObject, Python};

src/conversions/eyre.rs

@@ -63,7 +63,7 @@
 //! # Example: Using `eyre` in general
 //!
 //! Note that you don't need this feature to convert a [`PyErr`] into an [`eyre::Report`], because
-//! it can already convert anything that implements [`Error`](std::error::Error):
+//! it can already convert anything that implements [`Error`](core::error::Error):
 //!
 //! ```rust
 //! use pyo3::prelude::*;
@@ -137,8 +137,7 @@ mod tests {
     use eyre::{bail, eyre, Report, Result, WrapErr};
 
     fn f() -> Result<()> {
-        use std::io;
-        bail!(io::Error::new(io::ErrorKind::PermissionDenied, "oh no!"));
+        bail!("not int".parse::<u8>().unwrap_err())
     }
 
     fn g() -> Result<()> {

src/conversions/hashbrown.rs

@@ -28,7 +28,7 @@ use crate::{
 };
 #[cfg(feature = "experimental-inspect")]
 use crate::{type_hint_subscript, type_hint_union, PyTypeInfo};
-use std::hash;
+use core::hash;
 
 impl<'py, K, V, H> IntoPyObject<'py> for hashbrown::HashMap<K, V, H>
 where

src/conversions/indexmap.rs

@@ -94,7 +94,7 @@ use crate::types::*;
 #[cfg(feature = "experimental-inspect")]
 use crate::{type_hint_subscript, PyTypeInfo};
 use crate::{Borrowed, Bound, FromPyObject, PyErr, Python};
-use std::hash;
+use core::hash;
 
 impl<'py, K, V, H> IntoPyObject<'py> for indexmap::IndexMap<K, V, H>
 where

src/conversions/jiff.rs

@@ -55,12 +55,12 @@ use crate::types::{PyDateAccess, PyDeltaAccess, PyTimeAccess};
 use crate::{intern, Borrowed, Bound, FromPyObject, IntoPyObject, PyAny, PyErr, PyResult, Python};
 #[cfg(feature = "experimental-inspect")]
 use crate::{type_hint_identifier, PyTypeInfo};
+use alloc::borrow::Cow;
 use jiff::civil::{Date, DateTime, ISOWeekDate, Time};
 use jiff::tz::{Offset, TimeZone};
 use jiff::{SignedDuration, Span, Timestamp, Zoned};
 #[cfg(feature = "jiff-02")]
 use jiff_02 as jiff;
-use std::borrow::Cow;
 
 fn datetime_to_pydatetime<'py>(
     py: Python<'py>,
@@ -604,8 +604,8 @@ impl From<jiff::Error> for PyErr {
 mod tests {
     use super::*;
     use crate::{types::PyTuple, BoundObject};
+    use core::cmp::Ordering;
     use jiff::tz::Offset;
-    use std::cmp::Ordering;
 
     #[test]
     // Only Python>=3.9 has the zoneinfo package
@@ -860,7 +860,7 @@ mod tests {
     #[test]
     #[cfg(all(Py_3_9, not(windows)))]
     fn test_ambiguous_datetime_to_pyobject() {
-        use std::str::FromStr;
+        use core::str::FromStr;
         let dates = [
             Zoned::from_str("2020-10-24 23:00:00[UTC]").unwrap(),
             Zoned::from_str("2020-10-25 00:00:00[UTC]").unwrap(),
@@ -1069,22 +1069,22 @@ mod tests {
     mod proptests {
         use super::*;
         use crate::types::IntoPyDict;
+        use alloc::ffi::CString;
         use jiff::tz::TimeZoneTransition;
         use jiff::SpanRelativeTo;
         use proptest::prelude::*;
-        use std::ffi::CString;
 
         // This is to skip the test if we are creating an invalid date, like February 31.
         #[track_caller]
         fn try_date(year: i16, month: i8, day: i8) -> Result<Date, TestCaseError> {
-            let location = std::panic::Location::caller();
+            let location = core::panic::Location::caller();
             Date::new(year, month, day)
                 .map_err(|err| TestCaseError::reject(format!("{location}: {err:?}")))
         }
 
         #[track_caller]
         fn try_time(hour: i8, min: i8, sec: i8, micro: i32) -> Result<Time, TestCaseError> {
-            let location = std::panic::Location::caller();
+            let location = core::panic::Location::caller();
             Time::new(hour, min, sec, micro * 1000)
                 .map_err(|err| TestCaseError::reject(format!("{location}: {err:?}")))
         }
@@ -1102,7 +1102,7 @@ mod tests {
         ) -> Result<Zoned, TestCaseError> {
             let date = try_date(year, month, day)?;
             let time = try_time(hour, min, sec, micro)?;
-            let location = std::panic::Location::caller();
+            let location = core::panic::Location::caller();
             DateTime::from_parts(date, time)
                 .to_zoned(tz)
                 .map_err(|err| TestCaseError::reject(format!("{location}: {err:?}")))

src/conversions/num_bigint.rs

@@ -267,7 +267,7 @@ fn int_to_u32_vec<const SIGNED: bool>(long: &Bound<'_, PyInt>) -> PyResult<Vec<u
         flags |= ffi::Py_ASNATIVEBYTES_UNSIGNED_BUFFER | ffi::Py_ASNATIVEBYTES_REJECT_NEGATIVE;
     }
     let n_bytes =
-        unsafe { ffi::PyLong_AsNativeBytes(long.as_ptr().cast(), std::ptr::null_mut(), 0, flags) };
+        unsafe { ffi::PyLong_AsNativeBytes(long.as_ptr().cast(), core::ptr::null_mut(), 0, flags) };
     let n_bytes_unsigned: usize = n_bytes
         .try_into()
         .map_err(|_| crate::PyErr::fetch(long.py()))?;
@@ -350,22 +350,22 @@ mod tests {
     fn rust_fib<T>() -> impl Iterator<Item = T>
     where
         T: From<u16>,
-        for<'a> &'a T: std::ops::Add<Output = T>,
+        for<'a> &'a T: core::ops::Add<Output = T>,
     {
         let mut f0: T = T::from(1);
         let mut f1: T = T::from(1);
-        std::iter::from_fn(move || {
+        core::iter::from_fn(move || {
             let f2 = &f0 + &f1;
-            Some(std::mem::replace(&mut f0, std::mem::replace(&mut f1, f2)))
+            Some(core::mem::replace(&mut f0, core::mem::replace(&mut f1, f2)))
         })
     }
 
     fn python_fib(py: Python<'_>) -> impl Iterator<Item = Bound<'_, PyAny>> + '_ {
         let mut f0 = 1i32.into_pyobject(py).unwrap().into_any();
         let mut f1 = 1i32.into_pyobject(py).unwrap().into_any();
-        std::iter::from_fn(move || {
+        core::iter::from_fn(move || {
             let f2 = f0.call_method1("__add__", (&f1,)).unwrap();
-            Some(std::mem::replace(&mut f0, std::mem::replace(&mut f1, f2)))
+            Some(core::mem::replace(&mut f0, core::mem::replace(&mut f1, f2)))
         })
     }