pydantic_core.core_schema

该模块包含了用于构建 `pydantic_core` 可验证和序列化的 schema 的定义。

WhenUsed module-attribute

WhenUsed = Literal[
    "always", "unless-none", "json", "json-unless-none"
]

值的含义如下：

• 'always' 意味着总是使用
• 'unless-none' 意味着除非值为 None 才使用
• 'json' 意味着在序列化为 JSON 时使用
• 'json-unless-none' 意味着在序列化为 JSON 且值不为 None 时使用

CoreConfig

基类：TypedDict

schema 配置选项的基类。

属性

名称	类型	描述
title	str	配置的名称。
strict	bool	配置是否应严格遵守指定的规则。
extra_fields_behavior	ExtraBehavior	处理额外字段的行为。
typed_dict_total	bool	TypedDict 是否应被视为 total。默认为 True。
from_attributes	bool	是否为模型、数据类和带标签联合类型的键使用属性。
loc_by_alias	bool	是否使用已使用的别名（或对于“字段必需”错误使用第一个别名）而不是 field_names 来构建错误 locs。默认为 True。
revalidate_instances	Literal['always', 'never', 'subclass-instances']	模型和数据类的实例是否应该重新验证。默认为 'never'。
validate_default	bool	在验证期间是否验证默认值。默认为 False。
str_max_length	int	字符串字段的最大长度。
str_min_length	int	字符串字段的最小长度。
str_strip_whitespace	bool	是否从字符串字段中去除空白字符。
str_to_lower	bool	是否将字符串字段转换为小写。
str_to_upper	bool	是否将字符串字段转换为大写。
allow_inf_nan	bool	是否允许浮点数字段的无穷大和 NaN 值。默认为 True。
ser_json_timedelta	Literal['iso8601', 'float']	timedelta 值的序列化选项。默认为 'iso8601'。注意，如果设置了 ser_json_temporal，此参数将被忽略。
ser_json_temporal	Literal['iso8601', 'seconds', 'milliseconds']	类似 datetime 的值的序列化选项。默认为 'iso8601'。这涵盖的类型是 datetime、date、time 和 timedelta。如果设置了此项，它将优先于 ser_json_timedelta。
ser_json_bytes	Literal['utf8', 'base64', 'hex']	bytes 值的序列化选项。默认为 'utf8'。
ser_json_inf_nan	Literal['null', 'constants', 'strings']	浮点数字段中无穷大和 NaN 值的序列化选项。默认为 'null'。
val_json_bytes	Literal['utf8', 'base64', 'hex']	bytes 值的验证选项，补充 ser_json_bytes。默认为 'utf8'。
hide_input_in_errors	bool	是否在 ValidationError 表示中隐藏输入数据。
validation_error_cause	bool	是否将用户 Python 异常添加到 ValidationError 的 cause 中。在 Python 3.11 之前需要 exceptiongroup 的向后移植版本。
coerce_numbers_to_str	bool	是否启用将任何 Number 类型强制转换为 str（在 strict 模式下不适用）。
regex_engine	Literal['rust-regex', 'python-re']	用于正则表达式模式验证的正则表达式引擎。默认为 'rust-regex'。请参阅 StringSchema。
cache_strings	Union[bool, Literal['all', 'keys', 'none']]	是否缓存字符串。默认为 True，True 或 'all' 需要在常规验证期间缓存字符串，因为验证器不知道它们是在键还是值中。
validate_by_alias	bool	在根据提供的输入数据进行验证时，是否使用字段的别名。默认为 True。
validate_by_name	bool	在根据提供的输入数据进行验证时，是否使用字段的名称。默认为 False。替代 populate_by_name。
serialize_by_alias	bool	是否按别名序列化。默认为 False，预计在 V3 中会更改为 True。
url_preserve_empty_path	bool	在为 URL 类型验证值时，是否保留空的 URL 路径。默认为 False。

SerializationInfo

基类：Protocol[ContextT]

在序列化期间使用的额外数据。

include property

include: IncExCall

序列化期间设置的 include 参数。

exclude property

exclude: IncExCall

序列化期间设置的 exclude 参数。

context property

context: ContextT

当前的序列化上下文。

mode property

mode: Literal['python', 'json'] | str

序列化期间设置的序列化模式。

by_alias property

by_alias: bool

序列化期间设置的 by_alias 参数。

exclude_unset property

exclude_unset: bool

序列化期间设置的 exclude_unset 参数。

exclude_defaults property

exclude_defaults: bool

序列化期间设置的 exclude_defaults 参数。

exclude_none property

exclude_none: bool

序列化期间设置的 exclude_none 参数。

exclude_computed_fields property

exclude_computed_fields: bool

序列化期间设置的 exclude_computed_fields 参数。

serialize_as_any property

serialize_as_any: bool

序列化期间设置的 serialize_as_any 参数。

round_trip property

round_trip: bool

序列化期间设置的 round_trip 参数。

FieldSerializationInfo

基类：SerializationInfo[ContextT], Protocol

在字段序列化期间使用的额外数据。

field_name property

field_name: str

当前正在序列化的字段的名称。

ValidationInfo

基类：Protocol[ContextT]

在验证期间使用的额外数据。

context property

context: ContextT

当前的验证上下文。

config property

config: CoreConfig | None

适用于此验证的 CoreConfig。

mode property

mode: Literal['python', 'json']

我们当前正在验证的输入数据的类型。

data property

data: dict[str, Any]

正在为此模型验证的数据。

field_name property

field_name: str | None

如果此验证器附加到模型字段，则为当前正在验证的字段的名称。

simple_ser_schema

simple_ser_schema(
    type: ExpectedSerializationTypes,
) -> SimpleSerSchema

返回一个用于自定义类型序列化的 schema。

参数

名称	类型	描述	默认值
type	ExpectedSerializationTypes	用于序列化的类型	必需

源代码位于 pydantic_core/core_schema.py

def simple_ser_schema(type: ExpectedSerializationTypes) -> SimpleSerSchema:
    """
    Returns a schema for serialization with a custom type.

    Args:
        type: The type to use for serialization
    """
    return SimpleSerSchema(type=type)

plain_serializer_function_ser_schema

plain_serializer_function_ser_schema(
    function: SerializerFunction,
    *,
    is_field_serializer: bool | None = None,
    info_arg: bool | None = None,
    return_schema: CoreSchema | None = None,
    when_used: WhenUsed = "always"
) -> PlainSerializerFunctionSerSchema

返回一个使用函数进行序列化的 schema，可以是“通用”函数或“字段”函数。

参数

名称	类型	描述	默认值
function	SerializerFunction	用于序列化的函数	必需
is_field_serializer	bool | None	序列化器是否用于字段，例如，第一个参数接受 model，并且 info 包含 field_name	None
info_arg	bool | None	函数是否接受 info 参数	None
return_schema	CoreSchema | None	用于序列化返回值的 schema	None
when_used	WhenUsed	何时应该调用该函数	'always'

源代码位于 pydantic_core/core_schema.py

def plain_serializer_function_ser_schema(
    function: SerializerFunction,
    *,
    is_field_serializer: bool | None = None,
    info_arg: bool | None = None,
    return_schema: CoreSchema | None = None,
    when_used: WhenUsed = 'always',
) -> PlainSerializerFunctionSerSchema:
    """
    Returns a schema for serialization with a function, can be either a "general" or "field" function.

    Args:
        function: The function to use for serialization
        is_field_serializer: Whether the serializer is for a field, e.g. takes `model` as the first argument,
            and `info` includes `field_name`
        info_arg: Whether the function takes an `info` argument
        return_schema: Schema to use for serializing return value
        when_used: When the function should be called
    """
    if when_used == 'always':
        # just to avoid extra elements in schema, and to use the actual default defined in rust
        when_used = None  # type: ignore
    return _dict_not_none(
        type='function-plain',
        function=function,
        is_field_serializer=is_field_serializer,
        info_arg=info_arg,
        return_schema=return_schema,
        when_used=when_used,
    )

wrap_serializer_function_ser_schema

wrap_serializer_function_ser_schema(
    function: WrapSerializerFunction,
    *,
    is_field_serializer: bool | None = None,
    info_arg: bool | None = None,
    schema: CoreSchema | None = None,
    return_schema: CoreSchema | None = None,
    when_used: WhenUsed = "always"
) -> WrapSerializerFunctionSerSchema

返回一个使用包装函数进行序列化的 schema，可以是“通用”函数或“字段”函数。

参数

名称	类型	描述	默认值
function	WrapSerializerFunction	用于序列化的函数	必需
is_field_serializer	bool | None	序列化器是否用于字段，例如，第一个参数接受 model，并且 info 包含 field_name	None
info_arg	bool | None	函数是否接受 info 参数	None
schema	CoreSchema | None	用于内部序列化的 schema	None
return_schema	CoreSchema | None	用于序列化返回值的 schema	None
when_used	WhenUsed	何时应该调用该函数	'always'

源代码位于 pydantic_core/core_schema.py

def wrap_serializer_function_ser_schema(
    function: WrapSerializerFunction,
    *,
    is_field_serializer: bool | None = None,
    info_arg: bool | None = None,
    schema: CoreSchema | None = None,
    return_schema: CoreSchema | None = None,
    when_used: WhenUsed = 'always',
) -> WrapSerializerFunctionSerSchema:
    """
    Returns a schema for serialization with a wrap function, can be either a "general" or "field" function.

    Args:
        function: The function to use for serialization
        is_field_serializer: Whether the serializer is for a field, e.g. takes `model` as the first argument,
            and `info` includes `field_name`
        info_arg: Whether the function takes an `info` argument
        schema: The schema to use for the inner serialization
        return_schema: Schema to use for serializing return value
        when_used: When the function should be called
    """
    if when_used == 'always':
        # just to avoid extra elements in schema, and to use the actual default defined in rust
        when_used = None  # type: ignore
    return _dict_not_none(
        type='function-wrap',
        function=function,
        is_field_serializer=is_field_serializer,
        info_arg=info_arg,
        schema=schema,
        return_schema=return_schema,
        when_used=when_used,
    )

format_ser_schema

format_ser_schema(
    formatting_string: str,
    *,
    when_used: WhenUsed = "json-unless-none"
) -> FormatSerSchema

返回一个使用 Python 的 format 方法进行序列化的 schema。

参数

名称	类型	描述	默认值
formatting_string	str	定义要使用的格式的字符串	必需
when_used	WhenUsed	与 [general_function_plain_ser_schema] 含义相同，但默认值不同	'json-unless-none'

源代码位于 pydantic_core/core_schema.py

def format_ser_schema(formatting_string: str, *, when_used: WhenUsed = 'json-unless-none') -> FormatSerSchema:
    """
    Returns a schema for serialization using python's `format` method.

    Args:
        formatting_string: String defining the format to use
        when_used: Same meaning as for [general_function_plain_ser_schema], but with a different default
    """
    if when_used == 'json-unless-none':
        # just to avoid extra elements in schema, and to use the actual default defined in rust
        when_used = None  # type: ignore
    return _dict_not_none(type='format', formatting_string=formatting_string, when_used=when_used)

to_string_ser_schema

to_string_ser_schema(
    *, when_used: WhenUsed = "json-unless-none"
) -> ToStringSerSchema

返回一个使用 Python 的 str() / __str__ 方法进行序列化的 schema。

参数

名称	类型	描述	默认值
when_used	WhenUsed	与 [general_function_plain_ser_schema] 含义相同，但默认值不同	'json-unless-none'

源代码位于 pydantic_core/core_schema.py

def to_string_ser_schema(*, when_used: WhenUsed = 'json-unless-none') -> ToStringSerSchema:
    """
    Returns a schema for serialization using python's `str()` / `__str__` method.

    Args:
        when_used: Same meaning as for [general_function_plain_ser_schema], but with a different default
    """
    s = dict(type='to-string')
    if when_used != 'json-unless-none':
        # just to avoid extra elements in schema, and to use the actual default defined in rust
        s['when_used'] = when_used
    return s  # type: ignore

model_ser_schema

model_ser_schema(
    cls: type[Any], schema: CoreSchema
) -> ModelSerSchema

返回一个使用模型进行序列化的 schema。

参数

名称	类型	描述	默认值
cls	type[Any]	期望的类类型，用于在传递错误类型时生成警告	必需
schema	CoreSchema	用于序列化模型字典的内部 schema	必需

源代码位于 pydantic_core/core_schema.py

def model_ser_schema(cls: type[Any], schema: CoreSchema) -> ModelSerSchema:
    """
    Returns a schema for serialization using a model.

    Args:
        cls: The expected class type, used to generate warnings if the wrong type is passed
        schema: Internal schema to use to serialize the model dict
    """
    return ModelSerSchema(type='model', cls=cls, schema=schema)

invalid_schema

invalid_schema(
    ref: str | None = None,
    metadata: dict[str, Any] | None = None,
) -> InvalidSchema

返回一个无效的 schema，用于指示一个 schema 是无效的。

Returns a schema that matches any value, e.g.:

参数

名称	类型	描述	默认值
ref	str | None	schema 的可选唯一标识符，用于在其他地方引用该 schema	None
metadata	dict[str, Any] | None	您想包含在 schema 中的任何其他信息，pydantic-core 不使用	None

源代码位于 pydantic_core/core_schema.py

def invalid_schema(ref: str | None = None, metadata: dict[str, Any] | None = None) -> InvalidSchema:
    """
    Returns an invalid schema, used to indicate that a schema is invalid.

        Returns a schema that matches any value, e.g.:

    Args:
        ref: optional unique identifier of the schema, used to reference the schema in other places
        metadata: Any other information you want to include with the schema, not used by pydantic-core
    """

    return _dict_not_none(type='invalid', ref=ref, metadata=metadata)

computed_field

computed_field(
    property_name: str,
    return_schema: CoreSchema,
    *,
    alias: str | None = None,
    metadata: dict[str, Any] | None = None
) -> ComputedField

计算字段是模型或数据类的属性，它们包含在序列化中。

参数

名称	类型	描述	默认值
property_name	str	模型或数据类上的属性名称	必需
return_schema	CoreSchema	用于计算字段返回类型的 schema	必需
alias	str | None	在序列化输出中使用的名称	None
metadata	dict[str, Any] | None	您想包含在 schema 中的任何其他信息，pydantic-core 不使用	None

源代码位于 pydantic_core/core_schema.py

def computed_field(
    property_name: str, return_schema: CoreSchema, *, alias: str | None = None, metadata: dict[str, Any] | None = None
) -> ComputedField:
    """
    ComputedFields are properties of a model or dataclass that are included in serialization.

    Args:
        property_name: The name of the property on the model or dataclass
        return_schema: The schema used for the type returned by the computed field
        alias: The name to use in the serialized output
        metadata: Any other information you want to include with the schema, not used by pydantic-core
    """
    return _dict_not_none(
        type='computed-field', property_name=property_name, return_schema=return_schema, alias=alias, metadata=metadata
    )

any_schema

any_schema(
    *,
    ref: str | None = None,
    metadata: dict[str, Any] | None = None,
    serialization: SerSchema | None = None
) -> AnySchema

返回一个匹配任何值的 schema，例如

from pydantic_core import SchemaValidator, core_schema

schema = core_schema.any_schema()
v = SchemaValidator(schema)
assert v.validate_python(1) == 1

参数

名称	类型	描述	默认值
ref	str | None	schema 的可选唯一标识符，用于在其他地方引用该 schema	None
metadata	dict[str, Any] | None	您想包含在 schema 中的任何其他信息，pydantic-core 不使用	None
serialization	SerSchema | None	自定义序列化 schema	None

源代码位于 pydantic_core/core_schema.py

def any_schema(
    *, ref: str | None = None, metadata: dict[str, Any] | None = None, serialization: SerSchema | None = None
) -> AnySchema:
    """
    Returns a schema that matches any value, e.g.:

    ```py
    from pydantic_core import SchemaValidator, core_schema

    schema = core_schema.any_schema()
    v = SchemaValidator(schema)
    assert v.validate_python(1) == 1
    ```

    Args:
        ref: optional unique identifier of the schema, used to reference the schema in other places
        metadata: Any other information you want to include with the schema, not used by pydantic-core
        serialization: Custom serialization schema
    """
    return _dict_not_none(type='any', ref=ref, metadata=metadata, serialization=serialization)

none_schema

none_schema(
    *,
    ref: str | None = None,
    metadata: dict[str, Any] | None = None,
    serialization: SerSchema | None = None
) -> NoneSchema

返回一个匹配 None 值的 schema，例如

from pydantic_core import SchemaValidator, core_schema

schema = core_schema.none_schema()
v = SchemaValidator(schema)
assert v.validate_python(None) is None

参数

名称	类型	描述	默认值
ref	str | None	schema 的可选唯一标识符，用于在其他地方引用该 schema	None
metadata	dict[str, Any] | None	您想包含在 schema 中的任何其他信息，pydantic-core 不使用	None
serialization	SerSchema | None	自定义序列化 schema	None

源代码位于 pydantic_core/core_schema.py

def none_schema(
    *, ref: str | None = None, metadata: dict[str, Any] | None = None, serialization: SerSchema | None = None
) -> NoneSchema:
    """
    Returns a schema that matches a None value, e.g.:

    ```py
    from pydantic_core import SchemaValidator, core_schema

    schema = core_schema.none_schema()
    v = SchemaValidator(schema)
    assert v.validate_python(None) is None
    ```

    Args:
        ref: optional unique identifier of the schema, used to reference the schema in other places
        metadata: Any other information you want to include with the schema, not used by pydantic-core
        serialization: Custom serialization schema
    """
    return _dict_not_none(type='none', ref=ref, metadata=metadata, serialization=serialization)

bool_schema

bool_schema(
    strict: bool | None = None,
    ref: str | None = None,
    metadata: dict[str, Any] | None = None,
    serialization: SerSchema | None = None,
) -> BoolSchema

返回一个匹配布尔值的 schema，例如

from pydantic_core import SchemaValidator, core_schema

schema = core_schema.bool_schema()
v = SchemaValidator(schema)
assert v.validate_python('True') is True

参数

名称	类型	描述	默认值
strict	bool | None	值应该是布尔值还是可以转换为布尔值的值	None
ref	str | None	schema 的可选唯一标识符，用于在其他地方引用该 schema	None
metadata	dict[str, Any] | None	您想包含在 schema 中的任何其他信息，pydantic-core 不使用	None
serialization	SerSchema | None	自定义序列化 schema	None

源代码位于 pydantic_core/core_schema.py

def bool_schema(
    strict: bool | None = None,
    ref: str | None = None,
    metadata: dict[str, Any] | None = None,
    serialization: SerSchema | None = None,
) -> BoolSchema:
    """
    Returns a schema that matches a bool value, e.g.:

    ```py
    from pydantic_core import SchemaValidator, core_schema

    schema = core_schema.bool_schema()
    v = SchemaValidator(schema)
    assert v.validate_python('True') is True
    ```

    Args:
        strict: Whether the value should be a bool or a value that can be converted to a bool
        ref: optional unique identifier of the schema, used to reference the schema in other places
        metadata: Any other information you want to include with the schema, not used by pydantic-core
        serialization: Custom serialization schema
    """
    return _dict_not_none(type='bool', strict=strict, ref=ref, metadata=metadata, serialization=serialization)

int_schema

int_schema(
    *,
    multiple_of: int | None = None,
    le: int | None = None,
    ge: int | None = None,
    lt: int | None = None,
    gt: int | None = None,
    strict: bool | None = None,
    ref: str | None = None,
    metadata: dict[str, Any] | None = None,
    serialization: SerSchema | None = None
) -> IntSchema

返回一个匹配整数值的 schema，例如

from pydantic_core import SchemaValidator, core_schema

schema = core_schema.int_schema(multiple_of=2, le=6, ge=2)
v = SchemaValidator(schema)
assert v.validate_python('4') == 4

参数

名称	类型	描述	默认值
multiple_of	int | None	该值必须是这个数字的倍数	None
le	int | None	该值必须小于或等于这个数字	None
ge	int | None	该值必须大于或等于这个数字	None
lt	int | None	该值必须严格小于这个数字	None
gt	int | None	该值必须严格大于这个数字	None
strict	bool | None	值应该是整数还是可以转换为整数的值	None
ref	str | None	schema 的可选唯一标识符，用于在其他地方引用该 schema	None
metadata	dict[str, Any] | None	您想包含在 schema 中的任何其他信息，pydantic-core 不使用	None
serialization	SerSchema | None	自定义序列化 schema	None

源代码位于 pydantic_core/core_schema.py

def int_schema(
    *,
    multiple_of: int | None = None,
    le: int | None = None,
    ge: int | None = None,
    lt: int | None = None,
    gt: int | None = None,
    strict: bool | None = None,
    ref: str | None = None,
    metadata: dict[str, Any] | None = None,
    serialization: SerSchema | None = None,
) -> IntSchema:
    """
    Returns a schema that matches a int value, e.g.:

    ```py
    from pydantic_core import SchemaValidator, core_schema

    schema = core_schema.int_schema(multiple_of=2, le=6, ge=2)
    v = SchemaValidator(schema)
    assert v.validate_python('4') == 4
    ```

    Args:
        multiple_of: The value must be a multiple of this number
        le: The value must be less than or equal to this number
        ge: The value must be greater than or equal to this number
        lt: The value must be strictly less than this number
        gt: The value must be strictly greater than this number
        strict: Whether the value should be a int or a value that can be converted to a int
        ref: optional unique identifier of the schema, used to reference the schema in other places
        metadata: Any other information you want to include with the schema, not used by pydantic-core
        serialization: Custom serialization schema
    """
    return _dict_not_none(
        type='int',
        multiple_of=multiple_of,
        le=le,
        ge=ge,
        lt=lt,
        gt=gt,
        strict=strict,
        ref=ref,
        metadata=metadata,
        serialization=serialization,
    )

float_schema

float_schema(
    *,
    allow_inf_nan: bool | None = None,
    multiple_of: float | None = None,
    le: float | None = None,
    ge: float | None = None,
    lt: float | None = None,
    gt: float | None = None,
    strict: bool | None = None,
    ref: str | None = None,
    metadata: dict[str, Any] | None = None,
    serialization: SerSchema | None = None
) -> FloatSchema

返回一个匹配浮点数值的 schema，例如

from pydantic_core import SchemaValidator, core_schema

schema = core_schema.float_schema(le=0.8, ge=0.2)
v = SchemaValidator(schema)
assert v.validate_python('0.5') == 0.5

参数

名称	类型	描述	默认值
allow_inf_nan	bool | None	是否允许 inf 和 nan 值	None
multiple_of	float | None	该值必须是这个数字的倍数	None
le	float | None	该值必须小于或等于这个数字	None
ge	float | None	该值必须大于或等于这个数字	None
lt	float | None	该值必须严格小于这个数字	None
gt	float | None	该值必须严格大于这个数字	None
strict	bool | None	值应该是浮点数还是可以转换为浮点数的值	None
ref	str | None	schema 的可选唯一标识符，用于在其他地方引用该 schema	None
metadata	dict[str, Any] | None	您想包含在 schema 中的任何其他信息，pydantic-core 不使用	None
serialization	SerSchema | None	自定义序列化 schema	None

源代码位于 pydantic_core/core_schema.py

def float_schema(
    *,
    allow_inf_nan: bool | None = None,
    multiple_of: float | None = None,
    le: float | None = None,
    ge: float | None = None,
    lt: float | None = None,
    gt: float | None = None,
    strict: bool | None = None,
    ref: str | None = None,
    metadata: dict[str, Any] | None = None,
    serialization: SerSchema | None = None,
) -> FloatSchema:
    """
    Returns a schema that matches a float value, e.g.:

    ```py
    from pydantic_core import SchemaValidator, core_schema

    schema = core_schema.float_schema(le=0.8, ge=0.2)
    v = SchemaValidator(schema)
    assert v.validate_python('0.5') == 0.5
    ```

    Args:
        allow_inf_nan: Whether to allow inf and nan values
        multiple_of: The value must be a multiple of this number
        le: The value must be less than or equal to this number
        ge: The value must be greater than or equal to this number
        lt: The value must be strictly less than this number
        gt: The value must be strictly greater than this number
        strict: Whether the value should be a float or a value that can be converted to a float
        ref: optional unique identifier of the schema, used to reference the schema in other places
        metadata: Any other information you want to include with the schema, not used by pydantic-core
        serialization: Custom serialization schema
    """
    return _dict_not_none(
        type='float',
        allow_inf_nan=allow_inf_nan,
        multiple_of=multiple_of,
        le=le,
        ge=ge,
        lt=lt,
        gt=gt,
        strict=strict,
        ref=ref,
        metadata=metadata,
        serialization=serialization,
    )

