验证python dataclasses中的详细类型

Question

Python 3.7已发行了一段时间，我想测试一些花式新 dataclass +打字功能。通过本机类型和键入模块的提示正确工作非常容易：

>>> import dataclasses
>>> import typing as ty
>>> 
... @dataclasses.dataclass
... class Structure:
...     a_str: str
...     a_str_list: ty.List[str]
...
>>> my_struct = Structure(a_str='test', a_str_list=['t', 'e', 's', 't'])
>>> my_struct.a_str_list[0].  # IDE suggests all the string methods :)

但是我想尝试的另一件事是强迫类型提示作为运行时的条件，即可能存在 Dataclass 具有不正确类型的。它可以用 > ：

>>> @dataclasses.dataclass
... class Structure:
...     a_str: str
...     a_str_list: ty.List[str]
...     
...     def validate(self):
...         ret = True
...         for field_name, field_def in self.__dataclass_fields__.items():
...             actual_type = type(getattr(self, field_name))
...             if actual_type != field_def.type:
...                 print(f"\t{field_name}: '{actual_type}' instead of '{field_def.type}'")
...                 ret = False
...         return ret
...     
...     def __post_init__(self):
...         if not self.validate():
...             raise ValueError('Wrong types')

这种 validate 函数适用于本机类型和自定义类，而不是键入模块指定的函数：

>>> my_struct = Structure(a_str='test', a_str_list=['t', 'e', 's', 't'])
Traceback (most recent call last):
  a_str_list: '<class 'list'>' instead of 'typing.List[str]'
  ValueError: Wrong types

是否有更好的方法来验证一个键入 typed的列表？最好是一个不包括检查任何 list ， dict ， tuple 或 set streat set 中的所有元素类型>那是 dataclass '属性。

---

在几年后重新访问这个问题，我现在移动使用 pydantic < /a>在我想验证通常仅定义数据级别的类的情况下。不过，我将留下当前接受的答案，因为它正确回答了原始问题并具有出色的教育价值。

Answer 1

您应该使用 isInstance ，而不是检查类型平等。但是您不能使用参数化的通用类型（ typing.list [int] ）来做到这一点，您必须使用“通用”版本（ typing.list.list ）。因此，您将能够检查容器类型，而不能检查包含的类型。参数化的通用类型定义 __ Origin __ 您可以使用的属性。

与Python 3.6相反，在Python 3.7中，大多数类型的提示都具有有用的 __ Origin __ 属性。比较：

# Python 3.6
>>> import typing
>>> typing.List.__origin__
>>> typing.List[int].__origin__
typing.List

Python

# Python 3.7
>>> import typing
>>> typing.List.__origin__
<class 'list'>
>>> typing.List[int].__origin__
<class 'list'>

3.8引入 （） 内省功能：

# Python 3.8
>>> import typing
>>> typing.get_origin(typing.List)
<class 'list'>
>>> typing.get_origin(typing.List[int])
<class 'list'>

值得注意的例外是键入。 ，任何 typing._specialform 均未定义 __ oincor __ 。幸运的是：

>>> isinstance(typing.Union, typing._SpecialForm)
True
>>> isinstance(typing.Union[int, str], typing._SpecialForm)
False
>>> typing.get_origin(typing.Union[int, str])
typing.Union

但是参数化类型定义 __ args __ 属性将其参数存储为元组； Python 3.8介绍 typing> typing.get_args（get_args（） /a>检索它们的函数：

# Python 3.7
>>> typing.Union[int, str].__args__
(<class 'int'>, <class 'str'>)

# Python 3.8
>>> typing.get_args(typing.Union[int, str])
(<class 'int'>, <class 'str'>)

因此我们可以改进类型检查：

