>¶

Pydantic は、Python 標準ライブラリの多くの一般的な型をサポートしています。より厳密な処理が必要な場合は、許可される値を制限する必要があるかどうか (正のint要求するなど) を含め、「厳密な型」を参照してください。

ブール値¶

標準のboolフィールドでは、値が次のいずれでもない場合にValidationErrorが発生します。

有効なブール値 (つまり、 TrueまたはFalse )、
整数0または1 、
小文字に変換すると次のいずれかになるstr '0', 'off', 'f', 'false', 'n', 'no', '1', 'on', 't', 'true', 'y', 'yes'
strにデコードされたときに前のルールに従って有効なbytes

!!! note より厳密なブールロジック (たとえば、 TrueとFalseのみを許可するフィールド) が必要な場合は、 StrictBool使用できます。

これらの動作の一部を示すスクリプトを次に示します。

from pydantic import BaseModel, ValidationError


class BooleanModel(BaseModel):
    bool_value: bool


print(BooleanModel(bool_value=False))
#> bool_value=False
print(BooleanModel(bool_value='False'))
#> bool_value=False
print(BooleanModel(bool_value=1))
#> bool_value=True
try:
    BooleanModel(bool_value=[])
except ValidationError as e:
    print(str(e))
    """
    1 validation error for BooleanModel
    bool_value
      Input should be a valid boolean [type=bool_type, input_value=[], input_type=list]
    """

日時型¶

Pydantic は次の日時型をサポートしています。

`datetime.datetime`¶

datetimeフィールドは次のタイプの値を受け入れます。
- datetime ;既存のdatetimeオブジェクト
- intまたはfloat ; Unix 時間として想定されます。つまり、1970 年 1 月 1 日以降の秒数 ( >= -2e10および <= 2e10の場合) またはミリ秒 ( < -2e10または > 2e10の場合)
- str ;次の形式が受け入れられます。
  - YYYY-MM-DD[T]HH:MM[:SS[.ffffff]][Z or [±]HH[:]MM]
  - YYYY-MM-DDは、lax モードでは受け入れられますが、strict モードでは受け入れられません
  - 文字列としてのintまたはfloat (Unix 時間と想定)
- datetime.date インスタンスは、lax モードでは受け入れられますが、strict モードでは受け入れられません
from datetime import datetime

from pydantic import BaseModel

class Event(BaseModel): dt: datetime = None

event = Event(dt='2032-04-23T10:20:30.400+02:30')

print(event.model_dump()) """ {'dt': datetime.datetime(2032, 4, 23, 10, 20, 30, 400000, tzinfo=TzInfo(+02:30))} """

`datetime.date`¶

dateフィールドは次のタイプの値を受け入れます。
- date ;既存のdateオブジェクト
- intまたはfloat ;上記のdatetimeについて説明したのと同じように処理されます
- str ;次の形式が受け入れられます。
  - YYYY-MM-DD
  - 文字列としてのintまたはfloat (Unix 時間と想定)
from datetime import date

from pydantic import BaseModel

class Birthday(BaseModel): d: date = None

my_birthday = Birthday(d=1679616000.0)

print(my_birthday.model_dump())

>¶

`datetime.time`¶

timeフィールドは次のタイプの値を受け入れます。
- time ;既存のtimeオブジェクト
- str ;次の形式が受け入れられます。
  - HH:MM[:SS[.ffffff]][Z or [±]HH[:]MM]
from datetime import time

from pydantic import BaseModel

class Meeting(BaseModel): t: time = None

m = Meeting(t=time(4, 8, 16))

print(m.model_dump())

>¶

`datetime.timedelta`¶

timedeltaフィールドは次のタイプの値を受け入れます。
- timedelta ;既存のtimedeltaオブジェクト
- intまたはfloat ;秒とみなされます
- str ;次の形式が受け入れられます。
  - [-][DD]D[,][HH:MM:]SS[.ffffff]
    - 例: '1d,01:02:03.000004'または'1D01:02:03.000004'または'01:02:03'
  - [±]P[DD]DT[HH]H[MM]M[SS]S (タイムデルタのISO 8601形式)
