Standard Library Types
description: Support for common types from the Python standard library.¶
Pydanticは、Python標準ライブラリから多くの一般的な型をサポートしています。より厳密な処理が必要な場合は、Strict Typesを参照してください。これには、許可される値を制限する必要がある場合(たとえば、正のint
を要求する場合)も含まれます。
Booleans¶
標準のbool
フィールドは、値が次のいずれでもない場合にValidationError
を発生させます。
- 有効なブール値(すなわち
True
またはFalse
) - 整数
0
または1
- 小文字に変換されたときに、"0"、"off"、"f"、"false"、"n"、"no"、"1"、"on"、"t"、"true"、"y"、"yes"のいずれかになる"str"
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]
"""
Datetime Types¶
Pydanticは次のdatetime型をサポートしています。
datetime.datetime
¶
-
datetime
フィールドは以下の型の値を受け付けます:datetime
; 既存のdatetime
オブジェクトint
またはfloat
; 1970年1月1日からのUnix時間、つまり秒(>=-2e10
および<=2e10
の場合)またはミリ秒(<-2e10
または>2e10
の場合)と見なされます。str
; 以下のフォーマットが使用できます。YYYY-MM-DD[T]HH:MM[:SS[.ffffff]][Z or[±]HH[:]MM]
datetime.date
インスタンスはlaxモードでは受け付けられますが、strictモードでは受け付けられません。- 文字列としての
int
またはfloat
(Unix時間と仮定)
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`; an existing `date` object
* `int` or `float`; handled the same as described for `datetime` above
* `str`; the following formats are accepted:
* `YYYY-MM-DD`
* `int` or `float` as a string (assumed as Unix time)
-->
* `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())
#> {'d': datetime.date(2023, 3, 24)}
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())
#> {'t': datetime.time(4, 8, 16)}
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())
#> {'td': datetime.timedelta(days=3, seconds=45005)}
Number Types¶
Pydanticは、Python標準ライブラリから次の数値型をサポートしています。
int
¶
- Pydanticは型を
int
に強制するためにint(v)
を使用します。
データ変換中の情報損失の詳細については、Data conversionを参照してください。
float
¶
- Pydanticは
float(v)
を使用して値を浮動小数点に変換します。
enum.IntEnum
¶
- バリデーション: Pydanticは、値が有効な
IntEnum
インスタンスであることを確認します。
enum.IntEnum
のサブクラスのバリデーション: 値が整数列挙型の有効なメンバーであることをチェックします;
詳細については、Enums and Choicesを参照してください。
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)!
#> {'x': Decimal('1.1'), 'y': Decimal('2.1')}
print(my_model.model_dump(mode='json')) # (2)!
#> {'x': '1.1', 'y': 2.1}
print(my_model.model_dump_json()) # (3)!
#> {"x":"1.1","y":2.1}
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
のサブクラスは、値が列挙型の有効なメンバーであることをチェックします。
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]
"""
Lists and Tuples¶
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¶
deque
¶
list
、tuple
、set
、frozenset
、deque
、またはジェネレータとdeque
へのキャストを許可します。
一般的なパラメータが与えられると、適切な検証がdeque
の各項目に適用されます。
typing.Deque
¶
Handled the same as deque
above.
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])
Sets¶
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]
Other Iterables¶
typing.Sequence
¶
これは、提供された値がSequence
ABCの要件を満たす必要があり、コンテナ内の値を積極的に検証することが望ましい場合に使用することを意図しています。
コンテナの値に対して検証を実行する必要がある場合、検証によって値が置き換えられる可能性があるため、コンテナのタイプが保持されない可能性があることに注意してください。
検証された値が有効なtyping.Sequence
であることを保証しますが、提供されたものとは異なる型を持つ可能性があります(一般的にはlist
になります)。
typing.Iterable
¶
これは、提供された値が消費されるべきではないiterableである場合に使用することを意図しています。 解析と検証の詳細については、以下のInfinite Generatorsを参照してください。
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)
Infinite Generators¶
検証したいジェネレータがある場合は、上記のようにSequence
を使うことができます。
この場合、ジェネレータが消費されてリストとしてモデルに保存され、その値がSequence
の型パラメータ(例えばint
inSequence[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
Warning
最初の検証では、Iterable
フィールドは与えられた引数が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]
"""
Mapping Types¶
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]
"""
TypedDict¶
Note
3.12より前のtyping.TypedDictの制限により、Python<3.12にはtyping-extensionsパッケージが必要です。typing
の代わりにtyping_extensions
からTypedDict
をインポートする必要があり、インポートしないとビルド時エラーが発生します。
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 referenceを参照してください。
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¶
解析と検証の詳細については、以下を参照してください。
フィールドは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>
Warning
呼び出し可能フィールドは、引数が呼び出し可能であることの単純なチェックのみを実行します。引数、その型、または戻り値の型の検証は実行されません。
IP Address Types¶
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アドレスタイプについては、Network Typesを参照してください。
UUID¶
UUIDの場合、PydanticはUUID(v)
に値を渡すことで、型自体を検証に使用しようとします。
bytes
とbytearray
にはUUID(bytes=v)
へのフォールバックがあります。
UUIDバージョンを制限する場合は、次のタイプをチェックします。
Union¶
Pydanticはユニオン検証を幅広くサポートしており、typing.Union
とPython 3.10のパイプ構文(A B
)の両方がサポートされています。
詳細はconcepts docsのUnions
セクションを読んでください。
Type
and TypeVar
¶
type
¶
Pydanticでは、type[T]
を使用して、フィールドが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 Types¶
None
、type(None)
、またはLiteral[None]
はすべて、the typing specificationに従って等価です。
None
値のみを許可します。
Strings¶
str
:文字列はそのまま受け入れられます。bytes
とbytearray
はv.decode()
を使って変換されます。
str
から継承した列挙型はv.value
を使用して変換されます。他のすべての型はエラーを引き起こします。
Strings aren't Sequences
型チェッカーの観点から見ると、str
のインスタンスは技術的にはSequence[str]
プロトコルの有効なインスタンスですが、これはバグの一般的な原因として意図されていないことがよくあります。
その結果、str
またはbytes
インスタンスをSequence[str]
型またはSequence[bytes]
型のフィールドに渡そうとすると、PydanticはValidationError
を発生させます。
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¶
bytes
はそのまま受け入れられます。bytearray
はbytes(v)
を使って変換されます。str
はv.encode()
を使って変換されます。int
、float
、Decimal
はstr(v).encode()
を使って強制されます。詳細はByteSizeを参照してください。
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
¶
Allows any value, including None
.
typing.Annotated
¶
PEP-593に従って、別の型を任意のメタデータでラップすることを許可します。Annotated
ヒントには、Field
関数への単一の呼び出しを含めることができますが、それ以外の場合は追加のメタデータは無視され、ルート型が使用されます。
typing.Pattern
¶
正規表現パターンを作成するために、入力値がre.compile(v)
に渡されます。
pathlib.Path
¶
値をPath(v)
に渡すことで、型自体を検証に使用します。