如何设置pydantic模型的最小大小

huangapple
go评论117阅读模式
英文:

How to set pydantic model minimum size

问题

我有一个以下的Pydantic模型：

  1. class model(BaseModel):
  2.     name: Optional[str] 
  3.     age: Optional[int]
  4.     gender: Optional[str]

并且使用这个模型验证请求体。但是想要将Pydantic模型的最小大小设置为1，以便端点不会处理空输入。

  1. @app.post("my_url")
  2. def test(req: dict=model):
  3.     一些代码

可以在请求体中使用长度函数，但尝试找到一些Pydantic的方法。请帮忙！

英文:

I have a pydantic model below:

  1. class model(BaseModel):
  2.     name: Optional[str] 
  3.     age: Optional[int]
  4.     gender: Optional[str]

and validating the request body using this model. but want to set minimum size of pydantic model to be 1 so endpoint should not process empty input

  1. @app.post("my_url")
  2. def test(req: dict=model):
  3.     some code

can use length function inside body but trying to find some pydantic way.
Please help !

答案1

得分: 3

以下是您要翻译的代码部分：

  1. 最直接的解决方案是一个 [root 验证器][1]，如 M.O. 在上面的评论中提到的：
  3. ```python
  4. from typing import Any, Optional
  6. from pydantic import BaseModel, root_validator
  9. class Model(BaseModel):
  10.     foo: Optional[str]
  11.     bar: Optional[int]
  12.     baz: Optional[float]
  14.     @root_validator
  15.     def ensure_one_field_is_set(cls, data: dict[str, Any]) -> dict[str, Any]:
  16.         if all(value is None for value in data.values()):
  17.             raise ValueError("至少必须提供一个值")
  18.         return data

演示：

  1. from pydantic import ValidationError
  4. print(Model(bar=69).json(indent=4))
  5. try:
  6.     Model()
  7. except ValidationError as err:
  8.     print(err.json(indent=4))

输出：

  1. {
  2.     "foo": null,
  3.     "bar": 69,
  4.     "baz": null
  5. }
  1. [
  2.     {
  3.         "loc": [
  4.             "__root__"
  5.         ],
  6.         "msg": "至少必须提供一个值",
  7.         "type": "value_error"
  8.     }
  9. ]

然而，这种方法存在一个潜在的陷阱。

根验证器按照它们在模型中注册的顺序被调用。这意味着，如果您子类化 Model 并添加一个新的 root 验证器，该验证器将设置一个字段为非-None 值，那么之前的根验证器仍然会首先被调用，新的验证器在介入之前将引发错误：

  1. class SubModel(Model):
  2.     @root_validator
  3.     def set_baz_if_all_are_none(cls, data: dict[str, Any]) -> dict[str, Any]:
  4.         if all(value is None for value in data.values()):
  5.             data["baz"] = 3.14
  6.         return data
  8. SubModel()  # 将引发错误，`baz` 不会被设置

当然，这是一个假设的示例，但仍然值得注意。您可以通过明确 覆盖 先前的验证器方法来解决此问题：

  1. class SubModel(Model):
  2.     @root_validator
  3.     def set_baz_if_all_are_none(cls, data: dict[str, Any]) -> dict[str, Any]:
  4.         if all(value is None for value in data.values()):
  5.             data["baz"] = 3.14
  6.         return data
  8.     @root_validator
  9.     def ensure_one_field_is_set(cls, data: dict[str, Any]) -> dict[str, Any]:
  10.         return data  # 什么也不做
  13. print(SubModel())  # foo=None bar=None baz=3.14

另一种方法是在自己的 __init__ 方法中执行检查并手动构建一个 ValidationError：

  1. from typing import Any, Optional
  3. from pydantic import BaseModel, ValidationError
  4. from pydantic.error_wrappers import ErrorWrapper
  7. class Model(BaseModel):
  8.     foo: Optional[str]
  9.     bar: Optional[int]
  10.     baz: Optional[float]
  12.     def __init__(self, **kwargs: Any) -> None:
  13.         super().__init__(**kwargs)
  14.         if all(value is None for _field, value in self):
  15.             raise ValidationError(
  16.                 [
  17.                     ErrorWrapper(
  18.                         ValueError("至少必须提供一个值"),
  19.                         "__root__",
  20.                     )
  21.                 ],
  22.                 self.__class__,
  23.             )

现在，使用 Model() 将产生与上面根验证器相同的错误。

  2. <details>
  3. <summary>英文:</summary>
  5. The most straightforward solution is a [root validator][1] as mentionend by M.O. in the comments above:
  7. ```python
  8. from typing import Any, Optional
  10. from pydantic import BaseModel, root_validator
  13. class Model(BaseModel):
  14.     foo: Optional[str]
  15.     bar: Optional[int]
  16.     baz: Optional[float]
  18.     @root_validator
  19.     def ensure_one_field_is_set(cls, data: dict[str, Any]) -&gt; dict[str, Any]:
  20.         if all(value is None for value in data.values()):
  21.             raise ValueError(&quot;At least one value must be provided&quot;)
  22.         return data