from datetime import timedelta

from pydantic import BaseModel

class Model(BaseModel): td: timedelta = None

m = Model(td='P3DT12H30M5S')

print(m.model_dump())

>¶

数値の種類¶

Pydantic は、Python 標準ライブラリの次の数値型をサポートします。

`int`¶

Pydantic はint(v)使用して型をintに強制します。データ変換中の情報の損失の詳細については、「データ変換」を参照してください。

`float`¶

Pydantic はfloat(v)使用して値を強制的に float に変換します。

`enum.IntEnum`¶

検証: Pydantic は、値が有効なIntEnumインスタンスであることをチェックします。
enum.IntEnumのサブクラスの検証: 値が整数 enum の有効なメンバーであることを確認します。詳細については、「列挙型と選択肢」を参照してください。

`decimal.Decimal`¶

検証: Pydantic は値を文字列に変換しようとし、その文字列をDecimal(v)に渡します。
シリアル化: Pydantic は Decimal 型を文字列としてシリアル化します。必要に応じて、カスタムシリアライザーを使用してこの動作をオーバーライドできます。例えば：

from decimal import Decimal

from typing_extensions import Annotated

from pydantic import BaseModel, PlainSerializer

class Model(BaseModel): x: Decimal y: Annotated[ Decimal, PlainSerializer( lambda x: float(x), return_type=float, when_used='json' ), ]

my_model = Model(x=Decimal('1.1'), y=Decimal('2.1'))

print(my_model.model_dump()) # (1)!

>¶

print(my_model.model_dump(mode='json')) # (2)!

>¶

print(my_model.model_dump_json()) # (3)!

>¶
model_dump を使用すると、 xとy両方がDecimal型のインスタンスのままになります。
model_dump をmode='json'で使用すると、カスタムシリアライザーが適用されているため、 x stringとしてシリアル化され、 y floatとしてシリアル化されます。
model_dump_json を使用すると、カスタムシリアライザーが適用されているため、 x stringとしてシリアル化され、 y floatとしてシリアル化されます。

[`Enum`][列挙型.列挙型]¶

Pydantic は、Python の標準 enum クラスを使用して選択肢を定義します。

enum.Enum値が有効なEnumインスタンスであることを確認します。 enum.Enumのサブクラスは、値が enum の有効なメンバーであることを確認します。

from enum import Enum, IntEnum

from pydantic import BaseModel, ValidationError


class FruitEnum(str, Enum):
    pear = 'pear'
    banana = 'banana'


class ToolEnum(IntEnum):
    spanner = 1
    wrench = 2


class CookingModel(BaseModel):
    fruit: FruitEnum = FruitEnum.pear
    tool: ToolEnum = ToolEnum.spanner


print(CookingModel())
#> fruit=<FruitEnum.pear: 'pear'> tool=<ToolEnum.spanner: 1>
print(CookingModel(tool=2, fruit='banana'))
#> fruit=<FruitEnum.banana: 'banana'> tool=<ToolEnum.wrench: 2>
try:
    CookingModel(fruit='other')
except ValidationError as e:
    print(e)
    """
    1 validation error for CookingModel
    fruit
      Input should be 'pear' or 'banana' [type=enum, input_value='other', input_type=str]
    """

リストとタプル¶

`list`¶

list、tuple、set、frozenset、deque、またはジェネレーターと list へのキャストを許可します。汎用パラメーターが指定されると、リストのすべての項目に適切な検証が適用されます。

`typing.List`¶

上記のlistと同じように処理されます。

from typing import List, Optional

from pydantic import BaseModel


class Model(BaseModel):
    simple_list: Optional[list] = None
    list_of_ints: Optional[List[int]] = None


print(Model(simple_list=['1', '2', '3']).simple_list)
#> ['1', '2', '3']
print(Model(list_of_ints=['1', '2', '3']).list_of_ints)
#> [1, 2, 3]

`tuple`¶

list、tuple、set、frozenset、deque、またはジェネレーターと tuple へのキャストを許可します。汎用パラメータが指定されると、タプルのそれぞれの項目に適切な検証が適用されます。

