写一个零依赖的 JSON 配置文件校验器

# jsonconf.py —— 仅标准库，Python 3.9+
import copy
import json
import re

class ConfigError(ValueError):
    def __init__(self, errors):
        self.errors = list(errors)
        super().__init__("；".join(f"{p}: {m}" for p, m in self.errors))

_TYPES = {"string": str, "integer": int, "number": (int, float),
          "boolean": bool, "array": list, "object": dict}

def _is_type(value, name):
    if name == "integer":          # True 也会通过 isinstance(x, int)
        return isinstance(value, int) and not isinstance(value, bool)
    if name == "number":
        return isinstance(value, (int, float)) and not isinstance(value, bool)
    return isinstance(value, _TYPES[name])

def _join(path, key):
    return f"{path}.{key}" if isinstance(key, str) else f"{path}[{key}]"

def check(value, schema, path, errors):
    t = schema.get("type")
    if t and not _is_type(value, t):
        errors.append((path, f"期望 {t}，实际是 {type(value).__name__}"))
        return
    if "enum" in schema and value not in schema["enum"]:
        errors.append((path, f"必须是 {schema['enum']} 之一"))
    if t == "string":
        if len(value) < schema.get("minLength", 0):
            errors.append((path, f"长度不能小于 {schema['minLength']}"))
        if "pattern" in schema and not re.fullmatch(schema["pattern"], value):
            errors.append((path, f"不匹配 {schema['pattern']}"))
    elif t in ("integer", "number"):
        if "minimum" in schema and value < schema["minimum"]:
            errors.append((path, f"不能小于 {schema['minimum']}"))
        if "maximum" in schema and value > schema["maximum"]:
            errors.append((path, f"不能大于 {schema['maximum']}"))
    elif t == "object":
        props = schema.get("properties", {})
        for key in schema.get("required", []):
            if key not in value:
                errors.append((_join(path, key), "缺少必填字段"))
        for key, sub in props.items():
            if key in value:
                check(value[key], sub, _join(path, key), errors)
        if schema.get("additionalProperties") is False:
            for key in value.keys() - props.keys():
                errors.append((_join(path, key), "未知字段"))
    elif t == "array" and "items" in schema:
        for i, item in enumerate(value):
            check(item, schema["items"], _join(path, i), errors)

def apply_defaults(value, schema):
    if not isinstance(value, dict):
        return value
    out = dict(value)
    for key, sub in schema.get("properties", {}).items():
        if key in out:
            out[key] = apply_defaults(out[key], sub)
        elif "default" in sub:
            out[key] = copy.deepcopy(sub["default"])  # 避免共享可变默认值
    return out

def _reject_const(name):
    raise ValueError(f"不允许的常量 {name}")

def load_config(path, schema):
    try:
        with open(path, encoding="utf-8-sig") as f:
            data = json.load(f, parse_constant=_reject_const)
    except ValueError as e:
        raise ConfigError([("$", f"JSON 解析失败：{e}")]) from e
    data = apply_defaults(data, schema)
    errors = []
    check(data, schema, "$", errors)
    if errors:
        raise ConfigError(errors)
    return data

SCHEMA = {
    "type": "object",
    "additionalProperties": False,
    "required": ["server"],
    "properties": {
        "server": {
            "type": "object",
            "required": ["port"],
            "properties": {
                "host": {"type": "string", "default": "127.0.0.1"},
                "port": {"type": "integer", "minimum": 1, "maximum": 65535},
                "tls": {"type": "boolean", "default": False},
            },
        },
        "workers": {"type": "integer", "minimum": 1, "maximum": 64, "default": 4},
        "models": {"type": "array", "items": {"type": "string", "minLength": 1}},
    },
}

try:
    cfg = load_config("config.json", SCHEMA)
except ConfigError as e:
    for path, msg in e.errors:
        print(f"{path}: {msg}")
    raise SystemExit(1)