corvus-json-schema
A JSON Schema evaluator for Python (draft 4, 6, 7, 2019-09 and 2020-12), ported from the Corvus.Text.Json V5
standalone evaluator (Corvus.Text.Json.RuntimeEvaluator, see docs/RuntimeEvaluator.md)
by way of its TypeScript port. It compiles a schema once into specialised Python and validates parsed JSON values
(json.loads output) against it. Pure Python: its one dependency is regex, for
the ECMA-262 patterns that the standard library's re cannot run, or is not proved to run in time proportional to
the text.
For the same evaluator in Rust, behind the same Python API, see corvus-json-schema-rs.
- Conformant: passes all 7,967 tests of the JSON-Schema-Test-Suite (required, optional and
optional/format, every draft), includingdraft4/optional/zeroTerminatedFloats.json, which the C# and TypeScript evaluators exclude because their parsers cannot tell1.0from1(json.loadscan). - Fast: see Performance.
- Results and annotations: evaluate with a results collector at the Basic, Detailed or Verbose level for the same
rows (locations, messages, order) as the C#
JsonSchemaResultsCollector, and annotations asJsonSchemaAnnotationProducerextracts them; passes all of the suite's annotation tests. - Standalone: a schema can be emitted as a Python module that depends only on the small runtime.
- Bounded: a match of a regular expression has a limit of one second, and a regular expression has limits of size, so that neither a schema nor an instance from outside can make a validator hang. See Limits on regular expressions.
- Python 3.10 or later; typed (
py.typed, checked withmypy --strictand pyright).
Install
pip install corvus-json-schema
Usage
import corvus_json_schema as cjs
validate = cjs.compile({
"$schema": "https://json-schema.org/draft/2020-12/schema",
"type": "object",
"properties": {"id": {"type": "integer", "minimum": 1}},
"required": ["id"],
"unevaluatedProperties": False,
})
validate({"id": 3}) # True
validate({"id": 0}) # False
compile takes the schema as a parsed value or as JSON text, and these options, as keywords or as a CompileOptions
(the Python counterparts of JsonSchemaEvaluatorOptions):
| Option | Meaning |
|---|---|
default_dialect |
Dialect for schemas without $schema (Dialect.DRAFT4 … Dialect.DRAFT202012, default 2020-12). |
assert_format |
True asserts format, False never does; None (the default) follows the vocabularies (2020-12 format-assertion). |
assert_format_in_legacy_drafts |
With assert_format unset, also assert format in drafts 4 to 7. |
assert_content |
Assert contentEncoding/contentMediaType in draft 7 (default True). |
formats |
Custom format assertions by name, e.g. {"even": lambda s: len(s) % 2 == 0}. |
resolve_document |
(uri) -> schema | JSON text | None, for remote $refs. The standard metaschemas are built in. |
base_uri |
Base URI of the root document. |
entry_point |
Evaluate from a subschema, e.g. #/$defs/item. |
max_depth |
Depth limit for in-place recursion on a cycle (default 128); exceeding it raises SchemaEvaluationDepthError. |
pattern_match_limit |
The seconds one match of a regular expression against one string may take, by the clock (default 1.0); reaching it raises PatternMatchLimitError. None or 0 turns the limits of a match off. |
An unresolvable reference or an invalid pattern raises SchemaCompilationError at compile time, and a pattern over a
limit of size raises PatternTooLargeError, which is a SchemaCompilationError.
Limits on regular expressions
A schema and an instance may both come from outside, so what a regular expression can cost is bounded. The option and the two exceptions have the names and the meanings they have in corvus-json-schema-rs, so either package can be used as the other.
- A match has a limit of time.
pattern_match_limitis the seconds that one match of apatternorpatternPropertiesregular expression against one string may take, by the clock. It is1.0unless given, andNone,0or less turns the limits of a match off, for a caller who trusts both the schema and the instances. A validation whose match reaches the limit raisesPatternMatchLimitError, from the validator itself and fromevaluate, with a results collector or without. The instance is then neither valid nor not valid. The error has thepatternand thelimit. - A match has a limit of memory. Both engines keep what a group held each time the group closes, until the
match ends, and the
regexpackage keeps 35 to 56 bytes for each iteration of a repetition of more than one term. A group that no backreference reads is written so that it does not capture inside a repetition, which leaves nothing kept for the groups of a pattern without a backreference. For what is left, a text has a limit of length in a pattern that theregexpackage runs: 1,048,576 characters, and fewer for a pattern with groups that are read inside a repetition, as many as keep 524,288 groups. That is 262,144 characters for^(?:(a)|b)*\1$, about 5,000 for a pattern with a hundred such groups, and 175 for^(?:(?=(?:(a))*)\1)*[bc]$, where a repetition inside a lookahead inside a repetition keeps its group for every character after every character. The limit is asked about once the first try at a match has been abandoned (a thirty-second of the limit of time, which is too short to fill more than tens of megabytes), so a match that answers at once is answered whatever the length of the text, and a match that answers costs no comparison. A longer text then raisesPatternMatchLimitError, whose message says so and whosemost_charactersis the number (it isNonefor the limit of time). - A pattern has limits of size. A schema raises
PatternTooLargeErrorwhen it is compiled if one of its regular expressions has more than 32,768 characters, has groups nested more than 100 deep, has a translation for Python's engines of more than 32,768 characters, or has counts of more than one term that make theregexpackage write out more than 4,096 copies of what they repeat. It is aSchemaCompilationError, and it is never raised for a pattern that is not valid. A long class that a pattern has many times, such as\p{L}, counts once towards the length of the translation, and a plain term is as long translated as it was written, give or take a backslash.
import corvus_json_schema as cjs
validate = cjs.compile({"pattern": r"^(?:(a+)\1*)+$"}, pattern_match_limit=0.25)
validate("aaaa") # True
try:
validate("a" * 60 + "b") # no engine that backtracks answers this one
except cjs.PatternMatchLimitError as e:
print(e.limit, e.pattern) # 0.25 ^(?:(a+)\1*)+$
try:
cjs.compile({"pattern": "(?<=b)(?:(?:ab){1000}){1000}"})
except cjs.PatternTooLargeError as e:
print(e) # ... its counts come to more than 4,096 copies of what they repeat ...
trusting = cjs.compile({"pattern": r"^(a+)+$"}, pattern_match_limit=None) # no limit: re runs it, as before
generate_module writes the limit into the module it generates, and the command line takes
--pattern-match-limit <seconds>. There validate prints no answer for an instance whose match reaches the
limit, and exits with 2.
What differs from corvus-json-schema-rs. Both packages have pattern_match_limit, PatternMatchLimitError
and PatternTooLargeError, with the same meanings and the same default. What is left between them:
- The limit error has
pattern,limitandmost_charactershere. There it has its message and no attributes. - The memory of a match is bounded here by the length of the text, for a pattern that the
regexpackage runs: 1,048,576 characters, and fewer for a pattern with groups that the engine keeps for every repetition. There a match of any pattern is abandoned when its backtracking stack reaches 1,048,576 entries (24 MB). Both raisePatternMatchLimitError. compileruns no match here. There it matches each pattern ofpatternPropertiesagainst the property names the schema declares, socompilecan raisePatternMatchLimitErrortoo.- The limits of size are 32,768 characters of pattern, 100 levels of groups, 32,768 characters of translation and 4,096 copies here. There they are 1,048,576 bytes of pattern, 1,000 levels and about 16,000 terms.
- The time of a match is counted by the clock in both. Here that is for a pattern that the
regexpackage runs (the error does not come before nine tenths of the limit, and comes within about twice the limit), and a pattern that is proved to match in time proportional to the text has no limit, asreruns it. There the package's own engine runs every pattern and looks at the clock every 4,096 steps. format: regexhas one rule in both: a text over a limit of reading is not valid, and any other is valid or not by the grammar, whatever it would cost to compile. The limits of reading are each package's own: 32,768 characters and 100 levels here, 1,048,576 bytes, 1,000 levels and about 16,000 terms there.
Which engine runs a pattern. The standard library's re cannot be stopped once a match has started: it has no
limit of its own, and it looks at signals in the main thread only. The regex package takes a timeout. So with the
limit in force (the default) a pattern goes to re only when the package proves that re matches it in time
proportional to the text, whatever the text is. Such a pattern has no limit and needs none, and a match costs
what it did before, as the search function is the engine's own. Every other pattern goes to the regex package
with the limit.
The proof is that at every choice in the pattern (the alternatives of an alternation, one more iteration of a
repetition or none) the next character of the text says which way to go, and that the body of a repetition takes
a character. Five things are allowed beyond that, each for a bounded cost: a pattern that takes a bounded number
of characters and has few ways through it (^(?:es5|es6|es2015)$), a repetition that is left with a bounded rest
of the pattern to try (^[a-z0-9]*[a-z]$, ^.*\.json$), an alternation of bounded alternatives that start alike
(txt|trie, http|https), a bounded lookahead anywhere and an unbounded one at the start of a pattern that starts
with ^ (^(?=.*[a-z])(?=.*\d).{8,}$), and a pattern without ^ whose tries fail within a few characters
([a-z][a-z0-9]*). ^[a-z0-9]+(?:-[a-z0-9]+)*$, ^\d{3}-\d{4}$ and ^[a-z]+@[a-z]+\.[a-z]{2,}$ are proved.
^(a+)+$, ^([a-z0-9]+[._-]?)*$, a*b, \{.*\} and a pattern with a backreference or a lookbehind are not.
A proved pattern has at most 4,096 terms that a character of the text can pass more than once: those inside a
repetition, and in a pattern that does not start with ^, which is tried at every place in the text, all of them.
Of the 124 patterns of the jsonschema-benchmark corpora that need a regular expression, 117 are proved, and four of
the seven that are not take a time that grows as the square of the text or faster. With no limit, re runs every
pattern it can, as it did before there was a limit.
What the limit of time is, exactly. The regex package has a timeout, which counts the time of the whole
process on the processor (C's clock) and is looked at every 256 steps of a match. The package runs a match
without the interpreter's lock, so with other threads at work that time passes several times as fast as the clock:
a timeout of 1 second came after 0.24 seconds with three other threads busy, and after 0.07 with fifteen. So the
timeout is used as an allowance of processor time, and the clock decides.
- The first try at a match is allowed a thirty-second of the limit, and nothing is measured around it, so a match
that answers costs what the call of the engine costs (0.98 to 1.02 of what it cost before, on CPython 3.10, 3.12
and 3.14, on a machine with a load of 3). A match that does not answer in that is tried again from its start: a
short try that shows how fast the processor's time is passing, then tries that are allowed what should come to
the limit on the clock at that rate.
PatternMatchLimitErroris raised when nine tenths of the limit have passed on the clock, and never before. - A try cannot be stopped by the clock, and one that was allowed the time of sixteen threads would go on for sixteen limits if the others stopped. So no try is allowed more than is left of twice the limit, and a match is bounded at about twice the limit whatever the other threads do. The price is that with three or more other threads at work throughout, a try gets less than the limit on the clock (half of it with three, a quarter with seven), and a match that needs more than that is abandoned where it would have been answered alone. With one other thread or none, a match gets the limit.
- With a limit of 1 second the error came after 1.09, 0.97, 1.12, 0.95 and 0.95 seconds with 0, 1, 3, 7 and 15 other threads at work, and after 1.8 to 1.9 seconds with seven threads that stopped a quarter of a second in (CPython 3.12 and free-threaded 3.14, load 2 to 4). On a machine where the process does not get a processor to itself, a try takes longer on the clock than it was allowed.
- One step of a match can run over the whole text, and the engine looks at its clock every 256 steps, so its
timeout can come late by a time that grows with the text. A repetition of one class is such a step, and the
engine goes through the ranges of a class one by one. So a class of more than 24 ranges under a repetition is
written so that each character is a step, and a text of more than 32,768 characters is matched by the pattern
written so for every repetition of one class (that one is compiled when the first long text comes). With a
limit of 1 second,
(?:\p{L}*1|\p{L}*2|\p{L}*3)reached it after 1.1 seconds for a text of 100,000 letters and for one of a million, where it had been 1.9 and 7.7 seconds, and 68 for ten million. The latest that an answer or the error came in the adversarial probe was 1.3 seconds after the match started.
What is not bounded.
- A pattern that
reruns has no limit of time. Its time is in proportion to the text, with no bound on the text. - A pattern that
reruns has no limit of memory either. It keeps up to 70 bytes for a character of the text until the match ends, with no bound on the text. - The memory of a match in the
regexpackage is bounded as above. The most that one match took at the longest text its pattern lets through is 90 MB, and the most that a process took for one of the 210 patterns of the adversarial probe (at most 1,000 characters of pattern and 100,000 of text) is 90 MB. It was 488 MB, and patterns that the probe did not have then ended in aMemoryErrorat 770 MB. - A custom
formatsfunction and aresolve_documentfunction are the caller's own code.
Instances are the values json.loads produces: dict, list, str, int, float, bool and None. The generated
code tests exact types (type(x) is dict), so subclasses such as OrderedDict are not objects to it; True is a
boolean, never the number 1.
Results and annotations
validate = cjs.compile(schema)
collector = cjs.JsonSchemaResultsCollector.create(cjs.ResultsLevel.DETAILED)
validate.evaluate({"id": 0}, collector) # False
for r in collector.results:
... # r.is_match, r.message, r.evaluation_location, r.schema_evaluation_location, r.document_evaluation_location
verbose = cjs.JsonSchemaResultsCollector.create(cjs.ResultsLevel.VERBOSE)
validate.evaluate({"id": 3}, verbose)
cjs.collect_annotations(verbose) # {"": {"title": {"#": "Person"}}, "/id": {...}}
The levels and rows are those of the C# collector: BASIC records failures without message text, DETAILED adds the
text, VERBOSE records every keyword (passing ones and annotations included). Evaluation without a collector runs
the generated code; with one, an interpreter over the same compiled graph evaluates every keyword and reports it
(collecting.py), so results collection costs nothing when unused.
Standalone modules
from pathlib import Path
Path("person_validator.py").write_text(cjs.generate_module(schema))
# from person_validator import validate, evaluate -- needs only corvus_json_schema.runtime
Or from the command line:
corvus-json-schema generate schema.json -o validator.py
corvus-json-schema validate schema.json doc1.json doc2.json
How it works
The pipeline follows the C# evaluator stage for stage:
- Load (
loader.py): documents, resources ($id/id), anchors,$recursiveAnchor, and the dialect and vocabularies of each resource, including custom metaschemas read through$vocabulary. - Compile (
compiler.py): oneSchemaNodeper distinct schema location with its keywords pre-digested;$refresolved at compile time;$dynamicRef/$recursiveRefresolved statically wherever the entry resource decides them, so a dynamic scope is kept only for references that stay dynamic. - Analyse: which nodes can mark evaluated properties/items, in-place recursion cycles (only those nodes carry a
depth guard), and
oneOf/anyOfdiscriminators. - Generate (
codegen.py), as the TypeScript port does: each node becomes one function with exactly the checks it needs, compiled once withcompile()/exec(), so a validation is a single call into that code. The analyses that select C# plans select the shape of the code:- pure-
$refchains are elided; leaf schemas (type,const/enum, string and number keywords) are tested at their call sites as one expression, with no call; - small objects are checked by direct lookups (
"name" in x),requiredandadditionalProperties: falseby set operations onx.keys(), and larger objects by one pass dispatching each name through a dict; - an
allOf/$refcomposition of plain object schemas checks an object in one pass over the merged names (the C# and Rust flat fused plan); oneOf/anyOfnarrow by a discriminator property or by type dispatch;unevaluatedProperties/unevaluatedItemsare decided from static coverage where their contributors allow it, with conditions underif/then/elseand dependencies decided once per object;- patterns that are literals (a prefix, an exact value, alternatives, a substring) match without a regular
expression; others are ECMA-262 translated to Python's syntax (
pattern.py) and run byrewhen it is proved to match them in time proportional to the text, and otherwise byregexwith the limit of a match (lookbehind, a backreference that reads a group, a repetition that the next character does not decide); - structurally identical functions are merged by partition refinement.
- pure-
Generated code that keeps state (a live dynamic scope or an in-place depth count) evaluates under a lock, so a validator can be shared between threads.
Performance
Measured with jsonschema-benchmark's corpora and harness
protocol (bench/corpora.py: a fresh process per corpus and implementation, warm-up, then the best of five passes),
against the Rust-backed corvus-json-schema-rs, the
jsonschema-rs bindings and fastjsonschema
(another generator of Python code, draft 4 to 7). See Performance results for the figures.
python bench/corpora.py --schemas <jsonschema-benchmark>/schemas --impls corvus,corvus-rs,jsonschema-rs,fastjsonschema
Performance results
CPython 3.12.13 on an Intel Core i7-13800H (WSL2, pinned to the performance cores), jsonschema-rs 0.58.3, fastjsonschema 2.22.2, 2026-10-01. The validation columns are one warm pass over all of a corpus's instances (the best of five passes after warm-up, the median of three processes); "compile" is the schema compilation (for this package, the generation of the Python code and, for programs over 64 KB of source, the compilation of only the functions an instance reaches, on first use).
| Corpus | Instances | corvus (pure) | corvus-rs | jsonschema-rs | fastjsonschema | corvus compile | corvus-rs compile |
|---|---|---|---|---|---|---|---|
| ansible-meta | 333 | 345.0 µs | 105.1 µs | 286.2 µs | 7.96 ms | 10.92 ms | 876.6 µs |
| aws-cdk | 483 | 88.8 µs | 45.7 µs | 61.5 µs | 229.9 µs | 599.4 µs | 78.8 µs |
| babelrc | 794 | 260.2 µs | 97.4 µs | 130.9 µs | 898.2 µs | 1.54 ms | 189.6 µs |
| clang-format | 133 | 140.0 µs | 29.0 µs | 38.1 µs | 571.0 µs | 8.46 ms | 765.5 µs |
| cmake-presets | 967 | 12.29 ms | 3.65 ms | 6.64 ms | 250.54 ms | 19.01 ms | 1.58 ms |
| code-climate | 2484 | 354.0 µs | 284.6 µs | 329.4 µs | 1.77 ms | 909.5 µs | 121.1 µs |
| cql2 | 109 | 193.3 µs | 61.2 µs | 127.3 µs | 5.07 ms (!) | 12.54 ms | 800.1 µs |
| cspell | 981 | 1.52 ms | 1.16 ms | n/a | 52.35 ms | 12.24 ms | 1.68 ms |
| cypress | 981 | 279.8 µs | 108.8 µs | 185.5 µs | 1.34 ms | 2.76 ms | 267.4 µs |
| deno | 987 | 831.0 µs | 235.4 µs | 313.3 µs | 2.86 ms | 3.28 ms | 333.8 µs |
| dependabot | 967 | 1.10 ms | 334.4 µs | 435.5 µs | 2.84 ms | 2.22 ms | 154.9 µs |
| draft-04 | 563 | 12.55 ms | 4.39 ms | 6.05 ms | 16.83 ms | 2.35 ms | 185.6 µs |
| fabric-mod | 911 | 1.50 ms | 368.0 µs | 608.8 µs | 42.99 ms | 3.11 ms | 300.2 µs |
| geojson | 500 | 49.76 ms | 16.65 ms | 19.56 ms | 2173.86 ms | 10.41 ms | 516.9 µs |
| gitpod-configuration | 986 | 698.3 µs | 222.5 µs | 274.0 µs | 1.82 ms | 3.23 ms | 258.0 µs |
| helm-chart-lock | 3888 | 1.90 ms | 736.7 µs | 1.11 ms | 6.07 ms | 650.1 µs | 104.3 µs |
| importmap | 964 | 253.7 µs | 122.3 µs | 150.6 µs | 825.1 µs | 577.2 µs | 79.0 µs |
| jasmine | 980 | 338.8 µs | 99.0 µs | 197.6 µs | 2.74 ms | 1.39 ms | 123.1 µs |
| jsconfig | 981 | 906.9 µs | 301.4 µs | 338.1 µs | 19.70 ms | 8.38 ms | 1.70 ms |
| jshintrc | 966 | 1.16 ms | 329.9 µs | 523.8 µs | 3.96 ms | 1.80 ms | 207.2 µs |
| krakend | 47 | 698.0 µs | 139.7 µs | n/a | 4.65 ms | 29.33 ms | 4.22 ms |
| lazygit | 280 | 338.5 µs | 77.7 µs | 106.1 µs | 9.18 ms | 10.74 ms | 956.1 µs |
| lerna | 985 | 217.9 µs | 138.2 µs | 156.7 µs | 659.5 µs | 1.45 ms | 113.8 µs |
| nest-cli | 1025 | 579.8 µs | 186.4 µs | 231.9 µs | 3.85 ms | 3.79 ms | 370.0 µs |
| omnisharp | 987 | 719.2 µs | 215.1 µs | 253.6 µs | 2.21 ms | 2.96 ms | 325.3 µs |
| openapi | 107 | 16.90 ms | 5.23 ms | 10.91 ms | 88.9 µs | 13.63 ms | 1.44 ms |
| pre-commit-hooks | 985 | 1.28 ms | 308.9 µs | 467.0 µs | 22.78 ms | 1.44 ms | 195.4 µs |
| pulumi | 3807 | 1.67 ms | 627.3 µs | 786.2 µs | 19.22 ms | 3.54 ms | 291.8 µs |
| semantic-release | 794 | 291.5 µs | 118.5 µs | 168.0 µs | 9.30 ms | 1.43 ms | 125.5 µs |
| stale | 961 | 466.8 µs | 147.5 µs | 214.8 µs | 1.16 ms | 1.25 ms | 157.6 µs |
| stylecop | 983 | 934.6 µs | 253.1 µs | 296.6 µs | 3.26 ms | 3.56 ms | 236.8 µs |
| tmuxinator | 382 | 206.2 µs | 80.0 µs | 98.7 µs | 5.77 ms | 1.67 ms | 153.3 µs |
| ui5 | 942 | 1.33 ms | 624.4 µs | 527.8 µs | 10.50 ms | 20.00 ms | 2.36 ms |
| ui5-manifest | 611 | 6.81 ms | 2.18 ms | 2.47 ms | n/a | 70.67 ms | 8.92 ms |
| unreal-engine-uproject | 859 | 2.17 ms | 400.9 µs | 534.8 µs | 12.30 ms | 2.38 ms | 284.7 µs |
| vercel | 710 | 671.9 µs | 191.0 µs | 293.7 µs | 2.81 ms | 9.46 ms | 653.5 µs |
| yamllint | 966 | 61.3 µs | 61.9 µs | 65.7 µs | 169.1 µs | 310.3 µs | 78.4 µs |
- corvus-json-schema (pure Python) is faster than fastjsonschema, the other generator of Python code, on 34 of the 35 corpora both can run: its warm time is a sixth of fastjsonschema's (geometric mean 5.86 times faster). fastjsonschema supports drafts 4 to 7 only, so on openapi, a 2020-12 schema, it applies few of the keywords (its one faster time), on cql2 it rejects valid instances (!), and it cannot compile ui5-manifest.
- corvus-json-schema-rs, the same API backed by the Rust evaluator, takes 0.35 of the pure package's time (geometric mean over all 37 corpora), and 0.72 of jsonschema-rs's (faster on 34 of the 35 corpora jsonschema-rs can run; it rejects the patterns of cspell and krakend).
Tests
pip install -e . pytest
python -m pytest # API and results tests
python tests/suite.py # the JSON-Schema-Test-Suite (--draft, --filter, --verbose; --module through
# generate_module; --collect basic|detailed|verbose through a results collector;
# --impl corvus_json_schema_rs for the Rust-backed package)
python tests/annotations.py # the suite's annotation tests through a verbose collector
The suite is read from the repository's JSON-Schema-Test-Suite submodule (git submodule update --init JSON-Schema-Test-Suite), or from $JSON_SCHEMA_TEST_SUITE.
Limitations and differences from the C# evaluator
-
Results collection matches the C# collector's rows; annotation values are the values re-serialised (
json.dumps), not the schema's source text, because schemas arrive as parsed values, and numbers in messages are written as the Rust evaluator writes them (2.0,1e+21). -
Numbers are Python's: integers are exact at any size, and floats are doubles.
multipleOfwith a fractional divisor is computed exactly on the shortest decimal forms of the doubles. -
Regular expressions are ECMA-262 translated to Python's syntax with ECMA's meaning (
\dand\ware ASCII,.excludes every line terminator,$matches only at the end, a backreference to a group that has not matched matches the empty string, and a modifier group such as(?i:...)folds case by tables of Unicode 17 that the package carries). A pattern is read with theuflag. One that is not valid with it (an identity escape such as\-, a literal brace) is read as JavaScript'sRegExpreads it without the flag. Every answer for the 98,839 patterns of the ECMA-262 regular expression test data is V8's where the package answers. One of those patterns is over a limit of size, and nine or ten, by the version of Python and by what else the machine is doing, have a text whose match reaches the limit of one second (both are set out below). A digit of a pattern is one of0to9, whatever digits the interpreter's version of Unicode has. What is written out for the engines, so that it is exact:-
A backreference inside a case-insensitive group compares character by character by ECMA-262's Canonicalize, from the package's own tables, so the answer is the same on every version of Python and of
regex.^(?i:(.)\1)$takes"s\u017f"and"k\u212a"and not"i\u0130", and in a pattern that is valid only without theuflag it takes none of the three. The comparison is a loop in the pattern that theregexpackage runs. It costs a few microseconds for each character compared, where a plain backreference costs a fraction of one, and a group that can hold any character makes a translation of about 54,000 characters that takes about 0.2 seconds to compile and holds about 3 MB. A group that can hold no letter, such as(\d+), keeps a plain backreference. -
A lookbehind is matched backwards, as ECMA-262 matches it, so a group of one holds what it holds in V8 (
(?<=(a+))b\1), and so does a reference inside one to a group of it ((?<=\1(a))b). A group that a lookahead sets on only some of the ways it can match ((?=(a)?b)\1) and a lookaround group read in the same repetition after a choice (^(?:(?=([ab]))[ab](?:c|ca)\1)*$) are exact too. Inside a lookaround with a group that is read outside it, an iteration that matches nothing is refused as ECMA-262 refuses it, which decides what the group holds:^(?=((?:|a)*))\1$takes"a". -
A pattern that is valid only without the
uflag is read, and matches, by UTF-16 code unit, as V8 does: in^\-?.$the dot takes half of a character beyond the Basic Multilingual Plane, and a quantifier after such a character in the pattern repeats its second half. -
A
\p{...}has one of ECMA-262's names, or the pattern is not valid with theuflag: a value of General_Category by itself or afterGeneral_Category=orgc=, a value of Script afterScript=,sc=,Script_Extensions=orscx=, or a binary property that ECMA-262 lists, in the spelling of the Unicode Character Database. The names and the characters of a property are those of Unicode 17, from tables that the package carries and every port of the evaluator shares, whatever version of Unicode theregexpackage that is installed has (16 in release 2025.9.1, 18 in 2026.9.29, which has other characters than Unicode 17 for 89 of the 440 property expressions). So\p{sc=Sidetic},\p{sc=Tolong_Siki},\p{sc=Beria_Erfe}and\p{sc=Tai_Yo}are names, where V8 13.6, which has Unicode 16, reads such a pattern without theuflag. A property is written as ranges of characters forre, which finds a character of the Basic Multilingual Plane in a class of any size in a nanosecond or two. For theregexpackage it is written as the package's own property with what is different between its version of Unicode and 17: the ranges it lacks beside it, or[^\P{..}ranges]for the ranges it has too many of. Two releases differ by tens of ranges for the properties they differ on at all. What is written is asked about for every character once, and has to give the characters of the tables exactly, or the ranges are written.\p{L}then costs 35 nanoseconds for a character withregex2026.9.29 and 9 with 2025.9.1 (the engine's own\p{L}, which is not that of Unicode 17, costs 3, and the 684 ranges cost 44 for an ASCII letter and 950 for a character beyond the Basic Multilingual Plane). No version of CPython changes an answer: nothing in a translation asks the interpreter what a character is. The other names that theregexpackage has (\p{Greek},\p{IsLatin},\p{alpha}, a name in another case) are not taken: such a pattern is read without theuflag, where\pis the letterp. -
A repetition whose body can match nothing, with a repetition inside it or around it, is written with a body that cannot, where no reference reads a group of it:
^(?:(?:a|)*x?)*$is written as^(?:a+x?|x)*$would be. ECMA-262 refuses an iteration that matches nothing once the minimum count is met. Both engines accept it and try what follows the repetition twice, at each level, so a text that does not match took a time that doubles with each level. Without a reference that reads a group, a pattern only says which texts match, and the two writings match the same texts.
No valid pattern is refused for what it means, and none is answered with another meaning. What remains is the limits of Limits on regular expressions:
- both engines backtrack, and neither has V8's short cuts. Where a reference reads a group inside repetitions
that can match nothing, the pattern is written as ECMA-262 runs it, iteration by iteration, and a match of it
can reach the limit of a match where V8 answers in milliseconds. Nine or ten patterns of the test data have such
a text, by the version of Python, nine of them in the
backreferencesfile. V8 answers each of those texts within 10,000 backtracks; - a pattern over a limit of size raises
PatternTooLargeError. A plain term is as long translated as it was written (a character,a?,[ab]*), but for a backslash before the characters that mean something to an engine, and the dot,\sand\ware 9, 22 and up to 12 characters. A character in a case-insensitive group is the class of its forms, and a repetition around a group that a backreference reads is written out copy by copy, as in^(?:(?:(a)|b){300}){300}\1$. Theregexpackage writes out a minimum count itself, as copies of what is counted, at 125 to 400 bytes a copy:(?<=a)(?:bc){2000000}would take a gigabyte, and(?<=b)(?:ab){4097}is refused. A count of one character or class is written for it without the count where the copies would be over the limit, so(?<=b)a{2000000}and\u{10400}without theuflag (the letteru10,400 times) are compiled, in kilobytes. A count is no matter in a pattern thatreruns, which keeps it as a number:^a{100000}$is proved linear and is compiled in microseconds. A minimum count of 2,147,483,647 or more over something that can match nothing is refused too. One pattern of the test data is refused, in thelookaroundsfile: its translation is too long; - a repetition with no maximum whose body is nothing but another one is written as the inner one where no
reference reads a group of it (
(?:(?:a*)*)*bas(?:a)*b), which is the same texts in linear time.
Where V8 13.6 itself departs from ECMA-262, the package follows ECMA-262. Six such places are known. With the
uflag V8 also starts a match between the two surrogates of a character, so(?<!^.*)matches"\U00010428"there. With theianduflags V8 compares a backreference to a group of several characters by full case folding, so^(...)\1$takes"\u1e9eS\u00df\u1e9e\u00df\u017f"there, and^(.)(.)(.)\1\2\3$, which means the same, does not. V8 answers six patterns of the test data with a case-insensitive modifier group differently from the same pattern with theiflag. V8 takes\p{WSpace}, an alias of White_Space that ECMA-262 does not list, so here that pattern is the letterpand what follows it. V8 refuses the Script valueKatakana_Or_Hiragana(Hrkt), which ECMA-262 has becausePropertyValueAliases.txthas it, so here\p{sc=Hrkt}is valid and takes no character, as no character has that value. And V8 takesa{2147483648,2147483647}, where the first count is the greater, which is not valid here. -
-
Custom
formatsfunctions cannot be serialised into standalone modules.
License
Apache 2.0.
The tables of Unicode properties and of case (_properties.py and _casefold.py) are derived from the Unicode
Character Database, which is under the Unicode License V3. THIRD-PARTY-NOTICES.txt has
that notice, and the one of the regress crate that the tables were first read from. The file is in the source
distribution and in the wheel, beside LICENSE.
Metadata
Release files for corvus-json-schema 0.1.2
For a detailed explanation of source distributions (sdists) and built distributions (wheels), please see the package formats documentation.
Source distribution (sdist)
| File | Size | Uploaded | Provenance | Actions |
|---|---|---|---|---|
| corvus_json_schema-0.1.2.tar.gz | 253.3 kB | With provenance | Details for corvus_json_schema-0.1.2.tar.gz |
Built distribution (wheel)
| File | Interpreter | ABI | Platform | Actions Reset |
|---|---|---|---|---|
| corvus_json_schema-0.1.2-py3-none-any.whl | Python 3 | none | any | Details for corvus_json_schema-0.1.2-py3-none-any.whl |
Total release size: 491.5 kB
Release files / corvus_json_schema-0.1.2.tar.gz
| Download URL | corvus_json_schema-0.1.2.tar.gz |
|---|---|
| Size | 253.3 kB |
| Tags | Source |
|
SHA-256 checksum How to use checksums |
92648c10b1f4bfe937874726455a65f2eedb01b4e2856734854ad2867ebffb54
|
|
BLAKE2b-256 checksum How to use checksums |
42ac6a53b6567c12b3ba44b8f3566fb7e0ada4cf2f23c731cd65f3a979641d0d
|
| Upload date | |
|
Uploaded using Trusted Publishing? What is trusted publishing? |
Yes |
| Uploaded via |
twine/7.0.0 CPython/3.13.14
|
Provenance
Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.
PyPI Publish Attestation
PyPI verified that this artifact, at this checksum, originated from the publisher listed below.
Signed by GitHub Actions, verified by PyPI on Nov 3, 2026.
Transparency logRelease files / corvus_json_schema-0.1.2-py3-none-any.whl
| Download URL | corvus_json_schema-0.1.2-py3-none-any.whl |
|---|---|
| Size | 238.2 kB |
| Tags | Python 3 |
|
SHA-256 checksum How to use checksums |
6141fb118e1b2328863871383805129fb3602076157a5db958f975e91f675c45
|
|
BLAKE2b-256 checksum How to use checksums |
d5d879b2dc0bb0c7b59c7f09ce2f41da8191ac538c0e590809eae2b830114722
|
| Upload date | |
|
Uploaded using Trusted Publishing? What is trusted publishing? |
Yes |
| Uploaded via |
twine/7.0.0 CPython/3.13.14
|
Provenance
Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.
PyPI Publish Attestation
PyPI verified that this artifact, at this checksum, originated from the publisher listed below.
Signed by GitHub Actions, verified by PyPI on Nov 3, 2026.
Transparency logSecurity for corvus-json-schema 0.1.2
Provenance
Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.
Full provenance
Both files in this release have been uploaded with provenance metadata.
Attestation for corvus_json_schema-0.1.2.tar.gz
PyPI Publish Attestation
PyPI verified that this artifact, at this checksum, originated from the publisher listed below.
Signed by GitHub Actions, verified by PyPI on Nov 3, 2026.
Transparency logA note on package security
PyPI is a repository for distributing packages, not a service for auditing them. While third-party security researchers and our staff do their best to detect and remove malicious packages, PyPI cannot guarantee the quality, security or suitability of any given package.
To learn more about protecting yourself from malicious actors, visit our package security documentation.