decimal_schema

decimal_schema(
    *,
    allow_inf_nan: bool | None = None,
    multiple_of: Decimal | None = None,
    le: Decimal | None = None,
    ge: Decimal | None = None,
    lt: Decimal | None = None,
    gt: Decimal | None = None,
    max_digits: int | None = None,
    decimal_places: int | None = None,
    strict: bool | None = None,
    ref: str | None = None,
    metadata: dict[str, Any] | None = None,
    serialization: SerSchema | None = None
) -> DecimalSchema

返回一个匹配 decimal 值的 schema，例如

from decimal import Decimal
from pydantic_core import SchemaValidator, core_schema

schema = core_schema.decimal_schema(le=0.8, ge=0.2)
v = SchemaValidator(schema)
assert v.validate_python('0.5') == Decimal('0.5')

参数

名称	类型	描述	默认值
allow_inf_nan	bool | None	是否允许 inf 和 nan 值	None
multiple_of	Decimal | None	该值必须是这个数字的倍数	None
le	Decimal | None	该值必须小于或等于这个数字	None
ge	Decimal | None	该值必须大于或等于这个数字	None
lt	Decimal | None	该值必须严格小于这个数字	None
gt	Decimal | None	该值必须严格大于这个数字	None
max_digits	int | None	允许的最大十进制位数	None
decimal_places	int | None	允许的最大小数位数	None
strict	bool | None	值应该是浮点数还是可以转换为浮点数的值	None
ref	str | None	schema 的可选唯一标识符，用于在其他地方引用该 schema	None
metadata	dict[str, Any] | None	您想包含在 schema 中的任何其他信息，pydantic-core 不使用	None
serialization	SerSchema | None	自定义序列化 schema	None

源代码位于 pydantic_core/core_schema.py

def decimal_schema(
    *,
    allow_inf_nan: bool | None = None,
    multiple_of: Decimal | None = None,
    le: Decimal | None = None,
    ge: Decimal | None = None,
    lt: Decimal | None = None,
    gt: Decimal | None = None,
    max_digits: int | None = None,
    decimal_places: int | None = None,
    strict: bool | None = None,
    ref: str | None = None,
    metadata: dict[str, Any] | None = None,
    serialization: SerSchema | None = None,
) -> DecimalSchema:
    """
    Returns a schema that matches a decimal value, e.g.:

    ```py
    from decimal import Decimal
    from pydantic_core import SchemaValidator, core_schema

    schema = core_schema.decimal_schema(le=0.8, ge=0.2)
    v = SchemaValidator(schema)
    assert v.validate_python('0.5') == Decimal('0.5')
    ```

    Args:
        allow_inf_nan: Whether to allow inf and nan values
        multiple_of: The value must be a multiple of this number
        le: The value must be less than or equal to this number
        ge: The value must be greater than or equal to this number
        lt: The value must be strictly less than this number
        gt: The value must be strictly greater than this number
        max_digits: The maximum number of decimal digits allowed
        decimal_places: The maximum number of decimal places allowed
        strict: Whether the value should be a float or a value that can be converted to a float
        ref: optional unique identifier of the schema, used to reference the schema in other places
        metadata: Any other information you want to include with the schema, not used by pydantic-core
        serialization: Custom serialization schema
    """
    return _dict_not_none(
        type='decimal',
        gt=gt,
        ge=ge,
        lt=lt,
        le=le,
        max_digits=max_digits,
        decimal_places=decimal_places,
        multiple_of=multiple_of,
        allow_inf_nan=allow_inf_nan,
        strict=strict,
        ref=ref,
        metadata=metadata,
        serialization=serialization,
    )

complex_schema

complex_schema(
    *,
    strict: bool | None = None,
    ref: str | None = None,
    metadata: dict[str, Any] | None = None,
    serialization: SerSchema | None = None
) -> ComplexSchema

返回一个匹配复数值的 schema，例如

from pydantic_core import SchemaValidator, core_schema

schema = core_schema.complex_schema()
v = SchemaValidator(schema)
assert v.validate_python('1+2j') == complex(1, 2)
assert v.validate_python(complex(1, 2)) == complex(1, 2)

参数

名称	类型	描述	默认值
strict	bool | None	值应该是复数对象实例还是可以转换为复数对象的值	None
ref	str | None	schema 的可选唯一标识符，用于在其他地方引用该 schema	None
metadata	dict[str, Any] | None	您想包含在 schema 中的任何其他信息，pydantic-core 不使用	None
serialization	SerSchema | None	自定义序列化 schema	None

源代码位于 pydantic_core/core_schema.py

def complex_schema(
    *,
    strict: bool | None = None,
    ref: str | None = None,
    metadata: dict[str, Any] | None = None,
    serialization: SerSchema | None = None,
) -> ComplexSchema:
    """
    Returns a schema that matches a complex value, e.g.:

    ```py
    from pydantic_core import SchemaValidator, core_schema

    schema = core_schema.complex_schema()
    v = SchemaValidator(schema)
    assert v.validate_python('1+2j') == complex(1, 2)
    assert v.validate_python(complex(1, 2)) == complex(1, 2)
    ```

    Args:
        strict: Whether the value should be a complex object instance or a value that can be converted to a complex object
        ref: optional unique identifier of the schema, used to reference the schema in other places
        metadata: Any other information you want to include with the schema, not used by pydantic-core
        serialization: Custom serialization schema
    """
    return _dict_not_none(
        type='complex',
        strict=strict,
        ref=ref,
        metadata=metadata,
        serialization=serialization,
    )

str_schema

str_schema(
    *,
    pattern: str | Pattern[str] | None = None,
    max_length: int | None = None,
    min_length: int | None = None,
    strip_whitespace: bool | None = None,
    to_lower: bool | None = None,
    to_upper: bool | None = None,
    regex_engine: (
        Literal["rust-regex", "python-re"] | None
    ) = None,
    strict: bool | None = None,
    coerce_numbers_to_str: bool | None = None,
    ref: str | None = None,
    metadata: dict[str, Any] | None = None,
    serialization: SerSchema | None = None
) -> StringSchema

返回一个匹配字符串值的 schema，例如

from pydantic_core import SchemaValidator, core_schema

schema = core_schema.str_schema(max_length=10, min_length=2)
v = SchemaValidator(schema)
assert v.validate_python('hello') == 'hello'

参数

名称	类型	描述	默认值
pattern	str | Pattern[str] | None	该值必须匹配的正则表达式模式	None
max_length	int | None	该值的长度最多为这个长度	None
min_length	int | None	该值的长度至少为这个长度	None
strip_whitespace	bool | None	是否从值中去除空白字符	None
to_lower	bool | None	是否将值转换为小写	None
to_upper	bool | None	是否将值转换为大写	None
regex_engine	Literal['rust-regex', 'python-re'] | None	用于模式验证的正则表达式引擎。默认为 'rust-regex'。 - rust-regex 使用 regex Rust crate，它不会回溯，因此更能抵抗 DDoS 攻击，但不支持所有正则表达式功能。 - python-re 使用 re 模块，它支持所有正则表达式功能，但可能较慢。	None
strict	bool | None	值应该是字符串还是可以转换为字符串的值	None
coerce_numbers_to_str	bool | None	是否启用将任何 Number 类型强制转换为 str（在 strict 模式下不适用）。	None
ref	str | None	schema 的可选唯一标识符，用于在其他地方引用该 schema	None
metadata	dict[str, Any] | None	您想包含在 schema 中的任何其他信息，pydantic-core 不使用	None
serialization	SerSchema | None	自定义序列化 schema	None

源代码位于 pydantic_core/core_schema.py

def str_schema(
    *,
    pattern: str | Pattern[str] | None = None,
    max_length: int | None = None,
    min_length: int | None = None,
    strip_whitespace: bool | None = None,
    to_lower: bool | None = None,
    to_upper: bool | None = None,
    regex_engine: Literal['rust-regex', 'python-re'] | None = None,
    strict: bool | None = None,
    coerce_numbers_to_str: bool | None = None,
    ref: str | None = None,
    metadata: dict[str, Any] | None = None,
    serialization: SerSchema | None = None,
) -> StringSchema:
    """
    Returns a schema that matches a string value, e.g.:

    ```py
    from pydantic_core import SchemaValidator, core_schema

    schema = core_schema.str_schema(max_length=10, min_length=2)
    v = SchemaValidator(schema)
    assert v.validate_python('hello') == 'hello'
    ```

    Args:
        pattern: A regex pattern that the value must match
        max_length: The value must be at most this length
        min_length: The value must be at least this length
        strip_whitespace: Whether to strip whitespace from the value
        to_lower: Whether to convert the value to lowercase
        to_upper: Whether to convert the value to uppercase
        regex_engine: The regex engine to use for pattern validation. Default is 'rust-regex'.
            - `rust-regex` uses the [`regex`](https://docs.rs/regex) Rust
              crate, which is non-backtracking and therefore more DDoS
              resistant, but does not support all regex features.
            - `python-re` use the [`re`](https://docs.pythonlang.cn/3/library/re.html) module,
              which supports all regex features, but may be slower.
        strict: Whether the value should be a string or a value that can be converted to a string
        coerce_numbers_to_str: Whether to enable coercion of any `Number` type to `str` (not applicable in `strict` mode).
        ref: optional unique identifier of the schema, used to reference the schema in other places
        metadata: Any other information you want to include with the schema, not used by pydantic-core
        serialization: Custom serialization schema
    """
    return _dict_not_none(
        type='str',
        pattern=pattern,
        max_length=max_length,
        min_length=min_length,
        strip_whitespace=strip_whitespace,
        to_lower=to_lower,
        to_upper=to_upper,
        regex_engine=regex_engine,
        strict=strict,
        coerce_numbers_to_str=coerce_numbers_to_str,
        ref=ref,
        metadata=metadata,
        serialization=serialization,
    )

bytes_schema

bytes_schema(
    *,
    max_length: int | None = None,
    min_length: int | None = None,
    strict: bool | None = None,
    ref: str | None = None,
    metadata: dict[str, Any] | None = None,
    serialization: SerSchema | None = None
) -> BytesSchema

返回一个匹配字节值的 schema，例如

from pydantic_core import SchemaValidator, core_schema

schema = core_schema.bytes_schema(max_length=10, min_length=2)
v = SchemaValidator(schema)
assert v.validate_python(b'hello') == b'hello'

参数

名称	类型	描述	默认值
max_length	int | None	该值的长度最多为这个长度	None
min_length	int | None	该值的长度至少为这个长度	None
strict	bool | None	值应该是字节还是可以转换为字节的值	None
ref	str | None	schema 的可选唯一标识符，用于在其他地方引用该 schema	None
metadata	dict[str, Any] | None	您想包含在 schema 中的任何其他信息，pydantic-core 不使用	None
serialization	SerSchema | None	自定义序列化 schema	None

源代码位于 pydantic_core/core_schema.py

def bytes_schema(
    *,
    max_length: int | None = None,
    min_length: int | None = None,
    strict: bool | None = None,
    ref: str | None = None,
    metadata: dict[str, Any] | None = None,
    serialization: SerSchema | None = None,
) -> BytesSchema:
    """
    Returns a schema that matches a bytes value, e.g.:

    ```py
    from pydantic_core import SchemaValidator, core_schema

    schema = core_schema.bytes_schema(max_length=10, min_length=2)
    v = SchemaValidator(schema)
    assert v.validate_python(b'hello') == b'hello'
    ```

    Args:
        max_length: The value must be at most this length
        min_length: The value must be at least this length
        strict: Whether the value should be a bytes or a value that can be converted to a bytes
        ref: optional unique identifier of the schema, used to reference the schema in other places
        metadata: Any other information you want to include with the schema, not used by pydantic-core
        serialization: Custom serialization schema
    """
    return _dict_not_none(
        type='bytes',
        max_length=max_length,
        min_length=min_length,
        strict=strict,
        ref=ref,
        metadata=metadata,
        serialization=serialization,
    )

date_schema

date_schema(
    *,
    strict: bool | None = None,
    le: date | None = None,
    ge: date | None = None,
    lt: date | None = None,
    gt: date | None = None,
    now_op: Literal["past", "future"] | None = None,
    now_utc_offset: int | None = None,
    ref: str | None = None,
    metadata: dict[str, Any] | None = None,
    serialization: SerSchema | None = None
) -> DateSchema

返回一个匹配日期值的 schema，例如

from datetime import date
from pydantic_core import SchemaValidator, core_schema

schema = core_schema.date_schema(le=date(2020, 1, 1), ge=date(2019, 1, 1))
v = SchemaValidator(schema)
assert v.validate_python(date(2019, 6, 1)) == date(2019, 6, 1)

参数

名称	类型	描述	默认值
strict	bool | None	值应该是日期还是可以转换为日期的值	None
le	date | None	该值必须小于或等于此日期	None
ge	date | None	该值必须大于或等于此日期	None
lt	date | None	该值必须严格小于此日期	None
gt	date | None	该值必须严格大于此日期	None
now_op	Literal['past', 'future'] | None	该值必须相对于当前日期在过去或未来	None
now_utc_offset	int | None	该值必须相对于带有此时区偏移的当前日期在过去或未来	None
ref	str | None	schema 的可选唯一标识符，用于在其他地方引用该 schema	None
metadata	dict[str, Any] | None	您想包含在 schema 中的任何其他信息，pydantic-core 不使用	None
serialization	SerSchema | None	自定义序列化 schema	None

源代码位于 pydantic_core/core_schema.py

def date_schema(
    *,
    strict: bool | None = None,
    le: date | None = None,
    ge: date | None = None,
    lt: date | None = None,
    gt: date | None = None,
    now_op: Literal['past', 'future'] | None = None,
    now_utc_offset: int | None = None,
    ref: str | None = None,
    metadata: dict[str, Any] | None = None,
    serialization: SerSchema | None = None,
) -> DateSchema:
    """
    Returns a schema that matches a date value, e.g.:

    ```py
    from datetime import date
    from pydantic_core import SchemaValidator, core_schema

    schema = core_schema.date_schema(le=date(2020, 1, 1), ge=date(2019, 1, 1))
    v = SchemaValidator(schema)
    assert v.validate_python(date(2019, 6, 1)) == date(2019, 6, 1)
    ```

    Args:
        strict: Whether the value should be a date or a value that can be converted to a date
        le: The value must be less than or equal to this date
        ge: The value must be greater than or equal to this date
        lt: The value must be strictly less than this date
        gt: The value must be strictly greater than this date
        now_op: The value must be in the past or future relative to the current date
        now_utc_offset: The value must be in the past or future relative to the current date with this utc offset
        ref: optional unique identifier of the schema, used to reference the schema in other places
        metadata: Any other information you want to include with the schema, not used by pydantic-core
        serialization: Custom serialization schema
    """
    return _dict_not_none(
        type='date',
        strict=strict,
        le=le,
        ge=ge,
        lt=lt,
        gt=gt,
        now_op=now_op,
        now_utc_offset=now_utc_offset,
        ref=ref,
        metadata=metadata,
        serialization=serialization,
    )

time_schema

time_schema(
    *,
    strict: bool | None = None,
    le: time | None = None,
    ge: time | None = None,
    lt: time | None = None,
    gt: time | None = None,
    tz_constraint: (
        Literal["aware", "naive"] | int | None
    ) = None,
    microseconds_precision: Literal[
        "truncate", "error"
    ] = "truncate",
    ref: str | None = None,
    metadata: dict[str, Any] | None = None,
    serialization: SerSchema | None = None
) -> TimeSchema

返回一个匹配时间值的 schema，例如

from datetime import time
from pydantic_core import SchemaValidator, core_schema

schema = core_schema.time_schema(le=time(12, 0, 0), ge=time(6, 0, 0))
v = SchemaValidator(schema)
assert v.validate_python(time(9, 0, 0)) == time(9, 0, 0)

参数

名称	类型	描述	默认值
strict	bool | None	值应该是时间还是可以转换为时间的值	None
le	time | None	该值必须小于或等于此时间	None
ge	time | None	该值必须大于或等于此时间	None
lt	time | None	该值必须严格小于此时间	None
gt	time | None	该值必须严格大于此时间	None
tz_constraint	Literal['aware', 'naive'] | int | None	该值必须是时区感知或朴素的，或者是一个 int 来指示所需的时区偏移	None
microseconds_precision	Literal['truncate', 'error']	当秒数超过6位或微秒过大时的行为	'truncate'
ref	str | None	schema 的可选唯一标识符，用于在其他地方引用该 schema	None
metadata	dict[str, Any] | None	您想包含在 schema 中的任何其他信息，pydantic-core 不使用	None
serialization	SerSchema | None	自定义序列化 schema	None

源代码位于 pydantic_core/core_schema.py

def time_schema(
    *,
    strict: bool | None = None,
    le: time | None = None,
    ge: time | None = None,
    lt: time | None = None,
    gt: time | None = None,
    tz_constraint: Literal['aware', 'naive'] | int | None = None,
    microseconds_precision: Literal['truncate', 'error'] = 'truncate',
    ref: str | None = None,
    metadata: dict[str, Any] | None = None,
    serialization: SerSchema | None = None,
) -> TimeSchema:
    """
    Returns a schema that matches a time value, e.g.:

    ```py
    from datetime import time
    from pydantic_core import SchemaValidator, core_schema

    schema = core_schema.time_schema(le=time(12, 0, 0), ge=time(6, 0, 0))
    v = SchemaValidator(schema)
    assert v.validate_python(time(9, 0, 0)) == time(9, 0, 0)
    ```

    Args:
        strict: Whether the value should be a time or a value that can be converted to a time
        le: The value must be less than or equal to this time
        ge: The value must be greater than or equal to this time
        lt: The value must be strictly less than this time
        gt: The value must be strictly greater than this time
        tz_constraint: The value must be timezone aware or naive, or an int to indicate required tz offset
        microseconds_precision: The behavior when seconds have more than 6 digits or microseconds is too large
        ref: optional unique identifier of the schema, used to reference the schema in other places
        metadata: Any other information you want to include with the schema, not used by pydantic-core
        serialization: Custom serialization schema
    """
    return _dict_not_none(
        type='time',
        strict=strict,
        le=le,
        ge=ge,
        lt=lt,
        gt=gt,
        tz_constraint=tz_constraint,
        microseconds_precision=microseconds_precision,
        ref=ref,
        metadata=metadata,
        serialization=serialization,
    )

datetime_schema

datetime_schema(
    *,
    strict: bool | None = None,
    le: datetime | None = None,
    ge: datetime | None = None,
    lt: datetime | None = None,
    gt: datetime | None = None,
    now_op: Literal["past", "future"] | None = None,
    tz_constraint: (
        Literal["aware", "naive"] | int | None
    ) = None,
    now_utc_offset: int | None = None,
    microseconds_precision: Literal[
        "truncate", "error"
    ] = "truncate",
    ref: str | None = None,
    metadata: dict[str, Any] | None = None,
    serialization: SerSchema | None = None
) -> DatetimeSchema

返回一个匹配日期时间值的 schema，例如

from datetime import datetime
from pydantic_core import SchemaValidator, core_schema

schema = core_schema.datetime_schema()
v = SchemaValidator(schema)
now = datetime.now()
assert v.validate_python(str(now)) == now

参数

名称	类型	描述	默认值
strict	bool | None	值应该是日期时间还是可以转换为日期时间的值	None
le	datetime | None	该值必须小于或等于此日期时间	None
ge	datetime | None	该值必须大于或等于此日期时间	None
lt	datetime | None	该值必须严格小于此日期时间	None
gt	datetime | None	该值必须严格大于此日期时间	None
now_op	Literal['past', 'future'] | None	该值必须相对于当前日期时间在过去或未来	None
tz_constraint	Literal['aware', 'naive'] | int | None	该值必须是时区感知或朴素的，或者是一个 int 来指示所需的时区偏移。注意：尚不支持使用基于日期时间变化的 tzinfo。	None
now_utc_offset	int | None	该值必须相对于带有此时区偏移的当前日期时间在过去或未来	None
microseconds_precision	Literal['truncate', 'error']	当秒数超过6位或微秒过大时的行为	'truncate'
ref	str | None	schema 的可选唯一标识符，用于在其他地方引用该 schema	None
metadata	dict[str, Any] | None	您想包含在 schema 中的任何其他信息，pydantic-core 不使用	None
serialization	SerSchema | None	自定义序列化 schema	None

源代码位于 pydantic_core/core_schema.py

def datetime_schema(
    *,
    strict: bool | None = None,
    le: datetime | None = None,
    ge: datetime | None = None,
    lt: datetime | None = None,
    gt: datetime | None = None,
    now_op: Literal['past', 'future'] | None = None,
    tz_constraint: Literal['aware', 'naive'] | int | None = None,
    now_utc_offset: int | None = None,
    microseconds_precision: Literal['truncate', 'error'] = 'truncate',
    ref: str | None = None,
    metadata: dict[str, Any] | None = None,
    serialization: SerSchema | None = None,
) -> DatetimeSchema:
    """
    Returns a schema that matches a datetime value, e.g.:

    ```py
    from datetime import datetime
    from pydantic_core import SchemaValidator, core_schema

    schema = core_schema.datetime_schema()
    v = SchemaValidator(schema)
    now = datetime.now()
    assert v.validate_python(str(now)) == now
    ```

    Args:
        strict: Whether the value should be a datetime or a value that can be converted to a datetime
        le: The value must be less than or equal to this datetime
        ge: The value must be greater than or equal to this datetime
        lt: The value must be strictly less than this datetime
        gt: The value must be strictly greater than this datetime
        now_op: The value must be in the past or future relative to the current datetime
        tz_constraint: The value must be timezone aware or naive, or an int to indicate required tz offset
            TODO: use of a tzinfo where offset changes based on the datetime is not yet supported
        now_utc_offset: The value must be in the past or future relative to the current datetime with this utc offset
        microseconds_precision: The behavior when seconds have more than 6 digits or microseconds is too large
        ref: optional unique identifier of the schema, used to reference the schema in other places
        metadata: Any other information you want to include with the schema, not used by pydantic-core
        serialization: Custom serialization schema
    """
    return _dict_not_none(
        type='datetime',
        strict=strict,
        le=le,
        ge=ge,
        lt=lt,
        gt=gt,
        now_op=now_op,
        tz_constraint=tz_constraint,
        now_utc_offset=now_utc_offset,
        microseconds_precision=microseconds_precision,
        ref=ref,
        metadata=metadata,
        serialization=serialization,
    )

timedelta_schema

timedelta_schema(
    *,
    strict: bool | None = None,
    le: timedelta | None = None,
    ge: timedelta | None = None,
    lt: timedelta | None = None,
    gt: timedelta | None = None,
    microseconds_precision: Literal[
        "truncate", "error"
    ] = "truncate",
    ref: str | None = None,
    metadata: dict[str, Any] | None = None,
    serialization: SerSchema | None = None
) -> TimedeltaSchema

返回一个匹配 timedelta 值的 schema，例如

from datetime import timedelta
from pydantic_core import SchemaValidator, core_schema

schema = core_schema.timedelta_schema(le=timedelta(days=1), ge=timedelta(days=0))
v = SchemaValidator(schema)
assert v.validate_python(timedelta(hours=12)) == timedelta(hours=12)

参数

名称	类型	描述	默认值
strict	bool | None	值应该是 timedelta 还是可以转换为 timedelta 的值	None
le	timedelta | None	该值必须小于或等于此 timedelta	None
ge	timedelta | None	该值必须大于或等于此 timedelta	None
lt	timedelta | None	该值必须严格小于此 timedelta	None
gt	timedelta | None	该值必须严格大于此 timedelta	None
microseconds_precision	Literal['truncate', 'error']	当秒数超过6位或微秒过大时的行为	'truncate'
ref	str | None	schema 的可选唯一标识符，用于在其他地方引用该 schema	None
metadata	dict[str, Any] | None	您想包含在 schema 中的任何其他信息，pydantic-core 不使用	None
serialization	SerSchema | None	自定义序列化 schema	None

