fix ValueError on year zero

Author: davidhewitt

src/input/datetime.rs

@@ -45,21 +45,32 @@ pub fn pydate_as_date(py_date: &Bound<'_, PyAny>) -> PyResult<Date> {
     })
 }
 
-impl EitherDate<'_> {
+impl<'py> EitherDate<'py> {
+    pub fn try_into_py(self, py: Python<'py>, input: &(impl Input<'py> + ?Sized)) -> ValResult<PyObject> {
+        match self {
+            Self::Raw(date) => {
+                if date.year == 0 {
+                    return Err(ValError::new(
+                        ErrorType::DateParsing {
+                            error: Cow::Borrowed("year 0 is out of range"),
+                            context: None,
+                        },
+                        input,
+                    ));
+                };
+                let py_date = PyDate::new_bound(py, date.year.into(), date.month, date.day)?;
+                Ok(py_date.into())
+            }
+            Self::Py(py_date) => Ok(py_date.into()),
+        }
+    }
+
     pub fn as_raw(&self) -> PyResult<Date> {
         match self {
             Self::Raw(date) => Ok(date.clone()),
             Self::Py(py_date) => pydate_as_date(py_date),
         }
     }
-
-    pub fn try_into_py(self, py: Python<'_>) -> PyResult<PyObject> {
-        let date = match self {
-            Self::Py(date) => Ok(date),
-            Self::Raw(date) => PyDate::new_bound(py, date.year.into(), date.month, date.day),
-        }?;
-        Ok(date.into_py(py))
-    }
 }
 
 #[cfg_attr(debug_assertions, derive(Debug))]
@@ -259,31 +270,42 @@ pub fn pydatetime_as_datetime(py_dt: &Bound<'_, PyAny>) -> PyResult<DateTime> {
     })
 }
 
-impl<'a> EitherDateTime<'a> {
+impl<'py> EitherDateTime<'py> {
+    pub fn try_into_py(self, py: Python<'py>, input: &(impl Input<'py> + ?Sized)) -> ValResult<PyObject> {
+        match self {
+            Self::Raw(dt) => {
+                if dt.date.year == 0 {
+                    return Err(ValError::new(
+                        ErrorType::DatetimeParsing {
+                            error: Cow::Borrowed("year 0 is out of range"),
+                            context: None,
+                        },
+                        input,
+                    ));
+                };
+                let py_dt = PyDateTime::new_bound(
+                    py,
+                    dt.date.year.into(),
+                    dt.date.month,
+                    dt.date.day,
+                    dt.time.hour,
+                    dt.time.minute,
+                    dt.time.second,
+                    dt.time.microsecond,
+                    time_as_tzinfo(py, &dt.time)?.as_ref(),
+                )?;
+                Ok(py_dt.into())
+            }
+            Self::Py(py_dt) => Ok(py_dt.into()),
+        }
+    }
+
     pub fn as_raw(&self) -> PyResult<DateTime> {
         match self {
             Self::Raw(dt) => Ok(dt.clone()),
             Self::Py(py_dt) => pydatetime_as_datetime(py_dt),
         }
     }
-
-    pub fn try_into_py(self, py: Python<'a>) -> PyResult<PyObject> {
-        let dt = match self {
-            Self::Raw(datetime) => PyDateTime::new_bound(
-                py,
-                datetime.date.year.into(),
-                datetime.date.month,
-                datetime.date.day,
-                datetime.time.hour,
-                datetime.time.minute,
-                datetime.time.second,
-                datetime.time.microsecond,
-                time_as_tzinfo(py, &datetime.time)?.as_ref(),
-            )?,
-            Self::Py(dt) => dt.clone(),
-        };
-        Ok(dt.into_py(py))
-    }
 }
 
 pub fn bytes_as_date<'py>(input: &(impl Input<'py> + ?Sized), bytes: &[u8]) -> ValResult<EitherDate<'py>> {

src/validators/date.rs

@@ -97,7 +97,7 @@ impl Validator for DateValidator {
                 }
             }
         }
-        Ok(date.try_into_py(py)?)
+        date.try_into_py(py, input)
     }
 
     fn get_name(&self) -> &str {

src/validators/datetime.rs

@@ -130,7 +130,7 @@ impl Validator for DateTimeValidator {
                 tz_constraint.tz_check(speedate_dt.time.tz_offset, input)?;
             }
         }
-        Ok(datetime.try_into_py(py)?)
+        datetime.try_into_py(py, input)
     }
 
     fn get_name(&self) -> &str {

tests/validators/test_date.py

@@ -64,6 +64,12 @@
         ),
         pytest.param('-', Err('Input should be a valid date or datetime, input is too short'), id='minus'),
         pytest.param('+', Err('Input should be a valid date or datetime, input is too short'), id='pus'),
+        pytest.param('0001-01-01', date(1, 1, 1), id='min-date'),
+        pytest.param(
+            '0000-12-31',
+            Err('Input should be a valid date in the format YYYY-MM-DD, year 0 is out of range [type=date_parsing,'),
+            id='year-0',
+        ),
     ],
 )
 def test_date(input_value, expected):

tests/validators/test_datetime.py

@@ -53,6 +53,14 @@
                 'Input should be a valid datetime or date, day value is outside expected range [type=datetime_from_date_parsing,'
             ),
         ),
+        (
+            '0001-01-01T00:00:00.000000Z',
+            datetime(1, 1, 1, tzinfo=timezone.utc),
+        ),
+        (
+            '0000-12-31T23:59:59.999999Z',
+            Err('Input should be a valid datetime, year 0 is out of range [type=datetime_parsing,'),
+        ),
     ],
 )
 def test_datetime(input_value, expected):