mirror of
https://github.com/kennethreitz/kjvstudy.org.git
synced 2026-06-05 23:00:16 +00:00
711 lines
22 KiB
Python
Executable File
711 lines
22 KiB
Python
Executable File
#!/usr/bin/env python3
|
|
"""
|
|
Validate JSON data files using Pydantic models.
|
|
|
|
This script validates all data files in kjvstudy_org/data/ using Pydantic models
|
|
for type safety and validation. Pydantic provides better error messages and
|
|
integrates naturally with FastAPI.
|
|
|
|
Usage:
|
|
python scripts/validate_data.py # Validate all files
|
|
python scripts/validate_data.py --file bible_metadata.json # Validate specific file
|
|
python scripts/validate_data.py --verbose # Show detailed output
|
|
python scripts/validate_data.py --generate-schemas # Generate JSON schemas
|
|
|
|
Requirements:
|
|
pip install pydantic (already installed with FastAPI)
|
|
"""
|
|
|
|
import json
|
|
import sys
|
|
from pathlib import Path
|
|
from typing import Dict, List, Tuple, Optional
|
|
|
|
try:
|
|
from pydantic import BaseModel, RootModel, Field, field_validator, ValidationError
|
|
except ImportError:
|
|
print("Error: pydantic package not found")
|
|
print("Install with: pip install pydantic")
|
|
sys.exit(1)
|
|
|
|
# Path to data directory
|
|
DATA_DIR = Path(__file__).parent.parent / "kjvstudy_org" / "data"
|
|
SCHEMAS_DIR = DATA_DIR / "schemas"
|
|
|
|
|
|
# ============================================================================
|
|
# Pydantic Models for Data Validation
|
|
# ============================================================================
|
|
|
|
class BibleMetadata(BaseModel):
|
|
"""Schema for bible_metadata.json"""
|
|
old_testament_books: List[str] = Field(..., min_length=39, max_length=39)
|
|
new_testament_books: List[str] = Field(..., min_length=27, max_length=27)
|
|
book_abbreviations: Dict[str, str] = Field(..., min_length=1)
|
|
|
|
@field_validator('old_testament_books', 'new_testament_books')
|
|
@classmethod
|
|
def check_unique_books(cls, v):
|
|
if len(v) != len(set(v)):
|
|
raise ValueError("Duplicate book names found")
|
|
return v
|
|
|
|
|
|
class WordStudy(BaseModel):
|
|
"""Schema for individual word study entry"""
|
|
ot_term: Optional[str] = Field(None, min_length=1)
|
|
ot_transliteration: Optional[str] = Field(None, min_length=1)
|
|
ot_meaning: Optional[str] = Field(None, min_length=1)
|
|
ot_note: Optional[str] = Field(None, min_length=1)
|
|
nt_term: Optional[str] = Field(None, min_length=1)
|
|
nt_transliteration: Optional[str] = Field(None, min_length=1)
|
|
nt_meaning: Optional[str] = Field(None, min_length=1)
|
|
nt_note: Optional[str] = Field(None, min_length=1)
|
|
|
|
|
|
class WordStudies(RootModel[Dict[str, WordStudy]]):
|
|
"""Schema for word_studies.json"""
|
|
root: Dict[str, WordStudy]
|
|
|
|
|
|
class CatalogEntry(BaseModel):
|
|
"""Schema for study guide catalog entry"""
|
|
title: str = Field(..., min_length=1)
|
|
description: str = Field(..., min_length=1)
|
|
slug: str = Field(..., pattern=r'^[a-z-]+$')
|
|
verses: List[str]
|
|
|
|
@field_validator('verses')
|
|
@classmethod
|
|
def check_verse_format(cls, v):
|
|
import re
|
|
pattern = r'^[A-Za-z0-9 ]+ \d+:\d+(-\d+)?$'
|
|
for verse in v:
|
|
if not re.match(pattern, verse):
|
|
raise ValueError(f"Invalid verse reference format: {verse}")
|
|
return v
|
|
|
|
|
|
class StudySection(BaseModel):
|
|
"""Schema for study guide section"""
|
|
title: str = Field(..., min_length=1)
|
|
verses: List[str]
|
|
content: str = Field(..., min_length=1)
|
|
|
|
@field_validator('verses')
|
|
@classmethod
|
|
def check_verse_format(cls, v):
|
|
import re
|
|
pattern = r'^[A-Za-z0-9 ]+ \d+:\d+(-\d+)?$'
|
|
for verse in v:
|
|
if not re.match(pattern, verse):
|
|
raise ValueError(f"Invalid verse reference format: {verse}")
|
|
return v
|
|
|
|
|
|
class GuideContent(BaseModel):
|
|
"""Schema for study guide content"""
|
|
title: str = Field(..., min_length=1)
|
|
description: str = Field(..., min_length=1)
|
|
sections: List[StudySection] = Field(..., min_length=1)
|
|
|
|
|
|
class StudyGuideFile(BaseModel):
|
|
"""Schema for a single study guide file"""
|
|
content: GuideContent
|
|
catalog_entry: Optional[CatalogEntry] = None
|
|
category: Optional[str] = None
|
|
|
|
|
|
class TopicsFile(BaseModel):
|
|
"""Schema for a single topics file"""
|
|
root: Dict[str, dict]
|
|
|
|
|
|
class ReadingPlanFile(BaseModel):
|
|
"""Schema for a single reading plan file"""
|
|
plan: Dict[str, List[Dict[str, object]]]
|
|
|
|
|
|
class VerseCommentaryEntry(BaseModel):
|
|
"""Schema for verse commentary entry"""
|
|
analysis: str = Field(..., min_length=1)
|
|
historical: str = Field(..., min_length=1)
|
|
questions: List[str] = Field(..., min_length=1)
|
|
|
|
|
|
class VerseCommentaryBook(BaseModel):
|
|
"""Schema for a single verse commentary book file"""
|
|
book: str = Field(..., min_length=1)
|
|
commentary: Dict[str, Dict[str, VerseCommentaryEntry]] = Field(..., min_length=1)
|
|
|
|
@field_validator('commentary')
|
|
@classmethod
|
|
def check_numeric_keys(cls, v):
|
|
for chapter_key, verses in v.items():
|
|
if not str(chapter_key).isdigit():
|
|
raise ValueError(f"Invalid chapter key: {chapter_key}")
|
|
if not isinstance(verses, dict) or len(verses) == 0:
|
|
raise ValueError(f"Chapter {chapter_key} must contain verse entries")
|
|
for verse_key, entry in verses.items():
|
|
if not str(verse_key).isdigit():
|
|
raise ValueError(f"Invalid verse key: {verse_key}")
|
|
if not isinstance(entry, (dict, BaseModel)):
|
|
raise ValueError(f"Verse {chapter_key}:{verse_key} must be an object")
|
|
return v
|
|
|
|
|
|
class FeaturedVerse(BaseModel):
|
|
"""Schema for individual featured verse"""
|
|
book: str = Field(..., min_length=1)
|
|
chapter: int = Field(..., ge=1)
|
|
verse: int = Field(..., ge=1)
|
|
|
|
|
|
class FeaturedVerses(BaseModel):
|
|
"""Schema for featured_verses.json"""
|
|
verses: List[FeaturedVerse] = Field(..., min_length=1)
|
|
|
|
|
|
class RedLetterVerses(BaseModel):
|
|
"""Schema for red_letter_verses.json"""
|
|
description: str = Field(..., min_length=1)
|
|
note: str = Field(..., min_length=1)
|
|
verses: Dict[str, str] = Field(..., min_length=1)
|
|
|
|
@field_validator('verses')
|
|
@classmethod
|
|
def check_verses(cls, v):
|
|
import re
|
|
# Validate verse reference format
|
|
pattern = r"^[A-Za-z0-9 ']+ \d+:\d+$"
|
|
for key, value in v.items():
|
|
if not re.match(pattern, key):
|
|
raise ValueError(f"Invalid verse reference key: {key}")
|
|
# Value must be either "full" or a non-empty string
|
|
if value != "full" and (not isinstance(value, str) or len(value) == 0):
|
|
raise ValueError(f"Invalid value for {key}: must be 'full' or a non-empty string")
|
|
return v
|
|
|
|
|
|
class ResourceSlugs(BaseModel):
|
|
"""Schema for resource_slugs.json"""
|
|
study_guides: List[str]
|
|
angels: List[str]
|
|
prophets: List[str]
|
|
names_of_god: List[str]
|
|
parables: List[str]
|
|
covenants: List[str]
|
|
apostles: List[str]
|
|
women: List[str]
|
|
festivals: List[str]
|
|
fruits_of_spirit: List[str]
|
|
|
|
@field_validator('*')
|
|
@classmethod
|
|
def check_slugs(cls, v):
|
|
# Check for duplicates
|
|
if len(v) != len(set(v)):
|
|
raise ValueError("Duplicate slugs found")
|
|
# Check slug format
|
|
import re
|
|
pattern = r'^[a-z-]+$'
|
|
for slug in v:
|
|
if not re.match(pattern, slug):
|
|
raise ValueError(f"Invalid slug format: {slug}")
|
|
return v
|
|
|
|
|
|
class OutlineSection(BaseModel):
|
|
"""Schema for book outline section"""
|
|
section: str = Field(..., min_length=1)
|
|
chapters: str = Field(..., min_length=1)
|
|
description: str = Field(..., min_length=1)
|
|
|
|
|
|
class KeyTheme(BaseModel):
|
|
"""Schema for book key theme"""
|
|
theme: str = Field(..., min_length=1)
|
|
description: str = Field(..., min_length=1)
|
|
|
|
|
|
class KeyVerse(BaseModel):
|
|
"""Schema for book key verse"""
|
|
reference: str = Field(..., min_length=1)
|
|
text: str = Field(..., min_length=1)
|
|
|
|
|
|
class BookIntroduction(BaseModel):
|
|
"""Schema for individual book introduction file"""
|
|
name: str = Field(..., min_length=1)
|
|
abbreviation: str = Field(..., min_length=1)
|
|
testament: str = Field(..., pattern=r'^(Old Testament|New Testament)$')
|
|
position: int = Field(..., ge=1, le=66)
|
|
chapters: int = Field(..., ge=1)
|
|
category: str = Field(..., min_length=1)
|
|
author: str = Field(..., min_length=1)
|
|
date_written: str = Field(..., min_length=1)
|
|
introduction: str = Field(..., min_length=1)
|
|
outline: List[OutlineSection] = Field(..., min_length=1)
|
|
key_themes: List[KeyTheme] = Field(..., min_length=1)
|
|
key_verses: List[KeyVerse] = Field(..., min_length=1)
|
|
christ_in_book: Optional[str] = None
|
|
|
|
|
|
# ============================================================================
|
|
# Validation Logic
|
|
# ============================================================================
|
|
|
|
# Mapping of data files to their Pydantic models
|
|
MODEL_MAPPING = {
|
|
"bible_metadata.json": BibleMetadata,
|
|
"word_studies.json": WordStudies,
|
|
"study_guides": StudyGuideFile,
|
|
"verse_commentary": VerseCommentaryBook,
|
|
"topics": TopicsFile,
|
|
"reading_plans": ReadingPlanFile,
|
|
"featured_verses.json": FeaturedVerses,
|
|
"red_letter_verses.json": RedLetterVerses,
|
|
"resource_slugs.json": ResourceSlugs,
|
|
}
|
|
|
|
|
|
def load_json(file_path: Path) -> Tuple[dict, Optional[str]]:
|
|
"""Load JSON file and return data and error message if any."""
|
|
try:
|
|
with open(file_path, 'r', encoding='utf-8') as f:
|
|
return json.load(f), None
|
|
except json.JSONDecodeError as e:
|
|
return None, f"JSON syntax error: {e}"
|
|
except Exception as e:
|
|
return None, f"Error loading file: {e}"
|
|
|
|
|
|
def validate_file(data_file: str, verbose: bool = False) -> bool:
|
|
"""Validate a single data file using its Pydantic model."""
|
|
if data_file == "verse_commentary":
|
|
return validate_verse_commentary_directory(verbose)
|
|
if data_file == "study_guides":
|
|
return validate_study_guides_directory(verbose)
|
|
if data_file == "topics":
|
|
return validate_topics_directory(verbose)
|
|
if data_file == "reading_plans":
|
|
return validate_reading_plans_directory(verbose)
|
|
|
|
if data_file not in MODEL_MAPPING:
|
|
if verbose:
|
|
print(f"⚠️ {data_file}: No validation model defined (skipped)")
|
|
return True
|
|
|
|
model_class = MODEL_MAPPING[data_file]
|
|
data_path = DATA_DIR / data_file
|
|
|
|
# Check if file exists
|
|
if not data_path.exists():
|
|
print(f"❌ {data_file}: File not found at {data_path}")
|
|
return False
|
|
|
|
# Load data file
|
|
data, error = load_json(data_path)
|
|
if error:
|
|
print(f"❌ {data_file}: {error}")
|
|
return False
|
|
|
|
# Validate using Pydantic model
|
|
try:
|
|
# For RootModel subclasses, pass data directly to constructor
|
|
# For regular BaseModel subclasses, unpack as kwargs
|
|
if issubclass(model_class, RootModel):
|
|
model_class(data)
|
|
else:
|
|
model_class(**data)
|
|
|
|
print(f"✅ {data_file}: Valid")
|
|
if verbose:
|
|
print(f" Model: {model_class.__name__}")
|
|
print(f" Size: {data_path.stat().st_size:,} bytes")
|
|
return True
|
|
|
|
except ValidationError as e:
|
|
print(f"❌ {data_file}: Validation failed")
|
|
for error_detail in e.errors():
|
|
location = " -> ".join(str(loc) for loc in error_detail['loc'])
|
|
print(f" {location}: {error_detail['msg']}")
|
|
if verbose and 'ctx' in error_detail:
|
|
print(f" Context: {error_detail['ctx']}")
|
|
return False
|
|
|
|
except Exception as e:
|
|
print(f"❌ {data_file}: Unexpected error")
|
|
print(f" Error: {str(e)}")
|
|
return False
|
|
|
|
|
|
def validate_verse_commentary_directory(verbose: bool = False) -> bool:
|
|
"""Validate all per-book verse commentary files."""
|
|
dir_path = DATA_DIR / "verse_commentary"
|
|
if not dir_path.exists():
|
|
print(f"❌ verse_commentary: Directory not found at {dir_path}")
|
|
return False
|
|
|
|
passed = 0
|
|
failed = 0
|
|
|
|
for file_path in sorted(dir_path.glob("*.json")):
|
|
data, error = load_json(file_path)
|
|
if error:
|
|
print(f"❌ {file_path.name}: {error}")
|
|
failed += 1
|
|
continue
|
|
|
|
try:
|
|
VerseCommentaryBook(**data)
|
|
if verbose:
|
|
print(f"✅ {file_path.name}: Valid")
|
|
passed += 1
|
|
except ValidationError as e:
|
|
print(f"❌ {file_path.name}: Validation failed")
|
|
for error_detail in e.errors():
|
|
location = " -> ".join(str(loc) for loc in error_detail['loc'])
|
|
print(f" {location}: {error_detail['msg']}")
|
|
failed += 1
|
|
except Exception as e:
|
|
print(f"❌ {file_path.name}: Unexpected error")
|
|
print(f" Error: {str(e)}")
|
|
failed += 1
|
|
|
|
if failed == 0:
|
|
print(f"✅ verse_commentary: Valid ({passed} files)")
|
|
return True
|
|
|
|
print(f"❌ verse_commentary: {failed} files failed validation")
|
|
return False
|
|
|
|
|
|
def validate_study_guides_directory(verbose: bool = False) -> bool:
|
|
"""Validate per-guide study guide files."""
|
|
dir_path = DATA_DIR / "study_guides"
|
|
if not dir_path.exists():
|
|
print(f"❌ study_guides: Directory not found at {dir_path}")
|
|
return False
|
|
|
|
passed = 0
|
|
failed = 0
|
|
|
|
for file_path in sorted(dir_path.glob("*.json")):
|
|
data, error = load_json(file_path)
|
|
if error:
|
|
print(f"❌ {file_path.name}: {error}")
|
|
failed += 1
|
|
continue
|
|
|
|
try:
|
|
StudyGuideFile(**data)
|
|
if verbose:
|
|
print(f"✅ {file_path.name}: Valid")
|
|
passed += 1
|
|
except ValidationError as e:
|
|
print(f"❌ {file_path.name}: Validation failed")
|
|
for error_detail in e.errors():
|
|
location = " -> ".join(str(loc) for loc in error_detail['loc'])
|
|
print(f" {location}: {error_detail['msg']}")
|
|
failed += 1
|
|
except Exception as e:
|
|
print(f"❌ {file_path.name}: Unexpected error")
|
|
print(f" Error: {str(e)}")
|
|
failed += 1
|
|
|
|
if failed == 0:
|
|
print(f"✅ study_guides: Valid ({passed} files)")
|
|
return True
|
|
|
|
print(f"❌ study_guides: {failed} files failed validation")
|
|
return False
|
|
|
|
|
|
def validate_topics_directory(verbose: bool = False) -> bool:
|
|
"""Validate per-topic files."""
|
|
dir_path = DATA_DIR / "topics"
|
|
if not dir_path.exists():
|
|
print(f"❌ topics: Directory not found at {dir_path}")
|
|
return False
|
|
|
|
passed = 0
|
|
failed = 0
|
|
|
|
for file_path in sorted(dir_path.glob("*.json")):
|
|
data, error = load_json(file_path)
|
|
if error:
|
|
print(f"❌ {file_path.name}: {error}")
|
|
failed += 1
|
|
continue
|
|
|
|
try:
|
|
TopicsFile(root=data)
|
|
if verbose:
|
|
print(f"✅ {file_path.name}: Valid")
|
|
passed += 1
|
|
except ValidationError as e:
|
|
print(f"❌ {file_path.name}: Validation failed")
|
|
for error_detail in e.errors():
|
|
location = " -> ".join(str(loc) for loc in error_detail['loc'])
|
|
print(f" {location}: {error_detail['msg']}")
|
|
failed += 1
|
|
except Exception as e:
|
|
print(f"❌ {file_path.name}: Unexpected error")
|
|
print(f" Error: {str(e)}")
|
|
failed += 1
|
|
|
|
if failed == 0:
|
|
print(f"✅ topics: Valid ({passed} files)")
|
|
return True
|
|
|
|
print(f"❌ topics: {failed} files failed validation")
|
|
return False
|
|
|
|
|
|
def validate_reading_plans_directory(verbose: bool = False) -> bool:
|
|
"""Validate per-plan reading plan files."""
|
|
dir_path = DATA_DIR / "reading_plans"
|
|
if not dir_path.exists():
|
|
print(f"❌ reading_plans: Directory not found at {dir_path}")
|
|
return False
|
|
|
|
passed = 0
|
|
failed = 0
|
|
|
|
for file_path in sorted(dir_path.glob("*.json")):
|
|
data, error = load_json(file_path)
|
|
if error:
|
|
print(f"❌ {file_path.name}: {error}")
|
|
failed += 1
|
|
continue
|
|
|
|
try:
|
|
# Each file has one key with the plan id mapping to the plan object
|
|
if len(data) != 1:
|
|
raise ValueError("Reading plan file must contain exactly one plan")
|
|
ReadingPlanFile(plan=data)
|
|
if verbose:
|
|
print(f"✅ {file_path.name}: Valid")
|
|
passed += 1
|
|
except ValidationError as e:
|
|
print(f"❌ {file_path.name}: Validation failed")
|
|
for error_detail in e.errors():
|
|
location = " -> ".join(str(loc) for loc in error_detail['loc'])
|
|
print(f" {location}: {error_detail['msg']}")
|
|
failed += 1
|
|
except Exception as e:
|
|
print(f"❌ {file_path.name}: Unexpected error")
|
|
print(f" Error: {str(e)}")
|
|
failed += 1
|
|
|
|
if failed == 0:
|
|
print(f"✅ reading_plans: Valid ({passed} files)")
|
|
return True
|
|
|
|
print(f"❌ reading_plans: {failed} files failed validation")
|
|
return False
|
|
|
|
|
|
def validate_all(verbose: bool = False) -> Tuple[int, int]:
|
|
"""Validate all data files with models. Returns (passed, failed) counts."""
|
|
passed = 0
|
|
failed = 0
|
|
|
|
print("=" * 60)
|
|
print("Validating JSON data files with Pydantic models")
|
|
print("=" * 60)
|
|
print()
|
|
|
|
for data_file in sorted(MODEL_MAPPING.keys()):
|
|
if validate_file(data_file, verbose):
|
|
passed += 1
|
|
else:
|
|
failed += 1
|
|
if verbose:
|
|
print()
|
|
|
|
return passed, failed
|
|
|
|
|
|
def validate_book_file(book_file: Path, verbose: bool = False) -> bool:
|
|
"""Validate a single book JSON file using BookIntroduction model."""
|
|
# Load data file
|
|
data, error = load_json(book_file)
|
|
if error:
|
|
print(f"❌ {book_file.name}: {error}")
|
|
return False
|
|
|
|
# Validate using Pydantic model
|
|
try:
|
|
BookIntroduction(**data)
|
|
print(f"✅ {book_file.name}: Valid")
|
|
if verbose:
|
|
print(f" Size: {book_file.stat().st_size:,} bytes")
|
|
return True
|
|
|
|
except ValidationError as e:
|
|
print(f"❌ {book_file.name}: Validation failed")
|
|
for error_detail in e.errors():
|
|
location = " -> ".join(str(loc) for loc in error_detail['loc'])
|
|
print(f" {location}: {error_detail['msg']}")
|
|
return False
|
|
|
|
except Exception as e:
|
|
print(f"❌ {book_file.name}: Unexpected error")
|
|
print(f" Error: {str(e)}")
|
|
return False
|
|
|
|
|
|
def validate_all_books(verbose: bool = False) -> Tuple[int, int]:
|
|
"""Validate all 66 book introduction files. Returns (passed, failed) counts."""
|
|
passed = 0
|
|
failed = 0
|
|
|
|
books_dir = DATA_DIR / "books"
|
|
if not books_dir.exists():
|
|
print(f"❌ Books directory not found: {books_dir}")
|
|
return 0, 0
|
|
|
|
print("=" * 60)
|
|
print("Validating 66 book introduction files")
|
|
print("=" * 60)
|
|
print()
|
|
|
|
book_files = sorted(books_dir.glob("*.json"))
|
|
for book_file in book_files:
|
|
if validate_book_file(book_file, verbose):
|
|
passed += 1
|
|
else:
|
|
failed += 1
|
|
if verbose:
|
|
print()
|
|
|
|
return passed, failed
|
|
|
|
|
|
def generate_json_schemas():
|
|
"""Generate JSON Schema files from Pydantic models."""
|
|
print("=" * 60)
|
|
print("Generating JSON Schema files from Pydantic models")
|
|
print("=" * 60)
|
|
print()
|
|
|
|
SCHEMAS_DIR.mkdir(exist_ok=True)
|
|
|
|
# Generate schemas for main data files
|
|
for data_file, model_class in MODEL_MAPPING.items():
|
|
schema_file = data_file.replace('.json', '.schema.json') if data_file.endswith('.json') else f"{data_file}.schema.json"
|
|
schema_path = SCHEMAS_DIR / schema_file
|
|
|
|
try:
|
|
# Generate JSON Schema from Pydantic model
|
|
schema = model_class.model_json_schema()
|
|
|
|
# Add metadata
|
|
schema['$id'] = f"https://kjvstudy.org/schemas/{schema_file}"
|
|
schema['title'] = model_class.__doc__ or model_class.__name__
|
|
|
|
# Write schema file
|
|
with open(schema_path, 'w', encoding='utf-8') as f:
|
|
json.dump(schema, f, indent=2, ensure_ascii=False)
|
|
|
|
print(f"✅ Generated {schema_file}")
|
|
|
|
except Exception as e:
|
|
print(f"❌ Failed to generate {schema_file}: {e}")
|
|
|
|
# Generate schema for book introduction files
|
|
try:
|
|
schema_file = "book_introduction.schema.json"
|
|
schema_path = SCHEMAS_DIR / schema_file
|
|
|
|
schema = BookIntroduction.model_json_schema()
|
|
schema['$id'] = f"https://kjvstudy.org/schemas/{schema_file}"
|
|
schema['title'] = "Schema for individual book introduction files"
|
|
|
|
with open(schema_path, 'w', encoding='utf-8') as f:
|
|
json.dump(schema, f, indent=2, ensure_ascii=False)
|
|
|
|
print(f"✅ Generated {schema_file}")
|
|
|
|
except Exception as e:
|
|
print(f"❌ Failed to generate {schema_file}: {e}")
|
|
|
|
print()
|
|
print(f"Schemas written to: {SCHEMAS_DIR}")
|
|
|
|
|
|
def main():
|
|
"""Main entry point."""
|
|
import argparse
|
|
|
|
parser = argparse.ArgumentParser(
|
|
description="Validate JSON data files with Pydantic models",
|
|
formatter_class=argparse.RawDescriptionHelpFormatter,
|
|
epilog="""
|
|
Examples:
|
|
python scripts/validate_data.py # Validate all files
|
|
python scripts/validate_data.py -f bible_metadata.json # Validate one file
|
|
python scripts/validate_data.py --verbose # Show details
|
|
python scripts/validate_data.py --generate-schemas # Generate JSON schemas
|
|
"""
|
|
)
|
|
parser.add_argument(
|
|
'-f', '--file',
|
|
help='Validate specific file only',
|
|
metavar='FILE'
|
|
)
|
|
parser.add_argument(
|
|
'-v', '--verbose',
|
|
action='store_true',
|
|
help='Show detailed output'
|
|
)
|
|
parser.add_argument(
|
|
'--generate-schemas',
|
|
action='store_true',
|
|
help='Generate JSON Schema files from Pydantic models'
|
|
)
|
|
parser.add_argument(
|
|
'--books',
|
|
action='store_true',
|
|
help='Validate all 66 book introduction files'
|
|
)
|
|
|
|
args = parser.parse_args()
|
|
|
|
# Generate schemas if requested
|
|
if args.generate_schemas:
|
|
generate_json_schemas()
|
|
sys.exit(0)
|
|
|
|
# Validate books if requested
|
|
if args.books:
|
|
passed, failed = validate_all_books(args.verbose)
|
|
|
|
print()
|
|
print("=" * 60)
|
|
print(f"Results: {passed} passed, {failed} failed")
|
|
print("=" * 60)
|
|
|
|
sys.exit(0 if failed == 0 else 1)
|
|
|
|
# Validate specific file or all files
|
|
if args.file:
|
|
success = validate_file(args.file, args.verbose)
|
|
sys.exit(0 if success else 1)
|
|
else:
|
|
passed, failed = validate_all(args.verbose)
|
|
|
|
print()
|
|
print("=" * 60)
|
|
print(f"Results: {passed} passed, {failed} failed")
|
|
print("=" * 60)
|
|
|
|
sys.exit(0 if failed == 0 else 1)
|
|
|
|
|
|
if __name__ == "__main__":
|
|
main()
|