refactor schema build to use Py2

Author: davidhewitt

src/build_tools.rs

@@ -12,8 +12,8 @@ use crate::tools::SchemaDict;
 use crate::ValidationError;
 
 pub fn schema_or_config<'py, T>(
-    schema: &'py PyDict,
-    config: Option<&'py PyDict>,
+    schema: &Py2<'py, PyDict>,
+    config: Option<&Py2<'py, PyDict>>,
     schema_key: &PyString,
     config_key: &PyString,
 ) -> PyResult<Option<T>>
@@ -30,8 +30,8 @@ where
 }
 
 pub fn schema_or_config_same<'py, T>(
-    schema: &'py PyDict,
-    config: Option<&'py PyDict>,
+    schema: &Py2<'py, PyDict>,
+    config: Option<&Py2<'py, PyDict>>,
     key: &PyString,
 ) -> PyResult<Option<T>>
 where
@@ -40,7 +40,7 @@ where
     schema_or_config(schema, config, key, key)
 }
 
-pub fn is_strict(schema: &PyDict, config: Option<&PyDict>) -> PyResult<bool> {
+pub fn is_strict(schema: &Py2<'_, PyDict>, config: Option<&Py2<'_, PyDict>>) -> PyResult<bool> {
     let py = schema.py();
     Ok(schema_or_config_same(schema, config, intern!(py, "strict"))?.unwrap_or(false))
 }
@@ -174,18 +174,18 @@ pub(crate) enum ExtraBehavior {
 impl ExtraBehavior {
     pub fn from_schema_or_config(
         py: Python,
-        schema: &PyDict,
-        config: Option<&PyDict>,
+        schema: &Py2<'_, PyDict>,
+        config: Option<&Py2<'_, PyDict>>,
         default: Self,
     ) -> PyResult<Self> {
-        let extra_behavior = schema_or_config::<Option<&str>>(
+        let extra_behavior = schema_or_config::<Option<Py2<'_, PyString>>>(
             schema,
             config,
             intern!(py, "extra_behavior"),
             intern!(py, "extra_fields_behavior"),
         )?
         .flatten();
-        let res = match extra_behavior {
+        let res = match extra_behavior.as_ref().map(|s| s.to_str()).transpose()? {
             Some("allow") => Self::Allow,
             Some("ignore") => Self::Ignore,
             Some("forbid") => Self::Forbid,

src/input/datetime.rs

@@ -20,7 +20,7 @@ use crate::tools::py_err;
 #[cfg_attr(debug_assertions, derive(Debug))]
 pub enum EitherDate<'a> {
     Raw(Date),
-    Py(&'a PyDate),
+    Py(Py2<'a, PyDate>),
 }
 
 impl<'a> From<Date> for EitherDate<'a> {
@@ -29,13 +29,13 @@ impl<'a> From<Date> for EitherDate<'a> {
     }
 }
 
-impl<'a> From<&'a PyDate> for EitherDate<'a> {
-    fn from(date: &'a PyDate) -> Self {
+impl<'a> From<Py2<'a, PyDate>> for EitherDate<'a> {
+    fn from(date: Py2<'a, PyDate>) -> Self {
         Self::Py(date)
     }
 }
 
-pub fn pydate_as_date(py_date: &PyAny) -> PyResult<Date> {
+pub fn pydate_as_date(py_date: &Py2<'_, PyAny>) -> PyResult<Date> {
     let py = py_date.py();
     Ok(Date {
         year: py_date.getattr(intern!(py, "year"))?.extract()?,
@@ -55,7 +55,7 @@ impl<'a> EitherDate<'a> {
     pub fn try_into_py(self, py: Python<'_>) -> PyResult<PyObject> {
         let date = match self {
             Self::Py(date) => Ok(date),
-            Self::Raw(date) => PyDate::new2(py, date.year.into(), date.month, date.day).map(Py2::into_gil_ref),
+            Self::Raw(date) => PyDate::new2(py, date.year.into(), date.month, date.day),
         }?;
         Ok(date.into_py(py))
     }
@@ -64,7 +64,7 @@ impl<'a> EitherDate<'a> {
 #[cfg_attr(debug_assertions, derive(Debug))]
 pub enum EitherTime<'a> {
     Raw(Time),
-    Py(&'a PyTime),
+    Py(Py2<'a, PyTime>),
 }
 
 impl<'a> From<Time> for EitherTime<'a> {
@@ -73,17 +73,17 @@ impl<'a> From<Time> for EitherTime<'a> {
     }
 }
 
-impl<'a> From<&'a PyTime> for EitherTime<'a> {
-    fn from(time: &'a PyTime) -> Self {
+impl<'a> From<Py2<'a, PyTime>> for EitherTime<'a> {
+    fn from(time: Py2<'a, PyTime>) -> Self {
         Self::Py(time)
     }
 }
 
 #[cfg_attr(debug_assertions, derive(Debug))]
 pub enum EitherTimedelta<'a> {
     Raw(Duration),
-    PyExact(&'a PyDelta),
-    PySubclass(&'a PyDelta),
+    PyExact(Py2<'a, PyDelta>),
+    PySubclass(Py2<'a, PyDelta>),
 }
 
 impl<'a> From<Duration> for EitherTimedelta<'a> {
@@ -101,29 +101,29 @@ impl<'a> EitherTimedelta<'a> {
         }
     }
 
-    pub fn try_into_py(&self, py: Python<'a>) -> PyResult<&'a PyDelta> {
+    pub fn try_into_py(&self, py: Python<'a>) -> PyResult<Py2<'a, PyDelta>> {
         match self {
-            Self::PyExact(timedelta) => Ok(*timedelta),
-            Self::PySubclass(timedelta) => Ok(*timedelta),
-            Self::Raw(duration) => duration_as_pytimedelta(py, duration).map(Py2::into_gil_ref),
+            Self::PyExact(timedelta) => Ok(timedelta.clone()),
+            Self::PySubclass(timedelta) => Ok(timedelta.clone()),
+            Self::Raw(duration) => duration_as_pytimedelta(py, duration),
         }
     }
 }
 
-impl<'a> TryFrom<&'a PyAny> for EitherTimedelta<'a> {
+impl<'a> TryFrom<&'_ Py2<'a, PyAny>> for EitherTimedelta<'a> {
     type Error = PyErr;
 
-    fn try_from(value: &'a PyAny) -> PyResult<Self> {
-        if let Ok(dt) = <PyDelta as PyTryFrom>::try_from_exact(value) {
-            Ok(EitherTimedelta::PyExact(dt))
+    fn try_from(value: &Py2<'a, PyAny>) -> PyResult<Self> {
+        if let Ok(dt) = value.downcast() {
+            Ok(EitherTimedelta::PyExact(dt.clone()))
         } else {
             let dt = value.downcast::<PyDelta>()?;
-            Ok(EitherTimedelta::PySubclass(dt))
+            Ok(EitherTimedelta::PySubclass(dt.clone()))
         }
     }
 }
 
-pub fn pytimedelta_exact_as_duration(py_timedelta: &PyDelta) -> Duration {
+pub fn pytimedelta_exact_as_duration(py_timedelta: &Py2<'_, PyDelta>) -> Duration {
     // see https://docs.python.org/3/c-api/datetime.html#c.PyDateTime_DELTA_GET_DAYS
     // days can be negative, but seconds and microseconds are always positive.
     let mut days = py_timedelta.get_days(); // -999999999 to 999999999
@@ -146,7 +146,7 @@ pub fn pytimedelta_exact_as_duration(py_timedelta: &PyDelta) -> Duration {
     Duration::new(positive, days as u32, seconds as u32, microseconds as u32).unwrap()
 }
 
-pub fn pytimedelta_subclass_as_duration(py_timedelta: &PyDelta) -> PyResult<Duration> {
+pub fn pytimedelta_subclass_as_duration(py_timedelta: &Py2<'_, PyDelta>) -> PyResult<Duration> {
     let total_seconds: f64 = py_timedelta
         .call_method0(intern!(py_timedelta.py(), "total_seconds"))?
         .extract()?;
@@ -173,16 +173,16 @@ pub fn duration_as_pytimedelta<'py>(py: Python<'py>, duration: &Duration) -> PyR
     )
 }
 
-pub fn pytime_as_time(py_time: &PyAny, py_dt: Option<&PyAny>) -> PyResult<Time> {
+pub fn pytime_as_time(py_time: &Py2<'_, PyAny>, py_dt: Option<&Py2<'_, PyAny>>) -> PyResult<Time> {
     let py = py_time.py();
 
     let tzinfo = py_time.getattr(intern!(py, "tzinfo"))?;
-    let tz_offset: Option<i32> = if tzinfo.is_none() {
+    let tz_offset: Option<i32> = if PyAnyMethods::is_none(&tzinfo) {
         None
     } else {
         let offset_delta = tzinfo.call_method1(intern!(py, "utcoffset"), (py_dt,))?;
         // as per the docs, utcoffset() can return None
-        if offset_delta.is_none() {
+        if PyAnyMethods::is_none(&offset_delta) {
             None
         } else {
             let offset_seconds: f64 = offset_delta.call_method0(intern!(py, "total_seconds"))?.extract()?;
@@ -217,8 +217,7 @@ impl<'a> EitherTime<'a> {
                 time.second,
                 time.microsecond,
                 time_as_tzinfo(py, &time)?.as_ref(),
-            )
-            .map(Py2::into_gil_ref),
+            ),
         }?;
         Ok(time.into_py(py))
     }
@@ -237,7 +236,7 @@ fn time_as_tzinfo<'py>(py: Python<'py>, time: &Time) -> PyResult<Option<Py2<'py,
 #[cfg_attr(debug_assertions, derive(Debug))]
 pub enum EitherDateTime<'a> {
     Raw(DateTime),
-    Py(&'a PyDateTime),
+    Py(Py2<'a, PyDateTime>),
 }
 
 impl<'a> From<DateTime> for EitherDateTime<'a> {
@@ -246,13 +245,13 @@ impl<'a> From<DateTime> for EitherDateTime<'a> {
     }
 }
 
-impl<'a> From<&'a PyDateTime> for EitherDateTime<'a> {
-    fn from(dt: &'a PyDateTime) -> Self {
+impl<'a> From<Py2<'a, PyDateTime>> for EitherDateTime<'a> {
+    fn from(dt: Py2<'a, PyDateTime>) -> Self {
         Self::Py(dt)
     }
 }
 
-pub fn pydatetime_as_datetime(py_dt: &PyAny) -> PyResult<DateTime> {
+pub fn pydatetime_as_datetime(py_dt: &Py2<'_, PyAny>) -> PyResult<DateTime> {
     Ok(DateTime {
         date: pydate_as_date(py_dt)?,
         time: pytime_as_time(py_dt, Some(py_dt))?,
@@ -279,9 +278,8 @@ impl<'a> EitherDateTime<'a> {
                 datetime.time.second,
                 datetime.time.microsecond,
                 time_as_tzinfo(py, &datetime.time)?.as_ref(),
-            )?
-            .into_gil_ref(),
-            Self::Py(dt) => dt,
+            )?,
+            Self::Py(dt) => dt.clone(),
         };
         Ok(dt.into_py(py))
     }
@@ -405,7 +403,7 @@ pub fn date_as_datetime(date: &PyDate) -> PyResult<EitherDateTime> {
         0,
         None,
     )?;
-    Ok(dt.into_gil_ref().into())
+    Ok(dt.into())
 }
 
 const MAX_U32: i64 = u32::MAX as i64;