Support additional (Python) types in more than the type validator

[charkins]

In issue #364 and the related PR the type checker was expanded to allow redefining how jsonschema identifies/validates a type, with the intention of allowing a named tuple to be used as a jsonschema "object" type. In practice, this does not appear to be enough, as other portions of jsonschema use the python "in" expression to test for or iterate over properties in an object. In a NamedTuple, this will actually test the values of the properties. Two specific examples (required and additionalProperties) highlight this:

from typing import NamedTuple
from jsonschema import Draft7Validator
from jsonschema.validators import extend
from jsonschema.exceptions import ValidationError

# dict or tuple w/ _fields is object (allowed NamedTuple as object)
def is_object_or_namedtuple(checker, instance):
    return isinstance(instance, dict) or (
        isinstance(instance, tuple) and hasattr(instance, '_fields'))

# redefine object to allow namedtuple
type_checker = Draft7Validator.TYPE_CHECKER.redefine(
    'object', is_object_or_namedtuple)

# extend validator with new type checker
Validator = extend(Draft7Validator, type_checker=type_checker)

# validator with foo as required property
validator_foo_required = Validator(schema={
    "type": "object",
    "properties": {
        "foo": {
            "type": "string"
        }
    },
    "required": ["foo"]
})

# validator with foo as optional property, no additional
validator_foo_optional_no_additional = Validator(schema={
    "type": "object",
    "properties": {
        "foo": {
            "type": "string"
        }
    },
    "additionalProperties": False
})

class Example(NamedTuple):
    foo: str


example = Example(foo="bar")

try:
    validator_foo_required.validate(example)
except ValidationError as e:
    print(f"Error: {e.message}")

try:
    validator_foo_optional_no_additional.validate(example)
except ValidationError as e:
    print(f"Error: {e.message}")

# the problem is that 'foo' is not "in" example..
print('Is foo in example? ', ('foo' in example))

# ... but 'bar' is
print('Is bar in example? ', ('bar' in example))

This is more of an FYI, as #364 was targeted at supporting NamedTuple, but it looks like there would be some bigger changes required to facilitate redefining how properties are identified/accessed in the NamedTuple.

[Julian]

(Will come back to this in more detail)

Thanks for filing -- yeah, I was somewhat aware of this at the time.

Really the only way to do this "well" is if jsonschema specified what protocol each validator expected and committed to that protocol, but folks who want to do things like this somewhat expect to see things work as-is, which as you say, isn't the way things work.

At the minute things do work for type (the validator), but if arbitrary validators are to work with random types then yeah something much bigger would be needed.

We can leave this open for now -- I'm not sure such a thing is in jsonschema's future but worth thinking through.