use get_slice to copy lists

Author: samuelcolvin

src/input/return_enums.rs

@@ -12,12 +12,11 @@ use pyo3::types::PyFunction;
 use pyo3::PyTypeInfo;
 
 use crate::errors::{py_err_string, ErrorType, InputValue, ValError, ValLineError, ValResult};
-use crate::input::py_error_on_minusone;
 use crate::recursion_guard::RecursionGuard;
 use crate::validators::{CombinedValidator, Extra, Validator};
 
 use super::parse_json::{JsonArray, JsonInput, JsonObject};
-use super::Input;
+use super::{py_error_on_minusone, Input};
 
 /// Container for all the collections (sized iterable containers) types, which
 /// can mostly be converted to each other in lax mode.

src/validators/dict.rs

@@ -10,6 +10,7 @@ use crate::input::{
 use crate::recursion_guard::RecursionGuard;
 
 use super::any::AnyValidator;
+use super::list::length_check;
 use super::{build_validator, BuildValidator, CombinedValidator, Definitions, DefinitionsBuilder, Extra, Validator};
 
 #[derive(Debug, Clone)]
@@ -104,40 +105,6 @@ impl Validator for DictValidator {
     }
 }
 
-macro_rules! length_check {
-    ($input:ident, $field_type:literal, $min_length:expr, $max_length:expr, $obj:ident) => {{
-        let mut op_actual_length: Option<usize> = None;
-        if let Some(min_length) = $min_length {
-            let actual_length = $obj.len();
-            if actual_length < min_length {
-                return Err(crate::errors::ValError::new(
-                    crate::errors::ErrorType::TooShort {
-                        field_type: $field_type.to_string(),
-                        min_length,
-                        actual_length,
-                    },
-                    $input,
-                ));
-            }
-            op_actual_length = Some(actual_length);
-        }
-        if let Some(max_length) = $max_length {
-            let actual_length = op_actual_length.unwrap_or_else(|| $obj.len());
-            if actual_length > max_length {
-                return Err(crate::errors::ValError::new(
-                    crate::errors::ErrorType::TooLong {
-                        field_type: $field_type.to_string(),
-                        max_length,
-                        actual_length,
-                    },
-                    $input,
-                ));
-            }
-        }
-    }};
-}
-pub(crate) use length_check;
-
 macro_rules! build_validate {
     ($name:ident, $dict_type:ty, $iter:ty) => {
         fn $name<'s, 'data>(

src/validators/list.rs

@@ -3,7 +3,7 @@ use pyo3::types::PyDict;
 
 use crate::build_tools::SchemaDict;
 use crate::errors::ValResult;
-use crate::input::Input;
+use crate::input::{GenericCollection, Input};
 use crate::recursion_guard::RecursionGuard;
 
 use super::{build_validator, BuildValidator, CombinedValidator, Definitions, DefinitionsBuilder, Extra, Validator};
@@ -35,6 +35,40 @@ pub fn get_items_schema(
     }
 }
 
+macro_rules! length_check {
+    ($input:ident, $field_type:literal, $min_length:expr, $max_length:expr, $obj:ident) => {{
+        let mut op_actual_length: Option<usize> = None;
+        if let Some(min_length) = $min_length {
+            let actual_length = $obj.len();
+            if actual_length < min_length {
+                return Err(crate::errors::ValError::new(
+                    crate::errors::ErrorType::TooShort {
+                        field_type: $field_type.to_string(),
+                        min_length,
+                        actual_length,
+                    },
+                    $input,
+                ));
+            }
+            op_actual_length = Some(actual_length);
+        }
+        if let Some(max_length) = $max_length {
+            let actual_length = op_actual_length.unwrap_or_else(|| $obj.len());
+            if actual_length > max_length {
+                return Err(crate::errors::ValError::new(
+                    crate::errors::ErrorType::TooLong {
+                        field_type: $field_type.to_string(),
+                        max_length,
+                        actual_length,
+                    },
+                    $input,
+                ));
+            }
+        }
+    }};
+}
+pub(crate) use length_check;
+
 macro_rules! min_length_check {
     ($input:ident, $field_type:literal, $min_length:expr, $obj:ident) => {{
         if let Some(min_length) = $min_length {
@@ -100,7 +134,14 @@ impl Validator for ListValidator {
                 definitions,
                 recursion_guard,
             )?,
-            None => seq.to_vec(py, input, "List", self.max_length)?,
+            None => match seq {
+                GenericCollection::List(list) => {
+                    length_check!(input, "List", self.min_length, self.max_length, list);
+                    let list_copy = list.get_slice(0, usize::MAX);
+                    return Ok(list_copy.into_py(py));
+                }
+                _ => seq.to_vec(py, input, "List", self.max_length)?,
+            },
         };
         min_length_check!(input, "List", self.min_length, output);
         Ok(output.into_py(py))

tests/validators/test_list.py

@@ -40,6 +40,11 @@ def test_list_strict():
     ]
 
 
+def test_list_no_copy():
+    v = SchemaValidator({'type': 'list'})
+    assert v.validate_python([1, 2, 3]) is not [1, 2, 3]
+
+
 def gen_ints():
     yield 1
     yield 2
@@ -148,7 +153,7 @@ def test_list_error(input_value, index):
         (
             {'max_length': 3},
             [1, 2, 3, 4, 5, 6, 7],
-            Err('List should have at most 3 items after validation, not 4 [type=too_long,'),
+            Err('List should have at most 3 items after validation, not 7 [type=too_long,'),
         ),
         ({'max_length': 1}, [1, 2], Err('List should have at most 1 item after validation, not 2 [type=too_long,')),
         (