isinstance based custom validator in pydantic for custom classes from third party libraries

In my custom package for work, I want to validate inputs using pydantic. However, most of my functions take inputs that are not of native types, but instances of classes from other libraries, e.g. pandas.DataFrame or sqlalchemy.Engine. Mentioning these as type hints and adding pydantic.validate_arguments decorator fails.

Let's suppose the input of my function should be of type CustomClass from library CustomPackage.

import CustomPackage
import pydantic


@pydantic.validate_arguments
def custom_function(custom_argument: CustomPackage.CustomClass) -> None:
    pass

This will lead to the following error:

> RuntimeError: no validator found for <class 'CustomPackage.CustomClass'>, see arbitrary_types_allowed in Config

To solve this, I can use @pydantic.validate_arguments(config={"arbitrary_types_allowed": True}) instead, which will allow anything. This is not my intention, so I followed the custom type section in documentation, and created this:

import collections.abc
import typing

import CustomPackage


class CustomClassWithValidator(CustomPackage.CustomClass):
    @classmethod
    def __get_validators__(cls: typing.Type["CustomClassWithValidator"]) -> collections.abc.Iterable[collections.abc.Callable]:
        yield cls.validate_custom_class

    @classmethod
    def validate_custom_class(cls: typing.Type["CustomClassWithValidator"], passed_value: typing.Any) -> CustomPackage.CustomClass:
        if isinstance(passed_value, CustomPackage.CustomClass):
            return passed_value

        raise ValueError

After this, the following works fine:

@pydantic.validate_arguments
def custom_function(custom_argument: CustomClassWithValidator) -> None:
    pass

But I have quite a few of third party dependencies, and each have lots of custom classes which I am using. Creating almost identical class for every single one of them as above will work, but that does not seem optimal. Is there any functionality in pydantic to make this less repetitive?

I am not aware of any built-in Pydantic way in version 1 to do this other than adding the __get_validators__ generator function to your types you already found.

I think one of the main reasons for this is that usually you want field types to not just be validated as being of the correct type, but also parsed or serialized/deserialized because in most areas, where Pydantic is applied, you either instantiate Pydantic models from Python primitives or objects of built-in types or even from JSON text.

So Pydantic not only provides default validators for the most common types, but also sensible and somewhat flexible initialization and (de-)serialization functions for those types.

The implication then is that if you want to use some custom/foreign type, you are responsible for telling Pydantic how to instantiate and validate it.

Workarounds

Option A: Simple mix-in

If all you want is to have a blanket "dumb" validator simply checking isinstance for any given type, you can just re-write what you already have as an agnostic mix-in class to minimize repetition:

from collections.abc import Callable, Iterator
from typing import Any, Self


class ValidatorMixin:
    @classmethod
    def __get_validators__(cls) -> Iterator[Callable[..., Any]]:
        yield cls.__validate__

    @classmethod
    def __validate__(cls, v: object) -> Self:
        if isinstance(v, cls):
            return v
        raise TypeError(f"Not an instance of {cls.__name__}: {v}")

Then you can simply inherit from that with together with any specific class you want:

from pydantic import validate_arguments

# ... import ValidatorMixin


class Bar:  # from foo
    ...

class Eggs:  # from spam
    ...


class MyBar(ValidatorMixin, Bar):
    pass

class MyEggs(ValidatorMixin, Eggs):
    pass


@validate_arguments
def f(bar: MyBar, eggs: MyEggs) -> None:
    print(bar, eggs)

Now the problem with that is your arguments now must be of the types MyBar and MyEggs and cannot be just of type Bar and Eggs.

Option B: Generic mix-in

To allow specifying which class exactly to validate against, while keeping repetition to a minimum, we need to get creative. An approach I would suggest is making the ValidatorMixin generic in terms of what class to check against. There is a bit of magic you can do to then automatically extract the type argument passed to it and validate against that: (see here for details)

from collections.abc import Callable, Iterator
from typing import Any, Generic, TypeVar, get_args, get_origin

T = TypeVar("T")