源代码位于 pydantic_core/core_schema.py

def timedelta_schema(
    *,
    strict: bool | None = None,
    le: timedelta | None = None,
    ge: timedelta | None = None,
    lt: timedelta | None = None,
    gt: timedelta | None = None,
    microseconds_precision: Literal['truncate', 'error'] = 'truncate',
    ref: str | None = None,
    metadata: dict[str, Any] | None = None,
    serialization: SerSchema | None = None,
) -> TimedeltaSchema:
    """
    Returns a schema that matches a timedelta value, e.g.:

    ```py
    from datetime import timedelta
    from pydantic_core import SchemaValidator, core_schema

    schema = core_schema.timedelta_schema(le=timedelta(days=1), ge=timedelta(days=0))
    v = SchemaValidator(schema)
    assert v.validate_python(timedelta(hours=12)) == timedelta(hours=12)
    ```

    Args:
        strict: Whether the value should be a timedelta or a value that can be converted to a timedelta
        le: The value must be less than or equal to this timedelta
        ge: The value must be greater than or equal to this timedelta
        lt: The value must be strictly less than this timedelta
        gt: The value must be strictly greater than this timedelta
        microseconds_precision: The behavior when seconds have more than 6 digits or microseconds is too large
        ref: optional unique identifier of the schema, used to reference the schema in other places
        metadata: Any other information you want to include with the schema, not used by pydantic-core
        serialization: Custom serialization schema
    """
    return _dict_not_none(
        type='timedelta',
        strict=strict,
        le=le,
        ge=ge,
        lt=lt,
        gt=gt,
        microseconds_precision=microseconds_precision,
        ref=ref,
        metadata=metadata,
        serialization=serialization,
    )

literal_schema

literal_schema(
    expected: list[Any],
    *,
    ref: str | None = None,
    metadata: dict[str, Any] | None = None,
    serialization: SerSchema | None = None
) -> LiteralSchema

返回一个匹配字面值的 schema，例如

from pydantic_core import SchemaValidator, core_schema

schema = core_schema.literal_schema(['hello', 'world'])
v = SchemaValidator(schema)
assert v.validate_python('hello') == 'hello'

参数

名称	类型	描述	默认值
expected	list[Any]	该值必须是这些值之一	必需
ref	str | None	schema 的可选唯一标识符，用于在其他地方引用该 schema	None
metadata	dict[str, Any] | None	您想包含在 schema 中的任何其他信息，pydantic-core 不使用	None
serialization	SerSchema | None	自定义序列化 schema	None

源代码位于 pydantic_core/core_schema.py

def literal_schema(
    expected: list[Any],
    *,
    ref: str | None = None,
    metadata: dict[str, Any] | None = None,
    serialization: SerSchema | None = None,
) -> LiteralSchema:
    """
    Returns a schema that matches a literal value, e.g.:

    ```py
    from pydantic_core import SchemaValidator, core_schema

    schema = core_schema.literal_schema(['hello', 'world'])
    v = SchemaValidator(schema)
    assert v.validate_python('hello') == 'hello'
    ```

    Args:
        expected: The value must be one of these values
        ref: optional unique identifier of the schema, used to reference the schema in other places
        metadata: Any other information you want to include with the schema, not used by pydantic-core
        serialization: Custom serialization schema
    """
    return _dict_not_none(type='literal', expected=expected, ref=ref, metadata=metadata, serialization=serialization)

enum_schema

enum_schema(
    cls: Any,
    members: list[Any],
    *,
    sub_type: Literal["str", "int", "float"] | None = None,
    missing: Callable[[Any], Any] | None = None,
    strict: bool | None = None,
    ref: str | None = None,
    metadata: dict[str, Any] | None = None,
    serialization: SerSchema | None = None
) -> EnumSchema

返回一个匹配枚举值的 schema，例如

from enum import Enum
from pydantic_core import SchemaValidator, core_schema

class Color(Enum):
    RED = 1
    GREEN = 2
    BLUE = 3

schema = core_schema.enum_schema(Color, list(Color.__members__.values()))
v = SchemaValidator(schema)
assert v.validate_python(2) is Color.GREEN

参数

名称	类型	描述	默认值
cls	Any	枚举类	必需
members	list[Any]	枚举的成员，通常是 list(MyEnum.__members__.values())	必需
sub_type	Literal['str', 'int', 'float'] | None	枚举的类型，可以是 'str' 或 'int' 或 None（对于普通枚举）	None
missing	Callable[[Any], Any] | None	当值在枚举中找不到时使用的函数，来自 _missing_	None
strict	bool | None	是否使用严格模式，默认为 False	None
ref	str | None	schema 的可选唯一标识符，用于在其他地方引用该 schema	None
metadata	dict[str, Any] | None	您想包含在 schema 中的任何其他信息，pydantic-core 不使用	None
serialization	SerSchema | None	自定义序列化 schema	None

源代码位于 pydantic_core/core_schema.py

def enum_schema(
    cls: Any,
    members: list[Any],
    *,
    sub_type: Literal['str', 'int', 'float'] | None = None,
    missing: Callable[[Any], Any] | None = None,
    strict: bool | None = None,
    ref: str | None = None,
    metadata: dict[str, Any] | None = None,
    serialization: SerSchema | None = None,
) -> EnumSchema:
    """
    Returns a schema that matches an enum value, e.g.:

    ```py
    from enum import Enum
    from pydantic_core import SchemaValidator, core_schema

    class Color(Enum):
        RED = 1
        GREEN = 2
        BLUE = 3

    schema = core_schema.enum_schema(Color, list(Color.__members__.values()))
    v = SchemaValidator(schema)
    assert v.validate_python(2) is Color.GREEN
    ```

    Args:
        cls: The enum class
        members: The members of the enum, generally `list(MyEnum.__members__.values())`
        sub_type: The type of the enum, either 'str' or 'int' or None for plain enums
        missing: A function to use when the value is not found in the enum, from `_missing_`
        strict: Whether to use strict mode, defaults to False
        ref: optional unique identifier of the schema, used to reference the schema in other places
        metadata: Any other information you want to include with the schema, not used by pydantic-core
        serialization: Custom serialization schema
    """
    return _dict_not_none(
        type='enum',
        cls=cls,
        members=members,
        sub_type=sub_type,
        missing=missing,
        strict=strict,
        ref=ref,
        metadata=metadata,
        serialization=serialization,
    )

missing_sentinel_schema

missing_sentinel_schema(
    metadata: dict[str, Any] | None = None,
    serialization: SerSchema | None = None,
) -> MissingSentinelSchema

返回 MISSING 哨兵的 schema。

源代码位于 pydantic_core/core_schema.py

def missing_sentinel_schema(
    metadata: dict[str, Any] | None = None,
    serialization: SerSchema | None = None,
) -> MissingSentinelSchema:
    """Returns a schema for the `MISSING` sentinel."""

    return _dict_not_none(
        type='missing-sentinel',
        metadata=metadata,
        serialization=serialization,
    )

is_instance_schema

is_instance_schema(
    cls: Any,
    *,
    cls_repr: str | None = None,
    ref: str | None = None,
    metadata: dict[str, Any] | None = None,
    serialization: SerSchema | None = None
) -> IsInstanceSchema

返回一个检查值是否是类的实例的 schema，等同于 Python 的 isinstance 方法，例如

from pydantic_core import SchemaValidator, core_schema

class A:
    pass

schema = core_schema.is_instance_schema(cls=A)
v = SchemaValidator(schema)
v.validate_python(A())

参数

名称	类型	描述	默认值
cls	Any	该值必须是这个类的实例	必需
cls_repr	str | None	如果提供，则在验证器名称中使用此字符串代替 repr(cls)	None
ref	str | None	schema 的可选唯一标识符，用于在其他地方引用该 schema	None
metadata	dict[str, Any] | None	您想包含在 schema 中的任何其他信息，pydantic-core 不使用	None
serialization	SerSchema | None	自定义序列化 schema	None

源代码位于 pydantic_core/core_schema.py

def is_instance_schema(
    cls: Any,
    *,
    cls_repr: str | None = None,
    ref: str | None = None,
    metadata: dict[str, Any] | None = None,
    serialization: SerSchema | None = None,
) -> IsInstanceSchema:
    """
    Returns a schema that checks if a value is an instance of a class, equivalent to python's `isinstance` method, e.g.:

    ```py
    from pydantic_core import SchemaValidator, core_schema

    class A:
        pass

    schema = core_schema.is_instance_schema(cls=A)
    v = SchemaValidator(schema)
    v.validate_python(A())
    ```

    Args:
        cls: The value must be an instance of this class
        cls_repr: If provided this string is used in the validator name instead of `repr(cls)`
        ref: optional unique identifier of the schema, used to reference the schema in other places
        metadata: Any other information you want to include with the schema, not used by pydantic-core
        serialization: Custom serialization schema
    """
    return _dict_not_none(
        type='is-instance', cls=cls, cls_repr=cls_repr, ref=ref, metadata=metadata, serialization=serialization
    )

is_subclass_schema

is_subclass_schema(
    cls: type[Any],
    *,
    cls_repr: str | None = None,
    ref: str | None = None,
    metadata: dict[str, Any] | None = None,
    serialization: SerSchema | None = None
) -> IsInstanceSchema

返回一个检查值是否是类的子类型的 schema，等同于 Python 的 issubclass 方法，例如

from pydantic_core import SchemaValidator, core_schema

class A:
    pass

class B(A):
    pass

schema = core_schema.is_subclass_schema(cls=A)
v = SchemaValidator(schema)
v.validate_python(B)

参数

名称	类型	描述	默认值
cls	type[Any]	该值必须是这个类的子类	必需
cls_repr	str | None	如果提供，则在验证器名称中使用此字符串代替 repr(cls)	None
ref	str | None	schema 的可选唯一标识符，用于在其他地方引用该 schema	None
metadata	dict[str, Any] | None	您想包含在 schema 中的任何其他信息，pydantic-core 不使用	None
serialization	SerSchema | None	自定义序列化 schema	None

源代码位于 pydantic_core/core_schema.py

def is_subclass_schema(
    cls: type[Any],
    *,
    cls_repr: str | None = None,
    ref: str | None = None,
    metadata: dict[str, Any] | None = None,
    serialization: SerSchema | None = None,
) -> IsInstanceSchema:
    """
    Returns a schema that checks if a value is a subtype of a class, equivalent to python's `issubclass` method, e.g.:

    ```py
    from pydantic_core import SchemaValidator, core_schema

    class A:
        pass

    class B(A):
        pass

    schema = core_schema.is_subclass_schema(cls=A)
    v = SchemaValidator(schema)
    v.validate_python(B)
    ```

    Args:
        cls: The value must be a subclass of this class
        cls_repr: If provided this string is used in the validator name instead of `repr(cls)`
        ref: optional unique identifier of the schema, used to reference the schema in other places
        metadata: Any other information you want to include with the schema, not used by pydantic-core
        serialization: Custom serialization schema
    """
    return _dict_not_none(
        type='is-subclass', cls=cls, cls_repr=cls_repr, ref=ref, metadata=metadata, serialization=serialization
    )

callable_schema

callable_schema(
    *,
    ref: str | None = None,
    metadata: dict[str, Any] | None = None,
    serialization: SerSchema | None = None
) -> CallableSchema

返回一个检查值是否可调用的 schema，等同于 Python 的 callable 方法，例如

from pydantic_core import SchemaValidator, core_schema

schema = core_schema.callable_schema()
v = SchemaValidator(schema)
v.validate_python(min)

参数

名称	类型	描述	默认值
ref	str | None	schema 的可选唯一标识符，用于在其他地方引用该 schema	None
metadata	dict[str, Any] | None	您想包含在 schema 中的任何其他信息，pydantic-core 不使用	None
serialization	SerSchema | None	自定义序列化 schema	None

源代码位于 pydantic_core/core_schema.py

def callable_schema(
    *, ref: str | None = None, metadata: dict[str, Any] | None = None, serialization: SerSchema | None = None
) -> CallableSchema:
    """
    Returns a schema that checks if a value is callable, equivalent to python's `callable` method, e.g.:

    ```py
    from pydantic_core import SchemaValidator, core_schema

    schema = core_schema.callable_schema()
    v = SchemaValidator(schema)
    v.validate_python(min)
    ```

    Args:
        ref: optional unique identifier of the schema, used to reference the schema in other places
        metadata: Any other information you want to include with the schema, not used by pydantic-core
        serialization: Custom serialization schema
    """
    return _dict_not_none(type='callable', ref=ref, metadata=metadata, serialization=serialization)

list_schema

list_schema(
    items_schema: CoreSchema | None = None,
    *,
    min_length: int | None = None,
    max_length: int | None = None,
    fail_fast: bool | None = None,
    strict: bool | None = None,
    ref: str | None = None,
    metadata: dict[str, Any] | None = None,
    serialization: IncExSeqOrElseSerSchema | None = None
) -> ListSchema

返回一个匹配列表值的 schema，例如

from pydantic_core import SchemaValidator, core_schema

schema = core_schema.list_schema(core_schema.int_schema(), min_length=0, max_length=10)
v = SchemaValidator(schema)
assert v.validate_python(['4']) == [4]

参数

名称	类型	描述	默认值
items_schema	CoreSchema | None	该值必须是一个列表，其中的项必须匹配此 schema	None
min_length	int | None	该值必须是一个至少包含这么多项的列表	None
max_length	int | None	该值必须是一个最多包含这么多项的列表	None
fail_fast	bool | None	在第一个错误时停止验证	None
strict	bool | None	该值必须是一个恰好包含这么多项的列表	None
ref	str | None	schema 的可选唯一标识符，用于在其他地方引用该 schema	None
metadata	dict[str, Any] | None	您想包含在 schema 中的任何其他信息，pydantic-core 不使用	None
serialization	IncExSeqOrElseSerSchema | None	自定义序列化 schema	None

源代码位于 pydantic_core/core_schema.py

def list_schema(
    items_schema: CoreSchema | None = None,
    *,
    min_length: int | None = None,
    max_length: int | None = None,
    fail_fast: bool | None = None,
    strict: bool | None = None,
    ref: str | None = None,
    metadata: dict[str, Any] | None = None,
    serialization: IncExSeqOrElseSerSchema | None = None,
) -> ListSchema:
    """
    Returns a schema that matches a list value, e.g.:

    ```py
    from pydantic_core import SchemaValidator, core_schema

    schema = core_schema.list_schema(core_schema.int_schema(), min_length=0, max_length=10)
    v = SchemaValidator(schema)
    assert v.validate_python(['4']) == [4]
    ```

    Args:
        items_schema: The value must be a list of items that match this schema
        min_length: The value must be a list with at least this many items
        max_length: The value must be a list with at most this many items
        fail_fast: Stop validation on the first error
        strict: The value must be a list with exactly this many items
        ref: optional unique identifier of the schema, used to reference the schema in other places
        metadata: Any other information you want to include with the schema, not used by pydantic-core
        serialization: Custom serialization schema
    """
    return _dict_not_none(
        type='list',
        items_schema=items_schema,
        min_length=min_length,
        max_length=max_length,
        fail_fast=fail_fast,
        strict=strict,
        ref=ref,
        metadata=metadata,
        serialization=serialization,
    )

tuple_positional_schema

tuple_positional_schema(
    items_schema: list[CoreSchema],
    *,
    extras_schema: CoreSchema | None = None,
    strict: bool | None = None,
    ref: str | None = None,
    metadata: dict[str, Any] | None = None,
    serialization: IncExSeqOrElseSerSchema | None = None
) -> TupleSchema

返回一个匹配元组 schema 的 schema，例如

from pydantic_core import SchemaValidator, core_schema

schema = core_schema.tuple_positional_schema(
    [core_schema.int_schema(), core_schema.str_schema()]
)
v = SchemaValidator(schema)
assert v.validate_python((1, 'hello')) == (1, 'hello')

参数

名称	类型	描述	默认值
items_schema	list[CoreSchema]	该值必须是一个元组，其中的项必须匹配这些 schema	必需
extras_schema	CoreSchema | None	该值必须是一个元组，其中的项必须匹配此 schema。这受到 JSON schema 的 prefixItems 和 items 字段的启发。在 Python 的 typing.Tuple 中，您不能为“额外”项指定类型——如果长度可变，它们必须都是相同的类型。因此，此字段不会从 Pydantic 模型上的 typing.Tuple 注解中设置。	None
strict	bool | None	该值必须是一个恰好包含这么多项的元组	None
ref	str | None	schema 的可选唯一标识符，用于在其他地方引用该 schema	None
metadata	dict[str, Any] | None	您想包含在 schema 中的任何其他信息，pydantic-core 不使用	None
serialization	IncExSeqOrElseSerSchema | None	自定义序列化 schema	None

源代码位于 pydantic_core/core_schema.py

def tuple_positional_schema(
    items_schema: list[CoreSchema],
    *,
    extras_schema: CoreSchema | None = None,
    strict: bool | None = None,
    ref: str | None = None,
    metadata: dict[str, Any] | None = None,
    serialization: IncExSeqOrElseSerSchema | None = None,
) -> TupleSchema:
    """
    Returns a schema that matches a tuple of schemas, e.g.:

    ```py
    from pydantic_core import SchemaValidator, core_schema

    schema = core_schema.tuple_positional_schema(
        [core_schema.int_schema(), core_schema.str_schema()]
    )
    v = SchemaValidator(schema)
    assert v.validate_python((1, 'hello')) == (1, 'hello')
    ```

    Args:
        items_schema: The value must be a tuple with items that match these schemas
        extras_schema: The value must be a tuple with items that match this schema
            This was inspired by JSON schema's `prefixItems` and `items` fields.
            In python's `typing.Tuple`, you can't specify a type for "extra" items -- they must all be the same type
            if the length is variable. So this field won't be set from a `typing.Tuple` annotation on a pydantic model.
        strict: The value must be a tuple with exactly this many items
        ref: optional unique identifier of the schema, used to reference the schema in other places
        metadata: Any other information you want to include with the schema, not used by pydantic-core
        serialization: Custom serialization schema
    """
    if extras_schema is not None:
        variadic_item_index = len(items_schema)
        items_schema = items_schema + [extras_schema]
    else:
        variadic_item_index = None
    return tuple_schema(
        items_schema=items_schema,
        variadic_item_index=variadic_item_index,
        strict=strict,
        ref=ref,
        metadata=metadata,
        serialization=serialization,
    )

tuple_variable_schema

tuple_variable_schema(
    items_schema: CoreSchema | None = None,
    *,
    min_length: int | None = None,
    max_length: int | None = None,
    strict: bool | None = None,
    ref: str | None = None,
    metadata: dict[str, Any] | None = None,
    serialization: IncExSeqOrElseSerSchema | None = None
) -> TupleSchema

返回一个匹配给定 schema 的元组的 schema，例如

from pydantic_core import SchemaValidator, core_schema

schema = core_schema.tuple_variable_schema(
    items_schema=core_schema.int_schema(), min_length=0, max_length=10
)
v = SchemaValidator(schema)
assert v.validate_python(('1', 2, 3)) == (1, 2, 3)

参数

名称	类型	描述	默认值
items_schema	CoreSchema | None	该值必须是一个元组，其中的项必须匹配此 schema	None
min_length	int | None	该值必须是一个至少包含这么多项的元组	None
max_length	int | None	该值必须是一个最多包含这么多项的元组	None
strict	bool | None	该值必须是一个恰好包含这么多项的元组	None
ref	str | None	schema 的可选唯一标识符，用于在其他地方引用该 schema	None
metadata	dict[str, Any] | None	您想包含在 schema 中的任何其他信息，pydantic-core 不使用	None
serialization	IncExSeqOrElseSerSchema | None	自定义序列化 schema	None

源代码位于 pydantic_core/core_schema.py

def tuple_variable_schema(
    items_schema: CoreSchema | None = None,
    *,
    min_length: int | None = None,
    max_length: int | None = None,
    strict: bool | None = None,
    ref: str | None = None,
    metadata: dict[str, Any] | None = None,
    serialization: IncExSeqOrElseSerSchema | None = None,
) -> TupleSchema:
    """
    Returns a schema that matches a tuple of a given schema, e.g.:

    ```py
    from pydantic_core import SchemaValidator, core_schema

    schema = core_schema.tuple_variable_schema(
        items_schema=core_schema.int_schema(), min_length=0, max_length=10
    )
    v = SchemaValidator(schema)
    assert v.validate_python(('1', 2, 3)) == (1, 2, 3)
    ```

    Args:
        items_schema: The value must be a tuple with items that match this schema
        min_length: The value must be a tuple with at least this many items
        max_length: The value must be a tuple with at most this many items
        strict: The value must be a tuple with exactly this many items
        ref: Optional unique identifier of the schema, used to reference the schema in other places
        metadata: Any other information you want to include with the schema, not used by pydantic-core
        serialization: Custom serialization schema
    """
    return tuple_schema(
        items_schema=[items_schema or any_schema()],
        variadic_item_index=0,
        min_length=min_length,
        max_length=max_length,
        strict=strict,
        ref=ref,
        metadata=metadata,
        serialization=serialization,
    )

tuple_schema

tuple_schema(
    items_schema: list[CoreSchema],
    *,
    variadic_item_index: int | None = None,
    min_length: int | None = None,
    max_length: int | None = None,
    fail_fast: bool | None = None,
    strict: bool | None = None,
    ref: str | None = None,
    metadata: dict[str, Any] | None = None,
    serialization: IncExSeqOrElseSerSchema | None = None
) -> TupleSchema

返回一个匹配元组 schema 的 schema，带有可选的可变项，例如

from pydantic_core import SchemaValidator, core_schema

schema = core_schema.tuple_schema(
    [core_schema.int_schema(), core_schema.str_schema(), core_schema.float_schema()],
    variadic_item_index=1,
)
v = SchemaValidator(schema)
assert v.validate_python((1, 'hello', 'world', 1.5)) == (1, 'hello', 'world', 1.5)

参数

名称	类型	描述	默认值
items_schema	list[CoreSchema]	该值必须是一个元组，其中的项必须匹配这些 schema	必需
variadic_item_index	int | None	在 items_schema 中被视为可变项的 schema 的索引（遵循 PEP 646）	None
min_length	int | None	该值必须是一个至少包含这么多项的元组	None
max_length	int | None	该值必须是一个最多包含这么多项的元组	None
fail_fast	bool | None	在第一个错误时停止验证	None
strict	bool | None	该值必须是一个恰好包含这么多项的元组	None
ref	str | None	schema 的可选唯一标识符，用于在其他地方引用该 schema	None
metadata	dict[str, Any] | None	您想包含在 schema 中的任何其他信息，pydantic-core 不使用	None
serialization	IncExSeqOrElseSerSchema | None	自定义序列化 schema	None

源代码位于 pydantic_core/core_schema.py

def tuple_schema(
    items_schema: list[CoreSchema],
    *,
    variadic_item_index: int | None = None,
    min_length: int | None = None,
    max_length: int | None = None,
    fail_fast: bool | None = None,
    strict: bool | None = None,
    ref: str | None = None,
    metadata: dict[str, Any] | None = None,
    serialization: IncExSeqOrElseSerSchema | None = None,
) -> TupleSchema:
    """
    Returns a schema that matches a tuple of schemas, with an optional variadic item, e.g.:

    ```py
    from pydantic_core import SchemaValidator, core_schema

    schema = core_schema.tuple_schema(
        [core_schema.int_schema(), core_schema.str_schema(), core_schema.float_schema()],
        variadic_item_index=1,
    )
    v = SchemaValidator(schema)
    assert v.validate_python((1, 'hello', 'world', 1.5)) == (1, 'hello', 'world', 1.5)
    ```

    Args:
        items_schema: The value must be a tuple with items that match these schemas
        variadic_item_index: The index of the schema in `items_schema` to be treated as variadic (following PEP 646)
        min_length: The value must be a tuple with at least this many items
        max_length: The value must be a tuple with at most this many items
        fail_fast: Stop validation on the first error
        strict: The value must be a tuple with exactly this many items
        ref: Optional unique identifier of the schema, used to reference the schema in other places
        metadata: Any other information you want to include with the schema, not used by pydantic-core
        serialization: Custom serialization schema
    """
    return _dict_not_none(
        type='tuple',
        items_schema=items_schema,
        variadic_item_index=variadic_item_index,
        min_length=min_length,
        max_length=max_length,
        fail_fast=fail_fast,
        strict=strict,
        ref=ref,
        metadata=metadata,
        serialization=serialization,
    )

