corvus-json-schema 0.1.0__py3-none-any.whl

corvus_json_schema/__init__.py

@@ -0,0 +1,260 @@
+"""A high-performance JSON Schema evaluator (draft 4, 6, 7, 2019-09 and 2020-12) that compiles schemas to
+specialised Python, with results collection and annotations. A port of the Corvus.Text.Json V5 runtime evaluator, by
+way of its TypeScript port.
+
+    >>> import corvus_json_schema as cjs
+    >>> validate = cjs.compile({"type": "object", "required": ["id"], "properties": {"id": {"type": "integer"}}})
+    >>> validate({"id": 3})
+    True
+    >>> validate({"id": "3"})
+    False
+
+Instances are the values ``json.loads`` produces (``dict``, ``list``, ``str``, ``int``, ``float``, ``bool`` and
+``None``); a validator tests their exact types, so subclasses such as ``OrderedDict`` are not objects to it.
+"""
+
+from __future__ import annotations
+
+import builtins
+import json
+import os
+import re
+import threading
+import types
+from collections.abc import Mapping
+from dataclasses import replace
+from typing import Any, Protocol, cast
+
+from . import runtime
+from .codegen import CodeGenerator, GeneratedCode
+from .collecting import CollectingProgram, evaluate_with_collector, serialize_program
+from .compiler import CompiledSchema, SchemaCompiler, resolve_annotations
+from .dialect import Dialect
+from .options import (
+    CompileOptions,
+    DocumentResolver,
+    FormatValidator,
+    SchemaCompilationError,
+    SchemaEvaluationDepthError,
+)
+from .results import (
+    Annotation,
+    JsonSchemaResultsCollector,
+    ResultsLevel,
+    SchemaResult,
+    collect_annotations,
+    enumerate_annotations,
+    schema_location_fragment,
+)
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "Annotation",
+    "CompileOptions",
+    "Dialect",
+    "DocumentResolver",
+    "FormatValidator",
+    "JsonSchemaResultsCollector",
+    "ResultsLevel",
+    "SchemaCompilationError",
+    "SchemaEvaluationDepthError",
+    "SchemaResult",
+    "Validator",
+    "collect_annotations",
+    "compile",
+    "enumerate_annotations",
+    "generate_module",
+    "schema_location_fragment",
+]
+
+
+class Validator(Protocol):
+    """A compiled validator: returns True when the instance is valid against the schema."""
+
+    def __call__(self, instance: Any) -> bool: ...
+
+    def evaluate(self, instance: Any, collector: JsonSchemaResultsCollector | None = None) -> bool:
+        """Evaluates the instance, reporting results to the collector when one is given (every keyword is evaluated
+        and reported, at the collector's level); without a collector this is the validator itself."""
+        ...
+
+    @property
+    def source(self) -> str:
+        """The generated Python (the body of the validator's module)."""
+        ...
+
+
+def _options(options: CompileOptions | None, overrides: Mapping[str, Any]) -> CompileOptions:
+    base = options if options is not None else CompileOptions()
+    return replace(base, **overrides) if overrides else base
+
+
+def _parse_schema(schema: Any) -> Any:
+    return json.loads(schema) if isinstance(schema, (str, bytes, bytearray)) else schema
+
+
+def _generate(schema: Any, options: CompileOptions) -> tuple[GeneratedCode, CompiledSchema]:
+    program = SchemaCompiler.compile(_parse_schema(schema), options)
+    return CodeGenerator(program).generate(), program
+
+
+def _collecting_program(program: CompiledSchema) -> CollectingProgram:
+    resolve_annotations(program)
+    return CollectingProgram(
+        program.nodes, program.root, program.uses_dynamic_scope, program.options.max_depth, program.options.formats
+    )
+
+
+def _assemble(g: GeneratedCode, functions: bool = True) -> str:
+    s = ""
+    if g.uses_dynamic_scope:
+        s += "DS = []\n"
+    if g.uses_depth:
+        s += f"depth = 0\nMAXDEPTH = {g.max_depth}\n"
+    s += (g.declarations if functions else g.constants) + "\n"
+    if g.uses_dynamic_scope or g.uses_depth:
+        # The dynamic scope and the depth count are module state: one evaluation at a time (re-entrant, for a custom
+        # format that validates with the same validator).
+        s += "LOCK = THREADING.RLock()\n"
+        s += "def validate(x):\n"
+        s += "    global depth\n" if g.uses_depth else ""
+        s += "    with LOCK:\n"
+        if g.uses_depth:
+            s += "        saved = depth\n        depth = 0\n"
+        if g.uses_dynamic_scope:
+            s += f"        scope = DS[:]\n        DS.clear()\n        DS.append({g.root_resource})\n"
+        s += "        try:\n"
+        s += f"            return {g.root}(x)\n"
+        s += "        finally:\n"
+        restore = []
+        if g.uses_depth:
+            restore.append("            depth = saved\n")
+        if g.uses_dynamic_scope:
+            restore.append("            DS[:] = scope\n")
+        s += "".join(restore)
+    else:
+        s += f"validate = {g.root}\n"
+    return s
+
+
+# Programs with more source than this (characters) compile each function on its first call.
+LAZY_MIN_SOURCE = int(os.environ.get("CORVUS_PY_LAZY_MIN", 64 * 1024))
+
+
+def _stub_template(*args: Any) -> Any:
+    return MATERIALISE("@", args)  # type: ignore[name-defined]  # noqa: F821 - a global of the generated module
+
+
+def _install_lazy_functions(namespace: dict[str, Any], functions: list[tuple[str, str]]) -> None:
+    """Defines each function as a stub that, on its first call, compiles the function's source and takes its code:
+    the stub object becomes the function, so references already taken (dispatch tables) need no update."""
+    sources = dict(functions)
+    template = _stub_template.__code__
+
+    def materialise(name: str, args: tuple[Any, ...]) -> Any:
+        stub = namespace[name]
+        module = builtins.compile(sources[name], "<corvus-json-schema>", "exec")
+        stub.__code__ = next(c for c in module.co_consts if isinstance(c, types.CodeType))
+        return stub(*args)
+
+    namespace["MATERIALISE"] = materialise
+    for name, _ in functions:
+        code = template.replace(co_consts=tuple(name if c == "@" else c for c in template.co_consts), co_name=name)
+        namespace[name] = types.FunctionType(code, namespace, name)
+
+
+def _namespace(custom_formats: list[Any]) -> dict[str, Any]:
+    return {
+        "__name__": "corvus_json_schema.generated",
+        "R": runtime,
+        "F": custom_formats,
+        "JSON": json,
+        "RE": re,
+        "THREADING": threading,
+        "NoneType": types.NoneType,
+    }
+
+
+def compile(schema: Any, options: CompileOptions | None = None, **kwargs: Any) -> Validator:
+    """Compiles a schema (a parsed JSON value, or JSON text) into a validator.
+
+    The schema is loaded, its references are resolved and analysed, and the result is emitted as specialised Python
+    and compiled once. Options are given as a ``CompileOptions`` or as its fields by keyword (``default_dialect``,
+    ``assert_format``, ``formats``, ``resolve_document``, ``base_uri``, ``entry_point``, ``max_depth`` and so on).
+    """
+    opts = _options(options, kwargs)
+    g, program = _generate(schema, opts)
+    source = _assemble(g)
+    namespace = _namespace(g.custom_formats)
+    try:
+        if len(source) <= LAZY_MIN_SOURCE:
+            exec(builtins.compile(source, "<corvus-json-schema>", "exec"), namespace)
+        else:
+            # A large program: each function is compiled on its first call, so functions no instance reaches (much of
+            # a large schema, for most instances) are never compiled.
+            _install_lazy_functions(namespace, g.functions)
+            exec(builtins.compile(_assemble(g, functions=False), "<corvus-json-schema>", "exec"), namespace)
+    except SyntaxError as e:
+        raise SchemaCompilationError(f"The schema produced invalid code: {e}") from e
+    validate = namespace["validate"]
+    # The collecting program (annotations included) is built on the first evaluation with a collector.
+    collecting: list[CollectingProgram] = []
+
+    def evaluate(instance: Any, collector: JsonSchemaResultsCollector | None = None) -> bool:
+        if collector is None:
+            return bool(validate(instance))
+        if not collecting:
+            collecting.append(_collecting_program(program))
+        return evaluate_with_collector(collecting[0], instance, collector)
+
+    # The generated function itself is the validator, so a call costs nothing beyond the checks. When the module keeps
+    # evaluation state (a dynamic scope or a depth count), `validate` is already a wrapper that resets it.
+    validate.source = source
+    validate.evaluate = evaluate
+    return cast(Validator, validate)
+
+
+def generate_module(
+    schema: Any,
+    options: CompileOptions | None = None,
+    *,
+    runtime_import: str = "corvus_json_schema.runtime",
+    collecting: bool = True,
+    collecting_import: str = "corvus_json_schema.collecting",
+    **kwargs: Any,
+) -> str:
+    """Generates a standalone Python module for the schema, defining ``validate(instance) -> bool``.
+
+    The module depends only on the runtime helpers (``corvus_json_schema.runtime``), so the schema compiler is not
+    needed where it runs. With ``collecting`` (the default) it also defines ``evaluate(instance, collector=None)``,
+    embedding the program image for results collection. Custom format functions cannot be serialised; supply them to
+    ``compile`` instead.
+    """
+    opts = _options(options, kwargs)
+    g, program = _generate(schema, opts)
+    if g.custom_formats:
+        raise SchemaCompilationError("Custom format functions cannot be emitted into a standalone module.")
+    text = "# Generated by corvus-json-schema. Do not edit.\n"
+    text += "# ruff: noqa\n# fmt: off\n"
+    text += "import json as JSON\nimport re as RE\nimport threading as THREADING\nfrom types import NoneType\n\n"
+    text += f"import {runtime_import} as R\n"
+    if collecting:
+        text += f"from {collecting_import} import evaluate_with_collector, load_program\n"
+    text += "\n" + _assemble(g)
+    text += "\n__all__ = ['validate'" + (", 'evaluate'" if collecting else "") + "]\n"
+    if collecting:
+        image = serialize_program(_collecting_program(program))
+        text += (
+            f"\n_image = {image!r}\n"
+            "_program = None\n\n\n"
+            "def evaluate(instance, collector=None):\n"
+            '    """Evaluates the instance, reporting to the results collector when one is given."""\n'
+            "    global _program\n"
+            "    if collector is None:\n"
+            "        return validate(instance)\n"
+            "    if _program is None:\n"
+            "        _program = load_program(_image)\n"
+            "    return evaluate_with_collector(_program, instance, collector)\n"
+        )
+    return text