`typing.Tuple`¶

上記のtupleと同じように処理されます。

from typing import Optional, Tuple

from pydantic import BaseModel


class Model(BaseModel):
    simple_tuple: Optional[tuple] = None
    tuple_of_different_types: Optional[Tuple[int, float, bool]] = None


print(Model(simple_tuple=[1, 2, 3, 4]).simple_tuple)
#> (1, 2, 3, 4)
print(Model(tuple_of_different_types=[3, 2, 1]).tuple_of_different_types)
#> (3, 2.0, True)

`typing.NamedTuple`¶

typing.NamedTuple のサブクラスはtupleに似ていますが、指定されたnamedtupleクラスのインスタンスを作成します。

collections.namedtuple のサブクラスは typing.NamedTuple のサブクラスに似ていますが、フィールドタイプが指定されていないため、すべてのフィールドは Any タイプを持つものとして扱われます。

from typing import NamedTuple

from pydantic import BaseModel, ValidationError


class Point(NamedTuple):
    x: int
    y: int


class Model(BaseModel):
    p: Point


try:
    Model(p=('1.3', '2'))
except ValidationError as e:
    print(e)
    """
    1 validation error for Model
    p.0
      Input should be a valid integer, unable to parse string as an integer [type=int_parsing, input_value='1.3', input_type=str]
    """

デケ¶

`deque`¶

list、tuple、set、frozenset、deque、またはジェネレーターと deque へのキャストを許可します。汎用パラメーターが提供されると、適切な検証がdequeのそれぞれの項目に適用されます。

`typing.Deque`¶

上記のdequeと同じように処理されます。

from typing import Deque, Optional

from pydantic import BaseModel


class Model(BaseModel):
    deque: Optional[Deque[int]] = None


print(Model(deque=[1, 2, 3]).deque)
#> deque([1, 2, 3])

セット¶

`set`¶

list、tuple、set、frozenset、deque、またはジェネレーターと set へのキャストを許可します。汎用パラメーターが指定されると、適切な検証がセットのすべての項目に適用されます。

`typing.Set`¶

上記のsetと同じように処理されます。

from typing import Optional, Set

from pydantic import BaseModel


class Model(BaseModel):
    simple_set: Optional[set] = None
    set_of_ints: Optional[Set[int]] = None


print(Model(simple_set={'1', '2', '3'}).simple_set)
#> {'1', '2', '3'}
print(Model(simple_set=['1', '2', '3']).simple_set)
#> {'1', '2', '3'}
print(Model(set_of_ints=['1', '2', '3']).set_of_ints)
#> {1, 2, 3}

`frozenset`¶

list、tuple、set、frozenset、deque、またはジェネレーターと frozenset へのキャストを許可します。ジェネリックパラメーターが指定されると、適切な検証がフリーズセットのすべての項目に適用されます。

`typing.FrozenSet`¶

上記のfrozensetと同じように処理されます。

from typing import FrozenSet, Optional

from pydantic import BaseModel


class Model(BaseModel):
    simple_frozenset: Optional[frozenset] = None
    frozenset_of_ints: Optional[FrozenSet[int]] = None


m1 = Model(simple_frozenset=['1', '2', '3'])
print(type(m1.simple_frozenset))
#> <class 'frozenset'>
print(sorted(m1.simple_frozenset))
#> ['1', '2', '3']

m2 = Model(frozenset_of_ints=['1', '2', '3'])
print(type(m2.frozenset_of_ints))
#> <class 'frozenset'>
print(sorted(m2.frozenset_of_ints))
#> [1, 2, 3]

その他の反復可能オブジェクト¶

これは、提供された値がSequence ABC の要件を満たす必要があり、コンテナ内の値を積極的に検証することが望ましい場合に使用することを目的としています。コンテナの値に対して検証を実行する必要がある場合、検証によって値が置き換えられる可能性があるため、コンテナのタイプが保持されない可能性があることに注意してください。検証された値は有効な typing.Sequence であることを保証しますが、提供されたものとは異なる型を持つ可能性があります (通常はlistになります)。