set_schema

set_schema(
    items_schema: CoreSchema | None = None,
    *,
    min_length: int | None = None,
    max_length: int | None = None,
    fail_fast: bool | None = None,
    strict: bool | None = None,
    ref: str | None = None,
    metadata: dict[str, Any] | None = None,
    serialization: SerSchema | None = None
) -> SetSchema

返回一个匹配给定 schema 的集合的 schema，例如

from pydantic_core import SchemaValidator, core_schema

schema = core_schema.set_schema(
    items_schema=core_schema.int_schema(), min_length=0, max_length=10
)
v = SchemaValidator(schema)
assert v.validate_python({1, '2', 3}) == {1, 2, 3}

参数

名称	类型	描述	默认值
items_schema	CoreSchema | None	该值必须是一个集合，其中的项必须匹配此 schema	None
min_length	int | None	该值必须是一个至少包含这么多项的集合	None
max_length	int | None	该值必须是一个最多包含这么多项的集合	None
fail_fast	bool | None	在第一个错误时停止验证	None
strict	bool | None	该值必须是一个恰好包含这么多项的集合	None
ref	str | None	schema 的可选唯一标识符，用于在其他地方引用该 schema	None
metadata	dict[str, Any] | None	您想包含在 schema 中的任何其他信息，pydantic-core 不使用	None
serialization	SerSchema | None	自定义序列化 schema	None

源代码位于 pydantic_core/core_schema.py

def set_schema(
    items_schema: CoreSchema | None = None,
    *,
    min_length: int | None = None,
    max_length: int | None = None,
    fail_fast: bool | None = None,
    strict: bool | None = None,
    ref: str | None = None,
    metadata: dict[str, Any] | None = None,
    serialization: SerSchema | None = None,
) -> SetSchema:
    """
    Returns a schema that matches a set of a given schema, e.g.:

    ```py
    from pydantic_core import SchemaValidator, core_schema

    schema = core_schema.set_schema(
        items_schema=core_schema.int_schema(), min_length=0, max_length=10
    )
    v = SchemaValidator(schema)
    assert v.validate_python({1, '2', 3}) == {1, 2, 3}
    ```

    Args:
        items_schema: The value must be a set with items that match this schema
        min_length: The value must be a set with at least this many items
        max_length: The value must be a set with at most this many items
        fail_fast: Stop validation on the first error
        strict: The value must be a set with exactly this many items
        ref: optional unique identifier of the schema, used to reference the schema in other places
        metadata: Any other information you want to include with the schema, not used by pydantic-core
        serialization: Custom serialization schema
    """
    return _dict_not_none(
        type='set',
        items_schema=items_schema,
        min_length=min_length,
        max_length=max_length,
        fail_fast=fail_fast,
        strict=strict,
        ref=ref,
        metadata=metadata,
        serialization=serialization,
    )

frozenset_schema

frozenset_schema(
    items_schema: CoreSchema | None = None,
    *,
    min_length: int | None = None,
    max_length: int | None = None,
    fail_fast: bool | None = None,
    strict: bool | None = None,
    ref: str | None = None,
    metadata: dict[str, Any] | None = None,
    serialization: SerSchema | None = None
) -> FrozenSetSchema

返回一个匹配给定 schema 的 frozenset 的 schema，例如

from pydantic_core import SchemaValidator, core_schema

schema = core_schema.frozenset_schema(
    items_schema=core_schema.int_schema(), min_length=0, max_length=10
)
v = SchemaValidator(schema)
assert v.validate_python(frozenset(range(3))) == frozenset({0, 1, 2})

参数

名称	类型	描述	默认值
items_schema	CoreSchema | None	该值必须是一个 frozenset，其中的项必须匹配此 schema	None
min_length	int | None	该值必须是一个至少包含这么多项的 frozenset	None
max_length	int | None	该值必须是一个最多包含这么多项的 frozenset	None
fail_fast	bool | None	在第一个错误时停止验证	None
strict	bool | None	该值必须是一个恰好包含这么多项的 frozenset	None
ref	str | None	schema 的可选唯一标识符，用于在其他地方引用该 schema	None
metadata	dict[str, Any] | None	您想包含在 schema 中的任何其他信息，pydantic-core 不使用	None
serialization	SerSchema | None	自定义序列化 schema	None

源代码位于 pydantic_core/core_schema.py

def frozenset_schema(
    items_schema: CoreSchema | None = None,
    *,
    min_length: int | None = None,
    max_length: int | None = None,
    fail_fast: bool | None = None,
    strict: bool | None = None,
    ref: str | None = None,
    metadata: dict[str, Any] | None = None,
    serialization: SerSchema | None = None,
) -> FrozenSetSchema:
    """
    Returns a schema that matches a frozenset of a given schema, e.g.:

    ```py
    from pydantic_core import SchemaValidator, core_schema

    schema = core_schema.frozenset_schema(
        items_schema=core_schema.int_schema(), min_length=0, max_length=10
    )
    v = SchemaValidator(schema)
    assert v.validate_python(frozenset(range(3))) == frozenset({0, 1, 2})
    ```

    Args:
        items_schema: The value must be a frozenset with items that match this schema
        min_length: The value must be a frozenset with at least this many items
        max_length: The value must be a frozenset with at most this many items
        fail_fast: Stop validation on the first error
        strict: The value must be a frozenset with exactly this many items
        ref: optional unique identifier of the schema, used to reference the schema in other places
        metadata: Any other information you want to include with the schema, not used by pydantic-core
        serialization: Custom serialization schema
    """
    return _dict_not_none(
        type='frozenset',
        items_schema=items_schema,
        min_length=min_length,
        max_length=max_length,
        fail_fast=fail_fast,
        strict=strict,
        ref=ref,
        metadata=metadata,
        serialization=serialization,
    )

generator_schema

generator_schema(
    items_schema: CoreSchema | None = None,
    *,
    min_length: int | None = None,
    max_length: int | None = None,
    ref: str | None = None,
    metadata: dict[str, Any] | None = None,
    serialization: IncExSeqOrElseSerSchema | None = None
) -> GeneratorSchema

返回一个匹配生成器值的 schema，例如

from typing import Iterator
from pydantic_core import SchemaValidator, core_schema

def gen() -> Iterator[int]:
    yield 1

schema = core_schema.generator_schema(items_schema=core_schema.int_schema())
v = SchemaValidator(schema)
v.validate_python(gen())

与其他类型不同，经过验证的生成器不会立即引发 ValidationError，而是在从生成器中实际读取到违反规则的值时引发 ValidationError。这是为了确保“已验证”的生成器保留延迟评估的好处。

参数

名称	类型	描述	默认值
items_schema	CoreSchema | None	该值必须是一个生成器，其项必须匹配此 schema	None
min_length	int | None	该值必须是一个至少产生这么多项的生成器	None
max_length	int | None	该值必须是一个最多产生这么多项的生成器	None
ref	str | None	schema 的可选唯一标识符，用于在其他地方引用该 schema	None
metadata	dict[str, Any] | None	您想包含在 schema 中的任何其他信息，pydantic-core 不使用	None
serialization	IncExSeqOrElseSerSchema | None	自定义序列化 schema	None

源代码位于 pydantic_core/core_schema.py

def generator_schema(
    items_schema: CoreSchema | None = None,
    *,
    min_length: int | None = None,
    max_length: int | None = None,
    ref: str | None = None,
    metadata: dict[str, Any] | None = None,
    serialization: IncExSeqOrElseSerSchema | None = None,
) -> GeneratorSchema:
    """
    Returns a schema that matches a generator value, e.g.:

    ```py
    from typing import Iterator
    from pydantic_core import SchemaValidator, core_schema

    def gen() -> Iterator[int]:
        yield 1

    schema = core_schema.generator_schema(items_schema=core_schema.int_schema())
    v = SchemaValidator(schema)
    v.validate_python(gen())
    ```

    Unlike other types, validated generators do not raise ValidationErrors eagerly,
    but instead will raise a ValidationError when a violating value is actually read from the generator.
    This is to ensure that "validated" generators retain the benefit of lazy evaluation.

    Args:
        items_schema: The value must be a generator with items that match this schema
        min_length: The value must be a generator that yields at least this many items
        max_length: The value must be a generator that yields at most this many items
        ref: optional unique identifier of the schema, used to reference the schema in other places
        metadata: Any other information you want to include with the schema, not used by pydantic-core
        serialization: Custom serialization schema
    """
    return _dict_not_none(
        type='generator',
        items_schema=items_schema,
        min_length=min_length,
        max_length=max_length,
        ref=ref,
        metadata=metadata,
        serialization=serialization,
    )

dict_schema

dict_schema(
    keys_schema: CoreSchema | None = None,
    values_schema: CoreSchema | None = None,
    *,
    min_length: int | None = None,
    max_length: int | None = None,
    fail_fast: bool | None = None,
    strict: bool | None = None,
    ref: str | None = None,
    metadata: dict[str, Any] | None = None,
    serialization: SerSchema | None = None
) -> DictSchema

返回一个匹配字典值的 schema，例如

from pydantic_core import SchemaValidator, core_schema

schema = core_schema.dict_schema(
    keys_schema=core_schema.str_schema(), values_schema=core_schema.int_schema()
)
v = SchemaValidator(schema)
assert v.validate_python({'a': '1', 'b': 2}) == {'a': 1, 'b': 2}

参数

名称	类型	描述	默认值
keys_schema	CoreSchema | None	该值必须是一个字典，其键必须匹配此 schema	None
values_schema	CoreSchema | None	该值必须是一个字典，其值必须匹配此 schema	None
min_length	int | None	该值必须是一个至少包含这么多项的字典	None
max_length	int | None	该值必须是一个最多包含这么多项的字典	None
fail_fast	bool | None	在第一个错误时停止验证	None
strict	bool | None	键和值是否应在严格模式下验证	None
ref	str | None	schema 的可选唯一标识符，用于在其他地方引用该 schema	None
metadata	dict[str, Any] | None	您想包含在 schema 中的任何其他信息，pydantic-core 不使用	None
serialization	SerSchema | None	自定义序列化 schema	None

源代码位于 pydantic_core/core_schema.py

def dict_schema(
    keys_schema: CoreSchema | None = None,
    values_schema: CoreSchema | None = None,
    *,
    min_length: int | None = None,
    max_length: int | None = None,
    fail_fast: bool | None = None,
    strict: bool | None = None,
    ref: str | None = None,
    metadata: dict[str, Any] | None = None,
    serialization: SerSchema | None = None,
) -> DictSchema:
    """
    Returns a schema that matches a dict value, e.g.:

    ```py
    from pydantic_core import SchemaValidator, core_schema

    schema = core_schema.dict_schema(
        keys_schema=core_schema.str_schema(), values_schema=core_schema.int_schema()
    )
    v = SchemaValidator(schema)
    assert v.validate_python({'a': '1', 'b': 2}) == {'a': 1, 'b': 2}
    ```

    Args:
        keys_schema: The value must be a dict with keys that match this schema
        values_schema: The value must be a dict with values that match this schema
        min_length: The value must be a dict with at least this many items
        max_length: The value must be a dict with at most this many items
        fail_fast: Stop validation on the first error
        strict: Whether the keys and values should be validated with strict mode
        ref: optional unique identifier of the schema, used to reference the schema in other places
        metadata: Any other information you want to include with the schema, not used by pydantic-core
        serialization: Custom serialization schema
    """
    return _dict_not_none(
        type='dict',
        keys_schema=keys_schema,
        values_schema=values_schema,
        min_length=min_length,
        max_length=max_length,
        fail_fast=fail_fast,
        strict=strict,
        ref=ref,
        metadata=metadata,
        serialization=serialization,
    )

no_info_before_validator_function

no_info_before_validator_function(
    function: NoInfoValidatorFunction,
    schema: CoreSchema,
    *,
    ref: str | None = None,
    json_schema_input_schema: CoreSchema | None = None,
    metadata: dict[str, Any] | None = None,
    serialization: SerSchema | None = None
) -> BeforeValidatorFunctionSchema

返回一个在验证前调用验证器函数的 schema，不提供 info 参数，例如

from pydantic_core import SchemaValidator, core_schema

def fn(v: bytes) -> str:
    return v.decode() + 'world'

func_schema = core_schema.no_info_before_validator_function(
    function=fn, schema=core_schema.str_schema()
)
schema = core_schema.typed_dict_schema({'a': core_schema.typed_dict_field(func_schema)})

v = SchemaValidator(schema)
assert v.validate_python({'a': b'hello '}) == {'a': 'hello world'}

参数

名称	类型	描述	默认值
function	NoInfoValidatorFunction	要调用的验证器函数	必需
schema	CoreSchema	用于验证验证器函数输出的 schema	必需
ref	str | None	schema 的可选唯一标识符，用于在其他地方引用该 schema	None
json_schema_input_schema	CoreSchema | None	用于生成相应 JSON Schema 输入类型的核心 schema	None
metadata	dict[str, Any] | None	您想包含在 schema 中的任何其他信息，pydantic-core 不使用	None
serialization	SerSchema | None	自定义序列化 schema	None

源代码位于 pydantic_core/core_schema.py

def no_info_before_validator_function(
    function: NoInfoValidatorFunction,
    schema: CoreSchema,
    *,
    ref: str | None = None,
    json_schema_input_schema: CoreSchema | None = None,
    metadata: dict[str, Any] | None = None,
    serialization: SerSchema | None = None,
) -> BeforeValidatorFunctionSchema:
    """
    Returns a schema that calls a validator function before validating, no `info` argument is provided, e.g.:

    ```py
    from pydantic_core import SchemaValidator, core_schema

    def fn(v: bytes) -> str:
        return v.decode() + 'world'

    func_schema = core_schema.no_info_before_validator_function(
        function=fn, schema=core_schema.str_schema()
    )
    schema = core_schema.typed_dict_schema({'a': core_schema.typed_dict_field(func_schema)})

    v = SchemaValidator(schema)
    assert v.validate_python({'a': b'hello '}) == {'a': 'hello world'}
    ```

    Args:
        function: The validator function to call
        schema: The schema to validate the output of the validator function
        ref: optional unique identifier of the schema, used to reference the schema in other places
        json_schema_input_schema: The core schema to be used to generate the corresponding JSON Schema input type
        metadata: Any other information you want to include with the schema, not used by pydantic-core
        serialization: Custom serialization schema
    """
    return _dict_not_none(
        type='function-before',
        function={'type': 'no-info', 'function': function},
        schema=schema,
        ref=ref,
        json_schema_input_schema=json_schema_input_schema,
        metadata=metadata,
        serialization=serialization,
    )

with_info_before_validator_function

with_info_before_validator_function(
    function: WithInfoValidatorFunction,
    schema: CoreSchema,
    *,
    field_name: str | None = None,
    ref: str | None = None,
    json_schema_input_schema: CoreSchema | None = None,
    metadata: dict[str, Any] | None = None,
    serialization: SerSchema | None = None
) -> BeforeValidatorFunctionSchema

返回一个在验证前调用验证器函数的 schema，该函数使用 info 参数调用，例如

from pydantic_core import SchemaValidator, core_schema

def fn(v: bytes, info: core_schema.ValidationInfo) -> str:
    assert info.data is not None
    assert info.field_name is not None
    return v.decode() + 'world'

func_schema = core_schema.with_info_before_validator_function(
    function=fn, schema=core_schema.str_schema()
)
schema = core_schema.typed_dict_schema({'a': core_schema.typed_dict_field(func_schema)})

v = SchemaValidator(schema)
assert v.validate_python({'a': b'hello '}) == {'a': 'hello world'}

参数

名称	类型	描述	默认值
function	WithInfoValidatorFunction	要调用的验证器函数	必需
field_name	str | None	此验证器应用的字段名称（如果有）（已弃用）	None
schema	CoreSchema	用于验证验证器函数输出的 schema	必需
ref	str | None	schema 的可选唯一标识符，用于在其他地方引用该 schema	None
json_schema_input_schema	CoreSchema | None	用于生成相应 JSON Schema 输入类型的核心 schema	None
metadata	dict[str, Any] | None	您想包含在 schema 中的任何其他信息，pydantic-core 不使用	None
serialization	SerSchema | None	自定义序列化 schema	None

源代码位于 pydantic_core/core_schema.py

def with_info_before_validator_function(
    function: WithInfoValidatorFunction,
    schema: CoreSchema,
    *,
    field_name: str | None = None,
    ref: str | None = None,
    json_schema_input_schema: CoreSchema | None = None,
    metadata: dict[str, Any] | None = None,
    serialization: SerSchema | None = None,
) -> BeforeValidatorFunctionSchema:
    """
    Returns a schema that calls a validator function before validation, the function is called with
    an `info` argument, e.g.:

    ```py
    from pydantic_core import SchemaValidator, core_schema

    def fn(v: bytes, info: core_schema.ValidationInfo) -> str:
        assert info.data is not None
        assert info.field_name is not None
        return v.decode() + 'world'

    func_schema = core_schema.with_info_before_validator_function(
        function=fn, schema=core_schema.str_schema()
    )
    schema = core_schema.typed_dict_schema({'a': core_schema.typed_dict_field(func_schema)})

    v = SchemaValidator(schema)
    assert v.validate_python({'a': b'hello '}) == {'a': 'hello world'}
    ```

    Args:
        function: The validator function to call
        field_name: The name of the field this validator is applied to, if any (deprecated)
        schema: The schema to validate the output of the validator function
        ref: optional unique identifier of the schema, used to reference the schema in other places
        json_schema_input_schema: The core schema to be used to generate the corresponding JSON Schema input type
        metadata: Any other information you want to include with the schema, not used by pydantic-core
        serialization: Custom serialization schema
    """
    if field_name is not None:
        warnings.warn(
            'The `field_name` argument on `with_info_before_validator_function` is deprecated, it will be passed to the function through `ValidationState` instead.',
            DeprecationWarning,
            stacklevel=2,
        )

    return _dict_not_none(
        type='function-before',
        function=_dict_not_none(type='with-info', function=function, field_name=field_name),
        schema=schema,
        ref=ref,
        json_schema_input_schema=json_schema_input_schema,
        metadata=metadata,
        serialization=serialization,
    )

no_info_after_validator_function

no_info_after_validator_function(
    function: NoInfoValidatorFunction,
    schema: CoreSchema,
    *,
    ref: str | None = None,
    json_schema_input_schema: CoreSchema | None = None,
    metadata: dict[str, Any] | None = None,
    serialization: SerSchema | None = None
) -> AfterValidatorFunctionSchema

返回一个在验证后调用验证器函数的 schema，不提供 info 参数，例如

from pydantic_core import SchemaValidator, core_schema

def fn(v: str) -> str:
    return v + 'world'

func_schema = core_schema.no_info_after_validator_function(fn, core_schema.str_schema())
schema = core_schema.typed_dict_schema({'a': core_schema.typed_dict_field(func_schema)})

v = SchemaValidator(schema)
assert v.validate_python({'a': b'hello '}) == {'a': 'hello world'}

参数

名称	类型	描述	默认值
function	NoInfoValidatorFunction	在 schema 验证后要调用的验证器函数	必需
schema	CoreSchema	在验证器函数之前要验证的 schema	必需
ref	str | None	schema 的可选唯一标识符，用于在其他地方引用该 schema	None
json_schema_input_schema	CoreSchema | None	用于生成相应 JSON Schema 输入类型的核心 schema	None
metadata	dict[str, Any] | None	您想包含在 schema 中的任何其他信息，pydantic-core 不使用	None
serialization	SerSchema | None	自定义序列化 schema	None

源代码位于 pydantic_core/core_schema.py

def no_info_after_validator_function(
    function: NoInfoValidatorFunction,
    schema: CoreSchema,
    *,
    ref: str | None = None,
    json_schema_input_schema: CoreSchema | None = None,
    metadata: dict[str, Any] | None = None,
    serialization: SerSchema | None = None,
) -> AfterValidatorFunctionSchema:
    """
    Returns a schema that calls a validator function after validating, no `info` argument is provided, e.g.:

    ```py
    from pydantic_core import SchemaValidator, core_schema

    def fn(v: str) -> str:
        return v + 'world'

    func_schema = core_schema.no_info_after_validator_function(fn, core_schema.str_schema())
    schema = core_schema.typed_dict_schema({'a': core_schema.typed_dict_field(func_schema)})

    v = SchemaValidator(schema)
    assert v.validate_python({'a': b'hello '}) == {'a': 'hello world'}
    ```

    Args:
        function: The validator function to call after the schema is validated
        schema: The schema to validate before the validator function
        ref: optional unique identifier of the schema, used to reference the schema in other places
        json_schema_input_schema: The core schema to be used to generate the corresponding JSON Schema input type
        metadata: Any other information you want to include with the schema, not used by pydantic-core
        serialization: Custom serialization schema
    """
    return _dict_not_none(
        type='function-after',
        function={'type': 'no-info', 'function': function},
        schema=schema,
        ref=ref,
        json_schema_input_schema=json_schema_input_schema,
        metadata=metadata,
        serialization=serialization,
    )

with_info_after_validator_function

with_info_after_validator_function(
    function: WithInfoValidatorFunction,
    schema: CoreSchema,
    *,
    field_name: str | None = None,
    ref: str | None = None,
    metadata: dict[str, Any] | None = None,
    serialization: SerSchema | None = None
) -> AfterValidatorFunctionSchema

返回一个在验证后调用验证器函数的 schema，该函数使用 info 参数调用，例如

from pydantic_core import SchemaValidator, core_schema

def fn(v: str, info: core_schema.ValidationInfo) -> str:
    assert info.data is not None
    assert info.field_name is not None
    return v + 'world'

func_schema = core_schema.with_info_after_validator_function(
    function=fn, schema=core_schema.str_schema()
)
schema = core_schema.typed_dict_schema({'a': core_schema.typed_dict_field(func_schema)})

v = SchemaValidator(schema)
assert v.validate_python({'a': b'hello '}) == {'a': 'hello world'}

参数

名称	类型	描述	默认值
function	WithInfoValidatorFunction	在 schema 验证后要调用的验证器函数	必需
schema	CoreSchema	在验证器函数之前要验证的 schema	必需
field_name	str | None	此验证器应用的字段名称（如果有）（已弃用）	None
ref	str | None	schema 的可选唯一标识符，用于在其他地方引用该 schema	None
metadata	dict[str, Any] | None	您想包含在 schema 中的任何其他信息，pydantic-core 不使用	None
serialization	SerSchema | None	自定义序列化 schema	None

源代码位于 pydantic_core/core_schema.py

def with_info_after_validator_function(
    function: WithInfoValidatorFunction,
    schema: CoreSchema,
    *,
    field_name: str | None = None,
    ref: str | None = None,
    metadata: dict[str, Any] | None = None,
    serialization: SerSchema | None = None,
) -> AfterValidatorFunctionSchema:
    """
    Returns a schema that calls a validator function after validation, the function is called with
    an `info` argument, e.g.:

    ```py
    from pydantic_core import SchemaValidator, core_schema

    def fn(v: str, info: core_schema.ValidationInfo) -> str:
        assert info.data is not None
        assert info.field_name is not None
        return v + 'world'

    func_schema = core_schema.with_info_after_validator_function(
        function=fn, schema=core_schema.str_schema()
    )
    schema = core_schema.typed_dict_schema({'a': core_schema.typed_dict_field(func_schema)})

    v = SchemaValidator(schema)
    assert v.validate_python({'a': b'hello '}) == {'a': 'hello world'}
    ```

    Args:
        function: The validator function to call after the schema is validated
        schema: The schema to validate before the validator function
        field_name: The name of the field this validator is applied to, if any (deprecated)
        ref: optional unique identifier of the schema, used to reference the schema in other places
        metadata: Any other information you want to include with the schema, not used by pydantic-core
        serialization: Custom serialization schema
    """
    if field_name is not None:
        warnings.warn(
            'The `field_name` argument on `with_info_after_validator_function` is deprecated, it will be passed to the function through `ValidationState` instead.',
            DeprecationWarning,
            stacklevel=2,
        )

    return _dict_not_none(
        type='function-after',
        function=_dict_not_none(type='with-info', function=function, field_name=field_name),
        schema=schema,
        ref=ref,
        metadata=metadata,
        serialization=serialization,
    )