corvus_json_schema/_metaschemas.py

@@ -0,0 +1,27 @@
+# <auto-generated> by scripts/embed_metaschemas.py from src/Corvus.Text.Json/metaschema. Do not edit.
+
+"""The standard metaschemas, keyed by their canonical URI (no trailing empty fragment)."""
+
+METASCHEMAS: dict[str, str] = {
+    "http://json-schema.org/draft-04/schema": '{"id":"http://json-schema.org/draft-04/schema#","$schema":"http://json-schema.org/draft-04/schema#","description":"Core schema meta-schema","definitions":{"schemaArray":{"type":"array","minItems":1,"items":{"$ref":"#"}},"positiveInteger":{"type":"integer","minimum":0},"positiveIntegerDefault0":{"allOf":[{"$ref":"#/definitions/positiveInteger"},{"default":0}]},"simpleTypes":{"enum":["array","boolean","integer","null","number","object","string"]},"stringArray":{"type":"array","items":{"type":"string"},"minItems":1,"uniqueItems":true}},"type":"object","properties":{"id":{"type":"string"},"$schema":{"type":"string"},"title":{"type":"string"},"description":{"type":"string"},"default":{},"multipleOf":{"type":"number","minimum":0,"exclusiveMinimum":true},"maximum":{"type":"number"},"exclusiveMaximum":{"type":"boolean","default":false},"minimum":{"type":"number"},"exclusiveMinimum":{"type":"boolean","default":false},"maxLength":{"$ref":"#/definitions/positiveInteger"},"minLength":{"$ref":"#/definitions/positiveIntegerDefault0"},"pattern":{"type":"string","format":"regex"},"additionalItems":{"anyOf":[{"type":"boolean"},{"$ref":"#"}],"default":{}},"items":{"anyOf":[{"$ref":"#"},{"$ref":"#/definitions/schemaArray"}],"default":{}},"maxItems":{"$ref":"#/definitions/positiveInteger"},"minItems":{"$ref":"#/definitions/positiveIntegerDefault0"},"uniqueItems":{"type":"boolean","default":false},"maxProperties":{"$ref":"#/definitions/positiveInteger"},"minProperties":{"$ref":"#/definitions/positiveIntegerDefault0"},"required":{"$ref":"#/definitions/stringArray"},"additionalProperties":{"anyOf":[{"type":"boolean"},{"$ref":"#"}],"default":{}},"definitions":{"type":"object","additionalProperties":{"$ref":"#"},"default":{}},"properties":{"type":"object","additionalProperties":{"$ref":"#"},"default":{}},"patternProperties":{"type":"object","additionalProperties":{"$ref":"#"},"default":{}},"dependencies":{"type":"object","additionalProperties":{"anyOf":[{"$ref":"#"},{"$ref":"#/definitions/stringArray"}]}},"enum":{"type":"array","minItems":1,"uniqueItems":true},"type":{"anyOf":[{"$ref":"#/definitions/simpleTypes"},{"type":"array","items":{"$ref":"#/definitions/simpleTypes"},"minItems":1,"uniqueItems":true}]},"format":{"type":"string"},"allOf":{"$ref":"#/definitions/schemaArray"},"anyOf":{"$ref":"#/definitions/schemaArray"},"oneOf":{"$ref":"#/definitions/schemaArray"},"not":{"$ref":"#"}},"dependencies":{"exclusiveMaximum":["maximum"],"exclusiveMinimum":["minimum"]},"default":{}}',
+    "http://json-schema.org/draft-06/schema": '{"$schema":"http://json-schema.org/draft-06/schema#","$id":"http://json-schema.org/draft-06/schema#","title":"Core schema meta-schema","definitions":{"schemaArray":{"type":"array","minItems":1,"items":{"$ref":"#"}},"nonNegativeInteger":{"type":"integer","minimum":0},"nonNegativeIntegerDefault0":{"allOf":[{"$ref":"#/definitions/nonNegativeInteger"},{"default":0}]},"simpleTypes":{"enum":["array","boolean","integer","null","number","object","string"]},"stringArray":{"type":"array","items":{"type":"string"},"uniqueItems":true,"default":[]}},"type":["object","boolean"],"properties":{"$id":{"type":"string","format":"uri-reference"},"$schema":{"type":"string","format":"uri"},"$ref":{"type":"string","format":"uri-reference"},"title":{"type":"string"},"description":{"type":"string"},"default":{},"examples":{"type":"array","items":{}},"multipleOf":{"type":"number","exclusiveMinimum":0},"maximum":{"type":"number"},"exclusiveMaximum":{"type":"number"},"minimum":{"type":"number"},"exclusiveMinimum":{"type":"number"},"maxLength":{"$ref":"#/definitions/nonNegativeInteger"},"minLength":{"$ref":"#/definitions/nonNegativeIntegerDefault0"},"pattern":{"type":"string","format":"regex"},"additionalItems":{"$ref":"#"},"items":{"anyOf":[{"$ref":"#"},{"$ref":"#/definitions/schemaArray"}],"default":{}},"maxItems":{"$ref":"#/definitions/nonNegativeInteger"},"minItems":{"$ref":"#/definitions/nonNegativeIntegerDefault0"},"uniqueItems":{"type":"boolean","default":false},"contains":{"$ref":"#"},"maxProperties":{"$ref":"#/definitions/nonNegativeInteger"},"minProperties":{"$ref":"#/definitions/nonNegativeIntegerDefault0"},"required":{"$ref":"#/definitions/stringArray"},"additionalProperties":{"$ref":"#"},"definitions":{"type":"object","additionalProperties":{"$ref":"#"},"default":{}},"properties":{"type":"object","additionalProperties":{"$ref":"#"},"default":{}},"patternProperties":{"type":"object","additionalProperties":{"$ref":"#"},"propertyNames":{"format":"regex"},"default":{}},"dependencies":{"type":"object","additionalProperties":{"anyOf":[{"$ref":"#"},{"$ref":"#/definitions/stringArray"}]}},"propertyNames":{"$ref":"#"},"const":{},"enum":{"type":"array","minItems":1,"uniqueItems":true},"type":{"anyOf":[{"$ref":"#/definitions/simpleTypes"},{"type":"array","items":{"$ref":"#/definitions/simpleTypes"},"minItems":1,"uniqueItems":true}]},"format":{"type":"string"},"allOf":{"$ref":"#/definitions/schemaArray"},"anyOf":{"$ref":"#/definitions/schemaArray"},"oneOf":{"$ref":"#/definitions/schemaArray"},"not":{"$ref":"#"}},"default":{}}',
+    "http://json-schema.org/draft-07/schema": '{"$schema":"http://json-schema.org/draft-07/schema#","$id":"http://json-schema.org/draft-07/schema#","title":"Core schema meta-schema","definitions":{"schemaArray":{"type":"array","minItems":1,"items":{"$ref":"#"}},"nonNegativeInteger":{"type":"integer","minimum":0},"nonNegativeIntegerDefault0":{"allOf":[{"$ref":"#/definitions/nonNegativeInteger"},{"default":0}]},"simpleTypes":{"enum":["array","boolean","integer","null","number","object","string"]},"stringArray":{"type":"array","items":{"type":"string"},"uniqueItems":true,"default":[]}},"type":["object","boolean"],"properties":{"$id":{"type":"string","format":"uri-reference"},"$schema":{"type":"string","format":"uri"},"$ref":{"type":"string","format":"uri-reference"},"$comment":{"type":"string"},"title":{"type":"string"},"description":{"type":"string"},"default":true,"readOnly":{"type":"boolean","default":false},"writeOnly":{"type":"boolean","default":false},"examples":{"type":"array","items":true},"multipleOf":{"type":"number","exclusiveMinimum":0},"maximum":{"type":"number"},"exclusiveMaximum":{"type":"number"},"minimum":{"type":"number"},"exclusiveMinimum":{"type":"number"},"maxLength":{"$ref":"#/definitions/nonNegativeInteger"},"minLength":{"$ref":"#/definitions/nonNegativeIntegerDefault0"},"pattern":{"type":"string","format":"regex"},"additionalItems":{"$ref":"#"},"items":{"anyOf":[{"$ref":"#"},{"$ref":"#/definitions/schemaArray"}],"default":true},"maxItems":{"$ref":"#/definitions/nonNegativeInteger"},"minItems":{"$ref":"#/definitions/nonNegativeIntegerDefault0"},"uniqueItems":{"type":"boolean","default":false},"contains":{"$ref":"#"},"maxProperties":{"$ref":"#/definitions/nonNegativeInteger"},"minProperties":{"$ref":"#/definitions/nonNegativeIntegerDefault0"},"required":{"$ref":"#/definitions/stringArray"},"additionalProperties":{"$ref":"#"},"definitions":{"type":"object","additionalProperties":{"$ref":"#"},"default":{}},"properties":{"type":"object","additionalProperties":{"$ref":"#"},"default":{}},"patternProperties":{"type":"object","additionalProperties":{"$ref":"#"},"propertyNames":{"format":"regex"},"default":{}},"dependencies":{"type":"object","additionalProperties":{"anyOf":[{"$ref":"#"},{"$ref":"#/definitions/stringArray"}]}},"propertyNames":{"$ref":"#"},"const":true,"enum":{"type":"array","items":true,"minItems":1,"uniqueItems":true},"type":{"anyOf":[{"$ref":"#/definitions/simpleTypes"},{"type":"array","items":{"$ref":"#/definitions/simpleTypes"},"minItems":1,"uniqueItems":true}]},"format":{"type":"string"},"contentMediaType":{"type":"string"},"contentEncoding":{"type":"string"},"if":{"$ref":"#"},"then":{"$ref":"#"},"else":{"$ref":"#"},"allOf":{"$ref":"#/definitions/schemaArray"},"anyOf":{"$ref":"#/definitions/schemaArray"},"oneOf":{"$ref":"#/definitions/schemaArray"},"not":{"$ref":"#"}},"default":true}',
+    "https://json-schema.org/draft/2019-09/schema": '{"$schema":"https://json-schema.org/draft/2019-09/schema","$id":"https://json-schema.org/draft/2019-09/schema","$vocabulary":{"https://json-schema.org/draft/2019-09/vocab/core":true,"https://json-schema.org/draft/2019-09/vocab/applicator":true,"https://json-schema.org/draft/2019-09/vocab/validation":true,"https://json-schema.org/draft/2019-09/vocab/meta-data":true,"https://json-schema.org/draft/2019-09/vocab/format":false,"https://json-schema.org/draft/2019-09/vocab/content":true},"$recursiveAnchor":true,"title":"Core and Validation specifications meta-schema","allOf":[{"$ref":"meta/core"},{"$ref":"meta/applicator"},{"$ref":"meta/validation"},{"$ref":"meta/meta-data"},{"$ref":"meta/format"},{"$ref":"meta/content"}],"type":["object","boolean"],"properties":{"definitions":{"$comment":"While no longer an official keyword as it is replaced by $defs, this keyword is retained in the meta-schema to prevent incompatible extensions as it remains in common use.","type":"object","additionalProperties":{"$recursiveRef":"#"},"default":{}},"dependencies":{"$comment":"\\"dependencies\\" is no longer a keyword, but schema authors should avoid redefining it to facilitate a smooth transition to \\"dependentSchemas\\" and \\"dependentRequired\\"","type":"object","additionalProperties":{"anyOf":[{"$recursiveRef":"#"},{"$ref":"meta/validation#/$defs/stringArray"}]}}}}',
+    "https://json-schema.org/draft/2020-12/schema": '{"$schema":"https://json-schema.org/draft/2020-12/schema","$id":"https://json-schema.org/draft/2020-12/schema","$vocabulary":{"https://json-schema.org/draft/2020-12/vocab/core":true,"https://json-schema.org/draft/2020-12/vocab/applicator":true,"https://json-schema.org/draft/2020-12/vocab/unevaluated":true,"https://json-schema.org/draft/2020-12/vocab/validation":true,"https://json-schema.org/draft/2020-12/vocab/meta-data":true,"https://json-schema.org/draft/2020-12/vocab/format-annotation":true,"https://json-schema.org/draft/2020-12/vocab/content":true},"$dynamicAnchor":"meta","title":"Core and Validation specifications meta-schema","allOf":[{"$ref":"meta/core"},{"$ref":"meta/applicator"},{"$ref":"meta/unevaluated"},{"$ref":"meta/validation"},{"$ref":"meta/meta-data"},{"$ref":"meta/format-annotation"},{"$ref":"meta/content"}],"type":["object","boolean"],"$comment":"This meta-schema also defines keywords that have appeared in previous drafts in order to prevent incompatible extensions as they remain in common use.","properties":{"definitions":{"$comment":"\\"definitions\\" has been replaced by \\"$defs\\".","type":"object","additionalProperties":{"$dynamicRef":"#meta"},"deprecated":true,"default":{}},"dependencies":{"$comment":"\\"dependencies\\" has been split and replaced by \\"dependentSchemas\\" and \\"dependentRequired\\" in order to serve their differing semantics.","type":"object","additionalProperties":{"anyOf":[{"$dynamicRef":"#meta"},{"$ref":"meta/validation#/$defs/stringArray"}]},"deprecated":true,"default":{}},"$recursiveAnchor":{"$comment":"\\"$recursiveAnchor\\" has been replaced by \\"$dynamicAnchor\\".","$ref":"meta/core#/$defs/anchorString","deprecated":true},"$recursiveRef":{"$comment":"\\"$recursiveRef\\" has been replaced by \\"$dynamicRef\\".","$ref":"meta/core#/$defs/uriReferenceString","deprecated":true}}}',
+    "https://json-schema.org/draft/2019-09/meta/applicator": '{"$schema":"https://json-schema.org/draft/2019-09/schema","$id":"https://json-schema.org/draft/2019-09/meta/applicator","$recursiveAnchor":true,"title":"Applicator vocabulary meta-schema","type":["object","boolean"],"properties":{"additionalItems":{"$recursiveRef":"#"},"unevaluatedItems":{"$recursiveRef":"#"},"items":{"anyOf":[{"$recursiveRef":"#"},{"$ref":"#/$defs/schemaArray"}]},"contains":{"$recursiveRef":"#"},"additionalProperties":{"$recursiveRef":"#"},"unevaluatedProperties":{"$recursiveRef":"#"},"properties":{"type":"object","additionalProperties":{"$recursiveRef":"#"},"default":{}},"patternProperties":{"type":"object","additionalProperties":{"$recursiveRef":"#"},"propertyNames":{"format":"regex"},"default":{}},"dependentSchemas":{"type":"object","additionalProperties":{"$recursiveRef":"#"}},"propertyNames":{"$recursiveRef":"#"},"if":{"$recursiveRef":"#"},"then":{"$recursiveRef":"#"},"else":{"$recursiveRef":"#"},"allOf":{"$ref":"#/$defs/schemaArray"},"anyOf":{"$ref":"#/$defs/schemaArray"},"oneOf":{"$ref":"#/$defs/schemaArray"},"not":{"$recursiveRef":"#"}},"$defs":{"schemaArray":{"type":"array","minItems":1,"items":{"$recursiveRef":"#"}}}}',
+    "https://json-schema.org/draft/2019-09/meta/content": '{"$schema":"https://json-schema.org/draft/2019-09/schema","$id":"https://json-schema.org/draft/2019-09/meta/content","$recursiveAnchor":true,"title":"Content vocabulary meta-schema","type":["object","boolean"],"properties":{"contentMediaType":{"type":"string"},"contentEncoding":{"type":"string"},"contentSchema":{"$recursiveRef":"#"}}}',
+    "https://json-schema.org/draft/2019-09/meta/core": '{"$schema":"https://json-schema.org/draft/2019-09/schema","$id":"https://json-schema.org/draft/2019-09/meta/core","$recursiveAnchor":true,"title":"Core vocabulary meta-schema","type":["object","boolean"],"properties":{"$id":{"type":"string","format":"uri-reference","$comment":"Non-empty fragments not allowed.","pattern":"^[^#]*#?$"},"$schema":{"type":"string","format":"uri"},"$anchor":{"type":"string","pattern":"^[A-Za-z][-A-Za-z0-9.:_]*$"},"$ref":{"type":"string","format":"uri-reference"},"$recursiveRef":{"type":"string","format":"uri-reference"},"$recursiveAnchor":{"type":"boolean","default":false},"$vocabulary":{"type":"object","propertyNames":{"type":"string","format":"uri"},"additionalProperties":{"type":"boolean"}},"$comment":{"type":"string"},"$defs":{"type":"object","additionalProperties":{"$recursiveRef":"#"},"default":{}}}}',
+    "https://json-schema.org/draft/2019-09/meta/format": '{"$schema":"https://json-schema.org/draft/2019-09/schema","$id":"https://json-schema.org/draft/2019-09/meta/format","$recursiveAnchor":true,"title":"Format vocabulary meta-schema","type":["object","boolean"],"properties":{"format":{"type":"string"}}}',
+    "https://json-schema.org/draft/2019-09/meta/hyper-schema": '{"$schema":"https://json-schema.org/draft/2019-09/hyper-schema","$id":"https://json-schema.org/draft/2019-09/meta/hyper-schema","$recursiveAnchor":true,"title":"JSON Hyper-Schema Vocabulary Schema","type":["object","boolean"],"properties":{"base":{"type":"string","format":"uri-template"},"links":{"type":"array","items":{"$ref":"https://json-schema.org/draft/2019-09/links"}}},"links":[{"rel":"self","href":"{+%24id}"}]}',
+    "https://json-schema.org/draft/2019-09/meta/meta-data": '{"$schema":"https://json-schema.org/draft/2019-09/schema","$id":"https://json-schema.org/draft/2019-09/meta/meta-data","$recursiveAnchor":true,"title":"Meta-data vocabulary meta-schema","type":["object","boolean"],"properties":{"title":{"type":"string"},"description":{"type":"string"},"default":true,"deprecated":{"type":"boolean","default":false},"readOnly":{"type":"boolean","default":false},"writeOnly":{"type":"boolean","default":false},"examples":{"type":"array","items":true}}}',
+    "https://json-schema.org/draft/2019-09/meta/validation": '{"$schema":"https://json-schema.org/draft/2019-09/schema","$id":"https://json-schema.org/draft/2019-09/meta/validation","$recursiveAnchor":true,"title":"Validation vocabulary meta-schema","type":["object","boolean"],"properties":{"multipleOf":{"type":"number","exclusiveMinimum":0},"maximum":{"type":"number"},"exclusiveMaximum":{"type":"number"},"minimum":{"type":"number"},"exclusiveMinimum":{"type":"number"},"maxLength":{"$ref":"#/$defs/nonNegativeInteger"},"minLength":{"$ref":"#/$defs/nonNegativeIntegerDefault0"},"pattern":{"type":"string","format":"regex"},"maxItems":{"$ref":"#/$defs/nonNegativeInteger"},"minItems":{"$ref":"#/$defs/nonNegativeIntegerDefault0"},"uniqueItems":{"type":"boolean","default":false},"maxContains":{"$ref":"#/$defs/nonNegativeInteger"},"minContains":{"$ref":"#/$defs/nonNegativeInteger","default":1},"maxProperties":{"$ref":"#/$defs/nonNegativeInteger"},"minProperties":{"$ref":"#/$defs/nonNegativeIntegerDefault0"},"required":{"$ref":"#/$defs/stringArray"},"dependentRequired":{"type":"object","additionalProperties":{"$ref":"#/$defs/stringArray"}},"const":true,"enum":{"type":"array","items":true},"type":{"anyOf":[{"$ref":"#/$defs/simpleTypes"},{"type":"array","items":{"$ref":"#/$defs/simpleTypes"},"minItems":1,"uniqueItems":true}]}},"$defs":{"nonNegativeInteger":{"type":"integer","minimum":0},"nonNegativeIntegerDefault0":{"$ref":"#/$defs/nonNegativeInteger","default":0},"simpleTypes":{"enum":["array","boolean","integer","null","number","object","string"]},"stringArray":{"type":"array","items":{"type":"string"},"uniqueItems":true,"default":[]}}}',
+    "https://json-schema.org/draft/2020-12/meta/applicator": '{"$schema":"https://json-schema.org/draft/2020-12/schema","$id":"https://json-schema.org/draft/2020-12/meta/applicator","$dynamicAnchor":"meta","title":"Applicator vocabulary meta-schema","type":["object","boolean"],"properties":{"prefixItems":{"$ref":"#/$defs/schemaArray"},"items":{"$dynamicRef":"#meta"},"contains":{"$dynamicRef":"#meta"},"additionalProperties":{"$dynamicRef":"#meta"},"properties":{"type":"object","additionalProperties":{"$dynamicRef":"#meta"},"default":{}},"patternProperties":{"type":"object","additionalProperties":{"$dynamicRef":"#meta"},"propertyNames":{"format":"regex"},"default":{}},"dependentSchemas":{"type":"object","additionalProperties":{"$dynamicRef":"#meta"},"default":{}},"propertyNames":{"$dynamicRef":"#meta"},"if":{"$dynamicRef":"#meta"},"then":{"$dynamicRef":"#meta"},"else":{"$dynamicRef":"#meta"},"allOf":{"$ref":"#/$defs/schemaArray"},"anyOf":{"$ref":"#/$defs/schemaArray"},"oneOf":{"$ref":"#/$defs/schemaArray"},"not":{"$dynamicRef":"#meta"}},"$defs":{"schemaArray":{"type":"array","minItems":1,"items":{"$dynamicRef":"#meta"}}}}',
+    "https://json-schema.org/draft/2020-12/meta/content": '{"$schema":"https://json-schema.org/draft/2020-12/schema","$id":"https://json-schema.org/draft/2020-12/meta/content","$dynamicAnchor":"meta","title":"Content vocabulary meta-schema","type":["object","boolean"],"properties":{"contentEncoding":{"type":"string"},"contentMediaType":{"type":"string"},"contentSchema":{"$dynamicRef":"#meta"}}}',
+    "https://json-schema.org/draft/2020-12/meta/core": '{"$schema":"https://json-schema.org/draft/2020-12/schema","$id":"https://json-schema.org/draft/2020-12/meta/core","$dynamicAnchor":"meta","title":"Core vocabulary meta-schema","type":["object","boolean"],"properties":{"$id":{"$ref":"#/$defs/uriReferenceString","$comment":"Non-empty fragments not allowed.","pattern":"^[^#]*#?$"},"$schema":{"$ref":"#/$defs/uriString"},"$ref":{"$ref":"#/$defs/uriReferenceString"},"$anchor":{"$ref":"#/$defs/anchorString"},"$dynamicRef":{"$ref":"#/$defs/uriReferenceString"},"$dynamicAnchor":{"$ref":"#/$defs/anchorString"},"$vocabulary":{"type":"object","propertyNames":{"$ref":"#/$defs/uriString"},"additionalProperties":{"type":"boolean"}},"$comment":{"type":"string"},"$defs":{"type":"object","additionalProperties":{"$dynamicRef":"#meta"}}},"$defs":{"anchorString":{"type":"string","pattern":"^[A-Za-z_][-A-Za-z0-9._]*$"},"uriString":{"type":"string","format":"uri"},"uriReferenceString":{"type":"string","format":"uri-reference"}}}',
+    "https://json-schema.org/draft/2020-12/meta/format-annotation": '{"$schema":"https://json-schema.org/draft/2020-12/schema","$id":"https://json-schema.org/draft/2020-12/meta/format-annotation","$dynamicAnchor":"meta","title":"Format vocabulary meta-schema for annotation results","type":["object","boolean"],"properties":{"format":{"type":"string"}}}',
+    "https://json-schema.org/draft/2020-12/meta/format-assertion": '{"$schema":"https://json-schema.org/draft/2020-12/schema","$id":"https://json-schema.org/draft/2020-12/meta/format-assertion","$dynamicAnchor":"meta","title":"Format vocabulary meta-schema for assertion results","type":["object","boolean"],"properties":{"format":{"type":"string"}}}',
+    "https://json-schema.org/draft/2020-12/meta/hyper-schema": '{"$schema":"https://json-schema.org/draft/2020-12/hyper-schema","$id":"https://json-schema.org/draft/2020-12/meta/hyper-schema","$dynamicAnchor":"meta","title":"JSON Hyper-Schema Vocabulary Schema","type":["object","boolean"],"properties":{"base":{"type":"string","format":"uri-template"},"links":{"type":"array","items":{"$ref":"https://json-schema.org/draft/2020-12/links"}}},"links":[{"rel":"self","href":"{+%24id}"}]}',
+    "https://json-schema.org/draft/2020-12/meta/meta-data": '{"$schema":"https://json-schema.org/draft/2020-12/schema","$id":"https://json-schema.org/draft/2020-12/meta/meta-data","$dynamicAnchor":"meta","title":"Meta-data vocabulary meta-schema","type":["object","boolean"],"properties":{"title":{"type":"string"},"description":{"type":"string"},"default":true,"deprecated":{"type":"boolean","default":false},"readOnly":{"type":"boolean","default":false},"writeOnly":{"type":"boolean","default":false},"examples":{"type":"array","items":true}}}',
+    "https://json-schema.org/draft/2020-12/meta/unevaluated": '{"$schema":"https://json-schema.org/draft/2020-12/schema","$id":"https://json-schema.org/draft/2020-12/meta/unevaluated","$dynamicAnchor":"meta","title":"Unevaluated applicator vocabulary meta-schema","type":["object","boolean"],"properties":{"unevaluatedItems":{"$dynamicRef":"#meta"},"unevaluatedProperties":{"$dynamicRef":"#meta"}}}',
+    "https://json-schema.org/draft/2020-12/meta/validation": '{"$schema":"https://json-schema.org/draft/2020-12/schema","$id":"https://json-schema.org/draft/2020-12/meta/validation","$dynamicAnchor":"meta","title":"Validation vocabulary meta-schema","type":["object","boolean"],"properties":{"type":{"anyOf":[{"$ref":"#/$defs/simpleTypes"},{"type":"array","items":{"$ref":"#/$defs/simpleTypes"},"minItems":1,"uniqueItems":true}]},"const":true,"enum":{"type":"array","items":true},"multipleOf":{"type":"number","exclusiveMinimum":0},"maximum":{"type":"number"},"exclusiveMaximum":{"type":"number"},"minimum":{"type":"number"},"exclusiveMinimum":{"type":"number"},"maxLength":{"$ref":"#/$defs/nonNegativeInteger"},"minLength":{"$ref":"#/$defs/nonNegativeIntegerDefault0"},"pattern":{"type":"string","format":"regex"},"maxItems":{"$ref":"#/$defs/nonNegativeInteger"},"minItems":{"$ref":"#/$defs/nonNegativeIntegerDefault0"},"uniqueItems":{"type":"boolean","default":false},"maxContains":{"$ref":"#/$defs/nonNegativeInteger"},"minContains":{"$ref":"#/$defs/nonNegativeInteger","default":1},"maxProperties":{"$ref":"#/$defs/nonNegativeInteger"},"minProperties":{"$ref":"#/$defs/nonNegativeIntegerDefault0"},"required":{"$ref":"#/$defs/stringArray"},"dependentRequired":{"type":"object","additionalProperties":{"$ref":"#/$defs/stringArray"}}},"$defs":{"nonNegativeInteger":{"type":"integer","minimum":0},"nonNegativeIntegerDefault0":{"$ref":"#/$defs/nonNegativeInteger","default":0},"simpleTypes":{"enum":["array","boolean","integer","null","number","object","string"]},"stringArray":{"type":"array","items":{"type":"string"},"uniqueItems":true,"default":[]}}}',
+}