for field_name, field_def in self.__dataclass_fields__.items():
    if isinstance(field_def.type, typing._SpecialForm):
        # No check for typing.Any, typing.Union, typing.ClassVar (without parameters)
        continue
    try:
        actual_type = field_def.type.__origin__
    except AttributeError:
        # In case of non-typing types (such as <class 'int'>, for instance)
        actual_type = field_def.type
    # In Python 3.8 one would replace the try/except with
    # actual_type = typing.get_origin(field_def.type) or field_def.type
    if isinstance(actual_type, typing._SpecialForm):
        # case of typing.Union[…] or typing.ClassVar[…]
        actual_type = field_def.type.__args__

    actual_value = getattr(self, field_name)
    if not isinstance(actual_value, actual_type):
        print(f"\t{field_name}: '{type(actual_value)}' instead of '{field_def.type}'")
        ret = False

这不是完美的，因为它不会说明 typing.classvar [typing.union [int，str]] 或<代码> typing.optional [typing.list [int]] ，但应该开始工作。

---

接下来是应用此支票的方法。

我不使用 __ post_init __ ，而是去装饰器路线：可以在带有类型提示的任何内容上使用，不仅是 dataclasses ：

import inspect
import typing
from contextlib import suppress
from functools import wraps


def enforce_types(callable):
    spec = inspect.getfullargspec(callable)

    def check_types(*args, **kwargs):
        parameters = dict(zip(spec.args, args))
        parameters.update(kwargs)
        for name, value in parameters.items():
            with suppress(KeyError):  # Assume un-annotated parameters can be any type
                type_hint = spec.annotations[name]
                if isinstance(type_hint, typing._SpecialForm):
                    # No check for typing.Any, typing.Union, typing.ClassVar (without parameters)
                    continue
                try:
                    actual_type = type_hint.__origin__
                except AttributeError:
                    # In case of non-typing types (such as <class 'int'>, for instance)
                    actual_type = type_hint
                # In Python 3.8 one would replace the try/except with
                # actual_type = typing.get_origin(type_hint) or type_hint
                if isinstance(actual_type, typing._SpecialForm):
                    # case of typing.Union[…] or typing.ClassVar[…]
                    actual_type = type_hint.__args__

                if not isinstance(value, actual_type):
                    raise TypeError('Unexpected type for \'{}\' (expected {} but found {})'.format(name, type_hint, type(value)))

    def decorate(func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            check_types(*args, **kwargs)
            return func(*args, **kwargs)
        return wrapper

    if inspect.isclass(callable):
        callable.__init__ = decorate(callable.__init__)
        return callable

    return decorate(callable)

用法是：

@enforce_types
@dataclasses.dataclass
class Point:
    x: float
    y: float

@enforce_types
def foo(bar: typing.Union[int, str]):
    pass

appart appart vely某些类型的提示为某些类型的提示为在上一节中建议的是，此方法仍然有一些缺点：

• 使用字符串类型提示（ class foo：def __init __（self：'foo'）：Pass ）：）未通过<考虑。代码> getullargspec ：您可能需要使用 typing.get_type_hints 和 instead;

• 未验证不是适当类型的默认值：

    @enforce_type
   def foo（bar：int = none）：
       经过
  
   foo（）
   

  不提出任何 typeerror 。您可能需要使用 bistect.signature.signature.bind 与


• 变量的参数数量无法验证，因为您必须定义 def foo（*args：typing.sequence。开始，我们只能验证容器而不包含对象。

  


---

此答案之后的更新

获得了一些知名度，并且a library 受其启发的重大启发。解除上述缺点正在成为现实。因此，我在键入模块中播放了更多内容，并将在此处提出一些发现和新方法。

对于初学者，键入在查找参数时做得很好：

>>> def foo(a: int, b: str, c: typing.List[str] = None):
...   pass
... 
>>> typing.get_type_hints(foo)
{'a': <class 'int'>, 'b': <class 'str'>, 'c': typing.Union[typing.List[str], NoneType]}

这是非常整洁的，并且绝对是对 Inspect.getfullargspec 的改进，所以更好地将其当作它还可以正确处理字符串作为类型提示。但是 typing.get_type_hints 将为其他类型的默认值纾困：

>>> def foo(a: int, b: str, c: typing.List[str] = 3):
...   pass
... 
>>> typing.get_type_hints(foo)
{'a': <class 'int'>, 'b': <class 'str'>, 'c': typing.List[str]}

因此，即使这种情况感觉非常腥，您仍然需要额外的严格检查。

接下来是键入提示用作 typing._specialform 的参数的提示，例如 typing.optional [typing.list.list [str]] typing.final [typing.union [typing.sequence，typing.mapping]] 。由于这些 __ args __ typing._specialform s始终是一个元组，因此可以递归地找到该元组中包含的提示的 __ arount __ oink 。结合上述检查，我们将需要过滤任何键入。_specialform左。

拟议的改进：

import inspect
import typing
from functools import wraps


def _find_type_origin(type_hint):
    if isinstance(type_hint, typing._SpecialForm):
        # case of typing.Any, typing.ClassVar, typing.Final, typing.Literal,
        # typing.NoReturn, typing.Optional, or typing.Union without parameters
        return

    actual_type = typing.get_origin(type_hint) or type_hint  # requires Python 3.8
    if isinstance(actual_type, typing._SpecialForm):
        # case of typing.Union[…] or typing.ClassVar[…] or …
        for origins in map(_find_type_origin, typing.get_args(type_hint)):
            yield from origins
    else:
        yield actual_type


def _check_types(parameters, hints):
    for name, value in parameters.items():
        type_hint = hints.get(name, typing.Any)
        actual_types = tuple(_find_type_origin(type_hint))
        if actual_types and not isinstance(value, actual_types):
            raise TypeError(
                    f"Expected type '{type_hint}' for argument '{name}'"
                    f" but received type '{type(value)}' instead"
            )


def enforce_types(callable):
    def decorate(func):
        hints = typing.get_type_hints(func)
        signature = inspect.signature(func)

        @wraps(func)
        def wrapper(*args, **kwargs):
            parameters = dict(zip(signature.parameters, args))
            parameters.update(kwargs)
            _check_types(parameters, hints)

            return func(*args, **kwargs)
        return wrapper

    if inspect.isclass(callable):
        callable.__init__ = decorate(callable.__init__)
        return callable

    return decorate(callable)


def enforce_strict_types(callable):
    def decorate(func):
        hints = typing.get_type_hints(func)
        signature = inspect.signature(func)

        @wraps(func)
        def wrapper(*args, **kwargs):
            bound = signature.bind(*args, **kwargs)
            bound.apply_defaults()
            parameters = dict(zip(signature.parameters, bound.args))
            parameters.update(bound.kwargs)
            _check_types(parameters, hints)

            return func(*args, **kwargs)
        return wrapper

    if inspect.isclass(callable):
        callable.__init__ = decorate(callable.__init__)
        return callable

    return decorate(callable)

---

_{感谢@aran-fey 这帮助我改善了这个答案。}

Answer 2

刚刚找到了这个问题。

pydantic 可以为Dataclasses做完整的类型验证。 （入学：我构建了Pydantic）

只需使用Pydantic的Decorator版本，由此产生的Dataclass就是完全香草。

from datetime import datetime
from pydantic.dataclasses import dataclass

@dataclass
class User:
    id: int
    name: str = 'John Doe'
    signup_ts: datetime = None

print(User(id=42, signup_ts='2032-06-21T12:00'))
"""
User(id=42, name='John Doe', signup_ts=datetime.datetime(2032, 6, 21, 12, 0))
"""

User(id='not int', signup_ts='2032-06-21T12:00')

最后一行将给出：

    ...
pydantic.error_wrappers.ValidationError: 1 validation error
id
  value is not a valid integer (type=type_error.integer)

Answer 3

我创建了一个很小的Python库： https://github.com/tamuhey/tamuhey/tamuhey/dataclass_utils

为此， 可以将库应用于保存另一个数据级别（嵌套数据类）和嵌套容器类型的数据类（例如 tuple [list [dict ... ）

Answer 4

对于键入别名，您必须单独检查注释。
我确实喜欢这样：
https://github.com/evgeniyburdin/validin/validated_dc