fluent_validation 0.1.0

A popular .NET validation library for building strongly-typed validation rules, rewritten in python

Creating your first validator

To define a set of validation rules for a particular object, you will need to create a class that inherits from AbstractValidator[T], where T is the type of class that you wish to validate.

For example, imagine that you have a Customer class:

from dataclasses import dataclass

@dataclass
class Customer: 
  Id:int = None
  Surname:str = None
  Forename:str = None
  Discount:float = None
  Address:str = None

You would define a set of validation rules for this class by inheriting from AbstractValidator[Customer]:

from fluent_validation import AbstractValidator

class CustomerValidator(AbstractValidator[Customer]):
  ...

The validation rules themselves should be defined in the validator class's constructor.

To specify a validation rule for a particular property, call the rule_for method, passing a lambda expression that indicates the property that you wish to validate. For example, to ensure that the Surname property is not null, the validator class would look like this:

from fluent_validation import AbstractValidator

class CustomerValidator(AbstractValidator[Customer]):
  def __init__(self)-> None:
    super().__init__()
    self.rule_for(lambda customer: customer.Surname).not_null()

To run the validator, instantiate the validator object and call the validate method, passing in the object to validate.

customer = Customer()
validator = CustomerValidator()

result = validator.validate(customer)

The validate method returns a ValidationResult object. This contains two properties:

• is_valid - a boolean that says whether the validation succeeded.
• errors - a collection of ValidationFailure objects containing details about any validation failures.

The following code would write any validation failures to the console:

customer = Customer()
validator = CustomerValidator()

results = validator.validate(customer)

if not results.is_valid:
  for failure in results.errors:
    print(f"Property {failure.PropertyName} failed validation. Error was: {failure.ErrorMessage}")

Chaining validators

You can chain multiple validators together for the same property:

from fluent_validation import AbstractValidator

CustomerValidator(AbstractValidator[Customer]):
  def __init__(self)-> None:
    super().__init__()
    rule_for(lambda customer: customer.Surname).not_null().not_equal("foo")

This would ensure that the surname is not null and is not equal to the string 'foo'.