Allow ordering of constraints

pyproject.toml

@@ -56,6 +56,7 @@ features = ["pyo3/extension-module"]
 [tool.ruff]
 line-length = 120
 extend-select = ['Q', 'RUF100', 'C90', 'I']
+ignore = ['E501']
 flake8-quotes = {inline-quotes = 'single', multiline-quotes = 'double'}
 mccabe = { max-complexity = 13 }
 isort = { known-first-party = ['pydantic_core', 'tests'] }

src/errors/types.rs

@@ -129,12 +129,10 @@ pub enum ErrorType {
  // ---------------------
  // generic length errors - used for everything with a length except strings and bytes which need custom messages
  TooShort {
- field_type: String,
  min_length: usize,
  actual_length: usize,
  },
  TooLong {
- field_type: String,
  max_length: usize,
  actual_length: usize,
  },
@@ -414,14 +412,12 @@ impl ErrorType {
  Self::TooShort { .. } => extract_context!(
  TooShort,
  ctx,
- field_type: String,
  min_length: usize,
  actual_length: usize
  ),
  Self::TooLong { .. } => extract_context!(
  TooLong,
  ctx,
- field_type: String,
  max_length: usize,
  actual_length: usize
  ),
@@ -479,40 +475,44 @@ impl ErrorType {
 
  pub fn message_template_python(&self) -> &'static str {
  match self {
- Self::NoSuchAttribute {..} => "Object has no attribute '{attribute}'",
- Self::JsonInvalid {..} => "Invalid JSON: {error}",
+ Self::NoSuchAttribute { .. } => "Object has no attribute '{attribute}'",
+ Self::JsonInvalid { .. } => "Invalid JSON: {error}",
  Self::JsonType => "JSON input should be string, bytes or bytearray",
  Self::RecursionLoop => "Recursion error - cyclic reference detected",
  Self::Missing => "Field required",
  Self::FrozenField => "Field is frozen",
  Self::FrozenInstance => "Instance is frozen",
  Self::ExtraForbidden => "Extra inputs are not permitted",
  Self::InvalidKey => "Keys should be strings",
- Self::GetAttributeError {..} => "Error extracting attribute: {error}",
- Self::ModelType {..} => "Input should be a valid dictionary or instance of {class_name}",
+ Self::GetAttributeError { .. } => "Error extracting attribute: {error}",
+ Self::ModelType { .. } => "Input should be a valid dictionary or instance of {class_name}",
  Self::ModelAttributesType => "Input should be a valid dictionary or object to extract fields from",
- Self::DataclassType {..} => "Input should be a dictionary or an instance of {class_name}",
- Self::DataclassExactType {..} => "Input should be an instance of {class_name}",
+ Self::DataclassType { .. } => "Input should be a dictionary or an instance of {class_name}",
+ Self::DataclassExactType { .. } => "Input should be an instance of {class_name}",
  Self::NoneRequired => "Input should be None",
- Self::GreaterThan {..} => "Input should be greater than {gt}",
- Self::GreaterThanEqual {..} => "Input should be greater than or equal to {ge}",
- Self::LessThan {..} => "Input should be less than {lt}",
- Self::LessThanEqual {..} => "Input should be less than or equal to {le}",
- Self::MultipleOf {..} => "Input should be a multiple of {multiple_of}",
+ Self::GreaterThan { .. } => "Input should be greater than {gt}",
+ Self::GreaterThanEqual { .. } => "Input should be greater than or equal to {ge}",
+ Self::LessThan { .. } => "Input should be less than {lt}",
+ Self::LessThanEqual { .. } => "Input should be less than or equal to {le}",
+ Self::MultipleOf { .. } => "Input should be a multiple of {multiple_of}",
  Self::FiniteNumber => "Input should be a finite number",
- Self::TooShort {..} => "{field_type} should have at least {min_length} item{expected_plural} after validation, not {actual_length}",
- Self::TooLong {..} => "{field_type} should have at most {max_length} item{expected_plural} after validation, not {actual_length}",
+ Self::TooShort { .. } => {
+ "Data should have at least {min_length} item{expected_plural} after validation, not {actual_length}"
+ }
+ Self::TooLong { .. } => {
+ "Data should have at most {max_length} item{expected_plural} after validation, not {actual_length}"
+ }
  Self::IterableType => "Input should be iterable",
- Self::IterationError {..} => "Error iterating over object, error: {error}",
+ Self::IterationError { .. } => "Error iterating over object, error: {error}",
  Self::StringType => "Input should be a valid string",
  Self::StringSubType => "Input should be a string, not an instance of a subclass of str",
  Self::StringUnicode => "Input should be a valid string, unable to parse raw data as a unicode string",
- Self::StringTooShort {..} => "String should have at least {min_length} characters",
- Self::StringTooLong {..} => "String should have at most {max_length} characters",
- Self::StringPatternMismatch {..} => "String should match pattern '{pattern}'",
- Self::Enum {..} => "Input should be {expected}",
+ Self::StringTooShort { .. } => "String should have at least {min_length} characters",
+ Self::StringTooLong { .. } => "String should have at most {max_length} characters",
+ Self::StringPatternMismatch { .. } => "String should match pattern '{pattern}'",
+ Self::Enum { .. } => "Input should be {expected}",
  Self::DictType => "Input should be a valid dictionary",
- Self::MappingType {..} => "Input should be a valid mapping, error: {error}",
+ Self::MappingType { .. } => "Input should be a valid mapping, error: {error}",
  Self::ListType => "Input should be a valid list",
  Self::TupleType => "Input should be a valid tuple",
  Self::SetType => "Input should be a valid set",
@@ -525,36 +525,38 @@ impl ErrorType {
  Self::FloatType => "Input should be a valid number",
  Self::FloatParsing => "Input should be a valid number, unable to parse string as a number",
  Self::BytesType => "Input should be a valid bytes",
- Self::BytesTooShort {..} => "Data should have at least {min_length} bytes",
- Self::BytesTooLong {..} => "Data should have at most {max_length} bytes",
- Self::ValueError {..} => "Value error, {error}",
- Self::AssertionError {..} => "Assertion failed, {error}",
- Self::CustomError {..} => "",  // custom errors are handled separately
- Self::LiteralError {..} => "Input should be {expected}",
+ Self::BytesTooShort { .. } => "Data should have at least {min_length} bytes",
+ Self::BytesTooLong { .. } => "Data should have at most {max_length} bytes",
+ Self::ValueError { .. } => "Value error, {error}",
+ Self::AssertionError { .. } => "Assertion failed, {error}",
+ Self::CustomError { .. } => "", // custom errors are handled separately
+ Self::LiteralError { .. } => "Input should be {expected}",
  Self::DateType => "Input should be a valid date",
- Self::DateParsing {..} => "Input should be a valid date in the format YYYY-MM-DD, {error}",
- Self::DateFromDatetimeParsing {..} => "Input should be a valid date or datetime, {error}",
+ Self::DateParsing { .. } => "Input should be a valid date in the format YYYY-MM-DD, {error}",
+ Self::DateFromDatetimeParsing { .. } => "Input should be a valid date or datetime, {error}",
  Self::DateFromDatetimeInexact => "Datetimes provided to dates should have zero time - e.g. be exact dates",
  Self::DatePast => "Date should be in the past",
  Self::DateFuture => "Date should be in the future",
  Self::TimeType => "Input should be a valid time",
- Self::TimeParsing {..} => "Input should be in a valid time format, {error}",
+ Self::TimeParsing { .. } => "Input should be in a valid time format, {error}",
  Self::DatetimeType => "Input should be a valid datetime",
- Self::DatetimeParsing {..} => "Input should be a valid datetime, {error}",
- Self::DatetimeObjectInvalid {..} => "Invalid datetime object, got {error}",
+ Self::DatetimeParsing { .. } => "Input should be a valid datetime, {error}",
+ Self::DatetimeObjectInvalid { .. } => "Invalid datetime object, got {error}",
  Self::DatetimePast => "Input should be in the past",
  Self::DatetimeFuture => "Input should be in the future",
  Self::TimezoneNaive => "Input should not have timezone info",
  Self::TimezoneAware => "Input should have timezone info",
- Self::TimezoneOffset {..} => "Timezone offset of {tz_expected} required, got {tz_actual}",
+ Self::TimezoneOffset { .. } => "Timezone offset of {tz_expected} required, got {tz_actual}",
  Self::TimeDeltaType => "Input should be a valid timedelta",
- Self::TimeDeltaParsing {..} => "Input should be a valid timedelta, {error}",
+ Self::TimeDeltaParsing { .. } => "Input should be a valid timedelta, {error}",
  Self::FrozenSetType => "Input should be a valid frozenset",
- Self::IsInstanceOf {..} => "Input should be an instance of {class}",
- Self::IsSubclassOf {..} => "Input should be a subclass of {class}",
+ Self::IsInstanceOf { .. } => "Input should be an instance of {class}",
+ Self::IsSubclassOf { .. } => "Input should be a subclass of {class}",
  Self::CallableType => "Input should be callable",
- Self::UnionTagInvalid {..} => "Input tag '{tag}' found using {discriminator} does not match any of the expected tags: {expected_tags}",
- Self::UnionTagNotFound {..} => "Unable to extract tag using discriminator {discriminator}",
+ Self::UnionTagInvalid { .. } => {
+ "Input tag '{tag}' found using {discriminator} does not match any of the expected tags: {expected_tags}"
+ }
+ Self::UnionTagNotFound { .. } => "Unable to extract tag using discriminator {discriminator}",
  Self::ArgumentsType => "Arguments must be a tuple, list or a dictionary",
  Self::MissingArgument => "Missing required argument",
  Self::UnexpectedKeywordArgument => "Unexpected keyword argument",
@@ -563,14 +565,13 @@ impl ErrorType {
  Self::MissingPositionalOnlyArgument => "Missing required positional only argument",
  Self::MultipleArgumentValues => "Got multiple values for argument",
  Self::UrlType => "URL input should be a string or URL",
- Self::UrlParsing {..} => "Input should be a valid URL, {error}",
- Self::UrlSyntaxViolation {..} => "Input violated strict URL syntax rules, {error}",
- Self::UrlTooLong {..} => "URL should have at most {max_length} characters",
- Self::UrlScheme {..} => "URL scheme should be {expected_schemes}",
+ Self::UrlParsing { .. } => "Input should be a valid URL, {error}",
+ Self::UrlSyntaxViolation { .. } => "Input violated strict URL syntax rules, {error}",
+ Self::UrlTooLong { .. } => "URL should have at most {max_length} characters",
+ Self::UrlScheme { .. } => "URL scheme should be {expected_schemes}",
  Self::UuidType => "UUID input should be a string, bytes or UUID object",
  Self::UuidParsing { .. } => "Input should be a valid UUID, {error}",
- Self::UuidVersion { .. } => "UUID version {expected_version} expected"
-
+ Self::UuidVersion { .. } => "UUID version {expected_version} expected",
  }
  }
 
@@ -632,20 +633,18 @@ impl ErrorType {
  Self::LessThanEqual { le } => to_string_render!(tmpl, le),
  Self::MultipleOf { multiple_of } => to_string_render!(tmpl, multiple_of),
  Self::TooShort {
- field_type,
  min_length,
  actual_length,
  } => {
  let expected_plural = plural_s(*min_length);
- to_string_render!(tmpl, field_type, min_length, actual_length, expected_plural)
+ to_string_render!(tmpl, min_length, actual_length, expected_plural)
  }
  Self::TooLong {
- field_type,
  max_length,
  actual_length,
  } => {
  let expected_plural = plural_s(*max_length);
- to_string_render!(tmpl, field_type, max_length, actual_length, expected_plural)
+ to_string_render!(tmpl, max_length, actual_length, expected_plural)
  }
  Self::IterationError { error } => render!(tmpl, error),
  Self::StringTooShort { min_length } => to_string_render!(tmpl, min_length),
@@ -710,15 +709,13 @@ impl ErrorType {
  Self::LessThanEqual { le } => py_dict!(py, le),
  Self::MultipleOf { multiple_of } => py_dict!(py, multiple_of),
  Self::TooShort {
- field_type,
  min_length,
  actual_length,
- } => py_dict!(py, field_type, min_length, actual_length),
+ } => py_dict!(py, min_length, actual_length),
  Self::TooLong {
- field_type,
  max_length,
  actual_length,
- } => py_dict!(py, field_type, max_length, actual_length),
+ } => py_dict!(py, max_length, actual_length),
  Self::IterationError { error } => py_dict!(py, error),
  Self::StringTooShort { min_length } => py_dict!(py, min_length),
  Self::StringTooLong { max_length } => py_dict!(py, max_length),

src/input/input_abstract.rs

@@ -306,4 +306,5 @@ pub trait Input<'a>: fmt::Debug + ToPyObject {
  ) -> ValResult<EitherTimedelta> {
  self.strict_timedelta(microseconds_overflow_behavior)
  }
+ fn len(&self, py: Python<'_>) -> PyResult<usize>;
 }

src/input/input_json.rs

@@ -334,6 +334,13 @@ impl<'a> Input<'a> for JsonInput {
  _ => Err(ValError::new(ErrorType::TimeDeltaType, self)),
  }
  }
+
+ fn len(&self, py: Python<'_>) -> PyResult<usize> {
+ match self.len() {
+ Some(len) => Ok(len),
+ None => self.to_object(py).as_ref(py).len(),
+ }
+ }
 }
 
 /// Required for Dict keys so the string can behave like an Input
@@ -522,6 +529,10 @@ impl<'a> Input<'a> for String {
  ) -> ValResult<EitherTimedelta> {
  self.validate_timedelta(false, microseconds_overflow_behavior)
  }
+
+ fn len(&self, _py: Python<'_>) -> PyResult<usize> {
+ Ok(self.len())
+ }
 }
 
 fn string_to_vec(s: &str) -> JsonArray {

src/input/input_python.rs

@@ -646,6 +646,10 @@ impl<'a> Input<'a> for PyAny {
  Err(ValError::new(ErrorType::TimeDeltaType, self))
  }
  }
+
+ fn len(&self, _py: Python) -> PyResult<usize> {
+ self.len()
+ }
 }
 
 /// Best effort check of whether it's likely to make sense to inspect obj for attributes and iterate over it

src/input/parse_json.rs

@@ -218,3 +218,14 @@ impl<'de> Visitor<'de> for KeyDeserializer {
  unreachable!()
  }
 }
+
+impl JsonInput {
+ pub fn len(&self) -> Option<usize> {
+ match self {
+ Self::Array(v) => Some(v.len()),
+ Self::Object(o) => Some(o.len()),
+ Self::String(s) => Some(s.len()),
+ _ => None,
+ }
+ }
+}