`typing.Iterable`¶

これは、提供された値が消費すべきではない反復可能である可能性がある場合に使用することを目的としています。解析と検証の詳細については、以下の無限ジェネレーターを参照してください。 typing.Sequence と同様に、検証された結果が有効な typing.Iterable であることを保証しますが、提供されたものとは異なる型になる可能性があります。特に、 listなどの非ジェネレーター型が指定されている場合でも、typing.Iterable 型のフィールドの検証後の値はジェネレーターになります。

typing.Sequence を使用した簡単な例を次に示します。

from typing import Sequence

from pydantic import BaseModel


class Model(BaseModel):
    sequence_of_ints: Sequence[int] = None


print(Model(sequence_of_ints=[1, 2, 3, 4]).sequence_of_ints)
#> [1, 2, 3, 4]
print(Model(sequence_of_ints=(1, 2, 3, 4)).sequence_of_ints)
#> (1, 2, 3, 4)

無限ジェネレーター¶

検証したいジェネレーターがある場合でも、上記のようにSequence使用できます。その場合、ジェネレーターは使用され、リストとしてモデルに保存され、その値はSequenceの型パラメーター (例: Sequence[int]のint ) に対して検証されます。

ただし、頻繁に使用したく_ない_ジェネレーター (無限ジェネレーターやリモートデータローダーなど) がある場合は、Iterable 型のフィールドを使用できます。

from typing import Iterable

from pydantic import BaseModel


class Model(BaseModel):
    infinite: Iterable[int]


def infinite_ints():
    i = 0
    while True:
        yield i
        i += 1


m = Model(infinite=infinite_ints())
print(m)
"""
infinite=ValidatorIterator(index=0, schema=Some(Int(IntValidator { strict: false })))
"""

for i in m.infinite:
    print(i)
    #> 0
    #> 1
    #> 2
    #> 3
    #> 4
    #> 5
    #> 6
    #> 7
    #> 8
    #> 9
    #> 10
    if i == 10:
        break

!!!警告初期検証中、 Iterableフィールドは、指定された引数が反復可能であるかどうかの単純なチェックのみを実行します。消費されないように、生成された値の検証は積極的に実行されません。

生成された値は積極的に検証されませんが、生成時に検証され、必要に応じて生成時にValidationErrorが発生します。

from typing import Iterable

from pydantic import BaseModel, ValidationError


class Model(BaseModel):
    int_iterator: Iterable[int]


def my_iterator():
    yield 13
    yield '27'
    yield 'a'


m = Model(int_iterator=my_iterator())
print(next(m.int_iterator))
#> 13
print(next(m.int_iterator))
#> 27
try:
    next(m.int_iterator)
except ValidationError as e:
    print(e)
    """
    1 validation error for ValidatorIterator
    2
      Input should be a valid integer, unable to parse string as an integer [type=int_parsing, input_value='a', input_type=str]
    """

マッピングの種類¶

`dict`¶

dict(v)辞書の変換を試みるために使用されます。サブタイプの制約については、以下の typing.Dict を参照してください。

from pydantic import BaseModel, ValidationError


class Model(BaseModel):
    x: dict


m = Model(x={'foo': 1})
print(m.model_dump())
#> {'x': {'foo': 1}}

try:
    Model(x='test')
except ValidationError as e:
    print(e)
    """
    1 validation error for Model
    x
      Input should be a valid dictionary [type=dict_type, input_value='test', input_type=str]
    """

`typing.Dict`¶

from typing import Dict

from pydantic import BaseModel, ValidationError


class Model(BaseModel):
    x: Dict[str, int]


m = Model(x={'foo': 1})
print(m.model_dump())
#> {'x': {'foo': 1}}

try:
    Model(x={'foo': '1'})
except ValidationError as e:
    print(e)
    """
    1 validation error for Model
    x
      Input should be a valid dictionary [type=dict_type, input_value='test', input_type=str]
    """

型付き辞書¶

