Skip to content

Latest commit

 

History

History
246 lines (195 loc) · 8.08 KB

README.md

File metadata and controls

246 lines (195 loc) · 8.08 KB

Pydator

CI PyPI version Python Versions PyPI Downloads License

Pydator is a lightweight, easy-to-use validation library for Python. It provides a clean and intuitive way to validate data using predefined rules.

Installation

# Using pip
pip install pydator

# Using conda
conda install -c conda-forge pydator

Quick Start

from pydator.validator import Validator

# Data to validate
data = {
    "username": "john_doe123",
    "email": "john@example.com",
    "age": 30
}

# Define validation rules
rules = {
    "username": ["required", "string", "min:3", "max:20"],
    "email": ["required", "email"],
    "age": ["required", "integer", "min:18"]
}

# Create validator
validator = Validator(data, rules)

# Validate data
if validator.validate():
    print("All validations passed!")
else:
    print("Validation errors:", validator.errors)

Features

  • Simple and intuitive API
  • Multiple validation rules per field
  • Custom error messages
  • Extensive built-in validation rules
  • Easy to extend with custom rules

Available Validation Rules

Rule Description Example
required Field must be present and not empty "name": ["required"]
string Field must be a string "name": ["string"]
number Field must be a number (integer or float) "price": ["number"]
min:value Minimum value for numbers, minimum length for strings "age": ["min:18"]
max:value Maximum value for numbers, maximum length for strings "bio": ["max:200"]
email Field must be a valid email address "email": ["email"]
boolean Field must be a boolean value "active": ["boolean"]
in:val1,val2,val3 Field value must be in the specified list "status": ["in:pending,active,completed"]
regex:pattern Field must match the regular expression pattern "username": ["regex:^[a-zA-Z0-9_]+$"]
date Field must be a valid date string "birth_date": ["date"]
float Field must be a float number "weight": ["float"]
url Field must be a valid URL "website": ["url"]
integer Field must be an integer "age": ["integer"]
contains:value Field must contain the specified value "description": ["contains:important"]

Advanced Usage

Custom Error Messages

You can customize error messages for specific rules:

data = {
    "username": "",
    "email": "invalid-email"
}

rules = {
    "username": ["required", "string"],
    "email": ["required", "email"]
}

messages = {
    "username.required": "Username is required!",
    "email.email": "Please provide a valid email address."
}

validator = Validator(data, rules, messages)

if not validator.validate():
    print(validator.errors)
    # Output: {'username': ['Username is required!'], 'email': ['Please provide a valid email address.']}

Complete Example

Here's a comprehensive example showing most features:

from pydator.validator import Validator

data = {
    "username": "john_doe123",
    "email": "john@example.com",
    "age": 30,
    "is_active": True,
    "website": "https://example.com",
    "signup_date": "2025-04-24",
    "bio": "Software developer with 10 years of experience.",
    "password": "SecurePass123!",
    "confirm_password": "SecurePass123!",
    "referral_code": "ABC123XYZ",
}

rules = {
    "username": ["required", "string", "min:3", "max:20", "regex:^[a-zA-Z0-9_]+$"],
    "email": ["required", "email"],
    "age": ["required", "integer", "min:18", "max:65"],
    "is_active": ["required", "boolean"],
    "website": ["required", "url"],
    "signup_date": ["required", "date"],
    "bio": ["string", "max:100"],
    "password": ["required", "string", "min:8"],
    "confirm_password": ["required", "string", "min:8"],
    "referral_code": ["string", "regex:^[A-Z0-9]{9}$"],
    "ip_address": ["required", "string"],
}

messages = {
    "username.required": "Username is required!",
    "username.min": "Username must be at least 3 characters long.",
    "username.max": "Username must not exceed 20 characters.",
    "username.regex": "Username can only contain letters, numbers, and underscores.",
    "email.required": "Email address is required!",
    "email.email": "Please provide a valid email address.",
    "age.required": "Age is required!",
    "age.integer": "Age must be a valid number.",
    "age.min": "You must be at least 18 years old.",
    "age.max": "Age must not exceed 65.",
    "is_active.required": "Please specify if the account is active.",
    "is_active.boolean": "Active status must be a boolean value.",
    "website.required": "Website URL is required!",
    "website.url": "Please provide a valid URL.",
    "signup_date.required": "Signup date is required!",
    "signup_date.date": "Please provide a valid date.",
    "bio.max": "Bio must not exceed 100 characters.",
    "password.required": "Password is required!",
    "password.min": "Password must be at least 8 characters long.",
    "confirm_password.required": "Please confirm your password.",
    "confirm_password.min": "Confirmation password must be at least 8 characters long.",
    "referral_code.regex": "Referral code must be exactly 9 characters long and alphanumeric.",
    "ip_address.required": "IP address is required!",
}

validator = Validator(data, rules, messages)

if validator.validate():
    print("All validations passed!")
else:
    print("Validation errors:", validator.errors)

Extending with Custom Rules

You can create custom validation rules by extending the BaseRule class:

from pydator.base_rule import BaseRule
from pydator.validator import Validator
# Define a custom rule by extending BaseRule
class EvenNumberRule(BaseRule):
    def __call__(self, value, *args):
        if not isinstance(value, int):
            return False, self.message("even_number")
        
        if value % 2 != 0:
            return False, self.message("even_number")
        
        return True, None

    def message(self, field, *args):
        return f"The {field} must be an even number."

# Register the custom rule
Validator.register_rule("even_number", EvenNumberRule())

# Now you can use your custom rule in validation
data = {
    "number": 5
}

rules = {
    "number": ["required", "even_number"]
}

validator = Validator(data, rules)

if validator.validate():
    print("Validation passed!")
else:
    print("Validation errors:", validator.errors)

Why Pydator?

  • Simplicity: Easy to learn and use with a clean, intuitive API
  • Flexibility: Validate any data structure with customizable rules
  • Performance: Lightweight with minimal dependencies
  • Extensible: Easy to add custom validation rules
  • Readable: Straightforward validation definitions that are easy to understand

Comparison with other validation libraries

Feature Pydator Other Validation Libraries
Learning Curve Minimal Often steeper
Configuration Simple dict-based Various (class-based, schema-based)
Custom Rules Easy to add Usually requires more code
Dependencies Minimal Often more dependencies
Performance Lightweight Can be heavier

Contributing

Contributions are welcome! Please feel free to submit a Pull Request.

  1. Fork the repository
  2. Create your feature branch (git checkout -b feature/amazing-feature)
  3. Commit your changes (git commit -m 'Add some amazing feature')
  4. Push to the branch (git push origin feature/amazing-feature)
  5. Open a Pull Request

License

This project is licensed under the terms of the MIT license. See LICENSE for more details.