写了日期格式，为什么 2 月 31 日仍通过工具校验？

"""Real jsonschema validation of fixed fictional tool inputs; no network or booking."""
from copy import deepcopy
from datetime import date
from importlib.metadata import version
import json
from pathlib import Path

from jsonschema import Draft202012Validator, FormatChecker
from jsonschema.exceptions import SchemaError, ValidationError

EXPECTED_VERSION = "4.26.0"
START = date(2024, 2, 20)
END = date(2024, 3, 10)
checks = 0


def check(condition, message):
    global checks
    if not condition:
        raise AssertionError(message)
    checks += 1


def schema_for(format_name="date"):
    return {
        "$schema": "https://json-schema.org/draft/2020-12/schema",
        "type": "object",
        "properties": {"visit_date": {"type": "string", "format": format_name}},
        "required": ["visit_date"],
        "additionalProperties": False,
    }


def prepare_date_validator(schema):
    """Preflight this fixed one-field tool contract, not arbitrary remote schemas."""
    Draft202012Validator.check_schema(schema)
    checker = FormatChecker(formats=["date"])
    name = schema["properties"]["visit_date"]["format"]
    if name not in checker.checkers:
        raise ValueError("unsupported_format:" + name)
    return Draft202012Validator(schema, format_checker=checker)


def business_status(payload, validator):
    if not validator.is_valid(payload):
        return "not_checked"
    day = date.fromisoformat(payload["visit_date"])
    return "ready_for_lookup" if START <= day <= END else "outside_fixed_window"


def main():
    installed = version("jsonschema")
    check(installed == EXPECTED_VERSION, "install requirements.txt first")
    schema = schema_for()
    original = deepcopy(schema)
    Draft202012Validator.check_schema(schema)
    default = Draft202012Validator(schema)
    enabled = prepare_date_validator(schema)
    cases = [
        ("valid_leap_day", {"visit_date": "2024-02-29"}, True, True, "ready_for_lookup", []),
        ("impossible_day", {"visit_date": "2024-02-31"}, True, False, "not_checked", ["format"]),
        ("non_leap_year", {"visit_date": "2023-02-29"}, True, False, "not_checked", ["format"]),
        ("not_zero_padded", {"visit_date": "2024-2-9"}, True, False, "not_checked", ["format"]),
        ("wrong_type", {"visit_date": 42}, False, False, "not_checked", ["type"]),
        ("missing", {}, False, False, "not_checked", ["required"]),
        ("extra_field", {"visit_date": "2024-02-29", "book": True}, False, False,
         "not_checked", ["additionalProperties"]),
        ("too_late", {"visit_date": "2024-03-11"}, True, True, "outside_fixed_window", []),
        ("too_early", {"visit_date": "2024-02-19"}, True, True, "outside_fixed_window", []),
    ]
    report = []
    print("jsonschema=" + installed)
    print(f"fictional_window={START.isoformat()}..{END.isoformat()}")
    for name, payload, want_default, want_enabled, want_business, want_errors in cases:
        before = deepcopy(payload)
        without = default.is_valid(payload)
        with_format = enabled.is_valid(payload)
        business = business_status(payload, enabled)
        errors = sorted({str(error.validator) for error in enabled.iter_errors(payload)})
        check(without is want_default, name + " default")
        check(with_format is want_enabled, name + " enabled")
        check(business == want_business, name + " business")
        check(errors == want_errors, name + " error keywords")
        check(payload == before, name + " input unchanged")
        report.append(dict(case=name, payload=payload, default=without, enabled=with_format,
                           business=business, error_keywords=errors))
        print(f"{name}: default={without}; enabled={with_format}; business={business}")

    try:
        enabled.validate({"visit_date": "2024-02-31"})
    except ValidationError as error:
        check(list(error.absolute_path) == ["visit_date"], "instance error path")
        check(list(error.absolute_schema_path) == ["properties", "visit_date", "format"],
              "schema error path")
        print("invalid_date_error: instance=/visit_date; schema=/properties/visit_date/format")
    else:
        raise AssertionError("invalid date accepted")

    typo = schema_for("dtae")
    Draft202012Validator.check_schema(typo)  # A format name is a string, not an enum.
    unknown = Draft202012Validator(typo, format_checker=FormatChecker(formats=["date"]))
    check(unknown.is_valid({"visit_date": "2024-02-31"}), "unknown format is not checked")
    try:
        prepare_date_validator(typo)
    except ValueError as error:
        check(str(error) == "unsupported_format:dtae", "contract preflight rejects typo")
    else:
        raise AssertionError("unknown format configured")
    print("unknown_format=dtae: library_accepts=True; tool_preflight=rejects")

    format_only = Draft202012Validator({"format": "date"}, format_checker=FormatChecker())
    check(format_only.is_valid(42), "format is not a string type assertion")
    malformed = schema_for(7)
    try:
        Draft202012Validator.check_schema(malformed)
    except SchemaError:
        check(True, "numeric format value is a schema error")
    else:
        raise AssertionError("malformed schema accepted")
    check(schema == original, "schema unchanged")
    print("format_only_number=True; nonstring_format_value=SchemaError")
    print(f"PASS checks={checks}")
    Path("report.json").write_text(json.dumps({
        "jsonschema": installed, "scope": "fixed fictional date precheck; no real operation",
        "window": [START.isoformat(), END.isoformat()], "cases": report, "checks": checks,
    }, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")


if __name__ == "__main__":
    main()