tessl/pypi-jsonschema

An implementation of JSON Schema validation for Python

—

Pending

Overview

Eval results

Files

Validator Classes

Name: tessl/pypi-jsonschema
Author: tessl

Draft-specific validator implementations providing full compliance with each JSON Schema specification version. Each validator class implements the complete validation logic for its corresponding JSON Schema draft.

Capabilities

Draft 2020-12 Validator

The most recent JSON Schema specification with full support for modern schema features.

class Draft202012Validator:
    """
    Validator for JSON Schema Draft 2020-12.
    
    Attributes:
    - META_SCHEMA: The meta-schema for Draft 2020-12
    - VALIDATORS: Mapping of validation keywords to functions
    - TYPE_CHECKER: Type checker for this draft
    - FORMAT_CHECKER: Format checker for this draft
    """
    
    def __init__(self, schema, registry=None, resolver=None, format_checker=None):
        """
        Initialize validator with schema.
        
        Parameters:
        - schema: The schema to validate against (dict or bool)
        - registry: Schema registry for reference resolution
        - resolver: Deprecated, use registry instead
        - format_checker: FormatChecker for format validation
        """
    
    def validate(self, instance):
        """
        Validate instance against schema.
        
        Parameters:
        - instance: Data to validate
        
        Raises:
        - ValidationError: If validation fails
        """
    
    def is_valid(self, instance):
        """
        Check if instance is valid.
        
        Parameters:
        - instance: Data to validate
        
        Returns:
        - bool: True if valid, False otherwise
        """
    
    def iter_errors(self, instance):
        """
        Lazily yield validation errors.
        
        Parameters:
        - instance: Data to validate
        
        Yields:
        - ValidationError: Each validation error found
        """
    
    def evolve(self, **kwargs):
        """
        Create new validator with modified attributes.
        
        Parameters:
        - schema: New schema (optional)
        - format_checker: New format checker (optional)
        - registry: New registry (optional)
        
        Returns:
        - Validator: New validator instance
        """
    
    @classmethod
    def check_schema(cls, schema):
        """
        Validate schema against meta-schema.
        
        Parameters:
        - schema: Schema to validate
        
        Raises:
        - SchemaError: If schema is invalid
        """
    
    def is_type(self, instance, type):
        """
        Check if instance is of given JSON Schema type.
        
        Parameters:
        - instance: Value to check
        - type: JSON Schema type name
        
        Returns:
        - bool: True if instance is of the type
        
        Raises:
        - UnknownType: If type is unknown
        """

Draft 2019-09 Validator

JSON Schema Draft 2019-09 validator with support for unevaluated properties and items.

class Draft201909Validator:
    """Validator for JSON Schema Draft 2019-09."""
    # Same interface as Draft202012Validator

Draft 7 Validator

Widely adopted JSON Schema Draft 7 validator with if/then/else support.

class Draft7Validator:
    """Validator for JSON Schema Draft 7."""
    # Same interface as Draft202012Validator

Draft 6 Validator

JSON Schema Draft 6 validator with const keyword support.

class Draft6Validator:
    """Validator for JSON Schema Draft 6."""
    # Same interface as Draft202012Validator

Draft 4 Validator

Popular JSON Schema Draft 4 validator widely used in many applications.

class Draft4Validator:
    """Validator for JSON Schema Draft 4."""
    # Same interface as Draft202012Validator

Draft 3 Validator

Legacy JSON Schema Draft 3 validator for backward compatibility.

class Draft3Validator:
    """Validator for JSON Schema Draft 3."""
    # Same interface as Draft202012Validator

Usage Examples

Basic Validator Usage

from jsonschema import Draft202012Validator, ValidationError

schema = {
    "type": "object",
    "properties": {
        "name": {"type": "string"},
        "age": {"type": "integer", "minimum": 0}
    },
    "required": ["name"]
}

validator = Draft202012Validator(schema)

# Valid data
data = {"name": "Alice", "age": 30}
try:
    validator.validate(data)
    print("Valid!")
except ValidationError as e:
    print(f"Invalid: {e.message}")

# Check validity without exception
if validator.is_valid(data):
    print("Data is valid")

# Get all errors
invalid_data = {"age": -5}  # Missing required 'name', invalid age
errors = list(validator.iter_errors(invalid_data))
for error in errors:
    print(f"Error: {error.message} at path: {'.'.join(str(p) for p in error.path)}")

Schema Version Detection

from jsonschema import validator_for

# Schema with explicit version
schema_v7 = {
    "$schema": "http://json-schema.org/draft-07/schema#",
    "type": "string"
}

ValidatorClass = validator_for(schema_v7)
print(ValidatorClass.__name__)  # Draft7Validator

# Use detected validator
validator = ValidatorClass(schema_v7)
validator.validate("hello")  # Valid string

Format Validation

from jsonschema import Draft202012Validator, FormatChecker

schema = {
    "type": "object",
    "properties": {
        "email": {"type": "string", "format": "email"},
        "date": {"type": "string", "format": "date"}
    }
}

format_checker = FormatChecker()
validator = Draft202012Validator(schema, format_checker=format_checker)

# Valid with format checking
valid_data = {
    "email": "user@example.com",
    "date": "2023-12-25"
}
validator.validate(valid_data)  # Passes

# Invalid format
invalid_data = {
    "email": "not-an-email",
    "date": "invalid-date"
}
try:
    validator.validate(invalid_data)
except ValidationError as e:
    print(f"Format error: {e.message}")

Validator Evolution

from jsonschema import Draft202012Validator, FormatChecker

# Base validator
base_validator = Draft202012Validator({"type": "string"})

# Create new validator with different schema
new_validator = base_validator.evolve(
    schema={"type": "number", "minimum": 0}
)

# Create validator with format checking
format_validator = base_validator.evolve(
    format_checker=FormatChecker()
)

Install with Tessl CLI