I started writing up a bit of code for the current revision of draft 4. Branch is here I haven't done any testing, or added unit tests, so it is liable to be broken, just thought I'd let people know I'm working on it.

We discussed it a bit over here, just wanted to get your input on what sort of format you think the tests should be in? Should they be defined in json, maybe something like this?

{
    "name": "integer",
    "version": ["draft 3", "draft 4"],
    "schema": {"type": "integer"},
    "tests": [
        ["integer", 1, "valid"],
        ["number", 1.1, "invalid"]
    ]
}

In my project, I want to create user facing error messages which are friendlier than the default ones. I'm thinking we could attach the instance value, as well as the value for the schema keyword that failed to the ValidationError to facilitate this.

The instance could already be grabbed by walking the path through the instance, but it would be a bit easier if it is already attached.

Currently the RefResolver does not alter the resolution scope when the "id" keyword is encountered. This can lead to problems when dereferencing. Consider the following schema:

{
    "id": "http://somewhere/schema.json",
    "definitions": {
        "subschema": {
            "id": "subschema.json",
            "definitions": {
                "subsubschema1": {},
                "subsubschema2": {"$ref": "#/definitions/subsubschema1"}
            }
        }
    }
}

Currently we would resolve the ref as http://somewhere/schema.json#/definitions/subsubschema1, which would cause a RefResolutionError as it does not exist. The proper resolution would be http://somewhere/subschema.json#/definitions/subsubschema1.

This is the same issue #60 is trying to address, but that PR doesn't actually solve the problem fully. What I was calling 'context' in that ticket, is actually called 'resolution scope' in the specification, and it needs to change both when we are inside a remote reference (which is what that PR currently covers,) as well as when we encounter an id keyword in the same schema (which is not covered in that PR.)

Fixes #708.

This makes the pretty output look better by making error header and footer lines equal lengths and to use Unicode characters in them. It also shows schema JSON in error messages as valid JSON, not Python data structure representations. (Mostly a difference in quote marks used for strings.)

For the error messages, I wanted to continue using the strings with str.format(). However, I couldn't find a clean way of using the left justification and padding that's available in the formatting micro-language. If the technique I used isn't satisfactory, I can try for another approach.

To get the schema instance to display as true JSON, I thought encoding the schema back to JSON was the best approach. Using newline with the separator and sorting keys seems to give close to the same output format as pprint.pformat(). The difference is that it ends up being a little prettier, because there are always line breaks, but in my testing, pprint only broke the lines when the schema was longer than 72 characters. I didn't test extensively, so I don't know how well the json.dumps() technique compares with pprint for lines that longer than 72 characters and aren't easily broken.

Please feel free to be critical with the code review. I'm very much open to updating my changes to fit with the style of the project.

Okay, I think this resolves :stuck_out_tongue_winking_eye: the issue mentioned in #66. It at least passes the tests I have at https://github.com/json-schema/JSON-Schema-Test-Suite/pull/34

@Julian, how do you feel about this method?

@Julian Still need to come up with some more tests, and fix one current test to work with the new method to make sure this is working as intended. Just wanted to get your thoughts on this method of handling nested $ref resolution before proceeding.

$data proposal implemented by AJV allows validation based on another value. It can drastically reduce the amount of custom coded performed after the schema has been validated.

Additionally, interoperability with AJV would allow to quickly implement UIs with AJV-based form generators such as VueFormJsonSchema or similar solutions.

Is it in plan to support draft-06?

in my Project i need to use propertyNames to validate object keys agains regex pattern. but propertyNames was introduced in draft-06.

for now i am using patternProperties with "additionalProperties": False together, but the error is confusing because of "schema does not allow additional properties"

Hello Julian,

Are you planning to implement support of $ref attribute in your library? $ref attribute gives a lot of flexibility in building schemas for validating dynamic JSONs.

Thanks.

Hi.

So this will probably turn out to be a my local problem, but i'm not seeing it just yet.

I'm using jsonschema to validate a JSON file in darktable: https://github.com/darktable-org/darktable/blob/master/data/CMakeLists.txt#L99

On my local machine this just works:

$ make validate_noiseprofiles_json 
Checking validity of noiseprofiles.json
Built target validate_noiseprofiles_json

However in clean docker environment it does not: https://travis-ci.org/darktable-org/darktable/jobs/163489568#L520

[  4%] Checking validity of noiseprofiles.json
usage: jsonschema [-h] [-i INSTANCES] [-F ERROR_FORMAT] [-V VALIDATOR] schema
jsonschema: error: argument -i/--instance: invalid _json_file value: '/build/darktable/data/noiseprofiles.json'