!!! note 注これは、Python 3.8 の Python 標準ライブラリの新機能です。 3.12 より前の typing.TypedDict には制限があるため、Python <3.12 には入力拡張機能パッケージが必要です。 TypedDict typing代わりに、 typing_extensionsからインポートする必要があり、そうしないとビルド時にエラーが発生します。

TypedDict は、すべてのインスタンスが特定のキーのセットを持つことを期待する辞書型を宣言します。各キーは一貫した型の値に関連付けられます。

dict と同じですが、キーに注釈が付けられているため、Pydantic は辞書を検証します。

from typing_extensions import TypedDict

from pydantic import TypeAdapter, ValidationError


class User(TypedDict):
    name: str
    id: int


ta = TypeAdapter(User)

print(ta.validate_python({'name': 'foo', 'id': 1}))
#> {'name': 'foo', 'id': 1}

try:
    ta.validate_python({'name': 'foo'})
except ValidationError as e:
    print(e)
    """
    1 validation error for typed-dict
    id
      Field required [type=missing, input_value={'name': 'foo'}, input_type=dict]
    """

__pydantic_config__を定義して、TypedDict から継承したモデルを変更できます。詳細については、ConfigDict API リファレンスを参照してください。

from typing import Optional

from typing_extensions import TypedDict

from pydantic import ConfigDict, TypeAdapter, ValidationError


# `total=False` means keys are non-required
class UserIdentity(TypedDict, total=False):
    name: Optional[str]
    surname: str


class User(TypedDict):
    __pydantic_config__ = ConfigDict(extra='forbid')

    identity: UserIdentity
    age: int


ta = TypeAdapter(User)

print(
    ta.validate_python(
        {'identity': {'name': 'Smith', 'surname': 'John'}, 'age': 37}
    )
)
#> {'identity': {'name': 'Smith', 'surname': 'John'}, 'age': 37}

print(
    ta.validate_python(
        {'identity': {'name': None, 'surname': 'John'}, 'age': 37}
    )
)
#> {'identity': {'name': None, 'surname': 'John'}, 'age': 37}

print(ta.validate_python({'identity': {}, 'age': 37}))
#> {'identity': {}, 'age': 37}


try:
    ta.validate_python(
        {'identity': {'name': ['Smith'], 'surname': 'John'}, 'age': 24}
    )
except ValidationError as e:
    print(e)
    """
    1 validation error for typed-dict
    identity.name
      Input should be a valid string [type=string_type, input_value=['Smith'], input_type=list]
    """

try:
    ta.validate_python(
        {
            'identity': {'name': 'Smith', 'surname': 'John'},
            'age': '37',
            'email': 'john.smith@me.com',
        }
    )
except ValidationError as e:
    print(e)
    """
    1 validation error for typed-dict
    email
      Extra inputs are not permitted [type=extra_forbidden, input_value='john.smith@me.com', input_type=str]
    """

呼び出し可能¶

解析と検証の詳細については、以下を参照してください。

フィールドは Callable 型にすることもできます。

from typing import Callable

from pydantic import BaseModel


class Foo(BaseModel):
    callback: Callable[[int], int]


m = Foo(callback=lambda x: x)
print(m)
#> callback=<function <lambda> at 0x0123456789ab>

!!!警告呼び出し可能なフィールドは、引数が呼び出し可能であるかどうかの単純なチェックのみを実行します。引数、その型、戻り値の型の検証は実行されません。

IPアドレスの種類¶

ipaddress.IPv4Address: 値をIPv4Address(v)に渡すことで、型自体を検証に使用します。
ipaddress.IPv4Interface: 値をIPv4Address(v)に渡すことで、型自体を検証に使用します。
ipaddress.IPv4Network: 値をIPv4Network(v)に渡すことで、型自体を検証に使用します。
ipaddress.IPv6Address: 値をIPv6Address(v)に渡すことで、型自体を検証に使用します。
ipaddress.IPv6Interface: 値をIPv6Interface(v)に渡すことで、型自体を検証に使用します。
ipaddress.IPv6Network: 値をIPv6Network(v)に渡すことで、型自体を検証に使用します。

他のカスタム IP アドレスタイプについては、「ネットワークタイプ」を参照してください。

UUID¶

