Best practice for own TypeChecker that overrides is_type

[sebastianw]

Hello,

I'm trying to ignore type checking for a specific class instance that represents a Link in our YAML Schema. Right now I'm creating a new type checker, but to make it work as expected I have to create it with the "original" types taken from the private instance attribute _type_checkers of the original type checker.

Is this the best way to override the is_type function of a TypeChecker? I didn't want to monkey patch the function in the original TypeChecker.

class LinkTypeChecker(jsonschema.TypeChecker):
    """
    A Custom jsonschema TypeChecker that always returns True for our custom Link class.
    """

    def is_type(self, instance: Any, type: str) -> bool:
        if isinstance(instance, YamlLink):
            log.trace(f"Ignoring type validation for {instance}")
            return True
        return super().is_type(instance, type)


def extend_validator(validator: type[jsonschema.Validator]) -> type[jsonschema.Validator]:
    _old_types = validator.TYPE_CHECKER._type_checkers
    validator = jsonschema.validators.extend(validator, type_checker=LinkTypeChecker(_old_types))
    return validator

validator_cls = jsonschema.validators.validator_for(schema)
# noinspection PyTypeChecker
validator_cls = extend_validator(validator_cls)
validator = validator_cls(schema, registry=SCHEMA_REGISTRY)

[LehiSalvador]

For the stated goal—skip the schema's type assertion for YamlLink—you can extend the public keyword handler without subclassing TypeChecker or reading _type_checkers:

from jsonschema import validators

def skip_link_type(validator_cls):
    original_type = validator_cls.VALIDATORS["type"]

    def validate_type(validator, expected_types, instance, schema):
        if not isinstance(instance, YamlLink):
            yield from original_type(
                validator, expected_types, instance, schema
            )

    return validators.extend(
        validator_cls, validators={"type": validate_type}
    )

# Use your existing YamlLink definition and schema registry.
base_cls = validators.validator_for(schema)
base_cls.check_schema(schema)
validator_cls = skip_link_type(base_cls)
validator = validator_cls(schema, registry=SCHEMA_REGISTRY)

This leaves TYPE_CHECKER intact and delegates normal instances to the original type handler. That distinction matters: declaring a placeholder to be every JSON type can make other keyword handlers treat it as a real mapping, array or number and attempt unsupported operations.

If you want to change actual type classification instead, the public API is validator_cls.TYPE_CHECKER.redefine(...) or redefine_many(...), then validators.extend(..., type_checker=new_checker). Those APIs return a new checker while preserving definitions you did not replace.

The example bypasses only type, not all validation. enum, const, references and other applicable constraints can still reject a link. If links should be entirely transparent, resolve/preprocess them or define that broader behavior explicitly before validation. Cross-draft references also need testing because validator evolution can select a different class.

References: extending keyword handlers, public type checker API.

AI-assisted response. A standalone reproduction executed with jsonschema 4.25.1 for Draft7 and Draft202012: links bypass type, ordinary invalid types still fail, TYPE_CHECKER stays unchanged, and enum still rejects unmatched links.