If i manually pull that image, and do it manually, it does cause the same issue. And outside of the image, it just works. On the exact same input JSON+schema, with exactly the same sha512sum's for those 2 files.

What could possibly be going on?

Hi there I'm using a Json Schema with Version 2020-12 that includes enums. I do get the following error:

jsonschema.exceptions.SchemaError: ('=', '>', '<', '>=', '<=', '<>', '!=', '==', 'between', 'in') is not of type 'array'

VS Code does not complain about the schema so it seems like a but in jschonschema?

Here's my json schema:

{
    "type": "array",
    "items": {
        "$ref": "#/$defs/Config"
    },
    "$defs": {
        "Column": {
            "type": "object",
            "required": [
                "name"
            ],
            "additionalProperties": false,
            "properties": {
                "name": {
                    "type": "string"
                },
                "alias": {
                    "type": [
                        "string",
                        "null"
                    ]
                }
            }
        },
        "GroupByExpConfig": {
            "type": "object",
            "required": [],
            "additionalProperties": false,
            "properties": {
                "col": {
                    "type": "string"
                },
                "func": {
                    "enum": [
                        "sum",
                        "count",
                        "mean",
                        "median",
                        "min",
                        "max",
                        "first",
                        "std",
                        "n_unique",
                        "distinct",
                        "mode",
                        "null_count"
                    ]
                },
                "alias": {
                    "type": [
                        "string",
                        "null"
                    ]
                }
            }
        },
        "GroupByConfig": {
            "type": "object",
            "required": [
                "by",
                "expressions"
            ],
            "additionalProperties": false,
            "properties": {
                "by": {
                    "type": "array",
                    "items": {
                        "type": "string"
                    }
                },
                "expressions": {
                    "type": "array",
                    "items": {
                        "$ref": "#/$defs/GroupByExpConfig"
                    }
                }
            }
        },
        "SortBy": {
            "type": "object",
            "required": [
                "by"
            ],
            "additionalProperties": false,
            "properties": {
                "by": {
                    "type": "string"
                },
                "direction": {
                    "enum": [
                        "asc",
                        "desc"
                    ]
                }
            }
        },
        "Join": {
            "type": "object",
            "required": [
                "uri",
                "left_on",
                "right_on"
            ],
            "additionalProperties": false,
            "properties": {
                "uri": {
                    "type": "string"
                },
                "left_on": {
                    "type": "string"
                },
                "right_on": {
                    "type": "string"
                },
                "file_type": {
                    "enum": [
                        "delta",
                        "parquet",
                        "arrow",
                        "avro",
                        "csv",
                        "json",
                        "ndjson"
                    ]
                },
                "how": {
                    "enum": [
                        "inner",
                        "left",
                        "outer",
                        "semi",
                        "anti",
                        "cross"
                    ]
                },
                "suffix": {
                    "type": "string"
                }
            }
        },
        "Filter": {
            "type": "object",
            "required": [
                "key",
                "operator",
                "value"
            ],
            "additionalProperties": false,
            "properties": {
                "key": {
                    "type": "string"
                },
                "operator": {
                    "enum": [
                        "=",
                        ">",
                        "<",
                        ">=",
                        "<=",
                        "<>",
                        "!=",
                        "==",
                        "between",
                        "in"
                    ]
                },
                "value": {
                    "oneOf": [
                        {},
                        {
                            "type": "array",
                            "minItems": 2,
                            "maxItems": 2,
                            "additionalItems": false,
                            "prefixItems": [
                                {},
                                {}
                            ]
                        }
                    ]
                }
            }
        },
        "DataframeConfig": {
            "type": "object",
            "required": [
                "uri"
            ],
            "additionalProperties": false,
            "properties": {
                "uri": {
                    "type": "string"
                },
                "file_type": {
                    "enum": [
                        "delta",
                        "parquet",
                        "arrow",
                        "avro",
                        "csv",
                        "json",
                        "ndjson"
                    ]
                },
                "select": {
                    "type": "array",
                    "items": {
                        "$ref": "#/$defs/Column"
                    }
                },
                "groupby": {
                    "oneOf": [
                        {
                            "type": "null"
                        },
                        {
                            "$ref": "#/$defs/GroupByConfig"
                        }
                    ]
                },
                "sortby": {
                    "type": "array",
                    "items": {
                        "$ref": "#/$defs/SortBy"
                    }
                },
                "joins": {
                    "type": "array",
                    "items": {
                        "$ref": "#/$defs/Join"
                    }
                },
                "filters": {
                    "type": "array",
                    "items": {
                        "$ref": "#/$defs/Filter"
                    }
                },
                "cache_expiration_time_seconds": {
                    "type": [
                        "integer",
                        "null"
                    ]
                },
                "in_memory": {
                    "type": [
                        "boolean",
                        "null"
                    ]
                }
            }
        },
        "Param": {
            "type": "object",
            "required": [
                "name",
                "type"
            ],
            "additionalProperties": false,
            "properties": {
                "name": {
                    "type": "string"
                },
                "type": {
                    "type": "string"
                },
                "default": {
                    "type": [
                        "string",
                        "null"
                    ]
                }
            }
        },
        "Config": {
            "type": "object",
            "required": [
                "name"
            ],
            "additionalProperties": false,
            "properties": {
                "name": {
                    "type": "string"
                },
                "tag": {
                    "type": [
                        "string",
                        "null"
                    ]
                },
                "route": {
                    "type": [
                        "string",
                        "null"
                    ]
                },
                "dataframe": {
                    "oneOf": [
                        {
                            "type": "null"
                        },
                        {
                            "$ref": "#/$defs/DataframeConfig"
                        }
                    ]
                },
                "version": {
                    "type": [
                        "integer",
                        "null"
                    ]
                },
                "api_method": {
                    "type": [
                        "string",
                        "null"
                    ]
                },
                "params": {
                    "type": "array",
                    "items": {
                        "$ref": "#/$defs/Param"
                    }
                },
                "file_response": {
                    "type": [
                        "string",
                        "null"
                    ]
                },
                "all_col_in_query_endpoint": {
                    "type": [
                        "boolean",
                        "null"
                    ]
                },
                "timestamp": {
                    "type": [
                        "string",
                        "null"
                    ],
                    "format": "date-time"
                },
                "query_endpoint": {
                    "type": [
                        "boolean",
                        "null"
                    ]
                },
                "enable_cache": {
                    "type": [
                        "boolean",
                        "null"
                    ]
                },
                "cache_expiration_time_seconds": {
                    "type": [
                        "integer",
                        "null"
                    ]
                }
            }
        }
    },
    "$schema": "https://json-schema.org/draft/2020-12/schema"
}