UUID の場合、Pydantic は値をUUID(v)に渡すことで、型自体を検証に使用しようとします。 bytesとbytearrayにはUUID(bytes=v)へのフォールバックがあります。

UUID バージョンを制限したい場合は、次のタイプを確認できます。

UUID1: UUID バージョン 1 が必要です。
UUID3: UUID バージョン 3 が必要です。
UUID4: UUID バージョン 4 が必要です。
UUID5: UUID バージョン 5 が必要です。

連合¶

Pydantic は共用体検証を広範にサポートしており、typing.Union と Python 3.10 のパイプ構文 ( A | B ) の両方がサポートされています。詳細については、概念ドキュメントのUnionsセクションを参照してください。

`Type` および `TypeVar`¶

`type`¶

Pydantic は、フィールドがTのサブクラスであるクラス (インスタンスではない) のみを受け入れることを指定するtype[T]の使用をサポートしています。

`typing.Type`¶

上記のtypeと同じように処理されます。

from typing import Type

from pydantic import BaseModel, ValidationError


class Foo:
    pass


class Bar(Foo):
    pass


class Other:
    pass


class SimpleModel(BaseModel):
    just_subclasses: Type[Foo]


SimpleModel(just_subclasses=Foo)
SimpleModel(just_subclasses=Bar)
try:
    SimpleModel(just_subclasses=Other)
except ValidationError as e:
    print(e)
    """
    1 validation error for SimpleModel
    just_subclasses
      Input should be a subclass of Foo [type=is_subclass_of, input_value=<class '__main__.Other'>, input_type=type]
    """

Type使用して、任意のクラスが許可されることを指定することもできます。

from typing import Type

from pydantic import BaseModel, ValidationError


class Foo:
    pass


class LenientSimpleModel(BaseModel):
    any_class_goes: Type


LenientSimpleModel(any_class_goes=int)
LenientSimpleModel(any_class_goes=Foo)
try:
    LenientSimpleModel(any_class_goes=Foo())
except ValidationError as e:
    print(e)
    """
    1 validation error for LenientSimpleModel
    any_class_goes
      Input should be a type [type=is_type, input_value=<__main__.Foo object at 0x0123456789ab>, input_type=Foo]
    """

`typing.TypeVar`¶

TypeVar は、制約なし、制約あり、または境界ありのいずれかでサポートされます。

from typing import TypeVar

from pydantic import BaseModel

Foobar = TypeVar('Foobar')
BoundFloat = TypeVar('BoundFloat', bound=float)
IntStr = TypeVar('IntStr', int, str)


class Model(BaseModel):
    a: Foobar  # equivalent of ": Any"
    b: BoundFloat  # equivalent of ": float"
    c: IntStr  # equivalent of ": Union[int, str]"


print(Model(a=[1], b=4.2, c='x'))
#> a=[1] b=4.2 c='x'

# a may be None
print(Model(a=None, b=1, c=1))
#> a=None b=1.0 c=1

なしタイプ¶

None、 type(None) 、またはLiteral[None]型付け仕様に従ってすべて同等です。 None値のみを許可します。

文字列¶

