主页 / 问题 / 1355548
Accepted
evYpe
Asked:2022-04-30 14:58:41 +0000 UTC2022-04-30 14:58:41 +0000 UTC

如何根据字段之一的值进行不同的验证

  • 772

问题如下：

我们有具有以下结构的 JSON：

{
    key1: [
        {
         type_x: str,
         atr1: str,
         atr2: int
        },
        {
         type_x: str,
         atr1: str
        },
        {
         type_x: str,
         atr1: str,
         atr2: int,
         atr3: int
        },
    ],
    key2: [
        {
         atr1: str,
         atr2: int
        }
    ]
}

我需要创建一个用于验证的模型，但是对于键 key1 的字典列表的不同元素，我需要根据 type_x 键的值应用不同的验证。如您所见，列表元素中的参数数量不同，比方说，所需的参数取决于 type_x 参数的值。例如，如果值为type_x = 'base'，则其模型为：

class MyBase(BaseClass):
    type_x: str
    atr1: str
    atr2: int

如果值type_x = 'root'：

class MyRoot(BaseClass):
    type_x: str
    atr1: str
    atr3: int

我想出了如何为 key1 列表的每个元素编写相同的验证：

class MyClass(BaseClass):
    type_x: str
    atr1: str
    atr2: int

但是如何根据type_x的值做出不同的必填参数呢？当然，理想情况下，这应该在一个通用模型的框架内完成，以免为每个版本的 type_x 值生成单独的模型。谢谢你。

python

2 个回答

  1. 要针对多个字段进行验证，请使用root_validator：

    from pydantic import BaseModel, root_validator


class MyClass(BaseModel):
    type_x: str
    atr1: str
    atr2: int
    
    @root_validator
    def check_depending_on_type_x(cls, values):
        # values - словарь значений атрибутов,
        # значения получаем по строковому имени атрибутов
        type_x = values.get("type_x")
        
        # Тут пишите ваше условие, в зависимости от которого должны выполняться разные проверки
        if type_x == "something":  
            if values.get("atr1") != "qwerty":  # Меняете на нужную проверку
                raise ValueError("Ошибка 1")
        else:
            if values.get("atr2") != 42:  # Меняете на вашу проверку (другую)
                raise ValueError("Ошибка 2")
        
        # Если все хорошо, возвращаем values
        return values

    更新。如果 JSON 中可能不存在某个字段，则“包装”其类型Optional（即字面意思是“可选”），缺失的字段将被初始化为None：

    from pydantic import BaseModel
from typing import Optional


class MyRoot(BaseModel):
    type_x: str
    atr1: Optional[str]
    atr2: Optional[int]
    atr3: Optional[int]


print(repr(
    MyRoot.parse_obj({"type_x": "123", "atr1": "asdf", "atr2": 1})
))

print(repr(
    MyRoot.parse_obj({"type_x": "345", "atr1": "qwer"})
))

print(repr(
    MyRoot.parse_obj({"type_x": "789", "atr1": "qwerty", "atr2": 2, "atr3": 3})
))

    结论：

    MyRoot(type_x='123', atr1='asdf', atr2=1, atr3=None)
MyRoot(type_x='345', atr1='qwer', atr2=None, atr3=None)
MyRoot(type_x='789', atr1='qwerty', atr2=2, atr3=3)

    最重要的是，您已经可以根据type_x答案的第一部分所示的相同方式根据值来加快对正在填写的字段的验证（如果必须填写该字段，请检查它是否为is not None）。

    如果稍后您需要转换为 JSON，并且希望“空”字段不进入 JSON，请使用参数转换为 json exclude_unset=True：

    my_root = MyRoot.parse_obj({"type_x": "123", "atr1": "asdf", "atr2": 1})
print(repr(my_root))  # MyRoot(type_x='123', atr1='asdf', atr2=1, atr3=None)
print(my_root.json())  # {"type_x": "123", "atr1": "asdf", "atr2": 1, "atr3": null}
print(my_root.json(exclude_unset=True))  # {"type_x": "123", "atr1": "asdf", "atr2": 1}
    • 2
  2. Best Answer

    通过单独的类实现，具体类型由其中一个字段的值决定。这在 Pydantic 文档中称为区分联合（又名标记联合） 。

    from pydantic import BaseModel, ValidationError, Field, parse_obj_as
from typing import Literal, Union
from typing_extensions import Annotated


class MyBase(BaseModel):
    type_x: Literal["base"]
    atr1: str
    atr2: int


class MyRoot(BaseModel):
    type_x: Literal["root"]
    atr1: str
    atr3: int


CommonModel = Annotated[Union[MyBase, MyRoot], Field(discriminator='type_x')]


examples = [
    {"type_x": "base", "atr1": "asdf", "atr2": 1},  # Корректная модель base
    {"type_x": "root", "atr1": "asdf", "atr3": 1},  # Корректная модель root
    {"type_x": "foobar"},  # Неизвестный тип
    {"type_x": "base", "atr1": "qwer"},  # Отсутствует одно поле для типа base
    {"type_x": "root"},  # Отсутствуют два поле для типа root
]


for example in examples:
    print(example)
    try:
        print(repr(
            parse_obj_as(CommonModel, example)
        ))
    except ValidationError as ex:
        print(ex)
    print()

    结论：

    {'type_x': 'base', 'atr1': 'asdf', 'atr2': 1}
MyBase(type_x='base', atr1='asdf', atr2=1)

{'type_x': 'root', 'atr1': 'asdf', 'atr3': 1}
MyRoot(type_x='root', atr1='asdf', atr3=1)

{'type_x': 'foobar'}
1 validation error for ParsingModel[typing_extensions.Annotated[Union[__main__.MyBase, __main__.MyRoot], FieldInfo(default=PydanticUndefined, discriminator='type_x', extra={})]]
__root__
  No match for discriminator 'type_x' and value 'foobar' (allowed values: 'base', 'root') (type=value_error.discriminated_union.invalid_discriminator; discriminator_key=type_x; discriminator_value=foobar; allowed_values='base', 'root')

{'type_x': 'base', 'atr1': 'qwer'}
1 validation error for ParsingModel[typing_extensions.Annotated[Union[__main__.MyBase, __main__.MyRoot], FieldInfo(default=PydanticUndefined, discriminator='type_x', extra={})]]
__root__ -> MyBase -> atr2
  field required (type=value_error.missing)

{'type_x': 'root'}
2 validation errors for ParsingModel[typing_extensions.Annotated[Union[__main__.MyBase, __main__.MyRoot], FieldInfo(default=PydanticUndefined, discriminator='type_x', extra={})]]
__root__ -> MyRoot -> atr1
  field required (type=value_error.missing)
__root__ -> MyRoot -> atr3
  field required (type=value_error.missing)
    • 1

相关问题