no_info_wrap_validator_function

no_info_wrap_validator_function(
    function: NoInfoWrapValidatorFunction,
    schema: CoreSchema,
    *,
    ref: str | None = None,
    json_schema_input_schema: CoreSchema | None = None,
    metadata: dict[str, Any] | None = None,
    serialization: SerSchema | None = None
) -> WrapValidatorFunctionSchema

返回一个调用函数的 schema，该函数带有一个 validator 可调用参数，该参数可选择用于通过函数逻辑调用内部验证，这很像许多流行 Web 框架中中间件的“洋葱”实现，不传递 info 参数，例如

from pydantic_core import SchemaValidator, core_schema

def fn(
    v: str,
    validator: core_schema.ValidatorFunctionWrapHandler,
) -> str:
    return validator(input_value=v) + 'world'

schema = core_schema.no_info_wrap_validator_function(
    function=fn, schema=core_schema.str_schema()
)
v = SchemaValidator(schema)
assert v.validate_python('hello ') == 'hello world'

参数

名称	类型	描述	默认值
function	NoInfoWrapValidatorFunction	要调用的验证器函数	必需
schema	CoreSchema	用于验证验证器函数输出的 schema	必需
ref	str | None	schema 的可选唯一标识符，用于在其他地方引用该 schema	None
json_schema_input_schema	CoreSchema | None	用于生成相应 JSON Schema 输入类型的核心 schema	None
metadata	dict[str, Any] | None	您想包含在 schema 中的任何其他信息，pydantic-core 不使用	None
serialization	SerSchema | None	自定义序列化 schema	None

源代码位于 pydantic_core/core_schema.py

def no_info_wrap_validator_function(
    function: NoInfoWrapValidatorFunction,
    schema: CoreSchema,
    *,
    ref: str | None = None,
    json_schema_input_schema: CoreSchema | None = None,
    metadata: dict[str, Any] | None = None,
    serialization: SerSchema | None = None,
) -> WrapValidatorFunctionSchema:
    """
    Returns a schema which calls a function with a `validator` callable argument which can
    optionally be used to call inner validation with the function logic, this is much like the
    "onion" implementation of middleware in many popular web frameworks, no `info` argument is passed, e.g.:

    ```py
    from pydantic_core import SchemaValidator, core_schema

    def fn(
        v: str,
        validator: core_schema.ValidatorFunctionWrapHandler,
    ) -> str:
        return validator(input_value=v) + 'world'

    schema = core_schema.no_info_wrap_validator_function(
        function=fn, schema=core_schema.str_schema()
    )
    v = SchemaValidator(schema)
    assert v.validate_python('hello ') == 'hello world'
    ```

    Args:
        function: The validator function to call
        schema: The schema to validate the output of the validator function
        ref: optional unique identifier of the schema, used to reference the schema in other places
        json_schema_input_schema: The core schema to be used to generate the corresponding JSON Schema input type
        metadata: Any other information you want to include with the schema, not used by pydantic-core
        serialization: Custom serialization schema
    """
    return _dict_not_none(
        type='function-wrap',
        function={'type': 'no-info', 'function': function},
        schema=schema,
        json_schema_input_schema=json_schema_input_schema,
        ref=ref,
        metadata=metadata,
        serialization=serialization,
    )

with_info_wrap_validator_function

with_info_wrap_validator_function(
    function: WithInfoWrapValidatorFunction,
    schema: CoreSchema,
    *,
    field_name: str | None = None,
    json_schema_input_schema: CoreSchema | None = None,
    ref: str | None = None,
    metadata: dict[str, Any] | None = None,
    serialization: SerSchema | None = None
) -> WrapValidatorFunctionSchema

返回一个调用函数的 schema，该函数带有一个 validator 可调用参数，该参数可选择用于通过函数逻辑调用内部验证，这很像许多流行 Web 框架中中间件的“洋葱”实现，同时还传递一个 info 参数，例如

from pydantic_core import SchemaValidator, core_schema

def fn(
    v: str,
    validator: core_schema.ValidatorFunctionWrapHandler,
    info: core_schema.ValidationInfo,
) -> str:
    return validator(input_value=v) + 'world'

schema = core_schema.with_info_wrap_validator_function(
    function=fn, schema=core_schema.str_schema()
)
v = SchemaValidator(schema)
assert v.validate_python('hello ') == 'hello world'

参数

名称	类型	描述	默认值
function	WithInfoWrapValidatorFunction	要调用的验证器函数	必需
schema	CoreSchema	用于验证验证器函数输出的 schema	必需
field_name	str | None	此验证器应用的字段名称（如果有）（已弃用）	None
json_schema_input_schema	CoreSchema | None	用于生成相应 JSON Schema 输入类型的核心 schema	None
ref	str | None	schema 的可选唯一标识符，用于在其他地方引用该 schema	None
metadata	dict[str, Any] | None	您想包含在 schema 中的任何其他信息，pydantic-core 不使用	None
serialization	SerSchema | None	自定义序列化 schema	None

源代码位于 pydantic_core/core_schema.py

def with_info_wrap_validator_function(
    function: WithInfoWrapValidatorFunction,
    schema: CoreSchema,
    *,
    field_name: str | None = None,
    json_schema_input_schema: CoreSchema | None = None,
    ref: str | None = None,
    metadata: dict[str, Any] | None = None,
    serialization: SerSchema | None = None,
) -> WrapValidatorFunctionSchema:
    """
    Returns a schema which calls a function with a `validator` callable argument which can
    optionally be used to call inner validation with the function logic, this is much like the
    "onion" implementation of middleware in many popular web frameworks, an `info` argument is also passed, e.g.:

    ```py
    from pydantic_core import SchemaValidator, core_schema

    def fn(
        v: str,
        validator: core_schema.ValidatorFunctionWrapHandler,
        info: core_schema.ValidationInfo,
    ) -> str:
        return validator(input_value=v) + 'world'

    schema = core_schema.with_info_wrap_validator_function(
        function=fn, schema=core_schema.str_schema()
    )
    v = SchemaValidator(schema)
    assert v.validate_python('hello ') == 'hello world'
    ```

    Args:
        function: The validator function to call
        schema: The schema to validate the output of the validator function
        field_name: The name of the field this validator is applied to, if any (deprecated)
        json_schema_input_schema: The core schema to be used to generate the corresponding JSON Schema input type
        ref: optional unique identifier of the schema, used to reference the schema in other places
        metadata: Any other information you want to include with the schema, not used by pydantic-core
        serialization: Custom serialization schema
    """
    if field_name is not None:
        warnings.warn(
            'The `field_name` argument on `with_info_wrap_validator_function` is deprecated, it will be passed to the function through `ValidationState` instead.',
            DeprecationWarning,
            stacklevel=2,
        )

    return _dict_not_none(
        type='function-wrap',
        function=_dict_not_none(type='with-info', function=function, field_name=field_name),
        schema=schema,
        json_schema_input_schema=json_schema_input_schema,
        ref=ref,
        metadata=metadata,
        serialization=serialization,
    )

no_info_plain_validator_function

no_info_plain_validator_function(
    function: NoInfoValidatorFunction,
    *,
    ref: str | None = None,
    json_schema_input_schema: CoreSchema | None = None,
    metadata: dict[str, Any] | None = None,
    serialization: SerSchema | None = None
) -> PlainValidatorFunctionSchema

返回一个使用提供的函数进行验证的 schema，不传递 info 参数，例如

from pydantic_core import SchemaValidator, core_schema

def fn(v: str) -> str:
    assert 'hello' in v
    return v + 'world'

schema = core_schema.no_info_plain_validator_function(function=fn)
v = SchemaValidator(schema)
assert v.validate_python('hello ') == 'hello world'

参数

名称	类型	描述	默认值
function	NoInfoValidatorFunction	要调用的验证器函数	必需
ref	str | None	schema 的可选唯一标识符，用于在其他地方引用该 schema	None
json_schema_input_schema	CoreSchema | None	用于生成相应 JSON Schema 输入类型的核心 schema	None
metadata	dict[str, Any] | None	您想包含在 schema 中的任何其他信息，pydantic-core 不使用	None
serialization	SerSchema | None	自定义序列化 schema	None

源代码位于 pydantic_core/core_schema.py

def no_info_plain_validator_function(
    function: NoInfoValidatorFunction,
    *,
    ref: str | None = None,
    json_schema_input_schema: CoreSchema | None = None,
    metadata: dict[str, Any] | None = None,
    serialization: SerSchema | None = None,
) -> PlainValidatorFunctionSchema:
    """
    Returns a schema that uses the provided function for validation, no `info` argument is passed, e.g.:

    ```py
    from pydantic_core import SchemaValidator, core_schema

    def fn(v: str) -> str:
        assert 'hello' in v
        return v + 'world'

    schema = core_schema.no_info_plain_validator_function(function=fn)
    v = SchemaValidator(schema)
    assert v.validate_python('hello ') == 'hello world'
    ```

    Args:
        function: The validator function to call
        ref: optional unique identifier of the schema, used to reference the schema in other places
        json_schema_input_schema: The core schema to be used to generate the corresponding JSON Schema input type
        metadata: Any other information you want to include with the schema, not used by pydantic-core
        serialization: Custom serialization schema
    """
    return _dict_not_none(
        type='function-plain',
        function={'type': 'no-info', 'function': function},
        ref=ref,
        json_schema_input_schema=json_schema_input_schema,
        metadata=metadata,
        serialization=serialization,
    )

with_info_plain_validator_function

with_info_plain_validator_function(
    function: WithInfoValidatorFunction,
    *,
    field_name: str | None = None,
    ref: str | None = None,
    json_schema_input_schema: CoreSchema | None = None,
    metadata: dict[str, Any] | None = None,
    serialization: SerSchema | None = None
) -> PlainValidatorFunctionSchema

返回一个使用提供的函数进行验证的 schema，传递一个 info 参数，例如

from pydantic_core import SchemaValidator, core_schema

def fn(v: str, info: core_schema.ValidationInfo) -> str:
    assert 'hello' in v
    return v + 'world'

schema = core_schema.with_info_plain_validator_function(function=fn)
v = SchemaValidator(schema)
assert v.validate_python('hello ') == 'hello world'

参数

名称	类型	描述	默认值
function	WithInfoValidatorFunction	要调用的验证器函数	必需
field_name	str | None	此验证器应用的字段名称（如果有）（已弃用）	None
ref	str | None	schema 的可选唯一标识符，用于在其他地方引用该 schema	None
json_schema_input_schema	CoreSchema | None	用于生成相应 JSON Schema 输入类型的核心 schema	None
metadata	dict[str, Any] | None	您想包含在 schema 中的任何其他信息，pydantic-core 不使用	None
serialization	SerSchema | None	自定义序列化 schema	None

源代码位于 pydantic_core/core_schema.py

def with_info_plain_validator_function(
    function: WithInfoValidatorFunction,
    *,
    field_name: str | None = None,
    ref: str | None = None,
    json_schema_input_schema: CoreSchema | None = None,
    metadata: dict[str, Any] | None = None,
    serialization: SerSchema | None = None,
) -> PlainValidatorFunctionSchema:
    """
    Returns a schema that uses the provided function for validation, an `info` argument is passed, e.g.:

    ```py
    from pydantic_core import SchemaValidator, core_schema

    def fn(v: str, info: core_schema.ValidationInfo) -> str:
        assert 'hello' in v
        return v + 'world'

    schema = core_schema.with_info_plain_validator_function(function=fn)
    v = SchemaValidator(schema)
    assert v.validate_python('hello ') == 'hello world'
    ```

    Args:
        function: The validator function to call
        field_name: The name of the field this validator is applied to, if any (deprecated)
        ref: optional unique identifier of the schema, used to reference the schema in other places
        json_schema_input_schema: The core schema to be used to generate the corresponding JSON Schema input type
        metadata: Any other information you want to include with the schema, not used by pydantic-core
        serialization: Custom serialization schema
    """
    if field_name is not None:
        warnings.warn(
            'The `field_name` argument on `with_info_plain_validator_function` is deprecated, it will be passed to the function through `ValidationState` instead.',
            DeprecationWarning,
            stacklevel=2,
        )

    return _dict_not_none(
        type='function-plain',
        function=_dict_not_none(type='with-info', function=function, field_name=field_name),
        ref=ref,
        json_schema_input_schema=json_schema_input_schema,
        metadata=metadata,
        serialization=serialization,
    )

with_default_schema

with_default_schema(
    schema: CoreSchema,
    *,
    default: Any = PydanticUndefined,
    default_factory: Union[
        Callable[[], Any],
        Callable[[dict[str, Any]], Any],
        None,
    ] = None,
    default_factory_takes_data: bool | None = None,
    on_error: (
        Literal["raise", "omit", "default"] | None
    ) = None,
    validate_default: bool | None = None,
    strict: bool | None = None,
    ref: str | None = None,
    metadata: dict[str, Any] | None = None,
    serialization: SerSchema | None = None
) -> WithDefaultSchema

返回一个向给定 schema 添加默认值的 schema，例如

from pydantic_core import SchemaValidator, core_schema

schema = core_schema.with_default_schema(core_schema.str_schema(), default='hello')
wrapper_schema = core_schema.typed_dict_schema(
    {'a': core_schema.typed_dict_field(schema)}
)
v = SchemaValidator(wrapper_schema)
assert v.validate_python({}) == v.validate_python({'a': 'hello'})

参数

名称	类型	描述	默认值
schema	CoreSchema	要添加默认值的 schema	必需
default	Any	要使用的默认值	PydanticUndefined
default_factory	Union[Callable[[], Any], Callable[[dict[str, Any]], Any], None]	一个返回要使用的默认值的可调用对象	None
default_factory_takes_data	bool | None	默认工厂是否接受一个已验证的数据参数	None
on_error	Literal['raise', 'omit', 'default'] | None	如果 schema 验证失败该怎么办。'raise'、'omit'、'default' 之一	None
validate_default	bool | None	默认值是否应该被验证	None
strict	bool | None	底层 schema 是否应在严格模式下验证	None
ref	str | None	schema 的可选唯一标识符，用于在其他地方引用该 schema	None
metadata	dict[str, Any] | None	您想包含在 schema 中的任何其他信息，pydantic-core 不使用	None
serialization	SerSchema | None	自定义序列化 schema	None

源代码位于 pydantic_core/core_schema.py

def with_default_schema(
    schema: CoreSchema,
    *,
    default: Any = PydanticUndefined,
    default_factory: Union[Callable[[], Any], Callable[[dict[str, Any]], Any], None] = None,
    default_factory_takes_data: bool | None = None,
    on_error: Literal['raise', 'omit', 'default'] | None = None,
    validate_default: bool | None = None,
    strict: bool | None = None,
    ref: str | None = None,
    metadata: dict[str, Any] | None = None,
    serialization: SerSchema | None = None,
) -> WithDefaultSchema:
    """
    Returns a schema that adds a default value to the given schema, e.g.:

    ```py
    from pydantic_core import SchemaValidator, core_schema

    schema = core_schema.with_default_schema(core_schema.str_schema(), default='hello')
    wrapper_schema = core_schema.typed_dict_schema(
        {'a': core_schema.typed_dict_field(schema)}
    )
    v = SchemaValidator(wrapper_schema)
    assert v.validate_python({}) == v.validate_python({'a': 'hello'})
    ```

    Args:
        schema: The schema to add a default value to
        default: The default value to use
        default_factory: A callable that returns the default value to use
        default_factory_takes_data: Whether the default factory takes a validated data argument
        on_error: What to do if the schema validation fails. One of 'raise', 'omit', 'default'
        validate_default: Whether the default value should be validated
        strict: Whether the underlying schema should be validated with strict mode
        ref: optional unique identifier of the schema, used to reference the schema in other places
        metadata: Any other information you want to include with the schema, not used by pydantic-core
        serialization: Custom serialization schema
    """
    s = _dict_not_none(
        type='default',
        schema=schema,
        default_factory=default_factory,
        default_factory_takes_data=default_factory_takes_data,
        on_error=on_error,
        validate_default=validate_default,
        strict=strict,
        ref=ref,
        metadata=metadata,
        serialization=serialization,
    )
    if default is not PydanticUndefined:
        s['default'] = default
    return s

nullable_schema

nullable_schema(
    schema: CoreSchema,
    *,
    strict: bool | None = None,
    ref: str | None = None,
    metadata: dict[str, Any] | None = None,
    serialization: SerSchema | None = None
) -> NullableSchema

返回一个匹配可空值的 schema，例如

from pydantic_core import SchemaValidator, core_schema

schema = core_schema.nullable_schema(core_schema.str_schema())
v = SchemaValidator(schema)
assert v.validate_python(None) is None

参数

名称	类型	描述	默认值
schema	CoreSchema	要包装的 schema	必需
strict	bool | None	底层 schema 是否应在严格模式下验证	None
ref	str | None	schema 的可选唯一标识符，用于在其他地方引用该 schema	None
metadata	dict[str, Any] | None	您想包含在 schema 中的任何其他信息，pydantic-core 不使用	None
serialization	SerSchema | None	自定义序列化 schema	None

源代码位于 pydantic_core/core_schema.py

def nullable_schema(
    schema: CoreSchema,
    *,
    strict: bool | None = None,
    ref: str | None = None,
    metadata: dict[str, Any] | None = None,
    serialization: SerSchema | None = None,
) -> NullableSchema:
    """
    Returns a schema that matches a nullable value, e.g.:

    ```py
    from pydantic_core import SchemaValidator, core_schema

    schema = core_schema.nullable_schema(core_schema.str_schema())
    v = SchemaValidator(schema)
    assert v.validate_python(None) is None
    ```

    Args:
        schema: The schema to wrap
        strict: Whether the underlying schema should be validated with strict mode
        ref: optional unique identifier of the schema, used to reference the schema in other places
        metadata: Any other information you want to include with the schema, not used by pydantic-core
        serialization: Custom serialization schema
    """
    return _dict_not_none(
        type='nullable', schema=schema, strict=strict, ref=ref, metadata=metadata, serialization=serialization
    )

union_schema

union_schema(
    choices: list[CoreSchema | tuple[CoreSchema, str]],
    *,
    auto_collapse: bool | None = None,
    custom_error_type: str | None = None,
    custom_error_message: str | None = None,
    custom_error_context: (
        dict[str, str | int] | None
    ) = None,
    mode: Literal["smart", "left_to_right"] | None = None,
    ref: str | None = None,
    metadata: dict[str, Any] | None = None,
    serialization: SerSchema | None = None
) -> UnionSchema

返回一个匹配联合类型值的 schema，例如

from pydantic_core import SchemaValidator, core_schema

schema = core_schema.union_schema([core_schema.str_schema(), core_schema.int_schema()])
v = SchemaValidator(schema)
assert v.validate_python('hello') == 'hello'
assert v.validate_python(1) == 1

参数

名称	类型	描述	默认值
choices	list[CoreSchema | tuple[CoreSchema, str]]	要匹配的 schema。如果是元组，则第二项用作该情况的标签。	必需
auto_collapse	bool | None	是否自动将只有一个元素的联合类型折叠为内部验证器，默认为 true	None
custom_error_type	str | None	如果验证失败，要使用的自定义错误类型	None
custom_error_message	str | None	如果验证失败，要使用的自定义错误消息	None
custom_error_context	dict[str, str | int] | None	如果验证失败，要使用的自定义错误上下文	None
mode	Literal['smart', 'left_to_right'] | None	如何选择返回哪个选项 * smart (默认) 会尝试返回与输入值最接近的选项 * left_to_right 会返回 choices 中第一个验证成功的选项	None
ref	str | None	schema 的可选唯一标识符，用于在其他地方引用该 schema	None
metadata	dict[str, Any] | None	您想包含在 schema 中的任何其他信息，pydantic-core 不使用	None
serialization	SerSchema | None	自定义序列化 schema	None

源代码位于 pydantic_core/core_schema.py

def union_schema(
    choices: list[CoreSchema | tuple[CoreSchema, str]],
    *,
    auto_collapse: bool | None = None,
    custom_error_type: str | None = None,
    custom_error_message: str | None = None,
    custom_error_context: dict[str, str | int] | None = None,
    mode: Literal['smart', 'left_to_right'] | None = None,
    ref: str | None = None,
    metadata: dict[str, Any] | None = None,
    serialization: SerSchema | None = None,
) -> UnionSchema:
    """
    Returns a schema that matches a union value, e.g.:

    ```py
    from pydantic_core import SchemaValidator, core_schema

    schema = core_schema.union_schema([core_schema.str_schema(), core_schema.int_schema()])
    v = SchemaValidator(schema)
    assert v.validate_python('hello') == 'hello'
    assert v.validate_python(1) == 1
    ```

    Args:
        choices: The schemas to match. If a tuple, the second item is used as the label for the case.
        auto_collapse: whether to automatically collapse unions with one element to the inner validator, default true
        custom_error_type: The custom error type to use if the validation fails
        custom_error_message: The custom error message to use if the validation fails
        custom_error_context: The custom error context to use if the validation fails
        mode: How to select which choice to return
            * `smart` (default) will try to return the choice which is the closest match to the input value
            * `left_to_right` will return the first choice in `choices` which succeeds validation
        ref: optional unique identifier of the schema, used to reference the schema in other places
        metadata: Any other information you want to include with the schema, not used by pydantic-core
        serialization: Custom serialization schema
    """
    return _dict_not_none(
        type='union',
        choices=choices,
        auto_collapse=auto_collapse,
        custom_error_type=custom_error_type,
        custom_error_message=custom_error_message,
        custom_error_context=custom_error_context,
        mode=mode,
        ref=ref,
        metadata=metadata,
        serialization=serialization,
    )

tagged_union_schema

tagged_union_schema(
    choices: dict[Any, CoreSchema],
    discriminator: (
        str
        | list[str | int]
        | list[list[str | int]]
        | Callable[[Any], Any]
    ),
    *,
    custom_error_type: str | None = None,
    custom_error_message: str | None = None,
    custom_error_context: (
        dict[str, int | str | float] | None
    ) = None,
    strict: bool | None = None,
    from_attributes: bool | None = None,
    ref: str | None = None,
    metadata: dict[str, Any] | None = None,
    serialization: SerSchema | None = None
) -> TaggedUnionSchema

返回一个匹配带标签联合类型值的 schema，例如

from pydantic_core import SchemaValidator, core_schema

apple_schema = core_schema.typed_dict_schema(
    {
        'foo': core_schema.typed_dict_field(core_schema.str_schema()),
        'bar': core_schema.typed_dict_field(core_schema.int_schema()),
    }
)
banana_schema = core_schema.typed_dict_schema(
    {
        'foo': core_schema.typed_dict_field(core_schema.str_schema()),
        'spam': core_schema.typed_dict_field(
            core_schema.list_schema(items_schema=core_schema.int_schema())
        ),
    }
)
schema = core_schema.tagged_union_schema(
    choices={
        'apple': apple_schema,
        'banana': banana_schema,
    },
    discriminator='foo',
)
v = SchemaValidator(schema)
assert v.validate_python({'foo': 'apple', 'bar': '123'}) == {'foo': 'apple', 'bar': 123}
assert v.validate_python({'foo': 'banana', 'spam': [1, 2, 3]}) == {
    'foo': 'banana',
    'spam': [1, 2, 3],
}

参数

名称	类型	描述	默认值
choices	dict[Any, CoreSchema]	要匹配的 schema。当使用鉴别器值从 choices 中检索 schema 时，如果该值是 str，则应将其反馈到 choices 映射中，直到获得一个 schema（此方法是为了防止在 Rust 中对单个 schema 的多重所有权）	必需
discriminator	str | list[str | int] | list[list[str | int]] | Callable[[Any], Any]	用于确定要使用的 schema 的鉴别器 * 如果 discriminator 是一个 str，它是用作鉴别器的属性名称 * 如果 discriminator 是 int/str 的列表，它应该用作访问鉴别器的“路径” * 如果 discriminator 是列表的列表，每个内部列表都是一个路径，使用第一个存在的路径 * 如果 discriminator 是一个可调用对象，它在被调用时应返回鉴别器；该可调用对象可以返回 None 以指示输入中没有匹配的鉴别器	必需
custom_error_type	str | None	如果验证失败，要使用的自定义错误类型	None
custom_error_message	str | None	如果验证失败，要使用的自定义错误消息	None
custom_error_context	dict[str, int | str | float] | None	如果验证失败，要使用的自定义错误上下文	None
strict	bool | None	底层 schema 是否应在严格模式下验证	None
from_attributes	bool | None	是否使用对象的属性来检索鉴别器值	None
ref	str | None	schema 的可选唯一标识符，用于在其他地方引用该 schema	None
metadata	dict[str, Any] | None	您想包含在 schema 中的任何其他信息，pydantic-core 不使用	None
serialization	SerSchema | None	自定义序列化 schema	None