I haven't had time to focus on jsonschema typing much recently, but I want to get things back on track. The first thing to do is to correct any drift between jsonschema and typeshed. I'm going to try to produce a steady stream of very small PRs which get things back in sync.

This is therefore hopefully the first of a few changes.

python/typeshed#8608 introduced annotations for create which are not fully reflected here.

In order to reflect that state into jsonschema, a new module, jsonschema._typing is introduced. The purpose of _typing is to be a singular place for the library to define type aliases and any typing-related utilities which may be needed. This will let us use aliases like _typing.JsonValue in many locations where any valid JSON datatype is accepted. The definitions can be refined over time as necessary.

Initial definitions in _typing are:

• Schema (any JSON object)
• JsonObject (any JSON object)
• JsonValue (any JSON value, including objects or sequences)

Schema is just another name for JsonObject. Perhaps it is not needed, but the name may help clarify things to a reader. It is not obvious at present whether or not it is a good or bad idea to notate it as such, but a similar Schema alias is defined in typeshed and seems to be working there to annotate things accurately.

These types are using Mapping and Sequence rather than dict or list. The rationale is that jsonschema's logic does not dictate that the objects used must be defined in stdlib types or subtypes thereof. For example, a collections.UserDict could be used and should be accepted by the library (UserDict wraps but does not inherit from dict.)

:books: Documentation preview :books:: https://python-jsonschema--1027.org.readthedocs.build/en/1027/

I need to have a schema allowing extra fields only under one specific node (ExtensionProperties). It works well using "additionalProperties": false with simple schemas:

{
    "$schema": "https://json-schema.org/draft/2019-09/schema#",
    "type": "object",
    "additionalProperties": false,
    "properties": {
        "rootppty": {
            "type": "string"
        },
        "ExtensionProperties": {
            "type": "object"          
        }
    }
}

This data is ok

{
  "rootppty": "ad",
   "ExtensionProperties": {
      "whatever": "you want"
    }
}

and this one fails validation as expected

{
  "rootppty": "ok",
  "other": "fail",
   "ExtensionProperties": {
      "whatever": "you want"
    }
}

But when I have some allOf, I need to use "unevaluatedProperties": false as explained in the documentation It works well with simple schemas

