Let's be gentlemen (and use Input instead of Value) (#201)

* let us be gentlemen: s/must/should/g

* replace Value with Input in error messages

* sed was a bit too optimistic

Author: PrettyWood

README.md

@@ -59,7 +59,7 @@ except ValidationError as e:
     """
     1 validation error for model
     age
-      Value must be greater than or equal to 18
+      Input should be greater than or equal to 18
       [kind=greater_than_equal, context={ge: 18}, input_value=11, input_type=int]
     """
 ```

src/errors/kinds.rs

@@ -26,186 +26,195 @@ pub enum ErrorKind {
     RecursionLoop,
     // ---------------------
     // typed dict specific errors
-    #[strum(message = "Value must be a valid dictionary or instance to extract fields from")]
+    #[strum(message = "Input should be a valid dictionary or instance to extract fields from")]
     DictAttributesType,
     #[strum(message = "Field required")]
     Missing,
-    #[strum(message = "Extra values are not permitted")]
+    #[strum(message = "Extra inputs are not permitted")]
     ExtraForbidden,
-    #[strum(message = "Keys must be strings")]
+    #[strum(message = "Keys should be strings")]
     InvalidKey,
     #[strum(message = "Error extracting attribute: {error}")]
     GetAttributeError {
         error: String,
     },
     // ---------------------
     // model class specific errors
-    #[strum(message = "Value must be an instance of {class_name}")]
+    #[strum(message = "Input should be an instance of {class_name}")]
     ModelClassType {
         class_name: String,
     },
     // ---------------------
     // None errors
-    #[strum(message = "Value must be None/null")]
+    #[strum(message = "Input should be None/null")]
     NoneRequired,
     // boolean errors
-    #[strum(message = "Value must be a valid boolean")]
+    #[strum(message = "Input should be a valid boolean")]
     Bool,
     // ---------------------
     // generic comparison errors - used for all inequality comparisons except int and float which have their
     // own type, bounds arguments are Strings so they can be created from any type
-    #[strum(message = "Value must be greater than {gt}")]
+    #[strum(message = "Input should be greater than {gt}")]
     GreaterThan {
         gt: String,
     },
-    #[strum(message = "Value must be greater than or equal to {ge}")]
+    #[strum(message = "Input should be greater than or equal to {ge}")]
     GreaterThanEqual {
         ge: String,
     },
-    #[strum(message = "Value must be less than {lt}")]
+    #[strum(message = "Input should be less than {lt}")]
     LessThan {
         lt: String,
     },
-    #[strum(message = "Value must be less than or equal to {le}")]
+    #[strum(message = "Input should be less than or equal to {le}")]
     LessThanEqual {
         le: String,
     },
     // ---------------------
     // generic length errors - used for everything with a length except strings and bytes which need custom messages
     #[strum(
-        message = "Input must have at least {min_length} item{expected_plural}, got {input_length} item{input_plural}"
+        message = "Input should have at least {min_length} item{expected_plural}, got {input_length} item{input_plural}"
     )]
     TooShort {
         min_length: usize,
         input_length: usize,
     },
     #[strum(
-        message = "Input must have at most {max_length} item{expected_plural}, got {input_length} item{input_plural}"
+        message = "Input should have at most {max_length} item{expected_plural}, got {input_length} item{input_plural}"
     )]
     TooLong {
         max_length: usize,
         input_length: usize,
     },
     // ---------------------
     // string errors
-    #[strum(message = "Value must be a valid string")]
+    #[strum(message = "Input should be a valid string")]
     StrType,
-    #[strum(message = "Value must be a valid string, unable to parse raw data as a unicode string")]
+    #[strum(message = "Input should be a valid string, unable to parse raw data as a unicode string")]
     StrUnicode,
     #[strum(
-        message = "String must have at least {min_length} characters",
+        message = "String should have at least {min_length} characters",
         serialize = "too_short"
     )]
     StrTooShort {
         min_length: usize,
     },
-    #[strum(message = "String must have at most {max_length} characters", serialize = "too_long")]
+    #[strum(
+        message = "String should have at most {max_length} characters",
+        serialize = "too_long"
+    )]
     StrTooLong {
         max_length: usize,
     },
-    #[strum(message = "String must match pattern '{pattern}'")]
+    #[strum(message = "String should match pattern '{pattern}'")]
     StrPatternMismatch {
         pattern: String,
     },
     // ---------------------
     // dict errors
-    #[strum(message = "Value must be a valid dictionary")]
+    #[strum(message = "Input should be a valid dictionary")]
     DictType,
     #[strum(message = "Unable to convert mapping to a dictionary, error: {error}")]
     DictFromMapping {
         error: String,
     },
     // ---------------------
     // list errors
-    #[strum(message = "Value must be a valid list/array")]
+    #[strum(message = "Input should be a valid list/array")]
     ListType,
     // ---------------------
     // tuple errors
-    #[strum(message = "Value must be a valid tuple")]
+    #[strum(message = "Input should be a valid tuple")]
     TupleType,
     // ---------------------
     // set errors
-    #[strum(message = "Value must be a valid set")]
+    #[strum(message = "Input should be a valid set")]
     SetType,
     // ---------------------
     // bool errors
-    #[strum(message = "Value must be a valid boolean")]
+    #[strum(message = "Input should be a valid boolean")]
     BoolType,
-    #[strum(message = "Value must be a valid boolean, unable to interpret input")]
+    #[strum(message = "Input should be a valid boolean, unable to interpret input")]
     BoolParsing,
     // ---------------------
     // int errors
-    #[strum(message = "Value must be a valid integer")]
+    #[strum(message = "Input should be a valid integer")]
     IntType,
-    #[strum(message = "Value must be a valid integer, unable to parse string as an integer")]
+    #[strum(message = "Input should be a valid integer, unable to parse string as an integer")]
     IntParsing,
-    #[strum(message = "Value must be a valid integer, got a number with a fractional part")]
+    #[strum(message = "Input should be a valid integer, got a number with a fractional part")]
     IntFromFloat,
-    #[strum(message = "Value must be a valid integer, got {nan_value}")]
+    #[strum(message = "Input should be a valid integer, got {nan_value}")]
     IntNan {
         nan_value: &'static str,
     },
-    #[strum(serialize = "multiple_of", message = "Value must be a multiple of {multiple_of}")]
+    #[strum(serialize = "multiple_of", message = "Input should be a multiple of {multiple_of}")]
     IntMultipleOf {
         multiple_of: i64,
     },
-    #[strum(serialize = "greater_than", message = "Value must be greater than {gt}")]
+    #[strum(serialize = "greater_than", message = "Input should be greater than {gt}")]
     IntGreaterThan {
         gt: i64,
     },
     #[strum(
         serialize = "greater_than_equal",
-        message = "Value must be greater than or equal to {ge}"
+        message = "Input should be greater than or equal to {ge}"
     )]
     IntGreaterThanEqual {
         ge: i64,
     },
-    #[strum(serialize = "less_than", message = "Value must be less than {lt}")]
+    #[strum(serialize = "less_than", message = "Input should be less than {lt}")]
     IntLessThan {
         lt: i64,
     },
-    #[strum(serialize = "less_than_equal", message = "Value must be less than or equal to {le}")]
+    #[strum(
+        serialize = "less_than_equal",
+        message = "Input should be less than or equal to {le}"
+    )]
     IntLessThanEqual {
         le: i64,
     },
     // ---------------------
     // float errors
-    #[strum(message = "Value must be a valid number")]
+    #[strum(message = "Input should be a valid number")]
     FloatType,
-    #[strum(message = "Value must be a valid number, unable to parse string as an number")]
+    #[strum(message = "Input should be a valid number, unable to parse string as an number")]
     FloatParsing,
-    #[strum(serialize = "multiple_of", message = "Value must be a multiple of {multiple_of}")]
+    #[strum(serialize = "multiple_of", message = "Input should be a multiple of {multiple_of}")]
     FloatMultipleOf {
         multiple_of: f64,
     },
-    #[strum(serialize = "greater_than", message = "Value must be greater than {gt}")]
+    #[strum(serialize = "greater_than", message = "Input should be greater than {gt}")]
     FloatGreaterThan {
         gt: f64,
     },
     #[strum(
         serialize = "greater_than_equal",
-        message = "Value must be greater than or equal to {ge}"
+        message = "Input should be greater than or equal to {ge}"
     )]
     FloatGreaterThanEqual {
         ge: f64,
     },
-    #[strum(serialize = "less_than", message = "Value must be less than {lt}")]
+    #[strum(serialize = "less_than", message = "Input should be less than {lt}")]
     FloatLessThan {
         lt: f64,
     },
-    #[strum(serialize = "less_than_equal", message = "Value must be less than or equal to {le}")]
+    #[strum(
+        serialize = "less_than_equal",
+        message = "Input should be less than or equal to {le}"
+    )]
     FloatLessThanEqual {
         le: f64,
     },
     // ---------------------
     // bytes errors
-    #[strum(message = "Value must be a valid bytes")]
+    #[strum(message = "Input should be a valid bytes")]
     BytesType,
-    #[strum(message = "Data must have at least {min_length} bytes", serialize = "too_short")]
+    #[strum(message = "Data should have at least {min_length} bytes", serialize = "too_short")]
     BytesTooShort {
         min_length: usize,
     },
-    #[strum(message = "Data must have at most {max_length} bytes", serialize = "too_long")]
+    #[strum(message = "Data should have at most {max_length} bytes", serialize = "too_long")]
     BytesTooLong {
         max_length: usize,
     },
@@ -225,41 +234,44 @@ pub enum ErrorKind {
     },
     // ---------------------
     // literals
-    #[strum(serialize = "literal_error", message = "Value must be {expected}")]
+    #[strum(serialize = "literal_error", message = "Input should be {expected}")]
     LiteralSingleError {
         expected: String,
     },
-    #[strum(serialize = "literal_error", message = "Value must be one of: {expected}")]
+    #[strum(serialize = "literal_error", message = "Input should be one of: {expected}")]
     LiteralMultipleError {
         expected: String,
     },
     // ---------------------
     // date errors
-    #[strum(message = "Value must be a valid date")]
+    #[strum(message = "Input should be a valid date")]
     DateType,
-    #[strum(message = "Value must be a valid date in the format YYYY-MM-DD, {error}")]
+    #[strum(message = "Input should be a valid date in the format YYYY-MM-DD, {error}")]
     DateParsing {
         error: &'static str,
     },
-    #[strum(message = "Value must be a valid date or datetime, {error}")]
+    #[strum(message = "Input should be a valid date or datetime, {error}")]
     DateFromDatetimeParsing {
         error: String,
     },
-    #[strum(message = "Datetimes provided to dates must have zero time - e.g. be exact dates")]
+    #[strum(message = "Datetimes provided to dates should have zero time - e.g. be exact dates")]
     DateFromDatetimeInexact,
     // ---------------------
     // date errors
-    #[strum(message = "Value must be a valid time")]
+    #[strum(message = "Input should be a valid time")]
     TimeType,
-    #[strum(message = "Value must be in a valid time format, {error}")]
+    #[strum(message = "Input should be in a valid time format, {error}")]
     TimeParsing {
         error: &'static str,
     },
     // ---------------------
     // datetime errors
-    #[strum(serialize = "datetime_type", message = "Value must be a valid datetime")]
+    #[strum(serialize = "datetime_type", message = "Input should be a valid datetime")]
     DateTimeType,
-    #[strum(serialize = "datetime_parsing", message = "Value must be a valid datetime, {error}")]
+    #[strum(
+        serialize = "datetime_parsing",
+        message = "Input should be a valid datetime, {error}"
+    )]
     DateTimeParsing {
         error: &'static str,
     },
@@ -272,23 +284,23 @@ pub enum ErrorKind {
     },
     // ---------------------
     // timedelta errors
-    #[strum(message = "Value must be a valid timedelta")]
+    #[strum(message = "Input should be a valid timedelta")]
     TimeDeltaType,
-    #[strum(message = "Value must be a valid timedelta, {error}")]
+    #[strum(message = "Input should be a valid timedelta, {error}")]
     TimeDeltaParsing {
         error: &'static str,
     },
     // ---------------------
     // frozenset errors
-    #[strum(message = "Value must be a valid frozenset")]
+    #[strum(message = "Input should be a valid frozenset")]
     FrozenSetType,
     // ---------------------
     // introspection types - e.g. isinstance, callable
-    #[strum(message = "Input must be an instance of {class}")]
+    #[strum(message = "Input should be an instance of {class}")]
     IsInstanceOf {
         class: String,
     },
-    #[strum(message = "Input must be callable")]
+    #[strum(message = "Input should be callable")]
     CallableType,
     // ---------------------
     // union errors

src/input/datetime.rs

@@ -331,7 +331,7 @@ pub fn int_as_time<'a>(
         t if t < 0_i64 => {
             return Err(ValError::new(
                 ErrorKind::TimeParsing {
-                    error: "time in seconds must be positive",
+                    error: "time in seconds should be positive",
                 },
                 input,
             ));

src/lookup_key.rs

@@ -60,7 +60,7 @@ impl LookupKey {
             let list: &PyList = value.cast_as()?;
             let first = match list.get_item(0) {
                 Ok(v) => v,
-                Err(_) => return py_error!("Lookup paths must have at least one element"),
+                Err(_) => return py_error!("Lookup paths should have at least one element"),
             };
             let mut locs: Vec<Path> = if first.cast_as::<PyString>().is_ok() {
                 // list of strings rather than list of lists
@@ -91,7 +91,7 @@ impl LookupKey {
             .collect::<PyResult<Path>>()?;
 
         if path.is_empty() {
-            py_error!("Each alias path must have at least one element")
+            py_error!("Each alias path should have at least one element")
         } else {
             Ok(path)
         }
@@ -181,7 +181,7 @@ impl LookupKey {
                     let mut path_iter = path.iter();
 
                     // first step is different from the rest as we already know dict is JsonObject
-                    // because of above checks, we know that path must have at least one element, hence unwrap
+                    // because of above checks, we know that path should have at least one element, hence unwrap
                     let v: &JsonInput = match path_iter.next().unwrap().json_obj_get(dict) {
                         Some(v) => v,
                         None => continue,
@@ -244,7 +244,7 @@ impl PathItem {
         } else {
             let int_key = obj.extract::<usize>()?;
             if index == 0 {
-                py_error!(PyTypeError; "The first item in an alias path must be a string")
+                py_error!(PyTypeError; "The first item in an alias path should be a string")
             } else {
                 Ok(Self::I(int_key))
             }

src/validators/literal.rs

@@ -26,7 +26,7 @@ impl BuildValidator for LiteralBuilder {
     ) -> PyResult<CombinedValidator> {
         let expected: &PyList = schema.get_as_req(intern!(schema.py(), "expected"))?;
         if expected.is_empty() {
-            return py_error!(r#""expected" must have length > 0"#);
+            return py_error!(r#""expected" should have length > 0"#);
         } else if expected.len() == 1 {
             let first = expected.get_item(0)?;
             if let Ok(str) = first.extract::<String>() {

src/validators/mod.rs

@@ -237,7 +237,7 @@ fn parse_json(input: &PyAny) -> PyResult<serde_json::Result<JsonInput>> {
         Ok(serde_json::from_slice(unsafe { py_byte_array.as_bytes() }))
     } else {
         let input_type = input.get_type().name().unwrap_or("unknown");
-        py_error!(PyTypeError; "JSON input must be str, bytes or bytearray, not {}", input_type)
+        py_error!(PyTypeError; "JSON input should be str, bytes or bytearray, not {}", input_type)
     }
 }