源代码位于 pydantic_core/core_schema.py

def tagged_union_schema(
    choices: dict[Any, CoreSchema],
    discriminator: str | list[str | int] | list[list[str | int]] | Callable[[Any], Any],
    *,
    custom_error_type: str | None = None,
    custom_error_message: str | None = None,
    custom_error_context: dict[str, int | str | float] | None = None,
    strict: bool | None = None,
    from_attributes: bool | None = None,
    ref: str | None = None,
    metadata: dict[str, Any] | None = None,
    serialization: SerSchema | None = None,
) -> TaggedUnionSchema:
    """
    Returns a schema that matches a tagged union value, e.g.:

    ```py
    from pydantic_core import SchemaValidator, core_schema

    apple_schema = core_schema.typed_dict_schema(
        {
            'foo': core_schema.typed_dict_field(core_schema.str_schema()),
            'bar': core_schema.typed_dict_field(core_schema.int_schema()),
        }
    )
    banana_schema = core_schema.typed_dict_schema(
        {
            'foo': core_schema.typed_dict_field(core_schema.str_schema()),
            'spam': core_schema.typed_dict_field(
                core_schema.list_schema(items_schema=core_schema.int_schema())
            ),
        }
    )
    schema = core_schema.tagged_union_schema(
        choices={
            'apple': apple_schema,
            'banana': banana_schema,
        },
        discriminator='foo',
    )
    v = SchemaValidator(schema)
    assert v.validate_python({'foo': 'apple', 'bar': '123'}) == {'foo': 'apple', 'bar': 123}
    assert v.validate_python({'foo': 'banana', 'spam': [1, 2, 3]}) == {
        'foo': 'banana',
        'spam': [1, 2, 3],
    }
    ```

    Args:
        choices: The schemas to match
            When retrieving a schema from `choices` using the discriminator value, if the value is a str,
            it should be fed back into the `choices` map until a schema is obtained
            (This approach is to prevent multiple ownership of a single schema in Rust)
        discriminator: The discriminator to use to determine the schema to use
            * If `discriminator` is a str, it is the name of the attribute to use as the discriminator
            * If `discriminator` is a list of int/str, it should be used as a "path" to access the discriminator
            * If `discriminator` is a list of lists, each inner list is a path, and the first path that exists is used
            * If `discriminator` is a callable, it should return the discriminator when called on the value to validate;
              the callable can return `None` to indicate that there is no matching discriminator present on the input
        custom_error_type: The custom error type to use if the validation fails
        custom_error_message: The custom error message to use if the validation fails
        custom_error_context: The custom error context to use if the validation fails
        strict: Whether the underlying schemas should be validated with strict mode
        from_attributes: Whether to use the attributes of the object to retrieve the discriminator value
        ref: optional unique identifier of the schema, used to reference the schema in other places
        metadata: Any other information you want to include with the schema, not used by pydantic-core
        serialization: Custom serialization schema
    """
    return _dict_not_none(
        type='tagged-union',
        choices=choices,
        discriminator=discriminator,
        custom_error_type=custom_error_type,
        custom_error_message=custom_error_message,
        custom_error_context=custom_error_context,
        strict=strict,
        from_attributes=from_attributes,
        ref=ref,
        metadata=metadata,
        serialization=serialization,
    )

chain_schema

chain_schema(
    steps: list[CoreSchema],
    *,
    ref: str | None = None,
    metadata: dict[str, Any] | None = None,
    serialization: SerSchema | None = None
) -> ChainSchema

返回一个链接提供的验证 schema 的 schema，例如

from pydantic_core import SchemaValidator, core_schema

def fn(v: str, info: core_schema.ValidationInfo) -> str:
    assert 'hello' in v
    return v + ' world'

fn_schema = core_schema.with_info_plain_validator_function(function=fn)
schema = core_schema.chain_schema(
    [fn_schema, fn_schema, fn_schema, core_schema.str_schema()]
)
v = SchemaValidator(schema)
assert v.validate_python('hello') == 'hello world world world'

参数

名称	类型	描述	默认值
steps	list[CoreSchema]	要链接的 schema	必需
ref	str | None	schema 的可选唯一标识符，用于在其他地方引用该 schema	None
metadata	dict[str, Any] | None	您想包含在 schema 中的任何其他信息，pydantic-core 不使用	None
serialization	SerSchema | None	自定义序列化 schema	None

源代码位于 pydantic_core/core_schema.py

def chain_schema(
    steps: list[CoreSchema],
    *,
    ref: str | None = None,
    metadata: dict[str, Any] | None = None,
    serialization: SerSchema | None = None,
) -> ChainSchema:
    """
    Returns a schema that chains the provided validation schemas, e.g.:

    ```py
    from pydantic_core import SchemaValidator, core_schema

    def fn(v: str, info: core_schema.ValidationInfo) -> str:
        assert 'hello' in v
        return v + ' world'

    fn_schema = core_schema.with_info_plain_validator_function(function=fn)
    schema = core_schema.chain_schema(
        [fn_schema, fn_schema, fn_schema, core_schema.str_schema()]
    )
    v = SchemaValidator(schema)
    assert v.validate_python('hello') == 'hello world world world'
    ```

    Args:
        steps: The schemas to chain
        ref: optional unique identifier of the schema, used to reference the schema in other places
        metadata: Any other information you want to include with the schema, not used by pydantic-core
        serialization: Custom serialization schema
    """
    return _dict_not_none(type='chain', steps=steps, ref=ref, metadata=metadata, serialization=serialization)

lax_or_strict_schema

lax_or_strict_schema(
    lax_schema: CoreSchema,
    strict_schema: CoreSchema,
    *,
    strict: bool | None = None,
    ref: str | None = None,
    metadata: dict[str, Any] | None = None,
    serialization: SerSchema | None = None
) -> LaxOrStrictSchema

返回一个使用宽松或严格 schema 的 schema，例如

from pydantic_core import SchemaValidator, core_schema

def fn(v: str, info: core_schema.ValidationInfo) -> str:
    assert 'hello' in v
    return v + ' world'

lax_schema = core_schema.int_schema(strict=False)
strict_schema = core_schema.int_schema(strict=True)

schema = core_schema.lax_or_strict_schema(
    lax_schema=lax_schema, strict_schema=strict_schema, strict=True
)
v = SchemaValidator(schema)
assert v.validate_python(123) == 123

schema = core_schema.lax_or_strict_schema(
    lax_schema=lax_schema, strict_schema=strict_schema, strict=False
)
v = SchemaValidator(schema)
assert v.validate_python('123') == 123

参数

名称	类型	描述	默认值
lax_schema	CoreSchema	要使用的宽松 schema	必需
strict_schema	CoreSchema	要使用的严格 schema	必需
strict	bool | None	是否应使用严格 schema	None
ref	str | None	schema 的可选唯一标识符，用于在其他地方引用该 schema	None
metadata	dict[str, Any] | None	您想包含在 schema 中的任何其他信息，pydantic-core 不使用	None
serialization	SerSchema | None	自定义序列化 schema	None

源代码位于 pydantic_core/core_schema.py

def lax_or_strict_schema(
    lax_schema: CoreSchema,
    strict_schema: CoreSchema,
    *,
    strict: bool | None = None,
    ref: str | None = None,
    metadata: dict[str, Any] | None = None,
    serialization: SerSchema | None = None,
) -> LaxOrStrictSchema:
    """
    Returns a schema that uses the lax or strict schema, e.g.:

    ```py
    from pydantic_core import SchemaValidator, core_schema

    def fn(v: str, info: core_schema.ValidationInfo) -> str:
        assert 'hello' in v
        return v + ' world'

    lax_schema = core_schema.int_schema(strict=False)
    strict_schema = core_schema.int_schema(strict=True)

    schema = core_schema.lax_or_strict_schema(
        lax_schema=lax_schema, strict_schema=strict_schema, strict=True
    )
    v = SchemaValidator(schema)
    assert v.validate_python(123) == 123

    schema = core_schema.lax_or_strict_schema(
        lax_schema=lax_schema, strict_schema=strict_schema, strict=False
    )
    v = SchemaValidator(schema)
    assert v.validate_python('123') == 123
    ```

    Args:
        lax_schema: The lax schema to use
        strict_schema: The strict schema to use
        strict: Whether the strict schema should be used
        ref: optional unique identifier of the schema, used to reference the schema in other places
        metadata: Any other information you want to include with the schema, not used by pydantic-core
        serialization: Custom serialization schema
    """
    return _dict_not_none(
        type='lax-or-strict',
        lax_schema=lax_schema,
        strict_schema=strict_schema,
        strict=strict,
        ref=ref,
        metadata=metadata,
        serialization=serialization,
    )

json_or_python_schema

json_or_python_schema(
    json_schema: CoreSchema,
    python_schema: CoreSchema,
    *,
    ref: str | None = None,
    metadata: dict[str, Any] | None = None,
    serialization: SerSchema | None = None
) -> JsonOrPythonSchema

返回一个根据输入使用 Json 或 Python schema 的 schema

from pydantic_core import SchemaValidator, ValidationError, core_schema

v = SchemaValidator(
    core_schema.json_or_python_schema(
        json_schema=core_schema.int_schema(),
        python_schema=core_schema.int_schema(strict=True),
    )
)

assert v.validate_json('"123"') == 123

try:
    v.validate_python('123')
except ValidationError:
    pass
else:
    raise AssertionError('Validation should have failed')

参数

名称	类型	描述	默认值
json_schema	CoreSchema	用于 Json 输入的 schema	必需
python_schema	CoreSchema	用于 Python 输入的 schema	必需
ref	str | None	schema 的可选唯一标识符，用于在其他地方引用该 schema	None
metadata	dict[str, Any] | None	您想包含在 schema 中的任何其他信息，pydantic-core 不使用	None
serialization	SerSchema | None	自定义序列化 schema	None

源代码位于 pydantic_core/core_schema.py

def json_or_python_schema(
    json_schema: CoreSchema,
    python_schema: CoreSchema,
    *,
    ref: str | None = None,
    metadata: dict[str, Any] | None = None,
    serialization: SerSchema | None = None,
) -> JsonOrPythonSchema:
    """
    Returns a schema that uses the Json or Python schema depending on the input:

    ```py
    from pydantic_core import SchemaValidator, ValidationError, core_schema

    v = SchemaValidator(
        core_schema.json_or_python_schema(
            json_schema=core_schema.int_schema(),
            python_schema=core_schema.int_schema(strict=True),
        )
    )

    assert v.validate_json('"123"') == 123

    try:
        v.validate_python('123')
    except ValidationError:
        pass
    else:
        raise AssertionError('Validation should have failed')
    ```

    Args:
        json_schema: The schema to use for Json inputs
        python_schema: The schema to use for Python inputs
        ref: optional unique identifier of the schema, used to reference the schema in other places
        metadata: Any other information you want to include with the schema, not used by pydantic-core
        serialization: Custom serialization schema
    """
    return _dict_not_none(
        type='json-or-python',
        json_schema=json_schema,
        python_schema=python_schema,
        ref=ref,
        metadata=metadata,
        serialization=serialization,
    )

typed_dict_field

typed_dict_field(
    schema: CoreSchema,
    *,
    required: bool | None = None,
    validation_alias: (
        str | list[str | int] | list[list[str | int]] | None
    ) = None,
    serialization_alias: str | None = None,
    serialization_exclude: bool | None = None,
    metadata: dict[str, Any] | None = None,
    serialization_exclude_if: (
        Callable[[Any], bool] | None
    ) = None
) -> TypedDictField

返回一个匹配 TypedDict 字段的 schema，例如

from pydantic_core import core_schema

field = core_schema.typed_dict_field(schema=core_schema.int_schema(), required=True)

参数

名称	类型	描述	默认值
schema	CoreSchema	用于该字段的 schema	必需
必需	bool | None	字段是否是必需的，否则使用 TypedDict 上的 total 值	None
validation_alias	str | list[str | int] | list[list[str | int]] | None	用于在验证数据中查找字段的别名	None
serialization_alias	str | None	序列化时用作键的别名	None
serialization_exclude	bool | None	序列化时是否排除该字段	None
serialization_exclude_if	Callable[[Any], bool] | None	一个可调用对象，根据其值确定在序列化时是否排除该字段。	None
metadata	dict[str, Any] | None	您想包含在 schema 中的任何其他信息，pydantic-core 不使用	None

源代码位于 pydantic_core/core_schema.py

def typed_dict_field(
    schema: CoreSchema,
    *,
    required: bool | None = None,
    validation_alias: str | list[str | int] | list[list[str | int]] | None = None,
    serialization_alias: str | None = None,
    serialization_exclude: bool | None = None,
    metadata: dict[str, Any] | None = None,
    serialization_exclude_if: Callable[[Any], bool] | None = None,
) -> TypedDictField:
    """
    Returns a schema that matches a typed dict field, e.g.:

    ```py
    from pydantic_core import core_schema

    field = core_schema.typed_dict_field(schema=core_schema.int_schema(), required=True)
    ```

    Args:
        schema: The schema to use for the field
        required: Whether the field is required, otherwise uses the value from `total` on the typed dict
        validation_alias: The alias(es) to use to find the field in the validation data
        serialization_alias: The alias to use as a key when serializing
        serialization_exclude: Whether to exclude the field when serializing
        serialization_exclude_if: A callable that determines whether to exclude the field when serializing based on its value.
        metadata: Any other information you want to include with the schema, not used by pydantic-core
    """
    return _dict_not_none(
        type='typed-dict-field',
        schema=schema,
        required=required,
        validation_alias=validation_alias,
        serialization_alias=serialization_alias,
        serialization_exclude=serialization_exclude,
        serialization_exclude_if=serialization_exclude_if,
        metadata=metadata,
    )

typed_dict_schema

typed_dict_schema(
    fields: dict[str, TypedDictField],
    *,
    cls: type[Any] | None = None,
    cls_name: str | None = None,
    computed_fields: list[ComputedField] | None = None,
    strict: bool | None = None,
    extras_schema: CoreSchema | None = None,
    extra_behavior: ExtraBehavior | None = None,
    total: bool | None = None,
    ref: str | None = None,
    metadata: dict[str, Any] | None = None,
    serialization: SerSchema | None = None,
    config: CoreConfig | None = None
) -> TypedDictSchema

返回一个匹配 TypedDict 的 schema，例如

from typing_extensions import TypedDict

from pydantic_core import SchemaValidator, core_schema

class MyTypedDict(TypedDict):
    a: str

wrapper_schema = core_schema.typed_dict_schema(
    {'a': core_schema.typed_dict_field(core_schema.str_schema())}, cls=MyTypedDict
)
v = SchemaValidator(wrapper_schema)
assert v.validate_python({'a': 'hello'}) == {'a': 'hello'}

参数

名称	类型	描述	默认值
fields	dict[str, TypedDictField]	用于 TypedDict 的字段	必需
cls	type[Any] | None	用于 TypedDict 的类	None
cls_name	str | None	在错误位置中使用的名称。如果未提供类，则回退到 cls.__name__ 或验证器名称。	None
computed_fields	list[ComputedField] | None	在序列化模型时使用的计算字段，仅当直接在模型内部时适用	None
strict	bool | None	TypedDict 是否是严格的	None
extras_schema	CoreSchema | None	用于 TypedDict 的额外验证器	None
ref	str | None	schema 的可选唯一标识符，用于在其他地方引用该 schema	None
metadata	dict[str, Any] | None	您想包含在 schema 中的任何其他信息，pydantic-core 不使用	None
extra_behavior	ExtraBehavior | None	用于 TypedDict 的额外行为	None
total	bool | None	TypedDict 是否是 total 的，否则使用配置中的 typed_dict_total	None
serialization	SerSchema | None	自定义序列化 schema	None

源代码位于 pydantic_core/core_schema.py

def typed_dict_schema(
    fields: dict[str, TypedDictField],
    *,
    cls: type[Any] | None = None,
    cls_name: str | None = None,
    computed_fields: list[ComputedField] | None = None,
    strict: bool | None = None,
    extras_schema: CoreSchema | None = None,
    extra_behavior: ExtraBehavior | None = None,
    total: bool | None = None,
    ref: str | None = None,
    metadata: dict[str, Any] | None = None,
    serialization: SerSchema | None = None,
    config: CoreConfig | None = None,
) -> TypedDictSchema:
    """
    Returns a schema that matches a typed dict, e.g.:

    ```py
    from typing_extensions import TypedDict

    from pydantic_core import SchemaValidator, core_schema

    class MyTypedDict(TypedDict):
        a: str

    wrapper_schema = core_schema.typed_dict_schema(
        {'a': core_schema.typed_dict_field(core_schema.str_schema())}, cls=MyTypedDict
    )
    v = SchemaValidator(wrapper_schema)
    assert v.validate_python({'a': 'hello'}) == {'a': 'hello'}
    ```

    Args:
        fields: The fields to use for the typed dict
        cls: The class to use for the typed dict
        cls_name: The name to use in error locations. Falls back to `cls.__name__`, or the validator name if no class
            is provided.
        computed_fields: Computed fields to use when serializing the model, only applies when directly inside a model
        strict: Whether the typed dict is strict
        extras_schema: The extra validator to use for the typed dict
        ref: optional unique identifier of the schema, used to reference the schema in other places
        metadata: Any other information you want to include with the schema, not used by pydantic-core
        extra_behavior: The extra behavior to use for the typed dict
        total: Whether the typed dict is total, otherwise uses `typed_dict_total` from config
        serialization: Custom serialization schema
    """
    return _dict_not_none(
        type='typed-dict',
        fields=fields,
        cls=cls,
        cls_name=cls_name,
        computed_fields=computed_fields,
        strict=strict,
        extras_schema=extras_schema,
        extra_behavior=extra_behavior,
        total=total,
        ref=ref,
        metadata=metadata,
        serialization=serialization,
        config=config,
    )

model_field

model_field(
    schema: CoreSchema,
    *,
    validation_alias: (
        str | list[str | int] | list[list[str | int]] | None
    ) = None,
    serialization_alias: str | None = None,
    serialization_exclude: bool | None = None,
    serialization_exclude_if: (
        Callable[[Any], bool] | None
    ) = None,
    frozen: bool | None = None,
    metadata: dict[str, Any] | None = None
) -> ModelField

返回模型字段的 schema，例如

from pydantic_core import core_schema

field = core_schema.model_field(schema=core_schema.int_schema())

参数

名称	类型	描述	默认值
schema	CoreSchema	用于该字段的 schema	必需
validation_alias	str | list[str | int] | list[list[str | int]] | None	用于在验证数据中查找字段的别名	None
serialization_alias	str | None	序列化时用作键的别名	None
serialization_exclude	bool | None	序列化时是否排除该字段	None
serialization_exclude_if	Callable[[Any], bool] | None	一个可调用对象，根据字段的值确定在序列化期间是否排除该字段。	None
frozen	bool | None	字段是否被冻结	None
metadata	dict[str, Any] | None	您想包含在 schema 中的任何其他信息，pydantic-core 不使用	None

源代码位于 pydantic_core/core_schema.py

def model_field(
    schema: CoreSchema,
    *,
    validation_alias: str | list[str | int] | list[list[str | int]] | None = None,
    serialization_alias: str | None = None,
    serialization_exclude: bool | None = None,
    serialization_exclude_if: Callable[[Any], bool] | None = None,
    frozen: bool | None = None,
    metadata: dict[str, Any] | None = None,
) -> ModelField:
    """
    Returns a schema for a model field, e.g.:

    ```py
    from pydantic_core import core_schema

    field = core_schema.model_field(schema=core_schema.int_schema())
    ```

    Args:
        schema: The schema to use for the field
        validation_alias: The alias(es) to use to find the field in the validation data
        serialization_alias: The alias to use as a key when serializing
        serialization_exclude: Whether to exclude the field when serializing
        serialization_exclude_if: A Callable that determines whether to exclude a field during serialization based on its value.
        frozen: Whether the field is frozen
        metadata: Any other information you want to include with the schema, not used by pydantic-core
    """
    return _dict_not_none(
        type='model-field',
        schema=schema,
        validation_alias=validation_alias,
        serialization_alias=serialization_alias,
        serialization_exclude=serialization_exclude,
        serialization_exclude_if=serialization_exclude_if,
        frozen=frozen,
        metadata=metadata,
    )

model_fields_schema

model_fields_schema(
    fields: dict[str, ModelField],
    *,
    model_name: str | None = None,
    computed_fields: list[ComputedField] | None = None,
    strict: bool | None = None,
    extras_schema: CoreSchema | None = None,
    extras_keys_schema: CoreSchema | None = None,
    extra_behavior: ExtraBehavior | None = None,
    from_attributes: bool | None = None,
    ref: str | None = None,
    metadata: dict[str, Any] | None = None,
    serialization: SerSchema | None = None
) -> ModelFieldsSchema

返回一个匹配 Pydantic 模型字段的 schema，例如

from pydantic_core import SchemaValidator, core_schema

wrapper_schema = core_schema.model_fields_schema(
    {'a': core_schema.model_field(core_schema.str_schema())}
)
v = SchemaValidator(wrapper_schema)
print(v.validate_python({'a': 'hello'}))
#> ({'a': 'hello'}, None, {'a'})

参数

名称	类型	描述	默认值
fields	dict[str, ModelField]	模型的字段	必需
model_name	str | None	模型的名称，用于错误消息，默认为 "Model"	None
computed_fields	list[ComputedField] | None	在序列化模型时使用的计算字段，仅当直接在模型内部时适用	None
strict	bool | None	模型是否是严格的	None
extras_schema	CoreSchema | None	在验证额外输入数据时使用的 schema	None
extras_keys_schema	CoreSchema | None	在验证额外输入数据的键时使用的 schema	None
ref	str | None	schema 的可选唯一标识符，用于在其他地方引用该 schema	None
metadata	dict[str, Any] | None	您想包含在 schema 中的任何其他信息，pydantic-core 不使用	None
extra_behavior	ExtraBehavior | None	用于模型字段的额外行为	None
from_attributes	bool | None	模型字段是否应从属性中填充	None
serialization	SerSchema | None	自定义序列化 schema	None

源代码位于 pydantic_core/core_schema.py

def model_fields_schema(
    fields: dict[str, ModelField],
    *,
    model_name: str | None = None,
    computed_fields: list[ComputedField] | None = None,
    strict: bool | None = None,
    extras_schema: CoreSchema | None = None,
    extras_keys_schema: CoreSchema | None = None,
    extra_behavior: ExtraBehavior | None = None,
    from_attributes: bool | None = None,
    ref: str | None = None,
    metadata: dict[str, Any] | None = None,
    serialization: SerSchema | None = None,
) -> ModelFieldsSchema:
    """
    Returns a schema that matches the fields of a Pydantic model, e.g.:

    ```py
    from pydantic_core import SchemaValidator, core_schema

    wrapper_schema = core_schema.model_fields_schema(
        {'a': core_schema.model_field(core_schema.str_schema())}
    )
    v = SchemaValidator(wrapper_schema)
    print(v.validate_python({'a': 'hello'}))
    #> ({'a': 'hello'}, None, {'a'})
    ```

    Args:
        fields: The fields of the model
        model_name: The name of the model, used for error messages, defaults to "Model"
        computed_fields: Computed fields to use when serializing the model, only applies when directly inside a model
        strict: Whether the model is strict
        extras_schema: The schema to use when validating extra input data
        extras_keys_schema: The schema to use when validating the keys of extra input data
        ref: optional unique identifier of the schema, used to reference the schema in other places
        metadata: Any other information you want to include with the schema, not used by pydantic-core
        extra_behavior: The extra behavior to use for the model fields
        from_attributes: Whether the model fields should be populated from attributes
        serialization: Custom serialization schema
    """
    return _dict_not_none(
        type='model-fields',
        fields=fields,
        model_name=model_name,
        computed_fields=computed_fields,
        strict=strict,
        extras_schema=extras_schema,
        extras_keys_schema=extras_keys_schema,
        extra_behavior=extra_behavior,
        from_attributes=from_attributes,
        ref=ref,
        metadata=metadata,
        serialization=serialization,
    )

