Validate towards type hinted function signature without calling the function

[anders-kiaer]

Checks

• I added a descriptive title to this issue
• I have searched (google, github) for similar issues and couldn't find anything
• I have read and followed the docs and couldn't find an answer
• After submitting this, I commit to one of:
  • Look through open issues and helped at least one other person
  • Hit the "watch" button on this repo to receive notifications and I commit to help at least 2 people that ask questions in the future
  • Implement a Pull Request for a confirmed bug

Question

Is there a way to validate data input compared to type hinted function signature, without calling the function? I've seen https://pydantic-docs.helpmanual.io/usage/validation_decorator/ but that appears to do the validation check when calling the function.

Example use case/context:
User input (e.g. from a configuration file) is used to call different functions and/or initiate different classes. It would be nice to quickly provide the user with a collection of validation feedback in one go, and not having to wait on e.g. the first X function calls to be successful while X+1 turns out to have invalid data input.

[PrettyWood]

Hello @anders-kiaer
If you take a look at the code of validate_arguments, you should be able to just use the "validation part" of the call method

    def call(self, *args: Any, **kwargs: Any) -> Any:
        values = self.build_values(args, kwargs)
        m = self.model(**values)
        return self.execute(m)

For example you could do something like

from pydantic import validate_arguments


@validate_arguments
def repeat(s: str, count: int, *, separator: bytes = b'') -> bytes:
    print('CALLED')
    b = s.encode()
    return separator.join(b for _ in range(count))

def validate(f, *args, **kwargs):
    validated_function = f.vd
    values = validated_function.build_values(args, kwargs)
    validated_function.model(**values)

validate(repeat, 'qwe', 2)  # ok
validate(repeat, ['qwe'], 2)
# s
#   str type expected (type=type_error.str)

You can even add your custom decorator based on validate_arguments.

Hope it helps!

EDIT: I made a small PR to expose a way to do what you want directly! Feedback welcome :) Cheers

[anders-kiaer]

Thanks @PrettyWood for super and quick answer + PR 🏎️ 🎉 Indeed, reusing small parts of the decorator logic as you suggests seems to work beautifully.

In my use case the functions (plugins) being called are in third-party packages, i.e. being able to use pydantic directly without necessarily decorating the functions is useful, which apparently is easy+possible using ValidatedFunction used internally in the decorator.

I don't see ValidatedFunction mentioned in the documentation. Due to no leading underscores I guess it is already part of public API. Should we add some examples of usage in the documentation, or is this non-decorator use case (and variants of it) too narrow?

Some quick example:

from pydantic.decorator import ValidatedFunction


def validate(func, arg_dict, validate=True):
    vd = ValidatedFunction(func, config=None)

    return (
        {
            key: value
            for key, value in vd.model(**arg_dict).dict().items()
            if key not in ["args", "kwargs"]
        },
        vd.model.schema(),
    )


if __name__ == "__main__":

    def some_example_func(a: str, b: int, c: bool = False) -> str:
        return f"{a}-{b}-{c}"

    (values, schema) = validate(
        some_example_func, {"a": "some_string", "b": "42", "c": "Yes"}
    )

    print(values)
    print(schema)

{'a': 'some_string', 'b': 42, 'c': True}
{'title': 'SomeExampleFunc', 'type': 'object', 'properties': {'a': {'title': 'A', 'type': 'string'}, 'b': {'title': 'B', 'type': 'integer'}, 'c': {'title': 'C', 'default': False, 'type': 'boolean'}, 'args': {'title': 'Args', 'type': 'array', 'items': {}}, 'kwargs': {'title': 'Kwargs', 'type': 'object'}}, 'required': ['a', 'b'], 'additionalProperties': False}

(apparently args and kwargs are added both in values and schema even though they are not in the function signature)