Metadata-Version: 2.4
Name: valify
Version: 0.5.0
Summary: A composable, expressive data validation library for python
Author-email: Darshan Bamankar <darshanbamankar7@gmail.com>
Project-URL: Homepage, https://github.com/DarshanBamankar/valify
Project-URL: Documentation, https://valify.readthedocs.io
Project-URL: Repository, https://github.com/DarshanBamankar/valify
Project-URL: Bug Tracker, https://github.com/DarshanBamankar/valify/issues
Keywords: validation,schema,data
Classifier: Development Status :: 3 - Alpha
Classifier: Intended Audience :: Developers
Classifier: License :: OSI Approved :: MIT License
Classifier: Programming Language :: Python :: 3
Classifier: Topic :: Software Development :: Libraries :: Python Modules
Requires-Python: >=3.10
Description-Content-Type: text/markdown
License-File: LICENSE
Provides-Extra: dev
Requires-Dist: pytest>=7.0; extra == "dev"
Requires-Dist: mypy>=1.0; extra == "dev"
Dynamic: license-file

[![PyPI version](https://badge.fury.io/py/valify.svg)](https://pypi.org/project/valify/)
[![Python](https://img.shields.io/pypi/pyversions/valify.svg)](https://pypi.org/project/valify/)
[![CI](https://github.com/DarshanBamankar/valify/actions/workflows/ci.yml/badge.svg)](https://github.com/DarshanBamankar/valify/actions)
[![Documentation](https://readthedocs.org/projects/valify/badge/?version=latest)](https://valify.readthedocs.io)

# valify

A composable, expressive data validation library for Python.

## Installation

```bash
pip install valify
```

## Quick Start

```python
from valify import Schema, StringValidator, IntValidator, EmailValidator

schema = Schema({
    "name":  StringValidator(min_length=2, max_length=50),
    "age":   IntValidator(min_value=0, max_value=120),
    "email": EmailValidator(),
})

# Valid data — returns cleaned, validated dictionary
result = schema.validate({
    "name":  "Alice",
    "age":   30,
    "email": "alice@example.com",
})
print(result)
# {'name': 'Alice', 'age': 30, 'email': 'alice@example.com'}

# Invalid data — raises ValidationError with ALL errors at once
schema.validate({
    "name":  "A",
    "age":   -5,
    "email": "not-an-email",
})
# ValidationError: Validation failed:
#   name: Must be at least 2 characters long.
#   age: Must be at least 0.
#   email: 'not-an-email' is not a valid email address.
```

## Validators

| Validator | What it checks |
|-----------|---------------|
| `StringValidator` | Strings, with optional min/max length |
| `IntValidator` | Integers, with optional min/max value |
| `FloatValidator` | Floats, with optional min/max value |
| `BoolValidator` | Booleans, with optional string coercion |
| `EmailValidator` | Email address format |
| `OptionalValidator` | Wraps any validator and makes it optional |
| `ListValidator` | Validates every item in a list |
| `EnumValidator` | Value must be one of a fixed set of choices |

## Validators in Detail

### StringValidator

```python
from valify import StringValidator

v = StringValidator(
    min_length=2,   # minimum character length
    max_length=50,  # maximum character length
    strip=True,     # strip whitespace before validating (default: True)
)
```

### IntValidator

```python
from valify import IntValidator

v = IntValidator(
    min_value=0,    # minimum allowed value
    max_value=120,  # maximum allowed value
    coerce=False,   # if True, converts "42" -> 42 (default: False)
)
```

### EmailValidator

```python
from valify import EmailValidator

v = EmailValidator()
v.validate("alice@example.com")  # returns "alice@example.com"
```

## Using Validators Standalone

Validators work without a Schema too:

```python
from valify import IntValidator
from valify.exceptions import ValidationError

v = IntValidator(min_value=0)

try:
    v.validate(-1)
except ValidationError as e:
    print(e.message)  # Must be at least 0.
    print(e.value)    # -1
```

## Nested Schemas

Schemas can be nested inside other schemas for validating complex data:

```python
from valify import Schema, StringValidator, IntValidator

address_schema = Schema({
    "street": StringValidator(min_length=2),
    "city":   StringValidator(min_length=2),
    "pin":    StringValidator(min_length=6, max_length=6),
})

user_schema = Schema({
    "name":    StringValidator(min_length=2),
    "age":     IntValidator(min_value=0),
    "address": address_schema,
})

user_schema.validate({
    "name": "Darshan",
    "age":  20,
    "address": {
        "street": "MG Road",
        "city":   "Pune",
        "pin":    "411001",
    }
})
```

## Error Handling

```python
from valify.exceptions import (
    ValifyError,        # base — catches everything
    ValidationError,    # a value failed validation
    RequiredFieldError, # a required field was missing
    SchemaError,        # the schema definition is invalid
)
```

## Version History

- **0.4.0** — Added nested schema support 
- **0.3.0** — Added `OptionalValidator`, `ListValidator`, `EnumValidator`
- **0.2.0** — Full type hints and mypy compatibility
- **0.1.0** — Initial release

## License

MIT
