tessl/pypi-yamale

A schema and validator for YAML with comprehensive data type validation and constraint support.

Overview

Eval results

Files

Core Validation Functions

Name: tessl/pypi-yamale
Author: tessl

Primary functions for schema creation, data loading, and validation that form the foundation of Yamale's functionality. These functions provide the essential API for programmatic YAML validation.

Capabilities

Schema Creation

Creates a schema object from a YAML schema file or content string, supporting custom validators and multiple parsers.

def make_schema(path=None, parser="PyYAML", validators=None, content=None):
    """
    Create a Schema object from a YAML schema file or content.

    Parameters:
    - path (str, optional): Path to YAML schema file 
    - parser (str): YAML parser to use - "PyYAML" (default) or "ruamel"
    - validators (dict, optional): Custom validator dictionary, defaults to DefaultValidators
    - content (str, optional): YAML schema content as string (alternative to path)

    Returns:
    Schema: Configured schema object ready for validation

    Raises:
    ValueError: If schema file is empty
    SyntaxError: If schema contains syntax errors
    """

Usage examples:

# From file
schema = yamale.make_schema('./person.yaml')

# From content string  
schema = yamale.make_schema(content="""
name: str()
age: int(min=0, max=150)
""")

# With custom parser
schema = yamale.make_schema('./schema.yaml', parser='ruamel')

# With custom validators
from yamale.validators import DefaultValidators
custom_validators = DefaultValidators.copy()
custom_validators['custom'] = MyCustomValidator
schema = yamale.make_schema('./schema.yaml', validators=custom_validators)

# Or access built-in validators
print(f"Available validators: {list(DefaultValidators.keys())}")
string_validator_class = DefaultValidators['str']

Data Loading

Loads YAML data from files or content strings for validation, returning data in the format expected by the validate function.

def make_data(path=None, parser="PyYAML", content=None):
    """
    Load YAML data from file or content string.

    Parameters:
    - path (str, optional): Path to YAML data file
    - parser (str): YAML parser to use - "PyYAML" (default) or "ruamel"  
    - content (str, optional): YAML data content as string (alternative to path)

    Returns:
    list: List of (data, path) tuples for each YAML document
    """

Usage examples:

# From file
data = yamale.make_data('./person.yaml')

# From content string
data = yamale.make_data(content="""
name: John Doe
age: 30
""")

# With ruamel parser for YAML 1.2 support
data = yamale.make_data('./data.yaml', parser='ruamel')

# Multiple documents in one file
data = yamale.make_data('./multi-doc.yaml')  # Returns multiple (data, path) tuples

Validation

Validates data against a schema with configurable strict mode and error handling options.

def validate(schema, data, strict=True, _raise_error=True):
    """
    Validate data against a schema.

    Parameters:
    - schema (Schema): Schema object created with make_schema()
    - data (list): Data list created with make_data() - list of (data, path) tuples
    - strict (bool): Enable strict mode - reject unexpected elements (default: True)
    - _raise_error (bool): Whether to raise YamaleError on validation failure (default: True)

    Returns:
    list: List of ValidationResult objects

    Raises:
    YamaleError: If validation fails and _raise_error=True
    """

Usage examples:

# Basic validation (raises error on failure)
results = yamale.validate(schema, data)

# Non-strict mode (allows extra fields)
results = yamale.validate(schema, data, strict=False)

# Return results without raising errors
results = yamale.validate(schema, data, _raise_error=False)
for result in results:
    if not result.isValid():
        print(f"Validation failed: {result}")

# Handle validation errors
try:
    yamale.validate(schema, data)
    print("All data is valid!")
except yamale.YamaleError as e:
    print("Validation failed:")
    for result in e.results:
        if not result.isValid():
            print(f"  File: {result.data}")
            for error in result.errors:
                print(f"    {error}")

Complete Workflow Example

import yamale

# Create schema from file
schema = yamale.make_schema('./user-schema.yaml')

# Load multiple data files
data_files = ['user1.yaml', 'user2.yaml', 'user3.yaml']
all_data = []
for file_path in data_files:
    data = yamale.make_data(file_path)
    all_data.extend(data)

# Validate all data
try:
    results = yamale.validate(schema, all_data)
    print(f"Successfully validated {len(all_data)} documents")
except yamale.YamaleError as e:
    print(f"Validation failed for {len([r for r in e.results if not r.isValid()])} documents")
    for result in e.results:
        if not result.isValid():
            print(f"  {result.data}: {'; '.join(result.errors)}")