corvus_json_schema/cli.py

@@ -0,0 +1,95 @@
+"""corvus-json-schema: emit a standalone validator module for a schema, or validate JSON documents against a schema.
+
+    corvus-json-schema generate <schema.json> [-o <out.py>] [--runtime-import <module>] [options]
+    corvus-json-schema validate <schema.json> <instance.json>... [options]
+
+Options: --default-dialect <4|6|7|2019-09|2020-12>, --assert-format, --base-uri <uri>, --entry-point <ref>,
+--schema-dir <dir> (resolve remote $refs from local files named after the URI's last path segment).
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from pathlib import Path
+from typing import Any
+from urllib.parse import unquote, urlsplit
+
+from . import Dialect, compile, generate_module
+
+DIALECTS = {
+    "4": Dialect.DRAFT4,
+    "6": Dialect.DRAFT6,
+    "7": Dialect.DRAFT7,
+    "2019-09": Dialect.DRAFT201909,
+    "2020-12": Dialect.DRAFT202012,
+}
+
+
+def _read_json(file: str) -> Any:
+    return json.loads(Path(file).read_text(encoding="utf-8"))
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(
+        prog="corvus-json-schema", description=__doc__.split("\n\n")[0] if __doc__ else None
+    )
+    parser.add_argument("command", choices=["generate", "validate"])
+    parser.add_argument("files", nargs="+")
+    parser.add_argument("-o", "--output", help="the file to write the generated module to (generate)")
+    parser.add_argument(
+        "--runtime-import", default="corvus_json_schema.runtime", help="the module of the runtime helpers"
+    )
+    parser.add_argument("--default-dialect", help="dialect for schemas without $schema (default 2020-12)")
+    parser.add_argument("--assert-format", action="store_true", help='assert "format" (otherwise it is an annotation)')
+    parser.add_argument("--base-uri", help="base URI of the root schema")
+    parser.add_argument("--entry-point", help="evaluate from a subschema, e.g. #/$defs/item")
+    parser.add_argument("--schema-dir", help="resolve referenced documents from files in this directory")
+    args = parser.parse_args(argv)
+
+    options: dict[str, Any] = {}
+    if args.default_dialect is not None:
+        name = args.default_dialect.removeprefix("draft").removeprefix("-")
+        if name not in DIALECTS:
+            parser.error(f"unknown dialect '{args.default_dialect}'")
+        options["default_dialect"] = DIALECTS[name]
+    if args.assert_format:
+        options["assert_format"] = True
+    if args.base_uri is not None:
+        options["base_uri"] = args.base_uri
+    if args.entry_point is not None:
+        options["entry_point"] = args.entry_point
+    if args.schema_dir is not None:
+        directory = Path(args.schema_dir)
+
+        def resolve(uri: str) -> Any:
+            file = directory / unquote(urlsplit(uri).path.split("/")[-1])
+            return json.loads(file.read_text(encoding="utf-8")) if file.is_file() else None
+
+        options["resolve_document"] = resolve
+
+    if args.command == "generate":
+        if len(args.files) != 1:
+            parser.error("generate takes one schema file")
+        source = generate_module(_read_json(args.files[0]), runtime_import=args.runtime_import, **options)
+        if args.output is None:
+            sys.stdout.write(source)
+        else:
+            Path(args.output).write_text(source, encoding="utf-8")
+        return 0
+
+    if len(args.files) < 2:
+        parser.error("validate takes a schema file and at least one instance file")
+    validate = compile(_read_json(args.files[0]), **options)
+    failed = 0
+    for file in args.files[1:]:
+        valid = validate(_read_json(file))
+        if not valid:
+            failed += 1
+        print(f"{file}: {'valid' if valid else 'invalid'}")
+    return 0 if failed == 0 else 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())