Remove dead code

Author: adriangb

src/input/input_abstract.rs

@@ -9,7 +9,7 @@ use crate::{PyMultiHostUrl, PyUrl};
 use super::datetime::{EitherDate, EitherDateTime, EitherTime, EitherTimedelta};
 use super::generic_iterable::GenericIterable;
 use super::return_enums::{EitherBytes, EitherString};
-use super::{GenericArguments, GenericCollection, GenericIterator, GenericMapping, JsonInput};
+use super::{GenericArguments, GenericIterator, GenericMapping, JsonInput};
 
 #[derive(Debug, Clone, Copy)]
 pub enum InputType {
@@ -169,19 +169,6 @@ pub trait Input<'a>: fmt::Debug + ToPyObject {
 
     fn extract_iterable(&'a self) -> ValResult<GenericIterable<'a>>;
 
-    fn validate_tuple(&'a self, strict: bool) -> ValResult<GenericCollection<'a>> {
-        if strict {
-            self.strict_tuple()
-        } else {
-            self.lax_tuple()
-        }
-    }
-    fn strict_tuple(&'a self) -> ValResult<GenericCollection<'a>>;
-    #[cfg_attr(has_no_coverage, no_coverage)]
-    fn lax_tuple(&'a self) -> ValResult<GenericCollection<'a>> {
-        self.strict_tuple()
-    }
-
     fn validate_iter(&self) -> ValResult<GenericIterator>;
 
     fn validate_date(&self, strict: bool) -> ValResult<EitherDate> {

src/input/input_json.rs

@@ -10,8 +10,8 @@ use super::datetime::{
 use super::parse_json::JsonArray;
 use super::shared::{float_as_int, int_as_bool, map_json_err, str_as_bool, str_as_int};
 use super::{
-    EitherBytes, EitherString, EitherTimedelta, GenericArguments, GenericCollection, GenericIterator, GenericMapping,
-    Input, JsonArgs, JsonInput,
+    EitherBytes, EitherString, EitherTimedelta, GenericArguments, GenericIterator, GenericMapping, Input, JsonArgs,
+    JsonInput,
 };
 
 impl<'a> Input<'a> for JsonInput {
@@ -187,18 +187,6 @@ impl<'a> Input<'a> for JsonInput {
         self.validate_dict(false)
     }
 
-    fn validate_tuple(&'a self, _strict: bool) -> ValResult<GenericCollection<'a>> {
-        // just as in set's case, List has to be allowed
-        match self {
-            JsonInput::Array(a) => Ok(a.into()),
-            _ => Err(ValError::new(ErrorType::TupleType, self)),
-        }
-    }
-    #[cfg_attr(has_no_coverage, no_coverage)]
-    fn strict_tuple(&'a self) -> ValResult<GenericCollection<'a>> {
-        self.validate_tuple(false)
-    }
-
     fn extract_iterable(&'a self) -> ValResult<super::generic_iterable::GenericIterable<'a>> {
         match self {
             JsonInput::Array(a) => Ok(super::generic_iterable::GenericIterable::JsonArray(a)),
@@ -381,15 +369,6 @@ impl<'a> Input<'a> for String {
         Err(ValError::new(ErrorType::IterableType, self))
     }
 
-    #[cfg_attr(has_no_coverage, no_coverage)]
-    fn validate_tuple(&'a self, _strict: bool) -> ValResult<GenericCollection<'a>> {
-        Err(ValError::new(ErrorType::TupleType, self))
-    }
-    #[cfg_attr(has_no_coverage, no_coverage)]
-    fn strict_tuple(&'a self) -> ValResult<GenericCollection<'a>> {
-        self.validate_tuple(false)
-    }
-
     fn validate_iter(&self) -> ValResult<GenericIterator> {
         Ok(string_to_vec(self).into())
     }

src/input/input_python.rs

@@ -23,39 +23,10 @@ use super::datetime::{
 };
 use super::shared::{float_as_int, int_as_bool, map_json_err, str_as_bool, str_as_int};
 use super::{
-    py_string_str, EitherBytes, EitherString, EitherTimedelta, GenericArguments, GenericCollection, GenericIterator,
-    GenericMapping, Input, JsonInput, PyArgs,
+    py_string_str, EitherBytes, EitherString, EitherTimedelta, GenericArguments, GenericIterator, GenericMapping,
+    Input, JsonInput, PyArgs,
 };
 
-/// Extract generators and deques into a `GenericCollection`
-macro_rules! extract_shared_iter {
-    ($type:ty, $obj:ident) => {
-        if $obj.downcast::<PyIterator>().is_ok() {
-            Some($obj.into())
-        } else if is_deque($obj) {
-            Some($obj.into())
-        } else {
-            None
-        }
-    };
-}
-
-/// Extract dict keys, values and items into a `GenericCollection`
-#[cfg(not(PyPy))]
-macro_rules! extract_dict_iter {
-    ($obj:ident) => {
-        if $obj.is_instance_of::<PyDictKeys>().unwrap_or(false) {
-            Some($obj.into())
-        } else if $obj.is_instance_of::<PyDictValues>().unwrap_or(false) {
-            Some($obj.into())
-        } else if $obj.is_instance_of::<PyDictItems>().unwrap_or(false) {
-            Some($obj.into())
-        } else {
-            None
-        }
-    };
-}
-
 #[cfg(PyPy)]
 macro_rules! extract_dict_iter {
     ($obj:ident) => {
@@ -71,7 +42,6 @@ macro_rules! extract_dict_iter {
     };
 }
 
-/// Extract dict keys, values and items into a `GenericCollection`
 #[cfg(not(PyPy))]
 macro_rules! extract_dict_keys {
     ($py:expr, $obj:ident) => {
@@ -437,28 +407,6 @@ impl<'a> Input<'a> for PyAny {
         }
     }
 
-    fn strict_tuple(&'a self) -> ValResult<GenericCollection<'a>> {
-        if let Ok(tuple) = self.downcast::<PyTuple>() {
-            Ok(tuple.into())
-        } else {
-            Err(ValError::new(ErrorType::TupleType, self))
-        }
-    }
-
-    fn lax_tuple(&'a self) -> ValResult<GenericCollection<'a>> {
-        if let Ok(tuple) = self.downcast::<PyTuple>() {
-            Ok(tuple.into())
-        } else if let Ok(list) = self.downcast::<PyList>() {
-            Ok(list.into())
-        } else if let Some(collection) = extract_dict_iter!(self) {
-            Ok(collection)
-        } else if let Some(collection) = extract_shared_iter!(PyTuple, self) {
-            Ok(collection)
-        } else {
-            Err(ValError::new(ErrorType::TupleType, self))
-        }
-    }
-
     fn extract_iterable(&'a self) -> ValResult<super::generic_iterable::GenericIterable<'a>> {
         // Handle concrete non-overlapping types first, then abstract types
         if let Ok(iterable) = self.downcast::<PyList>() {
@@ -644,21 +592,6 @@ fn maybe_as_string(v: &PyAny, unicode_error: ErrorType) -> ValResult<Option<Cow<
     }
 }
 
-static DEQUE_TYPE: GILOnceCell<Py<PyType>> = GILOnceCell::new();
-
-fn is_deque(v: &PyAny) -> bool {
-    let py = v.py();
-    let deque_type = DEQUE_TYPE
-        .get_or_init(py, || import_type(py, "collections", "deque").unwrap())
-        .as_ref(py);
-    v.is_instance(deque_type).unwrap_or(false)
-}
-
-fn import_type(py: Python, module: &str, attr: &str) -> PyResult<Py<PyType>> {
-    let obj = py.import(module)?.getattr(attr)?;
-    Ok(obj.downcast::<PyType>()?.into())
-}
-
 fn is_builtin_str(py_str: &PyString) -> bool {
     py_str.get_type().is(PyString::type_object(py_str.py()))
 }

src/input/iterator.rs

@@ -1,5 +1,3 @@
-use std::{marker::PhantomData, mem};
-
 use pyo3::{PyObject, PyResult, Python};
 
 use super::Input;
@@ -36,17 +34,18 @@ impl IterableValidatorBuilder {
             fail_fast,
         }
     }
-    pub fn build<'data, 'py, I, R, L, V, D, N>(
+    pub fn build<'data, I, R, L, V, D, N>(
         self,
         iter: I,
         validation_func: V,
         input: &'data D,
-    ) -> IterableValidator<'data, 'py, I, R, L, V, D, N>
+    ) -> IterableValidator<'data, I, R, L, V, D, N>
     where
-        L: Into<LocItem>,
-        V: FnMut(Python<'py>, &L, R) -> ValResult<'data, N>,
+        L: Into<LocItem> + std::fmt::Debug,
+        V: FnMut(Python<'data>, &L, R) -> ValResult<'data, N>,
         I: Iterator<Item = ValResult<'data, (L, R)>>,
         D: Input<'data>,
+        R: std::fmt::Debug,
     {
         IterableValidator::new(
             iter,
@@ -60,12 +59,13 @@ impl IterableValidatorBuilder {
 }
 
 // Almost like an Iterator, but accepts some extra arguments
-pub struct IterableValidator<'data, 'py: 'data, I, R, L, V, D, N>
+pub struct IterableValidator<'data, I, R, L, V, D, N>
 where
     L: Into<LocItem>,
-    V: FnMut(Python<'py>, &L, R) -> ValResult<'data, N>,
+    V: FnMut(Python<'data>, &L, R) -> ValResult<'data, N>,
     I: Iterator<Item = ValResult<'data, (L, R)>>,
     D: Input<'data>,
+    R: std::fmt::Debug,
 {
     iter: I,
     validation_func: V,
@@ -76,15 +76,15 @@ where
     errors: Vec<ValLineError<'data>>,
     done: bool,
     current_index: usize,
-    p: PhantomData<Python<'py>>,
 }
 
-impl<'data, 'py, I, R, L, V, D, N> IterableValidator<'data, 'py, I, R, L, V, D, N>
+impl<'data, I, R, L, V, D, N> IterableValidator<'data, I, R, L, V, D, N>
 where
-    L: Into<LocItem>,
-    V: FnMut(Python<'py>, &L, R) -> ValResult<'data, N>,
+    L: Into<LocItem> + std::fmt::Debug,
+    V: FnMut(Python<'data>, &L, R) -> ValResult<'data, N>,
     I: Iterator<Item = ValResult<'data, (L, R)>>,
     D: Input<'data>,
+    R: std::fmt::Debug,
 {
     fn check_max_length(&self, current_length: usize, max_length: Option<usize>) -> ValResult<'data, ()> {
         if let Some(max_length) = max_length {
@@ -126,10 +126,9 @@ where
             errors: vec![],
             done: false,
             current_index: 0,
-            p: PhantomData,
         }
     }
-    pub fn next(&mut self, py: Python<'py>, current_output_length: usize) -> Option<ValResult<'data, (L, N)>> {
+    pub fn next(&mut self, py: Python<'data>, current_output_length: usize) -> Option<ValResult<'data, (L, N)>> {
         if self.done {
             return None;
         }
@@ -145,23 +144,25 @@ where
             self.current_index += 1;
             match self.iter.next() {
                 None => {
-                    if self.errors.is_empty() {
-                        // check min len and return
-                        if let Some(min_length) = self.length_constraints.min_length {
-                            if min_length > current_output_length {
-                                return Some(Err(ValError::new(
-                                    ErrorType::TooShort {
-                                        field_type: self.field_type.to_string(),
-                                        min_length,
-                                        actual_length: current_output_length,
-                                    },
-                                    self.input,
-                                )));
-                            }
+                    self.done = true;
+                    // check min len and return
+                    if let Some(min_length) = self.length_constraints.min_length {
+                        if min_length > current_output_length {
+                            let err = ValLineError::new(
+                                ErrorType::TooShort {
+                                    field_type: self.field_type.to_string(),
+                                    min_length,
+                                    actual_length: current_output_length,
+                                },
+                                self.input,
+                            );
+                            self.errors.push(err);
                         }
+                    }
+                    if self.errors.is_empty() {
                         return None;
                     }
-                    return Some(Err(ValError::LineErrors(mem::replace(&mut self.errors, vec![]))));
+                    return Some(Err(ValError::LineErrors(std::mem::take(&mut self.errors))));
                 }
                 Some(iter_result) => match iter_result {
                     Ok((loc, item)) => match (self.validation_func)(py, &loc, item) {
@@ -202,16 +203,17 @@ where
     }
 }
 
-pub fn validate_into_vec<'data, 'py, I, R, L, V, D, N>(
-    py: Python<'py>,
+pub fn validate_into_vec<'data, I, R, L, V, D, N>(
+    py: Python<'data>,
     capacity: usize,
-    iterator: &mut IterableValidator<'data, 'py, I, R, L, V, D, N>,
+    iterator: &mut IterableValidator<'data, I, R, L, V, D, N>,
 ) -> ValResult<'data, Vec<N>>
 where
-    L: Into<LocItem>,
-    V: FnMut(Python<'py>, &L, R) -> ValResult<'data, N>,
+    L: Into<LocItem> + std::fmt::Debug,
+    V: FnMut(Python<'data>, &L, R) -> ValResult<'data, N>,
     I: Iterator<Item = ValResult<'data, (L, R)>>,
     D: Input<'data>,
+    R: std::fmt::Debug,
 {
     let mut output = Vec::with_capacity(capacity);
     while let Some(result) = iterator.next(py, output.len()) {
@@ -314,7 +316,6 @@ where
     }
 }
 
-
 /// Utility wrapper used by dicts and mappings
 #[allow(clippy::too_many_arguments)]
 pub fn validate_mapping<'s, 'data, I, V, E, O, S>(

src/input/mod.rs

@@ -21,8 +21,7 @@ pub(crate) use input_abstract::{Input, InputType};
 pub(crate) use parse_json::{JsonInput, JsonObject};
 pub(crate) use return_enums::{
     py_string_str, AttributesGenericIterator, DictGenericIterator, EitherBytes, EitherString, GenericArguments,
-    GenericCollection, GenericIterator, GenericMapping, JsonArgs, JsonObjectGenericIterator, MappingGenericIterator,
-    PyArgs,
+    GenericIterator, GenericMapping, JsonArgs, JsonObjectGenericIterator, MappingGenericIterator, PyArgs,
 };
 
 // Defined here as it's not exported by pyo3