{
    "$schema": "https://json-schema.org/draft/2019-09/schema#",
    "type": "object",
    "additionalProperties": false,
    "properties": {
        "rootppty": {
            "type": "string"
        },
        "data": {
          "unevaluatedProperties": false,
          "allOf": [{
            "type": "object",
            "title": "IndividualProperties",
            "properties": {
              "Nestedppty": {
                "type": "string"
              }
            }
          }
         ]
        },
        "ExtensionProperties": {
            "type": "object"          
        }
    }
}

This data fails the validation as expected (on rootppty2 and Nestedppty2)

{
  "rootppty": "ok",
  "rootppty2": "fail",
  "data": {
    "Nestedppty": "ok",
    "Nestedppty2": "fail"
  },
   "ExtensionProperties": {
      "whatever": "you want"
    }
}

But when I am adding array in the allOf part I am facing issues This schema does not fail validation on additional fields in the array

{
    "$schema": "https://json-schema.org/draft/2019-09/schema#",
    "type": "object",
    "additionalProperties": false,
    "properties": {
        "rootppty": {
            "type": "string"
        },
        "data": {
            "unevaluatedProperties": false,
            "allOf": [{
                    "type": "object",
                    "title": "IndividualProperties",
                    "properties": {
                        "Nestedppty": {
                            "type": "string"
                        },
                        "Nestedarray": {
                            "type": "array",
                            "items": {
                                "unevaluatedProperties": false,
                                "type": "object",
                                "properties": {
                                    "additionalProperties": false,
                                    "nestedarrayInternalpty": {
                                        "type": "string"
                                    }
                                }
                            }
                        }
                    }
                }
            ]
        },
        "ExtensionProperties": {
            "type": "object"
        }
    }
}

for example this data should fail validation on nestedarrayInternalpty2

{
  "rootppty": "ok",
  "data": {
    "Nestedppty": "ok",
    "Nestedarray": [
      {"nestedarrayInternalpty": "ok"},
      {"nestedarrayInternalpty2": "should fail"}
    ]
  },
   "ExtensionProperties": {
      "whatever": "you want"
    }
}

but it fails also on Nestedppty, which should be ok Am I doing something wrong or is there an issue when several "unevaluatedProperties": false are nested ?

After getting the go-ahead in https://github.com/python-jsonschema/jsonschema/issues/1017 I thought I would test the waters both in size and scope of potential PRs.

Feel free to ask me to separate some of the commits into separate PRs. I thought this was quite manageable, especially if you go commit by commit.

I thought I would start with a fairly self contained module (and a module I interact with quite a lot with at work myself). I think most of the changes are pretty straight forward. The first commit is hardest to review and for now I focused on the attributes that I was most sure about, keeping harder ones for later.

The second and third commit "fix issues". I understand that these are not actual issues and that through the dynamicness of Python these code paths actually currently work. So: what is the desired action here? Add ignores to tell mypy we know this works? Or add some isinstance checks and attribute definitions to make the code actually type safe. I lean towards the latter but don't want to impose my personal preference on a project I am not involved with until now. I'm more than happy to change those commits to do something differenty!

Happy reviewing 😄

Edit: Sorry for all the force pushes, after a helpful comment from @ AlexWaygood in the typeshed repo I found one issue with my initial PR.

:books: Documentation preview :books:: https://python-jsonschema--1019.org.readthedocs.build/en/1019/

Looking at the following MCVE:

import jsonschema

null = None

schema = {
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "$id": "tag:example.com,2022:test.schema.json",
  # "$id": "worksfinewithoutcolon",
  "$ref": "#/$defs/foo",

  "$defs": {

    "foo": {
      "properties": {
        "bar": {
          "$ref": "#/$defs/bar"
        }
      }
    },

    "bar": { }
  }
}

instance = {
  "bar": 42
}

jsonschema.validate(instance, schema)

This raises:

Traceback (most recent call last):

  File "/home/lukas/anaconda3/envs/ifos_test/lib/python3.10/site-packages/jsonschema/validators.py", line 898, in resolve_from_url
    document = self.store[url]

  File "/home/lukas/anaconda3/envs/ifos_test/lib/python3.10/site-packages/jsonschema/_utils.py", line 28, in __getitem__
    return self.store[self.normalize(uri)]

KeyError: ''


During handling of the above exception, another exception occurred:

