Unexpected behavior. Do you have to explicitly specify format_checker?

[guild-jonathan-kaczynski]

Do you have to explicitly specify format_checker for the validators to produce expected results?

Expected: I would have expected that specifying $schema in the schema document would cause the correct validator and format_checker to be instantiated.

Actual: There is no format_checker used by default.

Setup:

docker run -it --rm python:3.9 bash
pip install jsonschema==4.5.1
python3
import json
import jsonschema
event = json.loads('{"uuid": "7"}')
schema = json.loads("""{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "type": "object",
  "properties": {
    "uuid": { 
      "type": "string", 
      "format": "uuid" 
    }
  },
  "required": ["uuid"],
  "additionalProperties": false
}
""")

First test (Unexpectedly, no errors):

schema["$schema"] in jsonschema.validators._META_SCHEMAS
# True
print(jsonschema.validators._META_SCHEMAS[schema["$schema"]])
# <class 'jsonschema.validators.Draft202012Validator'>
print(jsonschema.validate(event, schema))
# None

Second test (Unexpectedly, no errors):

validator = jsonschema.Draft202012Validator(schema=schema)
print(validator.validate(event))
# None
print(validator.format_checker)
# None

Third test (finally the error we're looking for):

validator = jsonschema.Draft202012Validator(schema=schema, format_checker=jsonschema.draft202012_format_checker)
print(validator.validate(event))
# Traceback (most recent call last):
#   File "/usr/local/lib/python3.9/site-packages/jsonschema/_format.py", line 106, in check
#     result = func(instance)
#   File "/usr/local/lib/python3.9/site-packages/jsonschema/_format.py", line 480, in is_uuid
#     UUID(instance)
#   File "/usr/local/lib/python3.9/uuid.py", line 177, in __init__
#     raise ValueError('badly formed hexadecimal UUID string')
# ValueError: badly formed hexadecimal UUID string
# 
# The above exception was the direct cause of the following exception:
# 
# Traceback (most recent call last):
#   File "<stdin>", line 1, in <module>
#   File "/usr/local/lib/python3.9/site-packages/jsonschema/validators.py", line 267, in validate
#     raise error
# jsonschema.exceptions.ValidationError: '7' is not a 'uuid'
# 
# Failed validating 'format' in schema['properties']['uuid']:
#     {'format': 'uuid', 'type': 'string'}
# 
# On instance['uuid']:
#     '7'
print(validator.format_checker)
# <FormatChecker checkers=['date', 'email', 'idn-email', 'ipv4', 'ipv6', 'regex', 'uuid']>

Fourth test (circling back to our first test, we see this works too):

>>> print(jsonschema.validate(event, schema, format_checker=jsonschema.draft202012_format_checker))
# Traceback (most recent call last):
#   File "/usr/local/lib/python3.9/site-packages/jsonschema/_format.py", line 106, in check
#     result = func(instance)
#   File "/usr/local/lib/python3.9/site-packages/jsonschema/_format.py", line 480, in is_uuid
#     UUID(instance)
#   File "/usr/local/lib/python3.9/uuid.py", line 177, in __init__
#     raise ValueError('badly formed hexadecimal UUID string')
# ValueError: badly formed hexadecimal UUID string
# 
# The above exception was the direct cause of the following exception:
# 
# Traceback (most recent call last):
#   File "<stdin>", line 1, in <module>
#   File "/usr/local/lib/python3.9/site-packages/jsonschema/validators.py", line 267, in validate
#     raise error
# jsonschema.exceptions.ValidationError: '7' is not a 'uuid'
# 
# Failed validating 'format' in schema['properties']['uuid']:
#     {'format': 'uuid', 'type': 'string'}
# 
# On instance['uuid']:
#     '7'

More information ...

In the create validator function, we see

jsonschema/jsonschema/validators.py

Line 113 in fb85c66

format_checker=_format.draft202012_format_checker,

and then documented below,

jsonschema/jsonschema/validators.py

Lines 154 to 160 in fb85c66

	format_checker (jsonschema.FormatChecker):
	a format checker, used when applying the :validator:`format`
	validator.
	If unprovided, a `jsonschema.FormatChecker` will be created
	with a set of default formats typical of JSON Schema drafts.

And then when Draft202012Validator is created, we see

jsonschema/jsonschema/validators.py

Line 624 in fb85c66

format_checker=_format.draft202012_format_checker,

which makes me think that we are setting the draft 2020-12 formatter on the draft 2020-12 validator.

But this contradicts what we see in the end, in the help text:

class Draft202012Validator(builtins.object)
| Draft202012Validator(schema, resolver=None, format_checker=None) -> None

Later in the create validator function we see

jsonschema/jsonschema/validators.py

Line 190 in fb85c66

format_checker = attr.ib(default=None)

which tracks with what I'm seeing in the help text above, but doesn't make sense to me on the face of it.

If, and I stress if, we wanted to instantiate a specific version of a validator, it appears that we can reference the FORMAT_CHECKER defined on that class.

>>> validator = jsonschema.Draft202012Validator(schema=schema, format_checker=jsonschema.Draft202012Validator.FORMAT_CHECKER)
>>> validator.format_checker
<FormatChecker checkers=['date', 'email', 'idn-email', 'ipv4', 'ipv6', 'regex', 'uuid']>

[Julian]

As I mentioned in the issue, yes, you need to specify a format checker because by default the specification says format should not do any asserting. You can do so either to jsonschema.validate or to Draft202012Validator if you repeatedly validate with the same schema.

[guild-jonathan-kaczynski]

Sorry, I misspoke, there is no Validator class for me to instantiate. I would have to replicate the guts of the validate function

jsonschema/jsonschema/validators.py

Lines 1051 to 1058 in fb85c66

	if cls is None:
	cls = validator_for(schema)
	cls.check_schema(schema)
	validator = cls(schema, *args, **kwargs)
	error = exceptions.best_match(validator.iter_errors(instance))
	if error is not None:
	raise error

but my question still stands.

[Julian]

All of what's in jsonschema.validate's implementation is public API, it's honestly just a convenience function for beginners, so indeed if you want to call jsonschema,validator.validator_for and then use Validator.FORMAT_CHECKER from what you get back you could indeed do so.

[guild-jonathan-kaczynski]

Would this be your recommended solution?

def get_validator(schema):
    # Borrowed from https://github.com/python-jsonschema/jsonschema/blob/fb85c6620ff26823362ebd27b8577995c0841028/jsonschema/validators.py#L995-L1058
    cls = jsonschema.validators.validator_for(schema)
    cls.check_schema(schema)
    validator = cls(schema)
    validator.format_checker = validator.FORMAT_CHECKER
    return validator


validator = get_validator(schema)

[Julian]

Assigning to attributes is not public API (which you're doing on line 6) -- you can replace lines 5-7 with return cls(schema, format_checker=cls.FORMAT_CHECKER), otherwise seems reasonable. You can skip the call to check_schema as well if you know it's valid, but if it's user specified then not.

[guild-jonathan-kaczynski]

Thanks! For posterity, here's the full working example:

docker run -it --rm python:3.9 bash
python --version
# Python 3.9.9
pip install jsonschema==4.5.1
python3
import json
import jsonschema


def get_validator(schema):
    # Borrowed from https://github.com/python-jsonschema/jsonschema/blob/fb85c6620ff26823362ebd27b8577995c0841028/jsonschema/validators.py#L995-L1058
    cls = jsonschema.validators.validator_for(schema)
    cls.check_schema(schema)
    validator = cls(schema, format_checker=cls.FORMAT_CHECKER)
    return validator


event = json.loads("""{"uuid": "7"}""")
schema = json.loads("""{
  "$schema": "http://json-schema.org/draft/2020-12/schema",
  "type": "object",
  "properties": {
    "uuid": { 
      "type": "string", 
      "format": "uuid" 
    }
  },
  "required": ["uuid"],
  "additionalProperties": false
}
""")
validator = get_validator(schema)
validator
# Draft202012Validator(schema={'$schema': 'http://json-...020-12/schema', 'additionalProperties': False, 'properties': {'uuid': {'format': 'uuid', 'type': 'string'}}, 'required': ['uuid'], ...}, format_checker=<FormatChecker checkers=['date', 'email', 'idn-email', 'ipv4', 'ipv6', 'regex', 'uuid']>)
print(list(validator.iter_errors(event)))
# [<ValidationError: "'7' is not a 'uuid'">]

[Chardrazle]

Hi,
I've just stumbled into something similar (v4.18.6). Is this still working?

The sample I have creates a validator instance and hooks in the format_checker, but it doesn't appear to carry through.

Full example:

#!/usr/bin/env python3

from jsonschema import validate, exceptions, Draft202012Validator, validators, FormatChecker
import sys

schema_item = {
  "$schema": "http://json-schema.org/schema#",
  "definitions": {
    "nonIP": {
      "allOf": [
        {
          "type": "string"
        },
        {
          "not": {
            "type": "string",
            "format": "ipv4"
          }
        }
      ]
    }
  },
  "type": "object",
  "properties": {
    "test": {
      "$ref": "#/definitions/nonIP"
    }
  },
  "required": [ "test" ],
  "additionalProperties": False
}


instance = {
   "test": "01.0.0.0"  # Should be invalid
#   "test": "Something non IP"  # Valid
}


v = Draft202012Validator(schema_item, format_checker=FormatChecker())
# Equally:
# v = Draft202012Validator(schema_item, format_checker=Draft202012Validator.FORMAT_CHECKER)
# v = validators.validator_for(schema_item)(schema_item, format_checker=Draft202012Validator.FORMAT_CHECKER)

try:
    v.validate(instance)
    print("PASSED VALIDATION")

    # Using the direct validate _does_ result in failure for the IPv4:
    #validate(schema=schema_item, instance=instance)
except exceptions.ValidationError as err:
    print(err)
    print("FAILED VALIDATION")

The production code actually uses extend, but this is what it strips back to. Is this the wrong approach?