class ValidatorMixin(Generic[T]):
    _type_arg: type[T] | None = None

    @classmethod
    def _get_type_arg(cls) -> type[T]:
        if cls._type_arg is not None:
            return cls._type_arg
        raise AttributeError(f"{cls.__name__} is generic; type arg unspecified")

    @classmethod
    def __init_subclass__(cls, **kwargs: Any) -> None:
        super().__init_subclass__(**kwargs)
        for base in cls.__orig_bases__:  # type: ignore[attr-defined]
            origin = get_origin(base)
            if origin is None or not issubclass(origin, ValidatorMixin):
                continue
            type_arg = get_args(base)[0]
            if not isinstance(type_arg, TypeVar):
                cls._type_arg = type_arg
                return

    @classmethod
    def __get_validators__(cls) -> Iterator[Callable[..., Any]]:
        yield cls.__validate__

    @classmethod
    def __validate__(cls, v: object) -> T:
        if isinstance(v, cls._get_type_arg()):
            return v
        raise TypeError(f"Not an instance of {cls.__name__}: {v}")

Now you can use it like this:

from pydantic import validate_arguments

# ... import ValidatorMixin


class Bar:  # from foo
    ...


class Eggs:  # from spam
    ...


class MyClass(ValidatorMixin[Eggs], Bar, Eggs):
    pass


@validate_arguments
def f(obj: MyClass) -> None:
    print(obj)


f(Eggs())

As you can see, this now also allows you to use multiple inheritance, yet still specify exactly what to validate against. That f call in the last line will therefore pass validation.

There is however still one flaw with this. Static type checkers will complain about that call because Eggs is not a subtype of MyClass (it is the other way around), so that call would be seen as an error.

Option C: Monkey-patch the class itself

If that bothers you, the only other reasonable alternative in my opinion would be to just monkey-patch the classes you want to use instead of subclassing and mixing. Something like this:

from collections.abc import Callable, Iterable, Iterator
from typing import Any, TypeVar

T = TypeVar("T")


def add_validation(
    cls: type[T],
    validators: Iterable[Callable[..., Any]] = (),
    force_patch: bool = False,
) -> type[T]:
    method_name = "__get_validators__"
    if not force_patch and hasattr(cls, method_name):
        raise AttributeError(f"{cls.__name__} already has `{method_name}`")
    if not validators:
        def __validate__(v: object) -> T:
            if isinstance(v, cls):
                return v
            raise TypeError(f"Not an instance of {cls.__name__}: {v}")
        validators = (__validate__, )

    def __get_validators__(_cls: type) -> Iterator[Callable[..., Any]]:
        yield from validators
    setattr(cls, method_name, classmethod(__get_validators__))
    return cls

Now this can be used both as a simple function for monkey-patching some third-party class and as a decorator for your own classes.

(You are also free to add other validation functions via the optional validators argument.)

Usage:

from pydantic import validate_arguments

# ... import add_validation


class Bar:  # from foo
    ...


add_validation(Bar)


@add_validation
class SomeCustomClass:
    ...


@validate_arguments
def f(bar: Bar, obj: SomeCustomClass) -> None:
    print(bar, obj)


f(Bar(), SomeCustomClass())

If you want, you can make a more sophisticated version of that decorator allowing usage with or without additional arguments:

from collections.abc import Callable, Iterable, Iterator
from typing import Any, TypeVar, overload

T = TypeVar("T")


@overload
def add_validation(
    cls: None = None,
    *,
    validators: Iterable[Callable[..., Any]] = (),
    force_patch: bool = False,
) -> Callable[[type[T]], type[T]]: ...


@overload
def add_validation(cls: type[T]) -> type[T]: ...


def add_validation(
    cls: type[T] | None = None,
    *,
    validators: Iterable[Callable[..., Any]] = (),
    force_patch: bool = False,
) -> type[T] | Callable[[type[T]], type[T]]:
    def decorator(cls_: type[T]) -> type[T]:
        nonlocal validators
        method_name = "__get_validators__"
        if not force_patch and hasattr(cls_, method_name):
            raise AttributeError(f"{cls_.__name__} already has `{method_name}`")
        if not validators:
            def __validate__(v: object) -> T:
                if isinstance(v, cls_):
                    return v
                raise TypeError(f"Not an instance of {cls_.__name__}: {v}")
            validators = (__validate__, )

        def __get_validators__(_cls: type) -> Iterator[Callable[..., Any]]:
            yield from validators
        setattr(cls_, method_name, classmethod(__get_validators__))
        return cls_
    return decorator if cls is None else decorator(cls)