model_schema

model_schema(
    cls: type[Any],
    schema: CoreSchema,
    *,
    generic_origin: type[Any] | None = None,
    custom_init: bool | None = None,
    root_model: bool | None = None,
    post_init: str | None = None,
    revalidate_instances: (
        Literal["always", "never", "subclass-instances"]
        | None
    ) = None,
    strict: bool | None = None,
    frozen: bool | None = None,
    extra_behavior: ExtraBehavior | None = None,
    config: CoreConfig | None = None,
    ref: str | None = None,
    metadata: dict[str, Any] | None = None,
    serialization: SerSchema | None = None
) -> ModelSchema

模型 schema 通常包含一个 TypedDict schema。它将运行 TypedDict 验证器，然后创建一个新类，并将从 TypedDict 验证器返回的字典和字段集分别设置到 __dict__ 和 __pydantic_fields_set__。

示例

from pydantic_core import CoreConfig, SchemaValidator, core_schema

class MyModel:
    __slots__ = (
        '__dict__',
        '__pydantic_fields_set__',
        '__pydantic_extra__',
        '__pydantic_private__',
    )

schema = core_schema.model_schema(
    cls=MyModel,
    config=CoreConfig(str_max_length=5),
    schema=core_schema.model_fields_schema(
        fields={'a': core_schema.model_field(core_schema.str_schema())},
    ),
)
v = SchemaValidator(schema)
assert v.isinstance_python({'a': 'hello'}) is True
assert v.isinstance_python({'a': 'too long'}) is False

参数

名称	类型	描述	默认值
cls	type[Any]	用于模型的类	必需
schema	CoreSchema	用于模型的 schema	必需
generic_origin	type[Any] | None	用于此模型的原始类型，如果它是一个参数化的泛型。例如，如果此模型 schema 代表 SomeModel[int]，则 generic_origin 是 SomeModel	None
custom_init	bool | None	模型是否有自定义的 init 方法	None
root_model	bool | None	模型是否是 RootModel	None
post_init	str | None	用于模型的初始化后调用	None
revalidate_instances	Literal['always', 'never', 'subclass-instances'] | None	模型和数据类的实例（包括子类实例）是否应重新验证，默认为 config.revalidate_instances，否则为 'never'	None
strict	bool | None	模型是否是严格的	None
frozen	bool | None	模型是否被冻结	None
extra_behavior	ExtraBehavior | None	用于模型的额外行为，在序列化中使用	None
config	CoreConfig | None	用于模型的配置	None
ref	str | None	schema 的可选唯一标识符，用于在其他地方引用该 schema	None
metadata	dict[str, Any] | None	您想包含在 schema 中的任何其他信息，pydantic-core 不使用	None
serialization	SerSchema | None	自定义序列化 schema	None

源代码位于 pydantic_core/core_schema.py

def model_schema(
    cls: type[Any],
    schema: CoreSchema,
    *,
    generic_origin: type[Any] | None = None,
    custom_init: bool | None = None,
    root_model: bool | None = None,
    post_init: str | None = None,
    revalidate_instances: Literal['always', 'never', 'subclass-instances'] | None = None,
    strict: bool | None = None,
    frozen: bool | None = None,
    extra_behavior: ExtraBehavior | None = None,
    config: CoreConfig | None = None,
    ref: str | None = None,
    metadata: dict[str, Any] | None = None,
    serialization: SerSchema | None = None,
) -> ModelSchema:
    """
    A model schema generally contains a typed-dict schema.
    It will run the typed dict validator, then create a new class
    and set the dict and fields set returned from the typed dict validator
    to `__dict__` and `__pydantic_fields_set__` respectively.

    Example:

    ```py
    from pydantic_core import CoreConfig, SchemaValidator, core_schema

    class MyModel:
        __slots__ = (
            '__dict__',
            '__pydantic_fields_set__',
            '__pydantic_extra__',
            '__pydantic_private__',
        )

    schema = core_schema.model_schema(
        cls=MyModel,
        config=CoreConfig(str_max_length=5),
        schema=core_schema.model_fields_schema(
            fields={'a': core_schema.model_field(core_schema.str_schema())},
        ),
    )
    v = SchemaValidator(schema)
    assert v.isinstance_python({'a': 'hello'}) is True
    assert v.isinstance_python({'a': 'too long'}) is False
    ```

    Args:
        cls: The class to use for the model
        schema: The schema to use for the model
        generic_origin: The origin type used for this model, if it's a parametrized generic. Ex,
            if this model schema represents `SomeModel[int]`, generic_origin is `SomeModel`
        custom_init: Whether the model has a custom init method
        root_model: Whether the model is a `RootModel`
        post_init: The call after init to use for the model
        revalidate_instances: whether instances of models and dataclasses (including subclass instances)
            should re-validate defaults to config.revalidate_instances, else 'never'
        strict: Whether the model is strict
        frozen: Whether the model is frozen
        extra_behavior: The extra behavior to use for the model, used in serialization
        config: The config to use for the model
        ref: optional unique identifier of the schema, used to reference the schema in other places
        metadata: Any other information you want to include with the schema, not used by pydantic-core
        serialization: Custom serialization schema
    """
    return _dict_not_none(
        type='model',
        cls=cls,
        generic_origin=generic_origin,
        schema=schema,
        custom_init=custom_init,
        root_model=root_model,
        post_init=post_init,
        revalidate_instances=revalidate_instances,
        strict=strict,
        frozen=frozen,
        extra_behavior=extra_behavior,
        config=config,
        ref=ref,
        metadata=metadata,
        serialization=serialization,
    )

dataclass_field

dataclass_field(
    name: str,
    schema: CoreSchema,
    *,
    kw_only: bool | None = None,
    init: bool | None = None,
    init_only: bool | None = None,
    validation_alias: (
        str | list[str | int] | list[list[str | int]] | None
    ) = None,
    serialization_alias: str | None = None,
    serialization_exclude: bool | None = None,
    metadata: dict[str, Any] | None = None,
    serialization_exclude_if: (
        Callable[[Any], bool] | None
    ) = None,
    frozen: bool | None = None
) -> DataclassField

返回数据类字段的 schema，例如

from pydantic_core import SchemaValidator, core_schema

field = core_schema.dataclass_field(
    name='a', schema=core_schema.str_schema(), kw_only=False
)
schema = core_schema.dataclass_args_schema('Foobar', [field])
v = SchemaValidator(schema)
assert v.validate_python({'a': 'hello'}) == ({'a': 'hello'}, None)

参数

名称	类型	描述	默认值
name	str	用于参数的名称	必需
schema	CoreSchema	用于参数的 schema	必需
kw_only	bool | None	字段是否可以用位置参数和关键字参数设置	None
init	bool | None	字段是否应在初始化期间进行验证	None
init_only	bool | None	字段是否应从 __dict__ 中省略并传递给 __post_init__	None
validation_alias	str | list[str | int] | list[list[str | int]] | None	用于在验证数据中查找字段的别名	None
serialization_alias	str | None	序列化时用作键的别名	None
serialization_exclude	bool | None	序列化时是否排除该字段	None
serialization_exclude_if	Callable[[Any], bool] | None	一个可调用对象，根据其值确定在序列化时是否排除该字段。	None
metadata	dict[str, Any] | None	您想包含在 schema 中的任何其他信息，pydantic-core 不使用	None
frozen	bool | None	字段是否被冻结	None

源代码位于 pydantic_core/core_schema.py

def dataclass_field(
    name: str,
    schema: CoreSchema,
    *,
    kw_only: bool | None = None,
    init: bool | None = None,
    init_only: bool | None = None,
    validation_alias: str | list[str | int] | list[list[str | int]] | None = None,
    serialization_alias: str | None = None,
    serialization_exclude: bool | None = None,
    metadata: dict[str, Any] | None = None,
    serialization_exclude_if: Callable[[Any], bool] | None = None,
    frozen: bool | None = None,
) -> DataclassField:
    """
    Returns a schema for a dataclass field, e.g.:

    ```py
    from pydantic_core import SchemaValidator, core_schema

    field = core_schema.dataclass_field(
        name='a', schema=core_schema.str_schema(), kw_only=False
    )
    schema = core_schema.dataclass_args_schema('Foobar', [field])
    v = SchemaValidator(schema)
    assert v.validate_python({'a': 'hello'}) == ({'a': 'hello'}, None)
    ```

    Args:
        name: The name to use for the argument parameter
        schema: The schema to use for the argument parameter
        kw_only: Whether the field can be set with a positional argument as well as a keyword argument
        init: Whether the field should be validated during initialization
        init_only: Whether the field should be omitted  from `__dict__` and passed to `__post_init__`
        validation_alias: The alias(es) to use to find the field in the validation data
        serialization_alias: The alias to use as a key when serializing
        serialization_exclude: Whether to exclude the field when serializing
        serialization_exclude_if: A callable that determines whether to exclude the field when serializing based on its value.
        metadata: Any other information you want to include with the schema, not used by pydantic-core
        frozen: Whether the field is frozen
    """
    return _dict_not_none(
        type='dataclass-field',
        name=name,
        schema=schema,
        kw_only=kw_only,
        init=init,
        init_only=init_only,
        validation_alias=validation_alias,
        serialization_alias=serialization_alias,
        serialization_exclude=serialization_exclude,
        serialization_exclude_if=serialization_exclude_if,
        metadata=metadata,
        frozen=frozen,
    )

dataclass_args_schema

dataclass_args_schema(
    dataclass_name: str,
    fields: list[DataclassField],
    *,
    computed_fields: list[ComputedField] | None = None,
    collect_init_only: bool | None = None,
    ref: str | None = None,
    metadata: dict[str, Any] | None = None,
    serialization: SerSchema | None = None,
    extra_behavior: ExtraBehavior | None = None
) -> DataclassArgsSchema

返回用于验证数据类参数的 schema，例如

from pydantic_core import SchemaValidator, core_schema

field_a = core_schema.dataclass_field(
    name='a', schema=core_schema.str_schema(), kw_only=False
)
field_b = core_schema.dataclass_field(
    name='b', schema=core_schema.bool_schema(), kw_only=False
)
schema = core_schema.dataclass_args_schema('Foobar', [field_a, field_b])
v = SchemaValidator(schema)
assert v.validate_python({'a': 'hello', 'b': True}) == ({'a': 'hello', 'b': True}, None)

参数

名称	类型	描述	默认值
dataclass_name	str	正在验证的数据类的名称	必需
fields	list[DataclassField]	用于数据类的字段	必需
computed_fields	list[ComputedField] | None	在序列化数据类时使用的计算字段	None
collect_init_only	bool | None	是否将仅初始化的字段收集到一个字典中以传递给 __post_init__	None
ref	str | None	schema 的可选唯一标识符，用于在其他地方引用该 schema	None
metadata	dict[str, Any] | None	您想包含在 schema 中的任何其他信息，pydantic-core 不使用	None
serialization	SerSchema | None	自定义序列化 schema	None
extra_behavior	ExtraBehavior | None	如何处理额外字段	None

源代码位于 pydantic_core/core_schema.py

def dataclass_args_schema(
    dataclass_name: str,
    fields: list[DataclassField],
    *,
    computed_fields: list[ComputedField] | None = None,
    collect_init_only: bool | None = None,
    ref: str | None = None,
    metadata: dict[str, Any] | None = None,
    serialization: SerSchema | None = None,
    extra_behavior: ExtraBehavior | None = None,
) -> DataclassArgsSchema:
    """
    Returns a schema for validating dataclass arguments, e.g.:

    ```py
    from pydantic_core import SchemaValidator, core_schema

    field_a = core_schema.dataclass_field(
        name='a', schema=core_schema.str_schema(), kw_only=False
    )
    field_b = core_schema.dataclass_field(
        name='b', schema=core_schema.bool_schema(), kw_only=False
    )
    schema = core_schema.dataclass_args_schema('Foobar', [field_a, field_b])
    v = SchemaValidator(schema)
    assert v.validate_python({'a': 'hello', 'b': True}) == ({'a': 'hello', 'b': True}, None)
    ```

    Args:
        dataclass_name: The name of the dataclass being validated
        fields: The fields to use for the dataclass
        computed_fields: Computed fields to use when serializing the dataclass
        collect_init_only: Whether to collect init only fields into a dict to pass to `__post_init__`
        ref: optional unique identifier of the schema, used to reference the schema in other places
        metadata: Any other information you want to include with the schema, not used by pydantic-core
        serialization: Custom serialization schema
        extra_behavior: How to handle extra fields
    """
    return _dict_not_none(
        type='dataclass-args',
        dataclass_name=dataclass_name,
        fields=fields,
        computed_fields=computed_fields,
        collect_init_only=collect_init_only,
        ref=ref,
        metadata=metadata,
        serialization=serialization,
        extra_behavior=extra_behavior,
    )

dataclass_schema

dataclass_schema(
    cls: type[Any],
    schema: CoreSchema,
    fields: list[str],
    *,
    generic_origin: type[Any] | None = None,
    cls_name: str | None = None,
    post_init: bool | None = None,
    revalidate_instances: (
        Literal["always", "never", "subclass-instances"]
        | None
    ) = None,
    strict: bool | None = None,
    ref: str | None = None,
    metadata: dict[str, Any] | None = None,
    serialization: SerSchema | None = None,
    frozen: bool | None = None,
    slots: bool | None = None,
    config: CoreConfig | None = None
) -> DataclassSchema

返回数据类的 schema。与 ModelSchema 一样，此 schema 只能用作另一个 schema 中的字段，不能作为根类型。

参数

名称	类型	描述	默认值
cls	type[Any]	数据类类型，用于执行子类检查	必需
schema	CoreSchema	用于数据类字段的 schema	必需
fields	list[str]	数据类的字段，这在序列化和重新验证以及验证赋值时使用	必需
generic_origin	type[Any] | None	用于此数据类的原始类型，如果它是一个参数化的泛型。例如，如果此模型 schema 代表 SomeDataclass[int]，则 generic_origin 是 SomeDataclass	None
cls_name	str | None	在错误位置等中使用的名称；这对于泛型很有用（默认：cls.__name__）	None
post_init	bool | None	是否在验证后调用 __post_init__	None
revalidate_instances	Literal['always', 'never', 'subclass-instances'] | None	模型和数据类的实例（包括子类实例）是否应重新验证，默认为 config.revalidate_instances，否则为 'never'	None
strict	bool | None	是否需要 cls 的确切实例	None
ref	str | None	schema 的可选唯一标识符，用于在其他地方引用该 schema	None
metadata	dict[str, Any] | None	您想包含在 schema 中的任何其他信息，pydantic-core 不使用	None
serialization	SerSchema | None	自定义序列化 schema	None
frozen	bool | None	数据类是否被冻结	None
slots	bool | None	数据类上是否设置了 slots=True，意味着每个字段都独立赋值，而不是简单地设置 __dict__，默认为 false	None

源代码位于 pydantic_core/core_schema.py

def dataclass_schema(
    cls: type[Any],
    schema: CoreSchema,
    fields: list[str],
    *,
    generic_origin: type[Any] | None = None,
    cls_name: str | None = None,
    post_init: bool | None = None,
    revalidate_instances: Literal['always', 'never', 'subclass-instances'] | None = None,
    strict: bool | None = None,
    ref: str | None = None,
    metadata: dict[str, Any] | None = None,
    serialization: SerSchema | None = None,
    frozen: bool | None = None,
    slots: bool | None = None,
    config: CoreConfig | None = None,
) -> DataclassSchema:
    """
    Returns a schema for a dataclass. As with `ModelSchema`, this schema can only be used as a field within
    another schema, not as the root type.

    Args:
        cls: The dataclass type, used to perform subclass checks
        schema: The schema to use for the dataclass fields
        fields: Fields of the dataclass, this is used in serialization and in validation during re-validation
            and while validating assignment
        generic_origin: The origin type used for this dataclass, if it's a parametrized generic. Ex,
            if this model schema represents `SomeDataclass[int]`, generic_origin is `SomeDataclass`
        cls_name: The name to use in error locs, etc; this is useful for generics (default: `cls.__name__`)
        post_init: Whether to call `__post_init__` after validation
        revalidate_instances: whether instances of models and dataclasses (including subclass instances)
            should re-validate defaults to config.revalidate_instances, else 'never'
        strict: Whether to require an exact instance of `cls`
        ref: optional unique identifier of the schema, used to reference the schema in other places
        metadata: Any other information you want to include with the schema, not used by pydantic-core
        serialization: Custom serialization schema
        frozen: Whether the dataclass is frozen
        slots: Whether `slots=True` on the dataclass, means each field is assigned independently, rather than
            simply setting `__dict__`, default false
    """
    return _dict_not_none(
        type='dataclass',
        cls=cls,
        generic_origin=generic_origin,
        fields=fields,
        cls_name=cls_name,
        schema=schema,
        post_init=post_init,
        revalidate_instances=revalidate_instances,
        strict=strict,
        ref=ref,
        metadata=metadata,
        serialization=serialization,
        frozen=frozen,
        slots=slots,
        config=config,
    )

arguments_parameter

arguments_parameter(
    name: str,
    schema: CoreSchema,
    *,
    mode: (
        Literal[
            "positional_only",
            "positional_or_keyword",
            "keyword_only",
        ]
        | None
    ) = None,
    alias: (
        str | list[str | int] | list[list[str | int]] | None
    ) = None
) -> ArgumentsParameter

返回一个匹配参数的 schema，例如

from pydantic_core import SchemaValidator, core_schema

param = core_schema.arguments_parameter(
    name='a', schema=core_schema.str_schema(), mode='positional_only'
)
schema = core_schema.arguments_schema([param])
v = SchemaValidator(schema)
assert v.validate_python(('hello',)) == (('hello',), {})

参数

名称	类型	描述	默认值
name	str	用于参数的名称	必需
schema	CoreSchema	用于参数的 schema	必需
mode	Literal['positional_only', 'positional_or_keyword', 'keyword_only'] | None	用于参数的模式	None
alias	str | list[str | int] | list[list[str | int]] | None	用于参数的别名	None

源代码位于 pydantic_core/core_schema.py

def arguments_parameter(
    name: str,
    schema: CoreSchema,
    *,
    mode: Literal['positional_only', 'positional_or_keyword', 'keyword_only'] | None = None,
    alias: str | list[str | int] | list[list[str | int]] | None = None,
) -> ArgumentsParameter:
    """
    Returns a schema that matches an argument parameter, e.g.:

    ```py
    from pydantic_core import SchemaValidator, core_schema

    param = core_schema.arguments_parameter(
        name='a', schema=core_schema.str_schema(), mode='positional_only'
    )
    schema = core_schema.arguments_schema([param])
    v = SchemaValidator(schema)
    assert v.validate_python(('hello',)) == (('hello',), {})
    ```

    Args:
        name: The name to use for the argument parameter
        schema: The schema to use for the argument parameter
        mode: The mode to use for the argument parameter
        alias: The alias to use for the argument parameter
    """
    return _dict_not_none(name=name, schema=schema, mode=mode, alias=alias)

arguments_schema

arguments_schema(
    arguments: list[ArgumentsParameter],
    *,
    validate_by_name: bool | None = None,
    validate_by_alias: bool | None = None,
    var_args_schema: CoreSchema | None = None,
    var_kwargs_mode: VarKwargsMode | None = None,
    var_kwargs_schema: CoreSchema | None = None,
    ref: str | None = None,
    metadata: dict[str, Any] | None = None,
    serialization: SerSchema | None = None
) -> ArgumentsSchema

返回一个匹配参数 schema 的 schema，例如

from pydantic_core import SchemaValidator, core_schema

param_a = core_schema.arguments_parameter(
    name='a', schema=core_schema.str_schema(), mode='positional_only'
)
param_b = core_schema.arguments_parameter(
    name='b', schema=core_schema.bool_schema(), mode='positional_only'
)
schema = core_schema.arguments_schema([param_a, param_b])
v = SchemaValidator(schema)
assert v.validate_python(('hello', True)) == (('hello', True), {})

参数

名称	类型	描述	默认值
arguments	list[ArgumentsParameter]	用于参数 schema 的参数	必需
validate_by_name	bool | None	是否按参数名称填充，默认为 False。	None
validate_by_alias	bool | None	是否按参数别名填充，默认为 True。	None
var_args_schema	CoreSchema | None	用于参数 schema 的可变参数 schema	None
var_kwargs_mode	VarKwargsMode | None	用于可变关键字参数的验证模式。如果为 'uniform'，则关键字参数的每个值都将根据 var_kwargs_schema schema进行验证。如果为 'unpacked-typed-dict'，则 var_kwargs_schema 参数必须是 typed_dict_schema	None
var_kwargs_schema	CoreSchema | None	用于参数 schema 的可变关键字参数 schema	None
ref	str | None	schema 的可选唯一标识符，用于在其他地方引用该 schema	None
metadata	dict[str, Any] | None	您想包含在 schema 中的任何其他信息，pydantic-core 不使用	None
serialization	SerSchema | None	自定义序列化 schema	None

源代码位于 pydantic_core/core_schema.py

def arguments_schema(
    arguments: list[ArgumentsParameter],
    *,
    validate_by_name: bool | None = None,
    validate_by_alias: bool | None = None,
    var_args_schema: CoreSchema | None = None,
    var_kwargs_mode: VarKwargsMode | None = None,
    var_kwargs_schema: CoreSchema | None = None,
    ref: str | None = None,
    metadata: dict[str, Any] | None = None,
    serialization: SerSchema | None = None,
) -> ArgumentsSchema:
    """
    Returns a schema that matches an arguments schema, e.g.:

    ```py
    from pydantic_core import SchemaValidator, core_schema

    param_a = core_schema.arguments_parameter(
        name='a', schema=core_schema.str_schema(), mode='positional_only'
    )
    param_b = core_schema.arguments_parameter(
        name='b', schema=core_schema.bool_schema(), mode='positional_only'
    )
    schema = core_schema.arguments_schema([param_a, param_b])
    v = SchemaValidator(schema)
    assert v.validate_python(('hello', True)) == (('hello', True), {})
    ```

    Args:
        arguments: The arguments to use for the arguments schema
        validate_by_name: Whether to populate by the parameter names, defaults to `False`.
        validate_by_alias: Whether to populate by the parameter aliases, defaults to `True`.
        var_args_schema: The variable args schema to use for the arguments schema
        var_kwargs_mode: The validation mode to use for variadic keyword arguments. If `'uniform'`, every value of the
            keyword arguments will be validated against the `var_kwargs_schema` schema. If `'unpacked-typed-dict'`,
            the `var_kwargs_schema` argument must be a [`typed_dict_schema`][pydantic_core.core_schema.typed_dict_schema]
        var_kwargs_schema: The variable kwargs schema to use for the arguments schema
        ref: optional unique identifier of the schema, used to reference the schema in other places
        metadata: Any other information you want to include with the schema, not used by pydantic-core
        serialization: Custom serialization schema
    """
    return _dict_not_none(
        type='arguments',
        arguments_schema=arguments,
        validate_by_name=validate_by_name,
        validate_by_alias=validate_by_alias,
        var_args_schema=var_args_schema,
        var_kwargs_mode=var_kwargs_mode,
        var_kwargs_schema=var_kwargs_schema,
        ref=ref,
        metadata=metadata,
        serialization=serialization,
    )

arguments_v3_parameter

arguments_v3_parameter(
    name: str,
    schema: CoreSchema,
    *,
    mode: (
        Literal[
            "positional_only",
            "positional_or_keyword",
            "keyword_only",
            "var_args",
            "var_kwargs_uniform",
            "var_kwargs_unpacked_typed_dict",
        ]
        | None
    ) = None,
    alias: (
        str | list[str | int] | list[list[str | int]] | None
    ) = None
) -> ArgumentsV3Parameter

返回一个匹配参数的 schema，例如

from pydantic_core import SchemaValidator, core_schema

param = core_schema.arguments_v3_parameter(
    name='a', schema=core_schema.str_schema(), mode='positional_only'
)
schema = core_schema.arguments_v3_schema([param])
v = SchemaValidator(schema)
assert v.validate_python({'a': 'hello'}) == (('hello',), {})