Traceback (most recent call last):

  File "/home/lukas/anaconda3/envs/ifos_test/lib/python3.10/site-packages/jsonschema/validators.py", line 901, in resolve_from_url
    document = self.resolve_remote(url)

  File "/home/lukas/anaconda3/envs/ifos_test/lib/python3.10/site-packages/jsonschema/validators.py", line 1007, in resolve_remote
    with urlopen(uri) as url:

  File "/home/lukas/anaconda3/envs/ifos_test/lib/python3.10/urllib/request.py", line 216, in urlopen
    return opener.open(url, data, timeout)

  File "/home/lukas/anaconda3/envs/ifos_test/lib/python3.10/urllib/request.py", line 503, in open
    req = Request(fullurl, data)

  File "/home/lukas/anaconda3/envs/ifos_test/lib/python3.10/urllib/request.py", line 322, in __init__
    self.full_url = url

  File "/home/lukas/anaconda3/envs/ifos_test/lib/python3.10/urllib/request.py", line 348, in full_url
    self._parse()

  File "/home/lukas/anaconda3/envs/ifos_test/lib/python3.10/urllib/request.py", line 377, in _parse
    raise ValueError("unknown url type: %r" % self.full_url)

ValueError: unknown url type: ''


During handling of the above exception, another exception occurred:

Traceback (most recent call last):

  File "/home/lukas/anaconda3/envs/ifos_test/lib/python3.10/site-packages/spyder_kernels/py3compat.py", line 356, in compat_exec
    exec(code, globals, locals)

  File "/home/lukas/Desktop/scratch/schemaref.py", line 41, in <module>
    jsonschema.validate(instance, schema, resolver=resolver)

  File "/home/lukas/anaconda3/envs/ifos_test/lib/python3.10/site-packages/jsonschema/validators.py", line 1108, in validate
    error = exceptions.best_match(validator.iter_errors(instance))

  File "/home/lukas/anaconda3/envs/ifos_test/lib/python3.10/site-packages/jsonschema/exceptions.py", line 382, in best_match
    best = next(errors, None)

  File "/home/lukas/anaconda3/envs/ifos_test/lib/python3.10/site-packages/jsonschema/validators.py", line 278, in iter_errors
    for error in errors:

  File "/home/lukas/anaconda3/envs/ifos_test/lib/python3.10/site-packages/jsonschema/_validators.py", line 332, in properties
    yield from validator.descend(

  File "/home/lukas/anaconda3/envs/ifos_test/lib/python3.10/site-packages/jsonschema/validators.py", line 295, in descend
    for error in self.evolve(schema=schema).iter_errors(instance):

  File "/home/lukas/anaconda3/envs/ifos_test/lib/python3.10/site-packages/jsonschema/validators.py", line 278, in iter_errors
    for error in errors:

  File "/home/lukas/anaconda3/envs/ifos_test/lib/python3.10/site-packages/jsonschema/_validators.py", line 298, in ref
    yield from validator.descend(instance, resolved)

  File "/home/lukas/anaconda3/envs/ifos_test/lib/python3.10/site-packages/jsonschema/validators.py", line 295, in descend
    for error in self.evolve(schema=schema).iter_errors(instance):

  File "/home/lukas/anaconda3/envs/ifos_test/lib/python3.10/site-packages/jsonschema/validators.py", line 278, in iter_errors
    for error in errors:

  File "/home/lukas/anaconda3/envs/ifos_test/lib/python3.10/site-packages/jsonschema/_validators.py", line 294, in ref
    scope, resolved = validator.resolver.resolve(ref)

  File "/home/lukas/anaconda3/envs/ifos_test/lib/python3.10/site-packages/jsonschema/validators.py", line 887, in resolve
    return url, self._remote_cache(url)

  File "/home/lukas/anaconda3/envs/ifos_test/lib/python3.10/site-packages/jsonschema/validators.py", line 903, in resolve_from_url
    raise exceptions.RefResolutionError(exc)

RefResolutionError: unknown url type: ''

RefResolutionError: unknown url type: ''

According to my reading of the spec, this should validate just fine. Hyperjump also finds these JSONs valid (after removing the # comment line).

However, jsonschema fails here. It looks like two things are needed for the error to happen:

• A URI in the "$id" field where jsonschema doesn't know the scheme (or a string that looks like a URI).
• Nested "$ref" statements.

According to the spec:

The $id keyword defines a URI for the schema, and the base URI that other URI references within the schema are resolved against.

jsonschema validates the file just fine if the "$id" doesn't contain a colon. I don't even understand why it tries to resolve the "$id".

Related: #313

Python 3.11 now supports exception groups for grouping together multiple (simultaneous, unrelated) exceptions.

This seems to suit us -- right now we have:

• Validator.iter_errors, aimed at returning (not raising) all errors
• Validator.is_valid, aimed at returning no errors and indicating via a boolean whether things are OK
• Validator.validate, aimed at raising 1 single exception (the first encountered one)

Another API where we raise all exceptions iter_errors would have returned seems like it may fit the picture.