str : 文字列はそのまま受け入れられます。 bytesとbytearray v.decode()を使用して変換されます。 str s inheriting from Enum は v.value` are converted using 。他のすべてのタイプではエラーが発生します。

!!!警告「文字列はシーケンスではありません」

While instances of `str` are technically valid instances of the `Sequence[str]` protocol from a type-checker's point of
view, this is frequently not intended as is a common source of bugs.

As a result, Pydantic raises a `ValidationError` if you attempt to pass a `str` or `bytes` instance into a field of type
`Sequence[str]` or `Sequence[bytes]`:


from typing import Optional, Sequence

from pydantic import BaseModel, ValidationError


class Model(BaseModel):
    sequence_of_strs: Optional[Sequence[str]] = None
    sequence_of_bytes: Optional[Sequence[bytes]] = None


print(Model(sequence_of_strs=['a', 'bc']).sequence_of_strs)
#> ['a', 'bc']
print(Model(sequence_of_strs=('a', 'bc')).sequence_of_strs)
#> ('a', 'bc')
print(Model(sequence_of_bytes=[b'a', b'bc']).sequence_of_bytes)
#> [b'a', b'bc']
print(Model(sequence_of_bytes=(b'a', b'bc')).sequence_of_bytes)
#> (b'a', b'bc')


try:
    Model(sequence_of_strs='abc')
except ValidationError as e:
    print(e)
    """
    1 validation error for Model
    sequence_of_strs
      'str' instances are not allowed as a Sequence value [type=sequence_str, input_value='abc', input_type=str]
    """
try:
    Model(sequence_of_bytes=b'abc')
except ValidationError as e:
    print(e)
    """
    1 validation error for Model
    sequence_of_bytes
      'bytes' instances are not allowed as a Sequence value [type=sequence_str, input_value=b'abc', input_type=bytes]
    """

バイト¶

bytes はそのまま受け入れられます。 bytearray はbytes(v)を使用して変換されます。 str v.encode()を使用して変換されます。 int 、 float 、およびDecimal 、 str(v).encode()を使用して強制されます。詳細については、バイトサイズを参照してください。

`typing.Literal`¶

Pydantic は、フィールドが特定のリテラル値のみを受け入れることを指定する軽量の方法として typing.Literal の使用をサポートしています。

from typing import Literal

from pydantic import BaseModel, ValidationError


class Pie(BaseModel):
    flavor: Literal['apple', 'pumpkin']


Pie(flavor='apple')
Pie(flavor='pumpkin')
try:
    Pie(flavor='cherry')
except ValidationError as e:
    print(str(e))
    """
    1 validation error for Pie
    flavor
      Input should be 'apple' or 'pumpkin' [type=literal_error, input_value='cherry', input_type=str]
    """

このフィールドタイプの利点の 1 つは、カスタムバリデータを宣言することなく、1 つ以上の特定の値との等しいかどうかをチェックするために使用できることです。

from typing import ClassVar, List, Literal, Union

from pydantic import BaseModel, ValidationError


class Cake(BaseModel):
    kind: Literal['cake']
    required_utensils: ClassVar[List[str]] = ['fork', 'knife']


class IceCream(BaseModel):
    kind: Literal['icecream']
    required_utensils: ClassVar[List[str]] = ['spoon']


class Meal(BaseModel):
    dessert: Union[Cake, IceCream]


print(type(Meal(dessert={'kind': 'cake'}).dessert).__name__)
#> Cake
print(type(Meal(dessert={'kind': 'icecream'}).dessert).__name__)
#> IceCream
try:
    Meal(dessert={'kind': 'pie'})
except ValidationError as e:
    print(str(e))
    """
    2 validation errors for Meal
    dessert.Cake.kind
      Input should be 'cake' [type=literal_error, input_value='pie', input_type=str]
    dessert.IceCream.kind
      Input should be 'icecream' [type=literal_error, input_value='pie', input_type=str]
    """

注釈付きUnionで適切な順序付けを行うと、これを使用して、特異性が減少するタイプを解析できます。

from typing import Literal, Optional, Union

from pydantic import BaseModel


class Dessert(BaseModel):
    kind: str


class Pie(Dessert):
    kind: Literal['pie']
    flavor: Optional[str]


class ApplePie(Pie):
    flavor: Literal['apple']


class PumpkinPie(Pie):
    flavor: Literal['pumpkin']


class Meal(BaseModel):
    dessert: Union[ApplePie, PumpkinPie, Pie, Dessert]


print(type(Meal(dessert={'kind': 'pie', 'flavor': 'apple'}).dessert).__name__)
#> ApplePie
print(type(Meal(dessert={'kind': 'pie', 'flavor': 'pumpkin'}).dessert).__name__)
#> PumpkinPie
print(type(Meal(dessert={'kind': 'pie'}).dessert).__name__)
#> Dessert
print(type(Meal(dessert={'kind': 'cake'}).dessert).__name__)
#> Dessert

[`typing.Any` 。任意][`typing.Any` 。任意]¶

Noneを含む任意の値を許可します。