参数

名称	类型	描述	默认值
name	str	用于参数的名称	必需
schema	CoreSchema	用于参数的 schema	必需
mode	Literal['positional_only', 'positional_or_keyword', 'keyword_only', 'var_args', 'var_kwargs_uniform', 'var_kwargs_unpacked_typed_dict'] | None	用于参数的模式	None
alias	str | list[str | int] | list[list[str | int]] | None	用于参数的别名	None

源代码位于 pydantic_core/core_schema.py

def arguments_v3_parameter(
    name: str,
    schema: CoreSchema,
    *,
    mode: Literal[
        'positional_only',
        'positional_or_keyword',
        'keyword_only',
        'var_args',
        'var_kwargs_uniform',
        'var_kwargs_unpacked_typed_dict',
    ]
    | None = None,
    alias: str | list[str | int] | list[list[str | int]] | None = None,
) -> ArgumentsV3Parameter:
    """
    Returns a schema that matches an argument parameter, e.g.:

    ```py
    from pydantic_core import SchemaValidator, core_schema

    param = core_schema.arguments_v3_parameter(
        name='a', schema=core_schema.str_schema(), mode='positional_only'
    )
    schema = core_schema.arguments_v3_schema([param])
    v = SchemaValidator(schema)
    assert v.validate_python({'a': 'hello'}) == (('hello',), {})
    ```

    Args:
        name: The name to use for the argument parameter
        schema: The schema to use for the argument parameter
        mode: The mode to use for the argument parameter
        alias: The alias to use for the argument parameter
    """
    return _dict_not_none(name=name, schema=schema, mode=mode, alias=alias)

arguments_v3_schema

arguments_v3_schema(
    arguments: list[ArgumentsV3Parameter],
    *,
    validate_by_name: bool | None = None,
    validate_by_alias: bool | None = None,
    extra_behavior: (
        Literal["forbid", "ignore"] | None
    ) = None,
    ref: str | None = None,
    metadata: dict[str, Any] | None = None,
    serialization: SerSchema | None = None
) -> ArgumentsV3Schema

返回一个匹配参数 schema 的 schema，例如

from pydantic_core import SchemaValidator, core_schema

param_a = core_schema.arguments_v3_parameter(
    name='a', schema=core_schema.str_schema(), mode='positional_only'
)
param_b = core_schema.arguments_v3_parameter(
    name='kwargs', schema=core_schema.bool_schema(), mode='var_kwargs_uniform'
)
schema = core_schema.arguments_v3_schema([param_a, param_b])
v = SchemaValidator(schema)
assert v.validate_python({'a': 'hi', 'kwargs': {'b': True}}) == (('hi',), {'b': True})

此 schema 目前未被其他 Pydantic 组件使用。在 V3 中，它很可能成为 'call' schema 的默认参数 schema。

参数

名称	类型	描述	默认值
arguments	list[ArgumentsV3Parameter]	用于参数 schema 的参数。	必需
validate_by_name	bool | None	是否按参数名称填充，默认为 False。	None
validate_by_alias	bool | None	是否按参数别名填充，默认为 True。	None
extra_behavior	Literal['forbid', 'ignore'] | None	要使用的额外行为。	None
ref	str | None	schema 的可选唯一标识符，用于在其他地方引用该 schema。	None
metadata	dict[str, Any] | None	您想包含在 schema 中的任何其他信息，pydantic-core 不使用。	None
serialization	SerSchema | None	自定义序列化 schema。	None

源代码位于 pydantic_core/core_schema.py

def arguments_v3_schema(
    arguments: list[ArgumentsV3Parameter],
    *,
    validate_by_name: bool | None = None,
    validate_by_alias: bool | None = None,
    extra_behavior: Literal['forbid', 'ignore'] | None = None,
    ref: str | None = None,
    metadata: dict[str, Any] | None = None,
    serialization: SerSchema | None = None,
) -> ArgumentsV3Schema:
    """
    Returns a schema that matches an arguments schema, e.g.:

    ```py
    from pydantic_core import SchemaValidator, core_schema

    param_a = core_schema.arguments_v3_parameter(
        name='a', schema=core_schema.str_schema(), mode='positional_only'
    )
    param_b = core_schema.arguments_v3_parameter(
        name='kwargs', schema=core_schema.bool_schema(), mode='var_kwargs_uniform'
    )
    schema = core_schema.arguments_v3_schema([param_a, param_b])
    v = SchemaValidator(schema)
    assert v.validate_python({'a': 'hi', 'kwargs': {'b': True}}) == (('hi',), {'b': True})
    ```

    This schema is currently not used by other Pydantic components. In V3, it will most likely
    become the default arguments schema for the `'call'` schema.

    Args:
        arguments: The arguments to use for the arguments schema.
        validate_by_name: Whether to populate by the parameter names, defaults to `False`.
        validate_by_alias: Whether to populate by the parameter aliases, defaults to `True`.
        extra_behavior: The extra behavior to use.
        ref: optional unique identifier of the schema, used to reference the schema in other places.
        metadata: Any other information you want to include with the schema, not used by pydantic-core.
        serialization: Custom serialization schema.
    """
    return _dict_not_none(
        type='arguments-v3',
        arguments_schema=arguments,
        validate_by_name=validate_by_name,
        validate_by_alias=validate_by_alias,
        extra_behavior=extra_behavior,
        ref=ref,
        metadata=metadata,
        serialization=serialization,
    )

call_schema

call_schema(
    arguments: CoreSchema,
    function: Callable[..., Any],
    *,
    function_name: str | None = None,
    return_schema: CoreSchema | None = None,
    ref: str | None = None,
    metadata: dict[str, Any] | None = None,
    serialization: SerSchema | None = None
) -> CallSchema

返回一个匹配参数 schema，然后调用一个函数的 schema，例如

from pydantic_core import SchemaValidator, core_schema

param_a = core_schema.arguments_parameter(
    name='a', schema=core_schema.str_schema(), mode='positional_only'
)
param_b = core_schema.arguments_parameter(
    name='b', schema=core_schema.bool_schema(), mode='positional_only'
)
args_schema = core_schema.arguments_schema([param_a, param_b])

schema = core_schema.call_schema(
    arguments=args_schema,
    function=lambda a, b: a + str(not b),
    return_schema=core_schema.str_schema(),
)
v = SchemaValidator(schema)
assert v.validate_python((('hello', True))) == 'helloFalse'

参数

名称	类型	描述	默认值
arguments	CoreSchema	用于参数 schema 的参数	必需
function	Callable[..., Any]	用于调用 schema 的函数	必需
function_name	str | None	用于调用 schema 的函数名，如果未提供，则使用 function.__name__	None
return_schema	CoreSchema | None	用于调用 schema 的返回 schema	None
ref	str | None	schema 的可选唯一标识符，用于在其他地方引用该 schema	None
metadata	dict[str, Any] | None	您想包含在 schema 中的任何其他信息，pydantic-core 不使用	None
serialization	SerSchema | None	自定义序列化 schema	None

源代码位于 pydantic_core/core_schema.py

def call_schema(
    arguments: CoreSchema,
    function: Callable[..., Any],
    *,
    function_name: str | None = None,
    return_schema: CoreSchema | None = None,
    ref: str | None = None,
    metadata: dict[str, Any] | None = None,
    serialization: SerSchema | None = None,
) -> CallSchema:
    """
    Returns a schema that matches an arguments schema, then calls a function, e.g.:

    ```py
    from pydantic_core import SchemaValidator, core_schema

    param_a = core_schema.arguments_parameter(
        name='a', schema=core_schema.str_schema(), mode='positional_only'
    )
    param_b = core_schema.arguments_parameter(
        name='b', schema=core_schema.bool_schema(), mode='positional_only'
    )
    args_schema = core_schema.arguments_schema([param_a, param_b])

    schema = core_schema.call_schema(
        arguments=args_schema,
        function=lambda a, b: a + str(not b),
        return_schema=core_schema.str_schema(),
    )
    v = SchemaValidator(schema)
    assert v.validate_python((('hello', True))) == 'helloFalse'
    ```

    Args:
        arguments: The arguments to use for the arguments schema
        function: The function to use for the call schema
        function_name: The function name to use for the call schema, if not provided `function.__name__` is used
        return_schema: The return schema to use for the call schema
        ref: optional unique identifier of the schema, used to reference the schema in other places
        metadata: Any other information you want to include with the schema, not used by pydantic-core
        serialization: Custom serialization schema
    """
    return _dict_not_none(
        type='call',
        arguments_schema=arguments,
        function=function,
        function_name=function_name,
        return_schema=return_schema,
        ref=ref,
        metadata=metadata,
        serialization=serialization,
    )

custom_error_schema

custom_error_schema(
    schema: CoreSchema,
    custom_error_type: str,
    *,
    custom_error_message: str | None = None,
    custom_error_context: dict[str, Any] | None = None,
    ref: str | None = None,
    metadata: dict[str, Any] | None = None,
    serialization: SerSchema | None = None
) -> CustomErrorSchema

返回一个匹配自定义错误值的 schema，例如

from pydantic_core import SchemaValidator, core_schema

schema = core_schema.custom_error_schema(
    schema=core_schema.int_schema(),
    custom_error_type='MyError',
    custom_error_message='Error msg',
)
v = SchemaValidator(schema)
v.validate_python(1)

参数

名称	类型	描述	默认值
schema	CoreSchema	用于自定义错误 schema 的 schema	必需
custom_error_type	str	用于自定义错误 schema 的自定义错误类型	必需
custom_error_message	str | None	用于自定义错误 schema 的自定义错误消息	None
custom_error_context	dict[str, Any] | None	用于自定义错误 schema 的自定义错误上下文	None
ref	str | None	schema 的可选唯一标识符，用于在其他地方引用该 schema	None
metadata	dict[str, Any] | None	您想包含在 schema 中的任何其他信息，pydantic-core 不使用	None
serialization	SerSchema | None	自定义序列化 schema	None

源代码位于 pydantic_core/core_schema.py

def custom_error_schema(
    schema: CoreSchema,
    custom_error_type: str,
    *,
    custom_error_message: str | None = None,
    custom_error_context: dict[str, Any] | None = None,
    ref: str | None = None,
    metadata: dict[str, Any] | None = None,
    serialization: SerSchema | None = None,
) -> CustomErrorSchema:
    """
    Returns a schema that matches a custom error value, e.g.:

    ```py
    from pydantic_core import SchemaValidator, core_schema

    schema = core_schema.custom_error_schema(
        schema=core_schema.int_schema(),
        custom_error_type='MyError',
        custom_error_message='Error msg',
    )
    v = SchemaValidator(schema)
    v.validate_python(1)
    ```

    Args:
        schema: The schema to use for the custom error schema
        custom_error_type: The custom error type to use for the custom error schema
        custom_error_message: The custom error message to use for the custom error schema
        custom_error_context: The custom error context to use for the custom error schema
        ref: optional unique identifier of the schema, used to reference the schema in other places
        metadata: Any other information you want to include with the schema, not used by pydantic-core
        serialization: Custom serialization schema
    """
    return _dict_not_none(
        type='custom-error',
        schema=schema,
        custom_error_type=custom_error_type,
        custom_error_message=custom_error_message,
        custom_error_context=custom_error_context,
        ref=ref,
        metadata=metadata,
        serialization=serialization,
    )

json_schema

json_schema(
    schema: CoreSchema | None = None,
    *,
    ref: str | None = None,
    metadata: dict[str, Any] | None = None,
    serialization: SerSchema | None = None
) -> JsonSchema

返回一个匹配 JSON 值的 schema，例如

from pydantic_core import SchemaValidator, core_schema

dict_schema = core_schema.model_fields_schema(
    {
        'field_a': core_schema.model_field(core_schema.str_schema()),
        'field_b': core_schema.model_field(core_schema.bool_schema()),
    },
)

class MyModel:
    __slots__ = (
        '__dict__',
        '__pydantic_fields_set__',
        '__pydantic_extra__',
        '__pydantic_private__',
    )
    field_a: str
    field_b: bool

json_schema = core_schema.json_schema(schema=dict_schema)
schema = core_schema.model_schema(cls=MyModel, schema=json_schema)
v = SchemaValidator(schema)
m = v.validate_python('{"field_a": "hello", "field_b": true}')
assert isinstance(m, MyModel)

参数

名称	类型	描述	默认值
schema	CoreSchema | None	用于 JSON schema 的 schema	None
ref	str | None	schema 的可选唯一标识符，用于在其他地方引用该 schema	None
metadata	dict[str, Any] | None	您想包含在 schema 中的任何其他信息，pydantic-core 不使用	None
serialization	SerSchema | None	自定义序列化 schema	None

源代码位于 pydantic_core/core_schema.py

def json_schema(
    schema: CoreSchema | None = None,
    *,
    ref: str | None = None,
    metadata: dict[str, Any] | None = None,
    serialization: SerSchema | None = None,
) -> JsonSchema:
    """
    Returns a schema that matches a JSON value, e.g.:

    ```py
    from pydantic_core import SchemaValidator, core_schema

    dict_schema = core_schema.model_fields_schema(
        {
            'field_a': core_schema.model_field(core_schema.str_schema()),
            'field_b': core_schema.model_field(core_schema.bool_schema()),
        },
    )

    class MyModel:
        __slots__ = (
            '__dict__',
            '__pydantic_fields_set__',
            '__pydantic_extra__',
            '__pydantic_private__',
        )
        field_a: str
        field_b: bool

    json_schema = core_schema.json_schema(schema=dict_schema)
    schema = core_schema.model_schema(cls=MyModel, schema=json_schema)
    v = SchemaValidator(schema)
    m = v.validate_python('{"field_a": "hello", "field_b": true}')
    assert isinstance(m, MyModel)
    ```

    Args:
        schema: The schema to use for the JSON schema
        ref: optional unique identifier of the schema, used to reference the schema in other places
        metadata: Any other information you want to include with the schema, not used by pydantic-core
        serialization: Custom serialization schema
    """
    return _dict_not_none(type='json', schema=schema, ref=ref, metadata=metadata, serialization=serialization)

url_schema

url_schema(
    *,
    max_length: int | None = None,
    allowed_schemes: list[str] | None = None,
    host_required: bool | None = None,
    default_host: str | None = None,
    default_port: int | None = None,
    default_path: str | None = None,
    preserve_empty_path: bool | None = None,
    strict: bool | None = None,
    ref: str | None = None,
    metadata: dict[str, Any] | None = None,
    serialization: SerSchema | None = None
) -> UrlSchema

返回一个匹配 URL 值的 schema，例如

from pydantic_core import SchemaValidator, core_schema

schema = core_schema.url_schema()
v = SchemaValidator(schema)
print(v.validate_python('https://example.com'))
#> https://example.com/

参数

名称	类型	描述	默认值
max_length	int | None	URL 的最大长度	None
allowed_schemes	list[str] | None	允许的 URL 协议	None
host_required	bool | None	URL 是否必须有主机	None
default_host	str | None	如果 URL 没有主机，则使用的默认主机	None
default_port	int | None	如果 URL 没有端口，则使用的默认端口	None
default_path	str | None	如果 URL 没有路径，则使用的默认路径	None
preserve_empty_path	bool | None	是否保留空路径或将其转换为 '/'，默认为 False	None
strict	bool | None	是否使用严格的 URL 解析	None
ref	str | None	schema 的可选唯一标识符，用于在其他地方引用该 schema	None
metadata	dict[str, Any] | None	您想包含在 schema 中的任何其他信息，pydantic-core 不使用	None
serialization	SerSchema | None	自定义序列化 schema	None

源代码位于 pydantic_core/core_schema.py

def url_schema(
    *,
    max_length: int | None = None,
    allowed_schemes: list[str] | None = None,
    host_required: bool | None = None,
    default_host: str | None = None,
    default_port: int | None = None,
    default_path: str | None = None,
    preserve_empty_path: bool | None = None,
    strict: bool | None = None,
    ref: str | None = None,
    metadata: dict[str, Any] | None = None,
    serialization: SerSchema | None = None,
) -> UrlSchema:
    """
    Returns a schema that matches a URL value, e.g.:

    ```py
    from pydantic_core import SchemaValidator, core_schema

    schema = core_schema.url_schema()
    v = SchemaValidator(schema)
    print(v.validate_python('https://example.com'))
    #> https://example.com/
    ```

    Args:
        max_length: The maximum length of the URL
        allowed_schemes: The allowed URL schemes
        host_required: Whether the URL must have a host
        default_host: The default host to use if the URL does not have a host
        default_port: The default port to use if the URL does not have a port
        default_path: The default path to use if the URL does not have a path
        preserve_empty_path: Whether to preserve an empty path or convert it to '/', default False
        strict: Whether to use strict URL parsing
        ref: optional unique identifier of the schema, used to reference the schema in other places
        metadata: Any other information you want to include with the schema, not used by pydantic-core
        serialization: Custom serialization schema
    """
    return _dict_not_none(
        type='url',
        max_length=max_length,
        allowed_schemes=allowed_schemes,
        host_required=host_required,
        default_host=default_host,
        default_port=default_port,
        default_path=default_path,
        preserve_empty_path=preserve_empty_path,
        strict=strict,
        ref=ref,
        metadata=metadata,
        serialization=serialization,
    )

multi_host_url_schema

multi_host_url_schema(
    *,
    max_length: int | None = None,
    allowed_schemes: list[str] | None = None,
    host_required: bool | None = None,
    default_host: str | None = None,
    default_port: int | None = None,
    default_path: str | None = None,
    preserve_empty_path: bool | None = None,
    strict: bool | None = None,
    ref: str | None = None,
    metadata: dict[str, Any] | None = None,
    serialization: SerSchema | None = None
) -> MultiHostUrlSchema

返回一个匹配可能具有多个主机的 URL 值的 schema，例如

from pydantic_core import SchemaValidator, core_schema

schema = core_schema.multi_host_url_schema()
v = SchemaValidator(schema)
print(v.validate_python('redis://,0.0.0.0,127.0.0.1'))
#> redis://,0.0.0.0,127.0.0.1

参数

名称	类型	描述	默认值
max_length	int | None	URL 的最大长度	None
allowed_schemes	list[str] | None	允许的 URL 协议	None
host_required	bool | None	URL 是否必须有主机	None
default_host	str | None	如果 URL 没有主机，则使用的默认主机	None
default_port	int | None	如果 URL 没有端口，则使用的默认端口	None
default_path	str | None	如果 URL 没有路径，则使用的默认路径	None
preserve_empty_path	bool | None	是否保留空路径或将其转换为 '/'，默认为 False	None
strict	bool | None	是否使用严格的 URL 解析	None
ref	str | None	schema 的可选唯一标识符，用于在其他地方引用该 schema	None
metadata	dict[str, Any] | None	您想包含在 schema 中的任何其他信息，pydantic-core 不使用	None
serialization	SerSchema | None	自定义序列化 schema	None

源代码位于 pydantic_core/core_schema.py

def multi_host_url_schema(
    *,
    max_length: int | None = None,
    allowed_schemes: list[str] | None = None,
    host_required: bool | None = None,
    default_host: str | None = None,
    default_port: int | None = None,
    default_path: str | None = None,
    preserve_empty_path: bool | None = None,
    strict: bool | None = None,
    ref: str | None = None,
    metadata: dict[str, Any] | None = None,
    serialization: SerSchema | None = None,
) -> MultiHostUrlSchema:
    """
    Returns a schema that matches a URL value with possibly multiple hosts, e.g.:

    ```py
    from pydantic_core import SchemaValidator, core_schema

    schema = core_schema.multi_host_url_schema()
    v = SchemaValidator(schema)
    print(v.validate_python('redis://,0.0.0.0,127.0.0.1'))
    #> redis://,0.0.0.0,127.0.0.1
    ```

    Args:
        max_length: The maximum length of the URL
        allowed_schemes: The allowed URL schemes
        host_required: Whether the URL must have a host
        default_host: The default host to use if the URL does not have a host
        default_port: The default port to use if the URL does not have a port
        default_path: The default path to use if the URL does not have a path
        preserve_empty_path: Whether to preserve an empty path or convert it to '/', default False
        strict: Whether to use strict URL parsing
        ref: optional unique identifier of the schema, used to reference the schema in other places
        metadata: Any other information you want to include with the schema, not used by pydantic-core
        serialization: Custom serialization schema
    """
    return _dict_not_none(
        type='multi-host-url',
        max_length=max_length,
        allowed_schemes=allowed_schemes,
        host_required=host_required,
        default_host=default_host,
        default_port=default_port,
        default_path=default_path,
        preserve_empty_path=preserve_empty_path,
        strict=strict,
        ref=ref,
        metadata=metadata,
        serialization=serialization,
    )

definitions_schema

definitions_schema(
    schema: CoreSchema, definitions: list[CoreSchema]
) -> DefinitionsSchema

构建一个既包含内部 schema 又包含可在内部 schema 中使用的定义列表的 schema。

from pydantic_core import SchemaValidator, core_schema

schema = core_schema.definitions_schema(
    core_schema.list_schema(core_schema.definition_reference_schema('foobar')),
    [core_schema.int_schema(ref='foobar')],
)
v = SchemaValidator(schema)
assert v.validate_python([1, 2, '3']) == [1, 2, 3]

参数

名称	类型	描述	默认值
schema	CoreSchema	内部 schema	必需
definitions	list[CoreSchema]	可在内部 schema 中引用的定义列表	必需

源代码位于 pydantic_core/core_schema.py

def definitions_schema(schema: CoreSchema, definitions: list[CoreSchema]) -> DefinitionsSchema:
    """
    Build a schema that contains both an inner schema and a list of definitions which can be used
    within the inner schema.

    ```py
    from pydantic_core import SchemaValidator, core_schema

    schema = core_schema.definitions_schema(
        core_schema.list_schema(core_schema.definition_reference_schema('foobar')),
        [core_schema.int_schema(ref='foobar')],
    )
    v = SchemaValidator(schema)
    assert v.validate_python([1, 2, '3']) == [1, 2, 3]
    ```

    Args:
        schema: The inner schema
        definitions: List of definitions which can be referenced within inner schema
    """
    return DefinitionsSchema(type='definitions', schema=schema, definitions=definitions)

definition_reference_schema

definition_reference_schema(
    schema_ref: str,
    ref: str | None = None,
    metadata: dict[str, Any] | None = None,
    serialization: SerSchema | None = None,
) -> DefinitionReferenceSchema

返回一个指向存储在“definitions”中的 schema 的 schema，这对于嵌套递归模型以及当您想将验证器与主 schema 分开定义时非常有用，例如

from pydantic_core import SchemaValidator, core_schema

schema_definition = core_schema.definition_reference_schema('list-schema')
schema = core_schema.definitions_schema(
    schema=schema_definition,
    definitions=[
        core_schema.list_schema(items_schema=schema_definition, ref='list-schema'),
    ],
)
v = SchemaValidator(schema)
assert v.validate_python([()]) == [[]]

参数

名称	类型	描述	默认值
schema_ref	str	用于定义引用 schema 的 schema ref	必需
metadata	dict[str, Any] | None	您想包含在 schema 中的任何其他信息，pydantic-core 不使用	None
serialization	SerSchema | None	自定义序列化 schema	None

源代码位于 pydantic_core/core_schema.py

def definition_reference_schema(
    schema_ref: str,
    ref: str | None = None,
    metadata: dict[str, Any] | None = None,
    serialization: SerSchema | None = None,
) -> DefinitionReferenceSchema:
    """
    Returns a schema that points to a schema stored in "definitions", this is useful for nested recursive
    models and also when you want to define validators separately from the main schema, e.g.:

    ```py
    from pydantic_core import SchemaValidator, core_schema

    schema_definition = core_schema.definition_reference_schema('list-schema')
    schema = core_schema.definitions_schema(
        schema=schema_definition,
        definitions=[
            core_schema.list_schema(items_schema=schema_definition, ref='list-schema'),
        ],
    )
    v = SchemaValidator(schema)
    assert v.validate_python([()]) == [[]]
    ```

    Args:
        schema_ref: The schema ref to use for the definition reference schema
        metadata: Any other information you want to include with the schema, not used by pydantic-core
        serialization: Custom serialization schema
    """
    return _dict_not_none(
        type='definition-ref', schema_ref=schema_ref, ref=ref, metadata=metadata, serialization=serialization
    )