Revert change to strict_int

Author: adriangb

src/input/input_abstract.rs

@@ -124,6 +124,18 @@ pub trait Input<'a>: fmt::Debug + ToPyObject {
         self.strict_int()
     }
 
+    /// Extract an EitherInt from the input, only allowing exact
+    /// matches for an Int (no subclasses)
+    fn exact_int(&'a self) -> ValResult<EitherInt<'a>> {
+        self.strict_int()
+    }
+
+    /// Extract a String from the input, only allowing exact
+    /// matches for a String (no subclasses)
+    fn exact_str(&'a self) -> ValResult<EitherString<'a>> {
+        self.strict_str()
+    }
+
     fn validate_float(&self, strict: bool, ultra_strict: bool) -> ValResult<f64> {
         if ultra_strict {
             self.ultra_strict_float()

src/input/input_python.rs

@@ -195,6 +195,14 @@ impl<'a> Input<'a> for PyAny {
         }
     }
 
+    fn exact_int(&'a self) -> ValResult<EitherInt<'a>> {
+        if PyInt::is_exact_type_of(self) {
+            Ok(EitherInt::Py(self))
+        } else {
+            Err(ValError::new(ErrorType::IntType, self))
+        }
+    }
+
     fn lax_str(&'a self) -> ValResult<EitherString<'a>> {
         if let Ok(py_str) = <PyString as PyTryFrom>::try_from_exact(self) {
             Ok(py_str.into())
@@ -270,6 +278,13 @@ impl<'a> Input<'a> for PyAny {
     fn strict_int(&'a self) -> ValResult<EitherInt<'a>> {
         if PyInt::is_exact_type_of(self) {
             Ok(EitherInt::Py(self))
+        } else if PyInt::is_type_of(self) {
+            // bools are a subclass of int, so check for bool type in this specific case
+            if PyBool::is_exact_type_of(self) {
+                Err(ValError::new(ErrorType::IntType, self))
+            } else {
+                Ok(EitherInt::Py(self))
+            }
         } else {
             Err(ValError::new(ErrorType::IntType, self))
         }

src/validators/literal.rs

@@ -37,12 +37,12 @@ impl<T: Clone + Debug> LiteralLookup<T> {
         for (k, v) in expected {
             let id = values.len();
             values.push(v);
-            if let Ok(either_int) = k.strict_int() {
+            if let Ok(either_int) = k.exact_int() {
                 let int = either_int
                     .into_i64(py)
                     .map_err(|_| py_schema_error_type!("error extracting int {:?}", k))?;
                 expected_int.insert(int, id);
-            } else if let Ok(either_str) = k.strict_str() {
+            } else if let Ok(either_str) = k.exact_str() {
                 let str = either_str
                     .as_cow()
                     .map_err(|_| py_schema_error_type!("error extracting str {:?}", k))?;
@@ -76,7 +76,7 @@ impl<T: Clone + Debug> LiteralLookup<T> {
     ) -> ValResult<'data, Option<(&'data I, &T)>> {
         // dbg!(input.to_object(py).as_ref(py).repr().unwrap());
         if let Some(expected_ints) = &self.expected_int {
-            if let Ok(either_int) = input.strict_int() {
+            if let Ok(either_int) = input.exact_int() {
                 let int = either_int.into_i64(py)?;
                 if let Some(id) = expected_ints.get(&int) {
                     return Ok(Some((input, &self.values[*id])));
@@ -85,7 +85,7 @@ impl<T: Clone + Debug> LiteralLookup<T> {
         }
         if let Some(expected_strings) = &self.expected_str {
             // dbg!(expected_strings);
-            if let Ok(either_str) = input.strict_str() {
+            if let Ok(either_str) = input.exact_str() {
                 let cow = either_str.as_cow()?;
                 if let Some(id) = expected_strings.get(cow.as_ref()) {
                     return Ok(Some((input, &self.values[*id])));