Demo:

  1. from pydantic import ValidationError
  4. print(Model(bar=69).json(indent=4))
  5. try:
  6.     Model()
  7. except ValidationError as err:
  8.     print(err.json(indent=4))

Output:

  1. {
  2.     &quot;foo&quot;: null,
  3.     &quot;bar&quot;: 69,
  4.     &quot;baz&quot;: null
  5. }
  1. [
  2.     {
  3.         &quot;loc&quot;: [
  4.             &quot;__root__&quot;
  5.         ],
  6.         &quot;msg&quot;: &quot;At least one value must be provided&quot;,
  7.         &quot;type&quot;: &quot;value_error&quot;
  8.     }
  9. ]

However there is one potential pitfall with this approach.

Root validators are called in the order they were registered with model. This means, if you subclass Model and add a new root validator that sets one of the fields to not-None, the previous root validator will still be called first and it will raise an error before the new validator gets a chance to intervene:

  1. class SubModel(Model):
  2.     @root_validator
  3.     def set_baz_if_all_are_none(cls, data: dict[str, Any]) -&gt; dict[str, Any]:
  4.         if all(value is None for value in data.values()):
  5.             data[&quot;baz&quot;] = 3.14
  6.         return data
  8. SubModel()  # will cause an error, `baz` will not be set

Granted, this is a contrived example, but still something to keep in mind. You can work around this by explicitly overriding the previous validator method:

  1. class SubModel(Model):
  2.     @root_validator
  3.     def set_baz_if_all_are_none(cls, data: dict[str, Any]) -&gt; dict[str, Any]:
  4.         if all(value is None for value in data.values()):
  5.             data[&quot;baz&quot;] = 3.14
  6.         return data
  8.     @root_validator
  9.     def ensure_one_field_is_set(cls, data: dict[str, Any]) -&gt; dict[str, Any]:
  10.         return data  # do nothing
  13. print(SubModel())  # foo=None bar=None baz=3.14

An alternative would be to simply do the check in your own __init__ method and manually construct a ValidationError:

  1. from typing import Any, Optional
  3. from pydantic import BaseModel, ValidationError
  4. from pydantic.error_wrappers import ErrorWrapper
  7. class Model(BaseModel):
  8.     foo: Optional[str]
  9.     bar: Optional[int]
  10.     baz: Optional[float]
  12.     def __init__(self, **kwargs: Any) -&gt; None:
  13.         super().__init__(**kwargs)
  14.         if all(value is None for _field, value in self):
  15.             raise ValidationError(
  16.                 [
  17.                     ErrorWrapper(
  18.                         ValueError(&quot;At least one value must be provided&quot;),
  19.                         &quot;__root__&quot;,
  20.                     )
  21.                 ],
  22.                 self.__class__,
  23.             )

Doing Model() would now produce the same error as with the root validator above.

huangapple
  • 本文由 发表于 2023年5月17日 18:10:23
  • 转载请务必保留本文链接：https://go.coder-hub.com/76270941.html
  • fastapi
  • pydantic
  • python
匿名

发表评论

匿名网友

:?: :razz: :sad: :evil: :!: :smile: :oops: :grin: :eek: :shock: :???: :cool: :lol: :mad: :twisted: :roll: :wink: :idea: :arrow: :neutral: :cry: :mrgreen:

确定